X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?p=sim%2Fe2-interface.git;a=blobdiff_plain;f=e2sim%2Fe2apv1sim%2Fe2sim%2Fsrc%2FASN1%2Fgenerated%2FX2AP-IEs.hpp;fp=e2sim%2Fe2apv1sim%2Fe2sim%2Fsrc%2FASN1%2Fgenerated%2FX2AP-IEs.hpp;h=f056563b3aaff6a35122a26b01223214f3254100;hp=0000000000000000000000000000000000000000;hb=3ebf932d23dcbec9ed19f4a51f9d00a0a54f5124;hpb=6896318f2b4ff01b4a88b16019c3dc93b0b693f5

diff --git a/e2sim/e2apv1sim/e2sim/src/ASN1/generated/X2AP-IEs.hpp b/e2sim/e2apv1sim/e2sim/src/ASN1/generated/X2AP-IEs.hpp
new file mode 100644
index 0000000..f056563
--- /dev/null
+++ b/e2sim/e2apv1sim/e2sim/src/ASN1/generated/X2AP-IEs.hpp
@@ -0,0 +1,35962 @@
+/*****************************************************************************
+# Copyright 2019 AT&T Intellectual Property                                  *
+#                                                                            *
+# Licensed under the Apache License, Version 2.0 (the "License");            *
+# you may not use this file except in compliance with the License.           *
+# You may obtain a copy of the License at                                    *
+#                                                                            *
+#      http://www.apache.org/licenses/LICENSE-2.0                            *
+#                                                                            *
+# Unless required by applicable law or agreed to in writing, software        *
+# distributed under the License is distributed on an "AS IS" BASIS,          *
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
+# See the License for the specific language governing permissions and        *
+# limitations under the License.                                             *
+#                                                                            *
+******************************************************************************/
+
+#pragma once
+
+#include "asn/asn.hpp"
+static_assert(ASN_API_VERSION_MAJOR == 5, "re-generate the ASN parser's code using 'make regen-asn' (do not use -j option)");
+
+#include "X2AP-Constants.hpp"
+#include "X2AP-CommonDataTypes.hpp"
+#include "X2AP-Containers.hpp"
+
+/*
+DL-ABS-status::= INTEGER (0..100)
+*/
+
+struct DL_ABS_status : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+	static constexpr const char* name() {return "DL-ABS-status";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+UsableABSInformationFDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct UsableABSInformationFDD_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+UsableABSInformationFDD ::= SEQUENCE {
+	usable-abs-pattern-info				BIT STRING (SIZE(40)),
+	iE-Extensions						ProtocolExtensionContainer { {UsableABSInformationFDD-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct UsableABSInformationFDD : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "UsableABSInformationFDD";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct usable_abs_pattern_info_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<40>>;
+		static constexpr const char* name() {return "usable_abs_pattern_info_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	usable_abs_pattern_info_t& ref_usable_abs_pattern_info() {return usable_abs_pattern_info;}
+	usable_abs_pattern_info_t const& ref_usable_abs_pattern_info() const {return usable_abs_pattern_info;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UsableABSInformationFDD_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UsableABSInformationFDD_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(usable_abs_pattern_info);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(usable_abs_pattern_info);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		usable_abs_pattern_info.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	usable_abs_pattern_info_t	usable_abs_pattern_info;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+UsableABSInformationTDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct UsableABSInformationTDD_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+UsableABSInformationTDD ::= SEQUENCE {
+	usaable-abs-pattern-info			BIT STRING (SIZE(1..70, ...)),
+	iE-Extensions						ProtocolExtensionContainer { {UsableABSInformationTDD-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct UsableABSInformationTDD : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "UsableABSInformationTDD";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct usaable_abs_pattern_info_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<1, 70>>;
+		static constexpr const char* name() {return "usaable_abs_pattern_info_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	usaable_abs_pattern_info_t& ref_usaable_abs_pattern_info() {return usaable_abs_pattern_info;}
+	usaable_abs_pattern_info_t const& ref_usaable_abs_pattern_info() const {return usaable_abs_pattern_info;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UsableABSInformationTDD_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UsableABSInformationTDD_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(usaable_abs_pattern_info);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(usaable_abs_pattern_info);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		usaable_abs_pattern_info.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	usaable_abs_pattern_info_t	usaable_abs_pattern_info;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+UsableABSInformation ::= CHOICE {
+	fdd					UsableABSInformationFDD,
+	tdd					UsableABSInformationTDD,
+	...
+}
+*/
+
+struct UsableABSInformation : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "UsableABSInformation";}
+	using parent_t = asn::choice<2, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 3;}
+	void set_unknown() { set_index(3);  }
+	~UsableABSInformation() {clear();}
+	struct fdd_t : UsableABSInformationFDD
+	{
+		static constexpr const char* name() {return "fdd_t";}
+		using parent_t = UsableABSInformationFDD;
+
+	};
+	struct tdd_t : UsableABSInformationTDD
+	{
+		static constexpr const char* name() {return "tdd_t";}
+		using parent_t = UsableABSInformationTDD;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<fdd_t>(); break;
+		case 2: var.destroy<tdd_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<fdd_t>());
+		case 2: set_index(2); return v(var.build<tdd_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<fdd_t>());
+		case 2: return v(var.as<tdd_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<fdd_t>(1);
+		v.template operator()<tdd_t>(2);
+
+	}
+	fdd_t& select_fdd() { if(get_index() != 1) { clear(); set_index(1); return var.build<fdd_t>();} return var.as<fdd_t>();}
+	fdd_t const* get_fdd() const { if(get_index() == 1) { return &var.as<fdd_t>();} return nullptr; }
+	tdd_t& select_tdd() { if(get_index() != 2) { clear(); set_index(2); return var.build<tdd_t>();} return var.as<tdd_t>();}
+	tdd_t const* get_tdd() const { if(get_index() == 2) { return &var.as<tdd_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(fdd_t)];
+		char dummy2[sizeof(tdd_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+ABS-Status-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ABS_Status_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ABS-Status ::= SEQUENCE {
+	dL-ABS-status								DL-ABS-status,
+	usableABSInformation						UsableABSInformation,
+	iE-Extensions								ProtocolExtensionContainer { {ABS-Status-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ABS_Status : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "ABS-Status";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct dL_ABS_status_t : DL_ABS_status
+	{
+		static constexpr const char* name() {return "dL_ABS_status_t";}
+		using parent_t = DL_ABS_status;
+
+	};
+	dL_ABS_status_t& ref_dL_ABS_status() {return dL_ABS_status;}
+	dL_ABS_status_t const& ref_dL_ABS_status() const {return dL_ABS_status;}
+	struct usableABSInformation_t : UsableABSInformation
+	{
+		static constexpr const char* name() {return "usableABSInformation_t";}
+		using parent_t = UsableABSInformation;
+
+	};
+	usableABSInformation_t& ref_usableABSInformation() {return usableABSInformation;}
+	usableABSInformation_t const& ref_usableABSInformation() const {return usableABSInformation;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ABS_Status_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ABS_Status_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(dL_ABS_status);
+		v(usableABSInformation);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(dL_ABS_status);
+		v(usableABSInformation);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		dL_ABS_status.clear();
+		usableABSInformation.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	dL_ABS_status_t	dL_ABS_status;
+	usableABSInformation_t	usableABSInformation;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ABSInformationFDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ABSInformationFDD_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ABSInformationFDD ::= SEQUENCE {
+	abs-pattern-info					BIT STRING (SIZE(40)),
+	numberOfCellSpecificAntennaPorts	ENUMERATED {one, two, four, ...},
+	measurement-subset					BIT STRING (SIZE(40)),
+	iE-Extensions						ProtocolExtensionContainer { {ABSInformationFDD-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ABSInformationFDD : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "ABSInformationFDD";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct abs_pattern_info_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<40>>;
+		static constexpr const char* name() {return "abs_pattern_info_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	abs_pattern_info_t& ref_abs_pattern_info() {return abs_pattern_info;}
+	abs_pattern_info_t const& ref_abs_pattern_info() const {return abs_pattern_info;}
+	struct numberOfCellSpecificAntennaPorts_t : asn::enumerated<3, 0, true>
+	{
+		static constexpr const char* name() {return "numberOfCellSpecificAntennaPorts_t";}
+		using parent_t = asn::enumerated<3, 0, true>;
+		typedef enum {
+			one
+			,two
+			,four
+		} index_t;
+
+	};
+
+	numberOfCellSpecificAntennaPorts_t& ref_numberOfCellSpecificAntennaPorts() {return numberOfCellSpecificAntennaPorts;}
+	numberOfCellSpecificAntennaPorts_t const& ref_numberOfCellSpecificAntennaPorts() const {return numberOfCellSpecificAntennaPorts;}
+	struct measurement_subset_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<40>>;
+		static constexpr const char* name() {return "measurement_subset_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	measurement_subset_t& ref_measurement_subset() {return measurement_subset;}
+	measurement_subset_t const& ref_measurement_subset() const {return measurement_subset;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ABSInformationFDD_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ABSInformationFDD_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(abs_pattern_info);
+		v(numberOfCellSpecificAntennaPorts);
+		v(measurement_subset);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(abs_pattern_info);
+		v(numberOfCellSpecificAntennaPorts);
+		v(measurement_subset);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		abs_pattern_info.clear();
+		numberOfCellSpecificAntennaPorts.clear();
+		measurement_subset.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	abs_pattern_info_t	abs_pattern_info;
+	numberOfCellSpecificAntennaPorts_t	numberOfCellSpecificAntennaPorts;
+	measurement_subset_t	measurement_subset;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ABSInformationTDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ABSInformationTDD_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ABSInformationTDD ::= SEQUENCE {
+	abs-pattern-info					BIT STRING (SIZE(1..70, ...)),
+	numberOfCellSpecificAntennaPorts	ENUMERATED {one, two, four, ...},
+	measurement-subset					BIT STRING (SIZE(1..70, ...)),
+	iE-Extensions						ProtocolExtensionContainer { {ABSInformationTDD-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ABSInformationTDD : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "ABSInformationTDD";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct abs_pattern_info_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<1, 70>>;
+		static constexpr const char* name() {return "abs_pattern_info_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	abs_pattern_info_t& ref_abs_pattern_info() {return abs_pattern_info;}
+	abs_pattern_info_t const& ref_abs_pattern_info() const {return abs_pattern_info;}
+	struct numberOfCellSpecificAntennaPorts_t : asn::enumerated<3, 0, true>
+	{
+		static constexpr const char* name() {return "numberOfCellSpecificAntennaPorts_t";}
+		using parent_t = asn::enumerated<3, 0, true>;
+		typedef enum {
+			one
+			,two
+			,four
+		} index_t;
+
+	};
+
+	numberOfCellSpecificAntennaPorts_t& ref_numberOfCellSpecificAntennaPorts() {return numberOfCellSpecificAntennaPorts;}
+	numberOfCellSpecificAntennaPorts_t const& ref_numberOfCellSpecificAntennaPorts() const {return numberOfCellSpecificAntennaPorts;}
+	struct measurement_subset_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<1, 70>>;
+		static constexpr const char* name() {return "measurement_subset_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	measurement_subset_t& ref_measurement_subset() {return measurement_subset;}
+	measurement_subset_t const& ref_measurement_subset() const {return measurement_subset;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ABSInformationTDD_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ABSInformationTDD_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(abs_pattern_info);
+		v(numberOfCellSpecificAntennaPorts);
+		v(measurement_subset);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(abs_pattern_info);
+		v(numberOfCellSpecificAntennaPorts);
+		v(measurement_subset);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		abs_pattern_info.clear();
+		numberOfCellSpecificAntennaPorts.clear();
+		measurement_subset.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	abs_pattern_info_t	abs_pattern_info;
+	numberOfCellSpecificAntennaPorts_t	numberOfCellSpecificAntennaPorts;
+	measurement_subset_t	measurement_subset;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ABSInformation ::= CHOICE {
+	fdd					ABSInformationFDD,
+	tdd					ABSInformationTDD,
+	abs-inactive		NULL,
+	...
+}
+*/
+
+struct ABSInformation : asn::choice<3, 0, true>
+{
+	static constexpr const char* name() {return "ABSInformation";}
+	using parent_t = asn::choice<3, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 4;}
+	void set_unknown() { set_index(4);  }
+	~ABSInformation() {clear();}
+	struct fdd_t : ABSInformationFDD
+	{
+		static constexpr const char* name() {return "fdd_t";}
+		using parent_t = ABSInformationFDD;
+
+	};
+	struct tdd_t : ABSInformationTDD
+	{
+		static constexpr const char* name() {return "tdd_t";}
+		using parent_t = ABSInformationTDD;
+
+	};
+	struct abs_inactive_t : asn::nulltype
+	{
+		static constexpr const char* name() {return "abs_inactive_t";}
+		using parent_t = asn::nulltype;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<fdd_t>(); break;
+		case 2: var.destroy<tdd_t>(); break;
+		case 3: var.destroy<abs_inactive_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<fdd_t>());
+		case 2: set_index(2); return v(var.build<tdd_t>());
+		case 3: set_index(3); return v(var.build<abs_inactive_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<fdd_t>());
+		case 2: return v(var.as<tdd_t>());
+		case 3: return v(var.as<abs_inactive_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<fdd_t>(1);
+		v.template operator()<tdd_t>(2);
+		v.template operator()<abs_inactive_t>(3);
+
+	}
+	fdd_t& select_fdd() { if(get_index() != 1) { clear(); set_index(1); return var.build<fdd_t>();} return var.as<fdd_t>();}
+	fdd_t const* get_fdd() const { if(get_index() == 1) { return &var.as<fdd_t>();} return nullptr; }
+	tdd_t& select_tdd() { if(get_index() != 2) { clear(); set_index(2); return var.build<tdd_t>();} return var.as<tdd_t>();}
+	tdd_t const* get_tdd() const { if(get_index() == 2) { return &var.as<tdd_t>();} return nullptr; }
+	abs_inactive_t& select_abs_inactive() { if(get_index() != 3) { clear(); set_index(3); return var.build<abs_inactive_t>();} return var.as<abs_inactive_t>();}
+	abs_inactive_t const* get_abs_inactive() const { if(get_index() == 3) { return &var.as<abs_inactive_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(fdd_t)];
+		char dummy2[sizeof(tdd_t)];
+		char dummy3[sizeof(abs_inactive_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+Key-eNodeB-Star ::= BIT STRING (SIZE(256))
+*/
+
+struct Key_eNodeB_Star : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<256>>;
+	static constexpr const char* name() {return "Key-eNodeB-Star";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+NextHopChainingCount ::= INTEGER (0..7)
+*/
+
+struct NextHopChainingCount : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 7>>;
+	static constexpr const char* name() {return "NextHopChainingCount";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+AS-SecurityInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct AS_SecurityInformation_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+AS-SecurityInformation ::= SEQUENCE {
+	key-eNodeB-star		Key-eNodeB-Star,
+	nextHopChainingCount			NextHopChainingCount,
+	iE-Extensions						ProtocolExtensionContainer { {AS-SecurityInformation-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct AS_SecurityInformation : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "AS-SecurityInformation";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct key_eNodeB_star_t : Key_eNodeB_Star
+	{
+		static constexpr const char* name() {return "key_eNodeB_star_t";}
+		using parent_t = Key_eNodeB_Star;
+
+	};
+	key_eNodeB_star_t& ref_key_eNodeB_star() {return key_eNodeB_star;}
+	key_eNodeB_star_t const& ref_key_eNodeB_star() const {return key_eNodeB_star;}
+	struct nextHopChainingCount_t : NextHopChainingCount
+	{
+		static constexpr const char* name() {return "nextHopChainingCount_t";}
+		using parent_t = NextHopChainingCount;
+
+	};
+	nextHopChainingCount_t& ref_nextHopChainingCount() {return nextHopChainingCount;}
+	nextHopChainingCount_t const& ref_nextHopChainingCount() const {return nextHopChainingCount;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<AS_SecurityInformation_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<AS_SecurityInformation_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(key_eNodeB_star);
+		v(nextHopChainingCount);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(key_eNodeB_star);
+		v(nextHopChainingCount);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		key_eNodeB_star.clear();
+		nextHopChainingCount.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	key_eNodeB_star_t	key_eNodeB_star;
+	nextHopChainingCount_t	nextHopChainingCount;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ActivationID ::= INTEGER (0..255)
+*/
+
+struct ActivationID : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 255>>;
+	static constexpr const char* name() {return "ActivationID";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+AdditionalSpecialSubframePatterns ::= ENUMERATED {
+	ssp0,
+	ssp1,
+	ssp2,
+	ssp3,
+	ssp4,
+	ssp5,
+	ssp6,
+	ssp7,
+	ssp8,
+	ssp9,
+	...
+}
+*/
+
+struct AdditionalSpecialSubframePatterns : asn::enumerated<10, 0, true>
+{
+	static constexpr const char* name() {return "AdditionalSpecialSubframePatterns";}
+	using parent_t = asn::enumerated<10, 0, true>;
+	typedef enum {
+		ssp0
+		,ssp1
+		,ssp2
+		,ssp3
+		,ssp4
+		,ssp5
+		,ssp6
+		,ssp7
+		,ssp8
+		,ssp9
+	} index_t;
+
+};
+
+/*
+CyclicPrefixDL ::= ENUMERATED {
+	normal,
+	extended,
+	...
+}
+*/
+
+struct CyclicPrefixDL : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "CyclicPrefixDL";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		normal
+		,extended
+	} index_t;
+
+};
+
+/*
+CyclicPrefixUL ::= ENUMERATED {
+	normal,
+	extended,
+	...
+}
+*/
+
+struct CyclicPrefixUL : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "CyclicPrefixUL";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		normal
+		,extended
+	} index_t;
+
+};
+
+/*
+AdditionalSpecialSubframe-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct AdditionalSpecialSubframe_Info_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+AdditionalSpecialSubframe-Info ::=		SEQUENCE {
+	additionalspecialSubframePatterns		AdditionalSpecialSubframePatterns,
+	cyclicPrefixDL							CyclicPrefixDL,
+	cyclicPrefixUL							CyclicPrefixUL,
+	iE-Extensions							ProtocolExtensionContainer { {AdditionalSpecialSubframe-Info-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct AdditionalSpecialSubframe_Info : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "AdditionalSpecialSubframe-Info";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct additionalspecialSubframePatterns_t : AdditionalSpecialSubframePatterns
+	{
+		static constexpr const char* name() {return "additionalspecialSubframePatterns_t";}
+		using parent_t = AdditionalSpecialSubframePatterns;
+
+	};
+	additionalspecialSubframePatterns_t& ref_additionalspecialSubframePatterns() {return additionalspecialSubframePatterns;}
+	additionalspecialSubframePatterns_t const& ref_additionalspecialSubframePatterns() const {return additionalspecialSubframePatterns;}
+	struct cyclicPrefixDL_t : CyclicPrefixDL
+	{
+		static constexpr const char* name() {return "cyclicPrefixDL_t";}
+		using parent_t = CyclicPrefixDL;
+
+	};
+	cyclicPrefixDL_t& ref_cyclicPrefixDL() {return cyclicPrefixDL;}
+	cyclicPrefixDL_t const& ref_cyclicPrefixDL() const {return cyclicPrefixDL;}
+	struct cyclicPrefixUL_t : CyclicPrefixUL
+	{
+		static constexpr const char* name() {return "cyclicPrefixUL_t";}
+		using parent_t = CyclicPrefixUL;
+
+	};
+	cyclicPrefixUL_t& ref_cyclicPrefixUL() {return cyclicPrefixUL;}
+	cyclicPrefixUL_t const& ref_cyclicPrefixUL() const {return cyclicPrefixUL;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<AdditionalSpecialSubframe_Info_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<AdditionalSpecialSubframe_Info_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(additionalspecialSubframePatterns);
+		v(cyclicPrefixDL);
+		v(cyclicPrefixUL);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(additionalspecialSubframePatterns);
+		v(cyclicPrefixDL);
+		v(cyclicPrefixUL);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		additionalspecialSubframePatterns.clear();
+		cyclicPrefixDL.clear();
+		cyclicPrefixUL.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	additionalspecialSubframePatterns_t	additionalspecialSubframePatterns;
+	cyclicPrefixDL_t	cyclicPrefixDL;
+	cyclicPrefixUL_t	cyclicPrefixUL;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+AdditionalSpecialSubframePatternsExtension ::= ENUMERATED {
+	ssp10,
+	...
+}
+*/
+
+struct AdditionalSpecialSubframePatternsExtension : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "AdditionalSpecialSubframePatternsExtension";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		ssp10
+	} index_t;
+
+};
+
+/*
+AdditionalSpecialSubframeExtension-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct AdditionalSpecialSubframeExtension_Info_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+AdditionalSpecialSubframeExtension-Info ::=		SEQUENCE {
+	additionalspecialSubframePatternsExtension	AdditionalSpecialSubframePatternsExtension,
+	cyclicPrefixDL								CyclicPrefixDL,
+	cyclicPrefixUL								CyclicPrefixUL,
+	iE-Extensions								ProtocolExtensionContainer { {AdditionalSpecialSubframeExtension-Info-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct AdditionalSpecialSubframeExtension_Info : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "AdditionalSpecialSubframeExtension-Info";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct additionalspecialSubframePatternsExtension_t : AdditionalSpecialSubframePatternsExtension
+	{
+		static constexpr const char* name() {return "additionalspecialSubframePatternsExtension_t";}
+		using parent_t = AdditionalSpecialSubframePatternsExtension;
+
+	};
+	additionalspecialSubframePatternsExtension_t& ref_additionalspecialSubframePatternsExtension() {return additionalspecialSubframePatternsExtension;}
+	additionalspecialSubframePatternsExtension_t const& ref_additionalspecialSubframePatternsExtension() const {return additionalspecialSubframePatternsExtension;}
+	struct cyclicPrefixDL_t : CyclicPrefixDL
+	{
+		static constexpr const char* name() {return "cyclicPrefixDL_t";}
+		using parent_t = CyclicPrefixDL;
+
+	};
+	cyclicPrefixDL_t& ref_cyclicPrefixDL() {return cyclicPrefixDL;}
+	cyclicPrefixDL_t const& ref_cyclicPrefixDL() const {return cyclicPrefixDL;}
+	struct cyclicPrefixUL_t : CyclicPrefixUL
+	{
+		static constexpr const char* name() {return "cyclicPrefixUL_t";}
+		using parent_t = CyclicPrefixUL;
+
+	};
+	cyclicPrefixUL_t& ref_cyclicPrefixUL() {return cyclicPrefixUL;}
+	cyclicPrefixUL_t const& ref_cyclicPrefixUL() const {return cyclicPrefixUL;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<AdditionalSpecialSubframeExtension_Info_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<AdditionalSpecialSubframeExtension_Info_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(additionalspecialSubframePatternsExtension);
+		v(cyclicPrefixDL);
+		v(cyclicPrefixUL);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(additionalspecialSubframePatternsExtension);
+		v(cyclicPrefixDL);
+		v(cyclicPrefixUL);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		additionalspecialSubframePatternsExtension.clear();
+		cyclicPrefixDL.clear();
+		cyclicPrefixUL.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	additionalspecialSubframePatternsExtension_t	additionalspecialSubframePatternsExtension;
+	cyclicPrefixDL_t	cyclicPrefixDL;
+	cyclicPrefixUL_t	cyclicPrefixUL;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+AerialUEsubscriptionInformation ::= ENUMERATED {
+	allowed,
+	not-allowed,
+	...
+}
+*/
+
+struct AerialUEsubscriptionInformation : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "AerialUEsubscriptionInformation";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		allowed
+		,not_allowed
+	} index_t;
+
+};
+
+/*
+PriorityLevel				::= INTEGER { spare (0), highest (1), lowest (14), no-priority (15) } (0..15)
+*/
+
+struct PriorityLevel : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 15>>;
+	static constexpr const char* name() {return "PriorityLevel";}
+	using parent_t = asn::integer<>;
+	enum {spare = 0, highest = 1, lowest = 14, no_priority = 15};
+
+};
+
+/*
+Pre-emptionCapability ::= ENUMERATED {
+	shall-not-trigger-pre-emption,
+	may-trigger-pre-emption
+}
+*/
+
+struct Pre_emptionCapability : asn::enumerated<2, 0, false>
+{
+	static constexpr const char* name() {return "Pre-emptionCapability";}
+	using parent_t = asn::enumerated<2, 0, false>;
+	typedef enum {
+		shall_not_trigger_pre_emption
+		,may_trigger_pre_emption
+	} index_t;
+
+};
+
+/*
+Pre-emptionVulnerability ::= ENUMERATED {
+	not-pre-emptable,
+	pre-emptable
+}
+*/
+
+struct Pre_emptionVulnerability : asn::enumerated<2, 0, false>
+{
+	static constexpr const char* name() {return "Pre-emptionVulnerability";}
+	using parent_t = asn::enumerated<2, 0, false>;
+	typedef enum {
+		not_pre_emptable
+		,pre_emptable
+	} index_t;
+
+};
+
+/*
+AllocationAndRetentionPriority-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct AllocationAndRetentionPriority_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+AllocationAndRetentionPriority ::= SEQUENCE {
+	priorityLevel				PriorityLevel,
+	pre-emptionCapability		Pre-emptionCapability,
+	pre-emptionVulnerability	Pre-emptionVulnerability,
+	iE-Extensions				ProtocolExtensionContainer { {AllocationAndRetentionPriority-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct AllocationAndRetentionPriority : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "AllocationAndRetentionPriority";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct priorityLevel_t : PriorityLevel
+	{
+		static constexpr const char* name() {return "priorityLevel_t";}
+		using parent_t = PriorityLevel;
+
+	};
+	priorityLevel_t& ref_priorityLevel() {return priorityLevel;}
+	priorityLevel_t const& ref_priorityLevel() const {return priorityLevel;}
+	struct pre_emptionCapability_t : Pre_emptionCapability
+	{
+		static constexpr const char* name() {return "pre_emptionCapability_t";}
+		using parent_t = Pre_emptionCapability;
+
+	};
+	pre_emptionCapability_t& ref_pre_emptionCapability() {return pre_emptionCapability;}
+	pre_emptionCapability_t const& ref_pre_emptionCapability() const {return pre_emptionCapability;}
+	struct pre_emptionVulnerability_t : Pre_emptionVulnerability
+	{
+		static constexpr const char* name() {return "pre_emptionVulnerability_t";}
+		using parent_t = Pre_emptionVulnerability;
+
+	};
+	pre_emptionVulnerability_t& ref_pre_emptionVulnerability() {return pre_emptionVulnerability;}
+	pre_emptionVulnerability_t const& ref_pre_emptionVulnerability() const {return pre_emptionVulnerability;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<AllocationAndRetentionPriority_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<AllocationAndRetentionPriority_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(priorityLevel);
+		v(pre_emptionCapability);
+		v(pre_emptionVulnerability);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(priorityLevel);
+		v(pre_emptionCapability);
+		v(pre_emptionVulnerability);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		priorityLevel.clear();
+		pre_emptionCapability.clear();
+		pre_emptionVulnerability.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	priorityLevel_t	priorityLevel;
+	pre_emptionCapability_t	pre_emptionCapability;
+	pre_emptionVulnerability_t	pre_emptionVulnerability;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+PLMN-Identity ::= OCTET STRING (SIZE(3))
+*/
+
+struct PLMN_Identity : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<3>>;
+	static constexpr const char* name() {return "PLMN-Identity";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+EUTRANCellIdentifier ::= BIT STRING (SIZE (28))
+*/
+
+struct EUTRANCellIdentifier : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<28>>;
+	static constexpr const char* name() {return "EUTRANCellIdentifier";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+ECGI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ECGI_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ECGI ::= SEQUENCE {
+	pLMN-Identity				PLMN-Identity,
+	eUTRANcellIdentifier		EUTRANCellIdentifier,
+	iE-Extensions				ProtocolExtensionContainer { {ECGI-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ECGI : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "ECGI";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct pLMN_Identity_t : PLMN_Identity
+	{
+		static constexpr const char* name() {return "pLMN_Identity_t";}
+		using parent_t = PLMN_Identity;
+
+	};
+	pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+	pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+	struct eUTRANcellIdentifier_t : EUTRANCellIdentifier
+	{
+		static constexpr const char* name() {return "eUTRANcellIdentifier_t";}
+		using parent_t = EUTRANCellIdentifier;
+
+	};
+	eUTRANcellIdentifier_t& ref_eUTRANcellIdentifier() {return eUTRANcellIdentifier;}
+	eUTRANcellIdentifier_t const& ref_eUTRANcellIdentifier() const {return eUTRANcellIdentifier;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ECGI_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ECGI_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(pLMN_Identity);
+		v(eUTRANcellIdentifier);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(pLMN_Identity);
+		v(eUTRANcellIdentifier);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		pLMN_Identity.clear();
+		eUTRANcellIdentifier.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	pLMN_Identity_t	pLMN_Identity;
+	eUTRANcellIdentifier_t	eUTRANcellIdentifier;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+CellIdListforMDT ::= SEQUENCE (SIZE(1..maxnoofCellIDforMDT)) OF ECGI
+*/
+
+struct CellIdListforMDT_elm : ECGI
+{
+	static constexpr const char* name() {return "CellIdListforMDT_elm";}
+	using parent_t = ECGI;
+
+};
+struct CellIdListforMDT : asn::sequenceof<CellIdListforMDT_elm>
+{
+	static constexpr const char* name() {return "CellIdListforMDT";}
+	using parent_t = asn::sequenceof<CellIdListforMDT_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofCellIDforMDT >>;
+
+};
+/*
+CellBasedMDT-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CellBasedMDT_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CellBasedMDT::= SEQUENCE {
+	cellIdListforMDT	CellIdListforMDT,
+	iE-Extensions		ProtocolExtensionContainer { {CellBasedMDT-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct CellBasedMDT : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "CellBasedMDT";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct cellIdListforMDT_t : CellIdListforMDT
+	{
+		static constexpr const char* name() {return "cellIdListforMDT_t";}
+		using parent_t = CellIdListforMDT;
+
+	};
+	cellIdListforMDT_t& ref_cellIdListforMDT() {return cellIdListforMDT;}
+	cellIdListforMDT_t const& ref_cellIdListforMDT() const {return cellIdListforMDT;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CellBasedMDT_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CellBasedMDT_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(cellIdListforMDT);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(cellIdListforMDT);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		cellIdListforMDT.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	cellIdListforMDT_t	cellIdListforMDT;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+TAC ::= OCTET STRING (SIZE (2))
+*/
+
+struct TAC : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<2>>;
+	static constexpr const char* name() {return "TAC";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+TAListforMDT ::= SEQUENCE (SIZE(1..maxnoofTAforMDT)) OF TAC
+*/
+
+struct TAListforMDT_elm : TAC
+{
+	static constexpr const char* name() {return "TAListforMDT_elm";}
+	using parent_t = TAC;
+
+};
+struct TAListforMDT : asn::sequenceof<TAListforMDT_elm>
+{
+	static constexpr const char* name() {return "TAListforMDT";}
+	using parent_t = asn::sequenceof<TAListforMDT_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofTAforMDT >>;
+
+};
+/*
+TABasedMDT-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct TABasedMDT_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+TABasedMDT::= SEQUENCE {
+	tAListforMDT		TAListforMDT,
+	iE-Extensions		ProtocolExtensionContainer { {TABasedMDT-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct TABasedMDT : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "TABasedMDT";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct tAListforMDT_t : TAListforMDT
+	{
+		static constexpr const char* name() {return "tAListforMDT_t";}
+		using parent_t = TAListforMDT;
+
+	};
+	tAListforMDT_t& ref_tAListforMDT() {return tAListforMDT;}
+	tAListforMDT_t const& ref_tAListforMDT() const {return tAListforMDT;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<TABasedMDT_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<TABasedMDT_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(tAListforMDT);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(tAListforMDT);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		tAListforMDT.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	tAListforMDT_t	tAListforMDT;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+TAI-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct TAI_Item_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+TAI-Item ::= SEQUENCE {
+	tAC					TAC,
+	pLMN-Identity		PLMN-Identity,
+	iE-Extensions		ProtocolExtensionContainer { {TAI-Item-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct TAI_Item : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "TAI-Item";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct tAC_t : TAC
+	{
+		static constexpr const char* name() {return "tAC_t";}
+		using parent_t = TAC;
+
+	};
+	tAC_t& ref_tAC() {return tAC;}
+	tAC_t const& ref_tAC() const {return tAC;}
+	struct pLMN_Identity_t : PLMN_Identity
+	{
+		static constexpr const char* name() {return "pLMN_Identity_t";}
+		using parent_t = PLMN_Identity;
+
+	};
+	pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+	pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<TAI_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<TAI_Item_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(tAC);
+		v(pLMN_Identity);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(tAC);
+		v(pLMN_Identity);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		tAC.clear();
+		pLMN_Identity.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	tAC_t	tAC;
+	pLMN_Identity_t	pLMN_Identity;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+TAIListforMDT ::= SEQUENCE (SIZE(1..maxnoofTAforMDT)) OF TAI-Item
+*/
+
+struct TAIListforMDT_elm : TAI_Item
+{
+	static constexpr const char* name() {return "TAIListforMDT_elm";}
+	using parent_t = TAI_Item;
+
+};
+struct TAIListforMDT : asn::sequenceof<TAIListforMDT_elm>
+{
+	static constexpr const char* name() {return "TAIListforMDT";}
+	using parent_t = asn::sequenceof<TAIListforMDT_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofTAforMDT >>;
+
+};
+/*
+TAIBasedMDT-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct TAIBasedMDT_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+TAIBasedMDT ::= SEQUENCE {
+	tAIListforMDT			TAIListforMDT,
+	iE-Extensions			ProtocolExtensionContainer { {TAIBasedMDT-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct TAIBasedMDT : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "TAIBasedMDT";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct tAIListforMDT_t : TAIListforMDT
+	{
+		static constexpr const char* name() {return "tAIListforMDT_t";}
+		using parent_t = TAIListforMDT;
+
+	};
+	tAIListforMDT_t& ref_tAIListforMDT() {return tAIListforMDT;}
+	tAIListforMDT_t const& ref_tAIListforMDT() const {return tAIListforMDT;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<TAIBasedMDT_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<TAIBasedMDT_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(tAIListforMDT);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(tAIListforMDT);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		tAIListforMDT.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	tAIListforMDT_t	tAIListforMDT;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+AreaScopeOfMDT ::= CHOICE {
+	cellBased					CellBasedMDT,
+	tABased						TABasedMDT,
+	pLMNWide					NULL,
+	...,
+	tAIBased					TAIBasedMDT
+}
+*/
+
+struct AreaScopeOfMDT : asn::choice<4, 1, true>
+{
+	static constexpr const char* name() {return "AreaScopeOfMDT";}
+	using parent_t = asn::choice<4, 1, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 5;}
+	void set_unknown() { set_index(5);  }
+	~AreaScopeOfMDT() {clear();}
+	struct cellBased_t : CellBasedMDT
+	{
+		static constexpr const char* name() {return "cellBased_t";}
+		using parent_t = CellBasedMDT;
+
+	};
+	struct tABased_t : TABasedMDT
+	{
+		static constexpr const char* name() {return "tABased_t";}
+		using parent_t = TABasedMDT;
+
+	};
+	struct pLMNWide_t : asn::nulltype
+	{
+		static constexpr const char* name() {return "pLMNWide_t";}
+		using parent_t = asn::nulltype;
+
+	};
+	struct tAIBased_t : TAIBasedMDT
+	{
+		static constexpr const char* name() {return "tAIBased_t";}
+		using parent_t = TAIBasedMDT;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<cellBased_t>(); break;
+		case 2: var.destroy<tABased_t>(); break;
+		case 3: var.destroy<pLMNWide_t>(); break;
+		case 4: var.destroy<tAIBased_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<cellBased_t>());
+		case 2: set_index(2); return v(var.build<tABased_t>());
+		case 3: set_index(3); return v(var.build<pLMNWide_t>());
+		case 4: set_index(4); return v(var.build<tAIBased_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<cellBased_t>());
+		case 2: return v(var.as<tABased_t>());
+		case 3: return v(var.as<pLMNWide_t>());
+		case 4: return v(var.as<tAIBased_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<cellBased_t>(1);
+		v.template operator()<tABased_t>(2);
+		v.template operator()<pLMNWide_t>(3);
+		v.template operator()<tAIBased_t>(4);
+
+	}
+	cellBased_t& select_cellBased() { if(get_index() != 1) { clear(); set_index(1); return var.build<cellBased_t>();} return var.as<cellBased_t>();}
+	cellBased_t const* get_cellBased() const { if(get_index() == 1) { return &var.as<cellBased_t>();} return nullptr; }
+	tABased_t& select_tABased() { if(get_index() != 2) { clear(); set_index(2); return var.build<tABased_t>();} return var.as<tABased_t>();}
+	tABased_t const* get_tABased() const { if(get_index() == 2) { return &var.as<tABased_t>();} return nullptr; }
+	pLMNWide_t& select_pLMNWide() { if(get_index() != 3) { clear(); set_index(3); return var.build<pLMNWide_t>();} return var.as<pLMNWide_t>();}
+	pLMNWide_t const* get_pLMNWide() const { if(get_index() == 3) { return &var.as<pLMNWide_t>();} return nullptr; }
+	tAIBased_t& select_tAIBased() { if(get_index() != 4) { clear(); set_index(4); return var.build<tAIBased_t>();} return var.as<tAIBased_t>();}
+	tAIBased_t const* get_tAIBased() const { if(get_index() == 4) { return &var.as<tAIBased_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(cellBased_t)];
+		char dummy2[sizeof(tABased_t)];
+		char dummy3[sizeof(pLMNWide_t)];
+		char dummy4[sizeof(tAIBased_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+CellIdListforQMC ::= SEQUENCE (SIZE(1..maxnoofCellIDforQMC)) OF ECGI
+*/
+
+struct CellIdListforQMC_elm : ECGI
+{
+	static constexpr const char* name() {return "CellIdListforQMC_elm";}
+	using parent_t = ECGI;
+
+};
+struct CellIdListforQMC : asn::sequenceof<CellIdListforQMC_elm>
+{
+	static constexpr const char* name() {return "CellIdListforQMC";}
+	using parent_t = asn::sequenceof<CellIdListforQMC_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofCellIDforQMC >>;
+
+};
+/*
+CellBasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CellBasedQMC_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CellBasedQMC::= SEQUENCE {
+	cellIdListforQMC		CellIdListforQMC,
+	iE-Extensions		ProtocolExtensionContainer { {CellBasedQMC-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct CellBasedQMC : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "CellBasedQMC";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct cellIdListforQMC_t : CellIdListforQMC
+	{
+		static constexpr const char* name() {return "cellIdListforQMC_t";}
+		using parent_t = CellIdListforQMC;
+
+	};
+	cellIdListforQMC_t& ref_cellIdListforQMC() {return cellIdListforQMC;}
+	cellIdListforQMC_t const& ref_cellIdListforQMC() const {return cellIdListforQMC;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CellBasedQMC_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CellBasedQMC_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(cellIdListforQMC);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(cellIdListforQMC);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		cellIdListforQMC.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	cellIdListforQMC_t	cellIdListforQMC;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+TAListforQMC ::= SEQUENCE (SIZE(1..maxnoofTAforQMC)) OF TAC
+*/
+
+struct TAListforQMC_elm : TAC
+{
+	static constexpr const char* name() {return "TAListforQMC_elm";}
+	using parent_t = TAC;
+
+};
+struct TAListforQMC : asn::sequenceof<TAListforQMC_elm>
+{
+	static constexpr const char* name() {return "TAListforQMC";}
+	using parent_t = asn::sequenceof<TAListforQMC_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofTAforQMC >>;
+
+};
+/*
+TABasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct TABasedQMC_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+TABasedQMC ::= SEQUENCE {
+	tAListforQMC		TAListforQMC,
+	iE-Extensions		ProtocolExtensionContainer { {TABasedQMC-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct TABasedQMC : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "TABasedQMC";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct tAListforQMC_t : TAListforQMC
+	{
+		static constexpr const char* name() {return "tAListforQMC_t";}
+		using parent_t = TAListforQMC;
+
+	};
+	tAListforQMC_t& ref_tAListforQMC() {return tAListforQMC;}
+	tAListforQMC_t const& ref_tAListforQMC() const {return tAListforQMC;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<TABasedQMC_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<TABasedQMC_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(tAListforQMC);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(tAListforQMC);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		tAListforQMC.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	tAListforQMC_t	tAListforQMC;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+TAIListforQMC ::= SEQUENCE (SIZE(1..maxnoofTAforQMC)) OF TAI-Item
+*/
+
+struct TAIListforQMC_elm : TAI_Item
+{
+	static constexpr const char* name() {return "TAIListforQMC_elm";}
+	using parent_t = TAI_Item;
+
+};
+struct TAIListforQMC : asn::sequenceof<TAIListforQMC_elm>
+{
+	static constexpr const char* name() {return "TAIListforQMC";}
+	using parent_t = asn::sequenceof<TAIListforQMC_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofTAforQMC >>;
+
+};
+/*
+TAIBasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct TAIBasedQMC_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+TAIBasedQMC ::= SEQUENCE {
+	tAIListforQMC		TAIListforQMC,
+	iE-Extensions		ProtocolExtensionContainer { {TAIBasedQMC-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct TAIBasedQMC : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "TAIBasedQMC";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct tAIListforQMC_t : TAIListforQMC
+	{
+		static constexpr const char* name() {return "tAIListforQMC_t";}
+		using parent_t = TAIListforQMC;
+
+	};
+	tAIListforQMC_t& ref_tAIListforQMC() {return tAIListforQMC;}
+	tAIListforQMC_t const& ref_tAIListforQMC() const {return tAIListforQMC;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<TAIBasedQMC_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<TAIBasedQMC_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(tAIListforQMC);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(tAIListforQMC);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		tAIListforQMC.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	tAIListforQMC_t	tAIListforQMC;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+PLMNListforQMC ::= SEQUENCE (SIZE(1..maxnoofPLMNforQMC)) OF PLMN-Identity
+*/
+
+struct PLMNListforQMC_elm : PLMN_Identity
+{
+	static constexpr const char* name() {return "PLMNListforQMC_elm";}
+	using parent_t = PLMN_Identity;
+
+};
+struct PLMNListforQMC : asn::sequenceof<PLMNListforQMC_elm>
+{
+	static constexpr const char* name() {return "PLMNListforQMC";}
+	using parent_t = asn::sequenceof<PLMNListforQMC_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofPLMNforQMC >>;
+
+};
+/*
+PLMNAreaBasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct PLMNAreaBasedQMC_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+PLMNAreaBasedQMC ::= SEQUENCE {
+	plmnListforQMC		PLMNListforQMC,
+	iE-Extensions		ProtocolExtensionContainer { {PLMNAreaBasedQMC-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct PLMNAreaBasedQMC : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "PLMNAreaBasedQMC";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct plmnListforQMC_t : PLMNListforQMC
+	{
+		static constexpr const char* name() {return "plmnListforQMC_t";}
+		using parent_t = PLMNListforQMC;
+
+	};
+	plmnListforQMC_t& ref_plmnListforQMC() {return plmnListforQMC;}
+	plmnListforQMC_t const& ref_plmnListforQMC() const {return plmnListforQMC;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<PLMNAreaBasedQMC_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<PLMNAreaBasedQMC_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(plmnListforQMC);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(plmnListforQMC);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		plmnListforQMC.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	plmnListforQMC_t	plmnListforQMC;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+AreaScopeOfQMC ::= CHOICE {
+	cellBased					CellBasedQMC,
+	tABased						TABasedQMC,
+	tAIBased					TAIBasedQMC,
+	pLMNAreaBased				PLMNAreaBasedQMC,
+	...
+}
+*/
+
+struct AreaScopeOfQMC : asn::choice<4, 0, true>
+{
+	static constexpr const char* name() {return "AreaScopeOfQMC";}
+	using parent_t = asn::choice<4, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 5;}
+	void set_unknown() { set_index(5);  }
+	~AreaScopeOfQMC() {clear();}
+	struct cellBased_t : CellBasedQMC
+	{
+		static constexpr const char* name() {return "cellBased_t";}
+		using parent_t = CellBasedQMC;
+
+	};
+	struct tABased_t : TABasedQMC
+	{
+		static constexpr const char* name() {return "tABased_t";}
+		using parent_t = TABasedQMC;
+
+	};
+	struct tAIBased_t : TAIBasedQMC
+	{
+		static constexpr const char* name() {return "tAIBased_t";}
+		using parent_t = TAIBasedQMC;
+
+	};
+	struct pLMNAreaBased_t : PLMNAreaBasedQMC
+	{
+		static constexpr const char* name() {return "pLMNAreaBased_t";}
+		using parent_t = PLMNAreaBasedQMC;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<cellBased_t>(); break;
+		case 2: var.destroy<tABased_t>(); break;
+		case 3: var.destroy<tAIBased_t>(); break;
+		case 4: var.destroy<pLMNAreaBased_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<cellBased_t>());
+		case 2: set_index(2); return v(var.build<tABased_t>());
+		case 3: set_index(3); return v(var.build<tAIBased_t>());
+		case 4: set_index(4); return v(var.build<pLMNAreaBased_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<cellBased_t>());
+		case 2: return v(var.as<tABased_t>());
+		case 3: return v(var.as<tAIBased_t>());
+		case 4: return v(var.as<pLMNAreaBased_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<cellBased_t>(1);
+		v.template operator()<tABased_t>(2);
+		v.template operator()<tAIBased_t>(3);
+		v.template operator()<pLMNAreaBased_t>(4);
+
+	}
+	cellBased_t& select_cellBased() { if(get_index() != 1) { clear(); set_index(1); return var.build<cellBased_t>();} return var.as<cellBased_t>();}
+	cellBased_t const* get_cellBased() const { if(get_index() == 1) { return &var.as<cellBased_t>();} return nullptr; }
+	tABased_t& select_tABased() { if(get_index() != 2) { clear(); set_index(2); return var.build<tABased_t>();} return var.as<tABased_t>();}
+	tABased_t const* get_tABased() const { if(get_index() == 2) { return &var.as<tABased_t>();} return nullptr; }
+	tAIBased_t& select_tAIBased() { if(get_index() != 3) { clear(); set_index(3); return var.build<tAIBased_t>();} return var.as<tAIBased_t>();}
+	tAIBased_t const* get_tAIBased() const { if(get_index() == 3) { return &var.as<tAIBased_t>();} return nullptr; }
+	pLMNAreaBased_t& select_pLMNAreaBased() { if(get_index() != 4) { clear(); set_index(4); return var.build<pLMNAreaBased_t>();} return var.as<pLMNAreaBased_t>();}
+	pLMNAreaBased_t const* get_pLMNAreaBased() const { if(get_index() == 4) { return &var.as<pLMNAreaBased_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(cellBased_t)];
+		char dummy2[sizeof(tABased_t)];
+		char dummy3[sizeof(tAIBased_t)];
+		char dummy4[sizeof(pLMNAreaBased_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+FreqBandIndicator ::= INTEGER (1..256, ...)
+*/
+
+struct FreqBandIndicator : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<1, 256>>;
+	static constexpr const char* name() {return "FreqBandIndicator";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+BandInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct BandInfo_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+BandInfo	::= SEQUENCE {
+	freqBandIndicator		FreqBandIndicator,
+	iE-Extensions			ProtocolExtensionContainer { {BandInfo-ExtIEs} } 	OPTIONAL,
+	...
+}
+*/
+
+struct BandInfo : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "BandInfo";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct freqBandIndicator_t : FreqBandIndicator
+	{
+		static constexpr const char* name() {return "freqBandIndicator_t";}
+		using parent_t = FreqBandIndicator;
+
+	};
+	freqBandIndicator_t& ref_freqBandIndicator() {return freqBandIndicator;}
+	freqBandIndicator_t const& ref_freqBandIndicator() const {return freqBandIndicator;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<BandInfo_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<BandInfo_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(freqBandIndicator);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(freqBandIndicator);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		freqBandIndicator.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	freqBandIndicator_t	freqBandIndicator;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+BandwidthReducedSI::= ENUMERATED {
+	scheduled,
+	...
+}
+*/
+
+struct BandwidthReducedSI : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "BandwidthReducedSI";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		scheduled
+	} index_t;
+
+};
+
+/*
+BearerType ::= ENUMERATED {
+	non-IP,
+	...
+}
+*/
+
+struct BearerType : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "BearerType";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		non_IP
+	} index_t;
+
+};
+
+/*
+BenefitMetric ::= INTEGER (-101..100, ...)
+*/
+
+struct BenefitMetric : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<-101, 100>>;
+	static constexpr const char* name() {return "BenefitMetric";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+BitRate ::= INTEGER (0..10000000000)
+*/
+
+struct BitRate : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 10000000000>>;
+	static constexpr const char* name() {return "BitRate";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+BluetoothMeasConfig::= ENUMERATED {setup,...}
+*/
+
+struct BluetoothMeasConfig : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "BluetoothMeasConfig";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		setup
+	} index_t;
+
+};
+
+/*
+BluetoothName ::= OCTET STRING (SIZE (1..248))
+*/
+
+struct BluetoothName : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::span<1, 248>>;
+	static constexpr const char* name() {return "BluetoothName";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+BluetoothMeasConfigNameList ::= SEQUENCE (SIZE(1..maxnoofBluetoothName)) OF BluetoothName
+*/
+
+struct BluetoothMeasConfigNameList_elm : BluetoothName
+{
+	static constexpr const char* name() {return "BluetoothMeasConfigNameList_elm";}
+	using parent_t = BluetoothName;
+
+};
+struct BluetoothMeasConfigNameList : asn::sequenceof<BluetoothMeasConfigNameList_elm>
+{
+	static constexpr const char* name() {return "BluetoothMeasConfigNameList";}
+	using parent_t = asn::sequenceof<BluetoothMeasConfigNameList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBluetoothName >>;
+
+};
+/*
+BluetoothMeasurementConfiguration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct BluetoothMeasurementConfiguration_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+BluetoothMeasurementConfiguration ::= SEQUENCE {
+	bluetoothMeasConfig				BluetoothMeasConfig,
+	bluetoothMeasConfigNameList		BluetoothMeasConfigNameList			OPTIONAL,
+	bt-rssi							ENUMERATED {true, ...}				OPTIONAL,
+	iE-Extensions		ProtocolExtensionContainer { {BluetoothMeasurementConfiguration-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct BluetoothMeasurementConfiguration : asn::sequence<4, 0, true, 3>
+{
+	static constexpr const char* name() {return "BluetoothMeasurementConfiguration";}
+	using parent_t = asn::sequence<4, 0, true, 3>;
+	struct bluetoothMeasConfig_t : BluetoothMeasConfig
+	{
+		static constexpr const char* name() {return "bluetoothMeasConfig_t";}
+		using parent_t = BluetoothMeasConfig;
+
+	};
+	bluetoothMeasConfig_t& ref_bluetoothMeasConfig() {return bluetoothMeasConfig;}
+	bluetoothMeasConfig_t const& ref_bluetoothMeasConfig() const {return bluetoothMeasConfig;}
+	struct bluetoothMeasConfigNameList_t : BluetoothMeasConfigNameList
+	{
+		static constexpr const char* name() {return "bluetoothMeasConfigNameList_t";}
+		using parent_t = BluetoothMeasConfigNameList;
+		static constexpr bool optional = true;
+
+	};
+	bluetoothMeasConfigNameList_t& set_bluetoothMeasConfigNameList() { bluetoothMeasConfigNameList.setpresent(true); return bluetoothMeasConfigNameList;}
+	bluetoothMeasConfigNameList_t const* get_bluetoothMeasConfigNameList() const {return bluetoothMeasConfigNameList.is_valid() ? &bluetoothMeasConfigNameList : nullptr;}
+	struct bt_rssi_t : asn::enumerated<1, 0, true>
+	{
+		static constexpr const char* name() {return "bt_rssi_t";}
+		using parent_t = asn::enumerated<1, 0, true>;
+		static constexpr bool optional = true;
+		typedef enum {
+			True
+		} index_t;
+
+	};
+
+	bt_rssi_t& set_bt_rssi() { bt_rssi.setpresent(true); return bt_rssi;}
+	bt_rssi_t const* get_bt_rssi() const {return bt_rssi.is_valid() ? &bt_rssi : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<BluetoothMeasurementConfiguration_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<BluetoothMeasurementConfiguration_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(bluetoothMeasConfig);
+		v(bluetoothMeasConfigNameList);
+		v(bt_rssi);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(bluetoothMeasConfig);
+		v(bluetoothMeasConfigNameList);
+		v(bt_rssi);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		bluetoothMeasConfig.clear();
+		bluetoothMeasConfigNameList.clear();
+		bt_rssi.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	bluetoothMeasConfig_t	bluetoothMeasConfig;
+	bluetoothMeasConfigNameList_t	bluetoothMeasConfigNameList;
+	bt_rssi_t	bt_rssi;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+BroadcastPLMNs-Item ::= SEQUENCE (SIZE(1..maxnoofBPLMNs)) OF PLMN-Identity
+*/
+
+struct BroadcastPLMNs_Item_elm : PLMN_Identity
+{
+	static constexpr const char* name() {return "BroadcastPLMNs_Item_elm";}
+	using parent_t = PLMN_Identity;
+
+};
+struct BroadcastPLMNs_Item : asn::sequenceof<BroadcastPLMNs_Item_elm>
+{
+	static constexpr const char* name() {return "BroadcastPLMNs-Item";}
+	using parent_t = asn::sequenceof<BroadcastPLMNs_Item_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBPLMNs >>;
+
+};
+/*
+CNTypeRestrictionsItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CNTypeRestrictionsItem_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CNTypeRestrictionsItem ::= SEQUENCE {
+	plmn-Id				PLMN-Identity,
+	cn-type				ENUMERATED {fiveGC-forbidden, ...},
+	iE-Extensions		ProtocolExtensionContainer { {CNTypeRestrictionsItem-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct CNTypeRestrictionsItem : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "CNTypeRestrictionsItem";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct plmn_Id_t : PLMN_Identity
+	{
+		static constexpr const char* name() {return "plmn_Id_t";}
+		using parent_t = PLMN_Identity;
+
+	};
+	plmn_Id_t& ref_plmn_Id() {return plmn_Id;}
+	plmn_Id_t const& ref_plmn_Id() const {return plmn_Id;}
+	struct cn_type_t : asn::enumerated<1, 0, true>
+	{
+		static constexpr const char* name() {return "cn_type_t";}
+		using parent_t = asn::enumerated<1, 0, true>;
+		typedef enum {
+			fiveGC_forbidden
+		} index_t;
+
+	};
+
+	cn_type_t& ref_cn_type() {return cn_type;}
+	cn_type_t const& ref_cn_type() const {return cn_type;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CNTypeRestrictionsItem_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CNTypeRestrictionsItem_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(plmn_Id);
+		v(cn_type);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(plmn_Id);
+		v(cn_type);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		plmn_Id.clear();
+		cn_type.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	plmn_Id_t	plmn_Id;
+	cn_type_t	cn_type;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+CNTypeRestrictions ::= SEQUENCE (SIZE(1.. maxnoofEPLMNsPlusOne)) OF CNTypeRestrictionsItem
+*/
+
+struct CNTypeRestrictions_elm : CNTypeRestrictionsItem
+{
+	static constexpr const char* name() {return "CNTypeRestrictions_elm";}
+	using parent_t = CNTypeRestrictionsItem;
+
+};
+struct CNTypeRestrictions : asn::sequenceof<CNTypeRestrictions_elm>
+{
+	static constexpr const char* name() {return "CNTypeRestrictions";}
+	using parent_t = asn::sequenceof<CNTypeRestrictions_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofEPLMNsPlusOne >>;
+
+};
+/*
+PDCP-SNExtended ::= INTEGER (0..32767)
+*/
+
+struct PDCP_SNExtended : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 32767>>;
+	static constexpr const char* name() {return "PDCP-SNExtended";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+HFNModified ::= INTEGER (0..131071)
+*/
+
+struct HFNModified : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 131071>>;
+	static constexpr const char* name() {return "HFNModified";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+COUNTValueExtended-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct COUNTValueExtended_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+COUNTValueExtended ::= SEQUENCE {
+	pDCP-SNExtended			PDCP-SNExtended,
+	hFNModified				HFNModified,
+	iE-Extensions			ProtocolExtensionContainer { {COUNTValueExtended-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct COUNTValueExtended : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "COUNTValueExtended";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct pDCP_SNExtended_t : PDCP_SNExtended
+	{
+		static constexpr const char* name() {return "pDCP_SNExtended_t";}
+		using parent_t = PDCP_SNExtended;
+
+	};
+	pDCP_SNExtended_t& ref_pDCP_SNExtended() {return pDCP_SNExtended;}
+	pDCP_SNExtended_t const& ref_pDCP_SNExtended() const {return pDCP_SNExtended;}
+	struct hFNModified_t : HFNModified
+	{
+		static constexpr const char* name() {return "hFNModified_t";}
+		using parent_t = HFNModified;
+
+	};
+	hFNModified_t& ref_hFNModified() {return hFNModified;}
+	hFNModified_t const& ref_hFNModified() const {return hFNModified;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<COUNTValueExtended_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<COUNTValueExtended_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(pDCP_SNExtended);
+		v(hFNModified);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(pDCP_SNExtended);
+		v(hFNModified);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		pDCP_SNExtended.clear();
+		hFNModified.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	pDCP_SNExtended_t	pDCP_SNExtended;
+	hFNModified_t	hFNModified;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+PDCP-SN ::= INTEGER (0..4095)
+*/
+
+struct PDCP_SN : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
+	static constexpr const char* name() {return "PDCP-SN";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+HFN ::= INTEGER (0..1048575)
+*/
+
+struct HFN : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 1048575>>;
+	static constexpr const char* name() {return "HFN";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+COUNTvalue-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct COUNTvalue_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+COUNTvalue ::= SEQUENCE {
+	pDCP-SN					PDCP-SN,
+	hFN						HFN,
+	iE-Extensions			ProtocolExtensionContainer { {COUNTvalue-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct COUNTvalue : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "COUNTvalue";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct pDCP_SN_t : PDCP_SN
+	{
+		static constexpr const char* name() {return "pDCP_SN_t";}
+		using parent_t = PDCP_SN;
+
+	};
+	pDCP_SN_t& ref_pDCP_SN() {return pDCP_SN;}
+	pDCP_SN_t const& ref_pDCP_SN() const {return pDCP_SN;}
+	struct hFN_t : HFN
+	{
+		static constexpr const char* name() {return "hFN_t";}
+		using parent_t = HFN;
+
+	};
+	hFN_t& ref_hFN() {return hFN;}
+	hFN_t const& ref_hFN() const {return hFN;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<COUNTvalue_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<COUNTvalue_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(pDCP_SN);
+		v(hFN);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(pDCP_SN);
+		v(hFN);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		pDCP_SN.clear();
+		hFN.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	pDCP_SN_t	pDCP_SN;
+	hFN_t	hFN;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+PDCP-SNlength18 ::= INTEGER (0..262143)
+*/
+
+struct PDCP_SNlength18 : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 262143>>;
+	static constexpr const char* name() {return "PDCP-SNlength18";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+HFNforPDCP-SNlength18 ::= INTEGER (0..16383)
+*/
+
+struct HFNforPDCP_SNlength18 : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 16383>>;
+	static constexpr const char* name() {return "HFNforPDCP-SNlength18";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+COUNTvaluePDCP-SNlength18-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct COUNTvaluePDCP_SNlength18_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+COUNTvaluePDCP-SNlength18 ::= SEQUENCE {
+	pDCP-SNlength18			PDCP-SNlength18,
+	hFNforPDCP-SNlength18	HFNforPDCP-SNlength18,
+	iE-Extensions			ProtocolExtensionContainer { {COUNTvaluePDCP-SNlength18-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct COUNTvaluePDCP_SNlength18 : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "COUNTvaluePDCP-SNlength18";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct pDCP_SNlength18_t : PDCP_SNlength18
+	{
+		static constexpr const char* name() {return "pDCP_SNlength18_t";}
+		using parent_t = PDCP_SNlength18;
+
+	};
+	pDCP_SNlength18_t& ref_pDCP_SNlength18() {return pDCP_SNlength18;}
+	pDCP_SNlength18_t const& ref_pDCP_SNlength18() const {return pDCP_SNlength18;}
+	struct hFNforPDCP_SNlength18_t : HFNforPDCP_SNlength18
+	{
+		static constexpr const char* name() {return "hFNforPDCP_SNlength18_t";}
+		using parent_t = HFNforPDCP_SNlength18;
+
+	};
+	hFNforPDCP_SNlength18_t& ref_hFNforPDCP_SNlength18() {return hFNforPDCP_SNlength18;}
+	hFNforPDCP_SNlength18_t const& ref_hFNforPDCP_SNlength18() const {return hFNforPDCP_SNlength18;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<COUNTvaluePDCP_SNlength18_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<COUNTvaluePDCP_SNlength18_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(pDCP_SNlength18);
+		v(hFNforPDCP_SNlength18);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(pDCP_SNlength18);
+		v(hFNforPDCP_SNlength18);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		pDCP_SNlength18.clear();
+		hFNforPDCP_SNlength18.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	pDCP_SNlength18_t	pDCP_SNlength18;
+	hFNforPDCP_SNlength18_t	hFNforPDCP_SNlength18;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+CRNTI ::= BIT STRING (SIZE (16))
+*/
+
+struct CRNTI : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<16>>;
+	static constexpr const char* name() {return "CRNTI";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+CSG-Id ::= BIT STRING (SIZE (27))
+*/
+
+struct CSG_Id : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<27>>;
+	static constexpr const char* name() {return "CSG-Id";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+CSGMembershipStatus ::= ENUMERATED {
+	member,
+	not-member
+}
+*/
+
+struct CSGMembershipStatus : asn::enumerated<2, 0, false>
+{
+	static constexpr const char* name() {return "CSGMembershipStatus";}
+	using parent_t = asn::enumerated<2, 0, false>;
+	typedef enum {
+		member
+		,not_member
+	} index_t;
+
+};
+
+/*
+UEID ::= BIT STRING (SIZE (16))
+*/
+
+struct UEID : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<16>>;
+	static constexpr const char* name() {return "UEID";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+WidebandCQICodeword1::= CHOICE {
+	four-bitCQI								INTEGER (0..15, ...),
+	three-bitSpatialDifferentialCQI			INTEGER (0..7, ...),
+	...
+}
+*/
+
+struct WidebandCQICodeword1 : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "WidebandCQICodeword1";}
+	using parent_t = asn::choice<2, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 3;}
+	void set_unknown() { set_index(3);  }
+	~WidebandCQICodeword1() {clear();}
+	struct four_bitCQI_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 15>>;
+		static constexpr const char* name() {return "four_bitCQI_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	struct three_bitSpatialDifferentialCQI_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 7>>;
+		static constexpr const char* name() {return "three_bitSpatialDifferentialCQI_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<four_bitCQI_t>(); break;
+		case 2: var.destroy<three_bitSpatialDifferentialCQI_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<four_bitCQI_t>());
+		case 2: set_index(2); return v(var.build<three_bitSpatialDifferentialCQI_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<four_bitCQI_t>());
+		case 2: return v(var.as<three_bitSpatialDifferentialCQI_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<four_bitCQI_t>(1);
+		v.template operator()<three_bitSpatialDifferentialCQI_t>(2);
+
+	}
+	four_bitCQI_t& select_four_bitCQI() { if(get_index() != 1) { clear(); set_index(1); return var.build<four_bitCQI_t>();} return var.as<four_bitCQI_t>();}
+	four_bitCQI_t const* get_four_bitCQI() const { if(get_index() == 1) { return &var.as<four_bitCQI_t>();} return nullptr; }
+	three_bitSpatialDifferentialCQI_t& select_three_bitSpatialDifferentialCQI() { if(get_index() != 2) { clear(); set_index(2); return var.build<three_bitSpatialDifferentialCQI_t>();} return var.as<three_bitSpatialDifferentialCQI_t>();}
+	three_bitSpatialDifferentialCQI_t const* get_three_bitSpatialDifferentialCQI() const { if(get_index() == 2) { return &var.as<three_bitSpatialDifferentialCQI_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(four_bitCQI_t)];
+		char dummy2[sizeof(three_bitSpatialDifferentialCQI_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+WidebandCQI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct WidebandCQI_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+WidebandCQI ::= SEQUENCE {
+	widebandCQICodeword0		INTEGER (0..15, ...),
+	widebandCQICodeword1		WidebandCQICodeword1		OPTIONAL,
+	iE-Extensions				ProtocolExtensionContainer { {WidebandCQI-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct WidebandCQI : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "WidebandCQI";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	struct widebandCQICodeword0_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 15>>;
+		static constexpr const char* name() {return "widebandCQICodeword0_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	widebandCQICodeword0_t& ref_widebandCQICodeword0() {return widebandCQICodeword0;}
+	widebandCQICodeword0_t const& ref_widebandCQICodeword0() const {return widebandCQICodeword0;}
+	struct widebandCQICodeword1_t : WidebandCQICodeword1
+	{
+		static constexpr const char* name() {return "widebandCQICodeword1_t";}
+		using parent_t = WidebandCQICodeword1;
+		static constexpr bool optional = true;
+
+	};
+	widebandCQICodeword1_t& set_widebandCQICodeword1() { widebandCQICodeword1.setpresent(true); return widebandCQICodeword1;}
+	widebandCQICodeword1_t const* get_widebandCQICodeword1() const {return widebandCQICodeword1.is_valid() ? &widebandCQICodeword1 : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<WidebandCQI_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<WidebandCQI_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(widebandCQICodeword0);
+		v(widebandCQICodeword1);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(widebandCQICodeword0);
+		v(widebandCQICodeword1);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		widebandCQICodeword0.clear();
+		widebandCQICodeword1.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	widebandCQICodeword0_t	widebandCQICodeword0;
+	widebandCQICodeword1_t	widebandCQICodeword1;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+SubbandSize ::= ENUMERATED {
+	size2,
+	size3,
+	size4,
+	size6,
+	size8,
+	...
+}
+*/
+
+struct SubbandSize : asn::enumerated<5, 0, true>
+{
+	static constexpr const char* name() {return "SubbandSize";}
+	using parent_t = asn::enumerated<5, 0, true>;
+	typedef enum {
+		size2
+		,size3
+		,size4
+		,size6
+		,size8
+	} index_t;
+
+};
+
+/*
+SubbandCQICodeword0 ::= CHOICE {
+	four-bitCQI						INTEGER (0..15, ...),
+	two-bitSubbandDifferentialCQI	INTEGER (0..3, ...),
+	two-bitDifferentialCQI			INTEGER (0..3, ...),
+	...
+}
+*/
+
+struct SubbandCQICodeword0 : asn::choice<3, 0, true>
+{
+	static constexpr const char* name() {return "SubbandCQICodeword0";}
+	using parent_t = asn::choice<3, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 4;}
+	void set_unknown() { set_index(4);  }
+	~SubbandCQICodeword0() {clear();}
+	struct four_bitCQI_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 15>>;
+		static constexpr const char* name() {return "four_bitCQI_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	struct two_bitSubbandDifferentialCQI_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 3>>;
+		static constexpr const char* name() {return "two_bitSubbandDifferentialCQI_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	struct two_bitDifferentialCQI_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 3>>;
+		static constexpr const char* name() {return "two_bitDifferentialCQI_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<four_bitCQI_t>(); break;
+		case 2: var.destroy<two_bitSubbandDifferentialCQI_t>(); break;
+		case 3: var.destroy<two_bitDifferentialCQI_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<four_bitCQI_t>());
+		case 2: set_index(2); return v(var.build<two_bitSubbandDifferentialCQI_t>());
+		case 3: set_index(3); return v(var.build<two_bitDifferentialCQI_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<four_bitCQI_t>());
+		case 2: return v(var.as<two_bitSubbandDifferentialCQI_t>());
+		case 3: return v(var.as<two_bitDifferentialCQI_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<four_bitCQI_t>(1);
+		v.template operator()<two_bitSubbandDifferentialCQI_t>(2);
+		v.template operator()<two_bitDifferentialCQI_t>(3);
+
+	}
+	four_bitCQI_t& select_four_bitCQI() { if(get_index() != 1) { clear(); set_index(1); return var.build<four_bitCQI_t>();} return var.as<four_bitCQI_t>();}
+	four_bitCQI_t const* get_four_bitCQI() const { if(get_index() == 1) { return &var.as<four_bitCQI_t>();} return nullptr; }
+	two_bitSubbandDifferentialCQI_t& select_two_bitSubbandDifferentialCQI() { if(get_index() != 2) { clear(); set_index(2); return var.build<two_bitSubbandDifferentialCQI_t>();} return var.as<two_bitSubbandDifferentialCQI_t>();}
+	two_bitSubbandDifferentialCQI_t const* get_two_bitSubbandDifferentialCQI() const { if(get_index() == 2) { return &var.as<two_bitSubbandDifferentialCQI_t>();} return nullptr; }
+	two_bitDifferentialCQI_t& select_two_bitDifferentialCQI() { if(get_index() != 3) { clear(); set_index(3); return var.build<two_bitDifferentialCQI_t>();} return var.as<two_bitDifferentialCQI_t>();}
+	two_bitDifferentialCQI_t const* get_two_bitDifferentialCQI() const { if(get_index() == 3) { return &var.as<two_bitDifferentialCQI_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(four_bitCQI_t)];
+		char dummy2[sizeof(two_bitSubbandDifferentialCQI_t)];
+		char dummy3[sizeof(two_bitDifferentialCQI_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+SubbandCQICodeword1 ::= CHOICE {
+	four-bitCQI							INTEGER (0..15, ...),
+	three-bitSpatialDifferentialCQI		INTEGER (0..7, ...),
+	two-bitSubbandDifferentialCQI		INTEGER (0..3, ...),
+	two-bitDifferentialCQI				INTEGER (0..3, ...),
+	...
+}
+*/
+
+struct SubbandCQICodeword1 : asn::choice<4, 0, true>
+{
+	static constexpr const char* name() {return "SubbandCQICodeword1";}
+	using parent_t = asn::choice<4, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 5;}
+	void set_unknown() { set_index(5);  }
+	~SubbandCQICodeword1() {clear();}
+	struct four_bitCQI_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 15>>;
+		static constexpr const char* name() {return "four_bitCQI_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	struct three_bitSpatialDifferentialCQI_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 7>>;
+		static constexpr const char* name() {return "three_bitSpatialDifferentialCQI_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	struct two_bitSubbandDifferentialCQI_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 3>>;
+		static constexpr const char* name() {return "two_bitSubbandDifferentialCQI_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	struct two_bitDifferentialCQI_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 3>>;
+		static constexpr const char* name() {return "two_bitDifferentialCQI_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<four_bitCQI_t>(); break;
+		case 2: var.destroy<three_bitSpatialDifferentialCQI_t>(); break;
+		case 3: var.destroy<two_bitSubbandDifferentialCQI_t>(); break;
+		case 4: var.destroy<two_bitDifferentialCQI_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<four_bitCQI_t>());
+		case 2: set_index(2); return v(var.build<three_bitSpatialDifferentialCQI_t>());
+		case 3: set_index(3); return v(var.build<two_bitSubbandDifferentialCQI_t>());
+		case 4: set_index(4); return v(var.build<two_bitDifferentialCQI_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<four_bitCQI_t>());
+		case 2: return v(var.as<three_bitSpatialDifferentialCQI_t>());
+		case 3: return v(var.as<two_bitSubbandDifferentialCQI_t>());
+		case 4: return v(var.as<two_bitDifferentialCQI_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<four_bitCQI_t>(1);
+		v.template operator()<three_bitSpatialDifferentialCQI_t>(2);
+		v.template operator()<two_bitSubbandDifferentialCQI_t>(3);
+		v.template operator()<two_bitDifferentialCQI_t>(4);
+
+	}
+	four_bitCQI_t& select_four_bitCQI() { if(get_index() != 1) { clear(); set_index(1); return var.build<four_bitCQI_t>();} return var.as<four_bitCQI_t>();}
+	four_bitCQI_t const* get_four_bitCQI() const { if(get_index() == 1) { return &var.as<four_bitCQI_t>();} return nullptr; }
+	three_bitSpatialDifferentialCQI_t& select_three_bitSpatialDifferentialCQI() { if(get_index() != 2) { clear(); set_index(2); return var.build<three_bitSpatialDifferentialCQI_t>();} return var.as<three_bitSpatialDifferentialCQI_t>();}
+	three_bitSpatialDifferentialCQI_t const* get_three_bitSpatialDifferentialCQI() const { if(get_index() == 2) { return &var.as<three_bitSpatialDifferentialCQI_t>();} return nullptr; }
+	two_bitSubbandDifferentialCQI_t& select_two_bitSubbandDifferentialCQI() { if(get_index() != 3) { clear(); set_index(3); return var.build<two_bitSubbandDifferentialCQI_t>();} return var.as<two_bitSubbandDifferentialCQI_t>();}
+	two_bitSubbandDifferentialCQI_t const* get_two_bitSubbandDifferentialCQI() const { if(get_index() == 3) { return &var.as<two_bitSubbandDifferentialCQI_t>();} return nullptr; }
+	two_bitDifferentialCQI_t& select_two_bitDifferentialCQI() { if(get_index() != 4) { clear(); set_index(4); return var.build<two_bitDifferentialCQI_t>();} return var.as<two_bitDifferentialCQI_t>();}
+	two_bitDifferentialCQI_t const* get_two_bitDifferentialCQI() const { if(get_index() == 4) { return &var.as<two_bitDifferentialCQI_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(four_bitCQI_t)];
+		char dummy2[sizeof(three_bitSpatialDifferentialCQI_t)];
+		char dummy3[sizeof(two_bitSubbandDifferentialCQI_t)];
+		char dummy4[sizeof(two_bitDifferentialCQI_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+SubbandCQI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct SubbandCQI_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SubbandCQI ::= SEQUENCE {
+	subbandCQICodeword0			SubbandCQICodeword0,
+	subbandCQICodeword1			SubbandCQICodeword1		OPTIONAL,
+	iE-Extensions				ProtocolExtensionContainer { {SubbandCQI-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct SubbandCQI : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "SubbandCQI";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	struct subbandCQICodeword0_t : SubbandCQICodeword0
+	{
+		static constexpr const char* name() {return "subbandCQICodeword0_t";}
+		using parent_t = SubbandCQICodeword0;
+
+	};
+	subbandCQICodeword0_t& ref_subbandCQICodeword0() {return subbandCQICodeword0;}
+	subbandCQICodeword0_t const& ref_subbandCQICodeword0() const {return subbandCQICodeword0;}
+	struct subbandCQICodeword1_t : SubbandCQICodeword1
+	{
+		static constexpr const char* name() {return "subbandCQICodeword1_t";}
+		using parent_t = SubbandCQICodeword1;
+		static constexpr bool optional = true;
+
+	};
+	subbandCQICodeword1_t& set_subbandCQICodeword1() { subbandCQICodeword1.setpresent(true); return subbandCQICodeword1;}
+	subbandCQICodeword1_t const* get_subbandCQICodeword1() const {return subbandCQICodeword1.is_valid() ? &subbandCQICodeword1 : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<SubbandCQI_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<SubbandCQI_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(subbandCQICodeword0);
+		v(subbandCQICodeword1);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(subbandCQICodeword0);
+		v(subbandCQICodeword1);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		subbandCQICodeword0.clear();
+		subbandCQICodeword1.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	subbandCQICodeword0_t	subbandCQICodeword0;
+	subbandCQICodeword1_t	subbandCQICodeword1;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+SubbandCQIItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct SubbandCQIItem_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SubbandCQIItem ::= SEQUENCE {
+	subbandCQI			SubbandCQI,
+	subbandIndex		INTEGER (0..27,...),
+	iE-Extensions		ProtocolExtensionContainer { {SubbandCQIItem-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct SubbandCQIItem : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "SubbandCQIItem";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct subbandCQI_t : SubbandCQI
+	{
+		static constexpr const char* name() {return "subbandCQI_t";}
+		using parent_t = SubbandCQI;
+
+	};
+	subbandCQI_t& ref_subbandCQI() {return subbandCQI;}
+	subbandCQI_t const& ref_subbandCQI() const {return subbandCQI;}
+	struct subbandIndex_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 27>>;
+		static constexpr const char* name() {return "subbandIndex_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	subbandIndex_t& ref_subbandIndex() {return subbandIndex;}
+	subbandIndex_t const& ref_subbandIndex() const {return subbandIndex;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<SubbandCQIItem_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<SubbandCQIItem_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(subbandCQI);
+		v(subbandIndex);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(subbandCQI);
+		v(subbandIndex);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		subbandCQI.clear();
+		subbandIndex.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	subbandCQI_t	subbandCQI;
+	subbandIndex_t	subbandIndex;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+SubbandCQIList ::= SEQUENCE (SIZE(1.. maxSubband)) OF SubbandCQIItem
+*/
+
+struct SubbandCQIList_elm : SubbandCQIItem
+{
+	static constexpr const char* name() {return "SubbandCQIList_elm";}
+	using parent_t = SubbandCQIItem;
+
+};
+struct SubbandCQIList : asn::sequenceof<SubbandCQIList_elm>
+{
+	static constexpr const char* name() {return "SubbandCQIList";}
+	using parent_t = asn::sequenceof<SubbandCQIList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxSubband >>;
+
+};
+/*
+CSIReportPerCSIProcessItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CSIReportPerCSIProcessItem_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CSIReportPerCSIProcessItem ::= SEQUENCE (SIZE(1.. maxCSIReport)) OF
+	SEQUENCE {
+		rI								INTEGER (1..8, ...),
+		widebandCQI						WidebandCQI,
+		subbandSize						SubbandSize,
+		subbandCQIList					SubbandCQIList	OPTIONAL,
+		iE-Extensions					ProtocolExtensionContainer { {CSIReportPerCSIProcessItem-ExtIEs} } OPTIONAL,
+		...
+	}
+*/
+
+struct CSIReportPerCSIProcessItem_elm : asn::sequence<5, 0, true, 2>
+{
+	static constexpr const char* name() {return "CSIReportPerCSIProcessItem_elm";}
+	using parent_t = asn::sequence<5, 0, true, 2>;
+	struct rI_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<1, 8>>;
+		static constexpr const char* name() {return "rI_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	rI_t& ref_rI() {return rI;}
+	rI_t const& ref_rI() const {return rI;}
+	struct widebandCQI_t : WidebandCQI
+	{
+		static constexpr const char* name() {return "widebandCQI_t";}
+		using parent_t = WidebandCQI;
+
+	};
+	widebandCQI_t& ref_widebandCQI() {return widebandCQI;}
+	widebandCQI_t const& ref_widebandCQI() const {return widebandCQI;}
+	struct subbandSize_t : SubbandSize
+	{
+		static constexpr const char* name() {return "subbandSize_t";}
+		using parent_t = SubbandSize;
+
+	};
+	subbandSize_t& ref_subbandSize() {return subbandSize;}
+	subbandSize_t const& ref_subbandSize() const {return subbandSize;}
+	struct subbandCQIList_t : SubbandCQIList
+	{
+		static constexpr const char* name() {return "subbandCQIList_t";}
+		using parent_t = SubbandCQIList;
+		static constexpr bool optional = true;
+
+	};
+	subbandCQIList_t& set_subbandCQIList() { subbandCQIList.setpresent(true); return subbandCQIList;}
+	subbandCQIList_t const* get_subbandCQIList() const {return subbandCQIList.is_valid() ? &subbandCQIList : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CSIReportPerCSIProcessItem_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CSIReportPerCSIProcessItem_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(rI);
+		v(widebandCQI);
+		v(subbandSize);
+		v(subbandCQIList);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(rI);
+		v(widebandCQI);
+		v(subbandSize);
+		v(subbandCQIList);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		rI.clear();
+		widebandCQI.clear();
+		subbandSize.clear();
+		subbandCQIList.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	rI_t	rI;
+	widebandCQI_t	widebandCQI;
+	subbandSize_t	subbandSize;
+	subbandCQIList_t	subbandCQIList;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct CSIReportPerCSIProcessItem : asn::sequenceof<CSIReportPerCSIProcessItem_elm>
+{
+	static constexpr const char* name() {return "CSIReportPerCSIProcessItem";}
+	using parent_t = asn::sequenceof<CSIReportPerCSIProcessItem_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCSIReport >>;
+
+};
+/*
+CSIReportPerCSIProcess-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CSIReportPerCSIProcess_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CSIReportPerCSIProcess ::= SEQUENCE (SIZE(1.. maxCSIProcess)) OF
+	SEQUENCE {
+		cSIProcessConfigurationIndex	INTEGER (1..7, ...),
+		cSIReportPerCSIProcessItem		CSIReportPerCSIProcessItem,
+		iE-Extensions					ProtocolExtensionContainer { {CSIReportPerCSIProcess-ExtIEs} } OPTIONAL,
+		...
+	}
+*/
+
+struct CSIReportPerCSIProcess_elm : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "CSIReportPerCSIProcess_elm";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct cSIProcessConfigurationIndex_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<1, 7>>;
+		static constexpr const char* name() {return "cSIProcessConfigurationIndex_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	cSIProcessConfigurationIndex_t& ref_cSIProcessConfigurationIndex() {return cSIProcessConfigurationIndex;}
+	cSIProcessConfigurationIndex_t const& ref_cSIProcessConfigurationIndex() const {return cSIProcessConfigurationIndex;}
+	struct cSIReportPerCSIProcessItem_t : CSIReportPerCSIProcessItem
+	{
+		static constexpr const char* name() {return "cSIReportPerCSIProcessItem_t";}
+		using parent_t = CSIReportPerCSIProcessItem;
+
+	};
+	cSIReportPerCSIProcessItem_t& ref_cSIReportPerCSIProcessItem() {return cSIReportPerCSIProcessItem;}
+	cSIReportPerCSIProcessItem_t const& ref_cSIReportPerCSIProcessItem() const {return cSIReportPerCSIProcessItem;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CSIReportPerCSIProcess_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CSIReportPerCSIProcess_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(cSIProcessConfigurationIndex);
+		v(cSIReportPerCSIProcessItem);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(cSIProcessConfigurationIndex);
+		v(cSIReportPerCSIProcessItem);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		cSIProcessConfigurationIndex.clear();
+		cSIReportPerCSIProcessItem.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	cSIProcessConfigurationIndex_t	cSIProcessConfigurationIndex;
+	cSIReportPerCSIProcessItem_t	cSIReportPerCSIProcessItem;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct CSIReportPerCSIProcess : asn::sequenceof<CSIReportPerCSIProcess_elm>
+{
+	static constexpr const char* name() {return "CSIReportPerCSIProcess";}
+	using parent_t = asn::sequenceof<CSIReportPerCSIProcess_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCSIProcess >>;
+
+};
+/*
+CSIReportList-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CSIReportList_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CSIReportList ::= SEQUENCE (SIZE(1..maxUEReport)) OF
+	SEQUENCE {
+		uEID							UEID,
+		cSIReportPerCSIProcess			CSIReportPerCSIProcess,
+		iE-Extensions					ProtocolExtensionContainer { {CSIReportList-ExtIEs} } OPTIONAL,
+		...
+	}
+*/
+
+struct CSIReportList_elm : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "CSIReportList_elm";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct uEID_t : UEID
+	{
+		static constexpr const char* name() {return "uEID_t";}
+		using parent_t = UEID;
+
+	};
+	uEID_t& ref_uEID() {return uEID;}
+	uEID_t const& ref_uEID() const {return uEID;}
+	struct cSIReportPerCSIProcess_t : CSIReportPerCSIProcess
+	{
+		static constexpr const char* name() {return "cSIReportPerCSIProcess_t";}
+		using parent_t = CSIReportPerCSIProcess;
+
+	};
+	cSIReportPerCSIProcess_t& ref_cSIReportPerCSIProcess() {return cSIReportPerCSIProcess;}
+	cSIReportPerCSIProcess_t const& ref_cSIReportPerCSIProcess() const {return cSIReportPerCSIProcess;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CSIReportList_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CSIReportList_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(uEID);
+		v(cSIReportPerCSIProcess);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(uEID);
+		v(cSIReportPerCSIProcess);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		uEID.clear();
+		cSIReportPerCSIProcess.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	uEID_t	uEID;
+	cSIReportPerCSIProcess_t	cSIReportPerCSIProcess;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct CSIReportList : asn::sequenceof<CSIReportList_elm>
+{
+	static constexpr const char* name() {return "CSIReportList";}
+	using parent_t = asn::sequenceof<CSIReportList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxUEReport >>;
+
+};
+/*
+CapacityValue ::= INTEGER (0..100)
+*/
+
+struct CapacityValue : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+	static constexpr const char* name() {return "CapacityValue";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+CauseRadioNetwork ::= ENUMERATED {
+	handover-desirable-for-radio-reasons,
+	time-critical-handover,
+	resource-optimisation-handover,
+	reduce-load-in-serving-cell,
+	partial-handover,
+	unknown-new-eNB-UE-X2AP-ID,
+	unknown-old-eNB-UE-X2AP-ID,
+	unknown-pair-of-UE-X2AP-ID,
+	ho-target-not-allowed,
+	tx2relocoverall-expiry,
+	trelocprep-expiry,
+	cell-not-available,
+	no-radio-resources-available-in-target-cell,
+	invalid-MME-GroupID,
+	unknown-MME-Code,
+	encryption-and-or-integrity-protection-algorithms-not-supported,
+	reportCharacteristicsEmpty,
+	noReportPeriodicity,
+	existingMeasurementID,
+	unknown-eNB-Measurement-ID,
+	measurement-temporarily-not-available,
+	unspecified,
+	...,
+	load-balancing,
+	handover-optimisation,
+	value-out-of-allowed-range,
+	multiple-E-RAB-ID-instances,
+	switch-off-ongoing,
+	not-supported-QCI-value,
+	measurement-not-supported-for-the-object,
+	tDCoverall-expiry,
+	tDCprep-expiry,
+	action-desirable-for-radio-reasons,
+	reduce-load,
+	resource-optimisation,
+	time-critical-action,
+	target-not-allowed,
+	no-radio-resources-available,
+	invalid-QoS-combination,
+	encryption-algorithms-not-aupported,
+	procedure-cancelled,
+	rRM-purpose,
+	improve-user-bit-rate,
+	user-inactivity,
+	radio-connection-with-UE-lost,
+	failure-in-the-radio-interface-procedure,
+	bearer-option-not-supported,
+	mCG-Mobility,
+	sCG-Mobility,
+	count-reaches-max-value,
+	unknown-old-en-gNB-UE-X2AP-ID,
+	pDCP-Overload
+
+}
+*/
+
+struct CauseRadioNetwork : asn::enumerated<51, 29, true>
+{
+	static constexpr const char* name() {return "CauseRadioNetwork";}
+	using parent_t = asn::enumerated<51, 29, true>;
+	typedef enum {
+		handover_desirable_for_radio_reasons
+		,time_critical_handover
+		,resource_optimisation_handover
+		,reduce_load_in_serving_cell
+		,partial_handover
+		,unknown_new_eNB_UE_X2AP_ID
+		,unknown_old_eNB_UE_X2AP_ID
+		,unknown_pair_of_UE_X2AP_ID
+		,ho_target_not_allowed
+		,tx2relocoverall_expiry
+		,trelocprep_expiry
+		,cell_not_available
+		,no_radio_resources_available_in_target_cell
+		,invalid_MME_GroupID
+		,unknown_MME_Code
+		,encryption_and_or_integrity_protection_algorithms_not_supported
+		,reportCharacteristicsEmpty
+		,noReportPeriodicity
+		,existingMeasurementID
+		,unknown_eNB_Measurement_ID
+		,measurement_temporarily_not_available
+		,unspecified
+		,load_balancing
+		,handover_optimisation
+		,value_out_of_allowed_range
+		,multiple_E_RAB_ID_instances
+		,switch_off_ongoing
+		,not_supported_QCI_value
+		,measurement_not_supported_for_the_object
+		,tDCoverall_expiry
+		,tDCprep_expiry
+		,action_desirable_for_radio_reasons
+		,reduce_load
+		,resource_optimisation
+		,time_critical_action
+		,target_not_allowed
+		,no_radio_resources_available
+		,invalid_QoS_combination
+		,encryption_algorithms_not_aupported
+		,procedure_cancelled
+		,rRM_purpose
+		,improve_user_bit_rate
+		,user_inactivity
+		,radio_connection_with_UE_lost
+		,failure_in_the_radio_interface_procedure
+		,bearer_option_not_supported
+		,mCG_Mobility
+		,sCG_Mobility
+		,count_reaches_max_value
+		,unknown_old_en_gNB_UE_X2AP_ID
+		,pDCP_Overload
+	} index_t;
+
+};
+
+/*
+CauseTransport ::= ENUMERATED {
+	transport-resource-unavailable,
+	unspecified,
+	...
+}
+*/
+
+struct CauseTransport : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "CauseTransport";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		transport_resource_unavailable
+		,unspecified
+	} index_t;
+
+};
+
+/*
+CauseProtocol ::= ENUMERATED {
+	transfer-syntax-error,
+	abstract-syntax-error-reject,
+	abstract-syntax-error-ignore-and-notify,
+	message-not-compatible-with-receiver-state,
+	semantic-error,
+	unspecified,
+	abstract-syntax-error-falsely-constructed-message,
+	...
+}
+*/
+
+struct CauseProtocol : asn::enumerated<7, 0, true>
+{
+	static constexpr const char* name() {return "CauseProtocol";}
+	using parent_t = asn::enumerated<7, 0, true>;
+	typedef enum {
+		transfer_syntax_error
+		,abstract_syntax_error_reject
+		,abstract_syntax_error_ignore_and_notify
+		,message_not_compatible_with_receiver_state
+		,semantic_error
+		,unspecified
+		,abstract_syntax_error_falsely_constructed_message
+	} index_t;
+
+};
+
+/*
+CauseMisc ::= ENUMERATED {
+	control-processing-overload,
+	hardware-failure,
+	om-intervention,
+	not-enough-user-plane-processing-resources,
+	unspecified,
+	...
+}
+*/
+
+struct CauseMisc : asn::enumerated<5, 0, true>
+{
+	static constexpr const char* name() {return "CauseMisc";}
+	using parent_t = asn::enumerated<5, 0, true>;
+	typedef enum {
+		control_processing_overload
+		,hardware_failure
+		,om_intervention
+		,not_enough_user_plane_processing_resources
+		,unspecified
+	} index_t;
+
+};
+
+/*
+Cause ::= CHOICE {
+	radioNetwork		CauseRadioNetwork,
+	transport			CauseTransport,
+	protocol			CauseProtocol,
+	misc				CauseMisc,
+	...
+}
+*/
+
+struct Cause : asn::choice<4, 0, true>
+{
+	static constexpr const char* name() {return "Cause";}
+	using parent_t = asn::choice<4, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 5;}
+	void set_unknown() { set_index(5);  }
+	~Cause() {clear();}
+	struct radioNetwork_t : CauseRadioNetwork
+	{
+		static constexpr const char* name() {return "radioNetwork_t";}
+		using parent_t = CauseRadioNetwork;
+
+	};
+	struct transport_t : CauseTransport
+	{
+		static constexpr const char* name() {return "transport_t";}
+		using parent_t = CauseTransport;
+
+	};
+	struct protocol_t : CauseProtocol
+	{
+		static constexpr const char* name() {return "protocol_t";}
+		using parent_t = CauseProtocol;
+
+	};
+	struct misc_t : CauseMisc
+	{
+		static constexpr const char* name() {return "misc_t";}
+		using parent_t = CauseMisc;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<radioNetwork_t>(); break;
+		case 2: var.destroy<transport_t>(); break;
+		case 3: var.destroy<protocol_t>(); break;
+		case 4: var.destroy<misc_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<radioNetwork_t>());
+		case 2: set_index(2); return v(var.build<transport_t>());
+		case 3: set_index(3); return v(var.build<protocol_t>());
+		case 4: set_index(4); return v(var.build<misc_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<radioNetwork_t>());
+		case 2: return v(var.as<transport_t>());
+		case 3: return v(var.as<protocol_t>());
+		case 4: return v(var.as<misc_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<radioNetwork_t>(1);
+		v.template operator()<transport_t>(2);
+		v.template operator()<protocol_t>(3);
+		v.template operator()<misc_t>(4);
+
+	}
+	radioNetwork_t& select_radioNetwork() { if(get_index() != 1) { clear(); set_index(1); return var.build<radioNetwork_t>();} return var.as<radioNetwork_t>();}
+	radioNetwork_t const* get_radioNetwork() const { if(get_index() == 1) { return &var.as<radioNetwork_t>();} return nullptr; }
+	transport_t& select_transport() { if(get_index() != 2) { clear(); set_index(2); return var.build<transport_t>();} return var.as<transport_t>();}
+	transport_t const* get_transport() const { if(get_index() == 2) { return &var.as<transport_t>();} return nullptr; }
+	protocol_t& select_protocol() { if(get_index() != 3) { clear(); set_index(3); return var.build<protocol_t>();} return var.as<protocol_t>();}
+	protocol_t const* get_protocol() const { if(get_index() == 3) { return &var.as<protocol_t>();} return nullptr; }
+	misc_t& select_misc() { if(get_index() != 4) { clear(); set_index(4); return var.build<misc_t>();} return var.as<misc_t>();}
+	misc_t const* get_misc() const { if(get_index() == 4) { return &var.as<misc_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(radioNetwork_t)];
+		char dummy2[sizeof(transport_t)];
+		char dummy3[sizeof(protocol_t)];
+		char dummy4[sizeof(misc_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+Cell-Size ::= ENUMERATED {verysmall, small, medium, large, ... }
+*/
+
+struct Cell_Size : asn::enumerated<4, 0, true>
+{
+	static constexpr const char* name() {return "Cell-Size";}
+	using parent_t = asn::enumerated<4, 0, true>;
+	typedef enum {
+		verysmall
+		,small
+		,medium
+		,large
+	} index_t;
+
+};
+
+/*
+CellCapacityClassValue ::= INTEGER (1..100, ...)
+*/
+
+struct CellCapacityClassValue : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<1, 100>>;
+	static constexpr const char* name() {return "CellCapacityClassValue";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+CellDeploymentStatusIndicator ::= ENUMERATED {pre-change-notification, ...}
+*/
+
+struct CellDeploymentStatusIndicator : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "CellDeploymentStatusIndicator";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		pre_change_notification
+	} index_t;
+
+};
+
+/*
+ReplacingCellsList-Item ::= SEQUENCE {
+	eCGI			ECGI,
+	...
+}
+*/
+
+struct ReplacingCellsList_Item : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ReplacingCellsList-Item";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct eCGI_t : ECGI
+	{
+		static constexpr const char* name() {return "eCGI_t";}
+		using parent_t = ECGI;
+
+	};
+	eCGI_t& ref_eCGI() {return eCGI;}
+	eCGI_t const& ref_eCGI() const {return eCGI;}
+	template<typename V> void decode(V& v)
+	{
+		v(eCGI);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(eCGI);
+
+	};
+	void clear()
+	{
+		eCGI.clear();
+
+	};
+	private:
+	eCGI_t	eCGI;
+
+};
+/*
+ReplacingCellsList ::= SEQUENCE (SIZE(0.. maxCellineNB)) OF ReplacingCellsList-Item
+*/
+
+struct ReplacingCellsList_elm : ReplacingCellsList_Item
+{
+	static constexpr const char* name() {return "ReplacingCellsList_elm";}
+	using parent_t = ReplacingCellsList_Item;
+
+};
+struct ReplacingCellsList : asn::sequenceof<ReplacingCellsList_elm>
+{
+	static constexpr const char* name() {return "ReplacingCellsList";}
+	using parent_t = asn::sequenceof<ReplacingCellsList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<0,  maxCellineNB >>;
+
+};
+/*
+CellReplacingInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CellReplacingInfo_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CellReplacingInfo ::= SEQUENCE {
+	replacingCellsList				ReplacingCellsList,
+	iE-Extensions					ProtocolExtensionContainer { {CellReplacingInfo-ExtIEs}}	OPTIONAL,
+	...
+}
+*/
+
+struct CellReplacingInfo : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "CellReplacingInfo";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct replacingCellsList_t : ReplacingCellsList
+	{
+		static constexpr const char* name() {return "replacingCellsList_t";}
+		using parent_t = ReplacingCellsList;
+
+	};
+	replacingCellsList_t& ref_replacingCellsList() {return replacingCellsList;}
+	replacingCellsList_t const& ref_replacingCellsList() const {return replacingCellsList;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CellReplacingInfo_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CellReplacingInfo_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(replacingCellsList);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(replacingCellsList);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		replacingCellsList.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	replacingCellsList_t	replacingCellsList;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+CellReportingIndicator ::= ENUMERATED {stop-request, ... }
+*/
+
+struct CellReportingIndicator : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "CellReportingIndicator";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		stop_request
+	} index_t;
+
+};
+
+/*
+CellType-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CellType_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CellType ::= SEQUENCE {
+	cell-Size						Cell-Size,
+	iE-Extensions					ProtocolExtensionContainer { {CellType-ExtIEs}}	OPTIONAL,
+	...
+}
+*/
+
+struct CellType : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "CellType";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct cell_Size_t : Cell_Size
+	{
+		static constexpr const char* name() {return "cell_Size_t";}
+		using parent_t = Cell_Size;
+
+	};
+	cell_Size_t& ref_cell_Size() {return cell_Size;}
+	cell_Size_t const& ref_cell_Size() const {return cell_Size;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CellType_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CellType_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(cell_Size);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(cell_Size);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		cell_Size.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	cell_Size_t	cell_Size;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+CoMPHypothesisSetItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CoMPHypothesisSetItem_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CoMPHypothesisSetItem ::= SEQUENCE {
+	coMPCellID						ECGI,
+	coMPHypothesis					BIT STRING (SIZE(6..4400, ...)),
+	iE-Extensions					ProtocolExtensionContainer { {CoMPHypothesisSetItem-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct CoMPHypothesisSetItem : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "CoMPHypothesisSetItem";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct coMPCellID_t : ECGI
+	{
+		static constexpr const char* name() {return "coMPCellID_t";}
+		using parent_t = ECGI;
+
+	};
+	coMPCellID_t& ref_coMPCellID() {return coMPCellID;}
+	coMPCellID_t const& ref_coMPCellID() const {return coMPCellID;}
+	struct coMPHypothesis_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
+		static constexpr const char* name() {return "coMPHypothesis_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	coMPHypothesis_t& ref_coMPHypothesis() {return coMPHypothesis;}
+	coMPHypothesis_t const& ref_coMPHypothesis() const {return coMPHypothesis;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CoMPHypothesisSetItem_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CoMPHypothesisSetItem_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(coMPCellID);
+		v(coMPHypothesis);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(coMPCellID);
+		v(coMPHypothesis);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		coMPCellID.clear();
+		coMPHypothesis.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	coMPCellID_t	coMPCellID;
+	coMPHypothesis_t	coMPHypothesis;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+CoMPHypothesisSet ::= SEQUENCE (SIZE(1..maxnoofCoMPCells)) OF CoMPHypothesisSetItem
+*/
+
+struct CoMPHypothesisSet_elm : CoMPHypothesisSetItem
+{
+	static constexpr const char* name() {return "CoMPHypothesisSet_elm";}
+	using parent_t = CoMPHypothesisSetItem;
+
+};
+struct CoMPHypothesisSet : asn::sequenceof<CoMPHypothesisSet_elm>
+{
+	static constexpr const char* name() {return "CoMPHypothesisSet";}
+	using parent_t = asn::sequenceof<CoMPHypothesisSet_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofCoMPCells >>;
+
+};
+/*
+CoMPInformationItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CoMPInformationItem_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CoMPInformationItem ::= SEQUENCE (SIZE(1..maxnoofCoMPHypothesisSet)) OF
+	SEQUENCE {
+		coMPHypothesisSet					CoMPHypothesisSet,
+		benefitMetric						BenefitMetric,
+		iE-Extensions						ProtocolExtensionContainer { {CoMPInformationItem-ExtIEs} } OPTIONAL,
+		...
+	}
+*/
+
+struct CoMPInformationItem_elm : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "CoMPInformationItem_elm";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct coMPHypothesisSet_t : CoMPHypothesisSet
+	{
+		static constexpr const char* name() {return "coMPHypothesisSet_t";}
+		using parent_t = CoMPHypothesisSet;
+
+	};
+	coMPHypothesisSet_t& ref_coMPHypothesisSet() {return coMPHypothesisSet;}
+	coMPHypothesisSet_t const& ref_coMPHypothesisSet() const {return coMPHypothesisSet;}
+	struct benefitMetric_t : BenefitMetric
+	{
+		static constexpr const char* name() {return "benefitMetric_t";}
+		using parent_t = BenefitMetric;
+
+	};
+	benefitMetric_t& ref_benefitMetric() {return benefitMetric;}
+	benefitMetric_t const& ref_benefitMetric() const {return benefitMetric;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CoMPInformationItem_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CoMPInformationItem_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(coMPHypothesisSet);
+		v(benefitMetric);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(coMPHypothesisSet);
+		v(benefitMetric);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		coMPHypothesisSet.clear();
+		benefitMetric.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	coMPHypothesisSet_t	coMPHypothesisSet;
+	benefitMetric_t	benefitMetric;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct CoMPInformationItem : asn::sequenceof<CoMPInformationItem_elm>
+{
+	static constexpr const char* name() {return "CoMPInformationItem";}
+	using parent_t = asn::sequenceof<CoMPInformationItem_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofCoMPHypothesisSet >>;
+
+};
+/*
+CoMPInformationStartTime-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CoMPInformationStartTime_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CoMPInformationStartTime ::= SEQUENCE (SIZE(0..1)) OF
+	SEQUENCE {
+		startSFN							INTEGER (0..1023, ...),
+		startSubframeNumber					INTEGER (0..9, ...),
+		iE-Extensions						ProtocolExtensionContainer { {CoMPInformationStartTime-ExtIEs} } OPTIONAL,
+		...
+	}
+*/
+
+struct CoMPInformationStartTime_elm : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "CoMPInformationStartTime_elm";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct startSFN_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 1023>>;
+		static constexpr const char* name() {return "startSFN_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	startSFN_t& ref_startSFN() {return startSFN;}
+	startSFN_t const& ref_startSFN() const {return startSFN;}
+	struct startSubframeNumber_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 9>>;
+		static constexpr const char* name() {return "startSubframeNumber_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	startSubframeNumber_t& ref_startSubframeNumber() {return startSubframeNumber;}
+	startSubframeNumber_t const& ref_startSubframeNumber() const {return startSubframeNumber;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CoMPInformationStartTime_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CoMPInformationStartTime_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(startSFN);
+		v(startSubframeNumber);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(startSFN);
+		v(startSubframeNumber);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		startSFN.clear();
+		startSubframeNumber.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	startSFN_t	startSFN;
+	startSubframeNumber_t	startSubframeNumber;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct CoMPInformationStartTime : asn::sequenceof<CoMPInformationStartTime_elm>
+{
+	static constexpr const char* name() {return "CoMPInformationStartTime";}
+	using parent_t = asn::sequenceof<CoMPInformationStartTime_elm>;
+	using constraint_t = asn::constraints<false,asn::span<0, 1>>;
+
+};
+/*
+CoMPInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CoMPInformation_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CoMPInformation ::= SEQUENCE {
+	coMPInformationItem						CoMPInformationItem,
+	coMPInformationStartTime				CoMPInformationStartTime,
+	iE-Extensions							ProtocolExtensionContainer { {CoMPInformation-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct CoMPInformation : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "CoMPInformation";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct coMPInformationItem_t : CoMPInformationItem
+	{
+		static constexpr const char* name() {return "coMPInformationItem_t";}
+		using parent_t = CoMPInformationItem;
+
+	};
+	coMPInformationItem_t& ref_coMPInformationItem() {return coMPInformationItem;}
+	coMPInformationItem_t const& ref_coMPInformationItem() const {return coMPInformationItem;}
+	struct coMPInformationStartTime_t : CoMPInformationStartTime
+	{
+		static constexpr const char* name() {return "coMPInformationStartTime_t";}
+		using parent_t = CoMPInformationStartTime;
+
+	};
+	coMPInformationStartTime_t& ref_coMPInformationStartTime() {return coMPInformationStartTime;}
+	coMPInformationStartTime_t const& ref_coMPInformationStartTime() const {return coMPInformationStartTime;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CoMPInformation_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CoMPInformation_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(coMPInformationItem);
+		v(coMPInformationStartTime);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(coMPInformationItem);
+		v(coMPInformationStartTime);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		coMPInformationItem.clear();
+		coMPInformationStartTime.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	coMPInformationItem_t	coMPInformationItem;
+	coMPInformationStartTime_t	coMPInformationStartTime;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+CompositeAvailableCapacity-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CompositeAvailableCapacity_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CompositeAvailableCapacity ::= SEQUENCE {
+	cellCapacityClassValue							CellCapacityClassValue				OPTIONAL,
+	capacityValue									CapacityValue,
+	iE-Extensions									ProtocolExtensionContainer { {CompositeAvailableCapacity-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct CompositeAvailableCapacity : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "CompositeAvailableCapacity";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	struct cellCapacityClassValue_t : CellCapacityClassValue
+	{
+		static constexpr const char* name() {return "cellCapacityClassValue_t";}
+		using parent_t = CellCapacityClassValue;
+		static constexpr bool optional = true;
+
+	};
+	cellCapacityClassValue_t& set_cellCapacityClassValue() { cellCapacityClassValue.setpresent(true); return cellCapacityClassValue;}
+	cellCapacityClassValue_t const* get_cellCapacityClassValue() const {return cellCapacityClassValue.is_valid() ? &cellCapacityClassValue : nullptr;}
+	struct capacityValue_t : CapacityValue
+	{
+		static constexpr const char* name() {return "capacityValue_t";}
+		using parent_t = CapacityValue;
+
+	};
+	capacityValue_t& ref_capacityValue() {return capacityValue;}
+	capacityValue_t const& ref_capacityValue() const {return capacityValue;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CompositeAvailableCapacity_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CompositeAvailableCapacity_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(cellCapacityClassValue);
+		v(capacityValue);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(cellCapacityClassValue);
+		v(capacityValue);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		cellCapacityClassValue.clear();
+		capacityValue.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	cellCapacityClassValue_t	cellCapacityClassValue;
+	capacityValue_t	capacityValue;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+CompositeAvailableCapacityGroup-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CompositeAvailableCapacityGroup_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CompositeAvailableCapacityGroup	::= SEQUENCE {
+	dL-CompositeAvailableCapacity					CompositeAvailableCapacity,
+	uL-CompositeAvailableCapacity					CompositeAvailableCapacity,
+	iE-Extensions									ProtocolExtensionContainer { {CompositeAvailableCapacityGroup-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct CompositeAvailableCapacityGroup : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "CompositeAvailableCapacityGroup";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct dL_CompositeAvailableCapacity_t : CompositeAvailableCapacity
+	{
+		static constexpr const char* name() {return "dL_CompositeAvailableCapacity_t";}
+		using parent_t = CompositeAvailableCapacity;
+
+	};
+	dL_CompositeAvailableCapacity_t& ref_dL_CompositeAvailableCapacity() {return dL_CompositeAvailableCapacity;}
+	dL_CompositeAvailableCapacity_t const& ref_dL_CompositeAvailableCapacity() const {return dL_CompositeAvailableCapacity;}
+	struct uL_CompositeAvailableCapacity_t : CompositeAvailableCapacity
+	{
+		static constexpr const char* name() {return "uL_CompositeAvailableCapacity_t";}
+		using parent_t = CompositeAvailableCapacity;
+
+	};
+	uL_CompositeAvailableCapacity_t& ref_uL_CompositeAvailableCapacity() {return uL_CompositeAvailableCapacity;}
+	uL_CompositeAvailableCapacity_t const& ref_uL_CompositeAvailableCapacity() const {return uL_CompositeAvailableCapacity;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CompositeAvailableCapacityGroup_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CompositeAvailableCapacityGroup_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(dL_CompositeAvailableCapacity);
+		v(uL_CompositeAvailableCapacity);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(dL_CompositeAvailableCapacity);
+		v(uL_CompositeAvailableCapacity);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		dL_CompositeAvailableCapacity.clear();
+		uL_CompositeAvailableCapacity.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	dL_CompositeAvailableCapacity_t	dL_CompositeAvailableCapacity;
+	uL_CompositeAvailableCapacity_t	uL_CompositeAvailableCapacity;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+Correlation-ID ::= OCTET STRING (SIZE (4))
+*/
+
+struct Correlation_ID : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<4>>;
+	static constexpr const char* name() {return "Correlation-ID";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+CoverageModification-Item ::= SEQUENCE {
+	eCGI							ECGI,
+	coverageState					INTEGER (0..15, ...),
+	cellDeploymentStatusIndicator	CellDeploymentStatusIndicator			OPTIONAL,
+	cellReplacingInfo				CellReplacingInfo						OPTIONAL,
+-- Included in case the Cell Deployment Status Indicator IE is present
+	...
+}
+*/
+
+struct CoverageModification_Item : asn::sequence<4, 0, true, 2>
+{
+	static constexpr const char* name() {return "CoverageModification-Item";}
+	using parent_t = asn::sequence<4, 0, true, 2>;
+	struct eCGI_t : ECGI
+	{
+		static constexpr const char* name() {return "eCGI_t";}
+		using parent_t = ECGI;
+
+	};
+	eCGI_t& ref_eCGI() {return eCGI;}
+	eCGI_t const& ref_eCGI() const {return eCGI;}
+	struct coverageState_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 15>>;
+		static constexpr const char* name() {return "coverageState_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	coverageState_t& ref_coverageState() {return coverageState;}
+	coverageState_t const& ref_coverageState() const {return coverageState;}
+	struct cellDeploymentStatusIndicator_t : CellDeploymentStatusIndicator
+	{
+		static constexpr const char* name() {return "cellDeploymentStatusIndicator_t";}
+		using parent_t = CellDeploymentStatusIndicator;
+		static constexpr bool optional = true;
+
+	};
+	cellDeploymentStatusIndicator_t& set_cellDeploymentStatusIndicator() { cellDeploymentStatusIndicator.setpresent(true); return cellDeploymentStatusIndicator;}
+	cellDeploymentStatusIndicator_t const* get_cellDeploymentStatusIndicator() const {return cellDeploymentStatusIndicator.is_valid() ? &cellDeploymentStatusIndicator : nullptr;}
+	struct cellReplacingInfo_t : CellReplacingInfo
+	{
+		static constexpr const char* name() {return "cellReplacingInfo_t";}
+		using parent_t = CellReplacingInfo;
+		static constexpr bool optional = true;
+
+	};
+	cellReplacingInfo_t& set_cellReplacingInfo() { cellReplacingInfo.setpresent(true); return cellReplacingInfo;}
+	cellReplacingInfo_t const* get_cellReplacingInfo() const {return cellReplacingInfo.is_valid() ? &cellReplacingInfo : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(eCGI);
+		v(coverageState);
+		v(cellDeploymentStatusIndicator);
+		v(cellReplacingInfo);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(eCGI);
+		v(coverageState);
+		v(cellDeploymentStatusIndicator);
+		v(cellReplacingInfo);
+
+	};
+	void clear()
+	{
+		eCGI.clear();
+		coverageState.clear();
+		cellDeploymentStatusIndicator.clear();
+		cellReplacingInfo.clear();
+
+	};
+	private:
+	eCGI_t	eCGI;
+	coverageState_t	coverageState;
+	cellDeploymentStatusIndicator_t	cellDeploymentStatusIndicator;
+	cellReplacingInfo_t	cellReplacingInfo;
+
+};
+/*
+CoverageModificationList ::= SEQUENCE (SIZE (1..maxCellineNB)) OF CoverageModification-Item
+*/
+
+struct CoverageModificationList_elm : CoverageModification_Item
+{
+	static constexpr const char* name() {return "CoverageModificationList_elm";}
+	using parent_t = CoverageModification_Item;
+
+};
+struct CoverageModificationList : asn::sequenceof<CoverageModificationList_elm>
+{
+	static constexpr const char* name() {return "CoverageModificationList";}
+	using parent_t = asn::sequenceof<CoverageModificationList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+TypeOfError ::= ENUMERATED {
+	not-understood,
+	missing,
+	...
+}
+*/
+
+struct TypeOfError : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "TypeOfError";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		not_understood
+		,missing
+	} index_t;
+
+};
+
+/*
+CriticalityDiagnostics-IE-List-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CriticalityDiagnostics_IE_List_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CriticalityDiagnostics-IE-List ::= SEQUENCE (SIZE (1..maxNrOfErrors)) OF
+	SEQUENCE {
+		iECriticality			Criticality,
+		iE-ID					ProtocolIE-ID,
+		typeOfError				TypeOfError,
+		iE-Extensions			ProtocolExtensionContainer { {CriticalityDiagnostics-IE-List-ExtIEs} } OPTIONAL,
+		...
+}
+*/
+
+struct CriticalityDiagnostics_IE_List_elm : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "CriticalityDiagnostics_IE_List_elm";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct iECriticality_t : Criticality
+	{
+		static constexpr const char* name() {return "iECriticality_t";}
+		using parent_t = Criticality;
+
+	};
+	iECriticality_t& ref_iECriticality() {return iECriticality;}
+	iECriticality_t const& ref_iECriticality() const {return iECriticality;}
+	struct iE_ID_t : ProtocolIE_ID
+	{
+		static constexpr const char* name() {return "iE_ID_t";}
+		using parent_t = ProtocolIE_ID;
+
+	};
+	iE_ID_t& ref_iE_ID() {return iE_ID;}
+	iE_ID_t const& ref_iE_ID() const {return iE_ID;}
+	struct typeOfError_t : TypeOfError
+	{
+		static constexpr const char* name() {return "typeOfError_t";}
+		using parent_t = TypeOfError;
+
+	};
+	typeOfError_t& ref_typeOfError() {return typeOfError;}
+	typeOfError_t const& ref_typeOfError() const {return typeOfError;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CriticalityDiagnostics_IE_List_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CriticalityDiagnostics_IE_List_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(iECriticality);
+		v(iE_ID);
+		v(typeOfError);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(iECriticality);
+		v(iE_ID);
+		v(typeOfError);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		iECriticality.clear();
+		iE_ID.clear();
+		typeOfError.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	iECriticality_t	iECriticality;
+	iE_ID_t	iE_ID;
+	typeOfError_t	typeOfError;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct CriticalityDiagnostics_IE_List : asn::sequenceof<CriticalityDiagnostics_IE_List_elm>
+{
+	static constexpr const char* name() {return "CriticalityDiagnostics-IE-List";}
+	using parent_t = asn::sequenceof<CriticalityDiagnostics_IE_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxNrOfErrors >>;
+
+};
+/*
+CriticalityDiagnostics-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CriticalityDiagnostics_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CriticalityDiagnostics ::= SEQUENCE {
+	procedureCode					ProcedureCode					OPTIONAL,
+	triggeringMessage				TriggeringMessage				OPTIONAL,
+	procedureCriticality			Criticality						OPTIONAL,
+	iEsCriticalityDiagnostics		CriticalityDiagnostics-IE-List	OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {CriticalityDiagnostics-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct CriticalityDiagnostics : asn::sequence<5, 0, true, 5>
+{
+	static constexpr const char* name() {return "CriticalityDiagnostics";}
+	using parent_t = asn::sequence<5, 0, true, 5>;
+	struct procedureCode_t : ProcedureCode
+	{
+		static constexpr const char* name() {return "procedureCode_t";}
+		using parent_t = ProcedureCode;
+		static constexpr bool optional = true;
+
+	};
+	procedureCode_t& set_procedureCode() { procedureCode.setpresent(true); return procedureCode;}
+	procedureCode_t const* get_procedureCode() const {return procedureCode.is_valid() ? &procedureCode : nullptr;}
+	struct triggeringMessage_t : TriggeringMessage
+	{
+		static constexpr const char* name() {return "triggeringMessage_t";}
+		using parent_t = TriggeringMessage;
+		static constexpr bool optional = true;
+
+	};
+	triggeringMessage_t& set_triggeringMessage() { triggeringMessage.setpresent(true); return triggeringMessage;}
+	triggeringMessage_t const* get_triggeringMessage() const {return triggeringMessage.is_valid() ? &triggeringMessage : nullptr;}
+	struct procedureCriticality_t : Criticality
+	{
+		static constexpr const char* name() {return "procedureCriticality_t";}
+		using parent_t = Criticality;
+		static constexpr bool optional = true;
+
+	};
+	procedureCriticality_t& set_procedureCriticality() { procedureCriticality.setpresent(true); return procedureCriticality;}
+	procedureCriticality_t const* get_procedureCriticality() const {return procedureCriticality.is_valid() ? &procedureCriticality : nullptr;}
+	struct iEsCriticalityDiagnostics_t : CriticalityDiagnostics_IE_List
+	{
+		static constexpr const char* name() {return "iEsCriticalityDiagnostics_t";}
+		using parent_t = CriticalityDiagnostics_IE_List;
+		static constexpr bool optional = true;
+
+	};
+	iEsCriticalityDiagnostics_t& set_iEsCriticalityDiagnostics() { iEsCriticalityDiagnostics.setpresent(true); return iEsCriticalityDiagnostics;}
+	iEsCriticalityDiagnostics_t const* get_iEsCriticalityDiagnostics() const {return iEsCriticalityDiagnostics.is_valid() ? &iEsCriticalityDiagnostics : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CriticalityDiagnostics_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CriticalityDiagnostics_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(procedureCode);
+		v(triggeringMessage);
+		v(procedureCriticality);
+		v(iEsCriticalityDiagnostics);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(procedureCode);
+		v(triggeringMessage);
+		v(procedureCriticality);
+		v(iEsCriticalityDiagnostics);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		procedureCode.clear();
+		triggeringMessage.clear();
+		procedureCriticality.clear();
+		iEsCriticalityDiagnostics.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	procedureCode_t	procedureCode;
+	triggeringMessage_t	triggeringMessage;
+	procedureCriticality_t	procedureCriticality;
+	iEsCriticalityDiagnostics_t	iEsCriticalityDiagnostics;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+DL-Forwarding ::= ENUMERATED {
+	dL-forwardingProposed,
+	...
+}
+*/
+
+struct DL_Forwarding : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "DL-Forwarding";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		dL_forwardingProposed
+	} index_t;
+
+};
+
+/*
+DL-GBR-PRB-usage::= INTEGER (0..100)
+*/
+
+struct DL_GBR_PRB_usage : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+	static constexpr const char* name() {return "DL-GBR-PRB-usage";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+DL-Total-PRB-usage::= INTEGER (0..100)
+*/
+
+struct DL_Total_PRB_usage : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+	static constexpr const char* name() {return "DL-Total-PRB-usage";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+DL-non-GBR-PRB-usage::= INTEGER (0..100)
+*/
+
+struct DL_non_GBR_PRB_usage : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+	static constexpr const char* name() {return "DL-non-GBR-PRB-usage";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+DL-scheduling-PDCCH-CCE-usage::= INTEGER (0..100)
+*/
+
+struct DL_scheduling_PDCCH_CCE_usage : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+	static constexpr const char* name() {return "DL-scheduling-PDCCH-CCE-usage";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+DataTrafficResources ::= BIT STRING (SIZE(6..17600))
+*/
+
+struct DataTrafficResources : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::span<6, 17600>>;
+	static constexpr const char* name() {return "DataTrafficResources";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+DLResourceBitmapULandDLSharing ::= DataTrafficResources
+*/
+
+struct DLResourceBitmapULandDLSharing : DataTrafficResources
+{
+	static constexpr const char* name() {return "DLResourceBitmapULandDLSharing";}
+	using parent_t = DataTrafficResources;
+
+};
+/*
+DLResourcesULandDLSharing ::= CHOICE {
+unchanged			NULL,
+	changed				DLResourceBitmapULandDLSharing,
+	...
+}
+*/
+
+struct DLResourcesULandDLSharing : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "DLResourcesULandDLSharing";}
+	using parent_t = asn::choice<2, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 3;}
+	void set_unknown() { set_index(3);  }
+	~DLResourcesULandDLSharing() {clear();}
+	struct unchanged_t : asn::nulltype
+	{
+		static constexpr const char* name() {return "unchanged_t";}
+		using parent_t = asn::nulltype;
+
+	};
+	struct changed_t : DLResourceBitmapULandDLSharing
+	{
+		static constexpr const char* name() {return "changed_t";}
+		using parent_t = DLResourceBitmapULandDLSharing;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<unchanged_t>(); break;
+		case 2: var.destroy<changed_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<unchanged_t>());
+		case 2: set_index(2); return v(var.build<changed_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<unchanged_t>());
+		case 2: return v(var.as<changed_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<unchanged_t>(1);
+		v.template operator()<changed_t>(2);
+
+	}
+	unchanged_t& select_unchanged() { if(get_index() != 1) { clear(); set_index(1); return var.build<unchanged_t>();} return var.as<unchanged_t>();}
+	unchanged_t const* get_unchanged() const { if(get_index() == 1) { return &var.as<unchanged_t>();} return nullptr; }
+	changed_t& select_changed() { if(get_index() != 2) { clear(); set_index(2); return var.build<changed_t>();} return var.as<changed_t>();}
+	changed_t const* get_changed() const { if(get_index() == 2) { return &var.as<changed_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(unchanged_t)];
+		char dummy2[sizeof(changed_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+DRB-ID ::= INTEGER (1..32)
+*/
+
+struct DRB_ID : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<1, 32>>;
+	static constexpr const char* name() {return "DRB-ID";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+ULOnlySharing-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ULOnlySharing_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ULOnlySharing ::= SEQUENCE{
+	uLResourceBitmapULOnlySharing	DataTrafficResources,
+	iE-Extensions					ProtocolExtensionContainer { {ULOnlySharing-ExtIEs} }				OPTIONAL,
+	...
+}
+*/
+
+struct ULOnlySharing : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "ULOnlySharing";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct uLResourceBitmapULOnlySharing_t : DataTrafficResources
+	{
+		static constexpr const char* name() {return "uLResourceBitmapULOnlySharing_t";}
+		using parent_t = DataTrafficResources;
+
+	};
+	uLResourceBitmapULOnlySharing_t& ref_uLResourceBitmapULOnlySharing() {return uLResourceBitmapULOnlySharing;}
+	uLResourceBitmapULOnlySharing_t const& ref_uLResourceBitmapULOnlySharing() const {return uLResourceBitmapULOnlySharing;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ULOnlySharing_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ULOnlySharing_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(uLResourceBitmapULOnlySharing);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(uLResourceBitmapULOnlySharing);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		uLResourceBitmapULOnlySharing.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	uLResourceBitmapULOnlySharing_t	uLResourceBitmapULOnlySharing;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ULResourceBitmapULandDLSharing ::= DataTrafficResources
+*/
+
+struct ULResourceBitmapULandDLSharing : DataTrafficResources
+{
+	static constexpr const char* name() {return "ULResourceBitmapULandDLSharing";}
+	using parent_t = DataTrafficResources;
+
+};
+/*
+ULResourcesULandDLSharing ::= CHOICE {
+	unchanged			NULL,
+	changed				ULResourceBitmapULandDLSharing,
+	...
+}
+*/
+
+struct ULResourcesULandDLSharing : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "ULResourcesULandDLSharing";}
+	using parent_t = asn::choice<2, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 3;}
+	void set_unknown() { set_index(3);  }
+	~ULResourcesULandDLSharing() {clear();}
+	struct unchanged_t : asn::nulltype
+	{
+		static constexpr const char* name() {return "unchanged_t";}
+		using parent_t = asn::nulltype;
+
+	};
+	struct changed_t : ULResourceBitmapULandDLSharing
+	{
+		static constexpr const char* name() {return "changed_t";}
+		using parent_t = ULResourceBitmapULandDLSharing;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<unchanged_t>(); break;
+		case 2: var.destroy<changed_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<unchanged_t>());
+		case 2: set_index(2); return v(var.build<changed_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<unchanged_t>());
+		case 2: return v(var.as<changed_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<unchanged_t>(1);
+		v.template operator()<changed_t>(2);
+
+	}
+	unchanged_t& select_unchanged() { if(get_index() != 1) { clear(); set_index(1); return var.build<unchanged_t>();} return var.as<unchanged_t>();}
+	unchanged_t const* get_unchanged() const { if(get_index() == 1) { return &var.as<unchanged_t>();} return nullptr; }
+	changed_t& select_changed() { if(get_index() != 2) { clear(); set_index(2); return var.build<changed_t>();} return var.as<changed_t>();}
+	changed_t const* get_changed() const { if(get_index() == 2) { return &var.as<changed_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(unchanged_t)];
+		char dummy2[sizeof(changed_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+ULandDLSharing-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ULandDLSharing_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ULandDLSharing ::= SEQUENCE{
+	uLResourcesULandDLSharing				ULResourcesULandDLSharing,
+	dLResourcesULandDLSharing				DLResourcesULandDLSharing,
+	iE-Extensions			ProtocolExtensionContainer { {ULandDLSharing-ExtIEs} }				OPTIONAL,
+	...
+}
+*/
+
+struct ULandDLSharing : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "ULandDLSharing";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct uLResourcesULandDLSharing_t : ULResourcesULandDLSharing
+	{
+		static constexpr const char* name() {return "uLResourcesULandDLSharing_t";}
+		using parent_t = ULResourcesULandDLSharing;
+
+	};
+	uLResourcesULandDLSharing_t& ref_uLResourcesULandDLSharing() {return uLResourcesULandDLSharing;}
+	uLResourcesULandDLSharing_t const& ref_uLResourcesULandDLSharing() const {return uLResourcesULandDLSharing;}
+	struct dLResourcesULandDLSharing_t : DLResourcesULandDLSharing
+	{
+		static constexpr const char* name() {return "dLResourcesULandDLSharing_t";}
+		using parent_t = DLResourcesULandDLSharing;
+
+	};
+	dLResourcesULandDLSharing_t& ref_dLResourcesULandDLSharing() {return dLResourcesULandDLSharing;}
+	dLResourcesULandDLSharing_t const& ref_dLResourcesULandDLSharing() const {return dLResourcesULandDLSharing;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ULandDLSharing_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ULandDLSharing_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(uLResourcesULandDLSharing);
+		v(dLResourcesULandDLSharing);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(uLResourcesULandDLSharing);
+		v(dLResourcesULandDLSharing);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		uLResourcesULandDLSharing.clear();
+		dLResourcesULandDLSharing.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	uLResourcesULandDLSharing_t	uLResourcesULandDLSharing;
+	dLResourcesULandDLSharing_t	dLResourcesULandDLSharing;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+SharedResourceType ::= CHOICE{
+	uLOnlySharing		ULOnlySharing,
+	uLandDLSharing		ULandDLSharing,
+	...
+}
+*/
+
+struct SharedResourceType : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "SharedResourceType";}
+	using parent_t = asn::choice<2, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 3;}
+	void set_unknown() { set_index(3);  }
+	~SharedResourceType() {clear();}
+	struct uLOnlySharing_t : ULOnlySharing
+	{
+		static constexpr const char* name() {return "uLOnlySharing_t";}
+		using parent_t = ULOnlySharing;
+
+	};
+	struct uLandDLSharing_t : ULandDLSharing
+	{
+		static constexpr const char* name() {return "uLandDLSharing_t";}
+		using parent_t = ULandDLSharing;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<uLOnlySharing_t>(); break;
+		case 2: var.destroy<uLandDLSharing_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<uLOnlySharing_t>());
+		case 2: set_index(2); return v(var.build<uLandDLSharing_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<uLOnlySharing_t>());
+		case 2: return v(var.as<uLandDLSharing_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<uLOnlySharing_t>(1);
+		v.template operator()<uLandDLSharing_t>(2);
+
+	}
+	uLOnlySharing_t& select_uLOnlySharing() { if(get_index() != 1) { clear(); set_index(1); return var.build<uLOnlySharing_t>();} return var.as<uLOnlySharing_t>();}
+	uLOnlySharing_t const* get_uLOnlySharing() const { if(get_index() == 1) { return &var.as<uLOnlySharing_t>();} return nullptr; }
+	uLandDLSharing_t& select_uLandDLSharing() { if(get_index() != 2) { clear(); set_index(2); return var.build<uLandDLSharing_t>();} return var.as<uLandDLSharing_t>();}
+	uLandDLSharing_t const* get_uLandDLSharing() const { if(get_index() == 2) { return &var.as<uLandDLSharing_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(uLOnlySharing_t)];
+		char dummy2[sizeof(uLandDLSharing_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+SubframeType ::= ENUMERATED{mbsfn,nonmbsfn,...}
+*/
+
+struct SubframeType : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "SubframeType";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		mbsfn
+		,nonmbsfn
+	} index_t;
+
+};
+
+/*
+ReservedSubframePattern-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ReservedSubframePattern_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ReservedSubframePattern ::= SEQUENCE{
+	subframeType					SubframeType,
+	reservedSubframePattern			BIT STRING (SIZE(10..160)),
+	mBSFNControlRegionLength		INTEGER (0..3),
+	iE-Extensions					ProtocolExtensionContainer { {ReservedSubframePattern-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct ReservedSubframePattern : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "ReservedSubframePattern";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct subframeType_t : SubframeType
+	{
+		static constexpr const char* name() {return "subframeType_t";}
+		using parent_t = SubframeType;
+
+	};
+	subframeType_t& ref_subframeType() {return subframeType;}
+	subframeType_t const& ref_subframeType() const {return subframeType;}
+	struct reservedSubframePattern_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<10, 160>>;
+		static constexpr const char* name() {return "reservedSubframePattern_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	reservedSubframePattern_t& ref_reservedSubframePattern() {return reservedSubframePattern;}
+	reservedSubframePattern_t const& ref_reservedSubframePattern() const {return reservedSubframePattern;}
+	struct mBSFNControlRegionLength_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 3>>;
+		static constexpr const char* name() {return "mBSFNControlRegionLength_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	mBSFNControlRegionLength_t& ref_mBSFNControlRegionLength() {return mBSFNControlRegionLength;}
+	mBSFNControlRegionLength_t const& ref_mBSFNControlRegionLength() const {return mBSFNControlRegionLength;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ReservedSubframePattern_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ReservedSubframePattern_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(subframeType);
+		v(reservedSubframePattern);
+		v(mBSFNControlRegionLength);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(subframeType);
+		v(reservedSubframePattern);
+		v(mBSFNControlRegionLength);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		subframeType.clear();
+		reservedSubframePattern.clear();
+		mBSFNControlRegionLength.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	subframeType_t	subframeType;
+	reservedSubframePattern_t	reservedSubframePattern;
+	mBSFNControlRegionLength_t	mBSFNControlRegionLength;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+DataTrafficResourceIndication-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct DataTrafficResourceIndication_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+DataTrafficResourceIndication ::= SEQUENCE {
+	activationSFN					INTEGER (0..1023),
+	sharedResourceType				SharedResourceType,
+	reservedSubframePattern 		ReservedSubframePattern OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {DataTrafficResourceIndication-ExtIEs} } OPTIONAL,
+...
+}
+*/
+
+struct DataTrafficResourceIndication : asn::sequence<4, 0, true, 2>
+{
+	static constexpr const char* name() {return "DataTrafficResourceIndication";}
+	using parent_t = asn::sequence<4, 0, true, 2>;
+	struct activationSFN_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 1023>>;
+		static constexpr const char* name() {return "activationSFN_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	activationSFN_t& ref_activationSFN() {return activationSFN;}
+	activationSFN_t const& ref_activationSFN() const {return activationSFN;}
+	struct sharedResourceType_t : SharedResourceType
+	{
+		static constexpr const char* name() {return "sharedResourceType_t";}
+		using parent_t = SharedResourceType;
+
+	};
+	sharedResourceType_t& ref_sharedResourceType() {return sharedResourceType;}
+	sharedResourceType_t const& ref_sharedResourceType() const {return sharedResourceType;}
+	struct reservedSubframePattern_t : ReservedSubframePattern
+	{
+		static constexpr const char* name() {return "reservedSubframePattern_t";}
+		using parent_t = ReservedSubframePattern;
+		static constexpr bool optional = true;
+
+	};
+	reservedSubframePattern_t& set_reservedSubframePattern() { reservedSubframePattern.setpresent(true); return reservedSubframePattern;}
+	reservedSubframePattern_t const* get_reservedSubframePattern() const {return reservedSubframePattern.is_valid() ? &reservedSubframePattern : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<DataTrafficResourceIndication_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<DataTrafficResourceIndication_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(activationSFN);
+		v(sharedResourceType);
+		v(reservedSubframePattern);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(activationSFN);
+		v(sharedResourceType);
+		v(reservedSubframePattern);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		activationSFN.clear();
+		sharedResourceType.clear();
+		reservedSubframePattern.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	activationSFN_t	activationSFN;
+	sharedResourceType_t	sharedResourceType;
+	reservedSubframePattern_t	reservedSubframePattern;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+DeactivationIndication::= ENUMERATED {
+	deactivated,
+	...
+}
+*/
+
+struct DeactivationIndication : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "DeactivationIndication";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		deactivated
+	} index_t;
+
+};
+
+/*
+DeliveryStatus-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct DeliveryStatus_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+DeliveryStatus ::= SEQUENCE {
+	highestSuccessDeliveredPDCPSN		INTEGER (0..4095),
+	iE-Extensions		ProtocolExtensionContainer { {DeliveryStatus-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct DeliveryStatus : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "DeliveryStatus";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct highestSuccessDeliveredPDCPSN_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
+		static constexpr const char* name() {return "highestSuccessDeliveredPDCPSN_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	highestSuccessDeliveredPDCPSN_t& ref_highestSuccessDeliveredPDCPSN() {return highestSuccessDeliveredPDCPSN;}
+	highestSuccessDeliveredPDCPSN_t const& ref_highestSuccessDeliveredPDCPSN() const {return highestSuccessDeliveredPDCPSN;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<DeliveryStatus_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<DeliveryStatus_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(highestSuccessDeliveredPDCPSN);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(highestSuccessDeliveredPDCPSN);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		highestSuccessDeliveredPDCPSN.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	highestSuccessDeliveredPDCPSN_t	highestSuccessDeliveredPDCPSN;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+DuplicationActivation::= ENUMERATED {active, inactive, ...}
+*/
+
+struct DuplicationActivation : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "DuplicationActivation";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		active
+		,inactive
+	} index_t;
+
+};
+
+/*
+PA-Values ::= ENUMERATED {
+	dB-6,
+	dB-4dot77,
+	dB-3,
+	dB-1dot77,
+	dB0,
+	dB1,
+	dB2,
+	dB3,
+	...
+}
+*/
+
+struct PA_Values : asn::enumerated<8, 0, true>
+{
+	static constexpr const char* name() {return "PA-Values";}
+	using parent_t = asn::enumerated<8, 0, true>;
+	typedef enum {
+		dB_6
+		,dB_4dot77
+		,dB_3
+		,dB_1dot77
+		,dB0
+		,dB1
+		,dB2
+		,dB3
+	} index_t;
+
+};
+
+/*
+DynamicNAICSInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct DynamicNAICSInformation_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+DynamicNAICSInformation ::= SEQUENCE {
+	transmissionModes					BIT STRING (SIZE(8))												OPTIONAL,
+	pB-information						INTEGER(0..3)														OPTIONAL,
+	pA-list								SEQUENCE (SIZE(0..maxnoofPA)) OF PA-Values,
+	iE-Extensions						ProtocolExtensionContainer { {DynamicNAICSInformation-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct DynamicNAICSInformation : asn::sequence<4, 0, true, 3>
+{
+	static constexpr const char* name() {return "DynamicNAICSInformation";}
+	using parent_t = asn::sequence<4, 0, true, 3>;
+	struct transmissionModes_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<8>>;
+		static constexpr const char* name() {return "transmissionModes_t";}
+		using parent_t = asn::bstring<>;
+		static constexpr bool optional = true;
+
+	};
+
+	transmissionModes_t& set_transmissionModes() { transmissionModes.setpresent(true); return transmissionModes;}
+	transmissionModes_t const* get_transmissionModes() const {return transmissionModes.is_valid() ? &transmissionModes : nullptr;}
+	struct pB_information_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 3>>;
+		static constexpr const char* name() {return "pB_information_t";}
+		using parent_t = asn::integer<>;
+		static constexpr bool optional = true;
+
+	};
+
+	pB_information_t& set_pB_information() { pB_information.setpresent(true); return pB_information;}
+	pB_information_t const* get_pB_information() const {return pB_information.is_valid() ? &pB_information : nullptr;}
+	struct pA_list_t_elm : PA_Values
+	{
+		static constexpr const char* name() {return "pA_list_t_elm";}
+		using parent_t = PA_Values;
+
+	};
+	struct pA_list_t : asn::sequenceof<pA_list_t_elm>
+	{
+		static constexpr const char* name() {return "pA_list_t";}
+		using parent_t = asn::sequenceof<pA_list_t_elm>;
+		using constraint_t = asn::constraints<false,asn::span<0,  maxnoofPA >>;
+
+	};
+	pA_list_t& ref_pA_list() {return pA_list;}
+	pA_list_t const& ref_pA_list() const {return pA_list;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<DynamicNAICSInformation_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<DynamicNAICSInformation_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(transmissionModes);
+		v(pB_information);
+		v(pA_list);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(transmissionModes);
+		v(pB_information);
+		v(pA_list);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		transmissionModes.clear();
+		pB_information.clear();
+		pA_list.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	transmissionModes_t	transmissionModes;
+	pB_information_t	pB_information;
+	pA_list_t	pA_list;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+DynamicDLTransmissionInformation ::= CHOICE {
+	naics-active			DynamicNAICSInformation,
+	naics-inactive			NULL,
+	...
+}
+*/
+
+struct DynamicDLTransmissionInformation : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "DynamicDLTransmissionInformation";}
+	using parent_t = asn::choice<2, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 3;}
+	void set_unknown() { set_index(3);  }
+	~DynamicDLTransmissionInformation() {clear();}
+	struct naics_active_t : DynamicNAICSInformation
+	{
+		static constexpr const char* name() {return "naics_active_t";}
+		using parent_t = DynamicNAICSInformation;
+
+	};
+	struct naics_inactive_t : asn::nulltype
+	{
+		static constexpr const char* name() {return "naics_inactive_t";}
+		using parent_t = asn::nulltype;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<naics_active_t>(); break;
+		case 2: var.destroy<naics_inactive_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<naics_active_t>());
+		case 2: set_index(2); return v(var.build<naics_inactive_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<naics_active_t>());
+		case 2: return v(var.as<naics_inactive_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<naics_active_t>(1);
+		v.template operator()<naics_inactive_t>(2);
+
+	}
+	naics_active_t& select_naics_active() { if(get_index() != 1) { clear(); set_index(1); return var.build<naics_active_t>();} return var.as<naics_active_t>();}
+	naics_active_t const* get_naics_active() const { if(get_index() == 1) { return &var.as<naics_active_t>();} return nullptr; }
+	naics_inactive_t& select_naics_inactive() { if(get_index() != 2) { clear(); set_index(2); return var.build<naics_inactive_t>();} return var.as<naics_inactive_t>();}
+	naics_inactive_t const* get_naics_inactive() const { if(get_index() == 2) { return &var.as<naics_inactive_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(naics_active_t)];
+		char dummy2[sizeof(naics_inactive_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+E-RAB-ID ::= INTEGER (0..15, ...)
+*/
+
+struct E_RAB_ID : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<0, 15>>;
+	static constexpr const char* name() {return "E-RAB-ID";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+E-RAB-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RAB_Item_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+E-RAB-Item ::= SEQUENCE {
+	e-RAB-ID				E-RAB-ID,
+	cause						Cause,
+	iE-Extensions				ProtocolExtensionContainer { {E-RAB-Item-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RAB_Item : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RAB-Item";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct e_RAB_ID_t : E_RAB_ID
+	{
+		static constexpr const char* name() {return "e_RAB_ID_t";}
+		using parent_t = E_RAB_ID;
+
+	};
+	e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
+	e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
+	struct cause_t : Cause
+	{
+		static constexpr const char* name() {return "cause_t";}
+		using parent_t = Cause;
+
+	};
+	cause_t& ref_cause() {return cause;}
+	cause_t const& ref_cause() const {return cause;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RAB_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RAB_Item_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(e_RAB_ID);
+		v(cause);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(cause);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		cause.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	cause_t	cause;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RAB-ItemIEs 	X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RAB-Item	 CRITICALITY ignore 	TYPE E-RAB-Item 	PRESENCE mandatory },
+	...
+}
+*/
+
+struct E_RAB_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_E_RAB_Item() { set(id_E_RAB_Item); type=1;}
+		X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_E_RAB_Item)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RAB_Item);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_E_RAB_Item() { set(ignore); type=1;}
+		X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		E_RAB_Item& select_id_E_RAB_Item() { return set<E_RAB_Item>(1); }
+		E_RAB_Item const* get_id_E_RAB_Item() const { return get<E_RAB_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RAB_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RAB_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RAB_Item()); return true;
+			case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<E_RAB_Item>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(E_RAB_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_E_RAB_Item() { set(mandatory); type=1;}
+		X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(mandatory)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+QCI ::= INTEGER (0..255)
+*/
+
+struct QCI : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 255>>;
+	static constexpr const char* name() {return "QCI";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+ExtendedBitRate	::= INTEGER (10000000001..4000000000000,...)
+*/
+
+struct ExtendedBitRate : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<10000000001, 4000000000000>>;
+	static constexpr const char* name() {return "ExtendedBitRate";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+GBR-QosInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+-- Extension for maximum bitrate > 10Gbps --
+	{ ID id-extended-e-RAB-MaximumBitrateDL		CRITICALITY ignore	EXTENSION ExtendedBitRate	PRESENCE optional}|
+	{ ID id-extended-e-RAB-MaximumBitrateUL		CRITICALITY ignore	EXTENSION ExtendedBitRate	PRESENCE optional}|
+	{ ID id-extended-e-RAB-GuaranteedBitrateDL	CRITICALITY ignore	EXTENSION ExtendedBitRate	PRESENCE optional}|
+	{ ID id-extended-e-RAB-GuaranteedBitrateUL	CRITICALITY ignore	EXTENSION ExtendedBitRate	PRESENCE optional},
+	...
+}
+*/
+
+struct GBR_QosInformation_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_extended_e_RAB_MaximumBitrateDL() { set(id_extended_e_RAB_MaximumBitrateDL); type=1;}
+		void select_id_extended_e_RAB_MaximumBitrateUL() { set(id_extended_e_RAB_MaximumBitrateUL); type=2;}
+		void select_id_extended_e_RAB_GuaranteedBitrateDL() { set(id_extended_e_RAB_GuaranteedBitrateDL); type=3;}
+		void select_id_extended_e_RAB_GuaranteedBitrateUL() { set(id_extended_e_RAB_GuaranteedBitrateUL); type=4;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_extended_e_RAB_MaximumBitrateDL)) { type = 1; return true; }
+			else if(equal(id_extended_e_RAB_MaximumBitrateUL)) { type = 2; return true; }
+			else if(equal(id_extended_e_RAB_GuaranteedBitrateDL)) { type = 3; return true; }
+			else if(equal(id_extended_e_RAB_GuaranteedBitrateUL)) { type = 4; return true; }
+			else { type = 5; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_extended_e_RAB_MaximumBitrateDL);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_extended_e_RAB_MaximumBitrateUL);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_extended_e_RAB_GuaranteedBitrateDL);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_extended_e_RAB_GuaranteedBitrateUL);} return false;
+			case 5: type = 5; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_extended_e_RAB_MaximumBitrateDL() { set(ignore); type=1;}
+		void select_id_extended_e_RAB_MaximumBitrateUL() { set(ignore); type=2;}
+		void select_id_extended_e_RAB_GuaranteedBitrateDL() { set(ignore); type=3;}
+		void select_id_extended_e_RAB_GuaranteedBitrateUL() { set(ignore); type=4;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else if(equal(ignore)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(ignore)) { type = 4; return true; }
+			else { type = 5; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 5: type = 5; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		ExtendedBitRate& select_id_extended_e_RAB_MaximumBitrateDL() { return set<ExtendedBitRate>(1); }
+		ExtendedBitRate const* get_id_extended_e_RAB_MaximumBitrateDL() const { return get<ExtendedBitRate>(1); }
+		ExtendedBitRate& select_id_extended_e_RAB_MaximumBitrateUL() { return set<ExtendedBitRate>(2); }
+		ExtendedBitRate const* get_id_extended_e_RAB_MaximumBitrateUL() const { return get<ExtendedBitRate>(2); }
+		ExtendedBitRate& select_id_extended_e_RAB_GuaranteedBitrateDL() { return set<ExtendedBitRate>(3); }
+		ExtendedBitRate const* get_id_extended_e_RAB_GuaranteedBitrateDL() const { return get<ExtendedBitRate>(3); }
+		ExtendedBitRate& select_id_extended_e_RAB_GuaranteedBitrateUL() { return set<ExtendedBitRate>(4); }
+		ExtendedBitRate const* get_id_extended_e_RAB_GuaranteedBitrateUL() const { return get<ExtendedBitRate>(4); }
+		bool is_unknown() const { return type == 5; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ExtendedBitRate>(); break;
+			case 2: var.destroy<ExtendedBitRate>(); break;
+			case 3: var.destroy<ExtendedBitRate>(); break;
+			case 4: var.destroy<ExtendedBitRate>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ExtendedBitRate>(1);
+			v.template operator()<ExtendedBitRate>(2);
+			v.template operator()<ExtendedBitRate>(3);
+			v.template operator()<ExtendedBitRate>(4);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_extended_e_RAB_MaximumBitrateDL()); return true;
+			case 2: v(select_id_extended_e_RAB_MaximumBitrateUL()); return true;
+			case 3: v(select_id_extended_e_RAB_GuaranteedBitrateDL()); return true;
+			case 4: v(select_id_extended_e_RAB_GuaranteedBitrateUL()); return true;
+			case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<ExtendedBitRate>()); return true;
+			case 2: v(var.as<ExtendedBitRate>()); return true;
+			case 3: v(var.as<ExtendedBitRate>()); return true;
+			case 4: v(var.as<ExtendedBitRate>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(ExtendedBitRate)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_extended_e_RAB_MaximumBitrateDL() { set(optional); type=1;}
+		void select_id_extended_e_RAB_MaximumBitrateUL() { set(optional); type=2;}
+		void select_id_extended_e_RAB_GuaranteedBitrateDL() { set(optional); type=3;}
+		void select_id_extended_e_RAB_GuaranteedBitrateUL() { set(optional); type=4;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else if(equal(optional)) { type = 2; return true; }
+			else if(equal(optional)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else { type = 5; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
+			case 5: type = 5; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+GBR-QosInformation ::= SEQUENCE {
+	e-RAB-MaximumBitrateDL			BitRate,
+	e-RAB-MaximumBitrateUL			BitRate,
+	e-RAB-GuaranteedBitrateDL		BitRate,
+	e-RAB-GuaranteedBitrateUL		BitRate,
+	iE-Extensions					ProtocolExtensionContainer { {GBR-QosInformation-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct GBR_QosInformation : asn::sequence<5, 0, true, 1>
+{
+	static constexpr const char* name() {return "GBR-QosInformation";}
+	using parent_t = asn::sequence<5, 0, true, 1>;
+	struct e_RAB_MaximumBitrateDL_t : BitRate
+	{
+		static constexpr const char* name() {return "e_RAB_MaximumBitrateDL_t";}
+		using parent_t = BitRate;
+
+	};
+	e_RAB_MaximumBitrateDL_t& ref_e_RAB_MaximumBitrateDL() {return e_RAB_MaximumBitrateDL;}
+	e_RAB_MaximumBitrateDL_t const& ref_e_RAB_MaximumBitrateDL() const {return e_RAB_MaximumBitrateDL;}
+	struct e_RAB_MaximumBitrateUL_t : BitRate
+	{
+		static constexpr const char* name() {return "e_RAB_MaximumBitrateUL_t";}
+		using parent_t = BitRate;
+
+	};
+	e_RAB_MaximumBitrateUL_t& ref_e_RAB_MaximumBitrateUL() {return e_RAB_MaximumBitrateUL;}
+	e_RAB_MaximumBitrateUL_t const& ref_e_RAB_MaximumBitrateUL() const {return e_RAB_MaximumBitrateUL;}
+	struct e_RAB_GuaranteedBitrateDL_t : BitRate
+	{
+		static constexpr const char* name() {return "e_RAB_GuaranteedBitrateDL_t";}
+		using parent_t = BitRate;
+
+	};
+	e_RAB_GuaranteedBitrateDL_t& ref_e_RAB_GuaranteedBitrateDL() {return e_RAB_GuaranteedBitrateDL;}
+	e_RAB_GuaranteedBitrateDL_t const& ref_e_RAB_GuaranteedBitrateDL() const {return e_RAB_GuaranteedBitrateDL;}
+	struct e_RAB_GuaranteedBitrateUL_t : BitRate
+	{
+		static constexpr const char* name() {return "e_RAB_GuaranteedBitrateUL_t";}
+		using parent_t = BitRate;
+
+	};
+	e_RAB_GuaranteedBitrateUL_t& ref_e_RAB_GuaranteedBitrateUL() {return e_RAB_GuaranteedBitrateUL;}
+	e_RAB_GuaranteedBitrateUL_t const& ref_e_RAB_GuaranteedBitrateUL() const {return e_RAB_GuaranteedBitrateUL;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<GBR_QosInformation_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<GBR_QosInformation_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(e_RAB_MaximumBitrateDL);
+		v(e_RAB_MaximumBitrateUL);
+		v(e_RAB_GuaranteedBitrateDL);
+		v(e_RAB_GuaranteedBitrateUL);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_MaximumBitrateDL);
+		v(e_RAB_MaximumBitrateUL);
+		v(e_RAB_GuaranteedBitrateDL);
+		v(e_RAB_GuaranteedBitrateUL);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_MaximumBitrateDL.clear();
+		e_RAB_MaximumBitrateUL.clear();
+		e_RAB_GuaranteedBitrateDL.clear();
+		e_RAB_GuaranteedBitrateUL.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_MaximumBitrateDL_t	e_RAB_MaximumBitrateDL;
+	e_RAB_MaximumBitrateUL_t	e_RAB_MaximumBitrateUL;
+	e_RAB_GuaranteedBitrateDL_t	e_RAB_GuaranteedBitrateDL;
+	e_RAB_GuaranteedBitrateUL_t	e_RAB_GuaranteedBitrateUL;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+Packet-LossRate	::= INTEGER(0..1000)
+*/
+
+struct Packet_LossRate : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 1000>>;
+	static constexpr const char* name() {return "Packet-LossRate";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+E-RAB-Level-QoS-Parameters-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+-- Extended for introduction of downlink and uplink packet loss rate for enhanced Voice performance –
+	{ ID id-DownlinkPacketLossRate			CRITICALITY ignore	EXTENSION Packet-LossRate		PRESENCE optional}|
+	{ ID id-UplinkPacketLossRate			CRITICALITY ignore	EXTENSION Packet-LossRate		PRESENCE optional},
+	...
+}
+*/
+
+struct E_RAB_Level_QoS_Parameters_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_DownlinkPacketLossRate() { set(id_DownlinkPacketLossRate); type=1;}
+		void select_id_UplinkPacketLossRate() { set(id_UplinkPacketLossRate); type=2;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_DownlinkPacketLossRate)) { type = 1; return true; }
+			else if(equal(id_UplinkPacketLossRate)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_DownlinkPacketLossRate);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_UplinkPacketLossRate);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_DownlinkPacketLossRate() { set(ignore); type=1;}
+		void select_id_UplinkPacketLossRate() { set(ignore); type=2;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else if(equal(ignore)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		Packet_LossRate& select_id_DownlinkPacketLossRate() { return set<Packet_LossRate>(1); }
+		Packet_LossRate const* get_id_DownlinkPacketLossRate() const { return get<Packet_LossRate>(1); }
+		Packet_LossRate& select_id_UplinkPacketLossRate() { return set<Packet_LossRate>(2); }
+		Packet_LossRate const* get_id_UplinkPacketLossRate() const { return get<Packet_LossRate>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Packet_LossRate>(); break;
+			case 2: var.destroy<Packet_LossRate>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Packet_LossRate>(1);
+			v.template operator()<Packet_LossRate>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_DownlinkPacketLossRate()); return true;
+			case 2: v(select_id_UplinkPacketLossRate()); return true;
+			case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<Packet_LossRate>()); return true;
+			case 2: v(var.as<Packet_LossRate>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(Packet_LossRate)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_DownlinkPacketLossRate() { set(optional); type=1;}
+		void select_id_UplinkPacketLossRate() { set(optional); type=2;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else if(equal(optional)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+E-RAB-Level-QoS-Parameters ::= SEQUENCE {
+	qCI								QCI,
+	allocationAndRetentionPriority	AllocationAndRetentionPriority,
+	gbrQosInformation				GBR-QosInformation													OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RAB-Level-QoS-Parameters-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RAB_Level_QoS_Parameters : asn::sequence<4, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RAB-Level-QoS-Parameters";}
+	using parent_t = asn::sequence<4, 0, true, 2>;
+	struct qCI_t : QCI
+	{
+		static constexpr const char* name() {return "qCI_t";}
+		using parent_t = QCI;
+
+	};
+	qCI_t& ref_qCI() {return qCI;}
+	qCI_t const& ref_qCI() const {return qCI;}
+	struct allocationAndRetentionPriority_t : AllocationAndRetentionPriority
+	{
+		static constexpr const char* name() {return "allocationAndRetentionPriority_t";}
+		using parent_t = AllocationAndRetentionPriority;
+
+	};
+	allocationAndRetentionPriority_t& ref_allocationAndRetentionPriority() {return allocationAndRetentionPriority;}
+	allocationAndRetentionPriority_t const& ref_allocationAndRetentionPriority() const {return allocationAndRetentionPriority;}
+	struct gbrQosInformation_t : GBR_QosInformation
+	{
+		static constexpr const char* name() {return "gbrQosInformation_t";}
+		using parent_t = GBR_QosInformation;
+		static constexpr bool optional = true;
+
+	};
+	gbrQosInformation_t& set_gbrQosInformation() { gbrQosInformation.setpresent(true); return gbrQosInformation;}
+	gbrQosInformation_t const* get_gbrQosInformation() const {return gbrQosInformation.is_valid() ? &gbrQosInformation : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RAB_Level_QoS_Parameters_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RAB_Level_QoS_Parameters_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(qCI);
+		v(allocationAndRetentionPriority);
+		v(gbrQosInformation);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(qCI);
+		v(allocationAndRetentionPriority);
+		v(gbrQosInformation);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		qCI.clear();
+		allocationAndRetentionPriority.clear();
+		gbrQosInformation.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	qCI_t	qCI;
+	allocationAndRetentionPriority_t	allocationAndRetentionPriority;
+	gbrQosInformation_t	gbrQosInformation;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RAB-List ::= SEQUENCE (SIZE(1.. maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RAB-ItemIEs} }
+*/
+
+struct E_RAB_List_elm : ProtocolIE_Single_Container<E_RAB_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RAB_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RAB_ItemIEs>;
+
+};
+struct E_RAB_List : asn::sequenceof<E_RAB_List_elm>
+{
+	static constexpr const char* name() {return "E-RAB-List";}
+	using parent_t = asn::sequenceof<E_RAB_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABUsageReport-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABUsageReport_Item_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+E-RABUsageReport-Item ::= SEQUENCE {
+	startTimeStamp				OCTET STRING (SIZE(4)),
+	endTimeStamp					OCTET STRING (SIZE(4)),
+	usageCountUL					INTEGER (0..4294967295),
+	usageCountDL					INTEGER (0..4294967295),
+	iE-Extensions				ProtocolExtensionContainer { {E-RABUsageReport-Item-ExtIEs} } OPTIONAL,
+...
+}
+*/
+
+struct E_RABUsageReport_Item : asn::sequence<5, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABUsageReport-Item";}
+	using parent_t = asn::sequence<5, 0, true, 1>;
+	struct startTimeStamp_t : asn::ostring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<4>>;
+		static constexpr const char* name() {return "startTimeStamp_t";}
+		using parent_t = asn::ostring<>;
+
+	};
+
+	startTimeStamp_t& ref_startTimeStamp() {return startTimeStamp;}
+	startTimeStamp_t const& ref_startTimeStamp() const {return startTimeStamp;}
+	struct endTimeStamp_t : asn::ostring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<4>>;
+		static constexpr const char* name() {return "endTimeStamp_t";}
+		using parent_t = asn::ostring<>;
+
+	};
+
+	endTimeStamp_t& ref_endTimeStamp() {return endTimeStamp;}
+	endTimeStamp_t const& ref_endTimeStamp() const {return endTimeStamp;}
+	struct usageCountUL_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
+		static constexpr const char* name() {return "usageCountUL_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	usageCountUL_t& ref_usageCountUL() {return usageCountUL;}
+	usageCountUL_t const& ref_usageCountUL() const {return usageCountUL;}
+	struct usageCountDL_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
+		static constexpr const char* name() {return "usageCountDL_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	usageCountDL_t& ref_usageCountDL() {return usageCountDL;}
+	usageCountDL_t const& ref_usageCountDL() const {return usageCountDL;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABUsageReport_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABUsageReport_Item_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(startTimeStamp);
+		v(endTimeStamp);
+		v(usageCountUL);
+		v(usageCountDL);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(startTimeStamp);
+		v(endTimeStamp);
+		v(usageCountUL);
+		v(usageCountDL);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		startTimeStamp.clear();
+		endTimeStamp.clear();
+		usageCountUL.clear();
+		usageCountDL.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	startTimeStamp_t	startTimeStamp;
+	endTimeStamp_t	endTimeStamp;
+	usageCountUL_t	usageCountUL;
+	usageCountDL_t	usageCountDL;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABUsageReport-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABUsageReport-Item	 CRITICALITY ignore 	TYPE E-RABUsageReport-Item 	PRESENCE mandatory },
+	...
+}
+*/
+
+struct E_RABUsageReport_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_E_RABUsageReport_Item() { set(id_E_RABUsageReport_Item); type=1;}
+		X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_E_RABUsageReport_Item)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABUsageReport_Item);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_E_RABUsageReport_Item() { set(ignore); type=1;}
+		X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		E_RABUsageReport_Item& select_id_E_RABUsageReport_Item() { return set<E_RABUsageReport_Item>(1); }
+		E_RABUsageReport_Item const* get_id_E_RABUsageReport_Item() const { return get<E_RABUsageReport_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABUsageReport_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABUsageReport_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABUsageReport_Item()); return true;
+			case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<E_RABUsageReport_Item>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(E_RABUsageReport_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_E_RABUsageReport_Item() { set(mandatory); type=1;}
+		X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(mandatory)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+E-RABUsageReportList ::= SEQUENCE (SIZE(1..maxnooftimeperiods)) OF ProtocolIE-Single-Container { {E-RABUsageReport-ItemIEs} }
+*/
+
+struct E_RABUsageReportList_elm : ProtocolIE_Single_Container<E_RABUsageReport_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABUsageReportList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABUsageReport_ItemIEs>;
+
+};
+struct E_RABUsageReportList : asn::sequenceof<E_RABUsageReportList_elm>
+{
+	static constexpr const char* name() {return "E-RABUsageReportList";}
+	using parent_t = asn::sequenceof<E_RABUsageReportList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnooftimeperiods >>;
+
+};
+/*
+EARFCN ::= INTEGER (0..maxEARFCN)
+*/
+
+struct EARFCN : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0,  maxEARFCN >>;
+	static constexpr const char* name() {return "EARFCN";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+EARFCNExtension ::= INTEGER(maxEARFCNPlusOne..newmaxEARFCN, ...)
+*/
+
+struct EARFCNExtension : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span< maxEARFCNPlusOne ,  newmaxEARFCN >>;
+	static constexpr const char* name() {return "EARFCNExtension";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+EN-DC-ResourceConfigurationExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct EN_DC_ResourceConfigurationExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+EN-DC-ResourceConfiguration ::= SEQUENCE {
+	pDCPatSgNB		ENUMERATED {present, not-present, ...},
+	mCGresources	ENUMERATED {present, not-present, ...},
+	sCGresources	ENUMERATED {present, not-present, ...},
+	iE-Extensions					ProtocolExtensionContainer { {EN-DC-ResourceConfigurationExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct EN_DC_ResourceConfiguration : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "EN-DC-ResourceConfiguration";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct pDCPatSgNB_t : asn::enumerated<2, 0, true>
+	{
+		static constexpr const char* name() {return "pDCPatSgNB_t";}
+		using parent_t = asn::enumerated<2, 0, true>;
+		typedef enum {
+			present
+			,not_present
+		} index_t;
+
+	};
+
+	pDCPatSgNB_t& ref_pDCPatSgNB() {return pDCPatSgNB;}
+	pDCPatSgNB_t const& ref_pDCPatSgNB() const {return pDCPatSgNB;}
+	struct mCGresources_t : asn::enumerated<2, 0, true>
+	{
+		static constexpr const char* name() {return "mCGresources_t";}
+		using parent_t = asn::enumerated<2, 0, true>;
+		typedef enum {
+			present
+			,not_present
+		} index_t;
+
+	};
+
+	mCGresources_t& ref_mCGresources() {return mCGresources;}
+	mCGresources_t const& ref_mCGresources() const {return mCGresources;}
+	struct sCGresources_t : asn::enumerated<2, 0, true>
+	{
+		static constexpr const char* name() {return "sCGresources_t";}
+		using parent_t = asn::enumerated<2, 0, true>;
+		typedef enum {
+			present
+			,not_present
+		} index_t;
+
+	};
+
+	sCGresources_t& ref_sCGresources() {return sCGresources;}
+	sCGresources_t const& ref_sCGresources() const {return sCGresources;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<EN_DC_ResourceConfigurationExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<EN_DC_ResourceConfigurationExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(pDCPatSgNB);
+		v(mCGresources);
+		v(sCGresources);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(pDCPatSgNB);
+		v(mCGresources);
+		v(sCGresources);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		pDCPatSgNB.clear();
+		mCGresources.clear();
+		sCGresources.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	pDCPatSgNB_t	pDCPatSgNB;
+	mCGresources_t	mCGresources;
+	sCGresources_t	sCGresources;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ENB-ID ::= CHOICE {
+	macro-eNB-ID	BIT STRING (SIZE (20)),
+	home-eNB-ID		BIT STRING (SIZE (28)),
+	... ,
+	short-Macro-eNB-ID		BIT STRING (SIZE(18)),
+	long-Macro-eNB-ID		BIT STRING (SIZE(21))
+}
+*/
+
+struct ENB_ID : asn::choice<4, 2, true>
+{
+	static constexpr const char* name() {return "ENB-ID";}
+	using parent_t = asn::choice<4, 2, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 5;}
+	void set_unknown() { set_index(5);  }
+	~ENB_ID() {clear();}
+	struct macro_eNB_ID_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<20>>;
+		static constexpr const char* name() {return "macro_eNB_ID_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	struct home_eNB_ID_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<28>>;
+		static constexpr const char* name() {return "home_eNB_ID_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	struct short_Macro_eNB_ID_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<18>>;
+		static constexpr const char* name() {return "short_Macro_eNB_ID_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	struct long_Macro_eNB_ID_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<21>>;
+		static constexpr const char* name() {return "long_Macro_eNB_ID_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<macro_eNB_ID_t>(); break;
+		case 2: var.destroy<home_eNB_ID_t>(); break;
+		case 3: var.destroy<short_Macro_eNB_ID_t>(); break;
+		case 4: var.destroy<long_Macro_eNB_ID_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<macro_eNB_ID_t>());
+		case 2: set_index(2); return v(var.build<home_eNB_ID_t>());
+		case 3: set_index(3); return v(var.build<short_Macro_eNB_ID_t>());
+		case 4: set_index(4); return v(var.build<long_Macro_eNB_ID_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<macro_eNB_ID_t>());
+		case 2: return v(var.as<home_eNB_ID_t>());
+		case 3: return v(var.as<short_Macro_eNB_ID_t>());
+		case 4: return v(var.as<long_Macro_eNB_ID_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<macro_eNB_ID_t>(1);
+		v.template operator()<home_eNB_ID_t>(2);
+		v.template operator()<short_Macro_eNB_ID_t>(3);
+		v.template operator()<long_Macro_eNB_ID_t>(4);
+
+	}
+	macro_eNB_ID_t& select_macro_eNB_ID() { if(get_index() != 1) { clear(); set_index(1); return var.build<macro_eNB_ID_t>();} return var.as<macro_eNB_ID_t>();}
+	macro_eNB_ID_t const* get_macro_eNB_ID() const { if(get_index() == 1) { return &var.as<macro_eNB_ID_t>();} return nullptr; }
+	home_eNB_ID_t& select_home_eNB_ID() { if(get_index() != 2) { clear(); set_index(2); return var.build<home_eNB_ID_t>();} return var.as<home_eNB_ID_t>();}
+	home_eNB_ID_t const* get_home_eNB_ID() const { if(get_index() == 2) { return &var.as<home_eNB_ID_t>();} return nullptr; }
+	short_Macro_eNB_ID_t& select_short_Macro_eNB_ID() { if(get_index() != 3) { clear(); set_index(3); return var.build<short_Macro_eNB_ID_t>();} return var.as<short_Macro_eNB_ID_t>();}
+	short_Macro_eNB_ID_t const* get_short_Macro_eNB_ID() const { if(get_index() == 3) { return &var.as<short_Macro_eNB_ID_t>();} return nullptr; }
+	long_Macro_eNB_ID_t& select_long_Macro_eNB_ID() { if(get_index() != 4) { clear(); set_index(4); return var.build<long_Macro_eNB_ID_t>();} return var.as<long_Macro_eNB_ID_t>();}
+	long_Macro_eNB_ID_t const* get_long_Macro_eNB_ID() const { if(get_index() == 4) { return &var.as<long_Macro_eNB_ID_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(macro_eNB_ID_t)];
+		char dummy2[sizeof(home_eNB_ID_t)];
+		char dummy3[sizeof(short_Macro_eNB_ID_t)];
+		char dummy4[sizeof(long_Macro_eNB_ID_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+EPLMNs ::= SEQUENCE (SIZE(1..maxnoofEPLMNs)) OF PLMN-Identity
+*/
+
+struct EPLMNs_elm : PLMN_Identity
+{
+	static constexpr const char* name() {return "EPLMNs_elm";}
+	using parent_t = PLMN_Identity;
+
+};
+struct EPLMNs : asn::sequenceof<EPLMNs_elm>
+{
+	static constexpr const char* name() {return "EPLMNs";}
+	using parent_t = asn::sequenceof<EPLMNs_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofEPLMNs >>;
+
+};
+/*
+UserPlaneTrafficActivityReport ::= ENUMERATED {inactive, re-activated, ...}
+*/
+
+struct UserPlaneTrafficActivityReport : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "UserPlaneTrafficActivityReport";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		inactive
+		,re_activated
+	} index_t;
+
+};
+
+/*
+ERABActivityNotifyItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ERABActivityNotifyItem_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ERABActivityNotifyItem ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	activityReport					UserPlaneTrafficActivityReport,
+	iE-Extensions					ProtocolExtensionContainer { {ERABActivityNotifyItem-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct ERABActivityNotifyItem : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "ERABActivityNotifyItem";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct e_RAB_ID_t : E_RAB_ID
+	{
+		static constexpr const char* name() {return "e_RAB_ID_t";}
+		using parent_t = E_RAB_ID;
+
+	};
+	e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
+	e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
+	struct activityReport_t : UserPlaneTrafficActivityReport
+	{
+		static constexpr const char* name() {return "activityReport_t";}
+		using parent_t = UserPlaneTrafficActivityReport;
+
+	};
+	activityReport_t& ref_activityReport() {return activityReport;}
+	activityReport_t const& ref_activityReport() const {return activityReport;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ERABActivityNotifyItem_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ERABActivityNotifyItem_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(e_RAB_ID);
+		v(activityReport);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(activityReport);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		activityReport.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	activityReport_t	activityReport;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ERABActivityNotifyItemList ::= SEQUENCE (SIZE (0..maxnoofBearers)) OF ERABActivityNotifyItem
+*/
+
+struct ERABActivityNotifyItemList_elm : ERABActivityNotifyItem
+{
+	static constexpr const char* name() {return "ERABActivityNotifyItemList_elm";}
+	using parent_t = ERABActivityNotifyItem;
+
+};
+struct ERABActivityNotifyItemList : asn::sequenceof<ERABActivityNotifyItemList_elm>
+{
+	static constexpr const char* name() {return "ERABActivityNotifyItemList";}
+	using parent_t = asn::sequenceof<ERABActivityNotifyItemList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<0,  maxnoofBearers >>;
+
+};
+/*
+Transmission-Bandwidth ::= ENUMERATED {
+		bw6,
+	 	bw15,
+		bw25,
+	 	bw50,
+		bw75,
+		bw100,
+		...,
+		bw1
+}
+*/
+
+struct Transmission_Bandwidth : asn::enumerated<7, 1, true>
+{
+	static constexpr const char* name() {return "Transmission-Bandwidth";}
+	using parent_t = asn::enumerated<7, 1, true>;
+	typedef enum {
+		bw6
+		,bw15
+		,bw25
+		,bw50
+		,bw75
+		,bw100
+		,bw1
+	} index_t;
+
+};
+
+/*
+OffsetOfNbiotChannelNumberToEARFCN ::= ENUMERATED {
+		minusTen,
+		minusNine,
+		minusEight,
+		minusSeven,
+		minusSix,
+		minusFive,
+		minusFour,
+		minusThree,
+		minusTwo,
+		minusOne,
+		minusZeroDotFive,
+		zero,
+		one,
+		two,
+		three,
+		four,
+		five,
+		six,
+		seven,
+		eight,
+		nine,
+		...
+}
+*/
+
+struct OffsetOfNbiotChannelNumberToEARFCN : asn::enumerated<21, 0, true>
+{
+	static constexpr const char* name() {return "OffsetOfNbiotChannelNumberToEARFCN";}
+	using parent_t = asn::enumerated<21, 0, true>;
+	typedef enum {
+		minusTen
+		,minusNine
+		,minusEight
+		,minusSeven
+		,minusSix
+		,minusFive
+		,minusFour
+		,minusThree
+		,minusTwo
+		,minusOne
+		,minusZeroDotFive
+		,zero
+		,one
+		,two
+		,three
+		,four
+		,five
+		,six
+		,seven
+		,eight
+		,nine
+	} index_t;
+
+};
+
+/*
+NRS-NSSS-PowerOffset ::= ENUMERATED { minusThree, zero, three, ...}
+*/
+
+struct NRS_NSSS_PowerOffset : asn::enumerated<3, 0, true>
+{
+	static constexpr const char* name() {return "NRS-NSSS-PowerOffset";}
+	using parent_t = asn::enumerated<3, 0, true>;
+	typedef enum {
+		minusThree
+		,zero
+		,three
+	} index_t;
+
+};
+
+/*
+NSSS-NumOccasionDifferentPrecoder ::= ENUMERATED { two, four, eight, ...}
+*/
+
+struct NSSS_NumOccasionDifferentPrecoder : asn::enumerated<3, 0, true>
+{
+	static constexpr const char* name() {return "NSSS-NumOccasionDifferentPrecoder";}
+	using parent_t = asn::enumerated<3, 0, true>;
+	typedef enum {
+		two
+		,four
+		,eight
+	} index_t;
+
+};
+
+/*
+FDD-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-UL-EARFCNExtension						CRITICALITY reject	EXTENSION EARFCNExtension									PRESENCE optional}|
+	{ ID id-DL-EARFCNExtension						CRITICALITY reject	EXTENSION EARFCNExtension									PRESENCE optional}|
+	{ ID id-OffsetOfNbiotChannelNumberToDL-EARFCN	CRITICALITY reject	EXTENSION OffsetOfNbiotChannelNumberToEARFCN		PRESENCE optional}|
+	{ ID id-OffsetOfNbiotChannelNumberToUL-EARFCN	CRITICALITY reject	EXTENSION OffsetOfNbiotChannelNumberToEARFCN		PRESENCE optional}|
+	{ ID id-NRS-NSSS-PowerOffset					CRITICALITY ignore	EXTENSION NRS-NSSS-PowerOffset							PRESENCE optional}|
+	{ ID id-NSSS-NumOccasionDifferentPrecoder		CRITICALITY ignore	EXTENSION NSSS-NumOccasionDifferentPrecoder			PRESENCE optional},
+	...
+}
+*/
+
+struct FDD_Info_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_UL_EARFCNExtension() { set(id_UL_EARFCNExtension); type=1;}
+		void select_id_DL_EARFCNExtension() { set(id_DL_EARFCNExtension); type=2;}
+		void select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { set(id_OffsetOfNbiotChannelNumberToDL_EARFCN); type=3;}
+		void select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { set(id_OffsetOfNbiotChannelNumberToUL_EARFCN); type=4;}
+		void select_id_NRS_NSSS_PowerOffset() { set(id_NRS_NSSS_PowerOffset); type=5;}
+		void select_id_NSSS_NumOccasionDifferentPrecoder() { set(id_NSSS_NumOccasionDifferentPrecoder); type=6;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_UL_EARFCNExtension)) { type = 1; return true; }
+			else if(equal(id_DL_EARFCNExtension)) { type = 2; return true; }
+			else if(equal(id_OffsetOfNbiotChannelNumberToDL_EARFCN)) { type = 3; return true; }
+			else if(equal(id_OffsetOfNbiotChannelNumberToUL_EARFCN)) { type = 4; return true; }
+			else if(equal(id_NRS_NSSS_PowerOffset)) { type = 5; return true; }
+			else if(equal(id_NSSS_NumOccasionDifferentPrecoder)) { type = 6; return true; }
+			else { type = 7; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_UL_EARFCNExtension);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_DL_EARFCNExtension);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_OffsetOfNbiotChannelNumberToDL_EARFCN);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_OffsetOfNbiotChannelNumberToUL_EARFCN);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_NRS_NSSS_PowerOffset);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_NSSS_NumOccasionDifferentPrecoder);} return false;
+			case 7: type = 7; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_UL_EARFCNExtension() { set(reject); type=1;}
+		void select_id_DL_EARFCNExtension() { set(reject); type=2;}
+		void select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { set(reject); type=3;}
+		void select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { set(reject); type=4;}
+		void select_id_NRS_NSSS_PowerOffset() { set(ignore); type=5;}
+		void select_id_NSSS_NumOccasionDifferentPrecoder() { set(ignore); type=6;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(reject)) { type = 1; return true; }
+			else if(equal(reject)) { type = 2; return true; }
+			else if(equal(reject)) { type = 3; return true; }
+			else if(equal(reject)) { type = 4; return true; }
+			else if(equal(ignore)) { type = 5; return true; }
+			else if(equal(ignore)) { type = 6; return true; }
+			else { type = 7; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 7: type = 7; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		EARFCNExtension& select_id_UL_EARFCNExtension() { return set<EARFCNExtension>(1); }
+		EARFCNExtension const* get_id_UL_EARFCNExtension() const { return get<EARFCNExtension>(1); }
+		EARFCNExtension& select_id_DL_EARFCNExtension() { return set<EARFCNExtension>(2); }
+		EARFCNExtension const* get_id_DL_EARFCNExtension() const { return get<EARFCNExtension>(2); }
+		OffsetOfNbiotChannelNumberToEARFCN& select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { return set<OffsetOfNbiotChannelNumberToEARFCN>(3); }
+		OffsetOfNbiotChannelNumberToEARFCN const* get_id_OffsetOfNbiotChannelNumberToDL_EARFCN() const { return get<OffsetOfNbiotChannelNumberToEARFCN>(3); }
+		OffsetOfNbiotChannelNumberToEARFCN& select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { return set<OffsetOfNbiotChannelNumberToEARFCN>(4); }
+		OffsetOfNbiotChannelNumberToEARFCN const* get_id_OffsetOfNbiotChannelNumberToUL_EARFCN() const { return get<OffsetOfNbiotChannelNumberToEARFCN>(4); }
+		NRS_NSSS_PowerOffset& select_id_NRS_NSSS_PowerOffset() { return set<NRS_NSSS_PowerOffset>(5); }
+		NRS_NSSS_PowerOffset const* get_id_NRS_NSSS_PowerOffset() const { return get<NRS_NSSS_PowerOffset>(5); }
+		NSSS_NumOccasionDifferentPrecoder& select_id_NSSS_NumOccasionDifferentPrecoder() { return set<NSSS_NumOccasionDifferentPrecoder>(6); }
+		NSSS_NumOccasionDifferentPrecoder const* get_id_NSSS_NumOccasionDifferentPrecoder() const { return get<NSSS_NumOccasionDifferentPrecoder>(6); }
+		bool is_unknown() const { return type == 7; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<EARFCNExtension>(); break;
+			case 2: var.destroy<EARFCNExtension>(); break;
+			case 3: var.destroy<OffsetOfNbiotChannelNumberToEARFCN>(); break;
+			case 4: var.destroy<OffsetOfNbiotChannelNumberToEARFCN>(); break;
+			case 5: var.destroy<NRS_NSSS_PowerOffset>(); break;
+			case 6: var.destroy<NSSS_NumOccasionDifferentPrecoder>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<EARFCNExtension>(1);
+			v.template operator()<EARFCNExtension>(2);
+			v.template operator()<OffsetOfNbiotChannelNumberToEARFCN>(3);
+			v.template operator()<OffsetOfNbiotChannelNumberToEARFCN>(4);
+			v.template operator()<NRS_NSSS_PowerOffset>(5);
+			v.template operator()<NSSS_NumOccasionDifferentPrecoder>(6);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_UL_EARFCNExtension()); return true;
+			case 2: v(select_id_DL_EARFCNExtension()); return true;
+			case 3: v(select_id_OffsetOfNbiotChannelNumberToDL_EARFCN()); return true;
+			case 4: v(select_id_OffsetOfNbiotChannelNumberToUL_EARFCN()); return true;
+			case 5: v(select_id_NRS_NSSS_PowerOffset()); return true;
+			case 6: v(select_id_NSSS_NumOccasionDifferentPrecoder()); return true;
+			case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<EARFCNExtension>()); return true;
+			case 2: v(var.as<EARFCNExtension>()); return true;
+			case 3: v(var.as<OffsetOfNbiotChannelNumberToEARFCN>()); return true;
+			case 4: v(var.as<OffsetOfNbiotChannelNumberToEARFCN>()); return true;
+			case 5: v(var.as<NRS_NSSS_PowerOffset>()); return true;
+			case 6: v(var.as<NSSS_NumOccasionDifferentPrecoder>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(EARFCNExtension)];
+			char dummy2[sizeof(NRS_NSSS_PowerOffset)];
+			char dummy3[sizeof(NSSS_NumOccasionDifferentPrecoder)];
+			char dummy4[sizeof(OffsetOfNbiotChannelNumberToEARFCN)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_UL_EARFCNExtension() { set(optional); type=1;}
+		void select_id_DL_EARFCNExtension() { set(optional); type=2;}
+		void select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { set(optional); type=3;}
+		void select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { set(optional); type=4;}
+		void select_id_NRS_NSSS_PowerOffset() { set(optional); type=5;}
+		void select_id_NSSS_NumOccasionDifferentPrecoder() { set(optional); type=6;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else if(equal(optional)) { type = 2; return true; }
+			else if(equal(optional)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else if(equal(optional)) { type = 6; return true; }
+			else { type = 7; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
+			case 7: type = 7; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+FDD-Info ::= SEQUENCE {
+	uL-EARFCN						EARFCN,
+	dL-EARFCN						EARFCN,
+	uL-Transmission-Bandwidth		Transmission-Bandwidth,
+	dL-Transmission-Bandwidth		Transmission-Bandwidth,
+	iE-Extensions				ProtocolExtensionContainer { {FDD-Info-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct FDD_Info : asn::sequence<5, 0, true, 1>
+{
+	static constexpr const char* name() {return "FDD-Info";}
+	using parent_t = asn::sequence<5, 0, true, 1>;
+	struct uL_EARFCN_t : EARFCN
+	{
+		static constexpr const char* name() {return "uL_EARFCN_t";}
+		using parent_t = EARFCN;
+
+	};
+	uL_EARFCN_t& ref_uL_EARFCN() {return uL_EARFCN;}
+	uL_EARFCN_t const& ref_uL_EARFCN() const {return uL_EARFCN;}
+	struct dL_EARFCN_t : EARFCN
+	{
+		static constexpr const char* name() {return "dL_EARFCN_t";}
+		using parent_t = EARFCN;
+
+	};
+	dL_EARFCN_t& ref_dL_EARFCN() {return dL_EARFCN;}
+	dL_EARFCN_t const& ref_dL_EARFCN() const {return dL_EARFCN;}
+	struct uL_Transmission_Bandwidth_t : Transmission_Bandwidth
+	{
+		static constexpr const char* name() {return "uL_Transmission_Bandwidth_t";}
+		using parent_t = Transmission_Bandwidth;
+
+	};
+	uL_Transmission_Bandwidth_t& ref_uL_Transmission_Bandwidth() {return uL_Transmission_Bandwidth;}
+	uL_Transmission_Bandwidth_t const& ref_uL_Transmission_Bandwidth() const {return uL_Transmission_Bandwidth;}
+	struct dL_Transmission_Bandwidth_t : Transmission_Bandwidth
+	{
+		static constexpr const char* name() {return "dL_Transmission_Bandwidth_t";}
+		using parent_t = Transmission_Bandwidth;
+
+	};
+	dL_Transmission_Bandwidth_t& ref_dL_Transmission_Bandwidth() {return dL_Transmission_Bandwidth;}
+	dL_Transmission_Bandwidth_t const& ref_dL_Transmission_Bandwidth() const {return dL_Transmission_Bandwidth;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<FDD_Info_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<FDD_Info_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(uL_EARFCN);
+		v(dL_EARFCN);
+		v(uL_Transmission_Bandwidth);
+		v(dL_Transmission_Bandwidth);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(uL_EARFCN);
+		v(dL_EARFCN);
+		v(uL_Transmission_Bandwidth);
+		v(dL_Transmission_Bandwidth);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		uL_EARFCN.clear();
+		dL_EARFCN.clear();
+		uL_Transmission_Bandwidth.clear();
+		dL_Transmission_Bandwidth.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	uL_EARFCN_t	uL_EARFCN;
+	dL_EARFCN_t	dL_EARFCN;
+	uL_Transmission_Bandwidth_t	uL_Transmission_Bandwidth;
+	dL_Transmission_Bandwidth_t	dL_Transmission_Bandwidth;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+SubframeAssignment ::= ENUMERATED {
+	sa0,
+	sa1,
+	sa2,
+	sa3,
+	sa4,
+	sa5,
+	sa6,
+	...
+}
+*/
+
+struct SubframeAssignment : asn::enumerated<7, 0, true>
+{
+	static constexpr const char* name() {return "SubframeAssignment";}
+	using parent_t = asn::enumerated<7, 0, true>;
+	typedef enum {
+		sa0
+		,sa1
+		,sa2
+		,sa3
+		,sa4
+		,sa5
+		,sa6
+	} index_t;
+
+};
+
+/*
+SpecialSubframePatterns ::= ENUMERATED {
+	ssp0,
+	ssp1,
+	ssp2,
+	ssp3,
+	ssp4,
+	ssp5,
+	ssp6,
+	ssp7,
+	ssp8,
+	...
+}
+*/
+
+struct SpecialSubframePatterns : asn::enumerated<9, 0, true>
+{
+	static constexpr const char* name() {return "SpecialSubframePatterns";}
+	using parent_t = asn::enumerated<9, 0, true>;
+	typedef enum {
+		ssp0
+		,ssp1
+		,ssp2
+		,ssp3
+		,ssp4
+		,ssp5
+		,ssp6
+		,ssp7
+		,ssp8
+	} index_t;
+
+};
+
+/*
+SpecialSubframe-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct SpecialSubframe_Info_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SpecialSubframe-Info ::= SEQUENCE {
+	specialSubframePatterns		SpecialSubframePatterns,
+	cyclicPrefixDL				CyclicPrefixDL,
+	cyclicPrefixUL				CyclicPrefixUL,
+	iE-Extensions				ProtocolExtensionContainer { {SpecialSubframe-Info-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct SpecialSubframe_Info : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "SpecialSubframe-Info";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct specialSubframePatterns_t : SpecialSubframePatterns
+	{
+		static constexpr const char* name() {return "specialSubframePatterns_t";}
+		using parent_t = SpecialSubframePatterns;
+
+	};
+	specialSubframePatterns_t& ref_specialSubframePatterns() {return specialSubframePatterns;}
+	specialSubframePatterns_t const& ref_specialSubframePatterns() const {return specialSubframePatterns;}
+	struct cyclicPrefixDL_t : CyclicPrefixDL
+	{
+		static constexpr const char* name() {return "cyclicPrefixDL_t";}
+		using parent_t = CyclicPrefixDL;
+
+	};
+	cyclicPrefixDL_t& ref_cyclicPrefixDL() {return cyclicPrefixDL;}
+	cyclicPrefixDL_t const& ref_cyclicPrefixDL() const {return cyclicPrefixDL;}
+	struct cyclicPrefixUL_t : CyclicPrefixUL
+	{
+		static constexpr const char* name() {return "cyclicPrefixUL_t";}
+		using parent_t = CyclicPrefixUL;
+
+	};
+	cyclicPrefixUL_t& ref_cyclicPrefixUL() {return cyclicPrefixUL;}
+	cyclicPrefixUL_t const& ref_cyclicPrefixUL() const {return cyclicPrefixUL;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<SpecialSubframe_Info_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<SpecialSubframe_Info_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(specialSubframePatterns);
+		v(cyclicPrefixDL);
+		v(cyclicPrefixUL);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(specialSubframePatterns);
+		v(cyclicPrefixDL);
+		v(cyclicPrefixUL);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		specialSubframePatterns.clear();
+		cyclicPrefixDL.clear();
+		cyclicPrefixUL.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	specialSubframePatterns_t	specialSubframePatterns;
+	cyclicPrefixDL_t	cyclicPrefixDL;
+	cyclicPrefixUL_t	cyclicPrefixUL;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+TDD-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-AdditionalSpecialSubframe-Info	CRITICALITY ignore	EXTENSION AdditionalSpecialSubframe-Info	PRESENCE optional}|
+	{ ID id-eARFCNExtension					CRITICALITY reject	EXTENSION EARFCNExtension						PRESENCE optional}|
+	{ ID id-AdditionalSpecialSubframeExtension-Info	CRITICALITY ignore	EXTENSION AdditionalSpecialSubframeExtension-Info	PRESENCE optional},
+	...
+}
+*/
+
+struct TDD_Info_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_AdditionalSpecialSubframe_Info() { set(id_AdditionalSpecialSubframe_Info); type=1;}
+		void select_id_eARFCNExtension() { set(id_eARFCNExtension); type=2;}
+		void select_id_AdditionalSpecialSubframeExtension_Info() { set(id_AdditionalSpecialSubframeExtension_Info); type=3;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_AdditionalSpecialSubframe_Info)) { type = 1; return true; }
+			else if(equal(id_eARFCNExtension)) { type = 2; return true; }
+			else if(equal(id_AdditionalSpecialSubframeExtension_Info)) { type = 3; return true; }
+			else { type = 4; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_AdditionalSpecialSubframe_Info);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_eARFCNExtension);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_AdditionalSpecialSubframeExtension_Info);} return false;
+			case 4: type = 4; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_AdditionalSpecialSubframe_Info() { set(ignore); type=1;}
+		void select_id_eARFCNExtension() { set(reject); type=2;}
+		void select_id_AdditionalSpecialSubframeExtension_Info() { set(ignore); type=3;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else if(equal(reject)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else { type = 4; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 4: type = 4; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		AdditionalSpecialSubframe_Info& select_id_AdditionalSpecialSubframe_Info() { return set<AdditionalSpecialSubframe_Info>(1); }
+		AdditionalSpecialSubframe_Info const* get_id_AdditionalSpecialSubframe_Info() const { return get<AdditionalSpecialSubframe_Info>(1); }
+		EARFCNExtension& select_id_eARFCNExtension() { return set<EARFCNExtension>(2); }
+		EARFCNExtension const* get_id_eARFCNExtension() const { return get<EARFCNExtension>(2); }
+		AdditionalSpecialSubframeExtension_Info& select_id_AdditionalSpecialSubframeExtension_Info() { return set<AdditionalSpecialSubframeExtension_Info>(3); }
+		AdditionalSpecialSubframeExtension_Info const* get_id_AdditionalSpecialSubframeExtension_Info() const { return get<AdditionalSpecialSubframeExtension_Info>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<AdditionalSpecialSubframe_Info>(); break;
+			case 2: var.destroy<EARFCNExtension>(); break;
+			case 3: var.destroy<AdditionalSpecialSubframeExtension_Info>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<AdditionalSpecialSubframe_Info>(1);
+			v.template operator()<EARFCNExtension>(2);
+			v.template operator()<AdditionalSpecialSubframeExtension_Info>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_AdditionalSpecialSubframe_Info()); return true;
+			case 2: v(select_id_eARFCNExtension()); return true;
+			case 3: v(select_id_AdditionalSpecialSubframeExtension_Info()); return true;
+			case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<AdditionalSpecialSubframe_Info>()); return true;
+			case 2: v(var.as<EARFCNExtension>()); return true;
+			case 3: v(var.as<AdditionalSpecialSubframeExtension_Info>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(AdditionalSpecialSubframeExtension_Info)];
+			char dummy2[sizeof(AdditionalSpecialSubframe_Info)];
+			char dummy3[sizeof(EARFCNExtension)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_AdditionalSpecialSubframe_Info() { set(optional); type=1;}
+		void select_id_eARFCNExtension() { set(optional); type=2;}
+		void select_id_AdditionalSpecialSubframeExtension_Info() { set(optional); type=3;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else if(equal(optional)) { type = 2; return true; }
+			else if(equal(optional)) { type = 3; return true; }
+			else { type = 4; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
+			case 4: type = 4; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+TDD-Info ::= SEQUENCE {
+	eARFCN							EARFCN,
+	transmission-Bandwidth			Transmission-Bandwidth,
+	subframeAssignment				SubframeAssignment,
+	specialSubframe-Info			SpecialSubframe-Info,
+	iE-Extensions					ProtocolExtensionContainer { {TDD-Info-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct TDD_Info : asn::sequence<5, 0, true, 1>
+{
+	static constexpr const char* name() {return "TDD-Info";}
+	using parent_t = asn::sequence<5, 0, true, 1>;
+	struct eARFCN_t : EARFCN
+	{
+		static constexpr const char* name() {return "eARFCN_t";}
+		using parent_t = EARFCN;
+
+	};
+	eARFCN_t& ref_eARFCN() {return eARFCN;}
+	eARFCN_t const& ref_eARFCN() const {return eARFCN;}
+	struct transmission_Bandwidth_t : Transmission_Bandwidth
+	{
+		static constexpr const char* name() {return "transmission_Bandwidth_t";}
+		using parent_t = Transmission_Bandwidth;
+
+	};
+	transmission_Bandwidth_t& ref_transmission_Bandwidth() {return transmission_Bandwidth;}
+	transmission_Bandwidth_t const& ref_transmission_Bandwidth() const {return transmission_Bandwidth;}
+	struct subframeAssignment_t : SubframeAssignment
+	{
+		static constexpr const char* name() {return "subframeAssignment_t";}
+		using parent_t = SubframeAssignment;
+
+	};
+	subframeAssignment_t& ref_subframeAssignment() {return subframeAssignment;}
+	subframeAssignment_t const& ref_subframeAssignment() const {return subframeAssignment;}
+	struct specialSubframe_Info_t : SpecialSubframe_Info
+	{
+		static constexpr const char* name() {return "specialSubframe_Info_t";}
+		using parent_t = SpecialSubframe_Info;
+
+	};
+	specialSubframe_Info_t& ref_specialSubframe_Info() {return specialSubframe_Info;}
+	specialSubframe_Info_t const& ref_specialSubframe_Info() const {return specialSubframe_Info;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<TDD_Info_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<TDD_Info_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(eARFCN);
+		v(transmission_Bandwidth);
+		v(subframeAssignment);
+		v(specialSubframe_Info);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(eARFCN);
+		v(transmission_Bandwidth);
+		v(subframeAssignment);
+		v(specialSubframe_Info);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		eARFCN.clear();
+		transmission_Bandwidth.clear();
+		subframeAssignment.clear();
+		specialSubframe_Info.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	eARFCN_t	eARFCN;
+	transmission_Bandwidth_t	transmission_Bandwidth;
+	subframeAssignment_t	subframeAssignment;
+	specialSubframe_Info_t	specialSubframe_Info;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+EUTRA-Mode-Info ::= CHOICE {
+	fDD		FDD-Info,
+	tDD		TDD-Info,
+	...
+}
+*/
+
+struct EUTRA_Mode_Info : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "EUTRA-Mode-Info";}
+	using parent_t = asn::choice<2, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 3;}
+	void set_unknown() { set_index(3);  }
+	~EUTRA_Mode_Info() {clear();}
+	struct fDD_t : FDD_Info
+	{
+		static constexpr const char* name() {return "fDD_t";}
+		using parent_t = FDD_Info;
+
+	};
+	struct tDD_t : TDD_Info
+	{
+		static constexpr const char* name() {return "tDD_t";}
+		using parent_t = TDD_Info;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<fDD_t>(); break;
+		case 2: var.destroy<tDD_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<fDD_t>());
+		case 2: set_index(2); return v(var.build<tDD_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<fDD_t>());
+		case 2: return v(var.as<tDD_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<fDD_t>(1);
+		v.template operator()<tDD_t>(2);
+
+	}
+	fDD_t& select_fDD() { if(get_index() != 1) { clear(); set_index(1); return var.build<fDD_t>();} return var.as<fDD_t>();}
+	fDD_t const* get_fDD() const { if(get_index() == 1) { return &var.as<fDD_t>();} return nullptr; }
+	tDD_t& select_tDD() { if(get_index() != 2) { clear(); set_index(2); return var.build<tDD_t>();} return var.as<tDD_t>();}
+	tDD_t const* get_tDD() const { if(get_index() == 2) { return &var.as<tDD_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(fDD_t)];
+		char dummy2[sizeof(tDD_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+EUTRANTraceID		::= OCTET STRING (SIZE (8))
+*/
+
+struct EUTRANTraceID : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<8>>;
+	static constexpr const char* name() {return "EUTRANTraceID";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+EncryptionAlgorithms ::= BIT STRING (SIZE (16, ...))
+*/
+
+struct EncryptionAlgorithms : asn::bstring<>
+{
+	using constraint_t = asn::constraints<true,asn::one<16>>;
+	static constexpr const char* name() {return "EncryptionAlgorithms";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+RNTP-Threshold ::= ENUMERATED {
+	minusInfinity,
+	minusEleven,
+	minusTen,
+	minusNine,
+	minusEight,
+	minusSeven,
+	minusSix,
+	minusFive,
+	minusFour,
+	minusThree,
+	minusTwo,
+	minusOne,
+	zero,
+	one,
+	two,
+	three,
+	...
+}
+*/
+
+struct RNTP_Threshold : asn::enumerated<16, 0, true>
+{
+	static constexpr const char* name() {return "RNTP-Threshold";}
+	using parent_t = asn::enumerated<16, 0, true>;
+	typedef enum {
+		minusInfinity
+		,minusEleven
+		,minusTen
+		,minusNine
+		,minusEight
+		,minusSeven
+		,minusSix
+		,minusFive
+		,minusFour
+		,minusThree
+		,minusTwo
+		,minusOne
+		,zero
+		,one
+		,two
+		,three
+	} index_t;
+
+};
+
+/*
+EnhancedRNTPStartTime-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct EnhancedRNTPStartTime_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+EnhancedRNTPStartTime ::= SEQUENCE {
+		startSFN				INTEGER (0..1023, ...),
+		startSubframeNumber		INTEGER (0..9, ...),
+		iE-Extensions			ProtocolExtensionContainer { {EnhancedRNTPStartTime-ExtIEs} } OPTIONAL,
+		...
+	}
+*/
+
+struct EnhancedRNTPStartTime : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "EnhancedRNTPStartTime";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct startSFN_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 1023>>;
+		static constexpr const char* name() {return "startSFN_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	startSFN_t& ref_startSFN() {return startSFN;}
+	startSFN_t const& ref_startSFN() const {return startSFN;}
+	struct startSubframeNumber_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 9>>;
+		static constexpr const char* name() {return "startSubframeNumber_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	startSubframeNumber_t& ref_startSubframeNumber() {return startSubframeNumber;}
+	startSubframeNumber_t const& ref_startSubframeNumber() const {return startSubframeNumber;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<EnhancedRNTPStartTime_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<EnhancedRNTPStartTime_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(startSFN);
+		v(startSubframeNumber);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(startSFN);
+		v(startSubframeNumber);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		startSFN.clear();
+		startSubframeNumber.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	startSFN_t	startSFN;
+	startSubframeNumber_t	startSubframeNumber;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+EnhancedRNTP-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct EnhancedRNTP_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+EnhancedRNTP ::= SEQUENCE {
+	enhancedRNTPBitmap			BIT STRING (SIZE(12..8800, ...)),
+	rNTP-High-Power-Threshold	RNTP-Threshold,
+	enhancedRNTPStartTime		EnhancedRNTPStartTime OPTIONAL,
+	iE-Extensions				ProtocolExtensionContainer { {EnhancedRNTP-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct EnhancedRNTP : asn::sequence<4, 0, true, 2>
+{
+	static constexpr const char* name() {return "EnhancedRNTP";}
+	using parent_t = asn::sequence<4, 0, true, 2>;
+	struct enhancedRNTPBitmap_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<12, 8800>>;
+		static constexpr const char* name() {return "enhancedRNTPBitmap_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	enhancedRNTPBitmap_t& ref_enhancedRNTPBitmap() {return enhancedRNTPBitmap;}
+	enhancedRNTPBitmap_t const& ref_enhancedRNTPBitmap() const {return enhancedRNTPBitmap;}
+	struct rNTP_High_Power_Threshold_t : RNTP_Threshold
+	{
+		static constexpr const char* name() {return "rNTP_High_Power_Threshold_t";}
+		using parent_t = RNTP_Threshold;
+
+	};
+	rNTP_High_Power_Threshold_t& ref_rNTP_High_Power_Threshold() {return rNTP_High_Power_Threshold;}
+	rNTP_High_Power_Threshold_t const& ref_rNTP_High_Power_Threshold() const {return rNTP_High_Power_Threshold;}
+	struct enhancedRNTPStartTime_t : EnhancedRNTPStartTime
+	{
+		static constexpr const char* name() {return "enhancedRNTPStartTime_t";}
+		using parent_t = EnhancedRNTPStartTime;
+		static constexpr bool optional = true;
+
+	};
+	enhancedRNTPStartTime_t& set_enhancedRNTPStartTime() { enhancedRNTPStartTime.setpresent(true); return enhancedRNTPStartTime;}
+	enhancedRNTPStartTime_t const* get_enhancedRNTPStartTime() const {return enhancedRNTPStartTime.is_valid() ? &enhancedRNTPStartTime : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<EnhancedRNTP_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<EnhancedRNTP_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(enhancedRNTPBitmap);
+		v(rNTP_High_Power_Threshold);
+		v(enhancedRNTPStartTime);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(enhancedRNTPBitmap);
+		v(rNTP_High_Power_Threshold);
+		v(enhancedRNTPStartTime);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		enhancedRNTPBitmap.clear();
+		rNTP_High_Power_Threshold.clear();
+		enhancedRNTPStartTime.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	enhancedRNTPBitmap_t	enhancedRNTPBitmap;
+	rNTP_High_Power_Threshold_t	rNTP_High_Power_Threshold;
+	enhancedRNTPStartTime_t	enhancedRNTPStartTime;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+EventType ::= ENUMERATED{
+	change-of-serving-cell,
+	...
+}
+*/
+
+struct EventType : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "EventType";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		change_of_serving_cell
+	} index_t;
+
+};
+
+/*
+ExpectedActivityPeriod ::= INTEGER (1..30|40|50|60|80|100|120|150|180|181,...)
+*/
+
+struct ExpectedActivityPeriod : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<1, 30>,asn::one<40>,asn::one<50>,asn::one<60>,asn::one<80>,asn::one<100>,asn::one<120>,asn::one<150>,asn::one<180>,asn::one<181>>;
+	static constexpr const char* name() {return "ExpectedActivityPeriod";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+ExpectedHOInterval ::= ENUMERATED {
+	sec15, sec30, sec60, sec90, sec120, sec180, long-time,
+	...
+}
+*/
+
+struct ExpectedHOInterval : asn::enumerated<7, 0, true>
+{
+	static constexpr const char* name() {return "ExpectedHOInterval";}
+	using parent_t = asn::enumerated<7, 0, true>;
+	typedef enum {
+		sec15
+		,sec30
+		,sec60
+		,sec90
+		,sec120
+		,sec180
+		,long_time
+	} index_t;
+
+};
+
+/*
+ExpectedIdlePeriod ::= INTEGER (1..30|40|50|60|80|100|120|150|180|181,...)
+*/
+
+struct ExpectedIdlePeriod : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<1, 30>,asn::one<40>,asn::one<50>,asn::one<60>,asn::one<80>,asn::one<100>,asn::one<120>,asn::one<150>,asn::one<180>,asn::one<181>>;
+	static constexpr const char* name() {return "ExpectedIdlePeriod";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+SourceOfUEActivityBehaviourInformation ::= ENUMERATED {
+	subscription-information,
+	statistics,
+	...
+}
+*/
+
+struct SourceOfUEActivityBehaviourInformation : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "SourceOfUEActivityBehaviourInformation";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		subscription_information
+		,statistics
+	} index_t;
+
+};
+
+/*
+ExpectedUEActivityBehaviour-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ExpectedUEActivityBehaviour_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ExpectedUEActivityBehaviour ::= SEQUENCE {
+	expectedActivityPeriod					ExpectedActivityPeriod					OPTIONAL,
+	expectedIdlePeriod						ExpectedIdlePeriod						OPTIONAL,
+	sourceofUEActivityBehaviourInformation	SourceOfUEActivityBehaviourInformation	OPTIONAL,
+	iE-Extensions		ProtocolExtensionContainer { {ExpectedUEActivityBehaviour-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ExpectedUEActivityBehaviour : asn::sequence<4, 0, true, 4>
+{
+	static constexpr const char* name() {return "ExpectedUEActivityBehaviour";}
+	using parent_t = asn::sequence<4, 0, true, 4>;
+	struct expectedActivityPeriod_t : ExpectedActivityPeriod
+	{
+		static constexpr const char* name() {return "expectedActivityPeriod_t";}
+		using parent_t = ExpectedActivityPeriod;
+		static constexpr bool optional = true;
+
+	};
+	expectedActivityPeriod_t& set_expectedActivityPeriod() { expectedActivityPeriod.setpresent(true); return expectedActivityPeriod;}
+	expectedActivityPeriod_t const* get_expectedActivityPeriod() const {return expectedActivityPeriod.is_valid() ? &expectedActivityPeriod : nullptr;}
+	struct expectedIdlePeriod_t : ExpectedIdlePeriod
+	{
+		static constexpr const char* name() {return "expectedIdlePeriod_t";}
+		using parent_t = ExpectedIdlePeriod;
+		static constexpr bool optional = true;
+
+	};
+	expectedIdlePeriod_t& set_expectedIdlePeriod() { expectedIdlePeriod.setpresent(true); return expectedIdlePeriod;}
+	expectedIdlePeriod_t const* get_expectedIdlePeriod() const {return expectedIdlePeriod.is_valid() ? &expectedIdlePeriod : nullptr;}
+	struct sourceofUEActivityBehaviourInformation_t : SourceOfUEActivityBehaviourInformation
+	{
+		static constexpr const char* name() {return "sourceofUEActivityBehaviourInformation_t";}
+		using parent_t = SourceOfUEActivityBehaviourInformation;
+		static constexpr bool optional = true;
+
+	};
+	sourceofUEActivityBehaviourInformation_t& set_sourceofUEActivityBehaviourInformation() { sourceofUEActivityBehaviourInformation.setpresent(true); return sourceofUEActivityBehaviourInformation;}
+	sourceofUEActivityBehaviourInformation_t const* get_sourceofUEActivityBehaviourInformation() const {return sourceofUEActivityBehaviourInformation.is_valid() ? &sourceofUEActivityBehaviourInformation : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ExpectedUEActivityBehaviour_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ExpectedUEActivityBehaviour_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(expectedActivityPeriod);
+		v(expectedIdlePeriod);
+		v(sourceofUEActivityBehaviourInformation);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(expectedActivityPeriod);
+		v(expectedIdlePeriod);
+		v(sourceofUEActivityBehaviourInformation);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		expectedActivityPeriod.clear();
+		expectedIdlePeriod.clear();
+		sourceofUEActivityBehaviourInformation.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	expectedActivityPeriod_t	expectedActivityPeriod;
+	expectedIdlePeriod_t	expectedIdlePeriod;
+	sourceofUEActivityBehaviourInformation_t	sourceofUEActivityBehaviourInformation;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ExpectedUEBehaviour-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ExpectedUEBehaviour_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ExpectedUEBehaviour ::= SEQUENCE {
+	expectedActivity		ExpectedUEActivityBehaviour OPTIONAL,
+	expectedHOInterval		ExpectedHOInterval			OPTIONAL,
+	iE-Extensions			ProtocolExtensionContainer { {ExpectedUEBehaviour-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ExpectedUEBehaviour : asn::sequence<3, 0, true, 3>
+{
+	static constexpr const char* name() {return "ExpectedUEBehaviour";}
+	using parent_t = asn::sequence<3, 0, true, 3>;
+	struct expectedActivity_t : ExpectedUEActivityBehaviour
+	{
+		static constexpr const char* name() {return "expectedActivity_t";}
+		using parent_t = ExpectedUEActivityBehaviour;
+		static constexpr bool optional = true;
+
+	};
+	expectedActivity_t& set_expectedActivity() { expectedActivity.setpresent(true); return expectedActivity;}
+	expectedActivity_t const* get_expectedActivity() const {return expectedActivity.is_valid() ? &expectedActivity : nullptr;}
+	struct expectedHOInterval_t : ExpectedHOInterval
+	{
+		static constexpr const char* name() {return "expectedHOInterval_t";}
+		using parent_t = ExpectedHOInterval;
+		static constexpr bool optional = true;
+
+	};
+	expectedHOInterval_t& set_expectedHOInterval() { expectedHOInterval.setpresent(true); return expectedHOInterval;}
+	expectedHOInterval_t const* get_expectedHOInterval() const {return expectedHOInterval.is_valid() ? &expectedHOInterval : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ExpectedUEBehaviour_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ExpectedUEBehaviour_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(expectedActivity);
+		v(expectedHOInterval);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(expectedActivity);
+		v(expectedHOInterval);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		expectedActivity.clear();
+		expectedHOInterval.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	expectedActivity_t	expectedActivity;
+	expectedHOInterval_t	expectedHOInterval;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+UL-InterferenceOverloadIndication-Item ::= ENUMERATED {
+	high-interference,
+	medium-interference,
+	low-interference,
+	...
+}
+*/
+
+struct UL_InterferenceOverloadIndication_Item : asn::enumerated<3, 0, true>
+{
+	static constexpr const char* name() {return "UL-InterferenceOverloadIndication-Item";}
+	using parent_t = asn::enumerated<3, 0, true>;
+	typedef enum {
+		high_interference
+		,medium_interference
+		,low_interference
+	} index_t;
+
+};
+
+/*
+UL-InterferenceOverloadIndication ::= SEQUENCE (SIZE(1..maxnoofPRBs)) OF UL-InterferenceOverloadIndication-Item
+*/
+
+struct UL_InterferenceOverloadIndication_elm : UL_InterferenceOverloadIndication_Item
+{
+	static constexpr const char* name() {return "UL_InterferenceOverloadIndication_elm";}
+	using parent_t = UL_InterferenceOverloadIndication_Item;
+
+};
+struct UL_InterferenceOverloadIndication : asn::sequenceof<UL_InterferenceOverloadIndication_elm>
+{
+	static constexpr const char* name() {return "UL-InterferenceOverloadIndication";}
+	using parent_t = asn::sequenceof<UL_InterferenceOverloadIndication_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofPRBs >>;
+
+};
+/*
+ExtendedULInterferenceOverloadInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ExtendedULInterferenceOverloadInfo_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ExtendedULInterferenceOverloadInfo ::= SEQUENCE {
+	associatedSubframes							BIT STRING (SIZE (5)),
+	extended-ul-InterferenceOverloadIndication	UL-InterferenceOverloadIndication,
+	iE-Extensions								ProtocolExtensionContainer { {ExtendedULInterferenceOverloadInfo-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ExtendedULInterferenceOverloadInfo : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "ExtendedULInterferenceOverloadInfo";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct associatedSubframes_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<5>>;
+		static constexpr const char* name() {return "associatedSubframes_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	associatedSubframes_t& ref_associatedSubframes() {return associatedSubframes;}
+	associatedSubframes_t const& ref_associatedSubframes() const {return associatedSubframes;}
+	struct extended_ul_InterferenceOverloadIndication_t : UL_InterferenceOverloadIndication
+	{
+		static constexpr const char* name() {return "extended_ul_InterferenceOverloadIndication_t";}
+		using parent_t = UL_InterferenceOverloadIndication;
+
+	};
+	extended_ul_InterferenceOverloadIndication_t& ref_extended_ul_InterferenceOverloadIndication() {return extended_ul_InterferenceOverloadIndication;}
+	extended_ul_InterferenceOverloadIndication_t const& ref_extended_ul_InterferenceOverloadIndication() const {return extended_ul_InterferenceOverloadIndication;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ExtendedULInterferenceOverloadInfo_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ExtendedULInterferenceOverloadInfo_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(associatedSubframes);
+		v(extended_ul_InterferenceOverloadIndication);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(associatedSubframes);
+		v(extended_ul_InterferenceOverloadIndication);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		associatedSubframes.clear();
+		extended_ul_InterferenceOverloadIndication.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	associatedSubframes_t	associatedSubframes;
+	extended_ul_InterferenceOverloadIndication_t	extended_ul_InterferenceOverloadIndication;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+FiveGS-TAC ::= OCTET STRING (SIZE (3))
+*/
+
+struct FiveGS_TAC : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<3>>;
+	static constexpr const char* name() {return "FiveGS-TAC";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+ForbiddenInterRATs ::= ENUMERATED {
+	all,
+	geran,
+	utran,
+	cdma2000,
+	...,
+	geranandutran,
+	cdma2000andutran
+
+}
+*/
+
+struct ForbiddenInterRATs : asn::enumerated<6, 2, true>
+{
+	static constexpr const char* name() {return "ForbiddenInterRATs";}
+	using parent_t = asn::enumerated<6, 2, true>;
+	typedef enum {
+		all
+		,geran
+		,utran
+		,cdma2000
+		,geranandutran
+		,cdma2000andutran
+	} index_t;
+
+};
+
+/*
+LAC					::= OCTET STRING (SIZE (2)) --(EXCEPT ('0000'H|'FFFE'H))
+*/
+
+struct LAC : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<2>>;
+	static constexpr const char* name() {return "LAC";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+ForbiddenLACs ::= SEQUENCE (SIZE(1..maxnoofForbLACs)) OF LAC
+*/
+
+struct ForbiddenLACs_elm : LAC
+{
+	static constexpr const char* name() {return "ForbiddenLACs_elm";}
+	using parent_t = LAC;
+
+};
+struct ForbiddenLACs : asn::sequenceof<ForbiddenLACs_elm>
+{
+	static constexpr const char* name() {return "ForbiddenLACs";}
+	using parent_t = asn::sequenceof<ForbiddenLACs_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofForbLACs >>;
+
+};
+/*
+ForbiddenLAs-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ForbiddenLAs_Item_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ForbiddenLAs-Item ::= SEQUENCE {
+	pLMN-Identity		PLMN-Identity,
+	forbiddenLACs		ForbiddenLACs,
+	iE-Extensions		ProtocolExtensionContainer { {ForbiddenLAs-Item-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ForbiddenLAs_Item : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "ForbiddenLAs-Item";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct pLMN_Identity_t : PLMN_Identity
+	{
+		static constexpr const char* name() {return "pLMN_Identity_t";}
+		using parent_t = PLMN_Identity;
+
+	};
+	pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+	pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+	struct forbiddenLACs_t : ForbiddenLACs
+	{
+		static constexpr const char* name() {return "forbiddenLACs_t";}
+		using parent_t = ForbiddenLACs;
+
+	};
+	forbiddenLACs_t& ref_forbiddenLACs() {return forbiddenLACs;}
+	forbiddenLACs_t const& ref_forbiddenLACs() const {return forbiddenLACs;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ForbiddenLAs_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ForbiddenLAs_Item_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(pLMN_Identity);
+		v(forbiddenLACs);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(pLMN_Identity);
+		v(forbiddenLACs);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		pLMN_Identity.clear();
+		forbiddenLACs.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	pLMN_Identity_t	pLMN_Identity;
+	forbiddenLACs_t	forbiddenLACs;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ForbiddenLAs ::= SEQUENCE (SIZE(1..maxnoofEPLMNsPlusOne)) OF ForbiddenLAs-Item
+*/
+
+struct ForbiddenLAs_elm : ForbiddenLAs_Item
+{
+	static constexpr const char* name() {return "ForbiddenLAs_elm";}
+	using parent_t = ForbiddenLAs_Item;
+
+};
+struct ForbiddenLAs : asn::sequenceof<ForbiddenLAs_elm>
+{
+	static constexpr const char* name() {return "ForbiddenLAs";}
+	using parent_t = asn::sequenceof<ForbiddenLAs_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofEPLMNsPlusOne >>;
+
+};
+/*
+ForbiddenTACs ::= SEQUENCE (SIZE(1..maxnoofForbTACs)) OF TAC
+*/
+
+struct ForbiddenTACs_elm : TAC
+{
+	static constexpr const char* name() {return "ForbiddenTACs_elm";}
+	using parent_t = TAC;
+
+};
+struct ForbiddenTACs : asn::sequenceof<ForbiddenTACs_elm>
+{
+	static constexpr const char* name() {return "ForbiddenTACs";}
+	using parent_t = asn::sequenceof<ForbiddenTACs_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofForbTACs >>;
+
+};
+/*
+ForbiddenTAs-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ForbiddenTAs_Item_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ForbiddenTAs-Item ::= SEQUENCE {
+	pLMN-Identity		PLMN-Identity,
+	forbiddenTACs		ForbiddenTACs,
+	iE-Extensions		ProtocolExtensionContainer { {ForbiddenTAs-Item-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ForbiddenTAs_Item : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "ForbiddenTAs-Item";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct pLMN_Identity_t : PLMN_Identity
+	{
+		static constexpr const char* name() {return "pLMN_Identity_t";}
+		using parent_t = PLMN_Identity;
+
+	};
+	pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+	pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+	struct forbiddenTACs_t : ForbiddenTACs
+	{
+		static constexpr const char* name() {return "forbiddenTACs_t";}
+		using parent_t = ForbiddenTACs;
+
+	};
+	forbiddenTACs_t& ref_forbiddenTACs() {return forbiddenTACs;}
+	forbiddenTACs_t const& ref_forbiddenTACs() const {return forbiddenTACs;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ForbiddenTAs_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ForbiddenTAs_Item_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(pLMN_Identity);
+		v(forbiddenTACs);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(pLMN_Identity);
+		v(forbiddenTACs);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		pLMN_Identity.clear();
+		forbiddenTACs.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	pLMN_Identity_t	pLMN_Identity;
+	forbiddenTACs_t	forbiddenTACs;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ForbiddenTAs ::= SEQUENCE (SIZE(1.. maxnoofEPLMNsPlusOne)) OF ForbiddenTAs-Item
+*/
+
+struct ForbiddenTAs_elm : ForbiddenTAs_Item
+{
+	static constexpr const char* name() {return "ForbiddenTAs_elm";}
+	using parent_t = ForbiddenTAs_Item;
+
+};
+struct ForbiddenTAs : asn::sequenceof<ForbiddenTAs_elm>
+{
+	static constexpr const char* name() {return "ForbiddenTAs";}
+	using parent_t = asn::sequenceof<ForbiddenTAs_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofEPLMNsPlusOne >>;
+
+};
+/*
+Fourframes ::= BIT STRING (SIZE (24))
+*/
+
+struct Fourframes : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<24>>;
+	static constexpr const char* name() {return "Fourframes";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+FreqBandIndicatorPriority ::= ENUMERATED {
+	not-broadcasted,
+	broadcasted,
+	...
+}
+*/
+
+struct FreqBandIndicatorPriority : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "FreqBandIndicatorPriority";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		not_broadcasted
+		,broadcasted
+	} index_t;
+
+};
+
+/*
+SupportedSULFreqBandItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct SupportedSULFreqBandItem_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SupportedSULFreqBandItem ::= SEQUENCE {
+	freqBandIndicatorNr 			INTEGER (1..1024,...),
+	iE-Extensions			ProtocolExtensionContainer { {SupportedSULFreqBandItem-ExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct SupportedSULFreqBandItem : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "SupportedSULFreqBandItem";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct freqBandIndicatorNr_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<1, 1024>>;
+		static constexpr const char* name() {return "freqBandIndicatorNr_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	freqBandIndicatorNr_t& ref_freqBandIndicatorNr() {return freqBandIndicatorNr;}
+	freqBandIndicatorNr_t const& ref_freqBandIndicatorNr() const {return freqBandIndicatorNr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<SupportedSULFreqBandItem_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<SupportedSULFreqBandItem_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(freqBandIndicatorNr);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(freqBandIndicatorNr);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		freqBandIndicatorNr.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	freqBandIndicatorNr_t	freqBandIndicatorNr;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+FreqBandNrItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct FreqBandNrItem_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+FreqBandNrItem ::= SEQUENCE {
+	freqBandIndicatorNr 			INTEGER (1..1024,...),
+	supportedSULBandList	SEQUENCE (SIZE(0..maxnoofNrCellBands)) OF SupportedSULFreqBandItem,
+	iE-Extensions				ProtocolExtensionContainer { {FreqBandNrItem-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct FreqBandNrItem : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "FreqBandNrItem";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct freqBandIndicatorNr_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<1, 1024>>;
+		static constexpr const char* name() {return "freqBandIndicatorNr_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	freqBandIndicatorNr_t& ref_freqBandIndicatorNr() {return freqBandIndicatorNr;}
+	freqBandIndicatorNr_t const& ref_freqBandIndicatorNr() const {return freqBandIndicatorNr;}
+	struct supportedSULBandList_t_elm : SupportedSULFreqBandItem
+	{
+		static constexpr const char* name() {return "supportedSULBandList_t_elm";}
+		using parent_t = SupportedSULFreqBandItem;
+
+	};
+	struct supportedSULBandList_t : asn::sequenceof<supportedSULBandList_t_elm>
+	{
+		static constexpr const char* name() {return "supportedSULBandList_t";}
+		using parent_t = asn::sequenceof<supportedSULBandList_t_elm>;
+		using constraint_t = asn::constraints<false,asn::span<0,  maxnoofNrCellBands >>;
+
+	};
+	supportedSULBandList_t& ref_supportedSULBandList() {return supportedSULBandList;}
+	supportedSULBandList_t const& ref_supportedSULBandList() const {return supportedSULBandList;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<FreqBandNrItem_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<FreqBandNrItem_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(freqBandIndicatorNr);
+		v(supportedSULBandList);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(freqBandIndicatorNr);
+		v(supportedSULBandList);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		freqBandIndicatorNr.clear();
+		supportedSULBandList.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	freqBandIndicatorNr_t	freqBandIndicatorNr;
+	supportedSULBandList_t	supportedSULBandList;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+GNB-ID ::= CHOICE {
+	gNB-ID	BIT STRING (SIZE (22..32)),
+	...
+}
+*/
+
+struct GNB_ID : asn::choice<1, 0, true>
+{
+	static constexpr const char* name() {return "GNB-ID";}
+	using parent_t = asn::choice<1, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 2;}
+	void set_unknown() { set_index(2);  }
+	~GNB_ID() {clear();}
+	struct gNB_ID_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<22, 32>>;
+		static constexpr const char* name() {return "gNB_ID_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<gNB_ID_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<gNB_ID_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<gNB_ID_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<gNB_ID_t>(1);
+
+	}
+	gNB_ID_t& select_gNB_ID() { if(get_index() != 1) { clear(); set_index(1); return var.build<gNB_ID_t>();} return var.as<gNB_ID_t>();}
+	gNB_ID_t const* get_gNB_ID() const { if(get_index() == 1) { return &var.as<gNB_ID_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(gNB_ID_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+GNBOverloadInformation ::= ENUMERATED {overloaded, not-overloaded, ...}
+*/
+
+struct GNBOverloadInformation : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "GNBOverloadInformation";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		overloaded
+		,not_overloaded
+	} index_t;
+
+};
+
+/*
+GTP-TEI					::= OCTET STRING (SIZE (4))
+*/
+
+struct GTP_TEI : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<4>>;
+	static constexpr const char* name() {return "GTP-TEI";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+TransportLayerAddress			::= BIT STRING (SIZE(1..160, ...))
+*/
+
+struct TransportLayerAddress : asn::bstring<>
+{
+	using constraint_t = asn::constraints<true,asn::span<1, 160>>;
+	static constexpr const char* name() {return "TransportLayerAddress";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+GTPtunnelEndpoint-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct GTPtunnelEndpoint_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+GTPtunnelEndpoint ::= SEQUENCE {
+	transportLayerAddress			TransportLayerAddress,
+	gTP-TEID						GTP-TEI,
+	iE-Extensions					ProtocolExtensionContainer { {GTPtunnelEndpoint-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct GTPtunnelEndpoint : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "GTPtunnelEndpoint";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct transportLayerAddress_t : TransportLayerAddress
+	{
+		static constexpr const char* name() {return "transportLayerAddress_t";}
+		using parent_t = TransportLayerAddress;
+
+	};
+	transportLayerAddress_t& ref_transportLayerAddress() {return transportLayerAddress;}
+	transportLayerAddress_t const& ref_transportLayerAddress() const {return transportLayerAddress;}
+	struct gTP_TEID_t : GTP_TEI
+	{
+		static constexpr const char* name() {return "gTP_TEID_t";}
+		using parent_t = GTP_TEI;
+
+	};
+	gTP_TEID_t& ref_gTP_TEID() {return gTP_TEID;}
+	gTP_TEID_t const& ref_gTP_TEID() const {return gTP_TEID;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<GTPtunnelEndpoint_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<GTPtunnelEndpoint_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(transportLayerAddress);
+		v(gTP_TEID);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(transportLayerAddress);
+		v(gTP_TEID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		transportLayerAddress.clear();
+		gTP_TEID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	transportLayerAddress_t	transportLayerAddress;
+	gTP_TEID_t	gTP_TEID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+MME-Group-ID	::= OCTET STRING (SIZE (2))
+*/
+
+struct MME_Group_ID : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<2>>;
+	static constexpr const char* name() {return "MME-Group-ID";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+GU-Group-ID-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct GU_Group_ID_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+GU-Group-ID			::= SEQUENCE {
+	pLMN-Identity		PLMN-Identity,
+	mME-Group-ID		MME-Group-ID,
+	iE-Extensions		ProtocolExtensionContainer { {GU-Group-ID-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct GU_Group_ID : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "GU-Group-ID";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct pLMN_Identity_t : PLMN_Identity
+	{
+		static constexpr const char* name() {return "pLMN_Identity_t";}
+		using parent_t = PLMN_Identity;
+
+	};
+	pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+	pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+	struct mME_Group_ID_t : MME_Group_ID
+	{
+		static constexpr const char* name() {return "mME_Group_ID_t";}
+		using parent_t = MME_Group_ID;
+
+	};
+	mME_Group_ID_t& ref_mME_Group_ID() {return mME_Group_ID;}
+	mME_Group_ID_t const& ref_mME_Group_ID() const {return mME_Group_ID;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<GU_Group_ID_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<GU_Group_ID_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(pLMN_Identity);
+		v(mME_Group_ID);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(pLMN_Identity);
+		v(mME_Group_ID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		pLMN_Identity.clear();
+		mME_Group_ID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	pLMN_Identity_t	pLMN_Identity;
+	mME_Group_ID_t	mME_Group_ID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+GUGroupIDList		::= SEQUENCE (SIZE (1..maxPools)) OF GU-Group-ID
+*/
+
+struct GUGroupIDList_elm : GU_Group_ID
+{
+	static constexpr const char* name() {return "GUGroupIDList_elm";}
+	using parent_t = GU_Group_ID;
+
+};
+struct GUGroupIDList : asn::sequenceof<GUGroupIDList_elm>
+{
+	static constexpr const char* name() {return "GUGroupIDList";}
+	using parent_t = asn::sequenceof<GUGroupIDList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxPools >>;
+
+};
+/*
+MME-Code		::= OCTET STRING (SIZE (1))
+*/
+
+struct MME_Code : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<1>>;
+	static constexpr const char* name() {return "MME-Code";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+GUMMEI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct GUMMEI_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+GUMMEI			::= SEQUENCE {
+
+	gU-Group-ID		GU-Group-ID,
+	mME-Code			MME-Code,
+	iE-Extensions					ProtocolExtensionContainer { {GUMMEI-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct GUMMEI : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "GUMMEI";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct gU_Group_ID_t : GU_Group_ID
+	{
+		static constexpr const char* name() {return "gU_Group_ID_t";}
+		using parent_t = GU_Group_ID;
+
+	};
+	gU_Group_ID_t& ref_gU_Group_ID() {return gU_Group_ID;}
+	gU_Group_ID_t const& ref_gU_Group_ID() const {return gU_Group_ID;}
+	struct mME_Code_t : MME_Code
+	{
+		static constexpr const char* name() {return "mME_Code_t";}
+		using parent_t = MME_Code;
+
+	};
+	mME_Code_t& ref_mME_Code() {return mME_Code;}
+	mME_Code_t const& ref_mME_Code() const {return mME_Code;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<GUMMEI_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<GUMMEI_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(gU_Group_ID);
+		v(mME_Code);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(gU_Group_ID);
+		v(mME_Code);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		gU_Group_ID.clear();
+		mME_Code.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	gU_Group_ID_t	gU_Group_ID;
+	mME_Code_t	mME_Code;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+GlobalENB-ID-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct GlobalENB_ID_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+GlobalENB-ID ::= SEQUENCE {
+	pLMN-Identity			PLMN-Identity,
+	eNB-ID					ENB-ID,
+	iE-Extensions			ProtocolExtensionContainer { {GlobalENB-ID-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct GlobalENB_ID : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "GlobalENB-ID";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct pLMN_Identity_t : PLMN_Identity
+	{
+		static constexpr const char* name() {return "pLMN_Identity_t";}
+		using parent_t = PLMN_Identity;
+
+	};
+	pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+	pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+	struct eNB_ID_t : ENB_ID
+	{
+		static constexpr const char* name() {return "eNB_ID_t";}
+		using parent_t = ENB_ID;
+
+	};
+	eNB_ID_t& ref_eNB_ID() {return eNB_ID;}
+	eNB_ID_t const& ref_eNB_ID() const {return eNB_ID;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<GlobalENB_ID_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<GlobalENB_ID_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(pLMN_Identity);
+		v(eNB_ID);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(pLMN_Identity);
+		v(eNB_ID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		pLMN_Identity.clear();
+		eNB_ID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	pLMN_Identity_t	pLMN_Identity;
+	eNB_ID_t	eNB_ID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+GlobalGNB-ID-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct GlobalGNB_ID_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+GlobalGNB-ID ::= SEQUENCE {
+	pLMN-Identity			PLMN-Identity,
+	gNB-ID					GNB-ID,
+	iE-Extensions			ProtocolExtensionContainer { {GlobalGNB-ID-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct GlobalGNB_ID : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "GlobalGNB-ID";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct pLMN_Identity_t : PLMN_Identity
+	{
+		static constexpr const char* name() {return "pLMN_Identity_t";}
+		using parent_t = PLMN_Identity;
+
+	};
+	pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+	pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+	struct gNB_ID_t : GNB_ID
+	{
+		static constexpr const char* name() {return "gNB_ID_t";}
+		using parent_t = GNB_ID;
+
+	};
+	gNB_ID_t& ref_gNB_ID() {return gNB_ID;}
+	gNB_ID_t const& ref_gNB_ID() const {return gNB_ID;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<GlobalGNB_ID_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<GlobalGNB_ID_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(pLMN_Identity);
+		v(gNB_ID);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(pLMN_Identity);
+		v(gNB_ID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		pLMN_Identity.clear();
+		gNB_ID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	pLMN_Identity_t	pLMN_Identity;
+	gNB_ID_t	gNB_ID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+LoadIndicator ::= ENUMERATED {
+	lowLoad,
+	mediumLoad,
+	highLoad,
+	overLoad,
+	...
+}
+*/
+
+struct LoadIndicator : asn::enumerated<4, 0, true>
+{
+	static constexpr const char* name() {return "LoadIndicator";}
+	using parent_t = asn::enumerated<4, 0, true>;
+	typedef enum {
+		lowLoad
+		,mediumLoad
+		,highLoad
+		,overLoad
+	} index_t;
+
+};
+
+/*
+HWLoadIndicator-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct HWLoadIndicator_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+HWLoadIndicator ::= SEQUENCE {
+	dLHWLoadIndicator			LoadIndicator,
+	uLHWLoadIndicator			LoadIndicator,
+	iE-Extensions				ProtocolExtensionContainer { {HWLoadIndicator-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct HWLoadIndicator : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "HWLoadIndicator";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct dLHWLoadIndicator_t : LoadIndicator
+	{
+		static constexpr const char* name() {return "dLHWLoadIndicator_t";}
+		using parent_t = LoadIndicator;
+
+	};
+	dLHWLoadIndicator_t& ref_dLHWLoadIndicator() {return dLHWLoadIndicator;}
+	dLHWLoadIndicator_t const& ref_dLHWLoadIndicator() const {return dLHWLoadIndicator;}
+	struct uLHWLoadIndicator_t : LoadIndicator
+	{
+		static constexpr const char* name() {return "uLHWLoadIndicator_t";}
+		using parent_t = LoadIndicator;
+
+	};
+	uLHWLoadIndicator_t& ref_uLHWLoadIndicator() {return uLHWLoadIndicator;}
+	uLHWLoadIndicator_t const& ref_uLHWLoadIndicator() const {return uLHWLoadIndicator;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<HWLoadIndicator_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<HWLoadIndicator_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(dLHWLoadIndicator);
+		v(uLHWLoadIndicator);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(dLHWLoadIndicator);
+		v(uLHWLoadIndicator);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		dLHWLoadIndicator.clear();
+		uLHWLoadIndicator.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	dLHWLoadIndicator_t	dLHWLoadIndicator;
+	uLHWLoadIndicator_t	uLHWLoadIndicator;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+HandoverReportType ::= ENUMERATED {
+	hoTooEarly,
+	hoToWrongCell,
+	...,
+	interRATpingpong
+}
+*/
+
+struct HandoverReportType : asn::enumerated<3, 1, true>
+{
+	static constexpr const char* name() {return "HandoverReportType";}
+	using parent_t = asn::enumerated<3, 1, true>;
+	typedef enum {
+		hoTooEarly
+		,hoToWrongCell
+		,interRATpingpong
+	} index_t;
+
+};
+
+/*
+NRrestrictioninEPSasSecondaryRAT ::= ENUMERATED {
+	nRrestrictedinEPSasSecondaryRAT,
+	...
+}
+*/
+
+struct NRrestrictioninEPSasSecondaryRAT : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "NRrestrictioninEPSasSecondaryRAT";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		nRrestrictedinEPSasSecondaryRAT
+	} index_t;
+
+};
+
+/*
+NRrestrictionin5GS ::= ENUMERATED {
+	nRrestrictedin5GS,
+	...
+}
+*/
+
+struct NRrestrictionin5GS : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "NRrestrictionin5GS";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		nRrestrictedin5GS
+	} index_t;
+
+};
+
+/*
+HandoverRestrictionList-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-NRrestrictioninEPSasSecondaryRAT			CRITICALITY ignore	EXTENSION NRrestrictioninEPSasSecondaryRAT			PRESENCE optional}|
+	{ ID id-CNTypeRestrictions						CRITICALITY ignore	EXTENSION CNTypeRestrictions								PRESENCE optional}|
+	{ ID id-NRrestrictionin5GS						CRITICALITY ignore	EXTENSION NRrestrictionin5GS								PRESENCE optional},
+	...
+}
+*/
+
+struct HandoverRestrictionList_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_NRrestrictioninEPSasSecondaryRAT() { set(id_NRrestrictioninEPSasSecondaryRAT); type=1;}
+		void select_id_CNTypeRestrictions() { set(id_CNTypeRestrictions); type=2;}
+		void select_id_NRrestrictionin5GS() { set(id_NRrestrictionin5GS); type=3;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_NRrestrictioninEPSasSecondaryRAT)) { type = 1; return true; }
+			else if(equal(id_CNTypeRestrictions)) { type = 2; return true; }
+			else if(equal(id_NRrestrictionin5GS)) { type = 3; return true; }
+			else { type = 4; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_NRrestrictioninEPSasSecondaryRAT);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_CNTypeRestrictions);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_NRrestrictionin5GS);} return false;
+			case 4: type = 4; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_NRrestrictioninEPSasSecondaryRAT() { set(ignore); type=1;}
+		void select_id_CNTypeRestrictions() { set(ignore); type=2;}
+		void select_id_NRrestrictionin5GS() { set(ignore); type=3;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else if(equal(ignore)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else { type = 4; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 4: type = 4; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		NRrestrictioninEPSasSecondaryRAT& select_id_NRrestrictioninEPSasSecondaryRAT() { return set<NRrestrictioninEPSasSecondaryRAT>(1); }
+		NRrestrictioninEPSasSecondaryRAT const* get_id_NRrestrictioninEPSasSecondaryRAT() const { return get<NRrestrictioninEPSasSecondaryRAT>(1); }
+		CNTypeRestrictions& select_id_CNTypeRestrictions() { return set<CNTypeRestrictions>(2); }
+		CNTypeRestrictions const* get_id_CNTypeRestrictions() const { return get<CNTypeRestrictions>(2); }
+		NRrestrictionin5GS& select_id_NRrestrictionin5GS() { return set<NRrestrictionin5GS>(3); }
+		NRrestrictionin5GS const* get_id_NRrestrictionin5GS() const { return get<NRrestrictionin5GS>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<NRrestrictioninEPSasSecondaryRAT>(); break;
+			case 2: var.destroy<CNTypeRestrictions>(); break;
+			case 3: var.destroy<NRrestrictionin5GS>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<NRrestrictioninEPSasSecondaryRAT>(1);
+			v.template operator()<CNTypeRestrictions>(2);
+			v.template operator()<NRrestrictionin5GS>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_NRrestrictioninEPSasSecondaryRAT()); return true;
+			case 2: v(select_id_CNTypeRestrictions()); return true;
+			case 3: v(select_id_NRrestrictionin5GS()); return true;
+			case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<NRrestrictioninEPSasSecondaryRAT>()); return true;
+			case 2: v(var.as<CNTypeRestrictions>()); return true;
+			case 3: v(var.as<NRrestrictionin5GS>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(CNTypeRestrictions)];
+			char dummy2[sizeof(NRrestrictionin5GS)];
+			char dummy3[sizeof(NRrestrictioninEPSasSecondaryRAT)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_NRrestrictioninEPSasSecondaryRAT() { set(optional); type=1;}
+		void select_id_CNTypeRestrictions() { set(optional); type=2;}
+		void select_id_NRrestrictionin5GS() { set(optional); type=3;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else if(equal(optional)) { type = 2; return true; }
+			else if(equal(optional)) { type = 3; return true; }
+			else { type = 4; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
+			case 4: type = 4; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+HandoverRestrictionList ::= SEQUENCE {
+	servingPLMN					PLMN-Identity,
+	equivalentPLMNs				EPLMNs					OPTIONAL,
+	forbiddenTAs				ForbiddenTAs			OPTIONAL,
+	forbiddenLAs				ForbiddenLAs			OPTIONAL,
+	forbiddenInterRATs			ForbiddenInterRATs		OPTIONAL,
+	iE-Extensions				ProtocolExtensionContainer { {HandoverRestrictionList-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct HandoverRestrictionList : asn::sequence<6, 0, true, 5>
+{
+	static constexpr const char* name() {return "HandoverRestrictionList";}
+	using parent_t = asn::sequence<6, 0, true, 5>;
+	struct servingPLMN_t : PLMN_Identity
+	{
+		static constexpr const char* name() {return "servingPLMN_t";}
+		using parent_t = PLMN_Identity;
+
+	};
+	servingPLMN_t& ref_servingPLMN() {return servingPLMN;}
+	servingPLMN_t const& ref_servingPLMN() const {return servingPLMN;}
+	struct equivalentPLMNs_t : EPLMNs
+	{
+		static constexpr const char* name() {return "equivalentPLMNs_t";}
+		using parent_t = EPLMNs;
+		static constexpr bool optional = true;
+
+	};
+	equivalentPLMNs_t& set_equivalentPLMNs() { equivalentPLMNs.setpresent(true); return equivalentPLMNs;}
+	equivalentPLMNs_t const* get_equivalentPLMNs() const {return equivalentPLMNs.is_valid() ? &equivalentPLMNs : nullptr;}
+	struct forbiddenTAs_t : ForbiddenTAs
+	{
+		static constexpr const char* name() {return "forbiddenTAs_t";}
+		using parent_t = ForbiddenTAs;
+		static constexpr bool optional = true;
+
+	};
+	forbiddenTAs_t& set_forbiddenTAs() { forbiddenTAs.setpresent(true); return forbiddenTAs;}
+	forbiddenTAs_t const* get_forbiddenTAs() const {return forbiddenTAs.is_valid() ? &forbiddenTAs : nullptr;}
+	struct forbiddenLAs_t : ForbiddenLAs
+	{
+		static constexpr const char* name() {return "forbiddenLAs_t";}
+		using parent_t = ForbiddenLAs;
+		static constexpr bool optional = true;
+
+	};
+	forbiddenLAs_t& set_forbiddenLAs() { forbiddenLAs.setpresent(true); return forbiddenLAs;}
+	forbiddenLAs_t const* get_forbiddenLAs() const {return forbiddenLAs.is_valid() ? &forbiddenLAs : nullptr;}
+	struct forbiddenInterRATs_t : ForbiddenInterRATs
+	{
+		static constexpr const char* name() {return "forbiddenInterRATs_t";}
+		using parent_t = ForbiddenInterRATs;
+		static constexpr bool optional = true;
+
+	};
+	forbiddenInterRATs_t& set_forbiddenInterRATs() { forbiddenInterRATs.setpresent(true); return forbiddenInterRATs;}
+	forbiddenInterRATs_t const* get_forbiddenInterRATs() const {return forbiddenInterRATs.is_valid() ? &forbiddenInterRATs : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<HandoverRestrictionList_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<HandoverRestrictionList_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(servingPLMN);
+		v(equivalentPLMNs);
+		v(forbiddenTAs);
+		v(forbiddenLAs);
+		v(forbiddenInterRATs);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(servingPLMN);
+		v(equivalentPLMNs);
+		v(forbiddenTAs);
+		v(forbiddenLAs);
+		v(forbiddenInterRATs);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		servingPLMN.clear();
+		equivalentPLMNs.clear();
+		forbiddenTAs.clear();
+		forbiddenLAs.clear();
+		forbiddenInterRATs.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	servingPLMN_t	servingPLMN;
+	equivalentPLMNs_t	equivalentPLMNs;
+	forbiddenTAs_t	forbiddenTAs;
+	forbiddenLAs_t	forbiddenLAs;
+	forbiddenInterRATs_t	forbiddenInterRATs;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+IntegrityProtectionAlgorithms ::= BIT STRING (SIZE (16, ...))
+*/
+
+struct IntegrityProtectionAlgorithms : asn::bstring<>
+{
+	using constraint_t = asn::constraints<true,asn::one<16>>;
+	static constexpr const char* name() {return "IntegrityProtectionAlgorithms";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+InterfacesToTrace ::= BIT STRING (SIZE (8))
+*/
+
+struct InterfacesToTrace : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<8>>;
+	static constexpr const char* name() {return "InterfacesToTrace";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+InvokeIndication ::= ENUMERATED{
+	abs-information,
+	...,
+	naics-information-start,
+	naics-information-stop
+}
+*/
+
+struct InvokeIndication : asn::enumerated<3, 2, true>
+{
+	static constexpr const char* name() {return "InvokeIndication";}
+	using parent_t = asn::enumerated<3, 2, true>;
+	typedef enum {
+		abs_information
+		,naics_information_start
+		,naics_information_stop
+	} index_t;
+
+};
+
+/*
+LCID ::= INTEGER(1..32, ...)
+*/
+
+struct LCID : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<1, 32>>;
+	static constexpr const char* name() {return "LCID";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+LHN-ID ::= OCTET STRING(SIZE (32..256))
+*/
+
+struct LHN_ID : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::span<32, 256>>;
+	static constexpr const char* name() {return "LHN-ID";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+Time-UE-StayedInCell ::= INTEGER (0..4095)
+*/
+
+struct Time_UE_StayedInCell : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
+	static constexpr const char* name() {return "Time-UE-StayedInCell";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+Time-UE-StayedInCell-EnhancedGranularity ::= INTEGER (0..40950)
+*/
+
+struct Time_UE_StayedInCell_EnhancedGranularity : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 40950>>;
+	static constexpr const char* name() {return "Time-UE-StayedInCell-EnhancedGranularity";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+LastVisitedEUTRANCellInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+-- Extension for Rel-11 to support enhanced granularity for time UE stayed in cell --
+	{ ID id-Time-UE-StayedInCell-EnhancedGranularity	CRITICALITY ignore	EXTENSION Time-UE-StayedInCell-EnhancedGranularity	PRESENCE optional}|
+	{ ID id-HO-cause									CRITICALITY ignore	EXTENSION Cause													PRESENCE optional},
+	...
+}
+*/
+
+struct LastVisitedEUTRANCellInformation_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_Time_UE_StayedInCell_EnhancedGranularity() { set(id_Time_UE_StayedInCell_EnhancedGranularity); type=1;}
+		void select_id_HO_cause() { set(id_HO_cause); type=2;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_Time_UE_StayedInCell_EnhancedGranularity)) { type = 1; return true; }
+			else if(equal(id_HO_cause)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_Time_UE_StayedInCell_EnhancedGranularity);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_HO_cause);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_Time_UE_StayedInCell_EnhancedGranularity() { set(ignore); type=1;}
+		void select_id_HO_cause() { set(ignore); type=2;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else if(equal(ignore)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		Time_UE_StayedInCell_EnhancedGranularity& select_id_Time_UE_StayedInCell_EnhancedGranularity() { return set<Time_UE_StayedInCell_EnhancedGranularity>(1); }
+		Time_UE_StayedInCell_EnhancedGranularity const* get_id_Time_UE_StayedInCell_EnhancedGranularity() const { return get<Time_UE_StayedInCell_EnhancedGranularity>(1); }
+		Cause& select_id_HO_cause() { return set<Cause>(2); }
+		Cause const* get_id_HO_cause() const { return get<Cause>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Time_UE_StayedInCell_EnhancedGranularity>(); break;
+			case 2: var.destroy<Cause>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Time_UE_StayedInCell_EnhancedGranularity>(1);
+			v.template operator()<Cause>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Time_UE_StayedInCell_EnhancedGranularity()); return true;
+			case 2: v(select_id_HO_cause()); return true;
+			case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<Time_UE_StayedInCell_EnhancedGranularity>()); return true;
+			case 2: v(var.as<Cause>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(Cause)];
+			char dummy2[sizeof(Time_UE_StayedInCell_EnhancedGranularity)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_Time_UE_StayedInCell_EnhancedGranularity() { set(optional); type=1;}
+		void select_id_HO_cause() { set(optional); type=2;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else if(equal(optional)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+LastVisitedEUTRANCellInformation ::= SEQUENCE {
+	global-Cell-ID					ECGI,
+	cellType						CellType,
+	time-UE-StayedInCell			Time-UE-StayedInCell,
+	iE-Extensions					ProtocolExtensionContainer { {LastVisitedEUTRANCellInformation-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct LastVisitedEUTRANCellInformation : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "LastVisitedEUTRANCellInformation";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct global_Cell_ID_t : ECGI
+	{
+		static constexpr const char* name() {return "global_Cell_ID_t";}
+		using parent_t = ECGI;
+
+	};
+	global_Cell_ID_t& ref_global_Cell_ID() {return global_Cell_ID;}
+	global_Cell_ID_t const& ref_global_Cell_ID() const {return global_Cell_ID;}
+	struct cellType_t : CellType
+	{
+		static constexpr const char* name() {return "cellType_t";}
+		using parent_t = CellType;
+
+	};
+	cellType_t& ref_cellType() {return cellType;}
+	cellType_t const& ref_cellType() const {return cellType;}
+	struct time_UE_StayedInCell_t : Time_UE_StayedInCell
+	{
+		static constexpr const char* name() {return "time_UE_StayedInCell_t";}
+		using parent_t = Time_UE_StayedInCell;
+
+	};
+	time_UE_StayedInCell_t& ref_time_UE_StayedInCell() {return time_UE_StayedInCell;}
+	time_UE_StayedInCell_t const& ref_time_UE_StayedInCell() const {return time_UE_StayedInCell;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<LastVisitedEUTRANCellInformation_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<LastVisitedEUTRANCellInformation_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(global_Cell_ID);
+		v(cellType);
+		v(time_UE_StayedInCell);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(global_Cell_ID);
+		v(cellType);
+		v(time_UE_StayedInCell);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		global_Cell_ID.clear();
+		cellType.clear();
+		time_UE_StayedInCell.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	global_Cell_ID_t	global_Cell_ID;
+	cellType_t	cellType;
+	time_UE_StayedInCell_t	time_UE_StayedInCell;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+LastVisitedUTRANCellInformation	::= OCTET STRING
+*/
+
+struct LastVisitedUTRANCellInformation : asn::ostring<>
+{
+	static constexpr const char* name() {return "LastVisitedUTRANCellInformation";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+LastVisitedGERANCellInformation ::= CHOICE {
+	undefined						NULL,
+	...
+}
+*/
+
+struct LastVisitedGERANCellInformation : asn::choice<1, 0, true>
+{
+	static constexpr const char* name() {return "LastVisitedGERANCellInformation";}
+	using parent_t = asn::choice<1, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 2;}
+	void set_unknown() { set_index(2);  }
+	~LastVisitedGERANCellInformation() {clear();}
+	struct undefined_t : asn::nulltype
+	{
+		static constexpr const char* name() {return "undefined_t";}
+		using parent_t = asn::nulltype;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<undefined_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<undefined_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<undefined_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<undefined_t>(1);
+
+	}
+	undefined_t& select_undefined() { if(get_index() != 1) { clear(); set_index(1); return var.build<undefined_t>();} return var.as<undefined_t>();}
+	undefined_t const* get_undefined() const { if(get_index() == 1) { return &var.as<undefined_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(undefined_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+LastVisitedNGRANCellInformation	::= OCTET STRING
+*/
+
+struct LastVisitedNGRANCellInformation : asn::ostring<>
+{
+	static constexpr const char* name() {return "LastVisitedNGRANCellInformation";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+LastVisitedCell-Item ::= CHOICE {
+	e-UTRAN-Cell					LastVisitedEUTRANCellInformation,
+	uTRAN-Cell						LastVisitedUTRANCellInformation,
+	gERAN-Cell						LastVisitedGERANCellInformation,
+	...,
+	nG-RAN-Cell						LastVisitedNGRANCellInformation
+}
+*/
+
+struct LastVisitedCell_Item : asn::choice<4, 1, true>
+{
+	static constexpr const char* name() {return "LastVisitedCell-Item";}
+	using parent_t = asn::choice<4, 1, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 5;}
+	void set_unknown() { set_index(5);  }
+	~LastVisitedCell_Item() {clear();}
+	struct e_UTRAN_Cell_t : LastVisitedEUTRANCellInformation
+	{
+		static constexpr const char* name() {return "e_UTRAN_Cell_t";}
+		using parent_t = LastVisitedEUTRANCellInformation;
+
+	};
+	struct uTRAN_Cell_t : LastVisitedUTRANCellInformation
+	{
+		static constexpr const char* name() {return "uTRAN_Cell_t";}
+		using parent_t = LastVisitedUTRANCellInformation;
+
+	};
+	struct gERAN_Cell_t : LastVisitedGERANCellInformation
+	{
+		static constexpr const char* name() {return "gERAN_Cell_t";}
+		using parent_t = LastVisitedGERANCellInformation;
+
+	};
+	struct nG_RAN_Cell_t : LastVisitedNGRANCellInformation
+	{
+		static constexpr const char* name() {return "nG_RAN_Cell_t";}
+		using parent_t = LastVisitedNGRANCellInformation;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<e_UTRAN_Cell_t>(); break;
+		case 2: var.destroy<uTRAN_Cell_t>(); break;
+		case 3: var.destroy<gERAN_Cell_t>(); break;
+		case 4: var.destroy<nG_RAN_Cell_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<e_UTRAN_Cell_t>());
+		case 2: set_index(2); return v(var.build<uTRAN_Cell_t>());
+		case 3: set_index(3); return v(var.build<gERAN_Cell_t>());
+		case 4: set_index(4); return v(var.build<nG_RAN_Cell_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<e_UTRAN_Cell_t>());
+		case 2: return v(var.as<uTRAN_Cell_t>());
+		case 3: return v(var.as<gERAN_Cell_t>());
+		case 4: return v(var.as<nG_RAN_Cell_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<e_UTRAN_Cell_t>(1);
+		v.template operator()<uTRAN_Cell_t>(2);
+		v.template operator()<gERAN_Cell_t>(3);
+		v.template operator()<nG_RAN_Cell_t>(4);
+
+	}
+	e_UTRAN_Cell_t& select_e_UTRAN_Cell() { if(get_index() != 1) { clear(); set_index(1); return var.build<e_UTRAN_Cell_t>();} return var.as<e_UTRAN_Cell_t>();}
+	e_UTRAN_Cell_t const* get_e_UTRAN_Cell() const { if(get_index() == 1) { return &var.as<e_UTRAN_Cell_t>();} return nullptr; }
+	uTRAN_Cell_t& select_uTRAN_Cell() { if(get_index() != 2) { clear(); set_index(2); return var.build<uTRAN_Cell_t>();} return var.as<uTRAN_Cell_t>();}
+	uTRAN_Cell_t const* get_uTRAN_Cell() const { if(get_index() == 2) { return &var.as<uTRAN_Cell_t>();} return nullptr; }
+	gERAN_Cell_t& select_gERAN_Cell() { if(get_index() != 3) { clear(); set_index(3); return var.build<gERAN_Cell_t>();} return var.as<gERAN_Cell_t>();}
+	gERAN_Cell_t const* get_gERAN_Cell() const { if(get_index() == 3) { return &var.as<gERAN_Cell_t>();} return nullptr; }
+	nG_RAN_Cell_t& select_nG_RAN_Cell() { if(get_index() != 4) { clear(); set_index(4); return var.build<nG_RAN_Cell_t>();} return var.as<nG_RAN_Cell_t>();}
+	nG_RAN_Cell_t const* get_nG_RAN_Cell() const { if(get_index() == 4) { return &var.as<nG_RAN_Cell_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(e_UTRAN_Cell_t)];
+		char dummy2[sizeof(uTRAN_Cell_t)];
+		char dummy3[sizeof(gERAN_Cell_t)];
+		char dummy4[sizeof(nG_RAN_Cell_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+Links-to-log ::= ENUMERATED {uplink, downlink, both-uplink-and-downlink, ...}
+*/
+
+struct Links_to_log : asn::enumerated<3, 0, true>
+{
+	static constexpr const char* name() {return "Links-to-log";}
+	using parent_t = asn::enumerated<3, 0, true>;
+	typedef enum {
+		uplink
+		,downlink
+		,both_uplink_and_downlink
+	} index_t;
+
+};
+
+/*
+ReportArea ::= ENUMERATED{
+	ecgi,
+	...
+}
+*/
+
+struct ReportArea : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "ReportArea";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		ecgi
+	} index_t;
+
+};
+
+/*
+LocationReportingInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::={
+	...
+}
+*/
+
+struct LocationReportingInformation_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+LocationReportingInformation ::= SEQUENCE {
+	eventType		EventType,
+	reportArea		ReportArea,
+	iE-Extensions		ProtocolExtensionContainer { {LocationReportingInformation-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct LocationReportingInformation : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "LocationReportingInformation";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct eventType_t : EventType
+	{
+		static constexpr const char* name() {return "eventType_t";}
+		using parent_t = EventType;
+
+	};
+	eventType_t& ref_eventType() {return eventType;}
+	eventType_t const& ref_eventType() const {return eventType;}
+	struct reportArea_t : ReportArea
+	{
+		static constexpr const char* name() {return "reportArea_t";}
+		using parent_t = ReportArea;
+
+	};
+	reportArea_t& ref_reportArea() {return reportArea;}
+	reportArea_t const& ref_reportArea() const {return reportArea;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<LocationReportingInformation_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<LocationReportingInformation_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(eventType);
+		v(reportArea);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(eventType);
+		v(reportArea);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		eventType.clear();
+		reportArea.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	eventType_t	eventType;
+	reportArea_t	reportArea;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ReportIntervalMDT ::= ENUMERATED {ms120, ms240, ms480, ms640, ms1024, ms2048, ms5120, ms10240, min1, min6, min12, min30, min60}
+*/
+
+struct ReportIntervalMDT : asn::enumerated<13, 0, false>
+{
+	static constexpr const char* name() {return "ReportIntervalMDT";}
+	using parent_t = asn::enumerated<13, 0, false>;
+	typedef enum {
+		ms120
+		,ms240
+		,ms480
+		,ms640
+		,ms1024
+		,ms2048
+		,ms5120
+		,ms10240
+		,min1
+		,min6
+		,min12
+		,min30
+		,min60
+	} index_t;
+
+};
+
+/*
+ReportAmountMDT ::= ENUMERATED{r1, r2, r4, r8, r16, r32, r64, rinfinity}
+*/
+
+struct ReportAmountMDT : asn::enumerated<8, 0, false>
+{
+	static constexpr const char* name() {return "ReportAmountMDT";}
+	using parent_t = asn::enumerated<8, 0, false>;
+	typedef enum {
+		r1
+		,r2
+		,r4
+		,r8
+		,r16
+		,r32
+		,r64
+		,rinfinity
+	} index_t;
+
+};
+
+/*
+M1PeriodicReporting-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct M1PeriodicReporting_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+M1PeriodicReporting ::= SEQUENCE {
+	reportInterval				ReportIntervalMDT,
+	reportAmount				ReportAmountMDT,
+	iE-Extensions				ProtocolExtensionContainer { {M1PeriodicReporting-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct M1PeriodicReporting : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "M1PeriodicReporting";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct reportInterval_t : ReportIntervalMDT
+	{
+		static constexpr const char* name() {return "reportInterval_t";}
+		using parent_t = ReportIntervalMDT;
+
+	};
+	reportInterval_t& ref_reportInterval() {return reportInterval;}
+	reportInterval_t const& ref_reportInterval() const {return reportInterval;}
+	struct reportAmount_t : ReportAmountMDT
+	{
+		static constexpr const char* name() {return "reportAmount_t";}
+		using parent_t = ReportAmountMDT;
+
+	};
+	reportAmount_t& ref_reportAmount() {return reportAmount;}
+	reportAmount_t const& ref_reportAmount() const {return reportAmount;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<M1PeriodicReporting_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<M1PeriodicReporting_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(reportInterval);
+		v(reportAmount);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(reportInterval);
+		v(reportAmount);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		reportInterval.clear();
+		reportAmount.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	reportInterval_t	reportInterval;
+	reportAmount_t	reportAmount;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+M1ReportingTrigger::= ENUMERATED{
+	periodic,
+	a2eventtriggered,
+	...,
+	a2eventtriggered-periodic
+}
+*/
+
+struct M1ReportingTrigger : asn::enumerated<3, 1, true>
+{
+	static constexpr const char* name() {return "M1ReportingTrigger";}
+	using parent_t = asn::enumerated<3, 1, true>;
+	typedef enum {
+		periodic
+		,a2eventtriggered
+		,a2eventtriggered_periodic
+	} index_t;
+
+};
+
+/*
+Threshold-RSRP ::= INTEGER(0..97)
+*/
+
+struct Threshold_RSRP : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 97>>;
+	static constexpr const char* name() {return "Threshold-RSRP";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+Threshold-RSRQ ::= INTEGER(0..34)
+*/
+
+struct Threshold_RSRQ : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 34>>;
+	static constexpr const char* name() {return "Threshold-RSRQ";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+MeasurementThresholdA2 ::= CHOICE {
+	threshold-RSRP				Threshold-RSRP,
+	threshold-RSRQ				Threshold-RSRQ,
+	...
+}
+*/
+
+struct MeasurementThresholdA2 : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "MeasurementThresholdA2";}
+	using parent_t = asn::choice<2, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 3;}
+	void set_unknown() { set_index(3);  }
+	~MeasurementThresholdA2() {clear();}
+	struct threshold_RSRP_t : Threshold_RSRP
+	{
+		static constexpr const char* name() {return "threshold_RSRP_t";}
+		using parent_t = Threshold_RSRP;
+
+	};
+	struct threshold_RSRQ_t : Threshold_RSRQ
+	{
+		static constexpr const char* name() {return "threshold_RSRQ_t";}
+		using parent_t = Threshold_RSRQ;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<threshold_RSRP_t>(); break;
+		case 2: var.destroy<threshold_RSRQ_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<threshold_RSRP_t>());
+		case 2: set_index(2); return v(var.build<threshold_RSRQ_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<threshold_RSRP_t>());
+		case 2: return v(var.as<threshold_RSRQ_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<threshold_RSRP_t>(1);
+		v.template operator()<threshold_RSRQ_t>(2);
+
+	}
+	threshold_RSRP_t& select_threshold_RSRP() { if(get_index() != 1) { clear(); set_index(1); return var.build<threshold_RSRP_t>();} return var.as<threshold_RSRP_t>();}
+	threshold_RSRP_t const* get_threshold_RSRP() const { if(get_index() == 1) { return &var.as<threshold_RSRP_t>();} return nullptr; }
+	threshold_RSRQ_t& select_threshold_RSRQ() { if(get_index() != 2) { clear(); set_index(2); return var.build<threshold_RSRQ_t>();} return var.as<threshold_RSRQ_t>();}
+	threshold_RSRQ_t const* get_threshold_RSRQ() const { if(get_index() == 2) { return &var.as<threshold_RSRQ_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(threshold_RSRP_t)];
+		char dummy2[sizeof(threshold_RSRQ_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+M1ThresholdEventA2-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct M1ThresholdEventA2_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+M1ThresholdEventA2 ::= SEQUENCE {
+	measurementThreshold		MeasurementThresholdA2,
+	iE-Extensions				ProtocolExtensionContainer { {M1ThresholdEventA2-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct M1ThresholdEventA2 : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "M1ThresholdEventA2";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct measurementThreshold_t : MeasurementThresholdA2
+	{
+		static constexpr const char* name() {return "measurementThreshold_t";}
+		using parent_t = MeasurementThresholdA2;
+
+	};
+	measurementThreshold_t& ref_measurementThreshold() {return measurementThreshold;}
+	measurementThreshold_t const& ref_measurementThreshold() const {return measurementThreshold;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<M1ThresholdEventA2_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<M1ThresholdEventA2_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(measurementThreshold);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(measurementThreshold);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		measurementThreshold.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	measurementThreshold_t	measurementThreshold;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+M3period ::= ENUMERATED {ms100, ms1000, ms10000, ... }
+*/
+
+struct M3period : asn::enumerated<3, 0, true>
+{
+	static constexpr const char* name() {return "M3period";}
+	using parent_t = asn::enumerated<3, 0, true>;
+	typedef enum {
+		ms100
+		,ms1000
+		,ms10000
+	} index_t;
+
+};
+
+/*
+M3Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct M3Configuration_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+M3Configuration ::= SEQUENCE {
+	m3period			M3period,
+	iE-Extensions		ProtocolExtensionContainer { {M3Configuration-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct M3Configuration : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "M3Configuration";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct m3period_t : M3period
+	{
+		static constexpr const char* name() {return "m3period_t";}
+		using parent_t = M3period;
+
+	};
+	m3period_t& ref_m3period() {return m3period;}
+	m3period_t const& ref_m3period() const {return m3period;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<M3Configuration_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<M3Configuration_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(m3period);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(m3period);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		m3period.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	m3period_t	m3period;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+M4period ::= ENUMERATED {ms1024, ms2048, ms5120, ms10240, min1, ... }
+*/
+
+struct M4period : asn::enumerated<5, 0, true>
+{
+	static constexpr const char* name() {return "M4period";}
+	using parent_t = asn::enumerated<5, 0, true>;
+	typedef enum {
+		ms1024
+		,ms2048
+		,ms5120
+		,ms10240
+		,min1
+	} index_t;
+
+};
+
+/*
+M4Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct M4Configuration_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+M4Configuration ::= SEQUENCE {
+	m4period			M4period,
+	m4-links-to-log		Links-to-log,
+	iE-Extensions		ProtocolExtensionContainer { {M4Configuration-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct M4Configuration : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "M4Configuration";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct m4period_t : M4period
+	{
+		static constexpr const char* name() {return "m4period_t";}
+		using parent_t = M4period;
+
+	};
+	m4period_t& ref_m4period() {return m4period;}
+	m4period_t const& ref_m4period() const {return m4period;}
+	struct m4_links_to_log_t : Links_to_log
+	{
+		static constexpr const char* name() {return "m4_links_to_log_t";}
+		using parent_t = Links_to_log;
+
+	};
+	m4_links_to_log_t& ref_m4_links_to_log() {return m4_links_to_log;}
+	m4_links_to_log_t const& ref_m4_links_to_log() const {return m4_links_to_log;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<M4Configuration_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<M4Configuration_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(m4period);
+		v(m4_links_to_log);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(m4period);
+		v(m4_links_to_log);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		m4period.clear();
+		m4_links_to_log.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	m4period_t	m4period;
+	m4_links_to_log_t	m4_links_to_log;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+M5period ::= ENUMERATED {ms1024, ms2048, ms5120, ms10240, min1, ... }
+*/
+
+struct M5period : asn::enumerated<5, 0, true>
+{
+	static constexpr const char* name() {return "M5period";}
+	using parent_t = asn::enumerated<5, 0, true>;
+	typedef enum {
+		ms1024
+		,ms2048
+		,ms5120
+		,ms10240
+		,min1
+	} index_t;
+
+};
+
+/*
+M5Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct M5Configuration_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+M5Configuration ::= SEQUENCE {
+	m5period			M5period,
+	m5-links-to-log		Links-to-log,
+	iE-Extensions		ProtocolExtensionContainer { {M5Configuration-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct M5Configuration : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "M5Configuration";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct m5period_t : M5period
+	{
+		static constexpr const char* name() {return "m5period_t";}
+		using parent_t = M5period;
+
+	};
+	m5period_t& ref_m5period() {return m5period;}
+	m5period_t const& ref_m5period() const {return m5period;}
+	struct m5_links_to_log_t : Links_to_log
+	{
+		static constexpr const char* name() {return "m5_links_to_log_t";}
+		using parent_t = Links_to_log;
+
+	};
+	m5_links_to_log_t& ref_m5_links_to_log() {return m5_links_to_log;}
+	m5_links_to_log_t const& ref_m5_links_to_log() const {return m5_links_to_log;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<M5Configuration_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<M5Configuration_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(m5period);
+		v(m5_links_to_log);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(m5period);
+		v(m5_links_to_log);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		m5period.clear();
+		m5_links_to_log.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	m5period_t	m5period;
+	m5_links_to_log_t	m5_links_to_log;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+M6report-interval ::= ENUMERATED { ms1024, ms2048, ms5120, ms10240, ... }
+*/
+
+struct M6report_interval : asn::enumerated<4, 0, true>
+{
+	static constexpr const char* name() {return "M6report-interval";}
+	using parent_t = asn::enumerated<4, 0, true>;
+	typedef enum {
+		ms1024
+		,ms2048
+		,ms5120
+		,ms10240
+	} index_t;
+
+};
+
+/*
+M6delay-threshold ::= ENUMERATED { ms30, ms40, ms50, ms60, ms70, ms80, ms90, ms100, ms150, ms300, ms500, ms750, ... }
+*/
+
+struct M6delay_threshold : asn::enumerated<12, 0, true>
+{
+	static constexpr const char* name() {return "M6delay-threshold";}
+	using parent_t = asn::enumerated<12, 0, true>;
+	typedef enum {
+		ms30
+		,ms40
+		,ms50
+		,ms60
+		,ms70
+		,ms80
+		,ms90
+		,ms100
+		,ms150
+		,ms300
+		,ms500
+		,ms750
+	} index_t;
+
+};
+
+/*
+M6Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct M6Configuration_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+M6Configuration ::= SEQUENCE {
+	m6report-interval	M6report-interval,
+	m6delay-threshold	M6delay-threshold	OPTIONAL,
+-- This IE shall be present if the M6 Links to log IE is set to “uplink” or to “both-uplink-and-downlink” --
+	m6-links-to-log		Links-to-log,
+	iE-Extensions		ProtocolExtensionContainer { {M6Configuration-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct M6Configuration : asn::sequence<4, 0, true, 2>
+{
+	static constexpr const char* name() {return "M6Configuration";}
+	using parent_t = asn::sequence<4, 0, true, 2>;
+	struct m6report_interval_t : M6report_interval
+	{
+		static constexpr const char* name() {return "m6report_interval_t";}
+		using parent_t = M6report_interval;
+
+	};
+	m6report_interval_t& ref_m6report_interval() {return m6report_interval;}
+	m6report_interval_t const& ref_m6report_interval() const {return m6report_interval;}
+	struct m6delay_threshold_t : M6delay_threshold
+	{
+		static constexpr const char* name() {return "m6delay_threshold_t";}
+		using parent_t = M6delay_threshold;
+		static constexpr bool optional = true;
+
+	};
+	m6delay_threshold_t& set_m6delay_threshold() { m6delay_threshold.setpresent(true); return m6delay_threshold;}
+	m6delay_threshold_t const* get_m6delay_threshold() const {return m6delay_threshold.is_valid() ? &m6delay_threshold : nullptr;}
+	struct m6_links_to_log_t : Links_to_log
+	{
+		static constexpr const char* name() {return "m6_links_to_log_t";}
+		using parent_t = Links_to_log;
+
+	};
+	m6_links_to_log_t& ref_m6_links_to_log() {return m6_links_to_log;}
+	m6_links_to_log_t const& ref_m6_links_to_log() const {return m6_links_to_log;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<M6Configuration_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<M6Configuration_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(m6report_interval);
+		v(m6delay_threshold);
+		v(m6_links_to_log);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(m6report_interval);
+		v(m6delay_threshold);
+		v(m6_links_to_log);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		m6report_interval.clear();
+		m6delay_threshold.clear();
+		m6_links_to_log.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	m6report_interval_t	m6report_interval;
+	m6delay_threshold_t	m6delay_threshold;
+	m6_links_to_log_t	m6_links_to_log;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+M7period ::= INTEGER(1..60, ...)
+*/
+
+struct M7period : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<1, 60>>;
+	static constexpr const char* name() {return "M7period";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+M7Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct M7Configuration_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+M7Configuration ::= SEQUENCE {
+	m7period			M7period,
+	m7-links-to-log		Links-to-log,
+	iE-Extensions		ProtocolExtensionContainer { {M7Configuration-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct M7Configuration : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "M7Configuration";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct m7period_t : M7period
+	{
+		static constexpr const char* name() {return "m7period_t";}
+		using parent_t = M7period;
+
+	};
+	m7period_t& ref_m7period() {return m7period;}
+	m7period_t const& ref_m7period() const {return m7period;}
+	struct m7_links_to_log_t : Links_to_log
+	{
+		static constexpr const char* name() {return "m7_links_to_log_t";}
+		using parent_t = Links_to_log;
+
+	};
+	m7_links_to_log_t& ref_m7_links_to_log() {return m7_links_to_log;}
+	m7_links_to_log_t const& ref_m7_links_to_log() const {return m7_links_to_log;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<M7Configuration_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<M7Configuration_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(m7period);
+		v(m7_links_to_log);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(m7period);
+		v(m7_links_to_log);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		m7period.clear();
+		m7_links_to_log.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	m7period_t	m7period;
+	m7_links_to_log_t	m7_links_to_log;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+MBMS-Service-Area-Identity ::= OCTET STRING (SIZE (2))
+*/
+
+struct MBMS_Service_Area_Identity : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<2>>;
+	static constexpr const char* name() {return "MBMS-Service-Area-Identity";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+MBMS-Service-Area-Identity-List ::= SEQUENCE (SIZE(1.. maxnoofMBMSServiceAreaIdentities)) OF MBMS-Service-Area-Identity
+*/
+
+struct MBMS_Service_Area_Identity_List_elm : MBMS_Service_Area_Identity
+{
+	static constexpr const char* name() {return "MBMS_Service_Area_Identity_List_elm";}
+	using parent_t = MBMS_Service_Area_Identity;
+
+};
+struct MBMS_Service_Area_Identity_List : asn::sequenceof<MBMS_Service_Area_Identity_List_elm>
+{
+	static constexpr const char* name() {return "MBMS-Service-Area-Identity-List";}
+	using parent_t = asn::sequenceof<MBMS_Service_Area_Identity_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofMBMSServiceAreaIdentities >>;
+
+};
+/*
+RadioframeAllocationPeriod ::= ENUMERATED{
+	n1,
+	n2,
+	n4,
+	n8,
+	n16,
+	n32,
+	...
+}
+*/
+
+struct RadioframeAllocationPeriod : asn::enumerated<6, 0, true>
+{
+	static constexpr const char* name() {return "RadioframeAllocationPeriod";}
+	using parent_t = asn::enumerated<6, 0, true>;
+	typedef enum {
+		n1
+		,n2
+		,n4
+		,n8
+		,n16
+		,n32
+	} index_t;
+
+};
+
+/*
+RadioframeAllocationOffset ::= INTEGER (0..7, ...)
+*/
+
+struct RadioframeAllocationOffset : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<0, 7>>;
+	static constexpr const char* name() {return "RadioframeAllocationOffset";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+Oneframe ::= BIT STRING (SIZE (6))
+*/
+
+struct Oneframe : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<6>>;
+	static constexpr const char* name() {return "Oneframe";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+SubframeAllocation ::= CHOICE {
+	oneframe						Oneframe,
+	fourframes						Fourframes,
+	...
+}
+*/
+
+struct SubframeAllocation : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "SubframeAllocation";}
+	using parent_t = asn::choice<2, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 3;}
+	void set_unknown() { set_index(3);  }
+	~SubframeAllocation() {clear();}
+	struct oneframe_t : Oneframe
+	{
+		static constexpr const char* name() {return "oneframe_t";}
+		using parent_t = Oneframe;
+
+	};
+	struct fourframes_t : Fourframes
+	{
+		static constexpr const char* name() {return "fourframes_t";}
+		using parent_t = Fourframes;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<oneframe_t>(); break;
+		case 2: var.destroy<fourframes_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<oneframe_t>());
+		case 2: set_index(2); return v(var.build<fourframes_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<oneframe_t>());
+		case 2: return v(var.as<fourframes_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<oneframe_t>(1);
+		v.template operator()<fourframes_t>(2);
+
+	}
+	oneframe_t& select_oneframe() { if(get_index() != 1) { clear(); set_index(1); return var.build<oneframe_t>();} return var.as<oneframe_t>();}
+	oneframe_t const* get_oneframe() const { if(get_index() == 1) { return &var.as<oneframe_t>();} return nullptr; }
+	fourframes_t& select_fourframes() { if(get_index() != 2) { clear(); set_index(2); return var.build<fourframes_t>();} return var.as<fourframes_t>();}
+	fourframes_t const* get_fourframes() const { if(get_index() == 2) { return &var.as<fourframes_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(oneframe_t)];
+		char dummy2[sizeof(fourframes_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+MBSFN-Subframe-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct MBSFN_Subframe_Info_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+MBSFN-Subframe-Info	::= SEQUENCE {
+	radioframeAllocationPeriod		RadioframeAllocationPeriod,
+	radioframeAllocationOffset		RadioframeAllocationOffset,
+	subframeAllocation				SubframeAllocation,
+	iE-Extensions					ProtocolExtensionContainer { {MBSFN-Subframe-Info-ExtIEs} } 	OPTIONAL,
+	...
+}
+*/
+
+struct MBSFN_Subframe_Info : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "MBSFN-Subframe-Info";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct radioframeAllocationPeriod_t : RadioframeAllocationPeriod
+	{
+		static constexpr const char* name() {return "radioframeAllocationPeriod_t";}
+		using parent_t = RadioframeAllocationPeriod;
+
+	};
+	radioframeAllocationPeriod_t& ref_radioframeAllocationPeriod() {return radioframeAllocationPeriod;}
+	radioframeAllocationPeriod_t const& ref_radioframeAllocationPeriod() const {return radioframeAllocationPeriod;}
+	struct radioframeAllocationOffset_t : RadioframeAllocationOffset
+	{
+		static constexpr const char* name() {return "radioframeAllocationOffset_t";}
+		using parent_t = RadioframeAllocationOffset;
+
+	};
+	radioframeAllocationOffset_t& ref_radioframeAllocationOffset() {return radioframeAllocationOffset;}
+	radioframeAllocationOffset_t const& ref_radioframeAllocationOffset() const {return radioframeAllocationOffset;}
+	struct subframeAllocation_t : SubframeAllocation
+	{
+		static constexpr const char* name() {return "subframeAllocation_t";}
+		using parent_t = SubframeAllocation;
+
+	};
+	subframeAllocation_t& ref_subframeAllocation() {return subframeAllocation;}
+	subframeAllocation_t const& ref_subframeAllocation() const {return subframeAllocation;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<MBSFN_Subframe_Info_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<MBSFN_Subframe_Info_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(radioframeAllocationPeriod);
+		v(radioframeAllocationOffset);
+		v(subframeAllocation);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(radioframeAllocationPeriod);
+		v(radioframeAllocationOffset);
+		v(subframeAllocation);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		radioframeAllocationPeriod.clear();
+		radioframeAllocationOffset.clear();
+		subframeAllocation.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	radioframeAllocationPeriod_t	radioframeAllocationPeriod;
+	radioframeAllocationOffset_t	radioframeAllocationOffset;
+	subframeAllocation_t	subframeAllocation;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+MBSFN-Subframe-Infolist::= SEQUENCE (SIZE(1.. maxnoofMBSFN)) OF MBSFN-Subframe-Info
+*/
+
+struct MBSFN_Subframe_Infolist_elm : MBSFN_Subframe_Info
+{
+	static constexpr const char* name() {return "MBSFN_Subframe_Infolist_elm";}
+	using parent_t = MBSFN_Subframe_Info;
+
+};
+struct MBSFN_Subframe_Infolist : asn::sequenceof<MBSFN_Subframe_Infolist_elm>
+{
+	static constexpr const char* name() {return "MBSFN-Subframe-Infolist";}
+	using parent_t = asn::sequenceof<MBSFN_Subframe_Infolist_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofMBSFN >>;
+
+};
+/*
+MDT-Activation		::= ENUMERATED {
+	immediate-MDT-only,
+	immediate-MDT-and-Trace,
+	...
+}
+*/
+
+struct MDT_Activation : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "MDT-Activation";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		immediate_MDT_only
+		,immediate_MDT_and_Trace
+	} index_t;
+
+};
+
+/*
+MeasurementsToActivate::= BIT STRING (SIZE (8))
+*/
+
+struct MeasurementsToActivate : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<8>>;
+	static constexpr const char* name() {return "MeasurementsToActivate";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+MDT-Location-Info ::= BIT STRING (SIZE (8))
+*/
+
+struct MDT_Location_Info : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<8>>;
+	static constexpr const char* name() {return "MDT-Location-Info";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+MDTPLMNList ::= SEQUENCE (SIZE(1..maxnoofMDTPLMNs)) OF PLMN-Identity
+*/
+
+struct MDTPLMNList_elm : PLMN_Identity
+{
+	static constexpr const char* name() {return "MDTPLMNList_elm";}
+	using parent_t = PLMN_Identity;
+
+};
+struct MDTPLMNList : asn::sequenceof<MDTPLMNList_elm>
+{
+	static constexpr const char* name() {return "MDTPLMNList";}
+	using parent_t = asn::sequenceof<MDTPLMNList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofMDTPLMNs >>;
+
+};
+/*
+WLANMeasConfig::= ENUMERATED {setup,...}
+*/
+
+struct WLANMeasConfig : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "WLANMeasConfig";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		setup
+	} index_t;
+
+};
+
+/*
+WLANName ::= OCTET STRING (SIZE (1..32))
+*/
+
+struct WLANName : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::span<1, 32>>;
+	static constexpr const char* name() {return "WLANName";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+WLANMeasConfigNameList ::= SEQUENCE (SIZE(1..maxnoofWLANName)) OF WLANName
+*/
+
+struct WLANMeasConfigNameList_elm : WLANName
+{
+	static constexpr const char* name() {return "WLANMeasConfigNameList_elm";}
+	using parent_t = WLANName;
+
+};
+struct WLANMeasConfigNameList : asn::sequenceof<WLANMeasConfigNameList_elm>
+{
+	static constexpr const char* name() {return "WLANMeasConfigNameList";}
+	using parent_t = asn::sequenceof<WLANMeasConfigNameList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofWLANName >>;
+
+};
+/*
+WLANMeasurementConfiguration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct WLANMeasurementConfiguration_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+WLANMeasurementConfiguration ::= SEQUENCE {
+	wlanMeasConfig				WLANMeasConfig,
+	wlanMeasConfigNameList		WLANMeasConfigNameList				OPTIONAL,
+	wlan-rssi					ENUMERATED {true, ...}				OPTIONAL,
+	wlan-rtt					ENUMERATED {true, ...}				OPTIONAL,
+	iE-Extensions		ProtocolExtensionContainer { {WLANMeasurementConfiguration-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct WLANMeasurementConfiguration : asn::sequence<5, 0, true, 4>
+{
+	static constexpr const char* name() {return "WLANMeasurementConfiguration";}
+	using parent_t = asn::sequence<5, 0, true, 4>;
+	struct wlanMeasConfig_t : WLANMeasConfig
+	{
+		static constexpr const char* name() {return "wlanMeasConfig_t";}
+		using parent_t = WLANMeasConfig;
+
+	};
+	wlanMeasConfig_t& ref_wlanMeasConfig() {return wlanMeasConfig;}
+	wlanMeasConfig_t const& ref_wlanMeasConfig() const {return wlanMeasConfig;}
+	struct wlanMeasConfigNameList_t : WLANMeasConfigNameList
+	{
+		static constexpr const char* name() {return "wlanMeasConfigNameList_t";}
+		using parent_t = WLANMeasConfigNameList;
+		static constexpr bool optional = true;
+
+	};
+	wlanMeasConfigNameList_t& set_wlanMeasConfigNameList() { wlanMeasConfigNameList.setpresent(true); return wlanMeasConfigNameList;}
+	wlanMeasConfigNameList_t const* get_wlanMeasConfigNameList() const {return wlanMeasConfigNameList.is_valid() ? &wlanMeasConfigNameList : nullptr;}
+	struct wlan_rssi_t : asn::enumerated<1, 0, true>
+	{
+		static constexpr const char* name() {return "wlan_rssi_t";}
+		using parent_t = asn::enumerated<1, 0, true>;
+		static constexpr bool optional = true;
+		typedef enum {
+			True
+		} index_t;
+
+	};
+
+	wlan_rssi_t& set_wlan_rssi() { wlan_rssi.setpresent(true); return wlan_rssi;}
+	wlan_rssi_t const* get_wlan_rssi() const {return wlan_rssi.is_valid() ? &wlan_rssi : nullptr;}
+	struct wlan_rtt_t : asn::enumerated<1, 0, true>
+	{
+		static constexpr const char* name() {return "wlan_rtt_t";}
+		using parent_t = asn::enumerated<1, 0, true>;
+		static constexpr bool optional = true;
+		typedef enum {
+			True
+		} index_t;
+
+	};
+
+	wlan_rtt_t& set_wlan_rtt() { wlan_rtt.setpresent(true); return wlan_rtt;}
+	wlan_rtt_t const* get_wlan_rtt() const {return wlan_rtt.is_valid() ? &wlan_rtt : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<WLANMeasurementConfiguration_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<WLANMeasurementConfiguration_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(wlanMeasConfig);
+		v(wlanMeasConfigNameList);
+		v(wlan_rssi);
+		v(wlan_rtt);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(wlanMeasConfig);
+		v(wlanMeasConfigNameList);
+		v(wlan_rssi);
+		v(wlan_rtt);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		wlanMeasConfig.clear();
+		wlanMeasConfigNameList.clear();
+		wlan_rssi.clear();
+		wlan_rtt.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	wlanMeasConfig_t	wlanMeasConfig;
+	wlanMeasConfigNameList_t	wlanMeasConfigNameList;
+	wlan_rssi_t	wlan_rssi;
+	wlan_rtt_t	wlan_rtt;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+MDT-Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ID id-M3Configuration							CRITICALITY ignore	EXTENSION M3Configuration								PRESENCE conditional}|
+	{ID id-M4Configuration							CRITICALITY ignore	EXTENSION M4Configuration								PRESENCE conditional}|
+	{ID id-M5Configuration							CRITICALITY ignore	EXTENSION M5Configuration								PRESENCE conditional}|
+	{ID id-MDT-Location-Info						CRITICALITY ignore	EXTENSION MDT-Location-Info							PRESENCE optional}|
+	{ID id-SignallingBasedMDTPLMNList				CRITICALITY ignore	EXTENSION MDTPLMNList									PRESENCE optional}|
+	{ID id-M6Configuration							CRITICALITY ignore	EXTENSION M6Configuration								PRESENCE conditional}|
+	{ID id-M7Configuration							CRITICALITY ignore	EXTENSION M7Configuration								PRESENCE conditional}|
+	{ ID id-BluetoothMeasurementConfiguration		CRITICALITY ignore	EXTENSION BluetoothMeasurementConfiguration		PRESENCE optional}|
+	{ ID id-WLANMeasurementConfiguration			CRITICALITY ignore	EXTENSION WLANMeasurementConfiguration			PRESENCE optional},
+	...
+}
+*/
+
+struct MDT_Configuration_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 10; }
+		void clear() {type = 0;}
+		void select_id_M3Configuration() { set(id_M3Configuration); type=1;}
+		void select_id_M4Configuration() { set(id_M4Configuration); type=2;}
+		void select_id_M5Configuration() { set(id_M5Configuration); type=3;}
+		void select_id_MDT_Location_Info() { set(id_MDT_Location_Info); type=4;}
+		void select_id_SignallingBasedMDTPLMNList() { set(id_SignallingBasedMDTPLMNList); type=5;}
+		void select_id_M6Configuration() { set(id_M6Configuration); type=6;}
+		void select_id_M7Configuration() { set(id_M7Configuration); type=7;}
+		void select_id_BluetoothMeasurementConfiguration() { set(id_BluetoothMeasurementConfiguration); type=8;}
+		void select_id_WLANMeasurementConfiguration() { set(id_WLANMeasurementConfiguration); type=9;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_M3Configuration)) { type = 1; return true; }
+			else if(equal(id_M4Configuration)) { type = 2; return true; }
+			else if(equal(id_M5Configuration)) { type = 3; return true; }
+			else if(equal(id_MDT_Location_Info)) { type = 4; return true; }
+			else if(equal(id_SignallingBasedMDTPLMNList)) { type = 5; return true; }
+			else if(equal(id_M6Configuration)) { type = 6; return true; }
+			else if(equal(id_M7Configuration)) { type = 7; return true; }
+			else if(equal(id_BluetoothMeasurementConfiguration)) { type = 8; return true; }
+			else if(equal(id_WLANMeasurementConfiguration)) { type = 9; return true; }
+			else { type = 10; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_M3Configuration);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_M4Configuration);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_M5Configuration);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_MDT_Location_Info);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_SignallingBasedMDTPLMNList);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_M6Configuration);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_M7Configuration);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_BluetoothMeasurementConfiguration);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_WLANMeasurementConfiguration);} return false;
+			case 10: type = 10; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 10; }
+		void clear() {type = 0;}
+		void select_id_M3Configuration() { set(ignore); type=1;}
+		void select_id_M4Configuration() { set(ignore); type=2;}
+		void select_id_M5Configuration() { set(ignore); type=3;}
+		void select_id_MDT_Location_Info() { set(ignore); type=4;}
+		void select_id_SignallingBasedMDTPLMNList() { set(ignore); type=5;}
+		void select_id_M6Configuration() { set(ignore); type=6;}
+		void select_id_M7Configuration() { set(ignore); type=7;}
+		void select_id_BluetoothMeasurementConfiguration() { set(ignore); type=8;}
+		void select_id_WLANMeasurementConfiguration() { set(ignore); type=9;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else if(equal(ignore)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(ignore)) { type = 4; return true; }
+			else if(equal(ignore)) { type = 5; return true; }
+			else if(equal(ignore)) { type = 6; return true; }
+			else if(equal(ignore)) { type = 7; return true; }
+			else if(equal(ignore)) { type = 8; return true; }
+			else if(equal(ignore)) { type = 9; return true; }
+			else { type = 10; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 10: type = 10; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		M3Configuration& select_id_M3Configuration() { return set<M3Configuration>(1); }
+		M3Configuration const* get_id_M3Configuration() const { return get<M3Configuration>(1); }
+		M4Configuration& select_id_M4Configuration() { return set<M4Configuration>(2); }
+		M4Configuration const* get_id_M4Configuration() const { return get<M4Configuration>(2); }
+		M5Configuration& select_id_M5Configuration() { return set<M5Configuration>(3); }
+		M5Configuration const* get_id_M5Configuration() const { return get<M5Configuration>(3); }
+		MDT_Location_Info& select_id_MDT_Location_Info() { return set<MDT_Location_Info>(4); }
+		MDT_Location_Info const* get_id_MDT_Location_Info() const { return get<MDT_Location_Info>(4); }
+		MDTPLMNList& select_id_SignallingBasedMDTPLMNList() { return set<MDTPLMNList>(5); }
+		MDTPLMNList const* get_id_SignallingBasedMDTPLMNList() const { return get<MDTPLMNList>(5); }
+		M6Configuration& select_id_M6Configuration() { return set<M6Configuration>(6); }
+		M6Configuration const* get_id_M6Configuration() const { return get<M6Configuration>(6); }
+		M7Configuration& select_id_M7Configuration() { return set<M7Configuration>(7); }
+		M7Configuration const* get_id_M7Configuration() const { return get<M7Configuration>(7); }
+		BluetoothMeasurementConfiguration& select_id_BluetoothMeasurementConfiguration() { return set<BluetoothMeasurementConfiguration>(8); }
+		BluetoothMeasurementConfiguration const* get_id_BluetoothMeasurementConfiguration() const { return get<BluetoothMeasurementConfiguration>(8); }
+		WLANMeasurementConfiguration& select_id_WLANMeasurementConfiguration() { return set<WLANMeasurementConfiguration>(9); }
+		WLANMeasurementConfiguration const* get_id_WLANMeasurementConfiguration() const { return get<WLANMeasurementConfiguration>(9); }
+		bool is_unknown() const { return type == 10; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<M3Configuration>(); break;
+			case 2: var.destroy<M4Configuration>(); break;
+			case 3: var.destroy<M5Configuration>(); break;
+			case 4: var.destroy<MDT_Location_Info>(); break;
+			case 5: var.destroy<MDTPLMNList>(); break;
+			case 6: var.destroy<M6Configuration>(); break;
+			case 7: var.destroy<M7Configuration>(); break;
+			case 8: var.destroy<BluetoothMeasurementConfiguration>(); break;
+			case 9: var.destroy<WLANMeasurementConfiguration>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<M3Configuration>(1);
+			v.template operator()<M4Configuration>(2);
+			v.template operator()<M5Configuration>(3);
+			v.template operator()<MDT_Location_Info>(4);
+			v.template operator()<MDTPLMNList>(5);
+			v.template operator()<M6Configuration>(6);
+			v.template operator()<M7Configuration>(7);
+			v.template operator()<BluetoothMeasurementConfiguration>(8);
+			v.template operator()<WLANMeasurementConfiguration>(9);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_M3Configuration()); return true;
+			case 2: v(select_id_M4Configuration()); return true;
+			case 3: v(select_id_M5Configuration()); return true;
+			case 4: v(select_id_MDT_Location_Info()); return true;
+			case 5: v(select_id_SignallingBasedMDTPLMNList()); return true;
+			case 6: v(select_id_M6Configuration()); return true;
+			case 7: v(select_id_M7Configuration()); return true;
+			case 8: v(select_id_BluetoothMeasurementConfiguration()); return true;
+			case 9: v(select_id_WLANMeasurementConfiguration()); return true;
+			case 10: if(type != 10) {clear(); asn::base::set();} type = 10; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<M3Configuration>()); return true;
+			case 2: v(var.as<M4Configuration>()); return true;
+			case 3: v(var.as<M5Configuration>()); return true;
+			case 4: v(var.as<MDT_Location_Info>()); return true;
+			case 5: v(var.as<MDTPLMNList>()); return true;
+			case 6: v(var.as<M6Configuration>()); return true;
+			case 7: v(var.as<M7Configuration>()); return true;
+			case 8: v(var.as<BluetoothMeasurementConfiguration>()); return true;
+			case 9: v(var.as<WLANMeasurementConfiguration>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(BluetoothMeasurementConfiguration)];
+			char dummy2[sizeof(M3Configuration)];
+			char dummy3[sizeof(M4Configuration)];
+			char dummy4[sizeof(M5Configuration)];
+			char dummy5[sizeof(M6Configuration)];
+			char dummy6[sizeof(M7Configuration)];
+			char dummy7[sizeof(MDTPLMNList)];
+			char dummy8[sizeof(MDT_Location_Info)];
+			char dummy9[sizeof(WLANMeasurementConfiguration)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 10; }
+		void clear() {type = 0;}
+		void select_id_M3Configuration() { set(conditional); type=1;}
+		void select_id_M4Configuration() { set(conditional); type=2;}
+		void select_id_M5Configuration() { set(conditional); type=3;}
+		void select_id_MDT_Location_Info() { set(optional); type=4;}
+		void select_id_SignallingBasedMDTPLMNList() { set(optional); type=5;}
+		void select_id_M6Configuration() { set(conditional); type=6;}
+		void select_id_M7Configuration() { set(conditional); type=7;}
+		void select_id_BluetoothMeasurementConfiguration() { set(optional); type=8;}
+		void select_id_WLANMeasurementConfiguration() { set(optional); type=9;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(conditional)) { type = 1; return true; }
+			else if(equal(conditional)) { type = 2; return true; }
+			else if(equal(conditional)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else if(equal(conditional)) { type = 6; return true; }
+			else if(equal(conditional)) { type = 7; return true; }
+			else if(equal(optional)) { type = 8; return true; }
+			else if(equal(optional)) { type = 9; return true; }
+			else { type = 10; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(conditional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(conditional);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(conditional);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(conditional);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(conditional);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
+			case 10: type = 10; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+MDT-Configuration ::= SEQUENCE {
+	mdt-Activation				MDT-Activation,
+	areaScopeOfMDT				AreaScopeOfMDT,
+	measurementsToActivate		MeasurementsToActivate,
+	m1reportingTrigger			M1ReportingTrigger,
+	m1thresholdeventA2			M1ThresholdEventA2			OPTIONAL,
+-- Included in case of event-triggered, or event-triggered periodic reporting for measurement M1
+	m1periodicReporting			M1PeriodicReporting			OPTIONAL,
+-- Included in case of periodic, or event-triggered periodic reporting for measurement M1
+	iE-Extensions				ProtocolExtensionContainer { {MDT-Configuration-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct MDT_Configuration : asn::sequence<7, 0, true, 3>
+{
+	static constexpr const char* name() {return "MDT-Configuration";}
+	using parent_t = asn::sequence<7, 0, true, 3>;
+	struct mdt_Activation_t : MDT_Activation
+	{
+		static constexpr const char* name() {return "mdt_Activation_t";}
+		using parent_t = MDT_Activation;
+
+	};
+	mdt_Activation_t& ref_mdt_Activation() {return mdt_Activation;}
+	mdt_Activation_t const& ref_mdt_Activation() const {return mdt_Activation;}
+	struct areaScopeOfMDT_t : AreaScopeOfMDT
+	{
+		static constexpr const char* name() {return "areaScopeOfMDT_t";}
+		using parent_t = AreaScopeOfMDT;
+
+	};
+	areaScopeOfMDT_t& ref_areaScopeOfMDT() {return areaScopeOfMDT;}
+	areaScopeOfMDT_t const& ref_areaScopeOfMDT() const {return areaScopeOfMDT;}
+	struct measurementsToActivate_t : MeasurementsToActivate
+	{
+		static constexpr const char* name() {return "measurementsToActivate_t";}
+		using parent_t = MeasurementsToActivate;
+
+	};
+	measurementsToActivate_t& ref_measurementsToActivate() {return measurementsToActivate;}
+	measurementsToActivate_t const& ref_measurementsToActivate() const {return measurementsToActivate;}
+	struct m1reportingTrigger_t : M1ReportingTrigger
+	{
+		static constexpr const char* name() {return "m1reportingTrigger_t";}
+		using parent_t = M1ReportingTrigger;
+
+	};
+	m1reportingTrigger_t& ref_m1reportingTrigger() {return m1reportingTrigger;}
+	m1reportingTrigger_t const& ref_m1reportingTrigger() const {return m1reportingTrigger;}
+	struct m1thresholdeventA2_t : M1ThresholdEventA2
+	{
+		static constexpr const char* name() {return "m1thresholdeventA2_t";}
+		using parent_t = M1ThresholdEventA2;
+		static constexpr bool optional = true;
+
+	};
+	m1thresholdeventA2_t& set_m1thresholdeventA2() { m1thresholdeventA2.setpresent(true); return m1thresholdeventA2;}
+	m1thresholdeventA2_t const* get_m1thresholdeventA2() const {return m1thresholdeventA2.is_valid() ? &m1thresholdeventA2 : nullptr;}
+	struct m1periodicReporting_t : M1PeriodicReporting
+	{
+		static constexpr const char* name() {return "m1periodicReporting_t";}
+		using parent_t = M1PeriodicReporting;
+		static constexpr bool optional = true;
+
+	};
+	m1periodicReporting_t& set_m1periodicReporting() { m1periodicReporting.setpresent(true); return m1periodicReporting;}
+	m1periodicReporting_t const* get_m1periodicReporting() const {return m1periodicReporting.is_valid() ? &m1periodicReporting : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<MDT_Configuration_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<MDT_Configuration_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(mdt_Activation);
+		v(areaScopeOfMDT);
+		v(measurementsToActivate);
+		v(m1reportingTrigger);
+		v(m1thresholdeventA2);
+		v(m1periodicReporting);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(mdt_Activation);
+		v(areaScopeOfMDT);
+		v(measurementsToActivate);
+		v(m1reportingTrigger);
+		v(m1thresholdeventA2);
+		v(m1periodicReporting);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		mdt_Activation.clear();
+		areaScopeOfMDT.clear();
+		measurementsToActivate.clear();
+		m1reportingTrigger.clear();
+		m1thresholdeventA2.clear();
+		m1periodicReporting.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	mdt_Activation_t	mdt_Activation;
+	areaScopeOfMDT_t	areaScopeOfMDT;
+	measurementsToActivate_t	measurementsToActivate;
+	m1reportingTrigger_t	m1reportingTrigger;
+	m1thresholdeventA2_t	m1thresholdeventA2;
+	m1periodicReporting_t	m1periodicReporting;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+MakeBeforeBreakIndicator::= ENUMERATED {true, ...}
+*/
+
+struct MakeBeforeBreakIndicator : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "MakeBeforeBreakIndicator";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		True
+	} index_t;
+
+};
+
+/*
+ManagementBasedMDTallowed ::= ENUMERATED {allowed, ...}
+*/
+
+struct ManagementBasedMDTallowed : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "ManagementBasedMDTallowed";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		allowed
+	} index_t;
+
+};
+
+/*
+Masked-IMEISV ::= BIT STRING (SIZE (64))
+*/
+
+struct Masked_IMEISV : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<64>>;
+	static constexpr const char* name() {return "Masked-IMEISV";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+MeNBCoordinationAssistanceInformation ::= ENUMERATED{
+	coordination-not-required,
+	...
+}
+*/
+
+struct MeNBCoordinationAssistanceInformation : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "MeNBCoordinationAssistanceInformation";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		coordination_not_required
+	} index_t;
+
+};
+
+/*
+NRCellIdentifier ::= BIT STRING (SIZE (36))
+*/
+
+struct NRCellIdentifier : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<36>>;
+	static constexpr const char* name() {return "NRCellIdentifier";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+NRCGI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct NRCGI_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+NRCGI ::= SEQUENCE {
+	pLMN-Identity				PLMN-Identity,
+	nRcellIdentifier				NRCellIdentifier,
+	iE-Extensions				ProtocolExtensionContainer { {NRCGI-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct NRCGI : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "NRCGI";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct pLMN_Identity_t : PLMN_Identity
+	{
+		static constexpr const char* name() {return "pLMN_Identity_t";}
+		using parent_t = PLMN_Identity;
+
+	};
+	pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+	pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+	struct nRcellIdentifier_t : NRCellIdentifier
+	{
+		static constexpr const char* name() {return "nRcellIdentifier_t";}
+		using parent_t = NRCellIdentifier;
+
+	};
+	nRcellIdentifier_t& ref_nRcellIdentifier() {return nRcellIdentifier;}
+	nRcellIdentifier_t const& ref_nRcellIdentifier() const {return nRcellIdentifier;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<NRCGI_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<NRCGI_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(pLMN_Identity);
+		v(nRcellIdentifier);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(pLMN_Identity);
+		v(nRcellIdentifier);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		pLMN_Identity.clear();
+		nRcellIdentifier.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	pLMN_Identity_t	pLMN_Identity;
+	nRcellIdentifier_t	nRcellIdentifier;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+MeNBResourceCoordinationInformationExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-NRCGI									CRITICALITY ignore	EXTENSION NRCGI												PRESENCE optional}|
+	{ ID id-MeNBCoordinationAssistanceInformation		CRITICALITY reject	EXTENSION MeNBCoordinationAssistanceInformation	PRESENCE optional},
+	...
+}
+*/
+
+struct MeNBResourceCoordinationInformationExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_NRCGI() { set(id_NRCGI); type=1;}
+		void select_id_MeNBCoordinationAssistanceInformation() { set(id_MeNBCoordinationAssistanceInformation); type=2;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_NRCGI)) { type = 1; return true; }
+			else if(equal(id_MeNBCoordinationAssistanceInformation)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_NRCGI);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_MeNBCoordinationAssistanceInformation);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_NRCGI() { set(ignore); type=1;}
+		void select_id_MeNBCoordinationAssistanceInformation() { set(reject); type=2;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else if(equal(reject)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		NRCGI& select_id_NRCGI() { return set<NRCGI>(1); }
+		NRCGI const* get_id_NRCGI() const { return get<NRCGI>(1); }
+		MeNBCoordinationAssistanceInformation& select_id_MeNBCoordinationAssistanceInformation() { return set<MeNBCoordinationAssistanceInformation>(2); }
+		MeNBCoordinationAssistanceInformation const* get_id_MeNBCoordinationAssistanceInformation() const { return get<MeNBCoordinationAssistanceInformation>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<NRCGI>(); break;
+			case 2: var.destroy<MeNBCoordinationAssistanceInformation>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<NRCGI>(1);
+			v.template operator()<MeNBCoordinationAssistanceInformation>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_NRCGI()); return true;
+			case 2: v(select_id_MeNBCoordinationAssistanceInformation()); return true;
+			case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<NRCGI>()); return true;
+			case 2: v(var.as<MeNBCoordinationAssistanceInformation>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(MeNBCoordinationAssistanceInformation)];
+			char dummy2[sizeof(NRCGI)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_NRCGI() { set(optional); type=1;}
+		void select_id_MeNBCoordinationAssistanceInformation() { set(optional); type=2;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else if(equal(optional)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+MeNBResourceCoordinationInformation ::= SEQUENCE {
+	eUTRA-Cell-ID					ECGI,
+	uLCoordinationInformation		BIT STRING (SIZE(6..4400, ...)),
+	dLCoordinationInformation		BIT STRING (SIZE(6..4400, ...))		OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {MeNBResourceCoordinationInformationExtIEs} }		 OPTIONAL,
+	...
+}
+*/
+
+struct MeNBResourceCoordinationInformation : asn::sequence<4, 0, true, 2>
+{
+	static constexpr const char* name() {return "MeNBResourceCoordinationInformation";}
+	using parent_t = asn::sequence<4, 0, true, 2>;
+	struct eUTRA_Cell_ID_t : ECGI
+	{
+		static constexpr const char* name() {return "eUTRA_Cell_ID_t";}
+		using parent_t = ECGI;
+
+	};
+	eUTRA_Cell_ID_t& ref_eUTRA_Cell_ID() {return eUTRA_Cell_ID;}
+	eUTRA_Cell_ID_t const& ref_eUTRA_Cell_ID() const {return eUTRA_Cell_ID;}
+	struct uLCoordinationInformation_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
+		static constexpr const char* name() {return "uLCoordinationInformation_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	uLCoordinationInformation_t& ref_uLCoordinationInformation() {return uLCoordinationInformation;}
+	uLCoordinationInformation_t const& ref_uLCoordinationInformation() const {return uLCoordinationInformation;}
+	struct dLCoordinationInformation_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
+		static constexpr const char* name() {return "dLCoordinationInformation_t";}
+		using parent_t = asn::bstring<>;
+		static constexpr bool optional = true;
+
+	};
+
+	dLCoordinationInformation_t& set_dLCoordinationInformation() { dLCoordinationInformation.setpresent(true); return dLCoordinationInformation;}
+	dLCoordinationInformation_t const* get_dLCoordinationInformation() const {return dLCoordinationInformation.is_valid() ? &dLCoordinationInformation : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<MeNBResourceCoordinationInformationExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<MeNBResourceCoordinationInformationExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(eUTRA_Cell_ID);
+		v(uLCoordinationInformation);
+		v(dLCoordinationInformation);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(eUTRA_Cell_ID);
+		v(uLCoordinationInformation);
+		v(dLCoordinationInformation);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		eUTRA_Cell_ID.clear();
+		uLCoordinationInformation.clear();
+		dLCoordinationInformation.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	eUTRA_Cell_ID_t	eUTRA_Cell_ID;
+	uLCoordinationInformation_t	uLCoordinationInformation;
+	dLCoordinationInformation_t	dLCoordinationInformation;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+MeNBtoSeNBContainer ::= OCTET STRING
+*/
+
+struct MeNBtoSeNBContainer : asn::ostring<>
+{
+	static constexpr const char* name() {return "MeNBtoSeNBContainer";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+MeNBtoSgNBContainer ::= OCTET STRING
+*/
+
+struct MeNBtoSgNBContainer : asn::ostring<>
+{
+	static constexpr const char* name() {return "MeNBtoSgNBContainer";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+Measurement-ID	::= INTEGER (1..4095, ...)
+*/
+
+struct Measurement_ID : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<1, 4095>>;
+	static constexpr const char* name() {return "Measurement-ID";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+MobilityParametersInformation ::= SEQUENCE {
+	handoverTriggerChange			INTEGER (-20..20),
+	...
+}
+*/
+
+struct MobilityParametersInformation : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "MobilityParametersInformation";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct handoverTriggerChange_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<-20, 20>>;
+		static constexpr const char* name() {return "handoverTriggerChange_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	handoverTriggerChange_t& ref_handoverTriggerChange() {return handoverTriggerChange;}
+	handoverTriggerChange_t const& ref_handoverTriggerChange() const {return handoverTriggerChange;}
+	template<typename V> void decode(V& v)
+	{
+		v(handoverTriggerChange);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(handoverTriggerChange);
+
+	};
+	void clear()
+	{
+		handoverTriggerChange.clear();
+
+	};
+	private:
+	handoverTriggerChange_t	handoverTriggerChange;
+
+};
+/*
+MobilityParametersModificationRange ::= SEQUENCE {
+	handoverTriggerChangeLowerLimit		INTEGER (-20..20),
+	handoverTriggerChangeUpperLimit		INTEGER (-20..20),
+	...
+}
+*/
+
+struct MobilityParametersModificationRange : asn::sequence<2, 0, true, 0>
+{
+	static constexpr const char* name() {return "MobilityParametersModificationRange";}
+	using parent_t = asn::sequence<2, 0, true, 0>;
+	struct handoverTriggerChangeLowerLimit_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<-20, 20>>;
+		static constexpr const char* name() {return "handoverTriggerChangeLowerLimit_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	handoverTriggerChangeLowerLimit_t& ref_handoverTriggerChangeLowerLimit() {return handoverTriggerChangeLowerLimit;}
+	handoverTriggerChangeLowerLimit_t const& ref_handoverTriggerChangeLowerLimit() const {return handoverTriggerChangeLowerLimit;}
+	struct handoverTriggerChangeUpperLimit_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<-20, 20>>;
+		static constexpr const char* name() {return "handoverTriggerChangeUpperLimit_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	handoverTriggerChangeUpperLimit_t& ref_handoverTriggerChangeUpperLimit() {return handoverTriggerChangeUpperLimit;}
+	handoverTriggerChangeUpperLimit_t const& ref_handoverTriggerChangeUpperLimit() const {return handoverTriggerChangeUpperLimit;}
+	template<typename V> void decode(V& v)
+	{
+		v(handoverTriggerChangeLowerLimit);
+		v(handoverTriggerChangeUpperLimit);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(handoverTriggerChangeLowerLimit);
+		v(handoverTriggerChangeUpperLimit);
+
+	};
+	void clear()
+	{
+		handoverTriggerChangeLowerLimit.clear();
+		handoverTriggerChangeUpperLimit.clear();
+
+	};
+	private:
+	handoverTriggerChangeLowerLimit_t	handoverTriggerChangeLowerLimit;
+	handoverTriggerChangeUpperLimit_t	handoverTriggerChangeUpperLimit;
+
+};
+/*
+MultibandInfoList ::= SEQUENCE (SIZE(1..maxnoofBands)) OF BandInfo
+*/
+
+struct MultibandInfoList_elm : BandInfo
+{
+	static constexpr const char* name() {return "MultibandInfoList_elm";}
+	using parent_t = BandInfo;
+
+};
+struct MultibandInfoList : asn::sequenceof<MultibandInfoList_elm>
+{
+	static constexpr const char* name() {return "MultibandInfoList";}
+	using parent_t = asn::sequenceof<MultibandInfoList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBands >>;
+
+};
+/*
+NRSCS ::= ENUMERATED { scs15, scs30, scs60, scs120, ...}
+*/
+
+struct NRSCS : asn::enumerated<4, 0, true>
+{
+	static constexpr const char* name() {return "NRSCS";}
+	using parent_t = asn::enumerated<4, 0, true>;
+	typedef enum {
+		scs15
+		,scs30
+		,scs60
+		,scs120
+	} index_t;
+
+};
+
+/*
+NRNRB ::= ENUMERATED { nrb11, nrb18, nrb24, nrb25, nrb31, nrb32, nrb38, nrb51, nrb52, nrb65, nrb66, nrb78, nrb79, nrb93, nrb106, nrb107, nrb121, nrb132, nrb133, nrb135, nrb160, nrb162, nrb189, nrb216, nrb217, nrb245, nrb264, nrb270, nrb273, ...}
+*/
+
+struct NRNRB : asn::enumerated<29, 0, true>
+{
+	static constexpr const char* name() {return "NRNRB";}
+	using parent_t = asn::enumerated<29, 0, true>;
+	typedef enum {
+		nrb11
+		,nrb18
+		,nrb24
+		,nrb25
+		,nrb31
+		,nrb32
+		,nrb38
+		,nrb51
+		,nrb52
+		,nrb65
+		,nrb66
+		,nrb78
+		,nrb79
+		,nrb93
+		,nrb106
+		,nrb107
+		,nrb121
+		,nrb132
+		,nrb133
+		,nrb135
+		,nrb160
+		,nrb162
+		,nrb189
+		,nrb216
+		,nrb217
+		,nrb245
+		,nrb264
+		,nrb270
+		,nrb273
+	} index_t;
+
+};
+
+/*
+NR-TxBW-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct NR_TxBW_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+NR-TxBW	::= SEQUENCE {
+	nRSCS	NRSCS,
+	nRNRB	NRNRB,
+	iE-Extensions				ProtocolExtensionContainer { {NR-TxBW-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct NR_TxBW : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "NR-TxBW";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct nRSCS_t : NRSCS
+	{
+		static constexpr const char* name() {return "nRSCS_t";}
+		using parent_t = NRSCS;
+
+	};
+	nRSCS_t& ref_nRSCS() {return nRSCS;}
+	nRSCS_t const& ref_nRSCS() const {return nRSCS;}
+	struct nRNRB_t : NRNRB
+	{
+		static constexpr const char* name() {return "nRNRB_t";}
+		using parent_t = NRNRB;
+
+	};
+	nRNRB_t& ref_nRNRB() {return nRNRB;}
+	nRNRB_t const& ref_nRNRB() const {return nRNRB;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<NR_TxBW_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<NR_TxBW_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(nRSCS);
+		v(nRNRB);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(nRSCS);
+		v(nRNRB);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		nRSCS.clear();
+		nRNRB.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	nRSCS_t	nRSCS;
+	nRNRB_t	nRNRB;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+SULInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct SULInformation_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SULInformation ::= SEQUENCE {
+	sUL-ARFCN				INTEGER (0.. 3279165),
+	sUL-TxBW				NR-TxBW,
+	iE-Extensions			ProtocolExtensionContainer { {SULInformation-ExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct SULInformation : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "SULInformation";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct sUL_ARFCN_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 3279165>>;
+		static constexpr const char* name() {return "sUL_ARFCN_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	sUL_ARFCN_t& ref_sUL_ARFCN() {return sUL_ARFCN;}
+	sUL_ARFCN_t const& ref_sUL_ARFCN() const {return sUL_ARFCN;}
+	struct sUL_TxBW_t : NR_TxBW
+	{
+		static constexpr const char* name() {return "sUL_TxBW_t";}
+		using parent_t = NR_TxBW;
+
+	};
+	sUL_TxBW_t& ref_sUL_TxBW() {return sUL_TxBW;}
+	sUL_TxBW_t const& ref_sUL_TxBW() const {return sUL_TxBW;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<SULInformation_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<SULInformation_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(sUL_ARFCN);
+		v(sUL_TxBW);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(sUL_ARFCN);
+		v(sUL_TxBW);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		sUL_ARFCN.clear();
+		sUL_TxBW.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	sUL_ARFCN_t	sUL_ARFCN;
+	sUL_TxBW_t	sUL_TxBW;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+NRFreqInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct NRFreqInfo_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+NRFreqInfo ::= SEQUENCE{
+	nRARFCN			INTEGER (0.. 3279165),
+	freqBandListNr	SEQUENCE (SIZE(1..maxnoofNrCellBands)) OF FreqBandNrItem,
+	sULInformation	SULInformation		OPTIONAL,
+	iE-Extensions	ProtocolExtensionContainer { {NRFreqInfo-ExtIEs} } OPTIONAL,
+
+	...
+}
+*/
+
+struct NRFreqInfo : asn::sequence<4, 0, true, 2>
+{
+	static constexpr const char* name() {return "NRFreqInfo";}
+	using parent_t = asn::sequence<4, 0, true, 2>;
+	struct nRARFCN_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 3279165>>;
+		static constexpr const char* name() {return "nRARFCN_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	nRARFCN_t& ref_nRARFCN() {return nRARFCN;}
+	nRARFCN_t const& ref_nRARFCN() const {return nRARFCN;}
+	struct freqBandListNr_t_elm : FreqBandNrItem
+	{
+		static constexpr const char* name() {return "freqBandListNr_t_elm";}
+		using parent_t = FreqBandNrItem;
+
+	};
+	struct freqBandListNr_t : asn::sequenceof<freqBandListNr_t_elm>
+	{
+		static constexpr const char* name() {return "freqBandListNr_t";}
+		using parent_t = asn::sequenceof<freqBandListNr_t_elm>;
+		using constraint_t = asn::constraints<false,asn::span<1,  maxnoofNrCellBands >>;
+
+	};
+	freqBandListNr_t& ref_freqBandListNr() {return freqBandListNr;}
+	freqBandListNr_t const& ref_freqBandListNr() const {return freqBandListNr;}
+	struct sULInformation_t : SULInformation
+	{
+		static constexpr const char* name() {return "sULInformation_t";}
+		using parent_t = SULInformation;
+		static constexpr bool optional = true;
+
+	};
+	sULInformation_t& set_sULInformation() { sULInformation.setpresent(true); return sULInformation;}
+	sULInformation_t const* get_sULInformation() const {return sULInformation.is_valid() ? &sULInformation : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<NRFreqInfo_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<NRFreqInfo_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(nRARFCN);
+		v(freqBandListNr);
+		v(sULInformation);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(nRARFCN);
+		v(freqBandListNr);
+		v(sULInformation);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		nRARFCN.clear();
+		freqBandListNr.clear();
+		sULInformation.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	nRARFCN_t	nRARFCN;
+	freqBandListNr_t	freqBandListNr;
+	sULInformation_t	sULInformation;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+NRPCI ::= INTEGER (0..1007)
+*/
+
+struct NRPCI : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 1007>>;
+	static constexpr const char* name() {return "NRPCI";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+NRencryptionAlgorithms ::= BIT STRING (SIZE (16,...))
+*/
+
+struct NRencryptionAlgorithms : asn::bstring<>
+{
+	using constraint_t = asn::constraints<true,asn::one<16>>;
+	static constexpr const char* name() {return "NRencryptionAlgorithms";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+NRintegrityProtectionAlgorithms ::= BIT STRING (SIZE (16,...))
+*/
+
+struct NRintegrityProtectionAlgorithms : asn::bstring<>
+{
+	using constraint_t = asn::constraints<true,asn::one<16>>;
+	static constexpr const char* name() {return "NRintegrityProtectionAlgorithms";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+NRUESecurityCapabilities-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct NRUESecurityCapabilities_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+NRUESecurityCapabilities ::= SEQUENCE {
+	nRencryptionAlgorithms				NRencryptionAlgorithms,
+	nRintegrityProtectionAlgorithms		NRintegrityProtectionAlgorithms,
+	iE-Extensions						ProtocolExtensionContainer { {NRUESecurityCapabilities-ExtIEs} }	OPTIONAL,
+...
+}
+*/
+
+struct NRUESecurityCapabilities : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "NRUESecurityCapabilities";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct nRencryptionAlgorithms_t : NRencryptionAlgorithms
+	{
+		static constexpr const char* name() {return "nRencryptionAlgorithms_t";}
+		using parent_t = NRencryptionAlgorithms;
+
+	};
+	nRencryptionAlgorithms_t& ref_nRencryptionAlgorithms() {return nRencryptionAlgorithms;}
+	nRencryptionAlgorithms_t const& ref_nRencryptionAlgorithms() const {return nRencryptionAlgorithms;}
+	struct nRintegrityProtectionAlgorithms_t : NRintegrityProtectionAlgorithms
+	{
+		static constexpr const char* name() {return "nRintegrityProtectionAlgorithms_t";}
+		using parent_t = NRintegrityProtectionAlgorithms;
+
+	};
+	nRintegrityProtectionAlgorithms_t& ref_nRintegrityProtectionAlgorithms() {return nRintegrityProtectionAlgorithms;}
+	nRintegrityProtectionAlgorithms_t const& ref_nRintegrityProtectionAlgorithms() const {return nRintegrityProtectionAlgorithms;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<NRUESecurityCapabilities_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<NRUESecurityCapabilities_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(nRencryptionAlgorithms);
+		v(nRintegrityProtectionAlgorithms);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(nRencryptionAlgorithms);
+		v(nRintegrityProtectionAlgorithms);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		nRencryptionAlgorithms.clear();
+		nRintegrityProtectionAlgorithms.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	nRencryptionAlgorithms_t	nRencryptionAlgorithms;
+	nRintegrityProtectionAlgorithms_t	nRintegrityProtectionAlgorithms;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+PCI ::= INTEGER (0..503, ...)
+*/
+
+struct PCI : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<0, 503>>;
+	static constexpr const char* name() {return "PCI";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+Neighbour-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-NeighbourTAC		CRITICALITY ignore	EXTENSION TAC				PRESENCE optional}|
+	{ ID id-eARFCNExtension		CRITICALITY reject	EXTENSION EARFCNExtension	PRESENCE optional},
+	...
+}
+*/
+
+struct Neighbour_Information_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_NeighbourTAC() { set(id_NeighbourTAC); type=1;}
+		void select_id_eARFCNExtension() { set(id_eARFCNExtension); type=2;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_NeighbourTAC)) { type = 1; return true; }
+			else if(equal(id_eARFCNExtension)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_NeighbourTAC);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_eARFCNExtension);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_NeighbourTAC() { set(ignore); type=1;}
+		void select_id_eARFCNExtension() { set(reject); type=2;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else if(equal(reject)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		TAC& select_id_NeighbourTAC() { return set<TAC>(1); }
+		TAC const* get_id_NeighbourTAC() const { return get<TAC>(1); }
+		EARFCNExtension& select_id_eARFCNExtension() { return set<EARFCNExtension>(2); }
+		EARFCNExtension const* get_id_eARFCNExtension() const { return get<EARFCNExtension>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<TAC>(); break;
+			case 2: var.destroy<EARFCNExtension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<TAC>(1);
+			v.template operator()<EARFCNExtension>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_NeighbourTAC()); return true;
+			case 2: v(select_id_eARFCNExtension()); return true;
+			case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<TAC>()); return true;
+			case 2: v(var.as<EARFCNExtension>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(EARFCNExtension)];
+			char dummy2[sizeof(TAC)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_NeighbourTAC() { set(optional); type=1;}
+		void select_id_eARFCNExtension() { set(optional); type=2;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else if(equal(optional)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+Neighbour-Information ::= SEQUENCE (SIZE (0..maxnoofNeighbours)) OF SEQUENCE {
+	eCGI						ECGI,
+	pCI							PCI,
+	eARFCN						EARFCN,
+	iE-Extensions				ProtocolExtensionContainer { {Neighbour-Information-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct Neighbour_Information_elm : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "Neighbour_Information_elm";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct eCGI_t : ECGI
+	{
+		static constexpr const char* name() {return "eCGI_t";}
+		using parent_t = ECGI;
+
+	};
+	eCGI_t& ref_eCGI() {return eCGI;}
+	eCGI_t const& ref_eCGI() const {return eCGI;}
+	struct pCI_t : PCI
+	{
+		static constexpr const char* name() {return "pCI_t";}
+		using parent_t = PCI;
+
+	};
+	pCI_t& ref_pCI() {return pCI;}
+	pCI_t const& ref_pCI() const {return pCI;}
+	struct eARFCN_t : EARFCN
+	{
+		static constexpr const char* name() {return "eARFCN_t";}
+		using parent_t = EARFCN;
+
+	};
+	eARFCN_t& ref_eARFCN() {return eARFCN;}
+	eARFCN_t const& ref_eARFCN() const {return eARFCN;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<Neighbour_Information_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<Neighbour_Information_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(eCGI);
+		v(pCI);
+		v(eARFCN);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(eCGI);
+		v(pCI);
+		v(eARFCN);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		eCGI.clear();
+		pCI.clear();
+		eARFCN.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	eCGI_t	eCGI;
+	pCI_t	pCI;
+	eARFCN_t	eARFCN;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct Neighbour_Information : asn::sequenceof<Neighbour_Information_elm>
+{
+	static constexpr const char* name() {return "Neighbour-Information";}
+	using parent_t = asn::sequenceof<Neighbour_Information_elm>;
+	using constraint_t = asn::constraints<false,asn::span<0,  maxnoofNeighbours >>;
+
+};
+/*
+NewDRBIDrequest::= ENUMERATED {true, ...}
+*/
+
+struct NewDRBIDrequest : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "NewDRBIDrequest";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		True
+	} index_t;
+
+};
+
+/*
+Number-of-Antennaports ::= ENUMERATED {
+		an1,
+	 	an2,
+		an4,
+		...
+}
+*/
+
+struct Number_of_Antennaports : asn::enumerated<3, 0, true>
+{
+	static constexpr const char* name() {return "Number-of-Antennaports";}
+	using parent_t = asn::enumerated<3, 0, true>;
+	typedef enum {
+		an1
+		,an2
+		,an4
+	} index_t;
+
+};
+
+/*
+PDCPChangeIndication ::= ENUMERATED {s-KgNB-update-required, pDCP-data-recovery-required,...}
+*/
+
+struct PDCPChangeIndication : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "PDCPChangeIndication";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		s_KgNB_update_required
+		,pDCP_data_recovery_required
+	} index_t;
+
+};
+
+/*
+PDCPSnLength	::=	ENUMERATED {twelve-bits,eighteen-bits,...}
+*/
+
+struct PDCPSnLength : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "PDCPSnLength";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		twelve_bits
+		,eighteen_bits
+	} index_t;
+
+};
+
+/*
+PRACH-Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct PRACH_Configuration_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+PRACH-Configuration ::= SEQUENCE {
+	rootSequenceIndex						INTEGER (0..837),
+	zeroCorrelationIndex					INTEGER (0..15),
+	highSpeedFlag							BOOLEAN,
+	prach-FreqOffset						INTEGER (0..94),
+	prach-ConfigIndex						INTEGER (0..63)		OPTIONAL, -- present for TDD --
+	iE-Extensions							ProtocolExtensionContainer { {PRACH-Configuration-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct PRACH_Configuration : asn::sequence<6, 0, true, 2>
+{
+	static constexpr const char* name() {return "PRACH-Configuration";}
+	using parent_t = asn::sequence<6, 0, true, 2>;
+	struct rootSequenceIndex_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 837>>;
+		static constexpr const char* name() {return "rootSequenceIndex_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	rootSequenceIndex_t& ref_rootSequenceIndex() {return rootSequenceIndex;}
+	rootSequenceIndex_t const& ref_rootSequenceIndex() const {return rootSequenceIndex;}
+	struct zeroCorrelationIndex_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 15>>;
+		static constexpr const char* name() {return "zeroCorrelationIndex_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	zeroCorrelationIndex_t& ref_zeroCorrelationIndex() {return zeroCorrelationIndex;}
+	zeroCorrelationIndex_t const& ref_zeroCorrelationIndex() const {return zeroCorrelationIndex;}
+	struct highSpeedFlag_t : asn::boolean
+	{
+		static constexpr const char* name() {return "highSpeedFlag_t";}
+		using parent_t = asn::boolean;
+
+	};
+	highSpeedFlag_t& ref_highSpeedFlag() {return highSpeedFlag;}
+	highSpeedFlag_t const& ref_highSpeedFlag() const {return highSpeedFlag;}
+	struct prach_FreqOffset_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 94>>;
+		static constexpr const char* name() {return "prach_FreqOffset_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	prach_FreqOffset_t& ref_prach_FreqOffset() {return prach_FreqOffset;}
+	prach_FreqOffset_t const& ref_prach_FreqOffset() const {return prach_FreqOffset;}
+	struct prach_ConfigIndex_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 63>>;
+		static constexpr const char* name() {return "prach_ConfigIndex_t";}
+		using parent_t = asn::integer<>;
+		static constexpr bool optional = true;
+
+	};
+
+	prach_ConfigIndex_t& set_prach_ConfigIndex() { prach_ConfigIndex.setpresent(true); return prach_ConfigIndex;}
+	prach_ConfigIndex_t const* get_prach_ConfigIndex() const {return prach_ConfigIndex.is_valid() ? &prach_ConfigIndex : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<PRACH_Configuration_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<PRACH_Configuration_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(rootSequenceIndex);
+		v(zeroCorrelationIndex);
+		v(highSpeedFlag);
+		v(prach_FreqOffset);
+		v(prach_ConfigIndex);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(rootSequenceIndex);
+		v(zeroCorrelationIndex);
+		v(highSpeedFlag);
+		v(prach_FreqOffset);
+		v(prach_ConfigIndex);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		rootSequenceIndex.clear();
+		zeroCorrelationIndex.clear();
+		highSpeedFlag.clear();
+		prach_FreqOffset.clear();
+		prach_ConfigIndex.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	rootSequenceIndex_t	rootSequenceIndex;
+	zeroCorrelationIndex_t	zeroCorrelationIndex;
+	highSpeedFlag_t	highSpeedFlag;
+	prach_FreqOffset_t	prach_FreqOffset;
+	prach_ConfigIndex_t	prach_ConfigIndex;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+PedestrianUE ::= ENUMERATED {
+	authorized,
+	not-authorized,
+	...
+}
+*/
+
+struct PedestrianUE : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "PedestrianUE";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		authorized
+		,not_authorized
+	} index_t;
+
+};
+
+/*
+Port-Number ::= OCTET STRING (SIZE (2))
+*/
+
+struct Port_Number : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<2>>;
+	static constexpr const char* name() {return "Port-Number";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+ProSeDirectDiscovery ::= ENUMERATED {
+	authorized,
+	not-authorized,
+	...
+}
+*/
+
+struct ProSeDirectDiscovery : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "ProSeDirectDiscovery";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		authorized
+		,not_authorized
+	} index_t;
+
+};
+
+/*
+ProSeDirectCommunication ::= ENUMERATED {
+	authorized,
+	not-authorized,
+	...
+}
+*/
+
+struct ProSeDirectCommunication : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "ProSeDirectCommunication";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		authorized
+		,not_authorized
+	} index_t;
+
+};
+
+/*
+ProSeUEtoNetworkRelaying ::= ENUMERATED {
+	authorized,
+	not-authorized,
+	...
+}
+*/
+
+struct ProSeUEtoNetworkRelaying : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "ProSeUEtoNetworkRelaying";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		authorized
+		,not_authorized
+	} index_t;
+
+};
+
+/*
+ProSeAuthorized-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-ProSeUEtoNetworkRelaying	CRITICALITY ignore	EXTENSION ProSeUEtoNetworkRelaying		PRESENCE optional},
+	...
+}
+*/
+
+struct ProSeAuthorized_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_ProSeUEtoNetworkRelaying() { set(id_ProSeUEtoNetworkRelaying); type=1;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_ProSeUEtoNetworkRelaying)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_ProSeUEtoNetworkRelaying);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_ProSeUEtoNetworkRelaying() { set(ignore); type=1;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		ProSeUEtoNetworkRelaying& select_id_ProSeUEtoNetworkRelaying() { return set<ProSeUEtoNetworkRelaying>(1); }
+		ProSeUEtoNetworkRelaying const* get_id_ProSeUEtoNetworkRelaying() const { return get<ProSeUEtoNetworkRelaying>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ProSeUEtoNetworkRelaying>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ProSeUEtoNetworkRelaying>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ProSeUEtoNetworkRelaying()); return true;
+			case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<ProSeUEtoNetworkRelaying>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(ProSeUEtoNetworkRelaying)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_ProSeUEtoNetworkRelaying() { set(optional); type=1;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ProSeAuthorized ::= SEQUENCE {
+	proSeDirectDiscovery		ProSeDirectDiscovery			OPTIONAL,
+	proSeDirectCommunication	ProSeDirectCommunication		OPTIONAL,
+	iE-Extensions				ProtocolExtensionContainer { {ProSeAuthorized-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct ProSeAuthorized : asn::sequence<3, 0, true, 3>
+{
+	static constexpr const char* name() {return "ProSeAuthorized";}
+	using parent_t = asn::sequence<3, 0, true, 3>;
+	struct proSeDirectDiscovery_t : ProSeDirectDiscovery
+	{
+		static constexpr const char* name() {return "proSeDirectDiscovery_t";}
+		using parent_t = ProSeDirectDiscovery;
+		static constexpr bool optional = true;
+
+	};
+	proSeDirectDiscovery_t& set_proSeDirectDiscovery() { proSeDirectDiscovery.setpresent(true); return proSeDirectDiscovery;}
+	proSeDirectDiscovery_t const* get_proSeDirectDiscovery() const {return proSeDirectDiscovery.is_valid() ? &proSeDirectDiscovery : nullptr;}
+	struct proSeDirectCommunication_t : ProSeDirectCommunication
+	{
+		static constexpr const char* name() {return "proSeDirectCommunication_t";}
+		using parent_t = ProSeDirectCommunication;
+		static constexpr bool optional = true;
+
+	};
+	proSeDirectCommunication_t& set_proSeDirectCommunication() { proSeDirectCommunication.setpresent(true); return proSeDirectCommunication;}
+	proSeDirectCommunication_t const* get_proSeDirectCommunication() const {return proSeDirectCommunication.is_valid() ? &proSeDirectCommunication : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ProSeAuthorized_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ProSeAuthorized_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(proSeDirectDiscovery);
+		v(proSeDirectCommunication);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(proSeDirectDiscovery);
+		v(proSeDirectCommunication);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		proSeDirectDiscovery.clear();
+		proSeDirectCommunication.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	proSeDirectDiscovery_t	proSeDirectDiscovery;
+	proSeDirectCommunication_t	proSeDirectCommunication;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ResourceType ::= ENUMERATED {
+	downlinknonCRS,
+	cRS,
+	uplink,
+	...
+}
+*/
+
+struct ResourceType : asn::enumerated<3, 0, true>
+{
+	static constexpr const char* name() {return "ResourceType";}
+	using parent_t = asn::enumerated<3, 0, true>;
+	typedef enum {
+		downlinknonCRS
+		,cRS
+		,uplink
+	} index_t;
+
+};
+
+/*
+ProtectedFootprintTimePattern-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ProtectedFootprintTimePattern_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ProtectedFootprintTimePattern ::= SEQUENCE {
+	protectedFootprintTimePeriodicity				INTEGER (1..320, ...),
+	protectedFootprintStartTime						INTEGER (1..20, ...),
+	iE-Extensions									ProtocolExtensionContainer { {ProtectedFootprintTimePattern-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct ProtectedFootprintTimePattern : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "ProtectedFootprintTimePattern";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct protectedFootprintTimePeriodicity_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<1, 320>>;
+		static constexpr const char* name() {return "protectedFootprintTimePeriodicity_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	protectedFootprintTimePeriodicity_t& ref_protectedFootprintTimePeriodicity() {return protectedFootprintTimePeriodicity;}
+	protectedFootprintTimePeriodicity_t const& ref_protectedFootprintTimePeriodicity() const {return protectedFootprintTimePeriodicity;}
+	struct protectedFootprintStartTime_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<1, 20>>;
+		static constexpr const char* name() {return "protectedFootprintStartTime_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	protectedFootprintStartTime_t& ref_protectedFootprintStartTime() {return protectedFootprintStartTime;}
+	protectedFootprintStartTime_t const& ref_protectedFootprintStartTime() const {return protectedFootprintStartTime;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ProtectedFootprintTimePattern_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ProtectedFootprintTimePattern_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(protectedFootprintTimePeriodicity);
+		v(protectedFootprintStartTime);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protectedFootprintTimePeriodicity);
+		v(protectedFootprintStartTime);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		protectedFootprintTimePeriodicity.clear();
+		protectedFootprintStartTime.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	protectedFootprintTimePeriodicity_t	protectedFootprintTimePeriodicity;
+	protectedFootprintStartTime_t	protectedFootprintStartTime;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ProtectedResourceList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ProtectedResourceList_Item_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ProtectedResourceList-Item ::= SEQUENCE {
+	resourceType					ResourceType,
+	intraPRBProtectedResourceFootprint 		BIT STRING (SIZE(84, ...)),
+	protectedFootprintFrequencyPattern 		BIT STRING (SIZE(6..110, ...)),
+	protectedFootprintTimePattern			ProtectedFootprintTimePattern,
+	iE-Extensions							ProtocolExtensionContainer { {ProtectedResourceList-Item-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct ProtectedResourceList_Item : asn::sequence<5, 0, true, 1>
+{
+	static constexpr const char* name() {return "ProtectedResourceList-Item";}
+	using parent_t = asn::sequence<5, 0, true, 1>;
+	struct resourceType_t : ResourceType
+	{
+		static constexpr const char* name() {return "resourceType_t";}
+		using parent_t = ResourceType;
+
+	};
+	resourceType_t& ref_resourceType() {return resourceType;}
+	resourceType_t const& ref_resourceType() const {return resourceType;}
+	struct intraPRBProtectedResourceFootprint_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<true,asn::one<84>>;
+		static constexpr const char* name() {return "intraPRBProtectedResourceFootprint_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	intraPRBProtectedResourceFootprint_t& ref_intraPRBProtectedResourceFootprint() {return intraPRBProtectedResourceFootprint;}
+	intraPRBProtectedResourceFootprint_t const& ref_intraPRBProtectedResourceFootprint() const {return intraPRBProtectedResourceFootprint;}
+	struct protectedFootprintFrequencyPattern_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<6, 110>>;
+		static constexpr const char* name() {return "protectedFootprintFrequencyPattern_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	protectedFootprintFrequencyPattern_t& ref_protectedFootprintFrequencyPattern() {return protectedFootprintFrequencyPattern;}
+	protectedFootprintFrequencyPattern_t const& ref_protectedFootprintFrequencyPattern() const {return protectedFootprintFrequencyPattern;}
+	struct protectedFootprintTimePattern_t : ProtectedFootprintTimePattern
+	{
+		static constexpr const char* name() {return "protectedFootprintTimePattern_t";}
+		using parent_t = ProtectedFootprintTimePattern;
+
+	};
+	protectedFootprintTimePattern_t& ref_protectedFootprintTimePattern() {return protectedFootprintTimePattern;}
+	protectedFootprintTimePattern_t const& ref_protectedFootprintTimePattern() const {return protectedFootprintTimePattern;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ProtectedResourceList_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ProtectedResourceList_Item_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(resourceType);
+		v(intraPRBProtectedResourceFootprint);
+		v(protectedFootprintFrequencyPattern);
+		v(protectedFootprintTimePattern);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(resourceType);
+		v(intraPRBProtectedResourceFootprint);
+		v(protectedFootprintFrequencyPattern);
+		v(protectedFootprintTimePattern);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		resourceType.clear();
+		intraPRBProtectedResourceFootprint.clear();
+		protectedFootprintFrequencyPattern.clear();
+		protectedFootprintTimePattern.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	resourceType_t	resourceType;
+	intraPRBProtectedResourceFootprint_t	intraPRBProtectedResourceFootprint;
+	protectedFootprintFrequencyPattern_t	protectedFootprintFrequencyPattern;
+	protectedFootprintTimePattern_t	protectedFootprintTimePattern;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ProtectedResourceList ::= SEQUENCE (SIZE(1.. maxnoofProtectedResourcePatterns)) OF ProtectedResourceList-Item
+*/
+
+struct ProtectedResourceList_elm : ProtectedResourceList_Item
+{
+	static constexpr const char* name() {return "ProtectedResourceList_elm";}
+	using parent_t = ProtectedResourceList_Item;
+
+};
+struct ProtectedResourceList : asn::sequenceof<ProtectedResourceList_elm>
+{
+	static constexpr const char* name() {return "ProtectedResourceList";}
+	using parent_t = asn::sequenceof<ProtectedResourceList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofProtectedResourcePatterns >>;
+
+};
+/*
+ProtectedEUTRAResourceIndication-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+} -- Rapporteur: missing extension --
+*/
+
+struct ProtectedEUTRAResourceIndication_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ProtectedEUTRAResourceIndication::= SEQUENCE {
+	activationSFN							INTEGER (0..1023),
+	protectedResourceList					ProtectedResourceList,
+	mBSFNControlRegionLength				INTEGER (0..3) OPTIONAL,
+	pDCCHRegionLength						INTEGER (1..3) OPTIONAL,
+	iE-Extensions							ProtocolExtensionContainer { {ProtectedEUTRAResourceIndication-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct ProtectedEUTRAResourceIndication : asn::sequence<5, 0, true, 3>
+{
+	static constexpr const char* name() {return "ProtectedEUTRAResourceIndication";}
+	using parent_t = asn::sequence<5, 0, true, 3>;
+	struct activationSFN_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 1023>>;
+		static constexpr const char* name() {return "activationSFN_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	activationSFN_t& ref_activationSFN() {return activationSFN;}
+	activationSFN_t const& ref_activationSFN() const {return activationSFN;}
+	struct protectedResourceList_t : ProtectedResourceList
+	{
+		static constexpr const char* name() {return "protectedResourceList_t";}
+		using parent_t = ProtectedResourceList;
+
+	};
+	protectedResourceList_t& ref_protectedResourceList() {return protectedResourceList;}
+	protectedResourceList_t const& ref_protectedResourceList() const {return protectedResourceList;}
+	struct mBSFNControlRegionLength_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 3>>;
+		static constexpr const char* name() {return "mBSFNControlRegionLength_t";}
+		using parent_t = asn::integer<>;
+		static constexpr bool optional = true;
+
+	};
+
+	mBSFNControlRegionLength_t& set_mBSFNControlRegionLength() { mBSFNControlRegionLength.setpresent(true); return mBSFNControlRegionLength;}
+	mBSFNControlRegionLength_t const* get_mBSFNControlRegionLength() const {return mBSFNControlRegionLength.is_valid() ? &mBSFNControlRegionLength : nullptr;}
+	struct pDCCHRegionLength_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<1, 3>>;
+		static constexpr const char* name() {return "pDCCHRegionLength_t";}
+		using parent_t = asn::integer<>;
+		static constexpr bool optional = true;
+
+	};
+
+	pDCCHRegionLength_t& set_pDCCHRegionLength() { pDCCHRegionLength.setpresent(true); return pDCCHRegionLength;}
+	pDCCHRegionLength_t const* get_pDCCHRegionLength() const {return pDCCHRegionLength.is_valid() ? &pDCCHRegionLength : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ProtectedEUTRAResourceIndication_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ProtectedEUTRAResourceIndication_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(activationSFN);
+		v(protectedResourceList);
+		v(mBSFNControlRegionLength);
+		v(pDCCHRegionLength);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(activationSFN);
+		v(protectedResourceList);
+		v(mBSFNControlRegionLength);
+		v(pDCCHRegionLength);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		activationSFN.clear();
+		protectedResourceList.clear();
+		mBSFNControlRegionLength.clear();
+		pDCCHRegionLength.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	activationSFN_t	activationSFN;
+	protectedResourceList_t	protectedResourceList;
+	mBSFNControlRegionLength_t	mBSFNControlRegionLength;
+	pDCCHRegionLength_t	pDCCHRegionLength;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+Reestablishment-Indication ::= ENUMERATED {
+	reestablished,
+	...
+}
+*/
+
+struct Reestablishment_Indication : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "Reestablishment-Indication";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		reestablished
+	} index_t;
+
+};
+
+/*
+RLC-Status-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct RLC_Status_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+RLC-Status ::= SEQUENCE {
+	reestablishment-Indication 	Reestablishment-Indication,
+	iE-Extensions				ProtocolExtensionContainer { {RLC-Status-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct RLC_Status : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "RLC-Status";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct reestablishment_Indication_t : Reestablishment_Indication
+	{
+		static constexpr const char* name() {return "reestablishment_Indication_t";}
+		using parent_t = Reestablishment_Indication;
+
+	};
+	reestablishment_Indication_t& ref_reestablishment_Indication() {return reestablishment_Indication;}
+	reestablishment_Indication_t const& ref_reestablishment_Indication() const {return reestablishment_Indication;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<RLC_Status_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<RLC_Status_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(reestablishment_Indication);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(reestablishment_Indication);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		reestablishment_Indication.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	reestablishment_Indication_t	reestablishment_Indication;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+RLCMode ::= ENUMERATED {
+	rlc-am,
+	rlc-um-bidirectional,
+	rlc-um-unidirectional-ul,
+	rlc-um-unidirectional-dl,
+	...
+}
+*/
+
+struct RLCMode : asn::enumerated<4, 0, true>
+{
+	static constexpr const char* name() {return "RLCMode";}
+	using parent_t = asn::enumerated<4, 0, true>;
+	typedef enum {
+		rlc_am
+		,rlc_um_bidirectional
+		,rlc_um_unidirectional_ul
+		,rlc_um_unidirectional_dl
+	} index_t;
+
+};
+
+/*
+RRC-Config-Ind ::= ENUMERATED {
+	full-config,
+	delta-config,
+	...
+}
+*/
+
+struct RRC_Config_Ind : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "RRC-Config-Ind";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		full_config
+		,delta_config
+	} index_t;
+
+};
+
+/*
+RRC-Context ::= OCTET STRING
+*/
+
+struct RRC_Context : asn::ostring<>
+{
+	static constexpr const char* name() {return "RRC-Context";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+RRCConnReestabIndicator ::= ENUMERATED {
+	reconfigurationFailure, handoverFailure, otherFailure, ...
+}
+*/
+
+struct RRCConnReestabIndicator : asn::enumerated<3, 0, true>
+{
+	static constexpr const char* name() {return "RRCConnReestabIndicator";}
+	using parent_t = asn::enumerated<3, 0, true>;
+	typedef enum {
+		reconfigurationFailure
+		,handoverFailure
+		,otherFailure
+	} index_t;
+
+};
+
+/*
+RRCConnSetupIndicator::= ENUMERATED {
+	rrcConnSetup,
+	...
+}
+*/
+
+struct RRCConnSetupIndicator : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "RRCConnSetupIndicator";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		rrcConnSetup
+	} index_t;
+
+};
+
+/*
+RRCContainer ::= OCTET STRING
+*/
+
+struct RRCContainer : asn::ostring<>
+{
+	static constexpr const char* name() {return "RRCContainer";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+RSRPMeasurementResult-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct RSRPMeasurementResult_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+RSRPMeasurementResult ::= SEQUENCE (SIZE(1..maxCellReport)) OF
+	SEQUENCE {
+		rSRPCellID						ECGI,
+		rSRPMeasured					INTEGER (0..97, ...),
+		iE-Extensions					ProtocolExtensionContainer { {RSRPMeasurementResult-ExtIEs} } OPTIONAL,
+		...
+	}
+*/
+
+struct RSRPMeasurementResult_elm : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "RSRPMeasurementResult_elm";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct rSRPCellID_t : ECGI
+	{
+		static constexpr const char* name() {return "rSRPCellID_t";}
+		using parent_t = ECGI;
+
+	};
+	rSRPCellID_t& ref_rSRPCellID() {return rSRPCellID;}
+	rSRPCellID_t const& ref_rSRPCellID() const {return rSRPCellID;}
+	struct rSRPMeasured_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 97>>;
+		static constexpr const char* name() {return "rSRPMeasured_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	rSRPMeasured_t& ref_rSRPMeasured() {return rSRPMeasured;}
+	rSRPMeasured_t const& ref_rSRPMeasured() const {return rSRPMeasured;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<RSRPMeasurementResult_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<RSRPMeasurementResult_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(rSRPCellID);
+		v(rSRPMeasured);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(rSRPCellID);
+		v(rSRPMeasured);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		rSRPCellID.clear();
+		rSRPMeasured.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	rSRPCellID_t	rSRPCellID;
+	rSRPMeasured_t	rSRPMeasured;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct RSRPMeasurementResult : asn::sequenceof<RSRPMeasurementResult_elm>
+{
+	static constexpr const char* name() {return "RSRPMeasurementResult";}
+	using parent_t = asn::sequenceof<RSRPMeasurementResult_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellReport >>;
+
+};
+/*
+RSRPMRList-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-UEID	CRITICALITY ignore	EXTENSION UEID		PRESENCE optional},
+	...
+}
+*/
+
+struct RSRPMRList_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_UEID() { set(id_UEID); type=1;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_UEID)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_UEID);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_UEID() { set(ignore); type=1;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		UEID& select_id_UEID() { return set<UEID>(1); }
+		UEID const* get_id_UEID() const { return get<UEID>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UEID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UEID>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_UEID()); return true;
+			case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<UEID>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(UEID)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_UEID() { set(optional); type=1;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+RSRPMRList ::= SEQUENCE (SIZE(1..maxUEReport)) OF
+	SEQUENCE {
+		rSRPMeasurementResult			RSRPMeasurementResult,
+		iE-Extensions					ProtocolExtensionContainer { {RSRPMRList-ExtIEs} } OPTIONAL,
+		...
+	}
+*/
+
+struct RSRPMRList_elm : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "RSRPMRList_elm";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct rSRPMeasurementResult_t : RSRPMeasurementResult
+	{
+		static constexpr const char* name() {return "rSRPMeasurementResult_t";}
+		using parent_t = RSRPMeasurementResult;
+
+	};
+	rSRPMeasurementResult_t& ref_rSRPMeasurementResult() {return rSRPMeasurementResult;}
+	rSRPMeasurementResult_t const& ref_rSRPMeasurementResult() const {return rSRPMeasurementResult;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<RSRPMRList_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<RSRPMRList_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(rSRPMeasurementResult);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(rSRPMeasurementResult);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		rSRPMeasurementResult.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	rSRPMeasurementResult_t	rSRPMeasurementResult;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct RSRPMRList : asn::sequenceof<RSRPMRList_elm>
+{
+	static constexpr const char* name() {return "RSRPMRList";}
+	using parent_t = asn::sequenceof<RSRPMRList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxUEReport >>;
+
+};
+/*
+UL-GBR-PRB-usage::= INTEGER (0..100)
+*/
+
+struct UL_GBR_PRB_usage : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+	static constexpr const char* name() {return "UL-GBR-PRB-usage";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+UL-non-GBR-PRB-usage::= INTEGER (0..100)
+*/
+
+struct UL_non_GBR_PRB_usage : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+	static constexpr const char* name() {return "UL-non-GBR-PRB-usage";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+UL-Total-PRB-usage::= INTEGER (0..100)
+*/
+
+struct UL_Total_PRB_usage : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+	static constexpr const char* name() {return "UL-Total-PRB-usage";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+UL-scheduling-PDCCH-CCE-usage::= INTEGER (0..100)
+*/
+
+struct UL_scheduling_PDCCH_CCE_usage : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+	static constexpr const char* name() {return "UL-scheduling-PDCCH-CCE-usage";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+RadioResourceStatus-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ID id-DL-scheduling-PDCCH-CCE-usage		CRITICALITY ignore	EXTENSION DL-scheduling-PDCCH-CCE-usage		PRESENCE optional}|
+
+	{ID id-UL-scheduling-PDCCH-CCE-usage		CRITICALITY ignore	EXTENSION UL-scheduling-PDCCH-CCE-usage		PRESENCE optional},
+	...
+}
+*/
+
+struct RadioResourceStatus_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_DL_scheduling_PDCCH_CCE_usage() { set(id_DL_scheduling_PDCCH_CCE_usage); type=1;}
+		void select_id_UL_scheduling_PDCCH_CCE_usage() { set(id_UL_scheduling_PDCCH_CCE_usage); type=2;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_DL_scheduling_PDCCH_CCE_usage)) { type = 1; return true; }
+			else if(equal(id_UL_scheduling_PDCCH_CCE_usage)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_DL_scheduling_PDCCH_CCE_usage);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_UL_scheduling_PDCCH_CCE_usage);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_DL_scheduling_PDCCH_CCE_usage() { set(ignore); type=1;}
+		void select_id_UL_scheduling_PDCCH_CCE_usage() { set(ignore); type=2;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else if(equal(ignore)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		DL_scheduling_PDCCH_CCE_usage& select_id_DL_scheduling_PDCCH_CCE_usage() { return set<DL_scheduling_PDCCH_CCE_usage>(1); }
+		DL_scheduling_PDCCH_CCE_usage const* get_id_DL_scheduling_PDCCH_CCE_usage() const { return get<DL_scheduling_PDCCH_CCE_usage>(1); }
+		UL_scheduling_PDCCH_CCE_usage& select_id_UL_scheduling_PDCCH_CCE_usage() { return set<UL_scheduling_PDCCH_CCE_usage>(2); }
+		UL_scheduling_PDCCH_CCE_usage const* get_id_UL_scheduling_PDCCH_CCE_usage() const { return get<UL_scheduling_PDCCH_CCE_usage>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<DL_scheduling_PDCCH_CCE_usage>(); break;
+			case 2: var.destroy<UL_scheduling_PDCCH_CCE_usage>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<DL_scheduling_PDCCH_CCE_usage>(1);
+			v.template operator()<UL_scheduling_PDCCH_CCE_usage>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_DL_scheduling_PDCCH_CCE_usage()); return true;
+			case 2: v(select_id_UL_scheduling_PDCCH_CCE_usage()); return true;
+			case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<DL_scheduling_PDCCH_CCE_usage>()); return true;
+			case 2: v(var.as<UL_scheduling_PDCCH_CCE_usage>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(DL_scheduling_PDCCH_CCE_usage)];
+			char dummy2[sizeof(UL_scheduling_PDCCH_CCE_usage)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_DL_scheduling_PDCCH_CCE_usage() { set(optional); type=1;}
+		void select_id_UL_scheduling_PDCCH_CCE_usage() { set(optional); type=2;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else if(equal(optional)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+RadioResourceStatus	::= SEQUENCE {
+	dL-GBR-PRB-usage							DL-GBR-PRB-usage,
+	uL-GBR-PRB-usage							UL-GBR-PRB-usage,
+	dL-non-GBR-PRB-usage						DL-non-GBR-PRB-usage,
+	uL-non-GBR-PRB-usage						UL-non-GBR-PRB-usage,
+	dL-Total-PRB-usage							DL-Total-PRB-usage,
+	uL-Total-PRB-usage							UL-Total-PRB-usage,
+	iE-Extensions								ProtocolExtensionContainer { {RadioResourceStatus-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct RadioResourceStatus : asn::sequence<7, 0, true, 1>
+{
+	static constexpr const char* name() {return "RadioResourceStatus";}
+	using parent_t = asn::sequence<7, 0, true, 1>;
+	struct dL_GBR_PRB_usage_t : DL_GBR_PRB_usage
+	{
+		static constexpr const char* name() {return "dL_GBR_PRB_usage_t";}
+		using parent_t = DL_GBR_PRB_usage;
+
+	};
+	dL_GBR_PRB_usage_t& ref_dL_GBR_PRB_usage() {return dL_GBR_PRB_usage;}
+	dL_GBR_PRB_usage_t const& ref_dL_GBR_PRB_usage() const {return dL_GBR_PRB_usage;}
+	struct uL_GBR_PRB_usage_t : UL_GBR_PRB_usage
+	{
+		static constexpr const char* name() {return "uL_GBR_PRB_usage_t";}
+		using parent_t = UL_GBR_PRB_usage;
+
+	};
+	uL_GBR_PRB_usage_t& ref_uL_GBR_PRB_usage() {return uL_GBR_PRB_usage;}
+	uL_GBR_PRB_usage_t const& ref_uL_GBR_PRB_usage() const {return uL_GBR_PRB_usage;}
+	struct dL_non_GBR_PRB_usage_t : DL_non_GBR_PRB_usage
+	{
+		static constexpr const char* name() {return "dL_non_GBR_PRB_usage_t";}
+		using parent_t = DL_non_GBR_PRB_usage;
+
+	};
+	dL_non_GBR_PRB_usage_t& ref_dL_non_GBR_PRB_usage() {return dL_non_GBR_PRB_usage;}
+	dL_non_GBR_PRB_usage_t const& ref_dL_non_GBR_PRB_usage() const {return dL_non_GBR_PRB_usage;}
+	struct uL_non_GBR_PRB_usage_t : UL_non_GBR_PRB_usage
+	{
+		static constexpr const char* name() {return "uL_non_GBR_PRB_usage_t";}
+		using parent_t = UL_non_GBR_PRB_usage;
+
+	};
+	uL_non_GBR_PRB_usage_t& ref_uL_non_GBR_PRB_usage() {return uL_non_GBR_PRB_usage;}
+	uL_non_GBR_PRB_usage_t const& ref_uL_non_GBR_PRB_usage() const {return uL_non_GBR_PRB_usage;}
+	struct dL_Total_PRB_usage_t : DL_Total_PRB_usage
+	{
+		static constexpr const char* name() {return "dL_Total_PRB_usage_t";}
+		using parent_t = DL_Total_PRB_usage;
+
+	};
+	dL_Total_PRB_usage_t& ref_dL_Total_PRB_usage() {return dL_Total_PRB_usage;}
+	dL_Total_PRB_usage_t const& ref_dL_Total_PRB_usage() const {return dL_Total_PRB_usage;}
+	struct uL_Total_PRB_usage_t : UL_Total_PRB_usage
+	{
+		static constexpr const char* name() {return "uL_Total_PRB_usage_t";}
+		using parent_t = UL_Total_PRB_usage;
+
+	};
+	uL_Total_PRB_usage_t& ref_uL_Total_PRB_usage() {return uL_Total_PRB_usage;}
+	uL_Total_PRB_usage_t const& ref_uL_Total_PRB_usage() const {return uL_Total_PRB_usage;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<RadioResourceStatus_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<RadioResourceStatus_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(dL_GBR_PRB_usage);
+		v(uL_GBR_PRB_usage);
+		v(dL_non_GBR_PRB_usage);
+		v(uL_non_GBR_PRB_usage);
+		v(dL_Total_PRB_usage);
+		v(uL_Total_PRB_usage);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(dL_GBR_PRB_usage);
+		v(uL_GBR_PRB_usage);
+		v(dL_non_GBR_PRB_usage);
+		v(uL_non_GBR_PRB_usage);
+		v(dL_Total_PRB_usage);
+		v(uL_Total_PRB_usage);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		dL_GBR_PRB_usage.clear();
+		uL_GBR_PRB_usage.clear();
+		dL_non_GBR_PRB_usage.clear();
+		uL_non_GBR_PRB_usage.clear();
+		dL_Total_PRB_usage.clear();
+		uL_Total_PRB_usage.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	dL_GBR_PRB_usage_t	dL_GBR_PRB_usage;
+	uL_GBR_PRB_usage_t	uL_GBR_PRB_usage;
+	dL_non_GBR_PRB_usage_t	dL_non_GBR_PRB_usage;
+	uL_non_GBR_PRB_usage_t	uL_non_GBR_PRB_usage;
+	dL_Total_PRB_usage_t	dL_Total_PRB_usage;
+	uL_Total_PRB_usage_t	uL_Total_PRB_usage;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ReceiveStatusOfULPDCPSDUsExtended ::= BIT STRING (SIZE(1..16384))
+*/
+
+struct ReceiveStatusOfULPDCPSDUsExtended : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::span<1, 16384>>;
+	static constexpr const char* name() {return "ReceiveStatusOfULPDCPSDUsExtended";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+ReceiveStatusOfULPDCPSDUsPDCP-SNlength18 ::= BIT STRING (SIZE(1..131072))
+*/
+
+struct ReceiveStatusOfULPDCPSDUsPDCP_SNlength18 : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::span<1, 131072>>;
+	static constexpr const char* name() {return "ReceiveStatusOfULPDCPSDUsPDCP-SNlength18";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+ReceiveStatusofULPDCPSDUs ::= BIT STRING (SIZE(4096))
+*/
+
+struct ReceiveStatusofULPDCPSDUs : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<4096>>;
+	static constexpr const char* name() {return "ReceiveStatusofULPDCPSDUs";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+Registration-Request	::= ENUMERATED {
+	start,
+	stop,
+	...,
+	partial-stop,
+	add
+}
+*/
+
+struct Registration_Request : asn::enumerated<4, 2, true>
+{
+	static constexpr const char* name() {return "Registration-Request";}
+	using parent_t = asn::enumerated<4, 2, true>;
+	typedef enum {
+		start
+		,stop
+		,partial_stop
+		,add
+	} index_t;
+
+};
+
+/*
+RelativeNarrowbandTxPower-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-enhancedRNTP	CRITICALITY ignore	EXTENSION EnhancedRNTP		PRESENCE optional },
+	...
+}
+*/
+
+struct RelativeNarrowbandTxPower_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_enhancedRNTP() { set(id_enhancedRNTP); type=1;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_enhancedRNTP)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_enhancedRNTP);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_enhancedRNTP() { set(ignore); type=1;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		EnhancedRNTP& select_id_enhancedRNTP() { return set<EnhancedRNTP>(1); }
+		EnhancedRNTP const* get_id_enhancedRNTP() const { return get<EnhancedRNTP>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<EnhancedRNTP>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<EnhancedRNTP>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_enhancedRNTP()); return true;
+			case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<EnhancedRNTP>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(EnhancedRNTP)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_enhancedRNTP() { set(optional); type=1;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+RelativeNarrowbandTxPower ::= SEQUENCE {
+
+	rNTP-PerPRB							BIT STRING (SIZE(6..110, ...)),
+	rNTP-Threshold						RNTP-Threshold,
+	numberOfCellSpecificAntennaPorts	ENUMERATED {one, two, four, ...},
+	p-B									INTEGER (0..3,...),
+	pDCCH-InterferenceImpact			INTEGER (0..4,...),
+	iE-Extensions						ProtocolExtensionContainer { {RelativeNarrowbandTxPower-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct RelativeNarrowbandTxPower : asn::sequence<6, 0, true, 1>
+{
+	static constexpr const char* name() {return "RelativeNarrowbandTxPower";}
+	using parent_t = asn::sequence<6, 0, true, 1>;
+	struct rNTP_PerPRB_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<6, 110>>;
+		static constexpr const char* name() {return "rNTP_PerPRB_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	rNTP_PerPRB_t& ref_rNTP_PerPRB() {return rNTP_PerPRB;}
+	rNTP_PerPRB_t const& ref_rNTP_PerPRB() const {return rNTP_PerPRB;}
+	struct rNTP_Threshold_t : RNTP_Threshold
+	{
+		static constexpr const char* name() {return "rNTP_Threshold_t";}
+		using parent_t = RNTP_Threshold;
+
+	};
+	rNTP_Threshold_t& ref_rNTP_Threshold() {return rNTP_Threshold;}
+	rNTP_Threshold_t const& ref_rNTP_Threshold() const {return rNTP_Threshold;}
+	struct numberOfCellSpecificAntennaPorts_t : asn::enumerated<3, 0, true>
+	{
+		static constexpr const char* name() {return "numberOfCellSpecificAntennaPorts_t";}
+		using parent_t = asn::enumerated<3, 0, true>;
+		typedef enum {
+			one
+			,two
+			,four
+		} index_t;
+
+	};
+
+	numberOfCellSpecificAntennaPorts_t& ref_numberOfCellSpecificAntennaPorts() {return numberOfCellSpecificAntennaPorts;}
+	numberOfCellSpecificAntennaPorts_t const& ref_numberOfCellSpecificAntennaPorts() const {return numberOfCellSpecificAntennaPorts;}
+	struct p_B_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 3>>;
+		static constexpr const char* name() {return "p_B_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	p_B_t& ref_p_B() {return p_B;}
+	p_B_t const& ref_p_B() const {return p_B;}
+	struct pDCCH_InterferenceImpact_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 4>>;
+		static constexpr const char* name() {return "pDCCH_InterferenceImpact_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	pDCCH_InterferenceImpact_t& ref_pDCCH_InterferenceImpact() {return pDCCH_InterferenceImpact;}
+	pDCCH_InterferenceImpact_t const& ref_pDCCH_InterferenceImpact() const {return pDCCH_InterferenceImpact;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<RelativeNarrowbandTxPower_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<RelativeNarrowbandTxPower_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(rNTP_PerPRB);
+		v(rNTP_Threshold);
+		v(numberOfCellSpecificAntennaPorts);
+		v(p_B);
+		v(pDCCH_InterferenceImpact);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(rNTP_PerPRB);
+		v(rNTP_Threshold);
+		v(numberOfCellSpecificAntennaPorts);
+		v(p_B);
+		v(pDCCH_InterferenceImpact);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		rNTP_PerPRB.clear();
+		rNTP_Threshold.clear();
+		numberOfCellSpecificAntennaPorts.clear();
+		p_B.clear();
+		pDCCH_InterferenceImpact.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	rNTP_PerPRB_t	rNTP_PerPRB;
+	rNTP_Threshold_t	rNTP_Threshold;
+	numberOfCellSpecificAntennaPorts_t	numberOfCellSpecificAntennaPorts;
+	p_B_t	p_B;
+	pDCCH_InterferenceImpact_t	pDCCH_InterferenceImpact;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ReportCharacteristics	::= BIT STRING (SIZE (32))
+*/
+
+struct ReportCharacteristics : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<32>>;
+	static constexpr const char* name() {return "ReportCharacteristics";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+ReportingPeriodicityCSIR ::= ENUMERATED {
+	ms5,
+	ms10,
+	ms20,
+	ms40,
+	ms80,
+...
+}
+*/
+
+struct ReportingPeriodicityCSIR : asn::enumerated<5, 0, true>
+{
+	static constexpr const char* name() {return "ReportingPeriodicityCSIR";}
+	using parent_t = asn::enumerated<5, 0, true>;
+	typedef enum {
+		ms5
+		,ms10
+		,ms20
+		,ms40
+		,ms80
+	} index_t;
+
+};
+
+/*
+ReportingPeriodicityRSRPMR ::= ENUMERATED {
+	one-hundred-20-ms,
+	two-hundred-40-ms,
+	four-hundred-80-ms,
+	six-hundred-40-ms,
+...
+}
+*/
+
+struct ReportingPeriodicityRSRPMR : asn::enumerated<4, 0, true>
+{
+	static constexpr const char* name() {return "ReportingPeriodicityRSRPMR";}
+	using parent_t = asn::enumerated<4, 0, true>;
+	typedef enum {
+		one_hundred_20_ms
+		,two_hundred_40_ms
+		,four_hundred_80_ms
+		,six_hundred_40_ms
+	} index_t;
+
+};
+
+/*
+ResumeID	::= CHOICE {
+	non-truncated	BIT STRING(SIZE(40)),
+	truncated		BIT STRING(SIZE(24)),
+	...
+}
+*/
+
+struct ResumeID : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "ResumeID";}
+	using parent_t = asn::choice<2, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 3;}
+	void set_unknown() { set_index(3);  }
+	~ResumeID() {clear();}
+	struct non_truncated_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<40>>;
+		static constexpr const char* name() {return "non_truncated_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	struct truncated_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<24>>;
+		static constexpr const char* name() {return "truncated_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<non_truncated_t>(); break;
+		case 2: var.destroy<truncated_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<non_truncated_t>());
+		case 2: set_index(2); return v(var.build<truncated_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<non_truncated_t>());
+		case 2: return v(var.as<truncated_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<non_truncated_t>(1);
+		v.template operator()<truncated_t>(2);
+
+	}
+	non_truncated_t& select_non_truncated() { if(get_index() != 1) { clear(); set_index(1); return var.build<non_truncated_t>();} return var.as<non_truncated_t>();}
+	non_truncated_t const* get_non_truncated() const { if(get_index() == 1) { return &var.as<non_truncated_t>();} return nullptr; }
+	truncated_t& select_truncated() { if(get_index() != 2) { clear(); set_index(2); return var.build<truncated_t>();} return var.as<truncated_t>();}
+	truncated_t const* get_truncated() const { if(get_index() == 2) { return &var.as<truncated_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(non_truncated_t)];
+		char dummy2[sizeof(truncated_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+S1TNLLoadIndicator-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct S1TNLLoadIndicator_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+S1TNLLoadIndicator ::= SEQUENCE {
+	dLS1TNLLoadIndicator			LoadIndicator,
+	uLS1TNLLoadIndicator			LoadIndicator,
+	iE-Extensions					ProtocolExtensionContainer { {S1TNLLoadIndicator-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct S1TNLLoadIndicator : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "S1TNLLoadIndicator";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct dLS1TNLLoadIndicator_t : LoadIndicator
+	{
+		static constexpr const char* name() {return "dLS1TNLLoadIndicator_t";}
+		using parent_t = LoadIndicator;
+
+	};
+	dLS1TNLLoadIndicator_t& ref_dLS1TNLLoadIndicator() {return dLS1TNLLoadIndicator;}
+	dLS1TNLLoadIndicator_t const& ref_dLS1TNLLoadIndicator() const {return dLS1TNLLoadIndicator;}
+	struct uLS1TNLLoadIndicator_t : LoadIndicator
+	{
+		static constexpr const char* name() {return "uLS1TNLLoadIndicator_t";}
+		using parent_t = LoadIndicator;
+
+	};
+	uLS1TNLLoadIndicator_t& ref_uLS1TNLLoadIndicator() {return uLS1TNLLoadIndicator;}
+	uLS1TNLLoadIndicator_t const& ref_uLS1TNLLoadIndicator() const {return uLS1TNLLoadIndicator;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<S1TNLLoadIndicator_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<S1TNLLoadIndicator_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(dLS1TNLLoadIndicator);
+		v(uLS1TNLLoadIndicator);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(dLS1TNLLoadIndicator);
+		v(uLS1TNLLoadIndicator);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		dLS1TNLLoadIndicator.clear();
+		uLS1TNLLoadIndicator.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	dLS1TNLLoadIndicator_t	dLS1TNLLoadIndicator;
+	uLS1TNLLoadIndicator_t	uLS1TNLLoadIndicator;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+SCGChangeIndication ::= ENUMERATED {pDCPCountWrapAround, pSCellChange, other, ...}
+*/
+
+struct SCGChangeIndication : asn::enumerated<3, 0, true>
+{
+	static constexpr const char* name() {return "SCGChangeIndication";}
+	using parent_t = asn::enumerated<3, 0, true>;
+	typedef enum {
+		pDCPCountWrapAround
+		,pSCellChange
+		,other
+	} index_t;
+
+};
+
+/*
+SCGConfigurationQuery ::= ENUMERATED {true,...}
+*/
+
+struct SCGConfigurationQuery : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "SCGConfigurationQuery";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		True
+	} index_t;
+
+};
+
+/*
+SGNB-Addition-Trigger-Ind	 ::= ENUMERATED {
+	sn-change,
+	inter-eNB-HO,
+	intra-eNB-HO,
+	...
+}
+*/
+
+struct SGNB_Addition_Trigger_Ind : asn::enumerated<3, 0, true>
+{
+	static constexpr const char* name() {return "SGNB-Addition-Trigger-Ind";}
+	using parent_t = asn::enumerated<3, 0, true>;
+	typedef enum {
+		sn_change
+		,inter_eNB_HO
+		,intra_eNB_HO
+	} index_t;
+
+};
+
+/*
+SIPTOBearerDeactivationIndication ::= ENUMERATED {
+	true,
+	...
+}
+*/
+
+struct SIPTOBearerDeactivationIndication : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "SIPTOBearerDeactivationIndication";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		True
+	} index_t;
+
+};
+
+/*
+SRBType ::= ENUMERATED {srb1, srb2, ...}
+*/
+
+struct SRBType : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "SRBType";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		srb1
+		,srb2
+	} index_t;
+
+};
+
+/*
+SRVCCOperationPossible ::= ENUMERATED {
+	possible,
+	...
+}
+*/
+
+struct SRVCCOperationPossible : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "SRVCCOperationPossible";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		possible
+	} index_t;
+
+};
+
+/*
+ScheduledCommunicationTime-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ScheduledCommunicationTime_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ScheduledCommunicationTime ::= SEQUENCE {
+	dayofWeek				BIT STRING (SIZE(7))									OPTIONAL,
+	timeofDayStart			INTEGER (0..86399, ...) 								OPTIONAL,
+	timeofDayEnd				INTEGER (0..86399, ...) 								OPTIONAL,
+	iE-Extensions			ProtocolExtensionContainer { { ScheduledCommunicationTime-ExtIEs}}	OPTIONAL,
+	...
+}
+*/
+
+struct ScheduledCommunicationTime : asn::sequence<4, 0, true, 4>
+{
+	static constexpr const char* name() {return "ScheduledCommunicationTime";}
+	using parent_t = asn::sequence<4, 0, true, 4>;
+	struct dayofWeek_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<7>>;
+		static constexpr const char* name() {return "dayofWeek_t";}
+		using parent_t = asn::bstring<>;
+		static constexpr bool optional = true;
+
+	};
+
+	dayofWeek_t& set_dayofWeek() { dayofWeek.setpresent(true); return dayofWeek;}
+	dayofWeek_t const* get_dayofWeek() const {return dayofWeek.is_valid() ? &dayofWeek : nullptr;}
+	struct timeofDayStart_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 86399>>;
+		static constexpr const char* name() {return "timeofDayStart_t";}
+		using parent_t = asn::integer<>;
+		static constexpr bool optional = true;
+
+	};
+
+	timeofDayStart_t& set_timeofDayStart() { timeofDayStart.setpresent(true); return timeofDayStart;}
+	timeofDayStart_t const* get_timeofDayStart() const {return timeofDayStart.is_valid() ? &timeofDayStart : nullptr;}
+	struct timeofDayEnd_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<0, 86399>>;
+		static constexpr const char* name() {return "timeofDayEnd_t";}
+		using parent_t = asn::integer<>;
+		static constexpr bool optional = true;
+
+	};
+
+	timeofDayEnd_t& set_timeofDayEnd() { timeofDayEnd.setpresent(true); return timeofDayEnd;}
+	timeofDayEnd_t const* get_timeofDayEnd() const {return timeofDayEnd.is_valid() ? &timeofDayEnd : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ScheduledCommunicationTime_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ScheduledCommunicationTime_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(dayofWeek);
+		v(timeofDayStart);
+		v(timeofDayEnd);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(dayofWeek);
+		v(timeofDayStart);
+		v(timeofDayEnd);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		dayofWeek.clear();
+		timeofDayStart.clear();
+		timeofDayEnd.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	dayofWeek_t	dayofWeek;
+	timeofDayStart_t	timeofDayStart;
+	timeofDayEnd_t	timeofDayEnd;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+SeNBSecurityKey ::= BIT STRING (SIZE(256))
+*/
+
+struct SeNBSecurityKey : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<256>>;
+	static constexpr const char* name() {return "SeNBSecurityKey";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+SeNBtoMeNBContainer ::= OCTET STRING
+*/
+
+struct SeNBtoMeNBContainer : asn::ostring<>
+{
+	static constexpr const char* name() {return "SeNBtoMeNBContainer";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+SecondaryRATUsageReport-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct SecondaryRATUsageReport_Item_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SecondaryRATUsageReport-Item ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	secondaryRATType				ENUMERATED {nr, ...},
+	e-RABUsageReportList			E-RABUsageReportList,
+	iE-Extensions				ProtocolExtensionContainer { {SecondaryRATUsageReport-Item-ExtIEs} } OPTIONAL,
+...
+}
+*/
+
+struct SecondaryRATUsageReport_Item : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "SecondaryRATUsageReport-Item";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct e_RAB_ID_t : E_RAB_ID
+	{
+		static constexpr const char* name() {return "e_RAB_ID_t";}
+		using parent_t = E_RAB_ID;
+
+	};
+	e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
+	e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
+	struct secondaryRATType_t : asn::enumerated<1, 0, true>
+	{
+		static constexpr const char* name() {return "secondaryRATType_t";}
+		using parent_t = asn::enumerated<1, 0, true>;
+		typedef enum {
+			nr
+		} index_t;
+
+	};
+
+	secondaryRATType_t& ref_secondaryRATType() {return secondaryRATType;}
+	secondaryRATType_t const& ref_secondaryRATType() const {return secondaryRATType;}
+	struct e_RABUsageReportList_t : E_RABUsageReportList
+	{
+		static constexpr const char* name() {return "e_RABUsageReportList_t";}
+		using parent_t = E_RABUsageReportList;
+
+	};
+	e_RABUsageReportList_t& ref_e_RABUsageReportList() {return e_RABUsageReportList;}
+	e_RABUsageReportList_t const& ref_e_RABUsageReportList() const {return e_RABUsageReportList;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<SecondaryRATUsageReport_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<SecondaryRATUsageReport_Item_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(e_RAB_ID);
+		v(secondaryRATType);
+		v(e_RABUsageReportList);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(secondaryRATType);
+		v(e_RABUsageReportList);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		secondaryRATType.clear();
+		e_RABUsageReportList.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	secondaryRATType_t	secondaryRATType;
+	e_RABUsageReportList_t	e_RABUsageReportList;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+SecondaryRATUsageReport-ItemIEs	X2AP-PROTOCOL-IES ::= {
+	{ ID id-SecondaryRATUsageReport-Item		CRITICALITY reject	TYPE SecondaryRATUsageReport-Item		PRESENCE mandatory},
+	...
+}
+*/
+
+struct SecondaryRATUsageReport_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_SecondaryRATUsageReport_Item() { set(id_SecondaryRATUsageReport_Item); type=1;}
+		X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_SecondaryRATUsageReport_Item)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_SecondaryRATUsageReport_Item);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_SecondaryRATUsageReport_Item() { set(reject); type=1;}
+		X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(reject)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		SecondaryRATUsageReport_Item& select_id_SecondaryRATUsageReport_Item() { return set<SecondaryRATUsageReport_Item>(1); }
+		SecondaryRATUsageReport_Item const* get_id_SecondaryRATUsageReport_Item() const { return get<SecondaryRATUsageReport_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<SecondaryRATUsageReport_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<SecondaryRATUsageReport_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_SecondaryRATUsageReport_Item()); return true;
+			case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<SecondaryRATUsageReport_Item>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(SecondaryRATUsageReport_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_SecondaryRATUsageReport_Item() { set(mandatory); type=1;}
+		X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(mandatory)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SecondaryRATUsageReportList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container {{SecondaryRATUsageReport-ItemIEs}}
+*/
+
+struct SecondaryRATUsageReportList_elm : ProtocolIE_Single_Container<SecondaryRATUsageReport_ItemIEs>
+{
+	static constexpr const char* name() {return "SecondaryRATUsageReportList_elm";}
+	using parent_t = ProtocolIE_Single_Container<SecondaryRATUsageReport_ItemIEs>;
+
+};
+struct SecondaryRATUsageReportList : asn::sequenceof<SecondaryRATUsageReportList_elm>
+{
+	static constexpr const char* name() {return "SecondaryRATUsageReportList";}
+	using parent_t = asn::sequenceof<SecondaryRATUsageReportList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+ServedCell-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ServedCell_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ServedCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-Number-of-Antennaports				CRITICALITY ignore	EXTENSION Number-of-Antennaports					PRESENCE optional}|
+	{ ID id-PRACH-Configuration					CRITICALITY ignore	EXTENSION PRACH-Configuration						PRESENCE optional}|
+	{ ID id-MBSFN-Subframe-Info					CRITICALITY ignore	EXTENSION MBSFN-Subframe-Infolist				PRESENCE optional}|
+	{ ID id-CSG-Id								CRITICALITY ignore	EXTENSION CSG-Id									PRESENCE optional}|
+	{ ID id-MBMS-Service-Area-List				CRITICALITY ignore	EXTENSION MBMS-Service-Area-Identity-List		PRESENCE optional}|
+	{ ID id-MultibandInfoList					CRITICALITY ignore	EXTENSION MultibandInfoList							PRESENCE optional}|
+	{ ID id-FreqBandIndicatorPriority			CRITICALITY ignore	EXTENSION FreqBandIndicatorPriority				PRESENCE optional}|
+	{ ID id-BandwidthReducedSI					CRITICALITY ignore	EXTENSION BandwidthReducedSI						PRESENCE optional}|
+	{ ID id-ProtectedEUTRAResourceIndication	CRITICALITY ignore	EXTENSION ProtectedEUTRAResourceIndication	PRESENCE optional},
+	...
+}
+*/
+
+struct ServedCell_Information_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 10; }
+		void clear() {type = 0;}
+		void select_id_Number_of_Antennaports() { set(id_Number_of_Antennaports); type=1;}
+		void select_id_PRACH_Configuration() { set(id_PRACH_Configuration); type=2;}
+		void select_id_MBSFN_Subframe_Info() { set(id_MBSFN_Subframe_Info); type=3;}
+		void select_id_CSG_Id() { set(id_CSG_Id); type=4;}
+		void select_id_MBMS_Service_Area_List() { set(id_MBMS_Service_Area_List); type=5;}
+		void select_id_MultibandInfoList() { set(id_MultibandInfoList); type=6;}
+		void select_id_FreqBandIndicatorPriority() { set(id_FreqBandIndicatorPriority); type=7;}
+		void select_id_BandwidthReducedSI() { set(id_BandwidthReducedSI); type=8;}
+		void select_id_ProtectedEUTRAResourceIndication() { set(id_ProtectedEUTRAResourceIndication); type=9;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_Number_of_Antennaports)) { type = 1; return true; }
+			else if(equal(id_PRACH_Configuration)) { type = 2; return true; }
+			else if(equal(id_MBSFN_Subframe_Info)) { type = 3; return true; }
+			else if(equal(id_CSG_Id)) { type = 4; return true; }
+			else if(equal(id_MBMS_Service_Area_List)) { type = 5; return true; }
+			else if(equal(id_MultibandInfoList)) { type = 6; return true; }
+			else if(equal(id_FreqBandIndicatorPriority)) { type = 7; return true; }
+			else if(equal(id_BandwidthReducedSI)) { type = 8; return true; }
+			else if(equal(id_ProtectedEUTRAResourceIndication)) { type = 9; return true; }
+			else { type = 10; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_Number_of_Antennaports);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_PRACH_Configuration);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_MBSFN_Subframe_Info);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CSG_Id);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_MBMS_Service_Area_List);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_MultibandInfoList);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_FreqBandIndicatorPriority);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_BandwidthReducedSI);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_ProtectedEUTRAResourceIndication);} return false;
+			case 10: type = 10; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 10; }
+		void clear() {type = 0;}
+		void select_id_Number_of_Antennaports() { set(ignore); type=1;}
+		void select_id_PRACH_Configuration() { set(ignore); type=2;}
+		void select_id_MBSFN_Subframe_Info() { set(ignore); type=3;}
+		void select_id_CSG_Id() { set(ignore); type=4;}
+		void select_id_MBMS_Service_Area_List() { set(ignore); type=5;}
+		void select_id_MultibandInfoList() { set(ignore); type=6;}
+		void select_id_FreqBandIndicatorPriority() { set(ignore); type=7;}
+		void select_id_BandwidthReducedSI() { set(ignore); type=8;}
+		void select_id_ProtectedEUTRAResourceIndication() { set(ignore); type=9;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else if(equal(ignore)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(ignore)) { type = 4; return true; }
+			else if(equal(ignore)) { type = 5; return true; }
+			else if(equal(ignore)) { type = 6; return true; }
+			else if(equal(ignore)) { type = 7; return true; }
+			else if(equal(ignore)) { type = 8; return true; }
+			else if(equal(ignore)) { type = 9; return true; }
+			else { type = 10; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 10: type = 10; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		Number_of_Antennaports& select_id_Number_of_Antennaports() { return set<Number_of_Antennaports>(1); }
+		Number_of_Antennaports const* get_id_Number_of_Antennaports() const { return get<Number_of_Antennaports>(1); }
+		PRACH_Configuration& select_id_PRACH_Configuration() { return set<PRACH_Configuration>(2); }
+		PRACH_Configuration const* get_id_PRACH_Configuration() const { return get<PRACH_Configuration>(2); }
+		MBSFN_Subframe_Infolist& select_id_MBSFN_Subframe_Info() { return set<MBSFN_Subframe_Infolist>(3); }
+		MBSFN_Subframe_Infolist const* get_id_MBSFN_Subframe_Info() const { return get<MBSFN_Subframe_Infolist>(3); }
+		CSG_Id& select_id_CSG_Id() { return set<CSG_Id>(4); }
+		CSG_Id const* get_id_CSG_Id() const { return get<CSG_Id>(4); }
+		MBMS_Service_Area_Identity_List& select_id_MBMS_Service_Area_List() { return set<MBMS_Service_Area_Identity_List>(5); }
+		MBMS_Service_Area_Identity_List const* get_id_MBMS_Service_Area_List() const { return get<MBMS_Service_Area_Identity_List>(5); }
+		MultibandInfoList& select_id_MultibandInfoList() { return set<MultibandInfoList>(6); }
+		MultibandInfoList const* get_id_MultibandInfoList() const { return get<MultibandInfoList>(6); }
+		FreqBandIndicatorPriority& select_id_FreqBandIndicatorPriority() { return set<FreqBandIndicatorPriority>(7); }
+		FreqBandIndicatorPriority const* get_id_FreqBandIndicatorPriority() const { return get<FreqBandIndicatorPriority>(7); }
+		BandwidthReducedSI& select_id_BandwidthReducedSI() { return set<BandwidthReducedSI>(8); }
+		BandwidthReducedSI const* get_id_BandwidthReducedSI() const { return get<BandwidthReducedSI>(8); }
+		ProtectedEUTRAResourceIndication& select_id_ProtectedEUTRAResourceIndication() { return set<ProtectedEUTRAResourceIndication>(9); }
+		ProtectedEUTRAResourceIndication const* get_id_ProtectedEUTRAResourceIndication() const { return get<ProtectedEUTRAResourceIndication>(9); }
+		bool is_unknown() const { return type == 10; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Number_of_Antennaports>(); break;
+			case 2: var.destroy<PRACH_Configuration>(); break;
+			case 3: var.destroy<MBSFN_Subframe_Infolist>(); break;
+			case 4: var.destroy<CSG_Id>(); break;
+			case 5: var.destroy<MBMS_Service_Area_Identity_List>(); break;
+			case 6: var.destroy<MultibandInfoList>(); break;
+			case 7: var.destroy<FreqBandIndicatorPriority>(); break;
+			case 8: var.destroy<BandwidthReducedSI>(); break;
+			case 9: var.destroy<ProtectedEUTRAResourceIndication>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Number_of_Antennaports>(1);
+			v.template operator()<PRACH_Configuration>(2);
+			v.template operator()<MBSFN_Subframe_Infolist>(3);
+			v.template operator()<CSG_Id>(4);
+			v.template operator()<MBMS_Service_Area_Identity_List>(5);
+			v.template operator()<MultibandInfoList>(6);
+			v.template operator()<FreqBandIndicatorPriority>(7);
+			v.template operator()<BandwidthReducedSI>(8);
+			v.template operator()<ProtectedEUTRAResourceIndication>(9);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Number_of_Antennaports()); return true;
+			case 2: v(select_id_PRACH_Configuration()); return true;
+			case 3: v(select_id_MBSFN_Subframe_Info()); return true;
+			case 4: v(select_id_CSG_Id()); return true;
+			case 5: v(select_id_MBMS_Service_Area_List()); return true;
+			case 6: v(select_id_MultibandInfoList()); return true;
+			case 7: v(select_id_FreqBandIndicatorPriority()); return true;
+			case 8: v(select_id_BandwidthReducedSI()); return true;
+			case 9: v(select_id_ProtectedEUTRAResourceIndication()); return true;
+			case 10: if(type != 10) {clear(); asn::base::set();} type = 10; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<Number_of_Antennaports>()); return true;
+			case 2: v(var.as<PRACH_Configuration>()); return true;
+			case 3: v(var.as<MBSFN_Subframe_Infolist>()); return true;
+			case 4: v(var.as<CSG_Id>()); return true;
+			case 5: v(var.as<MBMS_Service_Area_Identity_List>()); return true;
+			case 6: v(var.as<MultibandInfoList>()); return true;
+			case 7: v(var.as<FreqBandIndicatorPriority>()); return true;
+			case 8: v(var.as<BandwidthReducedSI>()); return true;
+			case 9: v(var.as<ProtectedEUTRAResourceIndication>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(BandwidthReducedSI)];
+			char dummy2[sizeof(CSG_Id)];
+			char dummy3[sizeof(FreqBandIndicatorPriority)];
+			char dummy4[sizeof(MBMS_Service_Area_Identity_List)];
+			char dummy5[sizeof(MBSFN_Subframe_Infolist)];
+			char dummy6[sizeof(MultibandInfoList)];
+			char dummy7[sizeof(Number_of_Antennaports)];
+			char dummy8[sizeof(PRACH_Configuration)];
+			char dummy9[sizeof(ProtectedEUTRAResourceIndication)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 10; }
+		void clear() {type = 0;}
+		void select_id_Number_of_Antennaports() { set(optional); type=1;}
+		void select_id_PRACH_Configuration() { set(optional); type=2;}
+		void select_id_MBSFN_Subframe_Info() { set(optional); type=3;}
+		void select_id_CSG_Id() { set(optional); type=4;}
+		void select_id_MBMS_Service_Area_List() { set(optional); type=5;}
+		void select_id_MultibandInfoList() { set(optional); type=6;}
+		void select_id_FreqBandIndicatorPriority() { set(optional); type=7;}
+		void select_id_BandwidthReducedSI() { set(optional); type=8;}
+		void select_id_ProtectedEUTRAResourceIndication() { set(optional); type=9;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else if(equal(optional)) { type = 2; return true; }
+			else if(equal(optional)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else if(equal(optional)) { type = 6; return true; }
+			else if(equal(optional)) { type = 7; return true; }
+			else if(equal(optional)) { type = 8; return true; }
+			else if(equal(optional)) { type = 9; return true; }
+			else { type = 10; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
+			case 10: type = 10; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ServedCell-Information ::= SEQUENCE {
+	pCI					PCI,
+	cellId				ECGI,
+	tAC					TAC,
+	broadcastPLMNs		BroadcastPLMNs-Item,
+	eUTRA-Mode-Info		EUTRA-Mode-Info,
+	iE-Extensions		ProtocolExtensionContainer { {ServedCell-Information-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ServedCell_Information : asn::sequence<6, 0, true, 1>
+{
+	static constexpr const char* name() {return "ServedCell-Information";}
+	using parent_t = asn::sequence<6, 0, true, 1>;
+	struct pCI_t : PCI
+	{
+		static constexpr const char* name() {return "pCI_t";}
+		using parent_t = PCI;
+
+	};
+	pCI_t& ref_pCI() {return pCI;}
+	pCI_t const& ref_pCI() const {return pCI;}
+	struct cellId_t : ECGI
+	{
+		static constexpr const char* name() {return "cellId_t";}
+		using parent_t = ECGI;
+
+	};
+	cellId_t& ref_cellId() {return cellId;}
+	cellId_t const& ref_cellId() const {return cellId;}
+	struct tAC_t : TAC
+	{
+		static constexpr const char* name() {return "tAC_t";}
+		using parent_t = TAC;
+
+	};
+	tAC_t& ref_tAC() {return tAC;}
+	tAC_t const& ref_tAC() const {return tAC;}
+	struct broadcastPLMNs_t : BroadcastPLMNs_Item
+	{
+		static constexpr const char* name() {return "broadcastPLMNs_t";}
+		using parent_t = BroadcastPLMNs_Item;
+
+	};
+	broadcastPLMNs_t& ref_broadcastPLMNs() {return broadcastPLMNs;}
+	broadcastPLMNs_t const& ref_broadcastPLMNs() const {return broadcastPLMNs;}
+	struct eUTRA_Mode_Info_t : EUTRA_Mode_Info
+	{
+		static constexpr const char* name() {return "eUTRA_Mode_Info_t";}
+		using parent_t = EUTRA_Mode_Info;
+
+	};
+	eUTRA_Mode_Info_t& ref_eUTRA_Mode_Info() {return eUTRA_Mode_Info;}
+	eUTRA_Mode_Info_t const& ref_eUTRA_Mode_Info() const {return eUTRA_Mode_Info;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ServedCell_Information_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ServedCell_Information_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(pCI);
+		v(cellId);
+		v(tAC);
+		v(broadcastPLMNs);
+		v(eUTRA_Mode_Info);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(pCI);
+		v(cellId);
+		v(tAC);
+		v(broadcastPLMNs);
+		v(eUTRA_Mode_Info);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		pCI.clear();
+		cellId.clear();
+		tAC.clear();
+		broadcastPLMNs.clear();
+		eUTRA_Mode_Info.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	pCI_t	pCI;
+	cellId_t	cellId;
+	tAC_t	tAC;
+	broadcastPLMNs_t	broadcastPLMNs;
+	eUTRA_Mode_Info_t	eUTRA_Mode_Info;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ServedCells ::= SEQUENCE (SIZE (1.. maxCellineNB)) OF SEQUENCE {
+	servedCellInfo					ServedCell-Information,
+	neighbour-Info					Neighbour-Information			OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {ServedCell-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ServedCells_elm : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "ServedCells_elm";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	struct servedCellInfo_t : ServedCell_Information
+	{
+		static constexpr const char* name() {return "servedCellInfo_t";}
+		using parent_t = ServedCell_Information;
+
+	};
+	servedCellInfo_t& ref_servedCellInfo() {return servedCellInfo;}
+	servedCellInfo_t const& ref_servedCellInfo() const {return servedCellInfo;}
+	struct neighbour_Info_t : Neighbour_Information
+	{
+		static constexpr const char* name() {return "neighbour_Info_t";}
+		using parent_t = Neighbour_Information;
+		static constexpr bool optional = true;
+
+	};
+	neighbour_Info_t& set_neighbour_Info() { neighbour_Info.setpresent(true); return neighbour_Info;}
+	neighbour_Info_t const* get_neighbour_Info() const {return neighbour_Info.is_valid() ? &neighbour_Info : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ServedCell_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ServedCell_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(servedCellInfo);
+		v(neighbour_Info);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(servedCellInfo);
+		v(neighbour_Info);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		servedCellInfo.clear();
+		neighbour_Info.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	servedCellInfo_t	servedCellInfo;
+	neighbour_Info_t	neighbour_Info;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct ServedCells : asn::sequenceof<ServedCells_elm>
+{
+	static constexpr const char* name() {return "ServedCells";}
+	using parent_t = asn::sequenceof<ServedCells_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+ServiceType ::= ENUMERATED{
+	qMC-for-streaming-service,
+	qMC-for-MTSI-service,
+	...
+}
+*/
+
+struct ServiceType : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "ServiceType";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		qMC_for_streaming_service
+		,qMC_for_MTSI_service
+	} index_t;
+
+};
+
+/*
+SgNB-UE-X2AP-ID ::= INTEGER (0..4294967295)
+*/
+
+struct SgNB_UE_X2AP_ID : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
+	static constexpr const char* name() {return "SgNB-UE-X2AP-ID";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+SgNBCoordinationAssistanceInformation ::= ENUMERATED{
+	coordination-not-required,
+	...
+}
+*/
+
+struct SgNBCoordinationAssistanceInformation : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "SgNBCoordinationAssistanceInformation";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		coordination_not_required
+	} index_t;
+
+};
+
+/*
+SgNBResourceCoordinationInformationExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-ECGI										CRITICALITY ignore	EXTENSION ECGI												PRESENCE optional}|
+	{ ID id-SgNBCoordinationAssistanceInformation		CRITICALITY reject	EXTENSION SgNBCoordinationAssistanceInformation	PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBResourceCoordinationInformationExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_ECGI() { set(id_ECGI); type=1;}
+		void select_id_SgNBCoordinationAssistanceInformation() { set(id_SgNBCoordinationAssistanceInformation); type=2;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_ECGI)) { type = 1; return true; }
+			else if(equal(id_SgNBCoordinationAssistanceInformation)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_ECGI);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNBCoordinationAssistanceInformation);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_ECGI() { set(ignore); type=1;}
+		void select_id_SgNBCoordinationAssistanceInformation() { set(reject); type=2;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else if(equal(reject)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		ECGI& select_id_ECGI() { return set<ECGI>(1); }
+		ECGI const* get_id_ECGI() const { return get<ECGI>(1); }
+		SgNBCoordinationAssistanceInformation& select_id_SgNBCoordinationAssistanceInformation() { return set<SgNBCoordinationAssistanceInformation>(2); }
+		SgNBCoordinationAssistanceInformation const* get_id_SgNBCoordinationAssistanceInformation() const { return get<SgNBCoordinationAssistanceInformation>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ECGI>(); break;
+			case 2: var.destroy<SgNBCoordinationAssistanceInformation>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ECGI>(1);
+			v.template operator()<SgNBCoordinationAssistanceInformation>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ECGI()); return true;
+			case 2: v(select_id_SgNBCoordinationAssistanceInformation()); return true;
+			case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<ECGI>()); return true;
+			case 2: v(var.as<SgNBCoordinationAssistanceInformation>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(ECGI)];
+			char dummy2[sizeof(SgNBCoordinationAssistanceInformation)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_ECGI() { set(optional); type=1;}
+		void select_id_SgNBCoordinationAssistanceInformation() { set(optional); type=2;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else if(equal(optional)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBResourceCoordinationInformation ::= SEQUENCE {
+	nR-CGI							NRCGI,
+	uLCoordinationInformation		BIT STRING (SIZE(6..4400, ...)),
+	dLCoordinationInformation		BIT STRING (SIZE(6..4400, ...))	OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {SgNBResourceCoordinationInformationExtIEs} }		 OPTIONAL,
+	...
+}
+*/
+
+struct SgNBResourceCoordinationInformation : asn::sequence<4, 0, true, 2>
+{
+	static constexpr const char* name() {return "SgNBResourceCoordinationInformation";}
+	using parent_t = asn::sequence<4, 0, true, 2>;
+	struct nR_CGI_t : NRCGI
+	{
+		static constexpr const char* name() {return "nR_CGI_t";}
+		using parent_t = NRCGI;
+
+	};
+	nR_CGI_t& ref_nR_CGI() {return nR_CGI;}
+	nR_CGI_t const& ref_nR_CGI() const {return nR_CGI;}
+	struct uLCoordinationInformation_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
+		static constexpr const char* name() {return "uLCoordinationInformation_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	uLCoordinationInformation_t& ref_uLCoordinationInformation() {return uLCoordinationInformation;}
+	uLCoordinationInformation_t const& ref_uLCoordinationInformation() const {return uLCoordinationInformation;}
+	struct dLCoordinationInformation_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
+		static constexpr const char* name() {return "dLCoordinationInformation_t";}
+		using parent_t = asn::bstring<>;
+		static constexpr bool optional = true;
+
+	};
+
+	dLCoordinationInformation_t& set_dLCoordinationInformation() { dLCoordinationInformation.setpresent(true); return dLCoordinationInformation;}
+	dLCoordinationInformation_t const* get_dLCoordinationInformation() const {return dLCoordinationInformation.is_valid() ? &dLCoordinationInformation : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<SgNBResourceCoordinationInformationExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<SgNBResourceCoordinationInformationExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(nR_CGI);
+		v(uLCoordinationInformation);
+		v(dLCoordinationInformation);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(nR_CGI);
+		v(uLCoordinationInformation);
+		v(dLCoordinationInformation);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		nR_CGI.clear();
+		uLCoordinationInformation.clear();
+		dLCoordinationInformation.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	nR_CGI_t	nR_CGI;
+	uLCoordinationInformation_t	uLCoordinationInformation;
+	dLCoordinationInformation_t	dLCoordinationInformation;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+SgNBSecurityKey ::= BIT STRING (SIZE(256))
+*/
+
+struct SgNBSecurityKey : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<256>>;
+	static constexpr const char* name() {return "SgNBSecurityKey";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+SgNBtoMeNBContainer ::= OCTET STRING
+*/
+
+struct SgNBtoMeNBContainer : asn::ostring<>
+{
+	static constexpr const char* name() {return "SgNBtoMeNBContainer";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+ShortMAC-I ::= BIT STRING (SIZE(16))
+*/
+
+struct ShortMAC_I : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<16>>;
+	static constexpr const char* name() {return "ShortMAC-I";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+SpectrumSharingGroupID ::= INTEGER (1..maxCellineNB)
+*/
+
+struct SpectrumSharingGroupID : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+	static constexpr const char* name() {return "SpectrumSharingGroupID";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+SplitSRB-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct SplitSRB_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SplitSRB ::= SEQUENCE {
+	rrcContainer 				RRCContainer			OPTIONAL,
+	srbType						SRBType,
+	deliveryStatus				DeliveryStatus			OPTIONAL,
+	iE-Extensions				ProtocolExtensionContainer { {SplitSRB-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct SplitSRB : asn::sequence<4, 0, true, 3>
+{
+	static constexpr const char* name() {return "SplitSRB";}
+	using parent_t = asn::sequence<4, 0, true, 3>;
+	struct rrcContainer_t : RRCContainer
+	{
+		static constexpr const char* name() {return "rrcContainer_t";}
+		using parent_t = RRCContainer;
+		static constexpr bool optional = true;
+
+	};
+	rrcContainer_t& set_rrcContainer() { rrcContainer.setpresent(true); return rrcContainer;}
+	rrcContainer_t const* get_rrcContainer() const {return rrcContainer.is_valid() ? &rrcContainer : nullptr;}
+	struct srbType_t : SRBType
+	{
+		static constexpr const char* name() {return "srbType_t";}
+		using parent_t = SRBType;
+
+	};
+	srbType_t& ref_srbType() {return srbType;}
+	srbType_t const& ref_srbType() const {return srbType;}
+	struct deliveryStatus_t : DeliveryStatus
+	{
+		static constexpr const char* name() {return "deliveryStatus_t";}
+		using parent_t = DeliveryStatus;
+		static constexpr bool optional = true;
+
+	};
+	deliveryStatus_t& set_deliveryStatus() { deliveryStatus.setpresent(true); return deliveryStatus;}
+	deliveryStatus_t const* get_deliveryStatus() const {return deliveryStatus.is_valid() ? &deliveryStatus : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<SplitSRB_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<SplitSRB_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(rrcContainer);
+		v(srbType);
+		v(deliveryStatus);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(rrcContainer);
+		v(srbType);
+		v(deliveryStatus);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		rrcContainer.clear();
+		srbType.clear();
+		deliveryStatus.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	rrcContainer_t	rrcContainer;
+	srbType_t	srbType;
+	deliveryStatus_t	deliveryStatus;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+SplitSRBs ::= ENUMERATED {srb1, srb2, srb1and2, ...}
+*/
+
+struct SplitSRBs : asn::enumerated<3, 0, true>
+{
+	static constexpr const char* name() {return "SplitSRBs";}
+	using parent_t = asn::enumerated<3, 0, true>;
+	typedef enum {
+		srb1
+		,srb2
+		,srb1and2
+	} index_t;
+
+};
+
+/*
+SubscriberProfileIDforRFP ::= INTEGER (1..256)
+*/
+
+struct SubscriberProfileIDforRFP : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<1, 256>>;
+	static constexpr const char* name() {return "SubscriberProfileIDforRFP";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+Subscription-Based-UE-DifferentiationInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct Subscription_Based_UE_DifferentiationInfo_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+Subscription-Based-UE-DifferentiationInfo ::= SEQUENCE {
+	periodicCommunicationIndicator	ENUMERATED {periodically, ondemand, ...}		OPTIONAL,
+	periodicTime					INTEGER (1..3600, ...) 							OPTIONAL,
+	scheduledCommunicationTime		ScheduledCommunicationTime 						OPTIONAL,
+	stationaryIndication			ENUMERATED {stationary, mobile, ...}			OPTIONAL,
+	trafficProfile 					ENUMERATED {single-packet, dual-packets, multiple-packets, ...} 			OPTIONAL,
+	batteryIndication				ENUMERATED {battery-powered, battery-powered-not-rechargeable-or-replaceable, not-battery-powered, ...}		OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { { Subscription-Based-UE-DifferentiationInfo-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct Subscription_Based_UE_DifferentiationInfo : asn::sequence<7, 0, true, 7>
+{
+	static constexpr const char* name() {return "Subscription-Based-UE-DifferentiationInfo";}
+	using parent_t = asn::sequence<7, 0, true, 7>;
+	struct periodicCommunicationIndicator_t : asn::enumerated<2, 0, true>
+	{
+		static constexpr const char* name() {return "periodicCommunicationIndicator_t";}
+		using parent_t = asn::enumerated<2, 0, true>;
+		static constexpr bool optional = true;
+		typedef enum {
+			periodically
+			,ondemand
+		} index_t;
+
+	};
+
+	periodicCommunicationIndicator_t& set_periodicCommunicationIndicator() { periodicCommunicationIndicator.setpresent(true); return periodicCommunicationIndicator;}
+	periodicCommunicationIndicator_t const* get_periodicCommunicationIndicator() const {return periodicCommunicationIndicator.is_valid() ? &periodicCommunicationIndicator : nullptr;}
+	struct periodicTime_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<true,asn::span<1, 3600>>;
+		static constexpr const char* name() {return "periodicTime_t";}
+		using parent_t = asn::integer<>;
+		static constexpr bool optional = true;
+
+	};
+
+	periodicTime_t& set_periodicTime() { periodicTime.setpresent(true); return periodicTime;}
+	periodicTime_t const* get_periodicTime() const {return periodicTime.is_valid() ? &periodicTime : nullptr;}
+	struct scheduledCommunicationTime_t : ScheduledCommunicationTime
+	{
+		static constexpr const char* name() {return "scheduledCommunicationTime_t";}
+		using parent_t = ScheduledCommunicationTime;
+		static constexpr bool optional = true;
+
+	};
+	scheduledCommunicationTime_t& set_scheduledCommunicationTime() { scheduledCommunicationTime.setpresent(true); return scheduledCommunicationTime;}
+	scheduledCommunicationTime_t const* get_scheduledCommunicationTime() const {return scheduledCommunicationTime.is_valid() ? &scheduledCommunicationTime : nullptr;}
+	struct stationaryIndication_t : asn::enumerated<2, 0, true>
+	{
+		static constexpr const char* name() {return "stationaryIndication_t";}
+		using parent_t = asn::enumerated<2, 0, true>;
+		static constexpr bool optional = true;
+		typedef enum {
+			stationary
+			,mobile
+		} index_t;
+
+	};
+
+	stationaryIndication_t& set_stationaryIndication() { stationaryIndication.setpresent(true); return stationaryIndication;}
+	stationaryIndication_t const* get_stationaryIndication() const {return stationaryIndication.is_valid() ? &stationaryIndication : nullptr;}
+	struct trafficProfile_t : asn::enumerated<3, 0, true>
+	{
+		static constexpr const char* name() {return "trafficProfile_t";}
+		using parent_t = asn::enumerated<3, 0, true>;
+		static constexpr bool optional = true;
+		typedef enum {
+			single_packet
+			,dual_packets
+			,multiple_packets
+		} index_t;
+
+	};
+
+	trafficProfile_t& set_trafficProfile() { trafficProfile.setpresent(true); return trafficProfile;}
+	trafficProfile_t const* get_trafficProfile() const {return trafficProfile.is_valid() ? &trafficProfile : nullptr;}
+	struct batteryIndication_t : asn::enumerated<3, 0, true>
+	{
+		static constexpr const char* name() {return "batteryIndication_t";}
+		using parent_t = asn::enumerated<3, 0, true>;
+		static constexpr bool optional = true;
+		typedef enum {
+			battery_powered
+			,battery_powered_not_rechargeable_or_replaceable
+			,not_battery_powered
+		} index_t;
+
+	};
+
+	batteryIndication_t& set_batteryIndication() { batteryIndication.setpresent(true); return batteryIndication;}
+	batteryIndication_t const* get_batteryIndication() const {return batteryIndication.is_valid() ? &batteryIndication : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<Subscription_Based_UE_DifferentiationInfo_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<Subscription_Based_UE_DifferentiationInfo_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(periodicCommunicationIndicator);
+		v(periodicTime);
+		v(scheduledCommunicationTime);
+		v(stationaryIndication);
+		v(trafficProfile);
+		v(batteryIndication);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(periodicCommunicationIndicator);
+		v(periodicTime);
+		v(scheduledCommunicationTime);
+		v(stationaryIndication);
+		v(trafficProfile);
+		v(batteryIndication);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		periodicCommunicationIndicator.clear();
+		periodicTime.clear();
+		scheduledCommunicationTime.clear();
+		stationaryIndication.clear();
+		trafficProfile.clear();
+		batteryIndication.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	periodicCommunicationIndicator_t	periodicCommunicationIndicator;
+	periodicTime_t	periodicTime;
+	scheduledCommunicationTime_t	scheduledCommunicationTime;
+	stationaryIndication_t	stationaryIndication;
+	trafficProfile_t	trafficProfile;
+	batteryIndication_t	batteryIndication;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+TargetCellInUTRAN ::= OCTET STRING -- This IE is to be encoded according to the UTRAN Cell ID in the Last Visited UTRAN Cell Information IE in TS 25.413 [24]
+*/
+
+struct TargetCellInUTRAN : asn::ostring<>
+{
+	static constexpr const char* name() {return "TargetCellInUTRAN";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+TargeteNBtoSource-eNBTransparentContainer	::= OCTET STRING
+*/
+
+struct TargeteNBtoSource_eNBTransparentContainer : asn::ostring<>
+{
+	static constexpr const char* name() {return "TargeteNBtoSource-eNBTransparentContainer";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+TimeToWait ::= ENUMERATED {
+	v1s,
+	v2s,
+	v5s,
+	v10s,
+	v20s,
+	v60s,
+	...
+}
+*/
+
+struct TimeToWait : asn::enumerated<6, 0, true>
+{
+	static constexpr const char* name() {return "TimeToWait";}
+	using parent_t = asn::enumerated<6, 0, true>;
+	typedef enum {
+		v1s
+		,v2s
+		,v5s
+		,v10s
+		,v20s
+		,v60s
+	} index_t;
+
+};
+
+/*
+TraceDepth 		::= ENUMERATED {
+	minimum,
+	medium,
+	maximum,
+	minimumWithoutVendorSpecificExtension,
+	mediumWithoutVendorSpecificExtension,
+	maximumWithoutVendorSpecificExtension,
+	...
+}
+*/
+
+struct TraceDepth : asn::enumerated<6, 0, true>
+{
+	static constexpr const char* name() {return "TraceDepth";}
+	using parent_t = asn::enumerated<6, 0, true>;
+	typedef enum {
+		minimum
+		,medium
+		,maximum
+		,minimumWithoutVendorSpecificExtension
+		,mediumWithoutVendorSpecificExtension
+		,maximumWithoutVendorSpecificExtension
+	} index_t;
+
+};
+
+/*
+TraceCollectionEntityIPAddress ::= BIT STRING (SIZE(1..160, ...))
+*/
+
+struct TraceCollectionEntityIPAddress : asn::bstring<>
+{
+	using constraint_t = asn::constraints<true,asn::span<1, 160>>;
+	static constexpr const char* name() {return "TraceCollectionEntityIPAddress";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+UEAppLayerMeasConfig-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ID id-serviceType	CRITICALITY ignore	EXTENSION ServiceType	PRESENCE optional},
+	...
+}
+*/
+
+struct UEAppLayerMeasConfig_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_serviceType() { set(id_serviceType); type=1;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_serviceType)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_serviceType);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_serviceType() { set(ignore); type=1;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		ServiceType& select_id_serviceType() { return set<ServiceType>(1); }
+		ServiceType const* get_id_serviceType() const { return get<ServiceType>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ServiceType>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ServiceType>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_serviceType()); return true;
+			case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<ServiceType>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(ServiceType)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 2; }
+		void clear() {type = 0;}
+		void select_id_serviceType() { set(optional); type=1;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else { type = 2; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+UEAppLayerMeasConfig ::= SEQUENCE {
+	containerForAppLayerMeasConfig			OCTET STRING (SIZE(1..1000)),
+	areaScopeOfQMC		AreaScopeOfQMC,
+	iE-Extensions		ProtocolExtensionContainer { {UEAppLayerMeasConfig-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct UEAppLayerMeasConfig : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "UEAppLayerMeasConfig";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct containerForAppLayerMeasConfig_t : asn::ostring<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<1, 1000>>;
+		static constexpr const char* name() {return "containerForAppLayerMeasConfig_t";}
+		using parent_t = asn::ostring<>;
+
+	};
+
+	containerForAppLayerMeasConfig_t& ref_containerForAppLayerMeasConfig() {return containerForAppLayerMeasConfig;}
+	containerForAppLayerMeasConfig_t const& ref_containerForAppLayerMeasConfig() const {return containerForAppLayerMeasConfig;}
+	struct areaScopeOfQMC_t : AreaScopeOfQMC
+	{
+		static constexpr const char* name() {return "areaScopeOfQMC_t";}
+		using parent_t = AreaScopeOfQMC;
+
+	};
+	areaScopeOfQMC_t& ref_areaScopeOfQMC() {return areaScopeOfQMC;}
+	areaScopeOfQMC_t const& ref_areaScopeOfQMC() const {return areaScopeOfQMC;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UEAppLayerMeasConfig_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UEAppLayerMeasConfig_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(containerForAppLayerMeasConfig);
+		v(areaScopeOfQMC);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(containerForAppLayerMeasConfig);
+		v(areaScopeOfQMC);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		containerForAppLayerMeasConfig.clear();
+		areaScopeOfQMC.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	containerForAppLayerMeasConfig_t	containerForAppLayerMeasConfig;
+	areaScopeOfQMC_t	areaScopeOfQMC;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+TraceActivation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-MDTConfiguration			CRITICALITY ignore	EXTENSION MDT-Configuration			PRESENCE optional}|
+	{ ID id-UEAppLayerMeasConfig		CRITICALITY ignore	EXTENSION UEAppLayerMeasConfig		PRESENCE optional},
+	...
+}
+*/
+
+struct TraceActivation_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_MDTConfiguration() { set(id_MDTConfiguration); type=1;}
+		void select_id_UEAppLayerMeasConfig() { set(id_UEAppLayerMeasConfig); type=2;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_MDTConfiguration)) { type = 1; return true; }
+			else if(equal(id_UEAppLayerMeasConfig)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_MDTConfiguration);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_UEAppLayerMeasConfig);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_MDTConfiguration() { set(ignore); type=1;}
+		void select_id_UEAppLayerMeasConfig() { set(ignore); type=2;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else if(equal(ignore)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		MDT_Configuration& select_id_MDTConfiguration() { return set<MDT_Configuration>(1); }
+		MDT_Configuration const* get_id_MDTConfiguration() const { return get<MDT_Configuration>(1); }
+		UEAppLayerMeasConfig& select_id_UEAppLayerMeasConfig() { return set<UEAppLayerMeasConfig>(2); }
+		UEAppLayerMeasConfig const* get_id_UEAppLayerMeasConfig() const { return get<UEAppLayerMeasConfig>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<MDT_Configuration>(); break;
+			case 2: var.destroy<UEAppLayerMeasConfig>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<MDT_Configuration>(1);
+			v.template operator()<UEAppLayerMeasConfig>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MDTConfiguration()); return true;
+			case 2: v(select_id_UEAppLayerMeasConfig()); return true;
+			case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<MDT_Configuration>()); return true;
+			case 2: v(var.as<UEAppLayerMeasConfig>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(MDT_Configuration)];
+			char dummy2[sizeof(UEAppLayerMeasConfig)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_MDTConfiguration() { set(optional); type=1;}
+		void select_id_UEAppLayerMeasConfig() { set(optional); type=2;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else if(equal(optional)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+TraceActivation ::= SEQUENCE {
+	eUTRANTraceID					EUTRANTraceID,
+	interfacesToTrace				InterfacesToTrace,
+traceDepth							TraceDepth,
+traceCollectionEntityIPAddress		TraceCollectionEntityIPAddress,
+	iE-Extensions					ProtocolExtensionContainer { {TraceActivation-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct TraceActivation : asn::sequence<5, 0, true, 1>
+{
+	static constexpr const char* name() {return "TraceActivation";}
+	using parent_t = asn::sequence<5, 0, true, 1>;
+	struct eUTRANTraceID_t : EUTRANTraceID
+	{
+		static constexpr const char* name() {return "eUTRANTraceID_t";}
+		using parent_t = EUTRANTraceID;
+
+	};
+	eUTRANTraceID_t& ref_eUTRANTraceID() {return eUTRANTraceID;}
+	eUTRANTraceID_t const& ref_eUTRANTraceID() const {return eUTRANTraceID;}
+	struct interfacesToTrace_t : InterfacesToTrace
+	{
+		static constexpr const char* name() {return "interfacesToTrace_t";}
+		using parent_t = InterfacesToTrace;
+
+	};
+	interfacesToTrace_t& ref_interfacesToTrace() {return interfacesToTrace;}
+	interfacesToTrace_t const& ref_interfacesToTrace() const {return interfacesToTrace;}
+	struct traceDepth_t : TraceDepth
+	{
+		static constexpr const char* name() {return "traceDepth_t";}
+		using parent_t = TraceDepth;
+
+	};
+	traceDepth_t& ref_traceDepth() {return traceDepth;}
+	traceDepth_t const& ref_traceDepth() const {return traceDepth;}
+	struct traceCollectionEntityIPAddress_t : TraceCollectionEntityIPAddress
+	{
+		static constexpr const char* name() {return "traceCollectionEntityIPAddress_t";}
+		using parent_t = TraceCollectionEntityIPAddress;
+
+	};
+	traceCollectionEntityIPAddress_t& ref_traceCollectionEntityIPAddress() {return traceCollectionEntityIPAddress;}
+	traceCollectionEntityIPAddress_t const& ref_traceCollectionEntityIPAddress() const {return traceCollectionEntityIPAddress;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<TraceActivation_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<TraceActivation_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(eUTRANTraceID);
+		v(interfacesToTrace);
+		v(traceDepth);
+		v(traceCollectionEntityIPAddress);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(eUTRANTraceID);
+		v(interfacesToTrace);
+		v(traceDepth);
+		v(traceCollectionEntityIPAddress);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		eUTRANTraceID.clear();
+		interfacesToTrace.clear();
+		traceDepth.clear();
+		traceCollectionEntityIPAddress.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	eUTRANTraceID_t	eUTRANTraceID;
+	interfacesToTrace_t	interfacesToTrace;
+	traceDepth_t	traceDepth;
+	traceCollectionEntityIPAddress_t	traceCollectionEntityIPAddress;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+Tunnel-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct Tunnel_Information_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+TunnelInformation ::= SEQUENCE {
+	transportLayerAddress	TransportLayerAddress,
+	uDP-Port-Number			Port-Number			OPTIONAL,
+	iE-Extensions			ProtocolExtensionContainer { {Tunnel-Information-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct TunnelInformation : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "TunnelInformation";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	struct transportLayerAddress_t : TransportLayerAddress
+	{
+		static constexpr const char* name() {return "transportLayerAddress_t";}
+		using parent_t = TransportLayerAddress;
+
+	};
+	transportLayerAddress_t& ref_transportLayerAddress() {return transportLayerAddress;}
+	transportLayerAddress_t const& ref_transportLayerAddress() const {return transportLayerAddress;}
+	struct uDP_Port_Number_t : Port_Number
+	{
+		static constexpr const char* name() {return "uDP_Port_Number_t";}
+		using parent_t = Port_Number;
+		static constexpr bool optional = true;
+
+	};
+	uDP_Port_Number_t& set_uDP_Port_Number() { uDP_Port_Number.setpresent(true); return uDP_Port_Number;}
+	uDP_Port_Number_t const* get_uDP_Port_Number() const {return uDP_Port_Number.is_valid() ? &uDP_Port_Number : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<Tunnel_Information_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<Tunnel_Information_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(transportLayerAddress);
+		v(uDP_Port_Number);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(transportLayerAddress);
+		v(uDP_Port_Number);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		transportLayerAddress.clear();
+		uDP_Port_Number.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	transportLayerAddress_t	transportLayerAddress;
+	uDP_Port_Number_t	uDP_Port_Number;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+UE-ContextKeptIndicator ::= ENUMERATED {
+	true,
+	...
+}
+*/
+
+struct UE_ContextKeptIndicator : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "UE-ContextKeptIndicator";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		True
+	} index_t;
+
+};
+
+/*
+UE-HistoryInformation ::= SEQUENCE (SIZE(1..maxnoofCells)) OF LastVisitedCell-Item
+*/
+
+struct UE_HistoryInformation_elm : LastVisitedCell_Item
+{
+	static constexpr const char* name() {return "UE_HistoryInformation_elm";}
+	using parent_t = LastVisitedCell_Item;
+
+};
+struct UE_HistoryInformation : asn::sequenceof<UE_HistoryInformation_elm>
+{
+	static constexpr const char* name() {return "UE-HistoryInformation";}
+	using parent_t = asn::sequenceof<UE_HistoryInformation_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofCells >>;
+
+};
+/*
+UE-HistoryInformationFromTheUE ::= OCTET STRING
+*/
+
+struct UE_HistoryInformationFromTheUE : asn::ostring<>
+{
+	static constexpr const char* name() {return "UE-HistoryInformationFromTheUE";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+UE-RLF-Report-Container::= OCTET STRING
+*/
+
+struct UE_RLF_Report_Container : asn::ostring<>
+{
+	static constexpr const char* name() {return "UE-RLF-Report-Container";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+UE-RLF-Report-Container-for-extended-bands ::= OCTET STRING
+*/
+
+struct UE_RLF_Report_Container_for_extended_bands : asn::ostring<>
+{
+	static constexpr const char* name() {return "UE-RLF-Report-Container-for-extended-bands";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+UE-S1AP-ID ::= INTEGER (0.. 4294967295)
+*/
+
+struct UE_S1AP_ID : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
+	static constexpr const char* name() {return "UE-S1AP-ID";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+UE-Sidelink-Aggregate-MaximumBitRate-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct UE_Sidelink_Aggregate_MaximumBitRate_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+UE-X2AP-ID ::= INTEGER (0..4095)
+*/
+
+struct UE_X2AP_ID : asn::integer<>
+{
+	using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
+	static constexpr const char* name() {return "UE-X2AP-ID";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+UE-X2AP-ID-Extension ::= INTEGER (0..4095, ...)
+*/
+
+struct UE_X2AP_ID_Extension : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<0, 4095>>;
+	static constexpr const char* name() {return "UE-X2AP-ID-Extension";}
+	using parent_t = asn::integer<>;
+
+};
+
+/*
+UEAggregate-MaximumBitrate-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-extended-uEaggregateMaximumBitRateDownlink	CRITICALITY ignore	EXTENSION ExtendedBitRate	PRESENCE optional}|
+	{ ID id-extended-uEaggregateMaximumBitRateUplink	CRITICALITY ignore	EXTENSION ExtendedBitRate	PRESENCE optional},
+	...
+}
+*/
+
+struct UEAggregate_MaximumBitrate_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_extended_uEaggregateMaximumBitRateDownlink() { set(id_extended_uEaggregateMaximumBitRateDownlink); type=1;}
+		void select_id_extended_uEaggregateMaximumBitRateUplink() { set(id_extended_uEaggregateMaximumBitRateUplink); type=2;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(id_extended_uEaggregateMaximumBitRateDownlink)) { type = 1; return true; }
+			else if(equal(id_extended_uEaggregateMaximumBitRateUplink)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(id_extended_uEaggregateMaximumBitRateDownlink);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_extended_uEaggregateMaximumBitRateUplink);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_extended_uEaggregateMaximumBitRateDownlink() { set(ignore); type=1;}
+		void select_id_extended_uEaggregateMaximumBitRateUplink() { set(ignore); type=2;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(ignore)) { type = 1; return true; }
+			else if(equal(ignore)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		ExtendedBitRate& select_id_extended_uEaggregateMaximumBitRateDownlink() { return set<ExtendedBitRate>(1); }
+		ExtendedBitRate const* get_id_extended_uEaggregateMaximumBitRateDownlink() const { return get<ExtendedBitRate>(1); }
+		ExtendedBitRate& select_id_extended_uEaggregateMaximumBitRateUplink() { return set<ExtendedBitRate>(2); }
+		ExtendedBitRate const* get_id_extended_uEaggregateMaximumBitRateUplink() const { return get<ExtendedBitRate>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ExtendedBitRate>(); break;
+			case 2: var.destroy<ExtendedBitRate>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ExtendedBitRate>(1);
+			v.template operator()<ExtendedBitRate>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_extended_uEaggregateMaximumBitRateDownlink()); return true;
+			case 2: v(select_id_extended_uEaggregateMaximumBitRateUplink()); return true;
+			case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			switch(type)
+			{
+			case 1: v(var.as<ExtendedBitRate>()); return true;
+			case 2: v(var.as<ExtendedBitRate>()); return true;
+			}
+			return false;
+
+		}
+		private:
+		template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+		template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+		union union_type
+		{
+			char dummy1[sizeof(ExtendedBitRate)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_extended_uEaggregateMaximumBitRateDownlink() { set(optional); type=1;}
+		void select_id_extended_uEaggregateMaximumBitRateUplink() { set(optional); type=2;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			if(equal(optional)) { type = 1; return true; }
+			else if(equal(optional)) { type = 2; return true; }
+			else { type = 3; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+UEAggregateMaximumBitRate ::= SEQUENCE {
+	uEaggregateMaximumBitRateDownlink	BitRate,
+	uEaggregateMaximumBitRateUplink		BitRate,
+	iE-Extensions						ProtocolExtensionContainer { {UEAggregate-MaximumBitrate-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct UEAggregateMaximumBitRate : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "UEAggregateMaximumBitRate";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct uEaggregateMaximumBitRateDownlink_t : BitRate
+	{
+		static constexpr const char* name() {return "uEaggregateMaximumBitRateDownlink_t";}
+		using parent_t = BitRate;
+
+	};
+	uEaggregateMaximumBitRateDownlink_t& ref_uEaggregateMaximumBitRateDownlink() {return uEaggregateMaximumBitRateDownlink;}
+	uEaggregateMaximumBitRateDownlink_t const& ref_uEaggregateMaximumBitRateDownlink() const {return uEaggregateMaximumBitRateDownlink;}
+	struct uEaggregateMaximumBitRateUplink_t : BitRate
+	{
+		static constexpr const char* name() {return "uEaggregateMaximumBitRateUplink_t";}
+		using parent_t = BitRate;
+
+	};
+	uEaggregateMaximumBitRateUplink_t& ref_uEaggregateMaximumBitRateUplink() {return uEaggregateMaximumBitRateUplink;}
+	uEaggregateMaximumBitRateUplink_t const& ref_uEaggregateMaximumBitRateUplink() const {return uEaggregateMaximumBitRateUplink;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UEAggregate_MaximumBitrate_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UEAggregate_MaximumBitrate_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(uEaggregateMaximumBitRateDownlink);
+		v(uEaggregateMaximumBitRateUplink);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(uEaggregateMaximumBitRateDownlink);
+		v(uEaggregateMaximumBitRateUplink);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		uEaggregateMaximumBitRateDownlink.clear();
+		uEaggregateMaximumBitRateUplink.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	uEaggregateMaximumBitRateDownlink_t	uEaggregateMaximumBitRateDownlink;
+	uEaggregateMaximumBitRateUplink_t	uEaggregateMaximumBitRateUplink;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+UENRMeasurement-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct UENRMeasurement_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+UENRMeasurement ::= SEQUENCE {
+	uENRMeasurements			RRCContainer,
+	iE-Extensions			ProtocolExtensionContainer { {UENRMeasurement-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct UENRMeasurement : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "UENRMeasurement";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct uENRMeasurements_t : RRCContainer
+	{
+		static constexpr const char* name() {return "uENRMeasurements_t";}
+		using parent_t = RRCContainer;
+
+	};
+	uENRMeasurements_t& ref_uENRMeasurements() {return uENRMeasurements;}
+	uENRMeasurements_t const& ref_uENRMeasurements() const {return uENRMeasurements;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UENRMeasurement_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UENRMeasurement_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(uENRMeasurements);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(uENRMeasurements);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		uENRMeasurements.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	uENRMeasurements_t	uENRMeasurements;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+UESecurityCapabilities-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct UESecurityCapabilities_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+UESecurityCapabilities ::= SEQUENCE {
+	encryptionAlgorithms				EncryptionAlgorithms,
+	integrityProtectionAlgorithms		IntegrityProtectionAlgorithms,
+	iE-Extensions						ProtocolExtensionContainer { {UESecurityCapabilities-ExtIEs} }		OPTIONAL,
+...
+}
+*/
+
+struct UESecurityCapabilities : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "UESecurityCapabilities";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct encryptionAlgorithms_t : EncryptionAlgorithms
+	{
+		static constexpr const char* name() {return "encryptionAlgorithms_t";}
+		using parent_t = EncryptionAlgorithms;
+
+	};
+	encryptionAlgorithms_t& ref_encryptionAlgorithms() {return encryptionAlgorithms;}
+	encryptionAlgorithms_t const& ref_encryptionAlgorithms() const {return encryptionAlgorithms;}
+	struct integrityProtectionAlgorithms_t : IntegrityProtectionAlgorithms
+	{
+		static constexpr const char* name() {return "integrityProtectionAlgorithms_t";}
+		using parent_t = IntegrityProtectionAlgorithms;
+
+	};
+	integrityProtectionAlgorithms_t& ref_integrityProtectionAlgorithms() {return integrityProtectionAlgorithms;}
+	integrityProtectionAlgorithms_t const& ref_integrityProtectionAlgorithms() const {return integrityProtectionAlgorithms;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UESecurityCapabilities_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UESecurityCapabilities_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(encryptionAlgorithms);
+		v(integrityProtectionAlgorithms);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(encryptionAlgorithms);
+		v(integrityProtectionAlgorithms);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		encryptionAlgorithms.clear();
+		integrityProtectionAlgorithms.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	encryptionAlgorithms_t	encryptionAlgorithms;
+	integrityProtectionAlgorithms_t	integrityProtectionAlgorithms;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+UESidelinkAggregateMaximumBitRate ::= SEQUENCE {
+	uESidelinkAggregateMaximumBitRate		BitRate,
+	iE-Extensions					ProtocolExtensionContainer { {UE-Sidelink-Aggregate-MaximumBitRate-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct UESidelinkAggregateMaximumBitRate : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "UESidelinkAggregateMaximumBitRate";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct uESidelinkAggregateMaximumBitRate_t : BitRate
+	{
+		static constexpr const char* name() {return "uESidelinkAggregateMaximumBitRate_t";}
+		using parent_t = BitRate;
+
+	};
+	uESidelinkAggregateMaximumBitRate_t& ref_uESidelinkAggregateMaximumBitRate() {return uESidelinkAggregateMaximumBitRate;}
+	uESidelinkAggregateMaximumBitRate_t const& ref_uESidelinkAggregateMaximumBitRate() const {return uESidelinkAggregateMaximumBitRate;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UE_Sidelink_Aggregate_MaximumBitRate_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UE_Sidelink_Aggregate_MaximumBitRate_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(uESidelinkAggregateMaximumBitRate);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(uESidelinkAggregateMaximumBitRate);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		uESidelinkAggregateMaximumBitRate.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	uESidelinkAggregateMaximumBitRate_t	uESidelinkAggregateMaximumBitRate;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+UEsToBeResetList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct UEsToBeResetList_Item_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+UEsToBeResetList-Item::= SEQUENCE {
+	meNB-ID					UE-X2AP-ID,
+	meNB-ID-ext				UE-X2AP-ID-Extension														OPTIONAL,
+	sgNB-ID					SgNB-UE-X2AP-ID																OPTIONAL,
+	iE-Extensions			ProtocolExtensionContainer { {UEsToBeResetList-Item-ExtIEs} }				OPTIONAL,
+	...
+}
+*/
+
+struct UEsToBeResetList_Item : asn::sequence<4, 0, true, 3>
+{
+	static constexpr const char* name() {return "UEsToBeResetList-Item";}
+	using parent_t = asn::sequence<4, 0, true, 3>;
+	struct meNB_ID_t : UE_X2AP_ID
+	{
+		static constexpr const char* name() {return "meNB_ID_t";}
+		using parent_t = UE_X2AP_ID;
+
+	};
+	meNB_ID_t& ref_meNB_ID() {return meNB_ID;}
+	meNB_ID_t const& ref_meNB_ID() const {return meNB_ID;}
+	struct meNB_ID_ext_t : UE_X2AP_ID_Extension
+	{
+		static constexpr const char* name() {return "meNB_ID_ext_t";}
+		using parent_t = UE_X2AP_ID_Extension;
+		static constexpr bool optional = true;
+
+	};
+	meNB_ID_ext_t& set_meNB_ID_ext() { meNB_ID_ext.setpresent(true); return meNB_ID_ext;}
+	meNB_ID_ext_t const* get_meNB_ID_ext() const {return meNB_ID_ext.is_valid() ? &meNB_ID_ext : nullptr;}
+	struct sgNB_ID_t : SgNB_UE_X2AP_ID
+	{
+		static constexpr const char* name() {return "sgNB_ID_t";}
+		using parent_t = SgNB_UE_X2AP_ID;
+		static constexpr bool optional = true;
+
+	};
+	sgNB_ID_t& set_sgNB_ID() { sgNB_ID.setpresent(true); return sgNB_ID;}
+	sgNB_ID_t const* get_sgNB_ID() const {return sgNB_ID.is_valid() ? &sgNB_ID : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UEsToBeResetList_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UEsToBeResetList_Item_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(meNB_ID);
+		v(meNB_ID_ext);
+		v(sgNB_ID);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(meNB_ID);
+		v(meNB_ID_ext);
+		v(sgNB_ID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		meNB_ID.clear();
+		meNB_ID_ext.clear();
+		sgNB_ID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	meNB_ID_t	meNB_ID;
+	meNB_ID_ext_t	meNB_ID_ext;
+	sgNB_ID_t	sgNB_ID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+UEsToBeResetList ::= SEQUENCE (SIZE (1.. maxUEsinengNBDU)) OF UEsToBeResetList-Item
+*/
+
+struct UEsToBeResetList_elm : UEsToBeResetList_Item
+{
+	static constexpr const char* name() {return "UEsToBeResetList_elm";}
+	using parent_t = UEsToBeResetList_Item;
+
+};
+struct UEsToBeResetList : asn::sequenceof<UEsToBeResetList_elm>
+{
+	static constexpr const char* name() {return "UEsToBeResetList";}
+	using parent_t = asn::sequenceof<UEsToBeResetList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxUEsinengNBDU >>;
+
+};
+/*
+UL-HighInterferenceIndication ::= BIT STRING (SIZE(1..110, ...))
+*/
+
+struct UL_HighInterferenceIndication : asn::bstring<>
+{
+	using constraint_t = asn::constraints<true,asn::span<1, 110>>;
+	static constexpr const char* name() {return "UL-HighInterferenceIndication";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+UL-HighInterferenceIndicationInfo-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct UL_HighInterferenceIndicationInfo_Item_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+UL-HighInterferenceIndicationInfo-Item ::= SEQUENCE {
+	target-Cell-ID					ECGI,
+	ul-interferenceindication		UL-HighInterferenceIndication,
+	iE-Extensions					ProtocolExtensionContainer { {UL-HighInterferenceIndicationInfo-Item-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct UL_HighInterferenceIndicationInfo_Item : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "UL-HighInterferenceIndicationInfo-Item";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct target_Cell_ID_t : ECGI
+	{
+		static constexpr const char* name() {return "target_Cell_ID_t";}
+		using parent_t = ECGI;
+
+	};
+	target_Cell_ID_t& ref_target_Cell_ID() {return target_Cell_ID;}
+	target_Cell_ID_t const& ref_target_Cell_ID() const {return target_Cell_ID;}
+	struct ul_interferenceindication_t : UL_HighInterferenceIndication
+	{
+		static constexpr const char* name() {return "ul_interferenceindication_t";}
+		using parent_t = UL_HighInterferenceIndication;
+
+	};
+	ul_interferenceindication_t& ref_ul_interferenceindication() {return ul_interferenceindication;}
+	ul_interferenceindication_t const& ref_ul_interferenceindication() const {return ul_interferenceindication;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UL_HighInterferenceIndicationInfo_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UL_HighInterferenceIndicationInfo_Item_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(target_Cell_ID);
+		v(ul_interferenceindication);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(target_Cell_ID);
+		v(ul_interferenceindication);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		target_Cell_ID.clear();
+		ul_interferenceindication.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	target_Cell_ID_t	target_Cell_ID;
+	ul_interferenceindication_t	ul_interferenceindication;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+UL-HighInterferenceIndicationInfo ::= SEQUENCE (SIZE(1..maxCellineNB)) OF UL-HighInterferenceIndicationInfo-Item
+*/
+
+struct UL_HighInterferenceIndicationInfo_elm : UL_HighInterferenceIndicationInfo_Item
+{
+	static constexpr const char* name() {return "UL_HighInterferenceIndicationInfo_elm";}
+	using parent_t = UL_HighInterferenceIndicationInfo_Item;
+
+};
+struct UL_HighInterferenceIndicationInfo : asn::sequenceof<UL_HighInterferenceIndicationInfo_elm>
+{
+	static constexpr const char* name() {return "UL-HighInterferenceIndicationInfo";}
+	using parent_t = asn::sequenceof<UL_HighInterferenceIndicationInfo_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+UL-UE-Configuration::= ENUMERATED { no-data, shared, only, ... }
+*/
+
+struct UL_UE_Configuration : asn::enumerated<3, 0, true>
+{
+	static constexpr const char* name() {return "UL-UE-Configuration";}
+	using parent_t = asn::enumerated<3, 0, true>;
+	typedef enum {
+		no_data
+		,shared
+		,only
+	} index_t;
+
+};
+
+/*
+ULConfiguration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ULConfiguration_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ULConfiguration::= SEQUENCE {
+	uL-PDCP			UL-UE-Configuration,
+	iE-Extensions					ProtocolExtensionContainer { {ULConfiguration-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ULConfiguration : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "ULConfiguration";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct uL_PDCP_t : UL_UE_Configuration
+	{
+		static constexpr const char* name() {return "uL_PDCP_t";}
+		using parent_t = UL_UE_Configuration;
+
+	};
+	uL_PDCP_t& ref_uL_PDCP() {return uL_PDCP;}
+	uL_PDCP_t const& ref_uL_PDCP() const {return uL_PDCP;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ULConfiguration_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ULConfiguration_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(uL_PDCP);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(uL_PDCP);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		uL_PDCP.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	uL_PDCP_t	uL_PDCP;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+VehicleUE ::= ENUMERATED {
+	authorized,
+	not-authorized,
+	...
+}
+*/
+
+struct VehicleUE : asn::enumerated<2, 0, true>
+{
+	static constexpr const char* name() {return "VehicleUE";}
+	using parent_t = asn::enumerated<2, 0, true>;
+	typedef enum {
+		authorized
+		,not_authorized
+	} index_t;
+
+};
+
+/*
+V2XServicesAuthorized-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct V2XServicesAuthorized_ExtIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear()
+		{
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) return false;
+			return false;
+
+		}
+		private:
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+		template<typename V>  bool decode(V& v)
+		{
+			clear();
+			if(!v(ref_nested())) return false;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+V2XServicesAuthorized ::= SEQUENCE {
+	vehicleUE			VehicleUE														OPTIONAL,
+pedestrianUE 			PedestrianUE													OPTIONAL,
+	iE-Extensions		ProtocolExtensionContainer { {V2XServicesAuthorized-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct V2XServicesAuthorized : asn::sequence<3, 0, true, 3>
+{
+	static constexpr const char* name() {return "V2XServicesAuthorized";}
+	using parent_t = asn::sequence<3, 0, true, 3>;
+	struct vehicleUE_t : VehicleUE
+	{
+		static constexpr const char* name() {return "vehicleUE_t";}
+		using parent_t = VehicleUE;
+		static constexpr bool optional = true;
+
+	};
+	vehicleUE_t& set_vehicleUE() { vehicleUE.setpresent(true); return vehicleUE;}
+	vehicleUE_t const* get_vehicleUE() const {return vehicleUE.is_valid() ? &vehicleUE : nullptr;}
+	struct pedestrianUE_t : PedestrianUE
+	{
+		static constexpr const char* name() {return "pedestrianUE_t";}
+		using parent_t = PedestrianUE;
+		static constexpr bool optional = true;
+
+	};
+	pedestrianUE_t& set_pedestrianUE() { pedestrianUE.setpresent(true); return pedestrianUE;}
+	pedestrianUE_t const* get_pedestrianUE() const {return pedestrianUE.is_valid() ? &pedestrianUE : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<V2XServicesAuthorized_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<V2XServicesAuthorized_ExtIEs>;
+		static constexpr bool optional = true;
+
+	};
+	iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+	iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+	template<typename V> void decode(V& v)
+	{
+		v(vehicleUE);
+		v(pedestrianUE);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(vehicleUE);
+		v(pedestrianUE);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		vehicleUE.clear();
+		pedestrianUE.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	vehicleUE_t	vehicleUE;
+	pedestrianUE_t	pedestrianUE;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+WT-UE-XwAP-ID ::= OCTET STRING (SIZE (3))
+*/
+
+struct WT_UE_XwAP_ID : asn::ostring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<3>>;
+	static constexpr const char* name() {return "WT-UE-XwAP-ID";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+WTID-Type1 ::= SEQUENCE {
+	pLMN-Identity					PLMN-Identity,
+	shortWTID						BIT STRING (SIZE(24)),
+	...
+}
+*/
+
+struct WTID_Type1 : asn::sequence<2, 0, true, 0>
+{
+	static constexpr const char* name() {return "WTID-Type1";}
+	using parent_t = asn::sequence<2, 0, true, 0>;
+	struct pLMN_Identity_t : PLMN_Identity
+	{
+		static constexpr const char* name() {return "pLMN_Identity_t";}
+		using parent_t = PLMN_Identity;
+
+	};
+	pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+	pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+	struct shortWTID_t : asn::bstring<>
+	{
+		using constraint_t = asn::constraints<false,asn::one<24>>;
+		static constexpr const char* name() {return "shortWTID_t";}
+		using parent_t = asn::bstring<>;
+
+	};
+
+	shortWTID_t& ref_shortWTID() {return shortWTID;}
+	shortWTID_t const& ref_shortWTID() const {return shortWTID;}
+	template<typename V> void decode(V& v)
+	{
+		v(pLMN_Identity);
+		v(shortWTID);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(pLMN_Identity);
+		v(shortWTID);
+
+	};
+	void clear()
+	{
+		pLMN_Identity.clear();
+		shortWTID.clear();
+
+	};
+	private:
+	pLMN_Identity_t	pLMN_Identity;
+	shortWTID_t	shortWTID;
+
+};
+/*
+WTID-Long-Type2 ::= BIT STRING (SIZE(48))
+*/
+
+struct WTID_Long_Type2 : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<48>>;
+	static constexpr const char* name() {return "WTID-Long-Type2";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+WTID ::= CHOICE {
+	wTID-Type1			WTID-Type1,
+	wTID-Type2			WTID-Long-Type2,
+	...
+}
+*/
+
+struct WTID : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "WTID";}
+	using parent_t = asn::choice<2, 0, true>;
+	index_type get_index() const {return index;}
+	bool is_unknown() const {return index == 3;}
+	void set_unknown() { set_index(3);  }
+	~WTID() {clear();}
+	struct wTID_Type1_t : WTID_Type1
+	{
+		static constexpr const char* name() {return "wTID_Type1_t";}
+		using parent_t = WTID_Type1;
+
+	};
+	struct wTID_Type2_t : WTID_Long_Type2
+	{
+		static constexpr const char* name() {return "wTID_Type2_t";}
+		using parent_t = WTID_Long_Type2;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<wTID_Type1_t>(); break;
+		case 2: var.destroy<wTID_Type2_t>(); break;
+		}
+		index = 0;
+		base::clear();
+	}
+	template<typename V> bool decode(size_t idx, V& v)
+	{
+		clear();
+		switch(idx)
+		{
+		case 1: set_index(1); return v(var.build<wTID_Type1_t>());
+		case 2: set_index(2); return v(var.build<wTID_Type2_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<wTID_Type1_t>());
+		case 2: return v(var.as<wTID_Type2_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<wTID_Type1_t>(1);
+		v.template operator()<wTID_Type2_t>(2);
+
+	}
+	wTID_Type1_t& select_wTID_Type1() { if(get_index() != 1) { clear(); set_index(1); return var.build<wTID_Type1_t>();} return var.as<wTID_Type1_t>();}
+	wTID_Type1_t const* get_wTID_Type1() const { if(get_index() == 1) { return &var.as<wTID_Type1_t>();} return nullptr; }
+	wTID_Type2_t& select_wTID_Type2() { if(get_index() != 2) { clear(); set_index(2); return var.build<wTID_Type2_t>();} return var.as<wTID_Type2_t>();}
+	wTID_Type2_t const* get_wTID_Type2() const { if(get_index() == 2) { return &var.as<wTID_Type2_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(wTID_Type1_t)];
+		char dummy2[sizeof(wTID_Type2_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+X2BenefitValue ::= INTEGER (1..8, ...)
+*/
+
+struct X2BenefitValue : asn::integer<>
+{
+	using constraint_t = asn::constraints<true,asn::span<1, 8>>;
+	static constexpr const char* name() {return "X2BenefitValue";}
+	using parent_t = asn::integer<>;
+
+};