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-PDU-Contents.hpp;fp=e2sim%2Fe2apv1sim%2Fe2sim%2Fsrc%2FASN1%2Fgenerated%2FX2AP-PDU-Contents.hpp;h=dd85f97af8c181c047b824b86a68552cb9686315;hp=0000000000000000000000000000000000000000;hb=3ebf932d23dcbec9ed19f4a51f9d00a0a54f5124;hpb=6896318f2b4ff01b4a88b16019c3dc93b0b693f5

diff --git a/e2sim/e2apv1sim/e2sim/src/ASN1/generated/X2AP-PDU-Contents.hpp b/e2sim/e2apv1sim/e2sim/src/ASN1/generated/X2AP-PDU-Contents.hpp
new file mode 100644
index 0000000..dd85f97
--- /dev/null
+++ b/e2sim/e2apv1sim/e2sim/src/ASN1/generated/X2AP-PDU-Contents.hpp
@@ -0,0 +1,68476 @@
+/*****************************************************************************
+# 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-IEs.hpp"
+#include "X2AP-Containers.hpp"
+#include "X2AP-Constants.hpp"
+
+/*
+ActivatedCellList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ActivatedCellList_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};
+
+	};
+
+};
+/*
+ActivatedCellList-Item::= SEQUENCE {
+	ecgi								ECGI,
+	iE-Extensions						ProtocolExtensionContainer { {ActivatedCellList-Item-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ActivatedCellList_Item : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "ActivatedCellList-Item";}
+	using parent_t = asn::sequence<2, 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 iE_Extensions_t : ProtocolExtensionContainer<ActivatedCellList_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ActivatedCellList_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(ecgi);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(ecgi);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		ecgi.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	ecgi_t	ecgi;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ActivatedCellList ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ActivatedCellList-Item
+*/
+
+struct ActivatedCellList_elm : ActivatedCellList_Item
+{
+	static constexpr const char* name() {return "ActivatedCellList_elm";}
+	using parent_t = ActivatedCellList_Item;
+
+};
+struct ActivatedCellList : asn::sequenceof<ActivatedCellList_elm>
+{
+	static constexpr const char* name() {return "ActivatedCellList";}
+	using parent_t = asn::sequenceof<ActivatedCellList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+ActivatedNRCellList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ActivatedNRCellList_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};
+
+	};
+
+};
+/*
+ActivatedNRCellList-Item::= SEQUENCE {
+	nrCellID						NRCGI,
+	iE-Extensions						ProtocolExtensionContainer { {ActivatedNRCellList-Item-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ActivatedNRCellList_Item : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "ActivatedNRCellList-Item";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct nrCellID_t : NRCGI
+	{
+		static constexpr const char* name() {return "nrCellID_t";}
+		using parent_t = NRCGI;
+
+	};
+	nrCellID_t& ref_nrCellID() {return nrCellID;}
+	nrCellID_t const& ref_nrCellID() const {return nrCellID;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ActivatedNRCellList_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ActivatedNRCellList_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(nrCellID);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(nrCellID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		nrCellID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	nrCellID_t	nrCellID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ActivatedNRCellList ::= SEQUENCE (SIZE (1.. maxCellinengNB)) OF ActivatedNRCellList-Item
+*/
+
+struct ActivatedNRCellList_elm : ActivatedNRCellList_Item
+{
+	static constexpr const char* name() {return "ActivatedNRCellList_elm";}
+	using parent_t = ActivatedNRCellList_Item;
+
+};
+struct ActivatedNRCellList : asn::sequenceof<ActivatedNRCellList_elm>
+{
+	static constexpr const char* name() {return "ActivatedNRCellList";}
+	using parent_t = asn::sequenceof<ActivatedNRCellList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellinengNB >>;
+
+};
+/*
+CellActivationFailure-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Cause						CRITICALITY ignore	TYPE Cause						PRESENCE mandatory }|
+	{ ID id-CriticalityDiagnostics		CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional },
+	...
+}
+*/
+
+struct CellActivationFailure_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(id_Cause); type=1;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
+		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_Cause)) { type = 1; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { 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_Cause);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(ignore); type=1;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
+		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 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		Cause& select_id_Cause() { return set<Cause>(1); }
+		Cause const* get_id_Cause() const { return get<Cause>(1); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Cause>(); break;
+			case 2: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Cause>(1);
+			v.template operator()<CriticalityDiagnostics>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Cause()); return true;
+			case 2: v(select_id_CriticalityDiagnostics()); 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<Cause>()); return true;
+			case 2: v(var.as<CriticalityDiagnostics>()); 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(CriticalityDiagnostics)];
+
+		};
+		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 == 3; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(mandatory); type=1;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=2;}
+		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 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(mandatory);} 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};
+
+	};
+
+};
+/*
+CellActivationFailure ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{CellActivationFailure-IEs}},
+	...
+}
+*/
+
+struct CellActivationFailure : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "CellActivationFailure";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<CellActivationFailure_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<CellActivationFailure_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ServedCellsToActivate-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ServedCellsToActivate_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};
+
+	};
+
+};
+/*
+ServedCellsToActivate-Item::= SEQUENCE {
+	ecgi						ECGI,
+	iE-Extensions					ProtocolExtensionContainer { {ServedCellsToActivate-Item-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ServedCellsToActivate_Item : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "ServedCellsToActivate-Item";}
+	using parent_t = asn::sequence<2, 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 iE_Extensions_t : ProtocolExtensionContainer<ServedCellsToActivate_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ServedCellsToActivate_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(ecgi);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(ecgi);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		ecgi.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	ecgi_t	ecgi;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ServedCellsToActivate::= SEQUENCE (SIZE (1..maxCellineNB)) OF ServedCellsToActivate-Item
+*/
+
+struct ServedCellsToActivate_elm : ServedCellsToActivate_Item
+{
+	static constexpr const char* name() {return "ServedCellsToActivate_elm";}
+	using parent_t = ServedCellsToActivate_Item;
+
+};
+struct ServedCellsToActivate : asn::sequenceof<ServedCellsToActivate_elm>
+{
+	static constexpr const char* name() {return "ServedCellsToActivate";}
+	using parent_t = asn::sequenceof<ServedCellsToActivate_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+CellActivationRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ServedCellsToActivate 	CRITICALITY reject	TYPE ServedCellsToActivate		PRESENCE mandatory},
+	...
+}
+*/
+
+struct CellActivationRequest_IEs
+{
+	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_ServedCellsToActivate() { set(id_ServedCellsToActivate); 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_ServedCellsToActivate)) { 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_ServedCellsToActivate);} 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_ServedCellsToActivate() { 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;}
+		ServedCellsToActivate& select_id_ServedCellsToActivate() { return set<ServedCellsToActivate>(1); }
+		ServedCellsToActivate const* get_id_ServedCellsToActivate() const { return get<ServedCellsToActivate>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ServedCellsToActivate>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ServedCellsToActivate>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ServedCellsToActivate()); 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<ServedCellsToActivate>()); 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(ServedCellsToActivate)];
+
+		};
+		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_ServedCellsToActivate() { 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};
+
+	};
+
+};
+/*
+CellActivationRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{CellActivationRequest-IEs}},
+	...
+}
+*/
+
+struct CellActivationRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "CellActivationRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<CellActivationRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<CellActivationRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+CellActivationResponse-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ActivatedCellList		CRITICALITY ignore	TYPE ActivatedCellList				PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics	CRITICALITY ignore	TYPE CriticalityDiagnostics			PRESENCE optional},
+	...
+}
+*/
+
+struct CellActivationResponse_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_ActivatedCellList() { set(id_ActivatedCellList); type=1;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
+		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_ActivatedCellList)) { type = 1; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { 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_ActivatedCellList);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_ActivatedCellList() { set(ignore); type=1;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
+		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 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		ActivatedCellList& select_id_ActivatedCellList() { return set<ActivatedCellList>(1); }
+		ActivatedCellList const* get_id_ActivatedCellList() const { return get<ActivatedCellList>(1); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ActivatedCellList>(); break;
+			case 2: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ActivatedCellList>(1);
+			v.template operator()<CriticalityDiagnostics>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ActivatedCellList()); return true;
+			case 2: v(select_id_CriticalityDiagnostics()); 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<ActivatedCellList>()); return true;
+			case 2: v(var.as<CriticalityDiagnostics>()); 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(ActivatedCellList)];
+			char dummy2[sizeof(CriticalityDiagnostics)];
+
+		};
+		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 == 3; }
+		void clear() {type = 0;}
+		void select_id_ActivatedCellList() { set(mandatory); type=1;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=2;}
+		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 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(mandatory);} 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};
+
+	};
+
+};
+/*
+CellActivationResponse ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{CellActivationResponse-IEs}},
+	...
+}
+*/
+
+struct CellActivationResponse : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "CellActivationResponse";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<CellActivationResponse_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<CellActivationResponse_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+Limited-list-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct Limited_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};
+
+	};
+
+};
+/*
+Limited-list 	::= SEQUENCE (SIZE (1..maxCellinengNB)) OF SEQUENCE {
+	nrCellID			NRCGI,
+		iE-Extensions						ProtocolExtensionContainer { {Limited-list-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct Limited_list_elm : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "Limited_list_elm";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct nrCellID_t : NRCGI
+	{
+		static constexpr const char* name() {return "nrCellID_t";}
+		using parent_t = NRCGI;
+
+	};
+	nrCellID_t& ref_nrCellID() {return nrCellID;}
+	nrCellID_t const& ref_nrCellID() const {return nrCellID;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<Limited_list_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<Limited_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(nrCellID);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(nrCellID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		nrCellID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	nrCellID_t	nrCellID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct Limited_list : asn::sequenceof<Limited_list_elm>
+{
+	static constexpr const char* name() {return "Limited-list";}
+	using parent_t = asn::sequenceof<Limited_list_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellinengNB >>;
+
+};
+/*
+CellAssistanceInformation ::= CHOICE {
+	limited-list				Limited-list,
+	full-list				ENUMERATED {allServedNRcells, ...},
+	...
+}
+*/
+
+struct CellAssistanceInformation : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "CellAssistanceInformation";}
+	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);  }
+	~CellAssistanceInformation() {clear();}
+	struct limited_list_t : Limited_list
+	{
+		static constexpr const char* name() {return "limited_list_t";}
+		using parent_t = Limited_list;
+
+	};
+	struct full_list_t : asn::enumerated<1, 0, true>
+	{
+		static constexpr const char* name() {return "full_list_t";}
+		using parent_t = asn::enumerated<1, 0, true>;
+		typedef enum {
+			allServedNRcells
+		} index_t;
+
+	};
+
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<limited_list_t>(); break;
+		case 2: var.destroy<full_list_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<limited_list_t>());
+		case 2: set_index(2); return v(var.build<full_list_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<limited_list_t>());
+		case 2: return v(var.as<full_list_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<limited_list_t>(1);
+		v.template operator()<full_list_t>(2);
+
+	}
+	limited_list_t& select_limited_list() { if(get_index() != 1) { clear(); set_index(1); return var.build<limited_list_t>();} return var.as<limited_list_t>();}
+	limited_list_t const* get_limited_list() const { if(get_index() == 1) { return &var.as<limited_list_t>();} return nullptr; }
+	full_list_t& select_full_list() { if(get_index() != 2) { clear(); set_index(2); return var.build<full_list_t>();} return var.as<full_list_t>();}
+	full_list_t const* get_full_list() const { if(get_index() == 2) { return &var.as<full_list_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(limited_list_t)];
+		char dummy2[sizeof(full_list_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+CellInformation-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+{ ID id-ABSInformation						CRITICALITY ignore	EXTENSION ABSInformation							PRESENCE optional }|
+{ ID id-InvokeIndication					CRITICALITY ignore	EXTENSION InvokeIndication							PRESENCE optional }|
+{ ID id-IntendedULDLConfiguration			CRITICALITY ignore	EXTENSION SubframeAssignment						PRESENCE optional }|
+{ ID id-ExtendedULInterferenceOverloadInfo	CRITICALITY ignore	EXTENSION ExtendedULInterferenceOverloadInfo	PRESENCE optional }|
+{ ID id-CoMPInformation						CRITICALITY ignore	EXTENSION CoMPInformation							PRESENCE optional }|
+{ ID id-DynamicDLTransmissionInformation	CRITICALITY ignore	EXTENSION DynamicDLTransmissionInformation		PRESENCE optional },
+	...
+}
+*/
+
+struct CellInformation_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 == 7; }
+		void clear() {type = 0;}
+		void select_id_ABSInformation() { set(id_ABSInformation); type=1;}
+		void select_id_InvokeIndication() { set(id_InvokeIndication); type=2;}
+		void select_id_IntendedULDLConfiguration() { set(id_IntendedULDLConfiguration); type=3;}
+		void select_id_ExtendedULInterferenceOverloadInfo() { set(id_ExtendedULInterferenceOverloadInfo); type=4;}
+		void select_id_CoMPInformation() { set(id_CoMPInformation); type=5;}
+		void select_id_DynamicDLTransmissionInformation() { set(id_DynamicDLTransmissionInformation); 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_ABSInformation)) { type = 1; return true; }
+			else if(equal(id_InvokeIndication)) { type = 2; return true; }
+			else if(equal(id_IntendedULDLConfiguration)) { type = 3; return true; }
+			else if(equal(id_ExtendedULInterferenceOverloadInfo)) { type = 4; return true; }
+			else if(equal(id_CoMPInformation)) { type = 5; return true; }
+			else if(equal(id_DynamicDLTransmissionInformation)) { 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_ABSInformation);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_InvokeIndication);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_IntendedULDLConfiguration);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_ExtendedULInterferenceOverloadInfo);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_CoMPInformation);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_DynamicDLTransmissionInformation);} 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_ABSInformation() { set(ignore); type=1;}
+		void select_id_InvokeIndication() { set(ignore); type=2;}
+		void select_id_IntendedULDLConfiguration() { set(ignore); type=3;}
+		void select_id_ExtendedULInterferenceOverloadInfo() { set(ignore); type=4;}
+		void select_id_CoMPInformation() { set(ignore); type=5;}
+		void select_id_DynamicDLTransmissionInformation() { 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(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 { 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		ABSInformation& select_id_ABSInformation() { return set<ABSInformation>(1); }
+		ABSInformation const* get_id_ABSInformation() const { return get<ABSInformation>(1); }
+		InvokeIndication& select_id_InvokeIndication() { return set<InvokeIndication>(2); }
+		InvokeIndication const* get_id_InvokeIndication() const { return get<InvokeIndication>(2); }
+		SubframeAssignment& select_id_IntendedULDLConfiguration() { return set<SubframeAssignment>(3); }
+		SubframeAssignment const* get_id_IntendedULDLConfiguration() const { return get<SubframeAssignment>(3); }
+		ExtendedULInterferenceOverloadInfo& select_id_ExtendedULInterferenceOverloadInfo() { return set<ExtendedULInterferenceOverloadInfo>(4); }
+		ExtendedULInterferenceOverloadInfo const* get_id_ExtendedULInterferenceOverloadInfo() const { return get<ExtendedULInterferenceOverloadInfo>(4); }
+		CoMPInformation& select_id_CoMPInformation() { return set<CoMPInformation>(5); }
+		CoMPInformation const* get_id_CoMPInformation() const { return get<CoMPInformation>(5); }
+		DynamicDLTransmissionInformation& select_id_DynamicDLTransmissionInformation() { return set<DynamicDLTransmissionInformation>(6); }
+		DynamicDLTransmissionInformation const* get_id_DynamicDLTransmissionInformation() const { return get<DynamicDLTransmissionInformation>(6); }
+		bool is_unknown() const { return type == 7; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ABSInformation>(); break;
+			case 2: var.destroy<InvokeIndication>(); break;
+			case 3: var.destroy<SubframeAssignment>(); break;
+			case 4: var.destroy<ExtendedULInterferenceOverloadInfo>(); break;
+			case 5: var.destroy<CoMPInformation>(); break;
+			case 6: var.destroy<DynamicDLTransmissionInformation>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ABSInformation>(1);
+			v.template operator()<InvokeIndication>(2);
+			v.template operator()<SubframeAssignment>(3);
+			v.template operator()<ExtendedULInterferenceOverloadInfo>(4);
+			v.template operator()<CoMPInformation>(5);
+			v.template operator()<DynamicDLTransmissionInformation>(6);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ABSInformation()); return true;
+			case 2: v(select_id_InvokeIndication()); return true;
+			case 3: v(select_id_IntendedULDLConfiguration()); return true;
+			case 4: v(select_id_ExtendedULInterferenceOverloadInfo()); return true;
+			case 5: v(select_id_CoMPInformation()); return true;
+			case 6: v(select_id_DynamicDLTransmissionInformation()); 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<ABSInformation>()); return true;
+			case 2: v(var.as<InvokeIndication>()); return true;
+			case 3: v(var.as<SubframeAssignment>()); return true;
+			case 4: v(var.as<ExtendedULInterferenceOverloadInfo>()); return true;
+			case 5: v(var.as<CoMPInformation>()); return true;
+			case 6: v(var.as<DynamicDLTransmissionInformation>()); 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(ABSInformation)];
+			char dummy2[sizeof(CoMPInformation)];
+			char dummy3[sizeof(DynamicDLTransmissionInformation)];
+			char dummy4[sizeof(ExtendedULInterferenceOverloadInfo)];
+			char dummy5[sizeof(InvokeIndication)];
+			char dummy6[sizeof(SubframeAssignment)];
+
+		};
+		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_ABSInformation() { set(optional); type=1;}
+		void select_id_InvokeIndication() { set(optional); type=2;}
+		void select_id_IntendedULDLConfiguration() { set(optional); type=3;}
+		void select_id_ExtendedULInterferenceOverloadInfo() { set(optional); type=4;}
+		void select_id_CoMPInformation() { set(optional); type=5;}
+		void select_id_DynamicDLTransmissionInformation() { 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};
+
+	};
+
+};
+/*
+CellInformation-Item ::= SEQUENCE {
+	cell-ID							ECGI,
+	ul-InterferenceOverloadIndication		UL-InterferenceOverloadIndication		OPTIONAL,
+	ul-HighInterferenceIndicationInfo		UL-HighInterferenceIndicationInfo		OPTIONAL,
+	relativeNarrowbandTxPower				RelativeNarrowbandTxPower				OPTIONAL,
+	iE-Extensions							ProtocolExtensionContainer { {CellInformation-Item-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct CellInformation_Item : asn::sequence<5, 0, true, 4>
+{
+	static constexpr const char* name() {return "CellInformation-Item";}
+	using parent_t = asn::sequence<5, 0, true, 4>;
+	struct cell_ID_t : ECGI
+	{
+		static constexpr const char* name() {return "cell_ID_t";}
+		using parent_t = ECGI;
+
+	};
+	cell_ID_t& ref_cell_ID() {return cell_ID;}
+	cell_ID_t const& ref_cell_ID() const {return cell_ID;}
+	struct ul_InterferenceOverloadIndication_t : UL_InterferenceOverloadIndication
+	{
+		static constexpr const char* name() {return "ul_InterferenceOverloadIndication_t";}
+		using parent_t = UL_InterferenceOverloadIndication;
+		static constexpr bool optional = true;
+
+	};
+	ul_InterferenceOverloadIndication_t& set_ul_InterferenceOverloadIndication() { ul_InterferenceOverloadIndication.setpresent(true); return ul_InterferenceOverloadIndication;}
+	ul_InterferenceOverloadIndication_t const* get_ul_InterferenceOverloadIndication() const {return ul_InterferenceOverloadIndication.is_valid() ? &ul_InterferenceOverloadIndication : nullptr;}
+	struct ul_HighInterferenceIndicationInfo_t : UL_HighInterferenceIndicationInfo
+	{
+		static constexpr const char* name() {return "ul_HighInterferenceIndicationInfo_t";}
+		using parent_t = UL_HighInterferenceIndicationInfo;
+		static constexpr bool optional = true;
+
+	};
+	ul_HighInterferenceIndicationInfo_t& set_ul_HighInterferenceIndicationInfo() { ul_HighInterferenceIndicationInfo.setpresent(true); return ul_HighInterferenceIndicationInfo;}
+	ul_HighInterferenceIndicationInfo_t const* get_ul_HighInterferenceIndicationInfo() const {return ul_HighInterferenceIndicationInfo.is_valid() ? &ul_HighInterferenceIndicationInfo : nullptr;}
+	struct relativeNarrowbandTxPower_t : RelativeNarrowbandTxPower
+	{
+		static constexpr const char* name() {return "relativeNarrowbandTxPower_t";}
+		using parent_t = RelativeNarrowbandTxPower;
+		static constexpr bool optional = true;
+
+	};
+	relativeNarrowbandTxPower_t& set_relativeNarrowbandTxPower() { relativeNarrowbandTxPower.setpresent(true); return relativeNarrowbandTxPower;}
+	relativeNarrowbandTxPower_t const* get_relativeNarrowbandTxPower() const {return relativeNarrowbandTxPower.is_valid() ? &relativeNarrowbandTxPower : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CellInformation_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CellInformation_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(cell_ID);
+		v(ul_InterferenceOverloadIndication);
+		v(ul_HighInterferenceIndicationInfo);
+		v(relativeNarrowbandTxPower);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(cell_ID);
+		v(ul_InterferenceOverloadIndication);
+		v(ul_HighInterferenceIndicationInfo);
+		v(relativeNarrowbandTxPower);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		cell_ID.clear();
+		ul_InterferenceOverloadIndication.clear();
+		ul_HighInterferenceIndicationInfo.clear();
+		relativeNarrowbandTxPower.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	cell_ID_t	cell_ID;
+	ul_InterferenceOverloadIndication_t	ul_InterferenceOverloadIndication;
+	ul_HighInterferenceIndicationInfo_t	ul_HighInterferenceIndicationInfo;
+	relativeNarrowbandTxPower_t	relativeNarrowbandTxPower;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+CellInformation-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-CellInformation-Item	CRITICALITY ignore	TYPE CellInformation-Item 	PRESENCE mandatory	}
+}
+*/
+
+struct CellInformation_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_CellInformation_Item() { set(id_CellInformation_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_CellInformation_Item)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_CellInformation_Item);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_CellInformation_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		CellInformation_Item& select_id_CellInformation_Item() { return set<CellInformation_Item>(1); }
+		CellInformation_Item const* get_id_CellInformation_Item() const { return get<CellInformation_Item>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<CellInformation_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<CellInformation_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_CellInformation_Item()); 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<CellInformation_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(CellInformation_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_CellInformation_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CellInformation-List ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {CellInformation-ItemIEs} }
+*/
+
+struct CellInformation_List_elm : ProtocolIE_Single_Container<CellInformation_ItemIEs>
+{
+	static constexpr const char* name() {return "CellInformation_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<CellInformation_ItemIEs>;
+
+};
+struct CellInformation_List : asn::sequenceof<CellInformation_List_elm>
+{
+	static constexpr const char* name() {return "CellInformation-List";}
+	using parent_t = asn::sequenceof<CellInformation_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+CellMeasurementResult-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-CompositeAvailableCapacityGroup	CRITICALITY ignore	EXTENSION CompositeAvailableCapacityGroup		PRESENCE optional}|
+	{ ID id-ABS-Status						CRITICALITY ignore	EXTENSION ABS-Status								PRESENCE optional}|
+	{ ID id-RSRPMRList						CRITICALITY ignore	EXTENSION RSRPMRList								PRESENCE optional}|
+	{ ID id-CSIReportList					CRITICALITY ignore	EXTENSION CSIReportList								PRESENCE optional}|
+	{ ID id-CellReportingIndicator			CRITICALITY ignore	EXTENSION CellReportingIndicator					PRESENCE optional},
+	...
+}
+*/
+
+struct CellMeasurementResult_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 == 6; }
+		void clear() {type = 0;}
+		void select_id_CompositeAvailableCapacityGroup() { set(id_CompositeAvailableCapacityGroup); type=1;}
+		void select_id_ABS_Status() { set(id_ABS_Status); type=2;}
+		void select_id_RSRPMRList() { set(id_RSRPMRList); type=3;}
+		void select_id_CSIReportList() { set(id_CSIReportList); type=4;}
+		void select_id_CellReportingIndicator() { set(id_CellReportingIndicator); type=5;}
+		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_CompositeAvailableCapacityGroup)) { type = 1; return true; }
+			else if(equal(id_ABS_Status)) { type = 2; return true; }
+			else if(equal(id_RSRPMRList)) { type = 3; return true; }
+			else if(equal(id_CSIReportList)) { type = 4; return true; }
+			else if(equal(id_CellReportingIndicator)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_CompositeAvailableCapacityGroup);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ABS_Status);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_RSRPMRList);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CSIReportList);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_CellReportingIndicator);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_CompositeAvailableCapacityGroup() { set(ignore); type=1;}
+		void select_id_ABS_Status() { set(ignore); type=2;}
+		void select_id_RSRPMRList() { set(ignore); type=3;}
+		void select_id_CSIReportList() { set(ignore); type=4;}
+		void select_id_CellReportingIndicator() { set(ignore); type=5;}
+		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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		CompositeAvailableCapacityGroup& select_id_CompositeAvailableCapacityGroup() { return set<CompositeAvailableCapacityGroup>(1); }
+		CompositeAvailableCapacityGroup const* get_id_CompositeAvailableCapacityGroup() const { return get<CompositeAvailableCapacityGroup>(1); }
+		ABS_Status& select_id_ABS_Status() { return set<ABS_Status>(2); }
+		ABS_Status const* get_id_ABS_Status() const { return get<ABS_Status>(2); }
+		RSRPMRList& select_id_RSRPMRList() { return set<RSRPMRList>(3); }
+		RSRPMRList const* get_id_RSRPMRList() const { return get<RSRPMRList>(3); }
+		CSIReportList& select_id_CSIReportList() { return set<CSIReportList>(4); }
+		CSIReportList const* get_id_CSIReportList() const { return get<CSIReportList>(4); }
+		CellReportingIndicator& select_id_CellReportingIndicator() { return set<CellReportingIndicator>(5); }
+		CellReportingIndicator const* get_id_CellReportingIndicator() const { return get<CellReportingIndicator>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<CompositeAvailableCapacityGroup>(); break;
+			case 2: var.destroy<ABS_Status>(); break;
+			case 3: var.destroy<RSRPMRList>(); break;
+			case 4: var.destroy<CSIReportList>(); break;
+			case 5: var.destroy<CellReportingIndicator>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<CompositeAvailableCapacityGroup>(1);
+			v.template operator()<ABS_Status>(2);
+			v.template operator()<RSRPMRList>(3);
+			v.template operator()<CSIReportList>(4);
+			v.template operator()<CellReportingIndicator>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_CompositeAvailableCapacityGroup()); return true;
+			case 2: v(select_id_ABS_Status()); return true;
+			case 3: v(select_id_RSRPMRList()); return true;
+			case 4: v(select_id_CSIReportList()); return true;
+			case 5: v(select_id_CellReportingIndicator()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<CompositeAvailableCapacityGroup>()); return true;
+			case 2: v(var.as<ABS_Status>()); return true;
+			case 3: v(var.as<RSRPMRList>()); return true;
+			case 4: v(var.as<CSIReportList>()); return true;
+			case 5: v(var.as<CellReportingIndicator>()); 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(ABS_Status)];
+			char dummy2[sizeof(CSIReportList)];
+			char dummy3[sizeof(CellReportingIndicator)];
+			char dummy4[sizeof(CompositeAvailableCapacityGroup)];
+			char dummy5[sizeof(RSRPMRList)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_CompositeAvailableCapacityGroup() { set(optional); type=1;}
+		void select_id_ABS_Status() { set(optional); type=2;}
+		void select_id_RSRPMRList() { set(optional); type=3;}
+		void select_id_CSIReportList() { set(optional); type=4;}
+		void select_id_CellReportingIndicator() { set(optional); type=5;}
+		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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CellMeasurementResult-Item ::= SEQUENCE {
+	cell-ID						ECGI,
+	hWLoadIndicator				HWLoadIndicator		OPTIONAL,
+	s1TNLLoadIndicator			S1TNLLoadIndicator	OPTIONAL,
+	radioResourceStatus			RadioResourceStatus	OPTIONAL,
+	iE-Extensions				ProtocolExtensionContainer { {CellMeasurementResult-Item-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct CellMeasurementResult_Item : asn::sequence<5, 0, true, 4>
+{
+	static constexpr const char* name() {return "CellMeasurementResult-Item";}
+	using parent_t = asn::sequence<5, 0, true, 4>;
+	struct cell_ID_t : ECGI
+	{
+		static constexpr const char* name() {return "cell_ID_t";}
+		using parent_t = ECGI;
+
+	};
+	cell_ID_t& ref_cell_ID() {return cell_ID;}
+	cell_ID_t const& ref_cell_ID() const {return cell_ID;}
+	struct hWLoadIndicator_t : HWLoadIndicator
+	{
+		static constexpr const char* name() {return "hWLoadIndicator_t";}
+		using parent_t = HWLoadIndicator;
+		static constexpr bool optional = true;
+
+	};
+	hWLoadIndicator_t& set_hWLoadIndicator() { hWLoadIndicator.setpresent(true); return hWLoadIndicator;}
+	hWLoadIndicator_t const* get_hWLoadIndicator() const {return hWLoadIndicator.is_valid() ? &hWLoadIndicator : nullptr;}
+	struct s1TNLLoadIndicator_t : S1TNLLoadIndicator
+	{
+		static constexpr const char* name() {return "s1TNLLoadIndicator_t";}
+		using parent_t = S1TNLLoadIndicator;
+		static constexpr bool optional = true;
+
+	};
+	s1TNLLoadIndicator_t& set_s1TNLLoadIndicator() { s1TNLLoadIndicator.setpresent(true); return s1TNLLoadIndicator;}
+	s1TNLLoadIndicator_t const* get_s1TNLLoadIndicator() const {return s1TNLLoadIndicator.is_valid() ? &s1TNLLoadIndicator : nullptr;}
+	struct radioResourceStatus_t : RadioResourceStatus
+	{
+		static constexpr const char* name() {return "radioResourceStatus_t";}
+		using parent_t = RadioResourceStatus;
+		static constexpr bool optional = true;
+
+	};
+	radioResourceStatus_t& set_radioResourceStatus() { radioResourceStatus.setpresent(true); return radioResourceStatus;}
+	radioResourceStatus_t const* get_radioResourceStatus() const {return radioResourceStatus.is_valid() ? &radioResourceStatus : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CellMeasurementResult_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CellMeasurementResult_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(cell_ID);
+		v(hWLoadIndicator);
+		v(s1TNLLoadIndicator);
+		v(radioResourceStatus);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(cell_ID);
+		v(hWLoadIndicator);
+		v(s1TNLLoadIndicator);
+		v(radioResourceStatus);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		cell_ID.clear();
+		hWLoadIndicator.clear();
+		s1TNLLoadIndicator.clear();
+		radioResourceStatus.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	cell_ID_t	cell_ID;
+	hWLoadIndicator_t	hWLoadIndicator;
+	s1TNLLoadIndicator_t	s1TNLLoadIndicator;
+	radioResourceStatus_t	radioResourceStatus;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+CellMeasurementResult-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-CellMeasurementResult-Item	CRITICALITY ignore	TYPE CellMeasurementResult-Item	PRESENCE mandatory}
+}
+*/
+
+struct CellMeasurementResult_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_CellMeasurementResult_Item() { set(id_CellMeasurementResult_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_CellMeasurementResult_Item)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_CellMeasurementResult_Item);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_CellMeasurementResult_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		CellMeasurementResult_Item& select_id_CellMeasurementResult_Item() { return set<CellMeasurementResult_Item>(1); }
+		CellMeasurementResult_Item const* get_id_CellMeasurementResult_Item() const { return get<CellMeasurementResult_Item>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<CellMeasurementResult_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<CellMeasurementResult_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_CellMeasurementResult_Item()); 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<CellMeasurementResult_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(CellMeasurementResult_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_CellMeasurementResult_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CellMeasurementResult-List ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {CellMeasurementResult-ItemIEs} }
+*/
+
+struct CellMeasurementResult_List_elm : ProtocolIE_Single_Container<CellMeasurementResult_ItemIEs>
+{
+	static constexpr const char* name() {return "CellMeasurementResult_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<CellMeasurementResult_ItemIEs>;
+
+};
+struct CellMeasurementResult_List : asn::sequenceof<CellMeasurementResult_List_elm>
+{
+	static constexpr const char* name() {return "CellMeasurementResult-List";}
+	using parent_t = asn::sequenceof<CellMeasurementResult_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+CellToReport-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CellToReport_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};
+
+	};
+
+};
+/*
+CellToReport-Item ::= SEQUENCE {
+	cell-ID									ECGI,
+	iE-Extensions							ProtocolExtensionContainer { {CellToReport-Item-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct CellToReport_Item : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "CellToReport-Item";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct cell_ID_t : ECGI
+	{
+		static constexpr const char* name() {return "cell_ID_t";}
+		using parent_t = ECGI;
+
+	};
+	cell_ID_t& ref_cell_ID() {return cell_ID;}
+	cell_ID_t const& ref_cell_ID() const {return cell_ID;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CellToReport_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CellToReport_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(cell_ID);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(cell_ID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		cell_ID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	cell_ID_t	cell_ID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+CellToReport-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-CellToReport-Item	CRITICALITY ignore	TYPE CellToReport-Item 	PRESENCE mandatory}
+}
+*/
+
+struct CellToReport_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_CellToReport_Item() { set(id_CellToReport_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_CellToReport_Item)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_CellToReport_Item);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_CellToReport_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		CellToReport_Item& select_id_CellToReport_Item() { return set<CellToReport_Item>(1); }
+		CellToReport_Item const* get_id_CellToReport_Item() const { return get<CellToReport_Item>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<CellToReport_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<CellToReport_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_CellToReport_Item()); 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<CellToReport_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(CellToReport_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_CellToReport_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CellToReport-List 		::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {CellToReport-ItemIEs} }
+*/
+
+struct CellToReport_List_elm : ProtocolIE_Single_Container<CellToReport_ItemIEs>
+{
+	static constexpr const char* name() {return "CellToReport_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<CellToReport_ItemIEs>;
+
+};
+struct CellToReport_List : asn::sequenceof<CellToReport_List_elm>
+{
+	static constexpr const char* name() {return "CellToReport-List";}
+	using parent_t = asn::sequenceof<CellToReport_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+MeasurementFailureCause-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct MeasurementFailureCause_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};
+
+	};
+
+};
+/*
+MeasurementFailureCause-Item ::= SEQUENCE {
+	measurementFailedReportCharacteristics			ReportCharacteristics,
+	cause											Cause,
+	iE-Extensions									ProtocolExtensionContainer { {MeasurementFailureCause-Item-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct MeasurementFailureCause_Item : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "MeasurementFailureCause-Item";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct measurementFailedReportCharacteristics_t : ReportCharacteristics
+	{
+		static constexpr const char* name() {return "measurementFailedReportCharacteristics_t";}
+		using parent_t = ReportCharacteristics;
+
+	};
+	measurementFailedReportCharacteristics_t& ref_measurementFailedReportCharacteristics() {return measurementFailedReportCharacteristics;}
+	measurementFailedReportCharacteristics_t const& ref_measurementFailedReportCharacteristics() const {return measurementFailedReportCharacteristics;}
+	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<MeasurementFailureCause_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<MeasurementFailureCause_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(measurementFailedReportCharacteristics);
+		v(cause);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(measurementFailedReportCharacteristics);
+		v(cause);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		measurementFailedReportCharacteristics.clear();
+		cause.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	measurementFailedReportCharacteristics_t	measurementFailedReportCharacteristics;
+	cause_t	cause;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+MeasurementFailureCause-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeasurementFailureCause-Item	CRITICALITY ignore	TYPE MeasurementFailureCause-Item		PRESENCE mandatory}
+}
+*/
+
+struct MeasurementFailureCause_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_MeasurementFailureCause_Item() { set(id_MeasurementFailureCause_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_MeasurementFailureCause_Item)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeasurementFailureCause_Item);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_MeasurementFailureCause_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		MeasurementFailureCause_Item& select_id_MeasurementFailureCause_Item() { return set<MeasurementFailureCause_Item>(1); }
+		MeasurementFailureCause_Item const* get_id_MeasurementFailureCause_Item() const { return get<MeasurementFailureCause_Item>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<MeasurementFailureCause_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<MeasurementFailureCause_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeasurementFailureCause_Item()); 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<MeasurementFailureCause_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(MeasurementFailureCause_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_MeasurementFailureCause_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+MeasurementFailureCause-List ::= SEQUENCE (SIZE (1..maxFailedMeasObjects)) OF ProtocolIE-Single-Container { {MeasurementFailureCause-ItemIEs} }
+*/
+
+struct MeasurementFailureCause_List_elm : ProtocolIE_Single_Container<MeasurementFailureCause_ItemIEs>
+{
+	static constexpr const char* name() {return "MeasurementFailureCause_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<MeasurementFailureCause_ItemIEs>;
+
+};
+struct MeasurementFailureCause_List : asn::sequenceof<MeasurementFailureCause_List_elm>
+{
+	static constexpr const char* name() {return "MeasurementFailureCause-List";}
+	using parent_t = asn::sequenceof<MeasurementFailureCause_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxFailedMeasObjects >>;
+
+};
+/*
+CompleteFailureCauseInformation-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct CompleteFailureCauseInformation_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};
+
+	};
+
+};
+/*
+CompleteFailureCauseInformation-Item ::= SEQUENCE {
+	cell-ID											ECGI,
+	measurementFailureCause-List					MeasurementFailureCause-List,
+	iE-Extensions									ProtocolExtensionContainer { {CompleteFailureCauseInformation-Item-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct CompleteFailureCauseInformation_Item : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "CompleteFailureCauseInformation-Item";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct cell_ID_t : ECGI
+	{
+		static constexpr const char* name() {return "cell_ID_t";}
+		using parent_t = ECGI;
+
+	};
+	cell_ID_t& ref_cell_ID() {return cell_ID;}
+	cell_ID_t const& ref_cell_ID() const {return cell_ID;}
+	struct measurementFailureCause_List_t : MeasurementFailureCause_List
+	{
+		static constexpr const char* name() {return "measurementFailureCause_List_t";}
+		using parent_t = MeasurementFailureCause_List;
+
+	};
+	measurementFailureCause_List_t& ref_measurementFailureCause_List() {return measurementFailureCause_List;}
+	measurementFailureCause_List_t const& ref_measurementFailureCause_List() const {return measurementFailureCause_List;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<CompleteFailureCauseInformation_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<CompleteFailureCauseInformation_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(cell_ID);
+		v(measurementFailureCause_List);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(cell_ID);
+		v(measurementFailureCause_List);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		cell_ID.clear();
+		measurementFailureCause_List.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	cell_ID_t	cell_ID;
+	measurementFailureCause_List_t	measurementFailureCause_List;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+CompleteFailureCauseInformation-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-CompleteFailureCauseInformation-Item	CRITICALITY ignore	TYPE CompleteFailureCauseInformation-Item	PRESENCE mandatory}
+}
+*/
+
+struct CompleteFailureCauseInformation_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_CompleteFailureCauseInformation_Item() { set(id_CompleteFailureCauseInformation_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_CompleteFailureCauseInformation_Item)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_CompleteFailureCauseInformation_Item);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_CompleteFailureCauseInformation_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		CompleteFailureCauseInformation_Item& select_id_CompleteFailureCauseInformation_Item() { return set<CompleteFailureCauseInformation_Item>(1); }
+		CompleteFailureCauseInformation_Item const* get_id_CompleteFailureCauseInformation_Item() const { return get<CompleteFailureCauseInformation_Item>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<CompleteFailureCauseInformation_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<CompleteFailureCauseInformation_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_CompleteFailureCauseInformation_Item()); 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<CompleteFailureCauseInformation_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(CompleteFailureCauseInformation_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_CompleteFailureCauseInformation_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+CompleteFailureCauseInformation-List ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {CompleteFailureCauseInformation-ItemIEs} }
+*/
+
+struct CompleteFailureCauseInformation_List_elm : ProtocolIE_Single_Container<CompleteFailureCauseInformation_ItemIEs>
+{
+	static constexpr const char* name() {return "CompleteFailureCauseInformation_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<CompleteFailureCauseInformation_ItemIEs>;
+
+};
+struct CompleteFailureCauseInformation_List : asn::sequenceof<CompleteFailureCauseInformation_List_elm>
+{
+	static constexpr const char* name() {return "CompleteFailureCauseInformation-List";}
+	using parent_t = asn::sequenceof<CompleteFailureCauseInformation_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+E-RABs-DataForwardingAddress-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_DataForwardingAddress_ItemExtIEs
+{
+	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-RABs-DataForwardingAddress-Item ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	dl-GTPtunnelEndpoint			GTPtunnelEndpoint,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-DataForwardingAddress-ItemExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_DataForwardingAddress_Item : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-DataForwardingAddress-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 dl_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dl_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	dl_GTPtunnelEndpoint_t& ref_dl_GTPtunnelEndpoint() {return dl_GTPtunnelEndpoint;}
+	dl_GTPtunnelEndpoint_t const& ref_dl_GTPtunnelEndpoint() const {return dl_GTPtunnelEndpoint;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_DataForwardingAddress_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_DataForwardingAddress_ItemExtIEs>;
+		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(dl_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(dl_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		dl_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	dl_GTPtunnelEndpoint_t	dl_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-DataForwardingAddress-ItemIEs	X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-DataForwardingAddress-Item	CRITICALITY ignore	TYPE E-RABs-DataForwardingAddress-Item	PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_DataForwardingAddress_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_RABs_DataForwardingAddress_Item() { set(id_E_RABs_DataForwardingAddress_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_RABs_DataForwardingAddress_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_RABs_DataForwardingAddress_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_RABs_DataForwardingAddress_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_RABs_DataForwardingAddress_Item& select_id_E_RABs_DataForwardingAddress_Item() { return set<E_RABs_DataForwardingAddress_Item>(1); }
+		E_RABs_DataForwardingAddress_Item const* get_id_E_RABs_DataForwardingAddress_Item() const { return get<E_RABs_DataForwardingAddress_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_DataForwardingAddress_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_DataForwardingAddress_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_DataForwardingAddress_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_RABs_DataForwardingAddress_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_RABs_DataForwardingAddress_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_RABs_DataForwardingAddress_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-RABs-DataForwardingAddress-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-DataForwardingAddress-ItemIEs} }
+*/
+
+struct E_RABs_DataForwardingAddress_List_elm : ProtocolIE_Single_Container<E_RABs_DataForwardingAddress_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_DataForwardingAddress_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_DataForwardingAddress_ItemIEs>;
+
+};
+struct E_RABs_DataForwardingAddress_List : asn::sequenceof<E_RABs_DataForwardingAddress_List_elm>
+{
+	static constexpr const char* name() {return "E-RABs-DataForwardingAddress-List";}
+	using parent_t = asn::sequenceof<E_RABs_DataForwardingAddress_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+DataForwardingAddressIndication-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-New-eNB-UE-X2AP-ID-Extension		CRITICALITY ignore	TYPE UE-X2AP-ID-Extension						PRESENCE optional }|
+	{ ID id-Old-eNB-UE-X2AP-ID					CRITICALITY ignore	TYPE UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-Old-eNB-UE-X2AP-ID-Extension		CRITICALITY ignore	TYPE UE-X2AP-ID-Extension						PRESENCE optional }|
+	{ ID id-E-RABs-DataForwardingAddress-List	CRITICALITY ignore	TYPE E-RABs-DataForwardingAddress-List		PRESENCE mandatory},
+	...
+}
+*/
+
+struct DataForwardingAddressIndication_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=1;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=2;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=3;}
+		void select_id_E_RABs_DataForwardingAddress_List() { set(id_E_RABs_DataForwardingAddress_List); type=4;}
+		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_New_eNB_UE_X2AP_ID_Extension)) { type = 1; return true; }
+			else if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 3; return true; }
+			else if(equal(id_E_RABs_DataForwardingAddress_List)) { 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_New_eNB_UE_X2AP_ID_Extension);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_DataForwardingAddress_List);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=1;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=3;}
+		void select_id_E_RABs_DataForwardingAddress_List() { set(ignore); type=4;}
+		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 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(1); }
+		UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(1); }
+		UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(3); }
+		UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(3); }
+		E_RABs_DataForwardingAddress_List& select_id_E_RABs_DataForwardingAddress_List() { return set<E_RABs_DataForwardingAddress_List>(4); }
+		E_RABs_DataForwardingAddress_List const* get_id_E_RABs_DataForwardingAddress_List() const { return get<E_RABs_DataForwardingAddress_List>(4); }
+		bool is_unknown() const { return type == 5; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 4: var.destroy<E_RABs_DataForwardingAddress_List>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID_Extension>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<UE_X2AP_ID_Extension>(3);
+			v.template operator()<E_RABs_DataForwardingAddress_List>(4);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
+			case 2: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
+			case 4: v(select_id_E_RABs_DataForwardingAddress_List()); 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<UE_X2AP_ID_Extension>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 4: v(var.as<E_RABs_DataForwardingAddress_List>()); 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_RABs_DataForwardingAddress_List)];
+			char dummy2[sizeof(UE_X2AP_ID)];
+			char dummy3[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 5; }
+		void clear() {type = 0;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=1;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=3;}
+		void select_id_E_RABs_DataForwardingAddress_List() { set(mandatory); type=4;}
+		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(optional)) { type = 1; return true; }
+			else if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(optional)) { type = 3; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} 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(mandatory);} 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};
+
+	};
+
+};
+/*
+DataForwardingAddressIndication ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{DataForwardingAddressIndication-IEs}},
+	...
+}
+*/
+
+struct DataForwardingAddressIndication : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "DataForwardingAddressIndication";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<DataForwardingAddressIndication_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<DataForwardingAddressIndication_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+E-RABs-Admitted-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_Admitted_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-RABs-Admitted-Item ::= SEQUENCE {
+	e-RAB-ID					E-RAB-ID,
+	uL-GTP-TunnelEndpoint			GTPtunnelEndpoint	OPTIONAL,
+	dL-GTP-TunnelEndpoint			GTPtunnelEndpoint	OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-Admitted-Item-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_Item : asn::sequence<4, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-Item";}
+	using parent_t = asn::sequence<4, 0, true, 3>;
+	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 uL_GTP_TunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "uL_GTP_TunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	uL_GTP_TunnelEndpoint_t& set_uL_GTP_TunnelEndpoint() { uL_GTP_TunnelEndpoint.setpresent(true); return uL_GTP_TunnelEndpoint;}
+	uL_GTP_TunnelEndpoint_t const* get_uL_GTP_TunnelEndpoint() const {return uL_GTP_TunnelEndpoint.is_valid() ? &uL_GTP_TunnelEndpoint : nullptr;}
+	struct dL_GTP_TunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_GTP_TunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_GTP_TunnelEndpoint_t& set_dL_GTP_TunnelEndpoint() { dL_GTP_TunnelEndpoint.setpresent(true); return dL_GTP_TunnelEndpoint;}
+	dL_GTP_TunnelEndpoint_t const* get_dL_GTP_TunnelEndpoint() const {return dL_GTP_TunnelEndpoint.is_valid() ? &dL_GTP_TunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_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(uL_GTP_TunnelEndpoint);
+		v(dL_GTP_TunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(uL_GTP_TunnelEndpoint);
+		v(dL_GTP_TunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		uL_GTP_TunnelEndpoint.clear();
+		dL_GTP_TunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	uL_GTP_TunnelEndpoint_t	uL_GTP_TunnelEndpoint;
+	dL_GTP_TunnelEndpoint_t	dL_GTP_TunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-Admitted-Item	CRITICALITY ignore	TYPE E-RABs-Admitted-Item 	PRESENCE mandatory	}
+}
+*/
+
+struct E_RABs_Admitted_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_Item() { set(id_E_RABs_Admitted_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_RABs_Admitted_Item)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_RABs_Admitted_Item);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		E_RABs_Admitted_Item& select_id_E_RABs_Admitted_Item() { return set<E_RABs_Admitted_Item>(1); }
+		E_RABs_Admitted_Item const* get_id_E_RABs_Admitted_Item() const { return get<E_RABs_Admitted_Item>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_Admitted_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_Admitted_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_Admitted_Item()); 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_RABs_Admitted_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_RABs_Admitted_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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-RABs-Admitted-List 		::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ItemIEs} }
+*/
+
+struct E_RABs_Admitted_List_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_Admitted_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ItemIEs>;
+
+};
+struct E_RABs_Admitted_List : asn::sequenceof<E_RABs_Admitted_List_elm>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-List";}
+	using parent_t = asn::sequenceof<E_RABs_Admitted_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-Item-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_Item_SCG_BearerExtIEs
+{
+	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-RABs-Admitted-ToBeAdded-Item-SCG-Bearer ::= SEQUENCE {
+	e-RAB-ID								E-RAB-ID,
+	s1-DL-GTPtunnelEndpoint					GTPtunnelEndpoint,
+	dL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint																	OPTIONAL,
+	uL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint																	OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-Item-SCG-BearerExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_Item_SCG_Bearer : asn::sequence<5, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-Item-SCG-Bearer";}
+	using parent_t = asn::sequence<5, 0, true, 3>;
+	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 s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	s1_DL_GTPtunnelEndpoint_t& ref_s1_DL_GTPtunnelEndpoint() {return s1_DL_GTPtunnelEndpoint;}
+	s1_DL_GTPtunnelEndpoint_t const& ref_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint;}
+	struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
+	dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
+	uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_Item_SCG_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_Item_SCG_BearerExtIEs>;
+		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(s1_DL_GTPtunnelEndpoint);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(uL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(s1_DL_GTPtunnelEndpoint);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(uL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		s1_DL_GTPtunnelEndpoint.clear();
+		dL_Forwarding_GTPtunnelEndpoint.clear();
+		uL_Forwarding_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	s1_DL_GTPtunnelEndpoint_t	s1_DL_GTPtunnelEndpoint;
+	dL_Forwarding_GTPtunnelEndpoint_t	dL_Forwarding_GTPtunnelEndpoint;
+	uL_Forwarding_GTPtunnelEndpoint_t	uL_Forwarding_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-Item-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_Item_Split_BearerExtIEs
+{
+	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-RABs-Admitted-ToBeAdded-Item-Split-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	seNB-GTPtunnelEndpoint			GTPtunnelEndpoint,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-Item-Split-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_Item_Split_Bearer : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-Item-Split-Bearer";}
+	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 seNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "seNB_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	seNB_GTPtunnelEndpoint_t& ref_seNB_GTPtunnelEndpoint() {return seNB_GTPtunnelEndpoint;}
+	seNB_GTPtunnelEndpoint_t const& ref_seNB_GTPtunnelEndpoint() const {return seNB_GTPtunnelEndpoint;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_Item_Split_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_Item_Split_BearerExtIEs>;
+		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(seNB_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(seNB_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		seNB_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	seNB_GTPtunnelEndpoint_t	seNB_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-Item ::= CHOICE {
+	sCG-Bearer		E-RABs-Admitted-ToBeAdded-Item-SCG-Bearer,
+	split-Bearer	E-RABs-Admitted-ToBeAdded-Item-Split-Bearer,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_Item : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-Item";}
+	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);  }
+	~E_RABs_Admitted_ToBeAdded_Item() {clear();}
+	struct sCG_Bearer_t : E_RABs_Admitted_ToBeAdded_Item_SCG_Bearer
+	{
+		static constexpr const char* name() {return "sCG_Bearer_t";}
+		using parent_t = E_RABs_Admitted_ToBeAdded_Item_SCG_Bearer;
+
+	};
+	struct split_Bearer_t : E_RABs_Admitted_ToBeAdded_Item_Split_Bearer
+	{
+		static constexpr const char* name() {return "split_Bearer_t";}
+		using parent_t = E_RABs_Admitted_ToBeAdded_Item_Split_Bearer;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<sCG_Bearer_t>(); break;
+		case 2: var.destroy<split_Bearer_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<sCG_Bearer_t>());
+		case 2: set_index(2); return v(var.build<split_Bearer_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<sCG_Bearer_t>());
+		case 2: return v(var.as<split_Bearer_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<sCG_Bearer_t>(1);
+		v.template operator()<split_Bearer_t>(2);
+
+	}
+	sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
+	sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
+	split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
+	split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(sCG_Bearer_t)];
+		char dummy2[sizeof(split_Bearer_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+E-RABs-Admitted-ToBeAdded-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-Admitted-ToBeAdded-Item	CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeAdded-Item 		PRESENCE mandatory}
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeAdded_Item() { set(id_E_RABs_Admitted_ToBeAdded_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_RABs_Admitted_ToBeAdded_Item)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_RABs_Admitted_ToBeAdded_Item);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeAdded_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		E_RABs_Admitted_ToBeAdded_Item& select_id_E_RABs_Admitted_ToBeAdded_Item() { return set<E_RABs_Admitted_ToBeAdded_Item>(1); }
+		E_RABs_Admitted_ToBeAdded_Item const* get_id_E_RABs_Admitted_ToBeAdded_Item() const { return get<E_RABs_Admitted_ToBeAdded_Item>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_Admitted_ToBeAdded_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_Admitted_ToBeAdded_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_Admitted_ToBeAdded_Item()); 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_RABs_Admitted_ToBeAdded_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_RABs_Admitted_ToBeAdded_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeAdded_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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-RABs-Admitted-ToBeAdded-List ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeAdded-ItemIEs} }
+*/
+
+struct E_RABs_Admitted_ToBeAdded_List_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_Admitted_ToBeAdded_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_ItemIEs>;
+
+};
+struct E_RABs_Admitted_ToBeAdded_List : asn::sequenceof<E_RABs_Admitted_ToBeAdded_List_elm>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-List";}
+	using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeAdded_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_BearerExtIEs
+{
+	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-RABs-Admitted-ToBeAdded-ModAckItem-SCG-Bearer ::= SEQUENCE {
+	e-RAB-ID								E-RAB-ID,
+	s1-DL-GTPtunnelEndpoint					GTPtunnelEndpoint,
+	dL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint																	OPTIONAL,
+	uL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint																	OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-BearerExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_Bearer : asn::sequence<5, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-Bearer";}
+	using parent_t = asn::sequence<5, 0, true, 3>;
+	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 s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	s1_DL_GTPtunnelEndpoint_t& ref_s1_DL_GTPtunnelEndpoint() {return s1_DL_GTPtunnelEndpoint;}
+	s1_DL_GTPtunnelEndpoint_t const& ref_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint;}
+	struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
+	dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
+	uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_BearerExtIEs>;
+		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(s1_DL_GTPtunnelEndpoint);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(uL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(s1_DL_GTPtunnelEndpoint);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(uL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		s1_DL_GTPtunnelEndpoint.clear();
+		dL_Forwarding_GTPtunnelEndpoint.clear();
+		uL_Forwarding_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	s1_DL_GTPtunnelEndpoint_t	s1_DL_GTPtunnelEndpoint;
+	dL_Forwarding_GTPtunnelEndpoint_t	dL_Forwarding_GTPtunnelEndpoint;
+	uL_Forwarding_GTPtunnelEndpoint_t	uL_Forwarding_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-ModAckItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_ModAckItem_Split_BearerExtIEs
+{
+	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-RABs-Admitted-ToBeAdded-ModAckItem-Split-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	seNB-GTPtunnelEndpoint			GTPtunnelEndpoint,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-ModAckItem-Split-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_ModAckItem_Split_Bearer : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-ModAckItem-Split-Bearer";}
+	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 seNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "seNB_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	seNB_GTPtunnelEndpoint_t& ref_seNB_GTPtunnelEndpoint() {return seNB_GTPtunnelEndpoint;}
+	seNB_GTPtunnelEndpoint_t const& ref_seNB_GTPtunnelEndpoint() const {return seNB_GTPtunnelEndpoint;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_ModAckItem_Split_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_ModAckItem_Split_BearerExtIEs>;
+		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(seNB_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(seNB_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		seNB_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	seNB_GTPtunnelEndpoint_t	seNB_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-ModAckItem ::= CHOICE {
+	sCG-Bearer		E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-Bearer,
+	split-Bearer	E-RABs-Admitted-ToBeAdded-ModAckItem-Split-Bearer,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_ModAckItem : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-ModAckItem";}
+	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);  }
+	~E_RABs_Admitted_ToBeAdded_ModAckItem() {clear();}
+	struct sCG_Bearer_t : E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_Bearer
+	{
+		static constexpr const char* name() {return "sCG_Bearer_t";}
+		using parent_t = E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_Bearer;
+
+	};
+	struct split_Bearer_t : E_RABs_Admitted_ToBeAdded_ModAckItem_Split_Bearer
+	{
+		static constexpr const char* name() {return "split_Bearer_t";}
+		using parent_t = E_RABs_Admitted_ToBeAdded_ModAckItem_Split_Bearer;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<sCG_Bearer_t>(); break;
+		case 2: var.destroy<split_Bearer_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<sCG_Bearer_t>());
+		case 2: set_index(2); return v(var.build<split_Bearer_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<sCG_Bearer_t>());
+		case 2: return v(var.as<split_Bearer_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<sCG_Bearer_t>(1);
+		v.template operator()<split_Bearer_t>(2);
+
+	}
+	sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
+	sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
+	split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
+	split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(sCG_Bearer_t)];
+		char dummy2[sizeof(split_Bearer_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+E-RABs-Admitted-ToBeAdded-ModAckItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-Admitted-ToBeAdded-ModAckItem	CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeAdded-ModAckItem		PRESENCE mandatory}
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_ModAckItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeAdded_ModAckItem() { set(id_E_RABs_Admitted_ToBeAdded_ModAckItem); 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_RABs_Admitted_ToBeAdded_ModAckItem)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_RABs_Admitted_ToBeAdded_ModAckItem);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeAdded_ModAckItem() { 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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		E_RABs_Admitted_ToBeAdded_ModAckItem& select_id_E_RABs_Admitted_ToBeAdded_ModAckItem() { return set<E_RABs_Admitted_ToBeAdded_ModAckItem>(1); }
+		E_RABs_Admitted_ToBeAdded_ModAckItem const* get_id_E_RABs_Admitted_ToBeAdded_ModAckItem() const { return get<E_RABs_Admitted_ToBeAdded_ModAckItem>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_Admitted_ToBeAdded_ModAckItem>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_Admitted_ToBeAdded_ModAckItem>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_Admitted_ToBeAdded_ModAckItem()); 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_RABs_Admitted_ToBeAdded_ModAckItem>()); 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_RABs_Admitted_ToBeAdded_ModAckItem)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeAdded_ModAckItem() { 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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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-RABs-Admitted-ToBeAdded-ModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeAdded-ModAckItemIEs} }
+*/
+
+struct E_RABs_Admitted_ToBeAdded_ModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_ModAckItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_Admitted_ToBeAdded_ModAckList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_ModAckItemIEs>;
+
+};
+struct E_RABs_Admitted_ToBeAdded_ModAckList : asn::sequenceof<E_RABs_Admitted_ToBeAdded_ModAckList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-ModAckList";}
+	using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeAdded_ModAckList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-uLpDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional}|
+	{ ID id-dLPDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresentExtIEs
+{
+	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_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
+		void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); 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_uLpDCPSnLength)) { type = 1; return true; }
+			else if(equal(id_dLPDCPSnLength)) { 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_uLpDCPSnLength);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} 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_uLpDCPSnLength() { set(ignore); type=1;}
+		void select_id_dLPDCPSnLength() { 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;}
+		PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
+		PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
+		PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
+		PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<PDCPSnLength>(); break;
+			case 2: var.destroy<PDCPSnLength>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<PDCPSnLength>(1);
+			v.template operator()<PDCPSnLength>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_uLpDCPSnLength()); return true;
+			case 2: v(select_id_dLPDCPSnLength()); 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<PDCPSnLength>()); return true;
+			case 2: v(var.as<PDCPSnLength>()); 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(PDCPSnLength)];
+
+		};
+		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_uLpDCPSnLength() { set(optional); type=1;}
+		void select_id_dLPDCPSnLength() { 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-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresent ::= SEQUENCE {
+	s1-DL-GTPtunnelEndpoint					GTPtunnelEndpoint,
+	sgNB-UL-GTP-TEIDatPDCP					GTPtunnelEndpoint																						OPTIONAL,
+-- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE is set to “present” --
+	rlc-Mode								RLCMode																									OPTIONAL,
+-- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE is set to “present” --
+	dL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint																						OPTIONAL,
+	uL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint																						OPTIONAL,
+	mCG-E-RAB-Level-QoS-Parameters			E-RAB-Level-QoS-Parameters																				OPTIONAL,
+-- This IE shall be present if MCG resource and SCG resource IEs in the the EN-DC Resource Configuration IE are set to “present” and the GBR QoS Information IE is present in the Requested MCG E-RAB Level QoS Parameters IE --
+	uL-Configuration							ULConfiguration																							OPTIONAL,
+-- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” --
+	iE-Extensions							ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresentExtIEs} }			OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent : asn::sequence<8, 0, true, 7>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresent";}
+	using parent_t = asn::sequence<8, 0, true, 7>;
+	struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	s1_DL_GTPtunnelEndpoint_t& ref_s1_DL_GTPtunnelEndpoint() {return s1_DL_GTPtunnelEndpoint;}
+	s1_DL_GTPtunnelEndpoint_t const& ref_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint;}
+	struct sgNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "sgNB_UL_GTP_TEIDatPDCP_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	sgNB_UL_GTP_TEIDatPDCP_t& set_sgNB_UL_GTP_TEIDatPDCP() { sgNB_UL_GTP_TEIDatPDCP.setpresent(true); return sgNB_UL_GTP_TEIDatPDCP;}
+	sgNB_UL_GTP_TEIDatPDCP_t const* get_sgNB_UL_GTP_TEIDatPDCP() const {return sgNB_UL_GTP_TEIDatPDCP.is_valid() ? &sgNB_UL_GTP_TEIDatPDCP : nullptr;}
+	struct rlc_Mode_t : RLCMode
+	{
+		static constexpr const char* name() {return "rlc_Mode_t";}
+		using parent_t = RLCMode;
+		static constexpr bool optional = true;
+
+	};
+	rlc_Mode_t& set_rlc_Mode() { rlc_Mode.setpresent(true); return rlc_Mode;}
+	rlc_Mode_t const* get_rlc_Mode() const {return rlc_Mode.is_valid() ? &rlc_Mode : nullptr;}
+	struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
+	dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
+	uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct mCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "mCG_E_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+		static constexpr bool optional = true;
+
+	};
+	mCG_E_RAB_Level_QoS_Parameters_t& set_mCG_E_RAB_Level_QoS_Parameters() { mCG_E_RAB_Level_QoS_Parameters.setpresent(true); return mCG_E_RAB_Level_QoS_Parameters;}
+	mCG_E_RAB_Level_QoS_Parameters_t const* get_mCG_E_RAB_Level_QoS_Parameters() const {return mCG_E_RAB_Level_QoS_Parameters.is_valid() ? &mCG_E_RAB_Level_QoS_Parameters : nullptr;}
+	struct uL_Configuration_t : ULConfiguration
+	{
+		static constexpr const char* name() {return "uL_Configuration_t";}
+		using parent_t = ULConfiguration;
+		static constexpr bool optional = true;
+
+	};
+	uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
+	uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresentExtIEs>;
+		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(s1_DL_GTPtunnelEndpoint);
+		v(sgNB_UL_GTP_TEIDatPDCP);
+		v(rlc_Mode);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(uL_Forwarding_GTPtunnelEndpoint);
+		v(mCG_E_RAB_Level_QoS_Parameters);
+		v(uL_Configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(s1_DL_GTPtunnelEndpoint);
+		v(sgNB_UL_GTP_TEIDatPDCP);
+		v(rlc_Mode);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(uL_Forwarding_GTPtunnelEndpoint);
+		v(mCG_E_RAB_Level_QoS_Parameters);
+		v(uL_Configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		s1_DL_GTPtunnelEndpoint.clear();
+		sgNB_UL_GTP_TEIDatPDCP.clear();
+		rlc_Mode.clear();
+		dL_Forwarding_GTPtunnelEndpoint.clear();
+		uL_Forwarding_GTPtunnelEndpoint.clear();
+		mCG_E_RAB_Level_QoS_Parameters.clear();
+		uL_Configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	s1_DL_GTPtunnelEndpoint_t	s1_DL_GTPtunnelEndpoint;
+	sgNB_UL_GTP_TEIDatPDCP_t	sgNB_UL_GTP_TEIDatPDCP;
+	rlc_Mode_t	rlc_Mode;
+	dL_Forwarding_GTPtunnelEndpoint_t	dL_Forwarding_GTPtunnelEndpoint;
+	uL_Forwarding_GTPtunnelEndpoint_t	uL_Forwarding_GTPtunnelEndpoint;
+	mCG_E_RAB_Level_QoS_Parameters_t	mCG_E_RAB_Level_QoS_Parameters;
+	uL_Configuration_t	uL_Configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-lCID				CRITICALITY ignore	EXTENSION LCID			PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresentExtIEs
+{
+	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_lCID() { set(id_lCID); 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_lCID)) { 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_lCID);} 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_lCID() { 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;}
+		LCID& select_id_lCID() { return set<LCID>(1); }
+		LCID const* get_id_lCID() const { return get<LCID>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<LCID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<LCID>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_lCID()); 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<LCID>()); 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(LCID)];
+
+		};
+		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_lCID() { 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};
+
+	};
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresent ::= SEQUENCE {
+	sgNB-DL-GTP-TEIDatSCG				GTPtunnelEndpoint,
+	secondary-sgNB-DL-GTP-TEIDatSCG		GTPtunnelEndpoint		OPTIONAL,
+	iE-Extensions						ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresentExtIEs} } 		OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresent";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	struct sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "sgNB_DL_GTP_TEIDatSCG_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	sgNB_DL_GTP_TEIDatSCG_t& ref_sgNB_DL_GTP_TEIDatSCG() {return sgNB_DL_GTP_TEIDatSCG;}
+	sgNB_DL_GTP_TEIDatSCG_t const& ref_sgNB_DL_GTP_TEIDatSCG() const {return sgNB_DL_GTP_TEIDatSCG;}
+	struct secondary_sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "secondary_sgNB_DL_GTP_TEIDatSCG_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	secondary_sgNB_DL_GTP_TEIDatSCG_t& set_secondary_sgNB_DL_GTP_TEIDatSCG() { secondary_sgNB_DL_GTP_TEIDatSCG.setpresent(true); return secondary_sgNB_DL_GTP_TEIDatSCG;}
+	secondary_sgNB_DL_GTP_TEIDatSCG_t const* get_secondary_sgNB_DL_GTP_TEIDatSCG() const {return secondary_sgNB_DL_GTP_TEIDatSCG.is_valid() ? &secondary_sgNB_DL_GTP_TEIDatSCG : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresentExtIEs>;
+		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(sgNB_DL_GTP_TEIDatSCG);
+		v(secondary_sgNB_DL_GTP_TEIDatSCG);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(sgNB_DL_GTP_TEIDatSCG);
+		v(secondary_sgNB_DL_GTP_TEIDatSCG);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		sgNB_DL_GTP_TEIDatSCG.clear();
+		secondary_sgNB_DL_GTP_TEIDatSCG.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	sgNB_DL_GTP_TEIDatSCG_t	sgNB_DL_GTP_TEIDatSCG;
+	secondary_sgNB_DL_GTP_TEIDatSCG_t	secondary_sgNB_DL_GTP_TEIDatSCG;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeAdded-SgNBAddReqAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBAddReqAck_ItemExtIEs
+{
+	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-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item ::= SEQUENCE {
+	e-RAB-ID								E-RAB-ID,
+	en-DC-ResourceConfiguration			EN-DC-ResourceConfiguration,
+	resource-configuration				CHOICE {
+		sgNBPDCPpresent						E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresent,
+		sgNBPDCPnotpresent					E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresent,
+		...
+	},
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBAddReqAck-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-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 en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
+	{
+		static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
+		using parent_t = EN_DC_ResourceConfiguration;
+
+	};
+	en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
+	en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
+	struct resource_configuration_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "resource_configuration_t";}
+		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);  }
+		~resource_configuration_t() {clear();}
+		struct sgNBPDCPpresent_t : E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPpresent_t";}
+			using parent_t = E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent;
+
+		};
+		struct sgNBPDCPnotpresent_t : E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
+			using parent_t = E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent;
+
+		};
+		void clear()
+		{
+			switch(get_index())
+			{
+			case 1: var.destroy<sgNBPDCPpresent_t>(); break;
+			case 2: var.destroy<sgNBPDCPnotpresent_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<sgNBPDCPpresent_t>());
+			case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			switch(get_index())
+			{
+			case 1: return v(var.as<sgNBPDCPpresent_t>());
+			case 2: return v(var.as<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<sgNBPDCPpresent_t>(1);
+			v.template operator()<sgNBPDCPnotpresent_t>(2);
+
+		}
+		sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
+		sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
+		sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
+		sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
+		private:
+		void set_index(index_type i) {index = i; base::set();}
+		union union_type
+		{
+			char dummy1[sizeof(sgNBPDCPpresent_t)];
+			char dummy2[sizeof(sgNBPDCPnotpresent_t)];
+
+		};
+		asn::variant<sizeof(union_type)>	var;
+		index_type	index {0};
+	};
+	resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
+	resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReqAck_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReqAck_ItemExtIEs>;
+		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(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		en_DC_ResourceConfiguration.clear();
+		resource_configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	en_DC_ResourceConfiguration_t	en_DC_ResourceConfiguration;
+	resource_configuration_t	resource_configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item	CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item 		PRESENCE mandatory}
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item() { set(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_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_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item& select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item() { return set<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>(1); }
+		E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item const* get_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item() const { return get<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item()); 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_RABs_Admitted_ToBeAdded_SgNBAddReqAck_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_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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-RABs-Admitted-ToBeAdded-SgNBAddReqAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-ItemIEs} }
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs>;
+
+};
+struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList : asn::sequenceof<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBAddReqAckList";}
+	using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-uLpDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional}|
+	{ ID id-dLPDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresentExtIEs
+{
+	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_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
+		void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); 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_uLpDCPSnLength)) { type = 1; return true; }
+			else if(equal(id_dLPDCPSnLength)) { 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_uLpDCPSnLength);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} 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_uLpDCPSnLength() { set(ignore); type=1;}
+		void select_id_dLPDCPSnLength() { 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;}
+		PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
+		PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
+		PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
+		PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<PDCPSnLength>(); break;
+			case 2: var.destroy<PDCPSnLength>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<PDCPSnLength>(1);
+			v.template operator()<PDCPSnLength>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_uLpDCPSnLength()); return true;
+			case 2: v(select_id_dLPDCPSnLength()); 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<PDCPSnLength>()); return true;
+			case 2: v(var.as<PDCPSnLength>()); 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(PDCPSnLength)];
+
+		};
+		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_uLpDCPSnLength() { set(optional); type=1;}
+		void select_id_dLPDCPSnLength() { 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-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresent ::= SEQUENCE {
+	s1-DL-GTPtunnelEndpoint					GTPtunnelEndpoint,
+	sgNB-UL-GTP-TEIDatPDCP					GTPtunnelEndpoint																					OPTIONAL,
+-- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE are set to “present” --
+	rlc-Mode									RLCMode																								OPTIONAL,
+-- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE are set to “present” --
+	dL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint																					OPTIONAL,
+	uL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint																					OPTIONAL,
+	mCG-E-RAB-Level-QoS-Parameters			E-RAB-Level-QoS-Parameters																			OPTIONAL,
+-- This IE shall be present if MCG resource and SCG resource IEs in the the EN-DC Resource Configuration IE are set to “present” and the GBR QoS Information IE is present in the Requested MCG E-RAB Level QoS Parameters IE --
+	uL-Configuration						ULConfiguration																							OPTIONAL,
+-- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” --
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresentExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresent : asn::sequence<8, 0, true, 7>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresent";}
+	using parent_t = asn::sequence<8, 0, true, 7>;
+	struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	s1_DL_GTPtunnelEndpoint_t& ref_s1_DL_GTPtunnelEndpoint() {return s1_DL_GTPtunnelEndpoint;}
+	s1_DL_GTPtunnelEndpoint_t const& ref_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint;}
+	struct sgNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "sgNB_UL_GTP_TEIDatPDCP_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	sgNB_UL_GTP_TEIDatPDCP_t& set_sgNB_UL_GTP_TEIDatPDCP() { sgNB_UL_GTP_TEIDatPDCP.setpresent(true); return sgNB_UL_GTP_TEIDatPDCP;}
+	sgNB_UL_GTP_TEIDatPDCP_t const* get_sgNB_UL_GTP_TEIDatPDCP() const {return sgNB_UL_GTP_TEIDatPDCP.is_valid() ? &sgNB_UL_GTP_TEIDatPDCP : nullptr;}
+	struct rlc_Mode_t : RLCMode
+	{
+		static constexpr const char* name() {return "rlc_Mode_t";}
+		using parent_t = RLCMode;
+		static constexpr bool optional = true;
+
+	};
+	rlc_Mode_t& set_rlc_Mode() { rlc_Mode.setpresent(true); return rlc_Mode;}
+	rlc_Mode_t const* get_rlc_Mode() const {return rlc_Mode.is_valid() ? &rlc_Mode : nullptr;}
+	struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
+	dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
+	uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct mCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "mCG_E_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+		static constexpr bool optional = true;
+
+	};
+	mCG_E_RAB_Level_QoS_Parameters_t& set_mCG_E_RAB_Level_QoS_Parameters() { mCG_E_RAB_Level_QoS_Parameters.setpresent(true); return mCG_E_RAB_Level_QoS_Parameters;}
+	mCG_E_RAB_Level_QoS_Parameters_t const* get_mCG_E_RAB_Level_QoS_Parameters() const {return mCG_E_RAB_Level_QoS_Parameters.is_valid() ? &mCG_E_RAB_Level_QoS_Parameters : nullptr;}
+	struct uL_Configuration_t : ULConfiguration
+	{
+		static constexpr const char* name() {return "uL_Configuration_t";}
+		using parent_t = ULConfiguration;
+		static constexpr bool optional = true;
+
+	};
+	uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
+	uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresentExtIEs>;
+		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(s1_DL_GTPtunnelEndpoint);
+		v(sgNB_UL_GTP_TEIDatPDCP);
+		v(rlc_Mode);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(uL_Forwarding_GTPtunnelEndpoint);
+		v(mCG_E_RAB_Level_QoS_Parameters);
+		v(uL_Configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(s1_DL_GTPtunnelEndpoint);
+		v(sgNB_UL_GTP_TEIDatPDCP);
+		v(rlc_Mode);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(uL_Forwarding_GTPtunnelEndpoint);
+		v(mCG_E_RAB_Level_QoS_Parameters);
+		v(uL_Configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		s1_DL_GTPtunnelEndpoint.clear();
+		sgNB_UL_GTP_TEIDatPDCP.clear();
+		rlc_Mode.clear();
+		dL_Forwarding_GTPtunnelEndpoint.clear();
+		uL_Forwarding_GTPtunnelEndpoint.clear();
+		mCG_E_RAB_Level_QoS_Parameters.clear();
+		uL_Configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	s1_DL_GTPtunnelEndpoint_t	s1_DL_GTPtunnelEndpoint;
+	sgNB_UL_GTP_TEIDatPDCP_t	sgNB_UL_GTP_TEIDatPDCP;
+	rlc_Mode_t	rlc_Mode;
+	dL_Forwarding_GTPtunnelEndpoint_t	dL_Forwarding_GTPtunnelEndpoint;
+	uL_Forwarding_GTPtunnelEndpoint_t	uL_Forwarding_GTPtunnelEndpoint;
+	mCG_E_RAB_Level_QoS_Parameters_t	mCG_E_RAB_Level_QoS_Parameters;
+	uL_Configuration_t	uL_Configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ID id-lCID				CRITICALITY ignore	EXTENSION LCID		PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs
+{
+	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_lCID() { set(id_lCID); 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_lCID)) { 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_lCID);} 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_lCID() { 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;}
+		LCID& select_id_lCID() { return set<LCID>(1); }
+		LCID const* get_id_lCID() const { return get<LCID>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<LCID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<LCID>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_lCID()); 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<LCID>()); 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(LCID)];
+
+		};
+		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_lCID() { 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};
+
+	};
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresent ::= SEQUENCE {
+	sgNB-DL-GTP-TEIDatSCG					GTPtunnelEndpoint,
+	secondary-sgNB-DL-GTP-TEIDatSCG			GTPtunnelEndpoint			OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresent : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresent";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	struct sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "sgNB_DL_GTP_TEIDatSCG_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	sgNB_DL_GTP_TEIDatSCG_t& ref_sgNB_DL_GTP_TEIDatSCG() {return sgNB_DL_GTP_TEIDatSCG;}
+	sgNB_DL_GTP_TEIDatSCG_t const& ref_sgNB_DL_GTP_TEIDatSCG() const {return sgNB_DL_GTP_TEIDatSCG;}
+	struct secondary_sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "secondary_sgNB_DL_GTP_TEIDatSCG_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	secondary_sgNB_DL_GTP_TEIDatSCG_t& set_secondary_sgNB_DL_GTP_TEIDatSCG() { secondary_sgNB_DL_GTP_TEIDatSCG.setpresent(true); return secondary_sgNB_DL_GTP_TEIDatSCG;}
+	secondary_sgNB_DL_GTP_TEIDatSCG_t const* get_secondary_sgNB_DL_GTP_TEIDatSCG() const {return secondary_sgNB_DL_GTP_TEIDatSCG.is_valid() ? &secondary_sgNB_DL_GTP_TEIDatSCG : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>;
+		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(sgNB_DL_GTP_TEIDatSCG);
+		v(secondary_sgNB_DL_GTP_TEIDatSCG);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(sgNB_DL_GTP_TEIDatSCG);
+		v(secondary_sgNB_DL_GTP_TEIDatSCG);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		sgNB_DL_GTP_TEIDatSCG.clear();
+		secondary_sgNB_DL_GTP_TEIDatSCG.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	sgNB_DL_GTP_TEIDatSCG_t	sgNB_DL_GTP_TEIDatSCG;
+	secondary_sgNB_DL_GTP_TEIDatSCG_t	secondary_sgNB_DL_GTP_TEIDatSCG;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-SgNBModAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemExtIEs
+{
+	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-RABs-Admitted-ToBeAdded-SgNBModAck-Item ::= SEQUENCE {
+	e-RAB-ID								E-RAB-ID,
+	en-DC-ResourceConfiguration			EN-DC-ResourceConfiguration,
+	resource-configuration				CHOICE {
+		sgNBPDCPpresent						E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresent,
+		sgNBPDCPnotpresent					E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresent,
+		...
+	},
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBModAck-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBModAck-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 en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
+	{
+		static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
+		using parent_t = EN_DC_ResourceConfiguration;
+
+	};
+	en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
+	en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
+	struct resource_configuration_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "resource_configuration_t";}
+		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);  }
+		~resource_configuration_t() {clear();}
+		struct sgNBPDCPpresent_t : E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPpresent_t";}
+			using parent_t = E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresent;
+
+		};
+		struct sgNBPDCPnotpresent_t : E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
+			using parent_t = E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresent;
+
+		};
+		void clear()
+		{
+			switch(get_index())
+			{
+			case 1: var.destroy<sgNBPDCPpresent_t>(); break;
+			case 2: var.destroy<sgNBPDCPnotpresent_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<sgNBPDCPpresent_t>());
+			case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			switch(get_index())
+			{
+			case 1: return v(var.as<sgNBPDCPpresent_t>());
+			case 2: return v(var.as<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<sgNBPDCPpresent_t>(1);
+			v.template operator()<sgNBPDCPnotpresent_t>(2);
+
+		}
+		sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
+		sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
+		sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
+		sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
+		private:
+		void set_index(index_type i) {index = i; base::set();}
+		union union_type
+		{
+			char dummy1[sizeof(sgNBPDCPpresent_t)];
+			char dummy2[sizeof(sgNBPDCPnotpresent_t)];
+
+		};
+		asn::variant<sizeof(union_type)>	var;
+		index_type	index {0};
+	};
+	resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
+	resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemExtIEs>;
+		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(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		en_DC_ResourceConfiguration.clear();
+		resource_configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	en_DC_ResourceConfiguration_t	en_DC_ResourceConfiguration;
+	resource_configuration_t	resource_configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeAdded-SgNBModAck-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-Admitted-ToBeAdded-SgNBModAck-Item 	CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeAdded-SgNBModAck-Item		PRESENCE mandatory}
+}
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item() { set(id_E_RABs_Admitted_ToBeAdded_SgNBModAck_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_RABs_Admitted_ToBeAdded_SgNBModAck_Item)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_RABs_Admitted_ToBeAdded_SgNBModAck_Item);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		E_RABs_Admitted_ToBeAdded_SgNBModAck_Item& select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item() { return set<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>(1); }
+		E_RABs_Admitted_ToBeAdded_SgNBModAck_Item const* get_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item() const { return get<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item()); 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_RABs_Admitted_ToBeAdded_SgNBModAck_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_RABs_Admitted_ToBeAdded_SgNBModAck_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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-RABs-Admitted-ToBeAdded-SgNBModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeAdded-SgNBModAck-ItemIEs} }
+*/
+
+struct E_RABs_Admitted_ToBeAdded_SgNBModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_Admitted_ToBeAdded_SgNBModAckList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemIEs>;
+
+};
+struct E_RABs_Admitted_ToBeAdded_SgNBModAckList : asn::sequenceof<E_RABs_Admitted_ToBeAdded_SgNBModAckList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBModAckList";}
+	using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeAdded_SgNBModAckList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-Admitted-ToBeModified-ModAckItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeModified_ModAckItem_SCG_BearerExtIEs
+{
+	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-RABs-Admitted-ToBeModified-ModAckItem-SCG-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	s1-DL-GTPtunnelEndpoint			GTPtunnelEndpoint																	OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-Admitted-ToBeModified-ModAckItem-SCG-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeModified_ModAckItem_SCG_Bearer : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-ModAckItem-SCG-Bearer";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	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 s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	s1_DL_GTPtunnelEndpoint_t& set_s1_DL_GTPtunnelEndpoint() { s1_DL_GTPtunnelEndpoint.setpresent(true); return s1_DL_GTPtunnelEndpoint;}
+	s1_DL_GTPtunnelEndpoint_t const* get_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint.is_valid() ? &s1_DL_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_ModAckItem_SCG_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_ModAckItem_SCG_BearerExtIEs>;
+		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(s1_DL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(s1_DL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		s1_DL_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	s1_DL_GTPtunnelEndpoint_t	s1_DL_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeModified-ModAckItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeModified_ModAckItem_Split_BearerExtIEs
+{
+	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-RABs-Admitted-ToBeModified-ModAckItem-Split-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	seNB-GTPtunnelEndpoint			GTPtunnelEndpoint																			OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-Admitted-ToBeModified-ModAckItem-Split-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeModified_ModAckItem_Split_Bearer : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-ModAckItem-Split-Bearer";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	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 seNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "seNB_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	seNB_GTPtunnelEndpoint_t& set_seNB_GTPtunnelEndpoint() { seNB_GTPtunnelEndpoint.setpresent(true); return seNB_GTPtunnelEndpoint;}
+	seNB_GTPtunnelEndpoint_t const* get_seNB_GTPtunnelEndpoint() const {return seNB_GTPtunnelEndpoint.is_valid() ? &seNB_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_ModAckItem_Split_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_ModAckItem_Split_BearerExtIEs>;
+		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(seNB_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(seNB_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		seNB_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	seNB_GTPtunnelEndpoint_t	seNB_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeModified-ModAckItem ::= CHOICE {
+	sCG-Bearer		E-RABs-Admitted-ToBeModified-ModAckItem-SCG-Bearer,
+	split-Bearer	E-RABs-Admitted-ToBeModified-ModAckItem-Split-Bearer,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeModified_ModAckItem : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-ModAckItem";}
+	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);  }
+	~E_RABs_Admitted_ToBeModified_ModAckItem() {clear();}
+	struct sCG_Bearer_t : E_RABs_Admitted_ToBeModified_ModAckItem_SCG_Bearer
+	{
+		static constexpr const char* name() {return "sCG_Bearer_t";}
+		using parent_t = E_RABs_Admitted_ToBeModified_ModAckItem_SCG_Bearer;
+
+	};
+	struct split_Bearer_t : E_RABs_Admitted_ToBeModified_ModAckItem_Split_Bearer
+	{
+		static constexpr const char* name() {return "split_Bearer_t";}
+		using parent_t = E_RABs_Admitted_ToBeModified_ModAckItem_Split_Bearer;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<sCG_Bearer_t>(); break;
+		case 2: var.destroy<split_Bearer_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<sCG_Bearer_t>());
+		case 2: set_index(2); return v(var.build<split_Bearer_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<sCG_Bearer_t>());
+		case 2: return v(var.as<split_Bearer_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<sCG_Bearer_t>(1);
+		v.template operator()<split_Bearer_t>(2);
+
+	}
+	sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
+	sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
+	split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
+	split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(sCG_Bearer_t)];
+		char dummy2[sizeof(split_Bearer_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+E-RABs-Admitted-ToBeModified-ModAckItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-Admitted-ToBeModified-ModAckItem		CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeModified-ModAckItem	PRESENCE mandatory}
+}
+*/
+
+struct E_RABs_Admitted_ToBeModified_ModAckItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeModified_ModAckItem() { set(id_E_RABs_Admitted_ToBeModified_ModAckItem); 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_RABs_Admitted_ToBeModified_ModAckItem)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_RABs_Admitted_ToBeModified_ModAckItem);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeModified_ModAckItem() { 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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		E_RABs_Admitted_ToBeModified_ModAckItem& select_id_E_RABs_Admitted_ToBeModified_ModAckItem() { return set<E_RABs_Admitted_ToBeModified_ModAckItem>(1); }
+		E_RABs_Admitted_ToBeModified_ModAckItem const* get_id_E_RABs_Admitted_ToBeModified_ModAckItem() const { return get<E_RABs_Admitted_ToBeModified_ModAckItem>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_Admitted_ToBeModified_ModAckItem>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_Admitted_ToBeModified_ModAckItem>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_Admitted_ToBeModified_ModAckItem()); 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_RABs_Admitted_ToBeModified_ModAckItem>()); 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_RABs_Admitted_ToBeModified_ModAckItem)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeModified_ModAckItem() { 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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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-RABs-Admitted-ToBeModified-ModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeModified-ModAckItemIEs} }
+*/
+
+struct E_RABs_Admitted_ToBeModified_ModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeModified_ModAckItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_Admitted_ToBeModified_ModAckList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeModified_ModAckItemIEs>;
+
+};
+struct E_RABs_Admitted_ToBeModified_ModAckList : asn::sequenceof<E_RABs_Admitted_ToBeModified_ModAckList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-ModAckList";}
+	using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeModified_ModAckList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-uLpDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional}|
+	{ ID id-dLPDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresentExtIEs
+{
+	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_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
+		void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); 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_uLpDCPSnLength)) { type = 1; return true; }
+			else if(equal(id_dLPDCPSnLength)) { 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_uLpDCPSnLength);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} 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_uLpDCPSnLength() { set(ignore); type=1;}
+		void select_id_dLPDCPSnLength() { 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;}
+		PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
+		PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
+		PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
+		PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<PDCPSnLength>(); break;
+			case 2: var.destroy<PDCPSnLength>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<PDCPSnLength>(1);
+			v.template operator()<PDCPSnLength>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_uLpDCPSnLength()); return true;
+			case 2: v(select_id_dLPDCPSnLength()); 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<PDCPSnLength>()); return true;
+			case 2: v(var.as<PDCPSnLength>()); 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(PDCPSnLength)];
+
+		};
+		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_uLpDCPSnLength() { set(optional); type=1;}
+		void select_id_dLPDCPSnLength() { 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-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresent ::= SEQUENCE {
+	s1-DL-GTPtunnelEndpoint					GTPtunnelEndpoint																						OPTIONAL,
+	sgNB-UL-GTP-TEIDatPDCP					GTPtunnelEndpoint																						OPTIONAL,
+	mCG-E-RAB-Level-QoS-Parameters			E-RAB-Level-QoS-Parameters																				OPTIONAL,
+	uL-Configuration							ULConfiguration																							OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresentExtIEs} } 	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresent : asn::sequence<5, 0, true, 5>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresent";}
+	using parent_t = asn::sequence<5, 0, true, 5>;
+	struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	s1_DL_GTPtunnelEndpoint_t& set_s1_DL_GTPtunnelEndpoint() { s1_DL_GTPtunnelEndpoint.setpresent(true); return s1_DL_GTPtunnelEndpoint;}
+	s1_DL_GTPtunnelEndpoint_t const* get_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint.is_valid() ? &s1_DL_GTPtunnelEndpoint : nullptr;}
+	struct sgNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "sgNB_UL_GTP_TEIDatPDCP_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	sgNB_UL_GTP_TEIDatPDCP_t& set_sgNB_UL_GTP_TEIDatPDCP() { sgNB_UL_GTP_TEIDatPDCP.setpresent(true); return sgNB_UL_GTP_TEIDatPDCP;}
+	sgNB_UL_GTP_TEIDatPDCP_t const* get_sgNB_UL_GTP_TEIDatPDCP() const {return sgNB_UL_GTP_TEIDatPDCP.is_valid() ? &sgNB_UL_GTP_TEIDatPDCP : nullptr;}
+	struct mCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "mCG_E_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+		static constexpr bool optional = true;
+
+	};
+	mCG_E_RAB_Level_QoS_Parameters_t& set_mCG_E_RAB_Level_QoS_Parameters() { mCG_E_RAB_Level_QoS_Parameters.setpresent(true); return mCG_E_RAB_Level_QoS_Parameters;}
+	mCG_E_RAB_Level_QoS_Parameters_t const* get_mCG_E_RAB_Level_QoS_Parameters() const {return mCG_E_RAB_Level_QoS_Parameters.is_valid() ? &mCG_E_RAB_Level_QoS_Parameters : nullptr;}
+	struct uL_Configuration_t : ULConfiguration
+	{
+		static constexpr const char* name() {return "uL_Configuration_t";}
+		using parent_t = ULConfiguration;
+		static constexpr bool optional = true;
+
+	};
+	uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
+	uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresentExtIEs>;
+		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(s1_DL_GTPtunnelEndpoint);
+		v(sgNB_UL_GTP_TEIDatPDCP);
+		v(mCG_E_RAB_Level_QoS_Parameters);
+		v(uL_Configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(s1_DL_GTPtunnelEndpoint);
+		v(sgNB_UL_GTP_TEIDatPDCP);
+		v(mCG_E_RAB_Level_QoS_Parameters);
+		v(uL_Configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		s1_DL_GTPtunnelEndpoint.clear();
+		sgNB_UL_GTP_TEIDatPDCP.clear();
+		mCG_E_RAB_Level_QoS_Parameters.clear();
+		uL_Configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	s1_DL_GTPtunnelEndpoint_t	s1_DL_GTPtunnelEndpoint;
+	sgNB_UL_GTP_TEIDatPDCP_t	sgNB_UL_GTP_TEIDatPDCP;
+	mCG_E_RAB_Level_QoS_Parameters_t	mCG_E_RAB_Level_QoS_Parameters;
+	uL_Configuration_t	uL_Configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-secondarysgNBDLGTPTEIDatPDCP			CRITICALITY ignore	EXTENSION GTPtunnelEndpoint				PRESENCE optional}|
+	{ ID id-RLC-Status								CRITICALITY ignore			EXTENSION RLC-Status				PRESENCE optional },
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs
+{
+	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_secondarysgNBDLGTPTEIDatPDCP() { set(id_secondarysgNBDLGTPTEIDatPDCP); type=1;}
+		void select_id_RLC_Status() { set(id_RLC_Status); 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_secondarysgNBDLGTPTEIDatPDCP)) { type = 1; return true; }
+			else if(equal(id_RLC_Status)) { 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_secondarysgNBDLGTPTEIDatPDCP);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_RLC_Status);} 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_secondarysgNBDLGTPTEIDatPDCP() { set(ignore); type=1;}
+		void select_id_RLC_Status() { 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;}
+		GTPtunnelEndpoint& select_id_secondarysgNBDLGTPTEIDatPDCP() { return set<GTPtunnelEndpoint>(1); }
+		GTPtunnelEndpoint const* get_id_secondarysgNBDLGTPTEIDatPDCP() const { return get<GTPtunnelEndpoint>(1); }
+		RLC_Status& select_id_RLC_Status() { return set<RLC_Status>(2); }
+		RLC_Status const* get_id_RLC_Status() const { return get<RLC_Status>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GTPtunnelEndpoint>(); break;
+			case 2: var.destroy<RLC_Status>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GTPtunnelEndpoint>(1);
+			v.template operator()<RLC_Status>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_secondarysgNBDLGTPTEIDatPDCP()); return true;
+			case 2: v(select_id_RLC_Status()); 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<GTPtunnelEndpoint>()); return true;
+			case 2: v(var.as<RLC_Status>()); 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(GTPtunnelEndpoint)];
+			char dummy2[sizeof(RLC_Status)];
+
+		};
+		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_secondarysgNBDLGTPTEIDatPDCP() { set(optional); type=1;}
+		void select_id_RLC_Status() { 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-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresent ::= SEQUENCE {
+	sgNB-DL-GTP-TEIDatSCG					GTPtunnelEndpoint																								OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs} } 	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresent : asn::sequence<2, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresent";}
+	using parent_t = asn::sequence<2, 0, true, 2>;
+	struct sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "sgNB_DL_GTP_TEIDatSCG_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	sgNB_DL_GTP_TEIDatSCG_t& set_sgNB_DL_GTP_TEIDatSCG() { sgNB_DL_GTP_TEIDatSCG.setpresent(true); return sgNB_DL_GTP_TEIDatSCG;}
+	sgNB_DL_GTP_TEIDatSCG_t const* get_sgNB_DL_GTP_TEIDatSCG() const {return sgNB_DL_GTP_TEIDatSCG.is_valid() ? &sgNB_DL_GTP_TEIDatSCG : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>;
+		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(sgNB_DL_GTP_TEIDatSCG);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(sgNB_DL_GTP_TEIDatSCG);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		sgNB_DL_GTP_TEIDatSCG.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	sgNB_DL_GTP_TEIDatSCG_t	sgNB_DL_GTP_TEIDatSCG;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeAdded-SgNBModAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBModAck_ItemExtIEs
+{
+	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-RABs-Admitted-ToBeModified-SgNBModAck-Item ::= SEQUENCE {
+	e-RAB-ID								E-RAB-ID,
+	en-DC-ResourceConfiguration			EN-DC-ResourceConfiguration,
+	resource-configuration				CHOICE {
+		sgNBPDCPpresent						E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresent,
+		sgNBPDCPnotpresent					E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresent,
+		...
+	},
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBModAck-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-SgNBModAck-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 en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
+	{
+		static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
+		using parent_t = EN_DC_ResourceConfiguration;
+
+	};
+	en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
+	en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
+	struct resource_configuration_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "resource_configuration_t";}
+		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);  }
+		~resource_configuration_t() {clear();}
+		struct sgNBPDCPpresent_t : E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPpresent_t";}
+			using parent_t = E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresent;
+
+		};
+		struct sgNBPDCPnotpresent_t : E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
+			using parent_t = E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresent;
+
+		};
+		void clear()
+		{
+			switch(get_index())
+			{
+			case 1: var.destroy<sgNBPDCPpresent_t>(); break;
+			case 2: var.destroy<sgNBPDCPnotpresent_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<sgNBPDCPpresent_t>());
+			case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			switch(get_index())
+			{
+			case 1: return v(var.as<sgNBPDCPpresent_t>());
+			case 2: return v(var.as<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<sgNBPDCPpresent_t>(1);
+			v.template operator()<sgNBPDCPnotpresent_t>(2);
+
+		}
+		sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
+		sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
+		sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
+		sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
+		private:
+		void set_index(index_type i) {index = i; base::set();}
+		union union_type
+		{
+			char dummy1[sizeof(sgNBPDCPpresent_t)];
+			char dummy2[sizeof(sgNBPDCPnotpresent_t)];
+
+		};
+		asn::variant<sizeof(union_type)>	var;
+		index_type	index {0};
+	};
+	resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
+	resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModAck_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModAck_ItemExtIEs>;
+		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(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		en_DC_ResourceConfiguration.clear();
+		resource_configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	en_DC_ResourceConfiguration_t	en_DC_ResourceConfiguration;
+	resource_configuration_t	resource_configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeModified-SgNBModAck-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-Admitted-ToBeModified-SgNBModAck-Item		CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeModified-SgNBModAck-Item		PRESENCE mandatory}
+}
+*/
+
+struct E_RABs_Admitted_ToBeModified_SgNBModAck_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item() { set(id_E_RABs_Admitted_ToBeModified_SgNBModAck_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_RABs_Admitted_ToBeModified_SgNBModAck_Item)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_RABs_Admitted_ToBeModified_SgNBModAck_Item);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		E_RABs_Admitted_ToBeModified_SgNBModAck_Item& select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item() { return set<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>(1); }
+		E_RABs_Admitted_ToBeModified_SgNBModAck_Item const* get_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item() const { return get<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item()); 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_RABs_Admitted_ToBeModified_SgNBModAck_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_RABs_Admitted_ToBeModified_SgNBModAck_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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-RABs-Admitted-ToBeModified-SgNBModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeModified-SgNBModAck-ItemIEs} }
+*/
+
+struct E_RABs_Admitted_ToBeModified_SgNBModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeModified_SgNBModAck_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_Admitted_ToBeModified_SgNBModAckList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeModified_SgNBModAck_ItemIEs>;
+
+};
+struct E_RABs_Admitted_ToBeModified_SgNBModAckList : asn::sequenceof<E_RABs_Admitted_ToBeModified_SgNBModAckList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-SgNBModAckList";}
+	using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeModified_SgNBModAckList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_BearerExtIEs
+{
+	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-RABs-Admitted-ToBeReleased-ModAckItem-SCG-Bearer ::= SEQUENCE {
+	e-RAB-ID					E-RAB-ID,
+	iE-Extensions				ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-BearerExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_Bearer : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-Bearer";}
+	using parent_t = asn::sequence<2, 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 iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_BearerExtIEs>;
+		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(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeReleased-ModAckItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeReleased_ModAckItem_Split_BearerExtIEs
+{
+	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-RABs-Admitted-ToBeReleased-ModAckItem-Split-Bearer ::= SEQUENCE {
+	e-RAB-ID					E-RAB-ID,
+	iE-Extensions				ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-ModAckItem-Split-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeReleased_ModAckItem_Split_Bearer : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-ModAckItem-Split-Bearer";}
+	using parent_t = asn::sequence<2, 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 iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_ModAckItem_Split_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_ModAckItem_Split_BearerExtIEs>;
+		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(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToReleased-ModAckItem ::= CHOICE {
+	sCG-Bearer		E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-Bearer,
+	split-Bearer	E-RABs-Admitted-ToBeReleased-ModAckItem-Split-Bearer,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToReleased_ModAckItem : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToReleased-ModAckItem";}
+	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);  }
+	~E_RABs_Admitted_ToReleased_ModAckItem() {clear();}
+	struct sCG_Bearer_t : E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_Bearer
+	{
+		static constexpr const char* name() {return "sCG_Bearer_t";}
+		using parent_t = E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_Bearer;
+
+	};
+	struct split_Bearer_t : E_RABs_Admitted_ToBeReleased_ModAckItem_Split_Bearer
+	{
+		static constexpr const char* name() {return "split_Bearer_t";}
+		using parent_t = E_RABs_Admitted_ToBeReleased_ModAckItem_Split_Bearer;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<sCG_Bearer_t>(); break;
+		case 2: var.destroy<split_Bearer_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<sCG_Bearer_t>());
+		case 2: set_index(2); return v(var.build<split_Bearer_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<sCG_Bearer_t>());
+		case 2: return v(var.as<split_Bearer_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<sCG_Bearer_t>(1);
+		v.template operator()<split_Bearer_t>(2);
+
+	}
+	sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
+	sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
+	split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
+	split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(sCG_Bearer_t)];
+		char dummy2[sizeof(split_Bearer_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+E-RABs-Admitted-ToBeReleased-ModAckItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-Admitted-ToBeReleased-ModAckItem		CRITICALITY ignore	TYPE E-RABs-Admitted-ToReleased-ModAckItem		PRESENCE mandatory}
+}
+*/
+
+struct E_RABs_Admitted_ToBeReleased_ModAckItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeReleased_ModAckItem() { set(id_E_RABs_Admitted_ToBeReleased_ModAckItem); 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_RABs_Admitted_ToBeReleased_ModAckItem)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_RABs_Admitted_ToBeReleased_ModAckItem);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeReleased_ModAckItem() { 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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		E_RABs_Admitted_ToReleased_ModAckItem& select_id_E_RABs_Admitted_ToBeReleased_ModAckItem() { return set<E_RABs_Admitted_ToReleased_ModAckItem>(1); }
+		E_RABs_Admitted_ToReleased_ModAckItem const* get_id_E_RABs_Admitted_ToBeReleased_ModAckItem() const { return get<E_RABs_Admitted_ToReleased_ModAckItem>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_Admitted_ToReleased_ModAckItem>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_Admitted_ToReleased_ModAckItem>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_Admitted_ToBeReleased_ModAckItem()); 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_RABs_Admitted_ToReleased_ModAckItem>()); 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_RABs_Admitted_ToReleased_ModAckItem)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeReleased_ModAckItem() { 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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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-RABs-Admitted-ToBeReleased-ModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeReleased-ModAckItemIEs} }
+*/
+
+struct E_RABs_Admitted_ToBeReleased_ModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_ModAckItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_Admitted_ToBeReleased_ModAckList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_ModAckItemIEs>;
+
+};
+struct E_RABs_Admitted_ToBeReleased_ModAckList : asn::sequenceof<E_RABs_Admitted_ToBeReleased_ModAckList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-ModAckList";}
+	using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeReleased_ModAckList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs
+{
+	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-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresent ::= SEQUENCE {
+	iE-Extensions				ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresent";}
+	using parent_t = asn::sequence<1, 0, true, 1>;
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>;
+		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(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		iE_Extensions.clear();
+
+	};
+	private:
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresentExtIEs
+{
+	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-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresent ::= SEQUENCE {
+	iE-Extensions				ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresentExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresent : asn::sequence<1, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresent";}
+	using parent_t = asn::sequence<1, 0, true, 1>;
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresentExtIEs>;
+		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(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		iE_Extensions.clear();
+
+	};
+	private:
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBModAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBModAck_ItemExtIEs
+{
+	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-RABs-Admitted-ToReleased-SgNBModAck-Item ::= SEQUENCE {
+	e-RAB-ID							E-RAB-ID,
+	en-DC-ResourceConfiguration			EN-DC-ResourceConfiguration,
+	resource-configuration				CHOICE {
+		sgNBPDCPpresent						E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresent,
+		sgNBPDCPnotpresent					E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresent,
+		...
+	},
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModAck-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToReleased_SgNBModAck_Item : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToReleased-SgNBModAck-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 en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
+	{
+		static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
+		using parent_t = EN_DC_ResourceConfiguration;
+
+	};
+	en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
+	en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
+	struct resource_configuration_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "resource_configuration_t";}
+		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);  }
+		~resource_configuration_t() {clear();}
+		struct sgNBPDCPpresent_t : E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPpresent_t";}
+			using parent_t = E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresent;
+
+		};
+		struct sgNBPDCPnotpresent_t : E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
+			using parent_t = E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresent;
+
+		};
+		void clear()
+		{
+			switch(get_index())
+			{
+			case 1: var.destroy<sgNBPDCPpresent_t>(); break;
+			case 2: var.destroy<sgNBPDCPnotpresent_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<sgNBPDCPpresent_t>());
+			case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			switch(get_index())
+			{
+			case 1: return v(var.as<sgNBPDCPpresent_t>());
+			case 2: return v(var.as<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<sgNBPDCPpresent_t>(1);
+			v.template operator()<sgNBPDCPnotpresent_t>(2);
+
+		}
+		sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
+		sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
+		sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
+		sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
+		private:
+		void set_index(index_type i) {index = i; base::set();}
+		union union_type
+		{
+			char dummy1[sizeof(sgNBPDCPpresent_t)];
+			char dummy2[sizeof(sgNBPDCPnotpresent_t)];
+
+		};
+		asn::variant<sizeof(union_type)>	var;
+		index_type	index {0};
+	};
+	resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
+	resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModAck_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModAck_ItemExtIEs>;
+		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(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		en_DC_ResourceConfiguration.clear();
+		resource_configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	en_DC_ResourceConfiguration_t	en_DC_ResourceConfiguration;
+	resource_configuration_t	resource_configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeReleased-SgNBModAck-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-Admitted-ToBeReleased-SgNBModAck-Item		CRITICALITY ignore	TYPE E-RABs-Admitted-ToReleased-SgNBModAck-Item		PRESENCE mandatory}
+}
+*/
+
+struct E_RABs_Admitted_ToBeReleased_SgNBModAck_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item() { set(id_E_RABs_Admitted_ToBeReleased_SgNBModAck_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_RABs_Admitted_ToBeReleased_SgNBModAck_Item)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_RABs_Admitted_ToBeReleased_SgNBModAck_Item);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		E_RABs_Admitted_ToReleased_SgNBModAck_Item& select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item() { return set<E_RABs_Admitted_ToReleased_SgNBModAck_Item>(1); }
+		E_RABs_Admitted_ToReleased_SgNBModAck_Item const* get_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item() const { return get<E_RABs_Admitted_ToReleased_SgNBModAck_Item>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_Admitted_ToReleased_SgNBModAck_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_Admitted_ToReleased_SgNBModAck_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item()); 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_RABs_Admitted_ToReleased_SgNBModAck_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_RABs_Admitted_ToReleased_SgNBModAck_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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-RABs-Admitted-ToBeReleased-SgNBModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeReleased-SgNBModAck-ItemIEs} }
+*/
+
+struct E_RABs_Admitted_ToBeReleased_SgNBModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_SgNBModAck_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_Admitted_ToBeReleased_SgNBModAckList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_SgNBModAck_ItemIEs>;
+
+};
+struct E_RABs_Admitted_ToBeReleased_SgNBModAckList : asn::sequenceof<E_RABs_Admitted_ToBeReleased_SgNBModAckList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBModAckList";}
+	using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeReleased_SgNBModAckList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemExtIEs
+{
+	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-RABs-Admitted-ToBeReleased-SgNBRelReqAck-Item ::= SEQUENCE {
+	e-RAB-ID							E-RAB-ID,
+	rlc-Mode-transferred			RLCMode,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-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 rlc_Mode_transferred_t : RLCMode
+	{
+		static constexpr const char* name() {return "rlc_Mode_transferred_t";}
+		using parent_t = RLCMode;
+
+	};
+	rlc_Mode_transferred_t& ref_rlc_Mode_transferred() {return rlc_Mode_transferred;}
+	rlc_Mode_transferred_t const& ref_rlc_Mode_transferred() const {return rlc_Mode_transferred;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemExtIEs>;
+		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(rlc_Mode_transferred);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(rlc_Mode_transferred);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		rlc_Mode_transferred.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	rlc_Mode_transferred_t	rlc_Mode_transferred;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-Item	CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-Item		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_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_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item() { set(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_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_RABs_Admitted_ToBeReleased_SgNBRelReqAck_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_RABs_Admitted_ToBeReleased_SgNBRelReqAck_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_RABs_Admitted_ToBeReleased_SgNBRelReqAck_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_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item& select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item() { return set<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>(1); }
+		E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item const* get_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item() const { return get<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_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_RABs_Admitted_ToBeReleased_SgNBRelReqAck_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_RABs_Admitted_ToBeReleased_SgNBRelReqAck_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_RABs_Admitted_ToBeReleased_SgNBRelReqAck_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-RABs-Admitted-ToBeReleased-SgNBRelReqAckList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF
+										ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-ItemIEs} }
+*/
+
+struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemIEs>;
+
+};
+struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList : asn::sequenceof<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBRelReqAckList";}
+	using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresentExtIEs
+{
+	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-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresent ::= SEQUENCE {
+	iE-Extensions				ProtocolExtensionContainer { {E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresentExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresent : asn::sequence<1, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresent";}
+	using parent_t = asn::sequence<1, 0, true, 1>;
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresentExtIEs>;
+		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(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		iE_Extensions.clear();
+
+	};
+	private:
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-uLpDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional}|
+	{ ID id-dLPDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresentExtIEs
+{
+	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_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
+		void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); 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_uLpDCPSnLength)) { type = 1; return true; }
+			else if(equal(id_dLPDCPSnLength)) { 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_uLpDCPSnLength);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} 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_uLpDCPSnLength() { set(ignore); type=1;}
+		void select_id_dLPDCPSnLength() { 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;}
+		PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
+		PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
+		PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
+		PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<PDCPSnLength>(); break;
+			case 2: var.destroy<PDCPSnLength>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<PDCPSnLength>(1);
+			v.template operator()<PDCPSnLength>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_uLpDCPSnLength()); return true;
+			case 2: v(select_id_dLPDCPSnLength()); 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<PDCPSnLength>()); return true;
+			case 2: v(var.as<PDCPSnLength>()); 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(PDCPSnLength)];
+
+		};
+		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_uLpDCPSnLength() { set(optional); type=1;}
+		void select_id_dLPDCPSnLength() { 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-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresent ::= SEQUENCE {
+	secondary-meNB-UL-GTP-TEIDatPDCP				GTPtunnelEndpoint				OPTIONAL,
+	iE-Extensions				ProtocolExtensionContainer { {E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresentExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresent : asn::sequence<2, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresent";}
+	using parent_t = asn::sequence<2, 0, true, 2>;
+	struct secondary_meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "secondary_meNB_UL_GTP_TEIDatPDCP_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	secondary_meNB_UL_GTP_TEIDatPDCP_t& set_secondary_meNB_UL_GTP_TEIDatPDCP() { secondary_meNB_UL_GTP_TEIDatPDCP.setpresent(true); return secondary_meNB_UL_GTP_TEIDatPDCP;}
+	secondary_meNB_UL_GTP_TEIDatPDCP_t const* get_secondary_meNB_UL_GTP_TEIDatPDCP() const {return secondary_meNB_UL_GTP_TEIDatPDCP.is_valid() ? &secondary_meNB_UL_GTP_TEIDatPDCP : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresentExtIEs>;
+		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(secondary_meNB_UL_GTP_TEIDatPDCP);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(secondary_meNB_UL_GTP_TEIDatPDCP);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		secondary_meNB_UL_GTP_TEIDatPDCP.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	secondary_meNB_UL_GTP_TEIDatPDCP_t	secondary_meNB_UL_GTP_TEIDatPDCP;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-AdmittedToBeModified-SgNBModConf-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_AdmittedToBeModified_SgNBModConf_ItemExtIEs
+{
+	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-RABs-AdmittedToBeModified-SgNBModConf-Item ::= SEQUENCE {
+	e-RAB-ID								E-RAB-ID,
+	en-DC-ResourceConfiguration			EN-DC-ResourceConfiguration,
+	resource-configuration				CHOICE {
+		sgNBPDCPpresent						E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresent,
+		sgNBPDCPnotpresent					E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresent,
+		...
+	},
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-AdmittedToBeModified-SgNBModConf-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_AdmittedToBeModified_SgNBModConf_Item : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-AdmittedToBeModified-SgNBModConf-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 en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
+	{
+		static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
+		using parent_t = EN_DC_ResourceConfiguration;
+
+	};
+	en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
+	en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
+	struct resource_configuration_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "resource_configuration_t";}
+		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);  }
+		~resource_configuration_t() {clear();}
+		struct sgNBPDCPpresent_t : E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPpresent_t";}
+			using parent_t = E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresent;
+
+		};
+		struct sgNBPDCPnotpresent_t : E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
+			using parent_t = E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresent;
+
+		};
+		void clear()
+		{
+			switch(get_index())
+			{
+			case 1: var.destroy<sgNBPDCPpresent_t>(); break;
+			case 2: var.destroy<sgNBPDCPnotpresent_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<sgNBPDCPpresent_t>());
+			case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			switch(get_index())
+			{
+			case 1: return v(var.as<sgNBPDCPpresent_t>());
+			case 2: return v(var.as<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<sgNBPDCPpresent_t>(1);
+			v.template operator()<sgNBPDCPnotpresent_t>(2);
+
+		}
+		sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
+		sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
+		sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
+		sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
+		private:
+		void set_index(index_type i) {index = i; base::set();}
+		union union_type
+		{
+			char dummy1[sizeof(sgNBPDCPpresent_t)];
+			char dummy2[sizeof(sgNBPDCPnotpresent_t)];
+
+		};
+		asn::variant<sizeof(union_type)>	var;
+		index_type	index {0};
+	};
+	resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
+	resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_ItemExtIEs>;
+		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(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		en_DC_ResourceConfiguration.clear();
+		resource_configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	en_DC_ResourceConfiguration_t	en_DC_ResourceConfiguration;
+	resource_configuration_t	resource_configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-AdmittedToBeModified-SgNBModConf-ItemIEs X2AP-PROTOCOL-IES ::= {
+{ ID id-E-RABs-AdmittedToBeModified-SgNBModConf-Item	 CRITICALITY ignore	TYPE E-RABs-AdmittedToBeModified-SgNBModConf-Item	 PRESENCE mandatory },
+	...
+}
+*/
+
+struct E_RABs_AdmittedToBeModified_SgNBModConf_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_RABs_AdmittedToBeModified_SgNBModConf_Item() { set(id_E_RABs_AdmittedToBeModified_SgNBModConf_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_RABs_AdmittedToBeModified_SgNBModConf_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_RABs_AdmittedToBeModified_SgNBModConf_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_RABs_AdmittedToBeModified_SgNBModConf_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_RABs_AdmittedToBeModified_SgNBModConf_Item& select_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item() { return set<E_RABs_AdmittedToBeModified_SgNBModConf_Item>(1); }
+		E_RABs_AdmittedToBeModified_SgNBModConf_Item const* get_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item() const { return get<E_RABs_AdmittedToBeModified_SgNBModConf_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_AdmittedToBeModified_SgNBModConf_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_AdmittedToBeModified_SgNBModConf_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_AdmittedToBeModified_SgNBModConf_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_RABs_AdmittedToBeModified_SgNBModConf_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_RABs_AdmittedToBeModified_SgNBModConf_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_RABs_AdmittedToBeModified_SgNBModConf_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-RABs-AdmittedToBeModified-SgNBModConfList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container
+	{ {E-RABs-AdmittedToBeModified-SgNBModConf-ItemIEs} }
+*/
+
+struct E_RABs_AdmittedToBeModified_SgNBModConfList_elm : ProtocolIE_Single_Container<E_RABs_AdmittedToBeModified_SgNBModConf_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_AdmittedToBeModified_SgNBModConfList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_AdmittedToBeModified_SgNBModConf_ItemIEs>;
+
+};
+struct E_RABs_AdmittedToBeModified_SgNBModConfList : asn::sequenceof<E_RABs_AdmittedToBeModified_SgNBModConfList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-AdmittedToBeModified-SgNBModConfList";}
+	using parent_t = asn::sequenceof<E_RABs_AdmittedToBeModified_SgNBModConfList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-SubjectToCounterCheckItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_SubjectToCounterCheckItemExtIEs
+{
+	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-RABs-SubjectToCounterCheckItem ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	uL-Count						INTEGER (0..4294967295),
+	dL-Count						INTEGER (0..4294967295),
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-SubjectToCounterCheckItemExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_SubjectToCounterCheckItem : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-SubjectToCounterCheckItem";}
+	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 uL_Count_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
+		static constexpr const char* name() {return "uL_Count_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	uL_Count_t& ref_uL_Count() {return uL_Count;}
+	uL_Count_t const& ref_uL_Count() const {return uL_Count;}
+	struct dL_Count_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
+		static constexpr const char* name() {return "dL_Count_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	dL_Count_t& ref_dL_Count() {return dL_Count;}
+	dL_Count_t const& ref_dL_Count() const {return dL_Count;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_SubjectToCounterCheckItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_SubjectToCounterCheckItemExtIEs>;
+		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(uL_Count);
+		v(dL_Count);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(uL_Count);
+		v(dL_Count);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		uL_Count.clear();
+		dL_Count.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	uL_Count_t	uL_Count;
+	dL_Count_t	dL_Count;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-SubjectToCounterCheckItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-SubjectToCounterCheckItem	CRITICALITY ignore	TYPE E-RABs-SubjectToCounterCheckItem		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_SubjectToCounterCheckItemIEs
+{
+	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_RABs_SubjectToCounterCheckItem() { set(id_E_RABs_SubjectToCounterCheckItem); 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_RABs_SubjectToCounterCheckItem)) { 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_RABs_SubjectToCounterCheckItem);} 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_RABs_SubjectToCounterCheckItem() { 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_RABs_SubjectToCounterCheckItem& select_id_E_RABs_SubjectToCounterCheckItem() { return set<E_RABs_SubjectToCounterCheckItem>(1); }
+		E_RABs_SubjectToCounterCheckItem const* get_id_E_RABs_SubjectToCounterCheckItem() const { return get<E_RABs_SubjectToCounterCheckItem>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_SubjectToCounterCheckItem>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_SubjectToCounterCheckItem>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_SubjectToCounterCheckItem()); 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_RABs_SubjectToCounterCheckItem>()); 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_RABs_SubjectToCounterCheckItem)];
+
+		};
+		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_RABs_SubjectToCounterCheckItem() { 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-RABs-SubjectToCounterCheck-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-SubjectToCounterCheckItemIEs} }
+*/
+
+struct E_RABs_SubjectToCounterCheck_List_elm : ProtocolIE_Single_Container<E_RABs_SubjectToCounterCheckItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_SubjectToCounterCheck_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_SubjectToCounterCheckItemIEs>;
+
+};
+struct E_RABs_SubjectToCounterCheck_List : asn::sequenceof<E_RABs_SubjectToCounterCheck_List_elm>
+{
+	static constexpr const char* name() {return "E-RABs-SubjectToCounterCheck-List";}
+	using parent_t = asn::sequenceof<E_RABs_SubjectToCounterCheck_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-SubjectToSgNBCounterCheck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_SubjectToSgNBCounterCheck_ItemExtIEs
+{
+	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-RABs-SubjectToSgNBCounterCheck-Item ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	uL-Count						INTEGER (0..4294967295),
+	dL-Count						INTEGER (0..4294967295),
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-SubjectToSgNBCounterCheck-ItemExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_SubjectToSgNBCounterCheck_Item : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-SubjectToSgNBCounterCheck-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 uL_Count_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
+		static constexpr const char* name() {return "uL_Count_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	uL_Count_t& ref_uL_Count() {return uL_Count;}
+	uL_Count_t const& ref_uL_Count() const {return uL_Count;}
+	struct dL_Count_t : asn::integer<>
+	{
+		using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
+		static constexpr const char* name() {return "dL_Count_t";}
+		using parent_t = asn::integer<>;
+
+	};
+
+	dL_Count_t& ref_dL_Count() {return dL_Count;}
+	dL_Count_t const& ref_dL_Count() const {return dL_Count;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_SubjectToSgNBCounterCheck_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_SubjectToSgNBCounterCheck_ItemExtIEs>;
+		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(uL_Count);
+		v(dL_Count);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(uL_Count);
+		v(dL_Count);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		uL_Count.clear();
+		dL_Count.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	uL_Count_t	uL_Count;
+	dL_Count_t	dL_Count;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-SubjectToSgNBCounterCheck-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-SubjectToSgNBCounterCheck-Item		CRITICALITY ignore	TYPE E-RABs-SubjectToSgNBCounterCheck-Item		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_SubjectToSgNBCounterCheck_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_RABs_SubjectToSgNBCounterCheck_Item() { set(id_E_RABs_SubjectToSgNBCounterCheck_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_RABs_SubjectToSgNBCounterCheck_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_RABs_SubjectToSgNBCounterCheck_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_RABs_SubjectToSgNBCounterCheck_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_RABs_SubjectToSgNBCounterCheck_Item& select_id_E_RABs_SubjectToSgNBCounterCheck_Item() { return set<E_RABs_SubjectToSgNBCounterCheck_Item>(1); }
+		E_RABs_SubjectToSgNBCounterCheck_Item const* get_id_E_RABs_SubjectToSgNBCounterCheck_Item() const { return get<E_RABs_SubjectToSgNBCounterCheck_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_SubjectToSgNBCounterCheck_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_SubjectToSgNBCounterCheck_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_SubjectToSgNBCounterCheck_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_RABs_SubjectToSgNBCounterCheck_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_RABs_SubjectToSgNBCounterCheck_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_RABs_SubjectToSgNBCounterCheck_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-RABs-SubjectToSgNBCounterCheck-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-SubjectToSgNBCounterCheck-ItemIEs} }
+*/
+
+struct E_RABs_SubjectToSgNBCounterCheck_List_elm : ProtocolIE_Single_Container<E_RABs_SubjectToSgNBCounterCheck_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_SubjectToSgNBCounterCheck_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_SubjectToSgNBCounterCheck_ItemIEs>;
+
+};
+struct E_RABs_SubjectToSgNBCounterCheck_List : asn::sequenceof<E_RABs_SubjectToSgNBCounterCheck_List_elm>
+{
+	static constexpr const char* name() {return "E-RABs-SubjectToSgNBCounterCheck-List";}
+	using parent_t = asn::sequenceof<E_RABs_SubjectToSgNBCounterCheck_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-SubjectToStatusTransfer-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-ReceiveStatusOfULPDCPSDUsExtended			CRITICALITY ignore	EXTENSION ReceiveStatusOfULPDCPSDUsExtended			PRESENCE optional}|
+	{ ID id-ULCOUNTValueExtended						CRITICALITY ignore	EXTENSION COUNTValueExtended								PRESENCE optional}|
+	{ ID id-DLCOUNTValueExtended						CRITICALITY ignore	EXTENSION COUNTValueExtended								PRESENCE optional}|
+	{ ID id-ReceiveStatusOfULPDCPSDUsPDCP-SNlength18	CRITICALITY ignore	EXTENSION ReceiveStatusOfULPDCPSDUsPDCP-SNlength18	PRESENCE optional}|
+	{ ID id-ULCOUNTValuePDCP-SNlength18					CRITICALITY ignore	EXTENSION COUNTvaluePDCP-SNlength18						PRESENCE optional}|
+	{ ID id-DLCOUNTValuePDCP-SNlength18					CRITICALITY ignore	EXTENSION COUNTvaluePDCP-SNlength18						PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_SubjectToStatusTransfer_ItemExtIEs
+{
+	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_ReceiveStatusOfULPDCPSDUsExtended() { set(id_ReceiveStatusOfULPDCPSDUsExtended); type=1;}
+		void select_id_ULCOUNTValueExtended() { set(id_ULCOUNTValueExtended); type=2;}
+		void select_id_DLCOUNTValueExtended() { set(id_DLCOUNTValueExtended); type=3;}
+		void select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() { set(id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18); type=4;}
+		void select_id_ULCOUNTValuePDCP_SNlength18() { set(id_ULCOUNTValuePDCP_SNlength18); type=5;}
+		void select_id_DLCOUNTValuePDCP_SNlength18() { set(id_DLCOUNTValuePDCP_SNlength18); 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_ReceiveStatusOfULPDCPSDUsExtended)) { type = 1; return true; }
+			else if(equal(id_ULCOUNTValueExtended)) { type = 2; return true; }
+			else if(equal(id_DLCOUNTValueExtended)) { type = 3; return true; }
+			else if(equal(id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18)) { type = 4; return true; }
+			else if(equal(id_ULCOUNTValuePDCP_SNlength18)) { type = 5; return true; }
+			else if(equal(id_DLCOUNTValuePDCP_SNlength18)) { 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_ReceiveStatusOfULPDCPSDUsExtended);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ULCOUNTValueExtended);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_DLCOUNTValueExtended);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_ULCOUNTValuePDCP_SNlength18);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_DLCOUNTValuePDCP_SNlength18);} 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_ReceiveStatusOfULPDCPSDUsExtended() { set(ignore); type=1;}
+		void select_id_ULCOUNTValueExtended() { set(ignore); type=2;}
+		void select_id_DLCOUNTValueExtended() { set(ignore); type=3;}
+		void select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() { set(ignore); type=4;}
+		void select_id_ULCOUNTValuePDCP_SNlength18() { set(ignore); type=5;}
+		void select_id_DLCOUNTValuePDCP_SNlength18() { 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(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 { 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		ReceiveStatusOfULPDCPSDUsExtended& select_id_ReceiveStatusOfULPDCPSDUsExtended() { return set<ReceiveStatusOfULPDCPSDUsExtended>(1); }
+		ReceiveStatusOfULPDCPSDUsExtended const* get_id_ReceiveStatusOfULPDCPSDUsExtended() const { return get<ReceiveStatusOfULPDCPSDUsExtended>(1); }
+		COUNTValueExtended& select_id_ULCOUNTValueExtended() { return set<COUNTValueExtended>(2); }
+		COUNTValueExtended const* get_id_ULCOUNTValueExtended() const { return get<COUNTValueExtended>(2); }
+		COUNTValueExtended& select_id_DLCOUNTValueExtended() { return set<COUNTValueExtended>(3); }
+		COUNTValueExtended const* get_id_DLCOUNTValueExtended() const { return get<COUNTValueExtended>(3); }
+		ReceiveStatusOfULPDCPSDUsPDCP_SNlength18& select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() { return set<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>(4); }
+		ReceiveStatusOfULPDCPSDUsPDCP_SNlength18 const* get_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() const { return get<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>(4); }
+		COUNTvaluePDCP_SNlength18& select_id_ULCOUNTValuePDCP_SNlength18() { return set<COUNTvaluePDCP_SNlength18>(5); }
+		COUNTvaluePDCP_SNlength18 const* get_id_ULCOUNTValuePDCP_SNlength18() const { return get<COUNTvaluePDCP_SNlength18>(5); }
+		COUNTvaluePDCP_SNlength18& select_id_DLCOUNTValuePDCP_SNlength18() { return set<COUNTvaluePDCP_SNlength18>(6); }
+		COUNTvaluePDCP_SNlength18 const* get_id_DLCOUNTValuePDCP_SNlength18() const { return get<COUNTvaluePDCP_SNlength18>(6); }
+		bool is_unknown() const { return type == 7; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ReceiveStatusOfULPDCPSDUsExtended>(); break;
+			case 2: var.destroy<COUNTValueExtended>(); break;
+			case 3: var.destroy<COUNTValueExtended>(); break;
+			case 4: var.destroy<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>(); break;
+			case 5: var.destroy<COUNTvaluePDCP_SNlength18>(); break;
+			case 6: var.destroy<COUNTvaluePDCP_SNlength18>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ReceiveStatusOfULPDCPSDUsExtended>(1);
+			v.template operator()<COUNTValueExtended>(2);
+			v.template operator()<COUNTValueExtended>(3);
+			v.template operator()<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>(4);
+			v.template operator()<COUNTvaluePDCP_SNlength18>(5);
+			v.template operator()<COUNTvaluePDCP_SNlength18>(6);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ReceiveStatusOfULPDCPSDUsExtended()); return true;
+			case 2: v(select_id_ULCOUNTValueExtended()); return true;
+			case 3: v(select_id_DLCOUNTValueExtended()); return true;
+			case 4: v(select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18()); return true;
+			case 5: v(select_id_ULCOUNTValuePDCP_SNlength18()); return true;
+			case 6: v(select_id_DLCOUNTValuePDCP_SNlength18()); 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<ReceiveStatusOfULPDCPSDUsExtended>()); return true;
+			case 2: v(var.as<COUNTValueExtended>()); return true;
+			case 3: v(var.as<COUNTValueExtended>()); return true;
+			case 4: v(var.as<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>()); return true;
+			case 5: v(var.as<COUNTvaluePDCP_SNlength18>()); return true;
+			case 6: v(var.as<COUNTvaluePDCP_SNlength18>()); 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(COUNTValueExtended)];
+			char dummy2[sizeof(COUNTvaluePDCP_SNlength18)];
+			char dummy3[sizeof(ReceiveStatusOfULPDCPSDUsExtended)];
+			char dummy4[sizeof(ReceiveStatusOfULPDCPSDUsPDCP_SNlength18)];
+
+		};
+		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_ReceiveStatusOfULPDCPSDUsExtended() { set(optional); type=1;}
+		void select_id_ULCOUNTValueExtended() { set(optional); type=2;}
+		void select_id_DLCOUNTValueExtended() { set(optional); type=3;}
+		void select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() { set(optional); type=4;}
+		void select_id_ULCOUNTValuePDCP_SNlength18() { set(optional); type=5;}
+		void select_id_DLCOUNTValuePDCP_SNlength18() { 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};
+
+	};
+
+};
+/*
+E-RABs-SubjectToStatusTransfer-Item ::= SEQUENCE {
+	e-RAB-ID								E-RAB-ID,
+
+	receiveStatusofULPDCPSDUs				ReceiveStatusofULPDCPSDUs			OPTIONAL,
+	uL-COUNTvalue					COUNTvalue,
+	dL-COUNTvalue					COUNTvalue,
+	iE-Extensions							ProtocolExtensionContainer { {E-RABs-SubjectToStatusTransfer-ItemExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_SubjectToStatusTransfer_Item : asn::sequence<5, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-SubjectToStatusTransfer-Item";}
+	using parent_t = asn::sequence<5, 0, true, 2>;
+	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 receiveStatusofULPDCPSDUs_t : ReceiveStatusofULPDCPSDUs
+	{
+		static constexpr const char* name() {return "receiveStatusofULPDCPSDUs_t";}
+		using parent_t = ReceiveStatusofULPDCPSDUs;
+		static constexpr bool optional = true;
+
+	};
+	receiveStatusofULPDCPSDUs_t& set_receiveStatusofULPDCPSDUs() { receiveStatusofULPDCPSDUs.setpresent(true); return receiveStatusofULPDCPSDUs;}
+	receiveStatusofULPDCPSDUs_t const* get_receiveStatusofULPDCPSDUs() const {return receiveStatusofULPDCPSDUs.is_valid() ? &receiveStatusofULPDCPSDUs : nullptr;}
+	struct uL_COUNTvalue_t : COUNTvalue
+	{
+		static constexpr const char* name() {return "uL_COUNTvalue_t";}
+		using parent_t = COUNTvalue;
+
+	};
+	uL_COUNTvalue_t& ref_uL_COUNTvalue() {return uL_COUNTvalue;}
+	uL_COUNTvalue_t const& ref_uL_COUNTvalue() const {return uL_COUNTvalue;}
+	struct dL_COUNTvalue_t : COUNTvalue
+	{
+		static constexpr const char* name() {return "dL_COUNTvalue_t";}
+		using parent_t = COUNTvalue;
+
+	};
+	dL_COUNTvalue_t& ref_dL_COUNTvalue() {return dL_COUNTvalue;}
+	dL_COUNTvalue_t const& ref_dL_COUNTvalue() const {return dL_COUNTvalue;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_SubjectToStatusTransfer_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_SubjectToStatusTransfer_ItemExtIEs>;
+		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(receiveStatusofULPDCPSDUs);
+		v(uL_COUNTvalue);
+		v(dL_COUNTvalue);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(receiveStatusofULPDCPSDUs);
+		v(uL_COUNTvalue);
+		v(dL_COUNTvalue);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		receiveStatusofULPDCPSDUs.clear();
+		uL_COUNTvalue.clear();
+		dL_COUNTvalue.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	receiveStatusofULPDCPSDUs_t	receiveStatusofULPDCPSDUs;
+	uL_COUNTvalue_t	uL_COUNTvalue;
+	dL_COUNTvalue_t	dL_COUNTvalue;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-SubjectToStatusTransfer-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-SubjectToStatusTransfer-Item	CRITICALITY ignore	TYPE E-RABs-SubjectToStatusTransfer-Item 	PRESENCE mandatory	}
+}
+*/
+
+struct E_RABs_SubjectToStatusTransfer_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_SubjectToStatusTransfer_Item() { set(id_E_RABs_SubjectToStatusTransfer_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_RABs_SubjectToStatusTransfer_Item)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_RABs_SubjectToStatusTransfer_Item);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_SubjectToStatusTransfer_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		E_RABs_SubjectToStatusTransfer_Item& select_id_E_RABs_SubjectToStatusTransfer_Item() { return set<E_RABs_SubjectToStatusTransfer_Item>(1); }
+		E_RABs_SubjectToStatusTransfer_Item const* get_id_E_RABs_SubjectToStatusTransfer_Item() const { return get<E_RABs_SubjectToStatusTransfer_Item>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_SubjectToStatusTransfer_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_SubjectToStatusTransfer_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_SubjectToStatusTransfer_Item()); 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_RABs_SubjectToStatusTransfer_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_RABs_SubjectToStatusTransfer_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_E_RABs_SubjectToStatusTransfer_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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-RABs-SubjectToStatusTransfer-List	::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-SubjectToStatusTransfer-ItemIEs} }
+*/
+
+struct E_RABs_SubjectToStatusTransfer_List_elm : ProtocolIE_Single_Container<E_RABs_SubjectToStatusTransfer_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_SubjectToStatusTransfer_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_SubjectToStatusTransfer_ItemIEs>;
+
+};
+struct E_RABs_SubjectToStatusTransfer_List : asn::sequenceof<E_RABs_SubjectToStatusTransfer_List_elm>
+{
+	static constexpr const char* name() {return "E-RABs-SubjectToStatusTransfer-List";}
+	using parent_t = asn::sequenceof<E_RABs_SubjectToStatusTransfer_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeAdded-Item-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-Correlation-ID				CRITICALITY ignore	EXTENSION Correlation-ID		PRESENCE optional}|
+	{ ID id-SIPTO-Correlation-ID		CRITICALITY ignore	EXTENSION Correlation-ID		PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_Item_SCG_BearerExtIEs
+{
+	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_Correlation_ID() { set(id_Correlation_ID); type=1;}
+		void select_id_SIPTO_Correlation_ID() { set(id_SIPTO_Correlation_ID); 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_Correlation_ID)) { type = 1; return true; }
+			else if(equal(id_SIPTO_Correlation_ID)) { 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_Correlation_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SIPTO_Correlation_ID);} 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_Correlation_ID() { set(ignore); type=1;}
+		void select_id_SIPTO_Correlation_ID() { 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;}
+		Correlation_ID& select_id_Correlation_ID() { return set<Correlation_ID>(1); }
+		Correlation_ID const* get_id_Correlation_ID() const { return get<Correlation_ID>(1); }
+		Correlation_ID& select_id_SIPTO_Correlation_ID() { return set<Correlation_ID>(2); }
+		Correlation_ID const* get_id_SIPTO_Correlation_ID() const { return get<Correlation_ID>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Correlation_ID>(); break;
+			case 2: var.destroy<Correlation_ID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Correlation_ID>(1);
+			v.template operator()<Correlation_ID>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Correlation_ID()); return true;
+			case 2: v(select_id_SIPTO_Correlation_ID()); 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<Correlation_ID>()); return true;
+			case 2: v(var.as<Correlation_ID>()); 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(Correlation_ID)];
+
+		};
+		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_Correlation_ID() { set(optional); type=1;}
+		void select_id_SIPTO_Correlation_ID() { 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-RABs-ToBeAdded-Item-SCG-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	e-RAB-Level-QoS-Parameters		E-RAB-Level-QoS-Parameters,
+	dL-Forwarding					DL-Forwarding																	OPTIONAL,
+	s1-UL-GTPtunnelEndpoint			GTPtunnelEndpoint,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeAdded-Item-SCG-BearerExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_Item_SCG_Bearer : asn::sequence<5, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-Item-SCG-Bearer";}
+	using parent_t = asn::sequence<5, 0, true, 2>;
+	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 e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+
+	};
+	e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
+	e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
+	struct dL_Forwarding_t : DL_Forwarding
+	{
+		static constexpr const char* name() {return "dL_Forwarding_t";}
+		using parent_t = DL_Forwarding;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
+	dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
+	struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	s1_UL_GTPtunnelEndpoint_t& ref_s1_UL_GTPtunnelEndpoint() {return s1_UL_GTPtunnelEndpoint;}
+	s1_UL_GTPtunnelEndpoint_t const& ref_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_Item_SCG_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_Item_SCG_BearerExtIEs>;
+		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(e_RAB_Level_QoS_Parameters);
+		v(dL_Forwarding);
+		v(s1_UL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(e_RAB_Level_QoS_Parameters);
+		v(dL_Forwarding);
+		v(s1_UL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		e_RAB_Level_QoS_Parameters.clear();
+		dL_Forwarding.clear();
+		s1_UL_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	e_RAB_Level_QoS_Parameters_t	e_RAB_Level_QoS_Parameters;
+	dL_Forwarding_t	dL_Forwarding;
+	s1_UL_GTPtunnelEndpoint_t	s1_UL_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeAdded-Item-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_Item_Split_BearerExtIEs
+{
+	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-RABs-ToBeAdded-Item-Split-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	e-RAB-Level-QoS-Parameters		E-RAB-Level-QoS-Parameters,
+	meNB-GTPtunnelEndpoint			GTPtunnelEndpoint,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeAdded-Item-Split-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_Item_Split_Bearer : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-Item-Split-Bearer";}
+	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 e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+
+	};
+	e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
+	e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
+	struct meNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "meNB_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	meNB_GTPtunnelEndpoint_t& ref_meNB_GTPtunnelEndpoint() {return meNB_GTPtunnelEndpoint;}
+	meNB_GTPtunnelEndpoint_t const& ref_meNB_GTPtunnelEndpoint() const {return meNB_GTPtunnelEndpoint;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_Item_Split_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_Item_Split_BearerExtIEs>;
+		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(e_RAB_Level_QoS_Parameters);
+		v(meNB_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(e_RAB_Level_QoS_Parameters);
+		v(meNB_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		e_RAB_Level_QoS_Parameters.clear();
+		meNB_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	e_RAB_Level_QoS_Parameters_t	e_RAB_Level_QoS_Parameters;
+	meNB_GTPtunnelEndpoint_t	meNB_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeAdded-Item ::= CHOICE {
+	sCG-Bearer		E-RABs-ToBeAdded-Item-SCG-Bearer,
+	split-Bearer	E-RABs-ToBeAdded-Item-Split-Bearer,
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_Item : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-Item";}
+	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);  }
+	~E_RABs_ToBeAdded_Item() {clear();}
+	struct sCG_Bearer_t : E_RABs_ToBeAdded_Item_SCG_Bearer
+	{
+		static constexpr const char* name() {return "sCG_Bearer_t";}
+		using parent_t = E_RABs_ToBeAdded_Item_SCG_Bearer;
+
+	};
+	struct split_Bearer_t : E_RABs_ToBeAdded_Item_Split_Bearer
+	{
+		static constexpr const char* name() {return "split_Bearer_t";}
+		using parent_t = E_RABs_ToBeAdded_Item_Split_Bearer;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<sCG_Bearer_t>(); break;
+		case 2: var.destroy<split_Bearer_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<sCG_Bearer_t>());
+		case 2: set_index(2); return v(var.build<split_Bearer_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<sCG_Bearer_t>());
+		case 2: return v(var.as<split_Bearer_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<sCG_Bearer_t>(1);
+		v.template operator()<split_Bearer_t>(2);
+
+	}
+	sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
+	sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
+	split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
+	split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(sCG_Bearer_t)];
+		char dummy2[sizeof(split_Bearer_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+E-RABs-ToBeAdded-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeAdded-Item	CRITICALITY reject	TYPE E-RABs-ToBeAdded-Item		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_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_RABs_ToBeAdded_Item() { set(id_E_RABs_ToBeAdded_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_RABs_ToBeAdded_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_RABs_ToBeAdded_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_RABs_ToBeAdded_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;}
+		E_RABs_ToBeAdded_Item& select_id_E_RABs_ToBeAdded_Item() { return set<E_RABs_ToBeAdded_Item>(1); }
+		E_RABs_ToBeAdded_Item const* get_id_E_RABs_ToBeAdded_Item() const { return get<E_RABs_ToBeAdded_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeAdded_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeAdded_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeAdded_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_RABs_ToBeAdded_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_RABs_ToBeAdded_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_RABs_ToBeAdded_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-RABs-ToBeAdded-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeAdded-ItemIEs} }
+*/
+
+struct E_RABs_ToBeAdded_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeAdded_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeAdded_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeAdded_ItemIEs>;
+
+};
+struct E_RABs_ToBeAdded_List : asn::sequenceof<E_RABs_ToBeAdded_List_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-List";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeAdded_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeAdded-ModReqItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-Correlation-ID				CRITICALITY ignore	EXTENSION Correlation-ID		PRESENCE optional}|
+	{ ID id-SIPTO-Correlation-ID		CRITICALITY ignore	EXTENSION Correlation-ID		PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_ModReqItem_SCG_BearerExtIEs
+{
+	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_Correlation_ID() { set(id_Correlation_ID); type=1;}
+		void select_id_SIPTO_Correlation_ID() { set(id_SIPTO_Correlation_ID); 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_Correlation_ID)) { type = 1; return true; }
+			else if(equal(id_SIPTO_Correlation_ID)) { 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_Correlation_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SIPTO_Correlation_ID);} 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_Correlation_ID() { set(ignore); type=1;}
+		void select_id_SIPTO_Correlation_ID() { 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;}
+		Correlation_ID& select_id_Correlation_ID() { return set<Correlation_ID>(1); }
+		Correlation_ID const* get_id_Correlation_ID() const { return get<Correlation_ID>(1); }
+		Correlation_ID& select_id_SIPTO_Correlation_ID() { return set<Correlation_ID>(2); }
+		Correlation_ID const* get_id_SIPTO_Correlation_ID() const { return get<Correlation_ID>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Correlation_ID>(); break;
+			case 2: var.destroy<Correlation_ID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Correlation_ID>(1);
+			v.template operator()<Correlation_ID>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Correlation_ID()); return true;
+			case 2: v(select_id_SIPTO_Correlation_ID()); 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<Correlation_ID>()); return true;
+			case 2: v(var.as<Correlation_ID>()); 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(Correlation_ID)];
+
+		};
+		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_Correlation_ID() { set(optional); type=1;}
+		void select_id_SIPTO_Correlation_ID() { 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-RABs-ToBeAdded-ModReqItem-SCG-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	e-RAB-Level-QoS-Parameters		E-RAB-Level-QoS-Parameters,
+	dL-Forwarding					DL-Forwarding																	OPTIONAL,
+	s1-UL-GTPtunnelEndpoint			GTPtunnelEndpoint,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeAdded-ModReqItem-SCG-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_ModReqItem_SCG_Bearer : asn::sequence<5, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-ModReqItem-SCG-Bearer";}
+	using parent_t = asn::sequence<5, 0, true, 2>;
+	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 e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+
+	};
+	e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
+	e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
+	struct dL_Forwarding_t : DL_Forwarding
+	{
+		static constexpr const char* name() {return "dL_Forwarding_t";}
+		using parent_t = DL_Forwarding;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
+	dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
+	struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	s1_UL_GTPtunnelEndpoint_t& ref_s1_UL_GTPtunnelEndpoint() {return s1_UL_GTPtunnelEndpoint;}
+	s1_UL_GTPtunnelEndpoint_t const& ref_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_ModReqItem_SCG_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_ModReqItem_SCG_BearerExtIEs>;
+		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(e_RAB_Level_QoS_Parameters);
+		v(dL_Forwarding);
+		v(s1_UL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(e_RAB_Level_QoS_Parameters);
+		v(dL_Forwarding);
+		v(s1_UL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		e_RAB_Level_QoS_Parameters.clear();
+		dL_Forwarding.clear();
+		s1_UL_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	e_RAB_Level_QoS_Parameters_t	e_RAB_Level_QoS_Parameters;
+	dL_Forwarding_t	dL_Forwarding;
+	s1_UL_GTPtunnelEndpoint_t	s1_UL_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeAdded-ModReqItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_ModReqItem_Split_BearerExtIEs
+{
+	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-RABs-ToBeAdded-ModReqItem-Split-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	e-RAB-Level-QoS-Parameters		E-RAB-Level-QoS-Parameters,
+	meNB-GTPtunnelEndpoint			GTPtunnelEndpoint,
+	iE-Extensions			ProtocolExtensionContainer { {E-RABs-ToBeAdded-ModReqItem-Split-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_ModReqItem_Split_Bearer : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-ModReqItem-Split-Bearer";}
+	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 e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+
+	};
+	e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
+	e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
+	struct meNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "meNB_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	meNB_GTPtunnelEndpoint_t& ref_meNB_GTPtunnelEndpoint() {return meNB_GTPtunnelEndpoint;}
+	meNB_GTPtunnelEndpoint_t const& ref_meNB_GTPtunnelEndpoint() const {return meNB_GTPtunnelEndpoint;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_ModReqItem_Split_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_ModReqItem_Split_BearerExtIEs>;
+		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(e_RAB_Level_QoS_Parameters);
+		v(meNB_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(e_RAB_Level_QoS_Parameters);
+		v(meNB_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		e_RAB_Level_QoS_Parameters.clear();
+		meNB_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	e_RAB_Level_QoS_Parameters_t	e_RAB_Level_QoS_Parameters;
+	meNB_GTPtunnelEndpoint_t	meNB_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeAdded-ModReqItem ::= CHOICE {
+	sCG-Bearer		E-RABs-ToBeAdded-ModReqItem-SCG-Bearer,
+	split-Bearer	E-RABs-ToBeAdded-ModReqItem-Split-Bearer,
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_ModReqItem : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-ModReqItem";}
+	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);  }
+	~E_RABs_ToBeAdded_ModReqItem() {clear();}
+	struct sCG_Bearer_t : E_RABs_ToBeAdded_ModReqItem_SCG_Bearer
+	{
+		static constexpr const char* name() {return "sCG_Bearer_t";}
+		using parent_t = E_RABs_ToBeAdded_ModReqItem_SCG_Bearer;
+
+	};
+	struct split_Bearer_t : E_RABs_ToBeAdded_ModReqItem_Split_Bearer
+	{
+		static constexpr const char* name() {return "split_Bearer_t";}
+		using parent_t = E_RABs_ToBeAdded_ModReqItem_Split_Bearer;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<sCG_Bearer_t>(); break;
+		case 2: var.destroy<split_Bearer_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<sCG_Bearer_t>());
+		case 2: set_index(2); return v(var.build<split_Bearer_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<sCG_Bearer_t>());
+		case 2: return v(var.as<split_Bearer_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<sCG_Bearer_t>(1);
+		v.template operator()<split_Bearer_t>(2);
+
+	}
+	sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
+	sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
+	split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
+	split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(sCG_Bearer_t)];
+		char dummy2[sizeof(split_Bearer_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+E-RABs-ToBeAdded-ModReqItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeAdded-ModReqItem	CRITICALITY ignore	TYPE E-RABs-ToBeAdded-ModReqItem	PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_ModReqItemIEs
+{
+	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_RABs_ToBeAdded_ModReqItem() { set(id_E_RABs_ToBeAdded_ModReqItem); 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_RABs_ToBeAdded_ModReqItem)) { 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_RABs_ToBeAdded_ModReqItem);} 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_RABs_ToBeAdded_ModReqItem() { 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_RABs_ToBeAdded_ModReqItem& select_id_E_RABs_ToBeAdded_ModReqItem() { return set<E_RABs_ToBeAdded_ModReqItem>(1); }
+		E_RABs_ToBeAdded_ModReqItem const* get_id_E_RABs_ToBeAdded_ModReqItem() const { return get<E_RABs_ToBeAdded_ModReqItem>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeAdded_ModReqItem>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeAdded_ModReqItem>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeAdded_ModReqItem()); 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_RABs_ToBeAdded_ModReqItem>()); 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_RABs_ToBeAdded_ModReqItem)];
+
+		};
+		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_RABs_ToBeAdded_ModReqItem() { 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-RABs-ToBeAdded-List-ModReq ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeAdded-ModReqItemIEs} }
+*/
+
+struct E_RABs_ToBeAdded_List_ModReq_elm : ProtocolIE_Single_Container<E_RABs_ToBeAdded_ModReqItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeAdded_List_ModReq_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeAdded_ModReqItemIEs>;
+
+};
+struct E_RABs_ToBeAdded_List_ModReq : asn::sequenceof<E_RABs_ToBeAdded_List_ModReq_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-List-ModReq";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeAdded_List_ModReq_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-RLCMode-transferred					CRITICALITY ignore	EXTENSION RLCMode					PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresentExtIEs
+{
+	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_RLCMode_transferred() { set(id_RLCMode_transferred); 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_RLCMode_transferred)) { 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_RLCMode_transferred);} 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_RLCMode_transferred() { 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;}
+		RLCMode& select_id_RLCMode_transferred() { return set<RLCMode>(1); }
+		RLCMode const* get_id_RLCMode_transferred() const { return get<RLCMode>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<RLCMode>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<RLCMode>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_RLCMode_transferred()); 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<RLCMode>()); 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(RLCMode)];
+
+		};
+		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_RLCMode_transferred() { 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};
+
+	};
+
+};
+/*
+E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresent ::= SEQUENCE {
+	full-E-RAB-Level-QoS-Parameters				E-RAB-Level-QoS-Parameters,
+	max-MCG-admit-E-RAB-Level-QoS-Parameters	GBR-QosInformation															OPTIONAL,
+-- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” and GBR QoS Information IE is present in Full E-RAB Level QoS Parameters IE --
+	dL-Forwarding								DL-Forwarding																		OPTIONAL,
+	meNB-DL-GTP-TEIDatMCG						GTPtunnelEndpoint																	OPTIONAL,
+-- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE is set to “present” --
+	s1-UL-GTPtunnelEndpoint						GTPtunnelEndpoint,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresentExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent : asn::sequence<6, 0, true, 4>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresent";}
+	using parent_t = asn::sequence<6, 0, true, 4>;
+	struct full_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "full_E_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+
+	};
+	full_E_RAB_Level_QoS_Parameters_t& ref_full_E_RAB_Level_QoS_Parameters() {return full_E_RAB_Level_QoS_Parameters;}
+	full_E_RAB_Level_QoS_Parameters_t const& ref_full_E_RAB_Level_QoS_Parameters() const {return full_E_RAB_Level_QoS_Parameters;}
+	struct max_MCG_admit_E_RAB_Level_QoS_Parameters_t : GBR_QosInformation
+	{
+		static constexpr const char* name() {return "max_MCG_admit_E_RAB_Level_QoS_Parameters_t";}
+		using parent_t = GBR_QosInformation;
+		static constexpr bool optional = true;
+
+	};
+	max_MCG_admit_E_RAB_Level_QoS_Parameters_t& set_max_MCG_admit_E_RAB_Level_QoS_Parameters() { max_MCG_admit_E_RAB_Level_QoS_Parameters.setpresent(true); return max_MCG_admit_E_RAB_Level_QoS_Parameters;}
+	max_MCG_admit_E_RAB_Level_QoS_Parameters_t const* get_max_MCG_admit_E_RAB_Level_QoS_Parameters() const {return max_MCG_admit_E_RAB_Level_QoS_Parameters.is_valid() ? &max_MCG_admit_E_RAB_Level_QoS_Parameters : nullptr;}
+	struct dL_Forwarding_t : DL_Forwarding
+	{
+		static constexpr const char* name() {return "dL_Forwarding_t";}
+		using parent_t = DL_Forwarding;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
+	dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
+	struct meNB_DL_GTP_TEIDatMCG_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "meNB_DL_GTP_TEIDatMCG_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	meNB_DL_GTP_TEIDatMCG_t& set_meNB_DL_GTP_TEIDatMCG() { meNB_DL_GTP_TEIDatMCG.setpresent(true); return meNB_DL_GTP_TEIDatMCG;}
+	meNB_DL_GTP_TEIDatMCG_t const* get_meNB_DL_GTP_TEIDatMCG() const {return meNB_DL_GTP_TEIDatMCG.is_valid() ? &meNB_DL_GTP_TEIDatMCG : nullptr;}
+	struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	s1_UL_GTPtunnelEndpoint_t& ref_s1_UL_GTPtunnelEndpoint() {return s1_UL_GTPtunnelEndpoint;}
+	s1_UL_GTPtunnelEndpoint_t const& ref_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresentExtIEs>;
+		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(full_E_RAB_Level_QoS_Parameters);
+		v(max_MCG_admit_E_RAB_Level_QoS_Parameters);
+		v(dL_Forwarding);
+		v(meNB_DL_GTP_TEIDatMCG);
+		v(s1_UL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(full_E_RAB_Level_QoS_Parameters);
+		v(max_MCG_admit_E_RAB_Level_QoS_Parameters);
+		v(dL_Forwarding);
+		v(meNB_DL_GTP_TEIDatMCG);
+		v(s1_UL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		full_E_RAB_Level_QoS_Parameters.clear();
+		max_MCG_admit_E_RAB_Level_QoS_Parameters.clear();
+		dL_Forwarding.clear();
+		meNB_DL_GTP_TEIDatMCG.clear();
+		s1_UL_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	full_E_RAB_Level_QoS_Parameters_t	full_E_RAB_Level_QoS_Parameters;
+	max_MCG_admit_E_RAB_Level_QoS_Parameters_t	max_MCG_admit_E_RAB_Level_QoS_Parameters;
+	dL_Forwarding_t	dL_Forwarding;
+	meNB_DL_GTP_TEIDatMCG_t	meNB_DL_GTP_TEIDatMCG;
+	s1_UL_GTPtunnelEndpoint_t	s1_UL_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-uLpDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional}|
+	{ ID id-dLPDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional}|
+	{ ID id-duplicationActivation					CRITICALITY ignore	EXTENSION DuplicationActivation	PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresentExtIEs
+{
+	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_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
+		void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
+		void select_id_duplicationActivation() { set(id_duplicationActivation); 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_uLpDCPSnLength)) { type = 1; return true; }
+			else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
+			else if(equal(id_duplicationActivation)) { 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_uLpDCPSnLength);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_duplicationActivation);} 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_uLpDCPSnLength() { set(ignore); type=1;}
+		void select_id_dLPDCPSnLength() { set(ignore); type=2;}
+		void select_id_duplicationActivation() { 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;}
+		PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
+		PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
+		PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
+		PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
+		DuplicationActivation& select_id_duplicationActivation() { return set<DuplicationActivation>(3); }
+		DuplicationActivation const* get_id_duplicationActivation() const { return get<DuplicationActivation>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<PDCPSnLength>(); break;
+			case 2: var.destroy<PDCPSnLength>(); break;
+			case 3: var.destroy<DuplicationActivation>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<PDCPSnLength>(1);
+			v.template operator()<PDCPSnLength>(2);
+			v.template operator()<DuplicationActivation>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_uLpDCPSnLength()); return true;
+			case 2: v(select_id_dLPDCPSnLength()); return true;
+			case 3: v(select_id_duplicationActivation()); 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<PDCPSnLength>()); return true;
+			case 2: v(var.as<PDCPSnLength>()); return true;
+			case 3: v(var.as<DuplicationActivation>()); 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(DuplicationActivation)];
+			char dummy2[sizeof(PDCPSnLength)];
+
+		};
+		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_uLpDCPSnLength() { set(optional); type=1;}
+		void select_id_dLPDCPSnLength() { set(optional); type=2;}
+		void select_id_duplicationActivation() { 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};
+
+	};
+
+};
+/*
+E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
+	requested-SCG-E-RAB-Level-QoS-Parameters		E-RAB-Level-QoS-Parameters,
+	meNB-UL-GTP-TEIDatPDCP							GTPtunnelEndpoint,
+	secondary-meNB-UL-GTP-TEIDatPDCP				GTPtunnelEndpoint	OPTIONAL,
+	rlc-Mode										RLCMode,
+	uL-Configuration								ULConfiguration	OPTIONAL,
+-- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” --
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresentExtIEs} }		 OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent : asn::sequence<6, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresent";}
+	using parent_t = asn::sequence<6, 0, true, 3>;
+	struct requested_SCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "requested_SCG_E_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+
+	};
+	requested_SCG_E_RAB_Level_QoS_Parameters_t& ref_requested_SCG_E_RAB_Level_QoS_Parameters() {return requested_SCG_E_RAB_Level_QoS_Parameters;}
+	requested_SCG_E_RAB_Level_QoS_Parameters_t const& ref_requested_SCG_E_RAB_Level_QoS_Parameters() const {return requested_SCG_E_RAB_Level_QoS_Parameters;}
+	struct meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "meNB_UL_GTP_TEIDatPDCP_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	meNB_UL_GTP_TEIDatPDCP_t& ref_meNB_UL_GTP_TEIDatPDCP() {return meNB_UL_GTP_TEIDatPDCP;}
+	meNB_UL_GTP_TEIDatPDCP_t const& ref_meNB_UL_GTP_TEIDatPDCP() const {return meNB_UL_GTP_TEIDatPDCP;}
+	struct secondary_meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "secondary_meNB_UL_GTP_TEIDatPDCP_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	secondary_meNB_UL_GTP_TEIDatPDCP_t& set_secondary_meNB_UL_GTP_TEIDatPDCP() { secondary_meNB_UL_GTP_TEIDatPDCP.setpresent(true); return secondary_meNB_UL_GTP_TEIDatPDCP;}
+	secondary_meNB_UL_GTP_TEIDatPDCP_t const* get_secondary_meNB_UL_GTP_TEIDatPDCP() const {return secondary_meNB_UL_GTP_TEIDatPDCP.is_valid() ? &secondary_meNB_UL_GTP_TEIDatPDCP : nullptr;}
+	struct rlc_Mode_t : RLCMode
+	{
+		static constexpr const char* name() {return "rlc_Mode_t";}
+		using parent_t = RLCMode;
+
+	};
+	rlc_Mode_t& ref_rlc_Mode() {return rlc_Mode;}
+	rlc_Mode_t const& ref_rlc_Mode() const {return rlc_Mode;}
+	struct uL_Configuration_t : ULConfiguration
+	{
+		static constexpr const char* name() {return "uL_Configuration_t";}
+		using parent_t = ULConfiguration;
+		static constexpr bool optional = true;
+
+	};
+	uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
+	uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresentExtIEs>;
+		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(requested_SCG_E_RAB_Level_QoS_Parameters);
+		v(meNB_UL_GTP_TEIDatPDCP);
+		v(secondary_meNB_UL_GTP_TEIDatPDCP);
+		v(rlc_Mode);
+		v(uL_Configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(requested_SCG_E_RAB_Level_QoS_Parameters);
+		v(meNB_UL_GTP_TEIDatPDCP);
+		v(secondary_meNB_UL_GTP_TEIDatPDCP);
+		v(rlc_Mode);
+		v(uL_Configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		requested_SCG_E_RAB_Level_QoS_Parameters.clear();
+		meNB_UL_GTP_TEIDatPDCP.clear();
+		secondary_meNB_UL_GTP_TEIDatPDCP.clear();
+		rlc_Mode.clear();
+		uL_Configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	requested_SCG_E_RAB_Level_QoS_Parameters_t	requested_SCG_E_RAB_Level_QoS_Parameters;
+	meNB_UL_GTP_TEIDatPDCP_t	meNB_UL_GTP_TEIDatPDCP;
+	secondary_meNB_UL_GTP_TEIDatPDCP_t	secondary_meNB_UL_GTP_TEIDatPDCP;
+	rlc_Mode_t	rlc_Mode;
+	uL_Configuration_t	uL_Configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeAdded-SgNBAddReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBAddReq_ItemExtIEs
+{
+	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-RABs-ToBeAdded-SgNBAddReq-Item ::= SEQUENCE {
+	e-RAB-ID								E-RAB-ID,
+	drb-ID								DRB-ID,
+	en-DC-ResourceConfiguration			EN-DC-ResourceConfiguration,
+	resource-configuration				CHOICE {
+		sgNBPDCPpresent						E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresent,
+		sgNBPDCPnotpresent					E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresent,
+		...
+	},
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBAddReq-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBAddReq_Item : asn::sequence<5, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBAddReq-Item";}
+	using parent_t = asn::sequence<5, 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 drb_ID_t : DRB_ID
+	{
+		static constexpr const char* name() {return "drb_ID_t";}
+		using parent_t = DRB_ID;
+
+	};
+	drb_ID_t& ref_drb_ID() {return drb_ID;}
+	drb_ID_t const& ref_drb_ID() const {return drb_ID;}
+	struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
+	{
+		static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
+		using parent_t = EN_DC_ResourceConfiguration;
+
+	};
+	en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
+	en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
+	struct resource_configuration_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "resource_configuration_t";}
+		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);  }
+		~resource_configuration_t() {clear();}
+		struct sgNBPDCPpresent_t : E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPpresent_t";}
+			using parent_t = E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent;
+
+		};
+		struct sgNBPDCPnotpresent_t : E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
+			using parent_t = E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent;
+
+		};
+		void clear()
+		{
+			switch(get_index())
+			{
+			case 1: var.destroy<sgNBPDCPpresent_t>(); break;
+			case 2: var.destroy<sgNBPDCPnotpresent_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<sgNBPDCPpresent_t>());
+			case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			switch(get_index())
+			{
+			case 1: return v(var.as<sgNBPDCPpresent_t>());
+			case 2: return v(var.as<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<sgNBPDCPpresent_t>(1);
+			v.template operator()<sgNBPDCPnotpresent_t>(2);
+
+		}
+		sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
+		sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
+		sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
+		sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
+		private:
+		void set_index(index_type i) {index = i; base::set();}
+		union union_type
+		{
+			char dummy1[sizeof(sgNBPDCPpresent_t)];
+			char dummy2[sizeof(sgNBPDCPnotpresent_t)];
+
+		};
+		asn::variant<sizeof(union_type)>	var;
+		index_type	index {0};
+	};
+	resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
+	resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_ItemExtIEs>;
+		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(drb_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(drb_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		drb_ID.clear();
+		en_DC_ResourceConfiguration.clear();
+		resource_configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	drb_ID_t	drb_ID;
+	en_DC_ResourceConfiguration_t	en_DC_ResourceConfiguration;
+	resource_configuration_t	resource_configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeAdded-SgNBAddReq-ItemIEs	X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeAdded-SgNBAddReq-Item		CRITICALITY reject	TYPE E-RABs-ToBeAdded-SgNBAddReq-Item		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBAddReq_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_RABs_ToBeAdded_SgNBAddReq_Item() { set(id_E_RABs_ToBeAdded_SgNBAddReq_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_RABs_ToBeAdded_SgNBAddReq_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_RABs_ToBeAdded_SgNBAddReq_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_RABs_ToBeAdded_SgNBAddReq_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;}
+		E_RABs_ToBeAdded_SgNBAddReq_Item& select_id_E_RABs_ToBeAdded_SgNBAddReq_Item() { return set<E_RABs_ToBeAdded_SgNBAddReq_Item>(1); }
+		E_RABs_ToBeAdded_SgNBAddReq_Item const* get_id_E_RABs_ToBeAdded_SgNBAddReq_Item() const { return get<E_RABs_ToBeAdded_SgNBAddReq_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeAdded_SgNBAddReq_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeAdded_SgNBAddReq_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeAdded_SgNBAddReq_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_RABs_ToBeAdded_SgNBAddReq_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_RABs_ToBeAdded_SgNBAddReq_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_RABs_ToBeAdded_SgNBAddReq_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-RABs-ToBeAdded-SgNBAddReqList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeAdded-SgNBAddReq-ItemIEs} }
+*/
+
+struct E_RABs_ToBeAdded_SgNBAddReqList_elm : ProtocolIE_Single_Container<E_RABs_ToBeAdded_SgNBAddReq_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeAdded_SgNBAddReqList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeAdded_SgNBAddReq_ItemIEs>;
+
+};
+struct E_RABs_ToBeAdded_SgNBAddReqList : asn::sequenceof<E_RABs_ToBeAdded_SgNBAddReqList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBAddReqList";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeAdded_SgNBAddReqList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-RLCMode-transferred					CRITICALITY ignore	EXTENSION RLCMode					PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresentExtIEs
+{
+	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_RLCMode_transferred() { set(id_RLCMode_transferred); 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_RLCMode_transferred)) { 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_RLCMode_transferred);} 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_RLCMode_transferred() { 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;}
+		RLCMode& select_id_RLCMode_transferred() { return set<RLCMode>(1); }
+		RLCMode const* get_id_RLCMode_transferred() const { return get<RLCMode>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<RLCMode>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<RLCMode>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_RLCMode_transferred()); 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<RLCMode>()); 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(RLCMode)];
+
+		};
+		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_RLCMode_transferred() { 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};
+
+	};
+
+};
+/*
+E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresent ::= SEQUENCE {
+	full-E-RAB-Level-QoS-Parameters			E-RAB-Level-QoS-Parameters,
+	max-MN-admit-E-RAB-Level-QoS-Parameters	GBR-QosInformation															OPTIONAL,
+-- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” and GBR QoS Information IE is present in Full E-RAB Level QoS Parameters IE --
+	dL-Forwarding							DL-Forwarding																		OPTIONAL,
+	meNB-DL-GTP-TEIDatMCG					GTPtunnelEndpoint																	OPTIONAL,
+-- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE is set to “present” --
+	s1-UL-GTPtunnelEndpoint					GTPtunnelEndpoint,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresentExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresent : asn::sequence<6, 0, true, 4>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresent";}
+	using parent_t = asn::sequence<6, 0, true, 4>;
+	struct full_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "full_E_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+
+	};
+	full_E_RAB_Level_QoS_Parameters_t& ref_full_E_RAB_Level_QoS_Parameters() {return full_E_RAB_Level_QoS_Parameters;}
+	full_E_RAB_Level_QoS_Parameters_t const& ref_full_E_RAB_Level_QoS_Parameters() const {return full_E_RAB_Level_QoS_Parameters;}
+	struct max_MN_admit_E_RAB_Level_QoS_Parameters_t : GBR_QosInformation
+	{
+		static constexpr const char* name() {return "max_MN_admit_E_RAB_Level_QoS_Parameters_t";}
+		using parent_t = GBR_QosInformation;
+		static constexpr bool optional = true;
+
+	};
+	max_MN_admit_E_RAB_Level_QoS_Parameters_t& set_max_MN_admit_E_RAB_Level_QoS_Parameters() { max_MN_admit_E_RAB_Level_QoS_Parameters.setpresent(true); return max_MN_admit_E_RAB_Level_QoS_Parameters;}
+	max_MN_admit_E_RAB_Level_QoS_Parameters_t const* get_max_MN_admit_E_RAB_Level_QoS_Parameters() const {return max_MN_admit_E_RAB_Level_QoS_Parameters.is_valid() ? &max_MN_admit_E_RAB_Level_QoS_Parameters : nullptr;}
+	struct dL_Forwarding_t : DL_Forwarding
+	{
+		static constexpr const char* name() {return "dL_Forwarding_t";}
+		using parent_t = DL_Forwarding;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
+	dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
+	struct meNB_DL_GTP_TEIDatMCG_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "meNB_DL_GTP_TEIDatMCG_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	meNB_DL_GTP_TEIDatMCG_t& set_meNB_DL_GTP_TEIDatMCG() { meNB_DL_GTP_TEIDatMCG.setpresent(true); return meNB_DL_GTP_TEIDatMCG;}
+	meNB_DL_GTP_TEIDatMCG_t const* get_meNB_DL_GTP_TEIDatMCG() const {return meNB_DL_GTP_TEIDatMCG.is_valid() ? &meNB_DL_GTP_TEIDatMCG : nullptr;}
+	struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	s1_UL_GTPtunnelEndpoint_t& ref_s1_UL_GTPtunnelEndpoint() {return s1_UL_GTPtunnelEndpoint;}
+	s1_UL_GTPtunnelEndpoint_t const& ref_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresentExtIEs>;
+		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(full_E_RAB_Level_QoS_Parameters);
+		v(max_MN_admit_E_RAB_Level_QoS_Parameters);
+		v(dL_Forwarding);
+		v(meNB_DL_GTP_TEIDatMCG);
+		v(s1_UL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(full_E_RAB_Level_QoS_Parameters);
+		v(max_MN_admit_E_RAB_Level_QoS_Parameters);
+		v(dL_Forwarding);
+		v(meNB_DL_GTP_TEIDatMCG);
+		v(s1_UL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		full_E_RAB_Level_QoS_Parameters.clear();
+		max_MN_admit_E_RAB_Level_QoS_Parameters.clear();
+		dL_Forwarding.clear();
+		meNB_DL_GTP_TEIDatMCG.clear();
+		s1_UL_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	full_E_RAB_Level_QoS_Parameters_t	full_E_RAB_Level_QoS_Parameters;
+	max_MN_admit_E_RAB_Level_QoS_Parameters_t	max_MN_admit_E_RAB_Level_QoS_Parameters;
+	dL_Forwarding_t	dL_Forwarding;
+	meNB_DL_GTP_TEIDatMCG_t	meNB_DL_GTP_TEIDatMCG;
+	s1_UL_GTPtunnelEndpoint_t	s1_UL_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-uLpDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional}|
+	{ ID id-dLPDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional}|
+	{ ID id-duplicationActivation					CRITICALITY ignore	EXTENSION DuplicationActivation	PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs
+{
+	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_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
+		void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
+		void select_id_duplicationActivation() { set(id_duplicationActivation); 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_uLpDCPSnLength)) { type = 1; return true; }
+			else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
+			else if(equal(id_duplicationActivation)) { 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_uLpDCPSnLength);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_duplicationActivation);} 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_uLpDCPSnLength() { set(ignore); type=1;}
+		void select_id_dLPDCPSnLength() { set(ignore); type=2;}
+		void select_id_duplicationActivation() { 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;}
+		PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
+		PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
+		PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
+		PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
+		DuplicationActivation& select_id_duplicationActivation() { return set<DuplicationActivation>(3); }
+		DuplicationActivation const* get_id_duplicationActivation() const { return get<DuplicationActivation>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<PDCPSnLength>(); break;
+			case 2: var.destroy<PDCPSnLength>(); break;
+			case 3: var.destroy<DuplicationActivation>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<PDCPSnLength>(1);
+			v.template operator()<PDCPSnLength>(2);
+			v.template operator()<DuplicationActivation>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_uLpDCPSnLength()); return true;
+			case 2: v(select_id_dLPDCPSnLength()); return true;
+			case 3: v(select_id_duplicationActivation()); 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<PDCPSnLength>()); return true;
+			case 2: v(var.as<PDCPSnLength>()); return true;
+			case 3: v(var.as<DuplicationActivation>()); 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(DuplicationActivation)];
+			char dummy2[sizeof(PDCPSnLength)];
+
+		};
+		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_uLpDCPSnLength() { set(optional); type=1;}
+		void select_id_dLPDCPSnLength() { set(optional); type=2;}
+		void select_id_duplicationActivation() { 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};
+
+	};
+
+};
+/*
+E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
+	requested-SCG-E-RAB-Level-QoS-Parameters		E-RAB-Level-QoS-Parameters,
+	meNB-UL-GTP-TEIDatPDCP							GTPtunnelEndpoint,
+	secondary-meNB-UL-GTP-TEIDatPDCP				GTPtunnelEndpoint		OPTIONAL,
+	rlc-Mode										RLCMode,
+	uL-Configuration								ULConfiguration																OPTIONAL,
+-- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” --
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs} } 		OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresent : asn::sequence<6, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresent";}
+	using parent_t = asn::sequence<6, 0, true, 3>;
+	struct requested_SCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "requested_SCG_E_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+
+	};
+	requested_SCG_E_RAB_Level_QoS_Parameters_t& ref_requested_SCG_E_RAB_Level_QoS_Parameters() {return requested_SCG_E_RAB_Level_QoS_Parameters;}
+	requested_SCG_E_RAB_Level_QoS_Parameters_t const& ref_requested_SCG_E_RAB_Level_QoS_Parameters() const {return requested_SCG_E_RAB_Level_QoS_Parameters;}
+	struct meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "meNB_UL_GTP_TEIDatPDCP_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	meNB_UL_GTP_TEIDatPDCP_t& ref_meNB_UL_GTP_TEIDatPDCP() {return meNB_UL_GTP_TEIDatPDCP;}
+	meNB_UL_GTP_TEIDatPDCP_t const& ref_meNB_UL_GTP_TEIDatPDCP() const {return meNB_UL_GTP_TEIDatPDCP;}
+	struct secondary_meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "secondary_meNB_UL_GTP_TEIDatPDCP_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	secondary_meNB_UL_GTP_TEIDatPDCP_t& set_secondary_meNB_UL_GTP_TEIDatPDCP() { secondary_meNB_UL_GTP_TEIDatPDCP.setpresent(true); return secondary_meNB_UL_GTP_TEIDatPDCP;}
+	secondary_meNB_UL_GTP_TEIDatPDCP_t const* get_secondary_meNB_UL_GTP_TEIDatPDCP() const {return secondary_meNB_UL_GTP_TEIDatPDCP.is_valid() ? &secondary_meNB_UL_GTP_TEIDatPDCP : nullptr;}
+	struct rlc_Mode_t : RLCMode
+	{
+		static constexpr const char* name() {return "rlc_Mode_t";}
+		using parent_t = RLCMode;
+
+	};
+	rlc_Mode_t& ref_rlc_Mode() {return rlc_Mode;}
+	rlc_Mode_t const& ref_rlc_Mode() const {return rlc_Mode;}
+	struct uL_Configuration_t : ULConfiguration
+	{
+		static constexpr const char* name() {return "uL_Configuration_t";}
+		using parent_t = ULConfiguration;
+		static constexpr bool optional = true;
+
+	};
+	uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
+	uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>;
+		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(requested_SCG_E_RAB_Level_QoS_Parameters);
+		v(meNB_UL_GTP_TEIDatPDCP);
+		v(secondary_meNB_UL_GTP_TEIDatPDCP);
+		v(rlc_Mode);
+		v(uL_Configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(requested_SCG_E_RAB_Level_QoS_Parameters);
+		v(meNB_UL_GTP_TEIDatPDCP);
+		v(secondary_meNB_UL_GTP_TEIDatPDCP);
+		v(rlc_Mode);
+		v(uL_Configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		requested_SCG_E_RAB_Level_QoS_Parameters.clear();
+		meNB_UL_GTP_TEIDatPDCP.clear();
+		secondary_meNB_UL_GTP_TEIDatPDCP.clear();
+		rlc_Mode.clear();
+		uL_Configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	requested_SCG_E_RAB_Level_QoS_Parameters_t	requested_SCG_E_RAB_Level_QoS_Parameters;
+	meNB_UL_GTP_TEIDatPDCP_t	meNB_UL_GTP_TEIDatPDCP;
+	secondary_meNB_UL_GTP_TEIDatPDCP_t	secondary_meNB_UL_GTP_TEIDatPDCP;
+	rlc_Mode_t	rlc_Mode;
+	uL_Configuration_t	uL_Configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeAdded-SgNBModReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBModReq_ItemExtIEs
+{
+	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-RABs-ToBeAdded-SgNBModReq-Item ::= SEQUENCE {
+	e-RAB-ID								E-RAB-ID,
+	drb-ID									DRB-ID,
+	en-DC-ResourceConfiguration				EN-DC-ResourceConfiguration,
+	resource-configuration					CHOICE {
+		sgNBPDCPpresent						E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresent,
+		sgNBPDCPnotpresent					E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresent,
+		...
+	},
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBModReq-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBModReq_Item : asn::sequence<5, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBModReq-Item";}
+	using parent_t = asn::sequence<5, 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 drb_ID_t : DRB_ID
+	{
+		static constexpr const char* name() {return "drb_ID_t";}
+		using parent_t = DRB_ID;
+
+	};
+	drb_ID_t& ref_drb_ID() {return drb_ID;}
+	drb_ID_t const& ref_drb_ID() const {return drb_ID;}
+	struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
+	{
+		static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
+		using parent_t = EN_DC_ResourceConfiguration;
+
+	};
+	en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
+	en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
+	struct resource_configuration_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "resource_configuration_t";}
+		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);  }
+		~resource_configuration_t() {clear();}
+		struct sgNBPDCPpresent_t : E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPpresent_t";}
+			using parent_t = E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresent;
+
+		};
+		struct sgNBPDCPnotpresent_t : E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
+			using parent_t = E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresent;
+
+		};
+		void clear()
+		{
+			switch(get_index())
+			{
+			case 1: var.destroy<sgNBPDCPpresent_t>(); break;
+			case 2: var.destroy<sgNBPDCPnotpresent_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<sgNBPDCPpresent_t>());
+			case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			switch(get_index())
+			{
+			case 1: return v(var.as<sgNBPDCPpresent_t>());
+			case 2: return v(var.as<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<sgNBPDCPpresent_t>(1);
+			v.template operator()<sgNBPDCPnotpresent_t>(2);
+
+		}
+		sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
+		sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
+		sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
+		sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
+		private:
+		void set_index(index_type i) {index = i; base::set();}
+		union union_type
+		{
+			char dummy1[sizeof(sgNBPDCPpresent_t)];
+			char dummy2[sizeof(sgNBPDCPnotpresent_t)];
+
+		};
+		asn::variant<sizeof(union_type)>	var;
+		index_type	index {0};
+	};
+	resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
+	resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_ItemExtIEs>;
+		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(drb_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(drb_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		drb_ID.clear();
+		en_DC_ResourceConfiguration.clear();
+		resource_configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	drb_ID_t	drb_ID;
+	en_DC_ResourceConfiguration_t	en_DC_ResourceConfiguration;
+	resource_configuration_t	resource_configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeAdded-SgNBModReq-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeAdded-SgNBModReq-Item		CRITICALITY ignore	TYPE E-RABs-ToBeAdded-SgNBModReq-Item		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeAdded_SgNBModReq_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_RABs_ToBeAdded_SgNBModReq_Item() { set(id_E_RABs_ToBeAdded_SgNBModReq_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_RABs_ToBeAdded_SgNBModReq_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_RABs_ToBeAdded_SgNBModReq_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_RABs_ToBeAdded_SgNBModReq_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_RABs_ToBeAdded_SgNBModReq_Item& select_id_E_RABs_ToBeAdded_SgNBModReq_Item() { return set<E_RABs_ToBeAdded_SgNBModReq_Item>(1); }
+		E_RABs_ToBeAdded_SgNBModReq_Item const* get_id_E_RABs_ToBeAdded_SgNBModReq_Item() const { return get<E_RABs_ToBeAdded_SgNBModReq_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeAdded_SgNBModReq_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeAdded_SgNBModReq_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeAdded_SgNBModReq_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_RABs_ToBeAdded_SgNBModReq_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_RABs_ToBeAdded_SgNBModReq_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_RABs_ToBeAdded_SgNBModReq_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-RABs-ToBeAdded-SgNBModReq-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeAdded-SgNBModReq-ItemIEs} }
+*/
+
+struct E_RABs_ToBeAdded_SgNBModReq_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeAdded_SgNBModReq_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeAdded_SgNBModReq_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeAdded_SgNBModReq_ItemIEs>;
+
+};
+struct E_RABs_ToBeAdded_SgNBModReq_List : asn::sequenceof<E_RABs_ToBeAdded_SgNBModReq_List_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBModReq-List";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeAdded_SgNBModReq_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeModified-ModReqItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_ModReqItem_SCG_BearerExtIEs
+{
+	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-RABs-ToBeModified-ModReqItem-SCG-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	e-RAB-Level-QoS-Parameters		E-RAB-Level-QoS-Parameters														OPTIONAL,
+	s1-UL-GTPtunnelEndpoint			GTPtunnelEndpoint																OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeModified-ModReqItem-SCG-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_ModReqItem_SCG_Bearer : asn::sequence<4, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeModified-ModReqItem-SCG-Bearer";}
+	using parent_t = asn::sequence<4, 0, true, 3>;
+	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 e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+		static constexpr bool optional = true;
+
+	};
+	e_RAB_Level_QoS_Parameters_t& set_e_RAB_Level_QoS_Parameters() { e_RAB_Level_QoS_Parameters.setpresent(true); return e_RAB_Level_QoS_Parameters;}
+	e_RAB_Level_QoS_Parameters_t const* get_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters.is_valid() ? &e_RAB_Level_QoS_Parameters : nullptr;}
+	struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	s1_UL_GTPtunnelEndpoint_t& set_s1_UL_GTPtunnelEndpoint() { s1_UL_GTPtunnelEndpoint.setpresent(true); return s1_UL_GTPtunnelEndpoint;}
+	s1_UL_GTPtunnelEndpoint_t const* get_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint.is_valid() ? &s1_UL_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_ModReqItem_SCG_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_ModReqItem_SCG_BearerExtIEs>;
+		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(e_RAB_Level_QoS_Parameters);
+		v(s1_UL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(e_RAB_Level_QoS_Parameters);
+		v(s1_UL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		e_RAB_Level_QoS_Parameters.clear();
+		s1_UL_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	e_RAB_Level_QoS_Parameters_t	e_RAB_Level_QoS_Parameters;
+	s1_UL_GTPtunnelEndpoint_t	s1_UL_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeModified-ModReqItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_ModReqItem_Split_BearerExtIEs
+{
+	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-RABs-ToBeModified-ModReqItem-Split-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	e-RAB-Level-QoS-Parameters		E-RAB-Level-QoS-Parameters																OPTIONAL,
+	meNB-GTPtunnelEndpoint			GTPtunnelEndpoint																		OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeModified-ModReqItem-Split-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_ModReqItem_Split_Bearer : asn::sequence<4, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeModified-ModReqItem-Split-Bearer";}
+	using parent_t = asn::sequence<4, 0, true, 3>;
+	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 e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+		static constexpr bool optional = true;
+
+	};
+	e_RAB_Level_QoS_Parameters_t& set_e_RAB_Level_QoS_Parameters() { e_RAB_Level_QoS_Parameters.setpresent(true); return e_RAB_Level_QoS_Parameters;}
+	e_RAB_Level_QoS_Parameters_t const* get_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters.is_valid() ? &e_RAB_Level_QoS_Parameters : nullptr;}
+	struct meNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "meNB_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	meNB_GTPtunnelEndpoint_t& set_meNB_GTPtunnelEndpoint() { meNB_GTPtunnelEndpoint.setpresent(true); return meNB_GTPtunnelEndpoint;}
+	meNB_GTPtunnelEndpoint_t const* get_meNB_GTPtunnelEndpoint() const {return meNB_GTPtunnelEndpoint.is_valid() ? &meNB_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_ModReqItem_Split_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_ModReqItem_Split_BearerExtIEs>;
+		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(e_RAB_Level_QoS_Parameters);
+		v(meNB_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(e_RAB_Level_QoS_Parameters);
+		v(meNB_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		e_RAB_Level_QoS_Parameters.clear();
+		meNB_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	e_RAB_Level_QoS_Parameters_t	e_RAB_Level_QoS_Parameters;
+	meNB_GTPtunnelEndpoint_t	meNB_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeModified-ModReqItem ::= CHOICE {
+	sCG-Bearer		E-RABs-ToBeModified-ModReqItem-SCG-Bearer,
+	split-Bearer	E-RABs-ToBeModified-ModReqItem-Split-Bearer,
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_ModReqItem : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeModified-ModReqItem";}
+	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);  }
+	~E_RABs_ToBeModified_ModReqItem() {clear();}
+	struct sCG_Bearer_t : E_RABs_ToBeModified_ModReqItem_SCG_Bearer
+	{
+		static constexpr const char* name() {return "sCG_Bearer_t";}
+		using parent_t = E_RABs_ToBeModified_ModReqItem_SCG_Bearer;
+
+	};
+	struct split_Bearer_t : E_RABs_ToBeModified_ModReqItem_Split_Bearer
+	{
+		static constexpr const char* name() {return "split_Bearer_t";}
+		using parent_t = E_RABs_ToBeModified_ModReqItem_Split_Bearer;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<sCG_Bearer_t>(); break;
+		case 2: var.destroy<split_Bearer_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<sCG_Bearer_t>());
+		case 2: set_index(2); return v(var.build<split_Bearer_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<sCG_Bearer_t>());
+		case 2: return v(var.as<split_Bearer_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<sCG_Bearer_t>(1);
+		v.template operator()<split_Bearer_t>(2);
+
+	}
+	sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
+	sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
+	split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
+	split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(sCG_Bearer_t)];
+		char dummy2[sizeof(split_Bearer_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+E-RABs-ToBeModified-ModReqItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeModified-ModReqItem	CRITICALITY ignore	TYPE E-RABs-ToBeModified-ModReqItem		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_ModReqItemIEs
+{
+	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_RABs_ToBeModified_ModReqItem() { set(id_E_RABs_ToBeModified_ModReqItem); 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_RABs_ToBeModified_ModReqItem)) { 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_RABs_ToBeModified_ModReqItem);} 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_RABs_ToBeModified_ModReqItem() { 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_RABs_ToBeModified_ModReqItem& select_id_E_RABs_ToBeModified_ModReqItem() { return set<E_RABs_ToBeModified_ModReqItem>(1); }
+		E_RABs_ToBeModified_ModReqItem const* get_id_E_RABs_ToBeModified_ModReqItem() const { return get<E_RABs_ToBeModified_ModReqItem>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeModified_ModReqItem>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeModified_ModReqItem>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeModified_ModReqItem()); 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_RABs_ToBeModified_ModReqItem>()); 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_RABs_ToBeModified_ModReqItem)];
+
+		};
+		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_RABs_ToBeModified_ModReqItem() { 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-RABs-ToBeModified-List-ModReq ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeModified-ModReqItemIEs} }
+*/
+
+struct E_RABs_ToBeModified_List_ModReq_elm : ProtocolIE_Single_Container<E_RABs_ToBeModified_ModReqItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeModified_List_ModReq_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeModified_ModReqItemIEs>;
+
+};
+struct E_RABs_ToBeModified_List_ModReq : asn::sequenceof<E_RABs_ToBeModified_List_ModReq_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeModified-List-ModReq";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeModified_List_ModReq_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-RLC-Status			CRITICALITY ignore			EXTENSION RLC-Status				PRESENCE optional },
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresentExtIEs
+{
+	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_RLC_Status() { set(id_RLC_Status); 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_RLC_Status)) { 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_RLC_Status);} 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_RLC_Status() { 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;}
+		RLC_Status& select_id_RLC_Status() { return set<RLC_Status>(1); }
+		RLC_Status const* get_id_RLC_Status() const { return get<RLC_Status>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<RLC_Status>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<RLC_Status>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_RLC_Status()); 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<RLC_Status>()); 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(RLC_Status)];
+
+		};
+		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_RLC_Status() { 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};
+
+	};
+
+};
+/*
+E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresent ::= SEQUENCE {
+	full-E-RAB-Level-QoS-Parameters			E-RAB-Level-QoS-Parameters																		OPTIONAL,
+	max-MN-admit-E-RAB-Level-QoS-Parameters	GBR-QosInformation																		OPTIONAL,
+	meNB-DL-GTP-TEIDatMCG					GTPtunnelEndpoint																				OPTIONAL,
+	s1-UL-GTPtunnelEndpoint					GTPtunnelEndpoint																				OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresentExtIEs} } 	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresent : asn::sequence<5, 0, true, 5>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresent";}
+	using parent_t = asn::sequence<5, 0, true, 5>;
+	struct full_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "full_E_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+		static constexpr bool optional = true;
+
+	};
+	full_E_RAB_Level_QoS_Parameters_t& set_full_E_RAB_Level_QoS_Parameters() { full_E_RAB_Level_QoS_Parameters.setpresent(true); return full_E_RAB_Level_QoS_Parameters;}
+	full_E_RAB_Level_QoS_Parameters_t const* get_full_E_RAB_Level_QoS_Parameters() const {return full_E_RAB_Level_QoS_Parameters.is_valid() ? &full_E_RAB_Level_QoS_Parameters : nullptr;}
+	struct max_MN_admit_E_RAB_Level_QoS_Parameters_t : GBR_QosInformation
+	{
+		static constexpr const char* name() {return "max_MN_admit_E_RAB_Level_QoS_Parameters_t";}
+		using parent_t = GBR_QosInformation;
+		static constexpr bool optional = true;
+
+	};
+	max_MN_admit_E_RAB_Level_QoS_Parameters_t& set_max_MN_admit_E_RAB_Level_QoS_Parameters() { max_MN_admit_E_RAB_Level_QoS_Parameters.setpresent(true); return max_MN_admit_E_RAB_Level_QoS_Parameters;}
+	max_MN_admit_E_RAB_Level_QoS_Parameters_t const* get_max_MN_admit_E_RAB_Level_QoS_Parameters() const {return max_MN_admit_E_RAB_Level_QoS_Parameters.is_valid() ? &max_MN_admit_E_RAB_Level_QoS_Parameters : nullptr;}
+	struct meNB_DL_GTP_TEIDatMCG_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "meNB_DL_GTP_TEIDatMCG_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	meNB_DL_GTP_TEIDatMCG_t& set_meNB_DL_GTP_TEIDatMCG() { meNB_DL_GTP_TEIDatMCG.setpresent(true); return meNB_DL_GTP_TEIDatMCG;}
+	meNB_DL_GTP_TEIDatMCG_t const* get_meNB_DL_GTP_TEIDatMCG() const {return meNB_DL_GTP_TEIDatMCG.is_valid() ? &meNB_DL_GTP_TEIDatMCG : nullptr;}
+	struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	s1_UL_GTPtunnelEndpoint_t& set_s1_UL_GTPtunnelEndpoint() { s1_UL_GTPtunnelEndpoint.setpresent(true); return s1_UL_GTPtunnelEndpoint;}
+	s1_UL_GTPtunnelEndpoint_t const* get_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint.is_valid() ? &s1_UL_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresentExtIEs>;
+		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(full_E_RAB_Level_QoS_Parameters);
+		v(max_MN_admit_E_RAB_Level_QoS_Parameters);
+		v(meNB_DL_GTP_TEIDatMCG);
+		v(s1_UL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(full_E_RAB_Level_QoS_Parameters);
+		v(max_MN_admit_E_RAB_Level_QoS_Parameters);
+		v(meNB_DL_GTP_TEIDatMCG);
+		v(s1_UL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		full_E_RAB_Level_QoS_Parameters.clear();
+		max_MN_admit_E_RAB_Level_QoS_Parameters.clear();
+		meNB_DL_GTP_TEIDatMCG.clear();
+		s1_UL_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	full_E_RAB_Level_QoS_Parameters_t	full_E_RAB_Level_QoS_Parameters;
+	max_MN_admit_E_RAB_Level_QoS_Parameters_t	max_MN_admit_E_RAB_Level_QoS_Parameters;
+	meNB_DL_GTP_TEIDatMCG_t	meNB_DL_GTP_TEIDatMCG;
+	s1_UL_GTPtunnelEndpoint_t	s1_UL_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-uLpDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional}|
+	{ ID id-dLPDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional}|
+	{ ID id-secondarymeNBULGTPTEIDatPDCP				CRITICALITY ignore	EXTENSION GTPtunnelEndpoint			PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs
+{
+	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_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
+		void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
+		void select_id_secondarymeNBULGTPTEIDatPDCP() { set(id_secondarymeNBULGTPTEIDatPDCP); 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_uLpDCPSnLength)) { type = 1; return true; }
+			else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
+			else if(equal(id_secondarymeNBULGTPTEIDatPDCP)) { 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_uLpDCPSnLength);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_secondarymeNBULGTPTEIDatPDCP);} 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_uLpDCPSnLength() { set(ignore); type=1;}
+		void select_id_dLPDCPSnLength() { set(ignore); type=2;}
+		void select_id_secondarymeNBULGTPTEIDatPDCP() { 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;}
+		PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
+		PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
+		PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
+		PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
+		GTPtunnelEndpoint& select_id_secondarymeNBULGTPTEIDatPDCP() { return set<GTPtunnelEndpoint>(3); }
+		GTPtunnelEndpoint const* get_id_secondarymeNBULGTPTEIDatPDCP() const { return get<GTPtunnelEndpoint>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<PDCPSnLength>(); break;
+			case 2: var.destroy<PDCPSnLength>(); break;
+			case 3: var.destroy<GTPtunnelEndpoint>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<PDCPSnLength>(1);
+			v.template operator()<PDCPSnLength>(2);
+			v.template operator()<GTPtunnelEndpoint>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_uLpDCPSnLength()); return true;
+			case 2: v(select_id_dLPDCPSnLength()); return true;
+			case 3: v(select_id_secondarymeNBULGTPTEIDatPDCP()); 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<PDCPSnLength>()); return true;
+			case 2: v(var.as<PDCPSnLength>()); return true;
+			case 3: v(var.as<GTPtunnelEndpoint>()); 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(GTPtunnelEndpoint)];
+			char dummy2[sizeof(PDCPSnLength)];
+
+		};
+		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_uLpDCPSnLength() { set(optional); type=1;}
+		void select_id_dLPDCPSnLength() { set(optional); type=2;}
+		void select_id_secondarymeNBULGTPTEIDatPDCP() { 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};
+
+	};
+
+};
+/*
+E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
+	requested-SCG-E-RAB-Level-QoS-Parameters		E-RAB-Level-QoS-Parameters																			OPTIONAL,
+	meNB-UL-GTP-TEIDatPDCP						GTPtunnelEndpoint																					OPTIONAL,
+	uL-Configuration								ULConfiguration																						OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs} } 	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresent : asn::sequence<4, 0, true, 4>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresent";}
+	using parent_t = asn::sequence<4, 0, true, 4>;
+	struct requested_SCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "requested_SCG_E_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+		static constexpr bool optional = true;
+
+	};
+	requested_SCG_E_RAB_Level_QoS_Parameters_t& set_requested_SCG_E_RAB_Level_QoS_Parameters() { requested_SCG_E_RAB_Level_QoS_Parameters.setpresent(true); return requested_SCG_E_RAB_Level_QoS_Parameters;}
+	requested_SCG_E_RAB_Level_QoS_Parameters_t const* get_requested_SCG_E_RAB_Level_QoS_Parameters() const {return requested_SCG_E_RAB_Level_QoS_Parameters.is_valid() ? &requested_SCG_E_RAB_Level_QoS_Parameters : nullptr;}
+	struct meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "meNB_UL_GTP_TEIDatPDCP_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	meNB_UL_GTP_TEIDatPDCP_t& set_meNB_UL_GTP_TEIDatPDCP() { meNB_UL_GTP_TEIDatPDCP.setpresent(true); return meNB_UL_GTP_TEIDatPDCP;}
+	meNB_UL_GTP_TEIDatPDCP_t const* get_meNB_UL_GTP_TEIDatPDCP() const {return meNB_UL_GTP_TEIDatPDCP.is_valid() ? &meNB_UL_GTP_TEIDatPDCP : nullptr;}
+	struct uL_Configuration_t : ULConfiguration
+	{
+		static constexpr const char* name() {return "uL_Configuration_t";}
+		using parent_t = ULConfiguration;
+		static constexpr bool optional = true;
+
+	};
+	uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
+	uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>;
+		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(requested_SCG_E_RAB_Level_QoS_Parameters);
+		v(meNB_UL_GTP_TEIDatPDCP);
+		v(uL_Configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(requested_SCG_E_RAB_Level_QoS_Parameters);
+		v(meNB_UL_GTP_TEIDatPDCP);
+		v(uL_Configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		requested_SCG_E_RAB_Level_QoS_Parameters.clear();
+		meNB_UL_GTP_TEIDatPDCP.clear();
+		uL_Configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	requested_SCG_E_RAB_Level_QoS_Parameters_t	requested_SCG_E_RAB_Level_QoS_Parameters;
+	meNB_UL_GTP_TEIDatPDCP_t	meNB_UL_GTP_TEIDatPDCP;
+	uL_Configuration_t	uL_Configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeModified-SgNBModReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReq_ItemExtIEs
+{
+	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-RABs-ToBeModified-SgNBModReq-Item ::= SEQUENCE {
+	e-RAB-ID								E-RAB-ID,
+	en-DC-ResourceConfiguration			EN-DC-ResourceConfiguration,
+	resource-configuration				CHOICE {
+		sgNBPDCPpresent						E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresent,
+		sgNBPDCPnotpresent					E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresent,
+		...
+	},
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReq-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReq_Item : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReq-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 en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
+	{
+		static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
+		using parent_t = EN_DC_ResourceConfiguration;
+
+	};
+	en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
+	en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
+	struct resource_configuration_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "resource_configuration_t";}
+		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);  }
+		~resource_configuration_t() {clear();}
+		struct sgNBPDCPpresent_t : E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPpresent_t";}
+			using parent_t = E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresent;
+
+		};
+		struct sgNBPDCPnotpresent_t : E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
+			using parent_t = E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresent;
+
+		};
+		void clear()
+		{
+			switch(get_index())
+			{
+			case 1: var.destroy<sgNBPDCPpresent_t>(); break;
+			case 2: var.destroy<sgNBPDCPnotpresent_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<sgNBPDCPpresent_t>());
+			case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			switch(get_index())
+			{
+			case 1: return v(var.as<sgNBPDCPpresent_t>());
+			case 2: return v(var.as<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<sgNBPDCPpresent_t>(1);
+			v.template operator()<sgNBPDCPnotpresent_t>(2);
+
+		}
+		sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
+		sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
+		sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
+		sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
+		private:
+		void set_index(index_type i) {index = i; base::set();}
+		union union_type
+		{
+			char dummy1[sizeof(sgNBPDCPpresent_t)];
+			char dummy2[sizeof(sgNBPDCPnotpresent_t)];
+
+		};
+		asn::variant<sizeof(union_type)>	var;
+		index_type	index {0};
+	};
+	resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
+	resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_ItemExtIEs>;
+		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(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		en_DC_ResourceConfiguration.clear();
+		resource_configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	en_DC_ResourceConfiguration_t	en_DC_ResourceConfiguration;
+	resource_configuration_t	resource_configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeModified-SgNBModReq-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeModified-SgNBModReq-Item	CRITICALITY ignore	TYPE E-RABs-ToBeModified-SgNBModReq-Item		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReq_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_RABs_ToBeModified_SgNBModReq_Item() { set(id_E_RABs_ToBeModified_SgNBModReq_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_RABs_ToBeModified_SgNBModReq_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_RABs_ToBeModified_SgNBModReq_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_RABs_ToBeModified_SgNBModReq_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_RABs_ToBeModified_SgNBModReq_Item& select_id_E_RABs_ToBeModified_SgNBModReq_Item() { return set<E_RABs_ToBeModified_SgNBModReq_Item>(1); }
+		E_RABs_ToBeModified_SgNBModReq_Item const* get_id_E_RABs_ToBeModified_SgNBModReq_Item() const { return get<E_RABs_ToBeModified_SgNBModReq_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeModified_SgNBModReq_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeModified_SgNBModReq_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeModified_SgNBModReq_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_RABs_ToBeModified_SgNBModReq_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_RABs_ToBeModified_SgNBModReq_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_RABs_ToBeModified_SgNBModReq_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-RABs-ToBeModified-SgNBModReq-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeModified-SgNBModReq-ItemIEs} }
+*/
+
+struct E_RABs_ToBeModified_SgNBModReq_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeModified_SgNBModReq_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeModified_SgNBModReq_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeModified_SgNBModReq_ItemIEs>;
+
+};
+struct E_RABs_ToBeModified_SgNBModReq_List : asn::sequenceof<E_RABs_ToBeModified_SgNBModReq_List_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReq-List";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeModified_SgNBModReq_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-uLpDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional}|
+	{ ID id-dLPDCPSnLength							CRITICALITY ignore	EXTENSION PDCPSnLength					PRESENCE optional}|
+	{ ID id-new-drb-ID-req							CRITICALITY ignore	EXTENSION NewDRBIDrequest				PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresentExtIEs
+{
+	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_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
+		void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
+		void select_id_new_drb_ID_req() { set(id_new_drb_ID_req); 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_uLpDCPSnLength)) { type = 1; return true; }
+			else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
+			else if(equal(id_new_drb_ID_req)) { 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_uLpDCPSnLength);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_new_drb_ID_req);} 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_uLpDCPSnLength() { set(ignore); type=1;}
+		void select_id_dLPDCPSnLength() { set(ignore); type=2;}
+		void select_id_new_drb_ID_req() { 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;}
+		PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
+		PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
+		PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
+		PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
+		NewDRBIDrequest& select_id_new_drb_ID_req() { return set<NewDRBIDrequest>(3); }
+		NewDRBIDrequest const* get_id_new_drb_ID_req() const { return get<NewDRBIDrequest>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<PDCPSnLength>(); break;
+			case 2: var.destroy<PDCPSnLength>(); break;
+			case 3: var.destroy<NewDRBIDrequest>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<PDCPSnLength>(1);
+			v.template operator()<PDCPSnLength>(2);
+			v.template operator()<NewDRBIDrequest>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_uLpDCPSnLength()); return true;
+			case 2: v(select_id_dLPDCPSnLength()); return true;
+			case 3: v(select_id_new_drb_ID_req()); 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<PDCPSnLength>()); return true;
+			case 2: v(var.as<PDCPSnLength>()); return true;
+			case 3: v(var.as<NewDRBIDrequest>()); 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(NewDRBIDrequest)];
+			char dummy2[sizeof(PDCPSnLength)];
+
+		};
+		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_uLpDCPSnLength() { set(optional); type=1;}
+		void select_id_dLPDCPSnLength() { set(optional); type=2;}
+		void select_id_new_drb_ID_req() { 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};
+
+	};
+
+};
+/*
+E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresent ::= SEQUENCE {
+	requested-MCG-E-RAB-Level-QoS-Parameters		E-RAB-Level-QoS-Parameters													OPTIONAL,
+	uL-Configuration								ULConfiguration																OPTIONAL,
+	sgNB-UL-GTP-TEIDatPDCP						GTPtunnelEndpoint															OPTIONAL,
+	s1-DL-GTP-TEIDatSgNB							GTPtunnelEndpoint															OPTIONAL,
+	iE-Extensions				ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresentExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresent : asn::sequence<5, 0, true, 5>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresent";}
+	using parent_t = asn::sequence<5, 0, true, 5>;
+	struct requested_MCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "requested_MCG_E_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+		static constexpr bool optional = true;
+
+	};
+	requested_MCG_E_RAB_Level_QoS_Parameters_t& set_requested_MCG_E_RAB_Level_QoS_Parameters() { requested_MCG_E_RAB_Level_QoS_Parameters.setpresent(true); return requested_MCG_E_RAB_Level_QoS_Parameters;}
+	requested_MCG_E_RAB_Level_QoS_Parameters_t const* get_requested_MCG_E_RAB_Level_QoS_Parameters() const {return requested_MCG_E_RAB_Level_QoS_Parameters.is_valid() ? &requested_MCG_E_RAB_Level_QoS_Parameters : nullptr;}
+	struct uL_Configuration_t : ULConfiguration
+	{
+		static constexpr const char* name() {return "uL_Configuration_t";}
+		using parent_t = ULConfiguration;
+		static constexpr bool optional = true;
+
+	};
+	uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
+	uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
+	struct sgNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "sgNB_UL_GTP_TEIDatPDCP_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	sgNB_UL_GTP_TEIDatPDCP_t& set_sgNB_UL_GTP_TEIDatPDCP() { sgNB_UL_GTP_TEIDatPDCP.setpresent(true); return sgNB_UL_GTP_TEIDatPDCP;}
+	sgNB_UL_GTP_TEIDatPDCP_t const* get_sgNB_UL_GTP_TEIDatPDCP() const {return sgNB_UL_GTP_TEIDatPDCP.is_valid() ? &sgNB_UL_GTP_TEIDatPDCP : nullptr;}
+	struct s1_DL_GTP_TEIDatSgNB_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "s1_DL_GTP_TEIDatSgNB_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	s1_DL_GTP_TEIDatSgNB_t& set_s1_DL_GTP_TEIDatSgNB() { s1_DL_GTP_TEIDatSgNB.setpresent(true); return s1_DL_GTP_TEIDatSgNB;}
+	s1_DL_GTP_TEIDatSgNB_t const* get_s1_DL_GTP_TEIDatSgNB() const {return s1_DL_GTP_TEIDatSgNB.is_valid() ? &s1_DL_GTP_TEIDatSgNB : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresentExtIEs>;
+		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(requested_MCG_E_RAB_Level_QoS_Parameters);
+		v(uL_Configuration);
+		v(sgNB_UL_GTP_TEIDatPDCP);
+		v(s1_DL_GTP_TEIDatSgNB);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(requested_MCG_E_RAB_Level_QoS_Parameters);
+		v(uL_Configuration);
+		v(sgNB_UL_GTP_TEIDatPDCP);
+		v(s1_DL_GTP_TEIDatSgNB);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		requested_MCG_E_RAB_Level_QoS_Parameters.clear();
+		uL_Configuration.clear();
+		sgNB_UL_GTP_TEIDatPDCP.clear();
+		s1_DL_GTP_TEIDatSgNB.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	requested_MCG_E_RAB_Level_QoS_Parameters_t	requested_MCG_E_RAB_Level_QoS_Parameters;
+	uL_Configuration_t	uL_Configuration;
+	sgNB_UL_GTP_TEIDatPDCP_t	sgNB_UL_GTP_TEIDatPDCP;
+	s1_DL_GTP_TEIDatSgNB_t	s1_DL_GTP_TEIDatSgNB;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-RLC-Status			CRITICALITY ignore			EXTENSION RLC-Status				PRESENCE optional}|
+	{ ID id-lCID				CRITICALITY ignore			EXTENSION LCID						PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresentExtIEs
+{
+	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_RLC_Status() { set(id_RLC_Status); type=1;}
+		void select_id_lCID() { set(id_lCID); 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_RLC_Status)) { type = 1; return true; }
+			else if(equal(id_lCID)) { 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_RLC_Status);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_lCID);} 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_RLC_Status() { set(ignore); type=1;}
+		void select_id_lCID() { 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;}
+		RLC_Status& select_id_RLC_Status() { return set<RLC_Status>(1); }
+		RLC_Status const* get_id_RLC_Status() const { return get<RLC_Status>(1); }
+		LCID& select_id_lCID() { return set<LCID>(2); }
+		LCID const* get_id_lCID() const { return get<LCID>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<RLC_Status>(); break;
+			case 2: var.destroy<LCID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<RLC_Status>(1);
+			v.template operator()<LCID>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_RLC_Status()); return true;
+			case 2: v(select_id_lCID()); 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<RLC_Status>()); return true;
+			case 2: v(var.as<LCID>()); 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(LCID)];
+			char dummy2[sizeof(RLC_Status)];
+
+		};
+		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_RLC_Status() { set(optional); type=1;}
+		void select_id_lCID() { 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-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresent ::= SEQUENCE {
+	sgNB-DL-GTP-TEIDatSCG				GTPtunnelEndpoint				OPTIONAL,
+	secondary-sgNB-DL-GTP-TEIDatSCG		GTPtunnelEndpoint				OPTIONAL,
+	iE-Extensions				ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresentExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresent : asn::sequence<3, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresent";}
+	using parent_t = asn::sequence<3, 0, true, 3>;
+	struct sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "sgNB_DL_GTP_TEIDatSCG_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	sgNB_DL_GTP_TEIDatSCG_t& set_sgNB_DL_GTP_TEIDatSCG() { sgNB_DL_GTP_TEIDatSCG.setpresent(true); return sgNB_DL_GTP_TEIDatSCG;}
+	sgNB_DL_GTP_TEIDatSCG_t const* get_sgNB_DL_GTP_TEIDatSCG() const {return sgNB_DL_GTP_TEIDatSCG.is_valid() ? &sgNB_DL_GTP_TEIDatSCG : nullptr;}
+	struct secondary_sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "secondary_sgNB_DL_GTP_TEIDatSCG_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	secondary_sgNB_DL_GTP_TEIDatSCG_t& set_secondary_sgNB_DL_GTP_TEIDatSCG() { secondary_sgNB_DL_GTP_TEIDatSCG.setpresent(true); return secondary_sgNB_DL_GTP_TEIDatSCG;}
+	secondary_sgNB_DL_GTP_TEIDatSCG_t const* get_secondary_sgNB_DL_GTP_TEIDatSCG() const {return secondary_sgNB_DL_GTP_TEIDatSCG.is_valid() ? &secondary_sgNB_DL_GTP_TEIDatSCG : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresentExtIEs>;
+		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(sgNB_DL_GTP_TEIDatSCG);
+		v(secondary_sgNB_DL_GTP_TEIDatSCG);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(sgNB_DL_GTP_TEIDatSCG);
+		v(secondary_sgNB_DL_GTP_TEIDatSCG);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		sgNB_DL_GTP_TEIDatSCG.clear();
+		secondary_sgNB_DL_GTP_TEIDatSCG.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	sgNB_DL_GTP_TEIDatSCG_t	sgNB_DL_GTP_TEIDatSCG;
+	secondary_sgNB_DL_GTP_TEIDatSCG_t	secondary_sgNB_DL_GTP_TEIDatSCG;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeModified-SgNBModReqd-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReqd_ItemExtIEs
+{
+	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-RABs-ToBeModified-SgNBModReqd-Item ::= SEQUENCE {
+	e-RAB-ID								E-RAB-ID,
+	en-DC-ResourceConfiguration			EN-DC-ResourceConfiguration,
+	resource-configuration				CHOICE {
+		sgNBPDCPpresent						E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresent,
+		sgNBPDCPnotpresent					E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresent,
+		...
+	},
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReqd-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReqd_Item : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReqd-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 en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
+	{
+		static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
+		using parent_t = EN_DC_ResourceConfiguration;
+
+	};
+	en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
+	en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
+	struct resource_configuration_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "resource_configuration_t";}
+		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);  }
+		~resource_configuration_t() {clear();}
+		struct sgNBPDCPpresent_t : E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPpresent_t";}
+			using parent_t = E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresent;
+
+		};
+		struct sgNBPDCPnotpresent_t : E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
+			using parent_t = E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresent;
+
+		};
+		void clear()
+		{
+			switch(get_index())
+			{
+			case 1: var.destroy<sgNBPDCPpresent_t>(); break;
+			case 2: var.destroy<sgNBPDCPnotpresent_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<sgNBPDCPpresent_t>());
+			case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			switch(get_index())
+			{
+			case 1: return v(var.as<sgNBPDCPpresent_t>());
+			case 2: return v(var.as<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<sgNBPDCPpresent_t>(1);
+			v.template operator()<sgNBPDCPnotpresent_t>(2);
+
+		}
+		sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
+		sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
+		sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
+		sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
+		private:
+		void set_index(index_type i) {index = i; base::set();}
+		union union_type
+		{
+			char dummy1[sizeof(sgNBPDCPpresent_t)];
+			char dummy2[sizeof(sgNBPDCPnotpresent_t)];
+
+		};
+		asn::variant<sizeof(union_type)>	var;
+		index_type	index {0};
+	};
+	resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
+	resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_ItemExtIEs>;
+		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(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		en_DC_ResourceConfiguration.clear();
+		resource_configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	en_DC_ResourceConfiguration_t	en_DC_ResourceConfiguration;
+	resource_configuration_t	resource_configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeModified-SgNBModReqd-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeModified-SgNBModReqd-Item	 CRITICALITY ignore		TYPE E-RABs-ToBeModified-SgNBModReqd-Item		PRESENCE mandatory },
+	...
+}
+*/
+
+struct E_RABs_ToBeModified_SgNBModReqd_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_RABs_ToBeModified_SgNBModReqd_Item() { set(id_E_RABs_ToBeModified_SgNBModReqd_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_RABs_ToBeModified_SgNBModReqd_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_RABs_ToBeModified_SgNBModReqd_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_RABs_ToBeModified_SgNBModReqd_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_RABs_ToBeModified_SgNBModReqd_Item& select_id_E_RABs_ToBeModified_SgNBModReqd_Item() { return set<E_RABs_ToBeModified_SgNBModReqd_Item>(1); }
+		E_RABs_ToBeModified_SgNBModReqd_Item const* get_id_E_RABs_ToBeModified_SgNBModReqd_Item() const { return get<E_RABs_ToBeModified_SgNBModReqd_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeModified_SgNBModReqd_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeModified_SgNBModReqd_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeModified_SgNBModReqd_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_RABs_ToBeModified_SgNBModReqd_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_RABs_ToBeModified_SgNBModReqd_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_RABs_ToBeModified_SgNBModReqd_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-RABs-ToBeModified-SgNBModReqdList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeModified-SgNBModReqd-ItemIEs} }
+*/
+
+struct E_RABs_ToBeModified_SgNBModReqdList_elm : ProtocolIE_Single_Container<E_RABs_ToBeModified_SgNBModReqd_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeModified_SgNBModReqdList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeModified_SgNBModReqd_ItemIEs>;
+
+};
+struct E_RABs_ToBeModified_SgNBModReqdList : asn::sequenceof<E_RABs_ToBeModified_SgNBModReqdList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReqdList";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeModified_SgNBModReqdList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeReleased-ModReqItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_ModReqItem_SCG_BearerExtIEs
+{
+	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-RABs-ToBeReleased-ModReqItem-SCG-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	dL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint												OPTIONAL,
+	uL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint												OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-ModReqItem-SCG-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_ModReqItem_SCG_Bearer : asn::sequence<4, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqItem-SCG-Bearer";}
+	using parent_t = asn::sequence<4, 0, true, 3>;
+	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 dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
+	dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
+	uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqItem_SCG_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqItem_SCG_BearerExtIEs>;
+		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(dL_Forwarding_GTPtunnelEndpoint);
+		v(uL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(uL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		dL_Forwarding_GTPtunnelEndpoint.clear();
+		uL_Forwarding_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	dL_Forwarding_GTPtunnelEndpoint_t	dL_Forwarding_GTPtunnelEndpoint;
+	uL_Forwarding_GTPtunnelEndpoint_t	uL_Forwarding_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-ModReqItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_ModReqItem_Split_BearerExtIEs
+{
+	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-RABs-ToBeReleased-ModReqItem-Split-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	dL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint												OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-ModReqItem-Split-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_ModReqItem_Split_Bearer : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqItem-Split-Bearer";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	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 dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
+	dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqItem_Split_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqItem_Split_BearerExtIEs>;
+		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(dL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		dL_Forwarding_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	dL_Forwarding_GTPtunnelEndpoint_t	dL_Forwarding_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-ModReqItem ::= CHOICE {
+	sCG-Bearer		E-RABs-ToBeReleased-ModReqItem-SCG-Bearer,
+	split-Bearer	E-RABs-ToBeReleased-ModReqItem-Split-Bearer,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_ModReqItem : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqItem";}
+	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);  }
+	~E_RABs_ToBeReleased_ModReqItem() {clear();}
+	struct sCG_Bearer_t : E_RABs_ToBeReleased_ModReqItem_SCG_Bearer
+	{
+		static constexpr const char* name() {return "sCG_Bearer_t";}
+		using parent_t = E_RABs_ToBeReleased_ModReqItem_SCG_Bearer;
+
+	};
+	struct split_Bearer_t : E_RABs_ToBeReleased_ModReqItem_Split_Bearer
+	{
+		static constexpr const char* name() {return "split_Bearer_t";}
+		using parent_t = E_RABs_ToBeReleased_ModReqItem_Split_Bearer;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<sCG_Bearer_t>(); break;
+		case 2: var.destroy<split_Bearer_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<sCG_Bearer_t>());
+		case 2: set_index(2); return v(var.build<split_Bearer_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<sCG_Bearer_t>());
+		case 2: return v(var.as<split_Bearer_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<sCG_Bearer_t>(1);
+		v.template operator()<split_Bearer_t>(2);
+
+	}
+	sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
+	sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
+	split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
+	split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(sCG_Bearer_t)];
+		char dummy2[sizeof(split_Bearer_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+E-RABs-ToBeReleased-ModReqItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeReleased-ModReqItem	CRITICALITY ignore	TYPE E-RABs-ToBeReleased-ModReqItem		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_ModReqItemIEs
+{
+	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_RABs_ToBeReleased_ModReqItem() { set(id_E_RABs_ToBeReleased_ModReqItem); 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_RABs_ToBeReleased_ModReqItem)) { 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_RABs_ToBeReleased_ModReqItem);} 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_RABs_ToBeReleased_ModReqItem() { 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_RABs_ToBeReleased_ModReqItem& select_id_E_RABs_ToBeReleased_ModReqItem() { return set<E_RABs_ToBeReleased_ModReqItem>(1); }
+		E_RABs_ToBeReleased_ModReqItem const* get_id_E_RABs_ToBeReleased_ModReqItem() const { return get<E_RABs_ToBeReleased_ModReqItem>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeReleased_ModReqItem>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeReleased_ModReqItem>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeReleased_ModReqItem()); 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_RABs_ToBeReleased_ModReqItem>()); 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_RABs_ToBeReleased_ModReqItem)];
+
+		};
+		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_RABs_ToBeReleased_ModReqItem() { 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-RABs-ToBeReleased-List-ModReq ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-ModReqItemIEs} }
+*/
+
+struct E_RABs_ToBeReleased_List_ModReq_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_ModReqItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeReleased_List_ModReq_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_ModReqItemIEs>;
+
+};
+struct E_RABs_ToBeReleased_List_ModReq : asn::sequenceof<E_RABs_ToBeReleased_List_ModReq_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-List-ModReq";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeReleased_List_ModReq_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeReleased-RelConfItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_RelConfItem_SCG_BearerExtIEs
+{
+	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-RABs-ToBeReleased-RelConfItem-SCG-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	uL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint												OPTIONAL,
+	dL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint												OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-RelConfItem-SCG-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_RelConfItem_SCG_Bearer : asn::sequence<4, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-RelConfItem-SCG-Bearer";}
+	using parent_t = asn::sequence<4, 0, true, 3>;
+	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 uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
+	uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
+	dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_RelConfItem_SCG_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_RelConfItem_SCG_BearerExtIEs>;
+		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(uL_Forwarding_GTPtunnelEndpoint);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(uL_Forwarding_GTPtunnelEndpoint);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		uL_Forwarding_GTPtunnelEndpoint.clear();
+		dL_Forwarding_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	uL_Forwarding_GTPtunnelEndpoint_t	uL_Forwarding_GTPtunnelEndpoint;
+	dL_Forwarding_GTPtunnelEndpoint_t	dL_Forwarding_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-RelConfItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_RelConfItem_Split_BearerExtIEs
+{
+	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-RABs-ToBeReleased-RelConfItem-Split-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	dL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint													OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-RelConfItem-Split-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_RelConfItem_Split_Bearer : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-RelConfItem-Split-Bearer";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	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 dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
+	dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_RelConfItem_Split_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_RelConfItem_Split_BearerExtIEs>;
+		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(dL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		dL_Forwarding_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	dL_Forwarding_GTPtunnelEndpoint_t	dL_Forwarding_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-RelConfItem ::= CHOICE {
+	sCG-Bearer		E-RABs-ToBeReleased-RelConfItem-SCG-Bearer,
+	split-Bearer	E-RABs-ToBeReleased-RelConfItem-Split-Bearer,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_RelConfItem : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-RelConfItem";}
+	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);  }
+	~E_RABs_ToBeReleased_RelConfItem() {clear();}
+	struct sCG_Bearer_t : E_RABs_ToBeReleased_RelConfItem_SCG_Bearer
+	{
+		static constexpr const char* name() {return "sCG_Bearer_t";}
+		using parent_t = E_RABs_ToBeReleased_RelConfItem_SCG_Bearer;
+
+	};
+	struct split_Bearer_t : E_RABs_ToBeReleased_RelConfItem_Split_Bearer
+	{
+		static constexpr const char* name() {return "split_Bearer_t";}
+		using parent_t = E_RABs_ToBeReleased_RelConfItem_Split_Bearer;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<sCG_Bearer_t>(); break;
+		case 2: var.destroy<split_Bearer_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<sCG_Bearer_t>());
+		case 2: set_index(2); return v(var.build<split_Bearer_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<sCG_Bearer_t>());
+		case 2: return v(var.as<split_Bearer_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<sCG_Bearer_t>(1);
+		v.template operator()<split_Bearer_t>(2);
+
+	}
+	sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
+	sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
+	split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
+	split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(sCG_Bearer_t)];
+		char dummy2[sizeof(split_Bearer_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+E-RABs-ToBeReleased-RelConfItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeReleased-RelConfItem		CRITICALITY ignore		TYPE E-RABs-ToBeReleased-RelConfItem		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_RelConfItemIEs
+{
+	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_RABs_ToBeReleased_RelConfItem() { set(id_E_RABs_ToBeReleased_RelConfItem); 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_RABs_ToBeReleased_RelConfItem)) { 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_RABs_ToBeReleased_RelConfItem);} 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_RABs_ToBeReleased_RelConfItem() { 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_RABs_ToBeReleased_RelConfItem& select_id_E_RABs_ToBeReleased_RelConfItem() { return set<E_RABs_ToBeReleased_RelConfItem>(1); }
+		E_RABs_ToBeReleased_RelConfItem const* get_id_E_RABs_ToBeReleased_RelConfItem() const { return get<E_RABs_ToBeReleased_RelConfItem>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeReleased_RelConfItem>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeReleased_RelConfItem>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeReleased_RelConfItem()); 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_RABs_ToBeReleased_RelConfItem>()); 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_RABs_ToBeReleased_RelConfItem)];
+
+		};
+		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_RABs_ToBeReleased_RelConfItem() { 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-RABs-ToBeReleased-List-RelConf ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-RelConfItemIEs} }
+*/
+
+struct E_RABs_ToBeReleased_List_RelConf_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_RelConfItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeReleased_List_RelConf_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_RelConfItemIEs>;
+
+};
+struct E_RABs_ToBeReleased_List_RelConf : asn::sequenceof<E_RABs_ToBeReleased_List_RelConf_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-List-RelConf";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeReleased_List_RelConf_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeReleased-RelReqItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_RelReqItem_SCG_BearerExtIEs
+{
+	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-RABs-ToBeReleased-RelReqItem-SCG-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	uL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint												OPTIONAL,
+	dL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint												OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-RelReqItem-SCG-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_RelReqItem_SCG_Bearer : asn::sequence<4, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-RelReqItem-SCG-Bearer";}
+	using parent_t = asn::sequence<4, 0, true, 3>;
+	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 uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
+	uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
+	dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_RelReqItem_SCG_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_RelReqItem_SCG_BearerExtIEs>;
+		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(uL_Forwarding_GTPtunnelEndpoint);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(uL_Forwarding_GTPtunnelEndpoint);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		uL_Forwarding_GTPtunnelEndpoint.clear();
+		dL_Forwarding_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	uL_Forwarding_GTPtunnelEndpoint_t	uL_Forwarding_GTPtunnelEndpoint;
+	dL_Forwarding_GTPtunnelEndpoint_t	dL_Forwarding_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-RelReqItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_RelReqItem_Split_BearerExtIEs
+{
+	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-RABs-ToBeReleased-RelReqItem-Split-Bearer ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	dL-Forwarding-GTPtunnelEndpoint			GTPtunnelEndpoint													OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-RelReqItem-Split-BearerExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_RelReqItem_Split_Bearer : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-RelReqItem-Split-Bearer";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	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 dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
+	dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_RelReqItem_Split_BearerExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_RelReqItem_Split_BearerExtIEs>;
+		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(dL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(dL_Forwarding_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		dL_Forwarding_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	dL_Forwarding_GTPtunnelEndpoint_t	dL_Forwarding_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-RelReqItem ::= CHOICE {
+	sCG-Bearer		E-RABs-ToBeReleased-RelReqItem-SCG-Bearer,
+	split-Bearer	E-RABs-ToBeReleased-RelReqItem-Split-Bearer,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_RelReqItem : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-RelReqItem";}
+	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);  }
+	~E_RABs_ToBeReleased_RelReqItem() {clear();}
+	struct sCG_Bearer_t : E_RABs_ToBeReleased_RelReqItem_SCG_Bearer
+	{
+		static constexpr const char* name() {return "sCG_Bearer_t";}
+		using parent_t = E_RABs_ToBeReleased_RelReqItem_SCG_Bearer;
+
+	};
+	struct split_Bearer_t : E_RABs_ToBeReleased_RelReqItem_Split_Bearer
+	{
+		static constexpr const char* name() {return "split_Bearer_t";}
+		using parent_t = E_RABs_ToBeReleased_RelReqItem_Split_Bearer;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<sCG_Bearer_t>(); break;
+		case 2: var.destroy<split_Bearer_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<sCG_Bearer_t>());
+		case 2: set_index(2); return v(var.build<split_Bearer_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<sCG_Bearer_t>());
+		case 2: return v(var.as<split_Bearer_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<sCG_Bearer_t>(1);
+		v.template operator()<split_Bearer_t>(2);
+
+	}
+	sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
+	sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
+	split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
+	split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(sCG_Bearer_t)];
+		char dummy2[sizeof(split_Bearer_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+E-RABs-ToBeReleased-RelReqItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeReleased-RelReqItem		CRITICALITY ignore	TYPE E-RABs-ToBeReleased-RelReqItem		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_RelReqItemIEs
+{
+	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_RABs_ToBeReleased_RelReqItem() { set(id_E_RABs_ToBeReleased_RelReqItem); 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_RABs_ToBeReleased_RelReqItem)) { 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_RABs_ToBeReleased_RelReqItem);} 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_RABs_ToBeReleased_RelReqItem() { 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_RABs_ToBeReleased_RelReqItem& select_id_E_RABs_ToBeReleased_RelReqItem() { return set<E_RABs_ToBeReleased_RelReqItem>(1); }
+		E_RABs_ToBeReleased_RelReqItem const* get_id_E_RABs_ToBeReleased_RelReqItem() const { return get<E_RABs_ToBeReleased_RelReqItem>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeReleased_RelReqItem>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeReleased_RelReqItem>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeReleased_RelReqItem()); 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_RABs_ToBeReleased_RelReqItem>()); 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_RABs_ToBeReleased_RelReqItem)];
+
+		};
+		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_RABs_ToBeReleased_RelReqItem() { 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-RABs-ToBeReleased-List-RelReq ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-RelReqItemIEs} }
+*/
+
+struct E_RABs_ToBeReleased_List_RelReq_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_RelReqItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeReleased_List_RelReq_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_RelReqItemIEs>;
+
+};
+struct E_RABs_ToBeReleased_List_RelReq : asn::sequenceof<E_RABs_ToBeReleased_List_RelReq_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-List-RelReq";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeReleased_List_RelReq_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeReleased-ModReqdItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_ModReqdItemExtIEs
+{
+	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-RABs-ToBeReleased-ModReqdItem ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	cause							Cause,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-ModReqdItemExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_ModReqdItem : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqdItem";}
+	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_RABs_ToBeReleased_ModReqdItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqdItemExtIEs>;
+		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-RABs-ToBeReleased-ModReqdItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeReleased-ModReqdItem	 CRITICALITY ignore		TYPE E-RABs-ToBeReleased-ModReqdItem	PRESENCE mandatory },
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_ModReqdItemIEs
+{
+	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_RABs_ToBeReleased_ModReqdItem() { set(id_E_RABs_ToBeReleased_ModReqdItem); 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_RABs_ToBeReleased_ModReqdItem)) { 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_RABs_ToBeReleased_ModReqdItem);} 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_RABs_ToBeReleased_ModReqdItem() { 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_RABs_ToBeReleased_ModReqdItem& select_id_E_RABs_ToBeReleased_ModReqdItem() { return set<E_RABs_ToBeReleased_ModReqdItem>(1); }
+		E_RABs_ToBeReleased_ModReqdItem const* get_id_E_RABs_ToBeReleased_ModReqdItem() const { return get<E_RABs_ToBeReleased_ModReqdItem>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeReleased_ModReqdItem>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeReleased_ModReqdItem>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeReleased_ModReqdItem()); 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_RABs_ToBeReleased_ModReqdItem>()); 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_RABs_ToBeReleased_ModReqdItem)];
+
+		};
+		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_RABs_ToBeReleased_ModReqdItem() { 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-RABs-ToBeReleased-ModReqd ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-ModReqdItemIEs} }
+*/
+
+struct E_RABs_ToBeReleased_ModReqd_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_ModReqdItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeReleased_ModReqd_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_ModReqdItemIEs>;
+
+};
+struct E_RABs_ToBeReleased_ModReqd : asn::sequenceof<E_RABs_ToBeReleased_ModReqd_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqd";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeReleased_ModReqd_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresentExtIEs
+{
+	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-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresent ::= SEQUENCE {
+	uL-GTPtunnelEndpoint			GTPtunnelEndpoint																				OPTIONAL,
+	dL-GTPtunnelEndpoint			GTPtunnelEndpoint																				OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresent : asn::sequence<3, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresent";}
+	using parent_t = asn::sequence<3, 0, true, 3>;
+	struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	uL_GTPtunnelEndpoint_t& set_uL_GTPtunnelEndpoint() { uL_GTPtunnelEndpoint.setpresent(true); return uL_GTPtunnelEndpoint;}
+	uL_GTPtunnelEndpoint_t const* get_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint.is_valid() ? &uL_GTPtunnelEndpoint : nullptr;}
+	struct dL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_GTPtunnelEndpoint_t& set_dL_GTPtunnelEndpoint() { dL_GTPtunnelEndpoint.setpresent(true); return dL_GTPtunnelEndpoint;}
+	dL_GTPtunnelEndpoint_t const* get_dL_GTPtunnelEndpoint() const {return dL_GTPtunnelEndpoint.is_valid() ? &dL_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresentExtIEs>;
+		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_GTPtunnelEndpoint);
+		v(dL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(uL_GTPtunnelEndpoint);
+		v(dL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		uL_GTPtunnelEndpoint.clear();
+		dL_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	uL_GTPtunnelEndpoint_t	uL_GTPtunnelEndpoint;
+	dL_GTPtunnelEndpoint_t	dL_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresentExtIEs
+{
+	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-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresent ::= SEQUENCE {
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresentExtIEs} } 	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresent";}
+	using parent_t = asn::sequence<1, 0, true, 1>;
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresentExtIEs>;
+		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(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		iE_Extensions.clear();
+
+	};
+	private:
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBChaConf-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBChaConf_ItemExtIEs
+{
+	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-RABs-ToBeReleased-SgNBChaConf-Item ::= SEQUENCE {
+	e-RAB-ID							E-RAB-ID,
+	en-DC-ResourceConfiguration			EN-DC-ResourceConfiguration,
+	resource-configuration				CHOICE {
+		sgNBPDCPpresent						E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresent,
+		sgNBPDCPnotpresent					E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresent,
+		...
+	},
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBChaConf-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBChaConf_Item : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBChaConf-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 en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
+	{
+		static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
+		using parent_t = EN_DC_ResourceConfiguration;
+
+	};
+	en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
+	en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
+	struct resource_configuration_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "resource_configuration_t";}
+		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);  }
+		~resource_configuration_t() {clear();}
+		struct sgNBPDCPpresent_t : E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPpresent_t";}
+			using parent_t = E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresent;
+
+		};
+		struct sgNBPDCPnotpresent_t : E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
+			using parent_t = E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresent;
+
+		};
+		void clear()
+		{
+			switch(get_index())
+			{
+			case 1: var.destroy<sgNBPDCPpresent_t>(); break;
+			case 2: var.destroy<sgNBPDCPnotpresent_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<sgNBPDCPpresent_t>());
+			case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			switch(get_index())
+			{
+			case 1: return v(var.as<sgNBPDCPpresent_t>());
+			case 2: return v(var.as<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<sgNBPDCPpresent_t>(1);
+			v.template operator()<sgNBPDCPnotpresent_t>(2);
+
+		}
+		sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
+		sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
+		sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
+		sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
+		private:
+		void set_index(index_type i) {index = i; base::set();}
+		union union_type
+		{
+			char dummy1[sizeof(sgNBPDCPpresent_t)];
+			char dummy2[sizeof(sgNBPDCPnotpresent_t)];
+
+		};
+		asn::variant<sizeof(union_type)>	var;
+		index_type	index {0};
+	};
+	resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
+	resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_ItemExtIEs>;
+		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(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		en_DC_ResourceConfiguration.clear();
+		resource_configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	en_DC_ResourceConfiguration_t	en_DC_ResourceConfiguration;
+	resource_configuration_t	resource_configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBChaConf-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeReleased-SgNBChaConf-Item		CRITICALITY ignore		TYPE E-RABs-ToBeReleased-SgNBChaConf-Item		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBChaConf_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_RABs_ToBeReleased_SgNBChaConf_Item() { set(id_E_RABs_ToBeReleased_SgNBChaConf_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_RABs_ToBeReleased_SgNBChaConf_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_RABs_ToBeReleased_SgNBChaConf_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_RABs_ToBeReleased_SgNBChaConf_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_RABs_ToBeReleased_SgNBChaConf_Item& select_id_E_RABs_ToBeReleased_SgNBChaConf_Item() { return set<E_RABs_ToBeReleased_SgNBChaConf_Item>(1); }
+		E_RABs_ToBeReleased_SgNBChaConf_Item const* get_id_E_RABs_ToBeReleased_SgNBChaConf_Item() const { return get<E_RABs_ToBeReleased_SgNBChaConf_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeReleased_SgNBChaConf_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeReleased_SgNBChaConf_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeReleased_SgNBChaConf_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_RABs_ToBeReleased_SgNBChaConf_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_RABs_ToBeReleased_SgNBChaConf_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_RABs_ToBeReleased_SgNBChaConf_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-RABs-ToBeReleased-SgNBChaConfList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBChaConf-ItemIEs} }
+*/
+
+struct E_RABs_ToBeReleased_SgNBChaConfList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBChaConf_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBChaConfList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBChaConf_ItemIEs>;
+
+};
+struct E_RABs_ToBeReleased_SgNBChaConfList : asn::sequenceof<E_RABs_ToBeReleased_SgNBChaConfList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBChaConfList";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBChaConfList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresentExtIEs
+{
+	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-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresent ::= SEQUENCE {
+	dL-GTPtunnelEndpoint			GTPtunnelEndpoint																				OPTIONAL,
+	uL-GTPtunnelEndpoint			GTPtunnelEndpoint																				OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresentExtIEs} } 	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresent : asn::sequence<3, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresent";}
+	using parent_t = asn::sequence<3, 0, true, 3>;
+	struct dL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_GTPtunnelEndpoint_t& set_dL_GTPtunnelEndpoint() { dL_GTPtunnelEndpoint.setpresent(true); return dL_GTPtunnelEndpoint;}
+	dL_GTPtunnelEndpoint_t const* get_dL_GTPtunnelEndpoint() const {return dL_GTPtunnelEndpoint.is_valid() ? &dL_GTPtunnelEndpoint : nullptr;}
+	struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	uL_GTPtunnelEndpoint_t& set_uL_GTPtunnelEndpoint() { uL_GTPtunnelEndpoint.setpresent(true); return uL_GTPtunnelEndpoint;}
+	uL_GTPtunnelEndpoint_t const* get_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint.is_valid() ? &uL_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresentExtIEs>;
+		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_GTPtunnelEndpoint);
+		v(uL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(dL_GTPtunnelEndpoint);
+		v(uL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		dL_GTPtunnelEndpoint.clear();
+		uL_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	dL_GTPtunnelEndpoint_t	dL_GTPtunnelEndpoint;
+	uL_GTPtunnelEndpoint_t	uL_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs
+{
+	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-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs} } 	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresent";}
+	using parent_t = asn::sequence<1, 0, true, 1>;
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>;
+		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(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		iE_Extensions.clear();
+
+	};
+	private:
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBModReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBModReq_ItemExtIEs
+{
+	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-RABs-ToBeReleased-SgNBModReq-Item ::= SEQUENCE {
+	e-RAB-ID								E-RAB-ID,
+	en-DC-ResourceConfiguration			EN-DC-ResourceConfiguration,
+	resource-configuration				CHOICE {
+		sgNBPDCPpresent						E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresent,
+		sgNBPDCPnotpresent					E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresent,
+		...
+	},
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModReq-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBModReq_Item : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReq-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 en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
+	{
+		static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
+		using parent_t = EN_DC_ResourceConfiguration;
+
+	};
+	en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
+	en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
+	struct resource_configuration_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "resource_configuration_t";}
+		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);  }
+		~resource_configuration_t() {clear();}
+		struct sgNBPDCPpresent_t : E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPpresent_t";}
+			using parent_t = E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresent;
+
+		};
+		struct sgNBPDCPnotpresent_t : E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
+			using parent_t = E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresent;
+
+		};
+		void clear()
+		{
+			switch(get_index())
+			{
+			case 1: var.destroy<sgNBPDCPpresent_t>(); break;
+			case 2: var.destroy<sgNBPDCPnotpresent_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<sgNBPDCPpresent_t>());
+			case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			switch(get_index())
+			{
+			case 1: return v(var.as<sgNBPDCPpresent_t>());
+			case 2: return v(var.as<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<sgNBPDCPpresent_t>(1);
+			v.template operator()<sgNBPDCPnotpresent_t>(2);
+
+		}
+		sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
+		sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
+		sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
+		sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
+		private:
+		void set_index(index_type i) {index = i; base::set();}
+		union union_type
+		{
+			char dummy1[sizeof(sgNBPDCPpresent_t)];
+			char dummy2[sizeof(sgNBPDCPnotpresent_t)];
+
+		};
+		asn::variant<sizeof(union_type)>	var;
+		index_type	index {0};
+	};
+	resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
+	resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_ItemExtIEs>;
+		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(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		en_DC_ResourceConfiguration.clear();
+		resource_configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	en_DC_ResourceConfiguration_t	en_DC_ResourceConfiguration;
+	resource_configuration_t	resource_configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBModReq-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeReleased-SgNBModReq-Item	CRITICALITY ignore	TYPE E-RABs-ToBeReleased-SgNBModReq-Item		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBModReq_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_RABs_ToBeReleased_SgNBModReq_Item() { set(id_E_RABs_ToBeReleased_SgNBModReq_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_RABs_ToBeReleased_SgNBModReq_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_RABs_ToBeReleased_SgNBModReq_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_RABs_ToBeReleased_SgNBModReq_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_RABs_ToBeReleased_SgNBModReq_Item& select_id_E_RABs_ToBeReleased_SgNBModReq_Item() { return set<E_RABs_ToBeReleased_SgNBModReq_Item>(1); }
+		E_RABs_ToBeReleased_SgNBModReq_Item const* get_id_E_RABs_ToBeReleased_SgNBModReq_Item() const { return get<E_RABs_ToBeReleased_SgNBModReq_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeReleased_SgNBModReq_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeReleased_SgNBModReq_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeReleased_SgNBModReq_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_RABs_ToBeReleased_SgNBModReq_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_RABs_ToBeReleased_SgNBModReq_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_RABs_ToBeReleased_SgNBModReq_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-RABs-ToBeReleased-SgNBModReq-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBModReq-ItemIEs} }
+*/
+
+struct E_RABs_ToBeReleased_SgNBModReq_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBModReq_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBModReq_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBModReq_ItemIEs>;
+
+};
+struct E_RABs_ToBeReleased_SgNBModReq_List : asn::sequenceof<E_RABs_ToBeReleased_SgNBModReq_List_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReq-List";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBModReq_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBModReqd-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-RLCMode-transferred					CRITICALITY ignore	EXTENSION RLCMode					PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBModReqd_ItemExtIEs
+{
+	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_RLCMode_transferred() { set(id_RLCMode_transferred); 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_RLCMode_transferred)) { 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_RLCMode_transferred);} 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_RLCMode_transferred() { 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;}
+		RLCMode& select_id_RLCMode_transferred() { return set<RLCMode>(1); }
+		RLCMode const* get_id_RLCMode_transferred() const { return get<RLCMode>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<RLCMode>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<RLCMode>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_RLCMode_transferred()); 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<RLCMode>()); 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(RLCMode)];
+
+		};
+		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_RLCMode_transferred() { 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};
+
+	};
+
+};
+/*
+E-RABs-ToBeReleased-SgNBModReqd-Item ::= SEQUENCE {
+	e-RAB-ID							E-RAB-ID,
+	cause							Cause,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModReqd-ItemExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBModReqd_Item : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReqd-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_RABs_ToBeReleased_SgNBModReqd_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReqd_ItemExtIEs>;
+		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-RABs-ToBeReleased-SgNBModReqd-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeReleased-SgNBModReqd-Item	 CRITICALITY ignore		TYPE E-RABs-ToBeReleased-SgNBModReqd-Item		PRESENCE mandatory },
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBModReqd_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_RABs_ToBeReleased_SgNBModReqd_Item() { set(id_E_RABs_ToBeReleased_SgNBModReqd_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_RABs_ToBeReleased_SgNBModReqd_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_RABs_ToBeReleased_SgNBModReqd_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_RABs_ToBeReleased_SgNBModReqd_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_RABs_ToBeReleased_SgNBModReqd_Item& select_id_E_RABs_ToBeReleased_SgNBModReqd_Item() { return set<E_RABs_ToBeReleased_SgNBModReqd_Item>(1); }
+		E_RABs_ToBeReleased_SgNBModReqd_Item const* get_id_E_RABs_ToBeReleased_SgNBModReqd_Item() const { return get<E_RABs_ToBeReleased_SgNBModReqd_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeReleased_SgNBModReqd_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeReleased_SgNBModReqd_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeReleased_SgNBModReqd_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_RABs_ToBeReleased_SgNBModReqd_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_RABs_ToBeReleased_SgNBModReqd_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_RABs_ToBeReleased_SgNBModReqd_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-RABs-ToBeReleased-SgNBModReqdList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBModReqd-ItemIEs} }
+*/
+
+struct E_RABs_ToBeReleased_SgNBModReqdList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBModReqd_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBModReqdList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBModReqd_ItemIEs>;
+
+};
+struct E_RABs_ToBeReleased_SgNBModReqdList : asn::sequenceof<E_RABs_ToBeReleased_SgNBModReqdList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReqdList";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBModReqdList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresentExtIEs
+{
+	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-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresent ::= SEQUENCE {
+	uL-GTPtunnelEndpoint			GTPtunnelEndpoint																				OPTIONAL,
+	dL-GTPtunnelEndpoint			GTPtunnelEndpoint																				OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresent : asn::sequence<3, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresent";}
+	using parent_t = asn::sequence<3, 0, true, 3>;
+	struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	uL_GTPtunnelEndpoint_t& set_uL_GTPtunnelEndpoint() { uL_GTPtunnelEndpoint.setpresent(true); return uL_GTPtunnelEndpoint;}
+	uL_GTPtunnelEndpoint_t const* get_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint.is_valid() ? &uL_GTPtunnelEndpoint : nullptr;}
+	struct dL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_GTPtunnelEndpoint_t& set_dL_GTPtunnelEndpoint() { dL_GTPtunnelEndpoint.setpresent(true); return dL_GTPtunnelEndpoint;}
+	dL_GTPtunnelEndpoint_t const* get_dL_GTPtunnelEndpoint() const {return dL_GTPtunnelEndpoint.is_valid() ? &dL_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresentExtIEs>;
+		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_GTPtunnelEndpoint);
+		v(dL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(uL_GTPtunnelEndpoint);
+		v(dL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		uL_GTPtunnelEndpoint.clear();
+		dL_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	uL_GTPtunnelEndpoint_t	uL_GTPtunnelEndpoint;
+	dL_GTPtunnelEndpoint_t	dL_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresentExtIEs
+{
+	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-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresent ::= SEQUENCE {
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresentExtIEs} } 	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresent";}
+	using parent_t = asn::sequence<1, 0, true, 1>;
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresentExtIEs>;
+		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(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		iE_Extensions.clear();
+
+	};
+	private:
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBRelConf-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelConf_ItemExtIEs
+{
+	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-RABs-ToBeReleased-SgNBRelConf-Item ::= SEQUENCE {
+	e-RAB-ID							E-RAB-ID,
+	en-DC-ResourceConfiguration			EN-DC-ResourceConfiguration,
+	resource-configuration				CHOICE {
+		sgNBPDCPpresent						E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresent,
+		sgNBPDCPnotpresent					E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresent,
+		...
+	},
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelConf-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelConf_Item : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelConf-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 en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
+	{
+		static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
+		using parent_t = EN_DC_ResourceConfiguration;
+
+	};
+	en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
+	en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
+	struct resource_configuration_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "resource_configuration_t";}
+		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);  }
+		~resource_configuration_t() {clear();}
+		struct sgNBPDCPpresent_t : E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPpresent_t";}
+			using parent_t = E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresent;
+
+		};
+		struct sgNBPDCPnotpresent_t : E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
+			using parent_t = E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresent;
+
+		};
+		void clear()
+		{
+			switch(get_index())
+			{
+			case 1: var.destroy<sgNBPDCPpresent_t>(); break;
+			case 2: var.destroy<sgNBPDCPnotpresent_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<sgNBPDCPpresent_t>());
+			case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			switch(get_index())
+			{
+			case 1: return v(var.as<sgNBPDCPpresent_t>());
+			case 2: return v(var.as<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<sgNBPDCPpresent_t>(1);
+			v.template operator()<sgNBPDCPnotpresent_t>(2);
+
+		}
+		sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
+		sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
+		sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
+		sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
+		private:
+		void set_index(index_type i) {index = i; base::set();}
+		union union_type
+		{
+			char dummy1[sizeof(sgNBPDCPpresent_t)];
+			char dummy2[sizeof(sgNBPDCPnotpresent_t)];
+
+		};
+		asn::variant<sizeof(union_type)>	var;
+		index_type	index {0};
+	};
+	resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
+	resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_ItemExtIEs>;
+		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(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		en_DC_ResourceConfiguration.clear();
+		resource_configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	en_DC_ResourceConfiguration_t	en_DC_ResourceConfiguration;
+	resource_configuration_t	resource_configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBRelConf-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeReleased-SgNBRelConf-Item		CRITICALITY ignore		TYPE E-RABs-ToBeReleased-SgNBRelConf-Item		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelConf_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_RABs_ToBeReleased_SgNBRelConf_Item() { set(id_E_RABs_ToBeReleased_SgNBRelConf_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_RABs_ToBeReleased_SgNBRelConf_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_RABs_ToBeReleased_SgNBRelConf_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_RABs_ToBeReleased_SgNBRelConf_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_RABs_ToBeReleased_SgNBRelConf_Item& select_id_E_RABs_ToBeReleased_SgNBRelConf_Item() { return set<E_RABs_ToBeReleased_SgNBRelConf_Item>(1); }
+		E_RABs_ToBeReleased_SgNBRelConf_Item const* get_id_E_RABs_ToBeReleased_SgNBRelConf_Item() const { return get<E_RABs_ToBeReleased_SgNBRelConf_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeReleased_SgNBRelConf_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeReleased_SgNBRelConf_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeReleased_SgNBRelConf_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_RABs_ToBeReleased_SgNBRelConf_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_RABs_ToBeReleased_SgNBRelConf_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_RABs_ToBeReleased_SgNBRelConf_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-RABs-ToBeReleased-SgNBRelConfList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBRelConf-ItemIEs} }
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelConfList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelConf_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBRelConfList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelConf_ItemIEs>;
+
+};
+struct E_RABs_ToBeReleased_SgNBRelConfList : asn::sequenceof<E_RABs_ToBeReleased_SgNBRelConfList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelConfList";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBRelConfList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresentExtIEs
+{
+	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-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresent ::= SEQUENCE {
+	uL-GTPtunnelEndpoint			GTPtunnelEndpoint																	OPTIONAL,
+	dL-GTPtunnelEndpoint			GTPtunnelEndpoint																				OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresentExtIEs} } 	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresent : asn::sequence<3, 0, true, 3>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresent";}
+	using parent_t = asn::sequence<3, 0, true, 3>;
+	struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	uL_GTPtunnelEndpoint_t& set_uL_GTPtunnelEndpoint() { uL_GTPtunnelEndpoint.setpresent(true); return uL_GTPtunnelEndpoint;}
+	uL_GTPtunnelEndpoint_t const* get_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint.is_valid() ? &uL_GTPtunnelEndpoint : nullptr;}
+	struct dL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "dL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+		static constexpr bool optional = true;
+
+	};
+	dL_GTPtunnelEndpoint_t& set_dL_GTPtunnelEndpoint() { dL_GTPtunnelEndpoint.setpresent(true); return dL_GTPtunnelEndpoint;}
+	dL_GTPtunnelEndpoint_t const* get_dL_GTPtunnelEndpoint() const {return dL_GTPtunnelEndpoint.is_valid() ? &dL_GTPtunnelEndpoint : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresentExtIEs>;
+		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_GTPtunnelEndpoint);
+		v(dL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(uL_GTPtunnelEndpoint);
+		v(dL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		uL_GTPtunnelEndpoint.clear();
+		dL_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	uL_GTPtunnelEndpoint_t	uL_GTPtunnelEndpoint;
+	dL_GTPtunnelEndpoint_t	dL_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresentExtIEs
+{
+	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-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresentExtIEs} } 	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresent";}
+	using parent_t = asn::sequence<1, 0, true, 1>;
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresentExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresentExtIEs>;
+		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(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		iE_Extensions.clear();
+
+	};
+	private:
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBRelReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelReq_ItemExtIEs
+{
+	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-RABs-ToBeReleased-SgNBRelReq-Item ::= SEQUENCE {
+	e-RAB-ID							E-RAB-ID,
+	en-DC-ResourceConfiguration			EN-DC-ResourceConfiguration,
+	resource-configuration				CHOICE {
+		sgNBPDCPpresent						E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresent,
+		sgNBPDCPnotpresent					E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresent,
+		...
+	},
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelReq-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelReq_Item : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReq-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 en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
+	{
+		static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
+		using parent_t = EN_DC_ResourceConfiguration;
+
+	};
+	en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
+	en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
+	struct resource_configuration_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "resource_configuration_t";}
+		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);  }
+		~resource_configuration_t() {clear();}
+		struct sgNBPDCPpresent_t : E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPpresent_t";}
+			using parent_t = E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresent;
+
+		};
+		struct sgNBPDCPnotpresent_t : E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresent
+		{
+			static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
+			using parent_t = E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresent;
+
+		};
+		void clear()
+		{
+			switch(get_index())
+			{
+			case 1: var.destroy<sgNBPDCPpresent_t>(); break;
+			case 2: var.destroy<sgNBPDCPnotpresent_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<sgNBPDCPpresent_t>());
+			case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			switch(get_index())
+			{
+			case 1: return v(var.as<sgNBPDCPpresent_t>());
+			case 2: return v(var.as<sgNBPDCPnotpresent_t>());
+			}
+			return false;
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<sgNBPDCPpresent_t>(1);
+			v.template operator()<sgNBPDCPnotpresent_t>(2);
+
+		}
+		sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
+		sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
+		sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
+		sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
+		private:
+		void set_index(index_type i) {index = i; base::set();}
+		union union_type
+		{
+			char dummy1[sizeof(sgNBPDCPpresent_t)];
+			char dummy2[sizeof(sgNBPDCPnotpresent_t)];
+
+		};
+		asn::variant<sizeof(union_type)>	var;
+		index_type	index {0};
+	};
+	resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
+	resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_ItemExtIEs>;
+		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(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(en_DC_ResourceConfiguration);
+		v(resource_configuration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		en_DC_ResourceConfiguration.clear();
+		resource_configuration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	en_DC_ResourceConfiguration_t	en_DC_ResourceConfiguration;
+	resource_configuration_t	resource_configuration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBRelReq-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeReleased-SgNBRelReq-Item		CRITICALITY ignore	TYPE E-RABs-ToBeReleased-SgNBRelReq-Item		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelReq_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_RABs_ToBeReleased_SgNBRelReq_Item() { set(id_E_RABs_ToBeReleased_SgNBRelReq_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_RABs_ToBeReleased_SgNBRelReq_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_RABs_ToBeReleased_SgNBRelReq_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_RABs_ToBeReleased_SgNBRelReq_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_RABs_ToBeReleased_SgNBRelReq_Item& select_id_E_RABs_ToBeReleased_SgNBRelReq_Item() { return set<E_RABs_ToBeReleased_SgNBRelReq_Item>(1); }
+		E_RABs_ToBeReleased_SgNBRelReq_Item const* get_id_E_RABs_ToBeReleased_SgNBRelReq_Item() const { return get<E_RABs_ToBeReleased_SgNBRelReq_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeReleased_SgNBRelReq_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeReleased_SgNBRelReq_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeReleased_SgNBRelReq_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_RABs_ToBeReleased_SgNBRelReq_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_RABs_ToBeReleased_SgNBRelReq_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_RABs_ToBeReleased_SgNBRelReq_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-RABs-ToBeReleased-SgNBRelReqList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBRelReq-ItemIEs} }
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelReqList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelReq_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBRelReqList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelReq_ItemIEs>;
+
+};
+struct E_RABs_ToBeReleased_SgNBRelReqList : asn::sequenceof<E_RABs_ToBeReleased_SgNBRelReqList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReqList";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBRelReqList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBRelReqd-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelReqd_ItemExtIEs
+{
+	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-RABs-ToBeReleased-SgNBRelReqd-Item ::= SEQUENCE {
+	e-RAB-ID							E-RAB-ID,
+	rlc-Mode-transferred			RLCMode,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelReqd-ItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelReqd_Item : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReqd-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 rlc_Mode_transferred_t : RLCMode
+	{
+		static constexpr const char* name() {return "rlc_Mode_transferred_t";}
+		using parent_t = RLCMode;
+
+	};
+	rlc_Mode_transferred_t& ref_rlc_Mode_transferred() {return rlc_Mode_transferred;}
+	rlc_Mode_transferred_t const& ref_rlc_Mode_transferred() const {return rlc_Mode_transferred;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReqd_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReqd_ItemExtIEs>;
+		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(rlc_Mode_transferred);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(rlc_Mode_transferred);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		rlc_Mode_transferred.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	rlc_Mode_transferred_t	rlc_Mode_transferred;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeReleased-SgNBRelReqd-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeReleased-SgNBRelReqd-Item		CRITICALITY ignore	TYPE E-RABs-ToBeReleased-SgNBRelReqd-Item		PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelReqd_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_RABs_ToBeReleased_SgNBRelReqd_Item() { set(id_E_RABs_ToBeReleased_SgNBRelReqd_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_RABs_ToBeReleased_SgNBRelReqd_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_RABs_ToBeReleased_SgNBRelReqd_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_RABs_ToBeReleased_SgNBRelReqd_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_RABs_ToBeReleased_SgNBRelReqd_Item& select_id_E_RABs_ToBeReleased_SgNBRelReqd_Item() { return set<E_RABs_ToBeReleased_SgNBRelReqd_Item>(1); }
+		E_RABs_ToBeReleased_SgNBRelReqd_Item const* get_id_E_RABs_ToBeReleased_SgNBRelReqd_Item() const { return get<E_RABs_ToBeReleased_SgNBRelReqd_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeReleased_SgNBRelReqd_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeReleased_SgNBRelReqd_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeReleased_SgNBRelReqd_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_RABs_ToBeReleased_SgNBRelReqd_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_RABs_ToBeReleased_SgNBRelReqd_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_RABs_ToBeReleased_SgNBRelReqd_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-RABs-ToBeReleased-SgNBRelReqdList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBRelReqd-ItemIEs} }
+*/
+
+struct E_RABs_ToBeReleased_SgNBRelReqdList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelReqd_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBRelReqdList_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelReqd_ItemIEs>;
+
+};
+struct E_RABs_ToBeReleased_SgNBRelReqdList : asn::sequenceof<E_RABs_ToBeReleased_SgNBRelReqdList_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReqdList";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBRelReqdList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeSetup-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-BearerType		CRITICALITY reject	EXTENSION BearerType		PRESENCE optional},
+	...
+}
+*/
+
+struct E_RABs_ToBeSetup_ItemExtIEs
+{
+	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_BearerType() { set(id_BearerType); 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_BearerType)) { 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_BearerType);} 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_BearerType() { set(reject); 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(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 Extension_t : asn::typefield<true>
+	{
+		~Extension_t()	{clear();}
+		size_t get_index() const {return type;}
+		BearerType& select_id_BearerType() { return set<BearerType>(1); }
+		BearerType const* get_id_BearerType() const { return get<BearerType>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<BearerType>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<BearerType>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_BearerType()); 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<BearerType>()); 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(BearerType)];
+
+		};
+		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_BearerType() { 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};
+
+	};
+
+};
+/*
+E-RABs-ToBeSetup-Item ::= SEQUENCE {
+	e-RAB-ID					E-RAB-ID,
+	e-RAB-Level-QoS-Parameters		E-RAB-Level-QoS-Parameters,
+	dL-Forwarding					DL-Forwarding													OPTIONAL,
+	uL-GTPtunnelEndpoint			GTPtunnelEndpoint,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeSetup-ItemExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeSetup_Item : asn::sequence<5, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeSetup-Item";}
+	using parent_t = asn::sequence<5, 0, true, 2>;
+	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 e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+
+	};
+	e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
+	e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
+	struct dL_Forwarding_t : DL_Forwarding
+	{
+		static constexpr const char* name() {return "dL_Forwarding_t";}
+		using parent_t = DL_Forwarding;
+		static constexpr bool optional = true;
+
+	};
+	dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
+	dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
+	struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
+	{
+		static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
+		using parent_t = GTPtunnelEndpoint;
+
+	};
+	uL_GTPtunnelEndpoint_t& ref_uL_GTPtunnelEndpoint() {return uL_GTPtunnelEndpoint;}
+	uL_GTPtunnelEndpoint_t const& ref_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeSetup_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeSetup_ItemExtIEs>;
+		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(e_RAB_Level_QoS_Parameters);
+		v(dL_Forwarding);
+		v(uL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(e_RAB_Level_QoS_Parameters);
+		v(dL_Forwarding);
+		v(uL_GTPtunnelEndpoint);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		e_RAB_Level_QoS_Parameters.clear();
+		dL_Forwarding.clear();
+		uL_GTPtunnelEndpoint.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	e_RAB_Level_QoS_Parameters_t	e_RAB_Level_QoS_Parameters;
+	dL_Forwarding_t	dL_Forwarding;
+	uL_GTPtunnelEndpoint_t	uL_GTPtunnelEndpoint;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeSetup-ItemIEs 	X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeSetup-Item	 CRITICALITY ignore 	TYPE E-RABs-ToBeSetup-Item 	PRESENCE mandatory },
+	...
+}
+*/
+
+struct E_RABs_ToBeSetup_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_RABs_ToBeSetup_Item() { set(id_E_RABs_ToBeSetup_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_RABs_ToBeSetup_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_RABs_ToBeSetup_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_RABs_ToBeSetup_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_RABs_ToBeSetup_Item& select_id_E_RABs_ToBeSetup_Item() { return set<E_RABs_ToBeSetup_Item>(1); }
+		E_RABs_ToBeSetup_Item const* get_id_E_RABs_ToBeSetup_Item() const { return get<E_RABs_ToBeSetup_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeSetup_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeSetup_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeSetup_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_RABs_ToBeSetup_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_RABs_ToBeSetup_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_RABs_ToBeSetup_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-RABs-ToBeSetup-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeSetup-ItemIEs} }
+*/
+
+struct E_RABs_ToBeSetup_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeSetup_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeSetup_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeSetup_ItemIEs>;
+
+};
+struct E_RABs_ToBeSetup_List : asn::sequenceof<E_RABs_ToBeSetup_List_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeSetup-List";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeSetup_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+E-RABs-ToBeSetupRetrieve-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{ ID id-uL-GTPtunnelEndpoint		CRITICALITY reject	EXTENSION GTPtunnelEndpoint		PRESENCE mandatory}|
+	{ ID id-dL-Forwarding		CRITICALITY ignore	EXTENSION DL-Forwarding		PRESENCE optional },
+	...
+}
+*/
+
+struct E_RABs_ToBeSetupRetrieve_ItemExtIEs
+{
+	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_uL_GTPtunnelEndpoint() { set(id_uL_GTPtunnelEndpoint); type=1;}
+		void select_id_dL_Forwarding() { set(id_dL_Forwarding); 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_uL_GTPtunnelEndpoint)) { type = 1; return true; }
+			else if(equal(id_dL_Forwarding)) { 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_uL_GTPtunnelEndpoint);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_dL_Forwarding);} 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_uL_GTPtunnelEndpoint() { set(reject); type=1;}
+		void select_id_dL_Forwarding() { 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(reject)) { 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(reject);} 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;}
+		GTPtunnelEndpoint& select_id_uL_GTPtunnelEndpoint() { return set<GTPtunnelEndpoint>(1); }
+		GTPtunnelEndpoint const* get_id_uL_GTPtunnelEndpoint() const { return get<GTPtunnelEndpoint>(1); }
+		DL_Forwarding& select_id_dL_Forwarding() { return set<DL_Forwarding>(2); }
+		DL_Forwarding const* get_id_dL_Forwarding() const { return get<DL_Forwarding>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GTPtunnelEndpoint>(); break;
+			case 2: var.destroy<DL_Forwarding>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GTPtunnelEndpoint>(1);
+			v.template operator()<DL_Forwarding>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_uL_GTPtunnelEndpoint()); return true;
+			case 2: v(select_id_dL_Forwarding()); 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<GTPtunnelEndpoint>()); return true;
+			case 2: v(var.as<DL_Forwarding>()); 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_Forwarding)];
+			char dummy2[sizeof(GTPtunnelEndpoint)];
+
+		};
+		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_uL_GTPtunnelEndpoint() { set(mandatory); type=1;}
+		void select_id_dL_Forwarding() { 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(mandatory)) { 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(mandatory);} 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-RABs-ToBeSetupRetrieve-Item ::= SEQUENCE {
+	e-RAB-ID						E-RAB-ID,
+	e-RAB-Level-QoS-Parameters		E-RAB-Level-QoS-Parameters,
+	bearerType						BearerType	OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {E-RABs-ToBeSetupRetrieve-ItemExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct E_RABs_ToBeSetupRetrieve_Item : asn::sequence<4, 0, true, 2>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeSetupRetrieve-Item";}
+	using parent_t = asn::sequence<4, 0, true, 2>;
+	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 e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
+	{
+		static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
+		using parent_t = E_RAB_Level_QoS_Parameters;
+
+	};
+	e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
+	e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
+	struct bearerType_t : BearerType
+	{
+		static constexpr const char* name() {return "bearerType_t";}
+		using parent_t = BearerType;
+		static constexpr bool optional = true;
+
+	};
+	bearerType_t& set_bearerType() { bearerType.setpresent(true); return bearerType;}
+	bearerType_t const* get_bearerType() const {return bearerType.is_valid() ? &bearerType : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeSetupRetrieve_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<E_RABs_ToBeSetupRetrieve_ItemExtIEs>;
+		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(e_RAB_Level_QoS_Parameters);
+		v(bearerType);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(e_RAB_ID);
+		v(e_RAB_Level_QoS_Parameters);
+		v(bearerType);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		e_RAB_ID.clear();
+		e_RAB_Level_QoS_Parameters.clear();
+		bearerType.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	e_RAB_ID_t	e_RAB_ID;
+	e_RAB_Level_QoS_Parameters_t	e_RAB_Level_QoS_Parameters;
+	bearerType_t	bearerType;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+E-RABs-ToBeSetupRetrieve-ItemIEs	X2AP-PROTOCOL-IES ::= {
+	{ ID id-E-RABs-ToBeSetupRetrieve-Item	CRITICALITY ignore	TYPE E-RABs-ToBeSetupRetrieve-Item	PRESENCE mandatory},
+	...
+}
+*/
+
+struct E_RABs_ToBeSetupRetrieve_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_RABs_ToBeSetupRetrieve_Item() { set(id_E_RABs_ToBeSetupRetrieve_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_RABs_ToBeSetupRetrieve_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_RABs_ToBeSetupRetrieve_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_RABs_ToBeSetupRetrieve_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_RABs_ToBeSetupRetrieve_Item& select_id_E_RABs_ToBeSetupRetrieve_Item() { return set<E_RABs_ToBeSetupRetrieve_Item>(1); }
+		E_RABs_ToBeSetupRetrieve_Item const* get_id_E_RABs_ToBeSetupRetrieve_Item() const { return get<E_RABs_ToBeSetupRetrieve_Item>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<E_RABs_ToBeSetupRetrieve_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<E_RABs_ToBeSetupRetrieve_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_E_RABs_ToBeSetupRetrieve_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_RABs_ToBeSetupRetrieve_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_RABs_ToBeSetupRetrieve_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_RABs_ToBeSetupRetrieve_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-RABs-ToBeSetup-ListRetrieve ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeSetupRetrieve-ItemIEs} }
+*/
+
+struct E_RABs_ToBeSetup_ListRetrieve_elm : ProtocolIE_Single_Container<E_RABs_ToBeSetupRetrieve_ItemIEs>
+{
+	static constexpr const char* name() {return "E_RABs_ToBeSetup_ListRetrieve_elm";}
+	using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeSetupRetrieve_ItemIEs>;
+
+};
+struct E_RABs_ToBeSetup_ListRetrieve : asn::sequenceof<E_RABs_ToBeSetup_ListRetrieve_elm>
+{
+	static constexpr const char* name() {return "E-RABs-ToBeSetup-ListRetrieve";}
+	using parent_t = asn::sequenceof<E_RABs_ToBeSetup_ListRetrieve_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
+
+};
+/*
+ENB-ENDCConfigUpdateAckIEs X2AP-PROTOCOL-IES ::= {
+	...
+}
+*/
+
+struct ENB_ENDCConfigUpdateAckIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		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;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 1; }
+		void clear() {type = 0;}
+		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;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		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_IES::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		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;
+			{ type = 1; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& v) const
+		{
+			return v(ref_nested());
+
+		}
+		protected:
+		template<typename V>  bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: type = 1; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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-InfoNeighbourServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct FDD_InfoNeighbourServedNRCell_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};
+
+	};
+
+};
+/*
+FDD-InfoNeighbourServedNRCell-Information ::= SEQUENCE {
+	ul-NRFreqInfo			NRFreqInfo,
+	dl-NRFreqInfo			NRFreqInfo,
+	iE-Extensions			ProtocolExtensionContainer { {FDD-InfoNeighbourServedNRCell-Information-ExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct FDD_InfoNeighbourServedNRCell_Information : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "FDD-InfoNeighbourServedNRCell-Information";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct ul_NRFreqInfo_t : NRFreqInfo
+	{
+		static constexpr const char* name() {return "ul_NRFreqInfo_t";}
+		using parent_t = NRFreqInfo;
+
+	};
+	ul_NRFreqInfo_t& ref_ul_NRFreqInfo() {return ul_NRFreqInfo;}
+	ul_NRFreqInfo_t const& ref_ul_NRFreqInfo() const {return ul_NRFreqInfo;}
+	struct dl_NRFreqInfo_t : NRFreqInfo
+	{
+		static constexpr const char* name() {return "dl_NRFreqInfo_t";}
+		using parent_t = NRFreqInfo;
+
+	};
+	dl_NRFreqInfo_t& ref_dl_NRFreqInfo() {return dl_NRFreqInfo;}
+	dl_NRFreqInfo_t const& ref_dl_NRFreqInfo() const {return dl_NRFreqInfo;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<FDD_InfoNeighbourServedNRCell_Information_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<FDD_InfoNeighbourServedNRCell_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(ul_NRFreqInfo);
+		v(dl_NRFreqInfo);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(ul_NRFreqInfo);
+		v(dl_NRFreqInfo);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		ul_NRFreqInfo.clear();
+		dl_NRFreqInfo.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	ul_NRFreqInfo_t	ul_NRFreqInfo;
+	dl_NRFreqInfo_t	dl_NRFreqInfo;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+TDD-InfoNeighbourServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct TDD_InfoNeighbourServedNRCell_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};
+
+	};
+
+};
+/*
+TDD-InfoNeighbourServedNRCell-Information ::= SEQUENCE {
+	nRFreqInfo				NRFreqInfo,
+	iE-Extensions			ProtocolExtensionContainer { {TDD-InfoNeighbourServedNRCell-Information-ExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct TDD_InfoNeighbourServedNRCell_Information : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "TDD-InfoNeighbourServedNRCell-Information";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct nRFreqInfo_t : NRFreqInfo
+	{
+		static constexpr const char* name() {return "nRFreqInfo_t";}
+		using parent_t = NRFreqInfo;
+
+	};
+	nRFreqInfo_t& ref_nRFreqInfo() {return nRFreqInfo;}
+	nRFreqInfo_t const& ref_nRFreqInfo() const {return nRFreqInfo;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<TDD_InfoNeighbourServedNRCell_Information_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<TDD_InfoNeighbourServedNRCell_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(nRFreqInfo);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(nRFreqInfo);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		nRFreqInfo.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	nRFreqInfo_t	nRFreqInfo;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+NRNeighbour-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct NRNeighbour_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};
+
+	};
+
+};
+/*
+NRNeighbour-Information ::= SEQUENCE (SIZE (1.. maxofNRNeighbours))OF SEQUENCE {
+	nrpCI				NRPCI,
+	nrCellID				NRCGI,
+	fiveGS-TAC			FiveGS-TAC	OPTIONAL,
+	configured-TAC		TAC			OPTIONAL,
+	measurementTimingConfiguration	OCTET STRING,
+	nRNeighbourModeInfo			CHOICE {
+		fdd		FDD-InfoNeighbourServedNRCell-Information,
+		tdd		TDD-InfoNeighbourServedNRCell-Information,
+		...
+	},
+	iE-Extensions						ProtocolExtensionContainer { {NRNeighbour-Information-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct NRNeighbour_Information_elm : asn::sequence<7, 0, true, 3>
+{
+	static constexpr const char* name() {return "NRNeighbour_Information_elm";}
+	using parent_t = asn::sequence<7, 0, true, 3>;
+	struct nrpCI_t : NRPCI
+	{
+		static constexpr const char* name() {return "nrpCI_t";}
+		using parent_t = NRPCI;
+
+	};
+	nrpCI_t& ref_nrpCI() {return nrpCI;}
+	nrpCI_t const& ref_nrpCI() const {return nrpCI;}
+	struct nrCellID_t : NRCGI
+	{
+		static constexpr const char* name() {return "nrCellID_t";}
+		using parent_t = NRCGI;
+
+	};
+	nrCellID_t& ref_nrCellID() {return nrCellID;}
+	nrCellID_t const& ref_nrCellID() const {return nrCellID;}
+	struct fiveGS_TAC_t : FiveGS_TAC
+	{
+		static constexpr const char* name() {return "fiveGS_TAC_t";}
+		using parent_t = FiveGS_TAC;
+		static constexpr bool optional = true;
+
+	};
+	fiveGS_TAC_t& set_fiveGS_TAC() { fiveGS_TAC.setpresent(true); return fiveGS_TAC;}
+	fiveGS_TAC_t const* get_fiveGS_TAC() const {return fiveGS_TAC.is_valid() ? &fiveGS_TAC : nullptr;}
+	struct configured_TAC_t : TAC
+	{
+		static constexpr const char* name() {return "configured_TAC_t";}
+		using parent_t = TAC;
+		static constexpr bool optional = true;
+
+	};
+	configured_TAC_t& set_configured_TAC() { configured_TAC.setpresent(true); return configured_TAC;}
+	configured_TAC_t const* get_configured_TAC() const {return configured_TAC.is_valid() ? &configured_TAC : nullptr;}
+	struct measurementTimingConfiguration_t : asn::ostring<>
+	{
+		static constexpr const char* name() {return "measurementTimingConfiguration_t";}
+		using parent_t = asn::ostring<>;
+
+	};
+
+	measurementTimingConfiguration_t& ref_measurementTimingConfiguration() {return measurementTimingConfiguration;}
+	measurementTimingConfiguration_t const& ref_measurementTimingConfiguration() const {return measurementTimingConfiguration;}
+	struct nRNeighbourModeInfo_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "nRNeighbourModeInfo_t";}
+		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);  }
+		~nRNeighbourModeInfo_t() {clear();}
+		struct fdd_t : FDD_InfoNeighbourServedNRCell_Information
+		{
+			static constexpr const char* name() {return "fdd_t";}
+			using parent_t = FDD_InfoNeighbourServedNRCell_Information;
+
+		};
+		struct tdd_t : TDD_InfoNeighbourServedNRCell_Information
+		{
+			static constexpr const char* name() {return "tdd_t";}
+			using parent_t = TDD_InfoNeighbourServedNRCell_Information;
+
+		};
+		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};
+	};
+	nRNeighbourModeInfo_t& ref_nRNeighbourModeInfo() {return nRNeighbourModeInfo;}
+	nRNeighbourModeInfo_t const& ref_nRNeighbourModeInfo() const {return nRNeighbourModeInfo;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<NRNeighbour_Information_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<NRNeighbour_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(nrpCI);
+		v(nrCellID);
+		v(fiveGS_TAC);
+		v(configured_TAC);
+		v(measurementTimingConfiguration);
+		v(nRNeighbourModeInfo);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(nrpCI);
+		v(nrCellID);
+		v(fiveGS_TAC);
+		v(configured_TAC);
+		v(measurementTimingConfiguration);
+		v(nRNeighbourModeInfo);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		nrpCI.clear();
+		nrCellID.clear();
+		fiveGS_TAC.clear();
+		configured_TAC.clear();
+		measurementTimingConfiguration.clear();
+		nRNeighbourModeInfo.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	nrpCI_t	nrpCI;
+	nrCellID_t	nrCellID;
+	fiveGS_TAC_t	fiveGS_TAC;
+	configured_TAC_t	configured_TAC;
+	measurementTimingConfiguration_t	measurementTimingConfiguration;
+	nRNeighbourModeInfo_t	nRNeighbourModeInfo;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct NRNeighbour_Information : asn::sequenceof<NRNeighbour_Information_elm>
+{
+	static constexpr const char* name() {return "NRNeighbour-Information";}
+	using parent_t = asn::sequenceof<NRNeighbour_Information_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxofNRNeighbours >>;
+
+};
+/*
+ServedEUTRAcellsENDCX2Management-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ServedEUTRAcellsENDCX2Management_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};
+
+	};
+
+};
+/*
+ServedEUTRAcellsENDCX2ManagementList ::= SEQUENCE (SIZE (1.. maxCellineNB)) OF SEQUENCE {
+	servedEUTRACellInfo					ServedCell-Information,
+	nrNeighbourInfo						NRNeighbour-Information		OPTIONAL,
+	iE-Extensions						ProtocolExtensionContainer { {ServedEUTRAcellsENDCX2Management-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ServedEUTRAcellsENDCX2ManagementList_elm : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "ServedEUTRAcellsENDCX2ManagementList_elm";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	struct servedEUTRACellInfo_t : ServedCell_Information
+	{
+		static constexpr const char* name() {return "servedEUTRACellInfo_t";}
+		using parent_t = ServedCell_Information;
+
+	};
+	servedEUTRACellInfo_t& ref_servedEUTRACellInfo() {return servedEUTRACellInfo;}
+	servedEUTRACellInfo_t const& ref_servedEUTRACellInfo() const {return servedEUTRACellInfo;}
+	struct nrNeighbourInfo_t : NRNeighbour_Information
+	{
+		static constexpr const char* name() {return "nrNeighbourInfo_t";}
+		using parent_t = NRNeighbour_Information;
+		static constexpr bool optional = true;
+
+	};
+	nrNeighbourInfo_t& set_nrNeighbourInfo() { nrNeighbourInfo.setpresent(true); return nrNeighbourInfo;}
+	nrNeighbourInfo_t const* get_nrNeighbourInfo() const {return nrNeighbourInfo.is_valid() ? &nrNeighbourInfo : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ServedEUTRAcellsENDCX2Management_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ServedEUTRAcellsENDCX2Management_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(servedEUTRACellInfo);
+		v(nrNeighbourInfo);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(servedEUTRACellInfo);
+		v(nrNeighbourInfo);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		servedEUTRACellInfo.clear();
+		nrNeighbourInfo.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	servedEUTRACellInfo_t	servedEUTRACellInfo;
+	nrNeighbourInfo_t	nrNeighbourInfo;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct ServedEUTRAcellsENDCX2ManagementList : asn::sequenceof<ServedEUTRAcellsENDCX2ManagementList_elm>
+{
+	static constexpr const char* name() {return "ServedEUTRAcellsENDCX2ManagementList";}
+	using parent_t = asn::sequenceof<ServedEUTRAcellsENDCX2ManagementList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+ServedEUTRAcellsToModifyListENDCConfUpd-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ServedEUTRAcellsToModifyListENDCConfUpd_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};
+
+	};
+
+};
+/*
+ServedEUTRAcellsToModifyListENDCConfUpd ::= SEQUENCE (SIZE (1.. maxCellineNB)) OF SEQUENCE {
+	old-ECGI								ECGI,
+	servedEUTRACellInfo					ServedCell-Information,
+	nrNeighbourInfo						NRNeighbour-Information		OPTIONAL,
+	iE-Extensions						ProtocolExtensionContainer { {ServedEUTRAcellsToModifyListENDCConfUpd-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ServedEUTRAcellsToModifyListENDCConfUpd_elm : asn::sequence<4, 0, true, 2>
+{
+	static constexpr const char* name() {return "ServedEUTRAcellsToModifyListENDCConfUpd_elm";}
+	using parent_t = asn::sequence<4, 0, true, 2>;
+	struct old_ECGI_t : ECGI
+	{
+		static constexpr const char* name() {return "old_ECGI_t";}
+		using parent_t = ECGI;
+
+	};
+	old_ECGI_t& ref_old_ECGI() {return old_ECGI;}
+	old_ECGI_t const& ref_old_ECGI() const {return old_ECGI;}
+	struct servedEUTRACellInfo_t : ServedCell_Information
+	{
+		static constexpr const char* name() {return "servedEUTRACellInfo_t";}
+		using parent_t = ServedCell_Information;
+
+	};
+	servedEUTRACellInfo_t& ref_servedEUTRACellInfo() {return servedEUTRACellInfo;}
+	servedEUTRACellInfo_t const& ref_servedEUTRACellInfo() const {return servedEUTRACellInfo;}
+	struct nrNeighbourInfo_t : NRNeighbour_Information
+	{
+		static constexpr const char* name() {return "nrNeighbourInfo_t";}
+		using parent_t = NRNeighbour_Information;
+		static constexpr bool optional = true;
+
+	};
+	nrNeighbourInfo_t& set_nrNeighbourInfo() { nrNeighbourInfo.setpresent(true); return nrNeighbourInfo;}
+	nrNeighbourInfo_t const* get_nrNeighbourInfo() const {return nrNeighbourInfo.is_valid() ? &nrNeighbourInfo : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ServedEUTRAcellsToModifyListENDCConfUpd_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ServedEUTRAcellsToModifyListENDCConfUpd_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(old_ECGI);
+		v(servedEUTRACellInfo);
+		v(nrNeighbourInfo);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(old_ECGI);
+		v(servedEUTRACellInfo);
+		v(nrNeighbourInfo);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		old_ECGI.clear();
+		servedEUTRACellInfo.clear();
+		nrNeighbourInfo.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	old_ECGI_t	old_ECGI;
+	servedEUTRACellInfo_t	servedEUTRACellInfo;
+	nrNeighbourInfo_t	nrNeighbourInfo;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct ServedEUTRAcellsToModifyListENDCConfUpd : asn::sequenceof<ServedEUTRAcellsToModifyListENDCConfUpd_elm>
+{
+	static constexpr const char* name() {return "ServedEUTRAcellsToModifyListENDCConfUpd";}
+	using parent_t = asn::sequenceof<ServedEUTRAcellsToModifyListENDCConfUpd_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+ServedEUTRAcellsToDeleteListENDCConfUpd ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ECGI
+*/
+
+struct ServedEUTRAcellsToDeleteListENDCConfUpd_elm : ECGI
+{
+	static constexpr const char* name() {return "ServedEUTRAcellsToDeleteListENDCConfUpd_elm";}
+	using parent_t = ECGI;
+
+};
+struct ServedEUTRAcellsToDeleteListENDCConfUpd : asn::sequenceof<ServedEUTRAcellsToDeleteListENDCConfUpd_elm>
+{
+	static constexpr const char* name() {return "ServedEUTRAcellsToDeleteListENDCConfUpd";}
+	using parent_t = asn::sequenceof<ServedEUTRAcellsToDeleteListENDCConfUpd_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+ENB-ENDCConfigUpdateIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-CellAssistanceInformation				CRITICALITY reject	TYPE CellAssistanceInformation							PRESENCE optional }|
+	{ ID id-ServedEUTRAcellsENDCX2ManagementList		CRITICALITY reject	TYPE ServedEUTRAcellsENDCX2ManagementList			PRESENCE optional }|
+	{ ID id-ServedEUTRAcellsToModifyListENDCConfUpd	CRITICALITY reject	TYPE ServedEUTRAcellsToModifyListENDCConfUpd		PRESENCE optional }|
+	{ ID id-ServedEUTRAcellsToDeleteListENDCConfUpd	CRITICALITY reject	TYPE ServedEUTRAcellsToDeleteListENDCConfUpd		PRESENCE optional },
+	...
+}
+*/
+
+struct ENB_ENDCConfigUpdateIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_CellAssistanceInformation() { set(id_CellAssistanceInformation); type=1;}
+		void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(id_ServedEUTRAcellsENDCX2ManagementList); type=2;}
+		void select_id_ServedEUTRAcellsToModifyListENDCConfUpd() { set(id_ServedEUTRAcellsToModifyListENDCConfUpd); type=3;}
+		void select_id_ServedEUTRAcellsToDeleteListENDCConfUpd() { set(id_ServedEUTRAcellsToDeleteListENDCConfUpd); type=4;}
+		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_CellAssistanceInformation)) { type = 1; return true; }
+			else if(equal(id_ServedEUTRAcellsENDCX2ManagementList)) { type = 2; return true; }
+			else if(equal(id_ServedEUTRAcellsToModifyListENDCConfUpd)) { type = 3; return true; }
+			else if(equal(id_ServedEUTRAcellsToDeleteListENDCConfUpd)) { 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_CellAssistanceInformation);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsENDCX2ManagementList);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsToModifyListENDCConfUpd);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsToDeleteListENDCConfUpd);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_CellAssistanceInformation() { set(reject); type=1;}
+		void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(reject); type=2;}
+		void select_id_ServedEUTRAcellsToModifyListENDCConfUpd() { set(reject); type=3;}
+		void select_id_ServedEUTRAcellsToDeleteListENDCConfUpd() { set(reject); type=4;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(reject)) { type = 3; return true; }
+			else if(equal(reject)) { 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		CellAssistanceInformation& select_id_CellAssistanceInformation() { return set<CellAssistanceInformation>(1); }
+		CellAssistanceInformation const* get_id_CellAssistanceInformation() const { return get<CellAssistanceInformation>(1); }
+		ServedEUTRAcellsENDCX2ManagementList& select_id_ServedEUTRAcellsENDCX2ManagementList() { return set<ServedEUTRAcellsENDCX2ManagementList>(2); }
+		ServedEUTRAcellsENDCX2ManagementList const* get_id_ServedEUTRAcellsENDCX2ManagementList() const { return get<ServedEUTRAcellsENDCX2ManagementList>(2); }
+		ServedEUTRAcellsToModifyListENDCConfUpd& select_id_ServedEUTRAcellsToModifyListENDCConfUpd() { return set<ServedEUTRAcellsToModifyListENDCConfUpd>(3); }
+		ServedEUTRAcellsToModifyListENDCConfUpd const* get_id_ServedEUTRAcellsToModifyListENDCConfUpd() const { return get<ServedEUTRAcellsToModifyListENDCConfUpd>(3); }
+		ServedEUTRAcellsToDeleteListENDCConfUpd& select_id_ServedEUTRAcellsToDeleteListENDCConfUpd() { return set<ServedEUTRAcellsToDeleteListENDCConfUpd>(4); }
+		ServedEUTRAcellsToDeleteListENDCConfUpd const* get_id_ServedEUTRAcellsToDeleteListENDCConfUpd() const { return get<ServedEUTRAcellsToDeleteListENDCConfUpd>(4); }
+		bool is_unknown() const { return type == 5; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<CellAssistanceInformation>(); break;
+			case 2: var.destroy<ServedEUTRAcellsENDCX2ManagementList>(); break;
+			case 3: var.destroy<ServedEUTRAcellsToModifyListENDCConfUpd>(); break;
+			case 4: var.destroy<ServedEUTRAcellsToDeleteListENDCConfUpd>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<CellAssistanceInformation>(1);
+			v.template operator()<ServedEUTRAcellsENDCX2ManagementList>(2);
+			v.template operator()<ServedEUTRAcellsToModifyListENDCConfUpd>(3);
+			v.template operator()<ServedEUTRAcellsToDeleteListENDCConfUpd>(4);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_CellAssistanceInformation()); return true;
+			case 2: v(select_id_ServedEUTRAcellsENDCX2ManagementList()); return true;
+			case 3: v(select_id_ServedEUTRAcellsToModifyListENDCConfUpd()); return true;
+			case 4: v(select_id_ServedEUTRAcellsToDeleteListENDCConfUpd()); 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<CellAssistanceInformation>()); return true;
+			case 2: v(var.as<ServedEUTRAcellsENDCX2ManagementList>()); return true;
+			case 3: v(var.as<ServedEUTRAcellsToModifyListENDCConfUpd>()); return true;
+			case 4: v(var.as<ServedEUTRAcellsToDeleteListENDCConfUpd>()); 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(CellAssistanceInformation)];
+			char dummy2[sizeof(ServedEUTRAcellsENDCX2ManagementList)];
+			char dummy3[sizeof(ServedEUTRAcellsToDeleteListENDCConfUpd)];
+			char dummy4[sizeof(ServedEUTRAcellsToModifyListENDCConfUpd)];
+
+		};
+		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 == 5; }
+		void clear() {type = 0;}
+		void select_id_CellAssistanceInformation() { set(optional); type=1;}
+		void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(optional); type=2;}
+		void select_id_ServedEUTRAcellsToModifyListENDCConfUpd() { set(optional); type=3;}
+		void select_id_ServedEUTRAcellsToDeleteListENDCConfUpd() { set(optional); type=4;}
+		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(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};
+
+	};
+
+};
+/*
+ENB-ENDCX2RemovalReqAckIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-GlobalENB-ID								CRITICALITY reject	TYPE GlobalENB-ID										PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENB_ENDCX2RemovalReqAckIEs
+{
+	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_GlobalENB_ID() { set(id_GlobalENB_ID); 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_GlobalENB_ID)) { 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_GlobalENB_ID);} 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_GlobalENB_ID() { 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;}
+		GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
+		GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GlobalENB_ID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GlobalENB_ID>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_GlobalENB_ID()); 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<GlobalENB_ID>()); 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(GlobalENB_ID)];
+
+		};
+		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_GlobalENB_ID() { 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};
+
+	};
+
+};
+/*
+ENB-ENDCX2RemovalReqIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-GlobalENB-ID								CRITICALITY reject	TYPE GlobalENB-ID										PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENB_ENDCX2RemovalReqIEs
+{
+	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_GlobalENB_ID() { set(id_GlobalENB_ID); 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_GlobalENB_ID)) { 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_GlobalENB_ID);} 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_GlobalENB_ID() { 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;}
+		GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
+		GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GlobalENB_ID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GlobalENB_ID>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_GlobalENB_ID()); 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<GlobalENB_ID>()); 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(GlobalENB_ID)];
+
+		};
+		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_GlobalENB_ID() { 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};
+
+	};
+
+};
+/*
+ENB-ENDCX2SetupReqAckIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-GlobalENB-ID								CRITICALITY reject	TYPE GlobalENB-ID										PRESENCE mandatory}|
+	{ ID id-ServedEUTRAcellsENDCX2ManagementList		CRITICALITY reject	TYPE ServedEUTRAcellsENDCX2ManagementList		PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENB_ENDCX2SetupReqAckIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
+		void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(id_ServedEUTRAcellsENDCX2ManagementList); type=2;}
+		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_GlobalENB_ID)) { type = 1; return true; }
+			else if(equal(id_ServedEUTRAcellsENDCX2ManagementList)) { 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_GlobalENB_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsENDCX2ManagementList);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(reject); type=1;}
+		void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(reject); type=2;}
+		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 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(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
+		GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
+		ServedEUTRAcellsENDCX2ManagementList& select_id_ServedEUTRAcellsENDCX2ManagementList() { return set<ServedEUTRAcellsENDCX2ManagementList>(2); }
+		ServedEUTRAcellsENDCX2ManagementList const* get_id_ServedEUTRAcellsENDCX2ManagementList() const { return get<ServedEUTRAcellsENDCX2ManagementList>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GlobalENB_ID>(); break;
+			case 2: var.destroy<ServedEUTRAcellsENDCX2ManagementList>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GlobalENB_ID>(1);
+			v.template operator()<ServedEUTRAcellsENDCX2ManagementList>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_GlobalENB_ID()); return true;
+			case 2: v(select_id_ServedEUTRAcellsENDCX2ManagementList()); 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<GlobalENB_ID>()); return true;
+			case 2: v(var.as<ServedEUTRAcellsENDCX2ManagementList>()); 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(GlobalENB_ID)];
+			char dummy2[sizeof(ServedEUTRAcellsENDCX2ManagementList)];
+
+		};
+		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 == 3; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(mandatory); type=1;}
+		void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(mandatory); type=2;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+ENB-ENDCX2SetupReqIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-GlobalENB-ID								CRITICALITY reject	TYPE GlobalENB-ID										PRESENCE mandatory}|
+	{ ID id-ServedEUTRAcellsENDCX2ManagementList		CRITICALITY reject	TYPE ServedEUTRAcellsENDCX2ManagementList		PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENB_ENDCX2SetupReqIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
+		void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(id_ServedEUTRAcellsENDCX2ManagementList); type=2;}
+		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_GlobalENB_ID)) { type = 1; return true; }
+			else if(equal(id_ServedEUTRAcellsENDCX2ManagementList)) { 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_GlobalENB_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsENDCX2ManagementList);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(reject); type=1;}
+		void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(reject); type=2;}
+		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 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(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
+		GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
+		ServedEUTRAcellsENDCX2ManagementList& select_id_ServedEUTRAcellsENDCX2ManagementList() { return set<ServedEUTRAcellsENDCX2ManagementList>(2); }
+		ServedEUTRAcellsENDCX2ManagementList const* get_id_ServedEUTRAcellsENDCX2ManagementList() const { return get<ServedEUTRAcellsENDCX2ManagementList>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GlobalENB_ID>(); break;
+			case 2: var.destroy<ServedEUTRAcellsENDCX2ManagementList>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GlobalENB_ID>(1);
+			v.template operator()<ServedEUTRAcellsENDCX2ManagementList>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_GlobalENB_ID()); return true;
+			case 2: v(select_id_ServedEUTRAcellsENDCX2ManagementList()); 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<GlobalENB_ID>()); return true;
+			case 2: v(var.as<ServedEUTRAcellsENDCX2ManagementList>()); 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(GlobalENB_ID)];
+			char dummy2[sizeof(ServedEUTRAcellsENDCX2ManagementList)];
+
+		};
+		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 == 3; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(mandatory); type=1;}
+		void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(mandatory); type=2;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+ListofEUTRACellsinEUTRACoordinationResp ::= SEQUENCE (SIZE (0..maxCellineNB)) OF ECGI
+*/
+
+struct ListofEUTRACellsinEUTRACoordinationResp_elm : ECGI
+{
+	static constexpr const char* name() {return "ListofEUTRACellsinEUTRACoordinationResp_elm";}
+	using parent_t = ECGI;
+
+};
+struct ListofEUTRACellsinEUTRACoordinationResp : asn::sequenceof<ListofEUTRACellsinEUTRACoordinationResp_elm>
+{
+	static constexpr const char* name() {return "ListofEUTRACellsinEUTRACoordinationResp";}
+	using parent_t = asn::sequenceof<ListofEUTRACellsinEUTRACoordinationResp_elm>;
+	using constraint_t = asn::constraints<false,asn::span<0,  maxCellineNB >>;
+
+};
+/*
+ENB-EUTRA-NRCellResourceCoordinationReqAckIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-DataTrafficResourceIndication				CRITICALITY reject	TYPE DataTrafficResourceIndication				PRESENCE mandatory}|
+	{ ID id-SpectrumSharingGroupID						CRITICALITY reject	TYPE SpectrumSharingGroupID							PRESENCE mandatory}|
+	{ ID id-ListofEUTRACellsinEUTRACoordinationResp		CRITICALITY reject	TYPE ListofEUTRACellsinEUTRACoordinationResp	PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENB_EUTRA_NRCellResourceCoordinationReqAckIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_DataTrafficResourceIndication() { set(id_DataTrafficResourceIndication); type=1;}
+		void select_id_SpectrumSharingGroupID() { set(id_SpectrumSharingGroupID); type=2;}
+		void select_id_ListofEUTRACellsinEUTRACoordinationResp() { set(id_ListofEUTRACellsinEUTRACoordinationResp); type=3;}
+		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_DataTrafficResourceIndication)) { type = 1; return true; }
+			else if(equal(id_SpectrumSharingGroupID)) { type = 2; return true; }
+			else if(equal(id_ListofEUTRACellsinEUTRACoordinationResp)) { 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_DataTrafficResourceIndication);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SpectrumSharingGroupID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_ListofEUTRACellsinEUTRACoordinationResp);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_DataTrafficResourceIndication() { set(reject); type=1;}
+		void select_id_SpectrumSharingGroupID() { set(reject); type=2;}
+		void select_id_ListofEUTRACellsinEUTRACoordinationResp() { set(reject); type=3;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(reject)) { 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		DataTrafficResourceIndication& select_id_DataTrafficResourceIndication() { return set<DataTrafficResourceIndication>(1); }
+		DataTrafficResourceIndication const* get_id_DataTrafficResourceIndication() const { return get<DataTrafficResourceIndication>(1); }
+		SpectrumSharingGroupID& select_id_SpectrumSharingGroupID() { return set<SpectrumSharingGroupID>(2); }
+		SpectrumSharingGroupID const* get_id_SpectrumSharingGroupID() const { return get<SpectrumSharingGroupID>(2); }
+		ListofEUTRACellsinEUTRACoordinationResp& select_id_ListofEUTRACellsinEUTRACoordinationResp() { return set<ListofEUTRACellsinEUTRACoordinationResp>(3); }
+		ListofEUTRACellsinEUTRACoordinationResp const* get_id_ListofEUTRACellsinEUTRACoordinationResp() const { return get<ListofEUTRACellsinEUTRACoordinationResp>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<DataTrafficResourceIndication>(); break;
+			case 2: var.destroy<SpectrumSharingGroupID>(); break;
+			case 3: var.destroy<ListofEUTRACellsinEUTRACoordinationResp>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<DataTrafficResourceIndication>(1);
+			v.template operator()<SpectrumSharingGroupID>(2);
+			v.template operator()<ListofEUTRACellsinEUTRACoordinationResp>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_DataTrafficResourceIndication()); return true;
+			case 2: v(select_id_SpectrumSharingGroupID()); return true;
+			case 3: v(select_id_ListofEUTRACellsinEUTRACoordinationResp()); 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<DataTrafficResourceIndication>()); return true;
+			case 2: v(var.as<SpectrumSharingGroupID>()); return true;
+			case 3: v(var.as<ListofEUTRACellsinEUTRACoordinationResp>()); 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(DataTrafficResourceIndication)];
+			char dummy2[sizeof(ListofEUTRACellsinEUTRACoordinationResp)];
+			char dummy3[sizeof(SpectrumSharingGroupID)];
+
+		};
+		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 == 4; }
+		void clear() {type = 0;}
+		void select_id_DataTrafficResourceIndication() { set(mandatory); type=1;}
+		void select_id_SpectrumSharingGroupID() { set(mandatory); type=2;}
+		void select_id_ListofEUTRACellsinEUTRACoordinationResp() { set(mandatory); type=3;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+ListofEUTRACellsinEUTRACoordinationReq ::= SEQUENCE (SIZE (0..maxCellineNB)) OF ECGI
+*/
+
+struct ListofEUTRACellsinEUTRACoordinationReq_elm : ECGI
+{
+	static constexpr const char* name() {return "ListofEUTRACellsinEUTRACoordinationReq_elm";}
+	using parent_t = ECGI;
+
+};
+struct ListofEUTRACellsinEUTRACoordinationReq : asn::sequenceof<ListofEUTRACellsinEUTRACoordinationReq_elm>
+{
+	static constexpr const char* name() {return "ListofEUTRACellsinEUTRACoordinationReq";}
+	using parent_t = asn::sequenceof<ListofEUTRACellsinEUTRACoordinationReq_elm>;
+	using constraint_t = asn::constraints<false,asn::span<0,  maxCellineNB >>;
+
+};
+/*
+ENB-EUTRA-NRCellResourceCoordinationReqIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-DataTrafficResourceIndication			CRITICALITY reject	TYPE DataTrafficResourceIndication					PRESENCE mandatory}|
+	{ ID id-SpectrumSharingGroupID					CRITICALITY reject	TYPE SpectrumSharingGroupID							PRESENCE mandatory}|
+	{ ID id-ListofEUTRACellsinEUTRACoordinationReq	CRITICALITY reject	TYPE ListofEUTRACellsinEUTRACoordinationReq		PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENB_EUTRA_NRCellResourceCoordinationReqIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_DataTrafficResourceIndication() { set(id_DataTrafficResourceIndication); type=1;}
+		void select_id_SpectrumSharingGroupID() { set(id_SpectrumSharingGroupID); type=2;}
+		void select_id_ListofEUTRACellsinEUTRACoordinationReq() { set(id_ListofEUTRACellsinEUTRACoordinationReq); type=3;}
+		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_DataTrafficResourceIndication)) { type = 1; return true; }
+			else if(equal(id_SpectrumSharingGroupID)) { type = 2; return true; }
+			else if(equal(id_ListofEUTRACellsinEUTRACoordinationReq)) { 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_DataTrafficResourceIndication);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SpectrumSharingGroupID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_ListofEUTRACellsinEUTRACoordinationReq);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_DataTrafficResourceIndication() { set(reject); type=1;}
+		void select_id_SpectrumSharingGroupID() { set(reject); type=2;}
+		void select_id_ListofEUTRACellsinEUTRACoordinationReq() { set(reject); type=3;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(reject)) { 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		DataTrafficResourceIndication& select_id_DataTrafficResourceIndication() { return set<DataTrafficResourceIndication>(1); }
+		DataTrafficResourceIndication const* get_id_DataTrafficResourceIndication() const { return get<DataTrafficResourceIndication>(1); }
+		SpectrumSharingGroupID& select_id_SpectrumSharingGroupID() { return set<SpectrumSharingGroupID>(2); }
+		SpectrumSharingGroupID const* get_id_SpectrumSharingGroupID() const { return get<SpectrumSharingGroupID>(2); }
+		ListofEUTRACellsinEUTRACoordinationReq& select_id_ListofEUTRACellsinEUTRACoordinationReq() { return set<ListofEUTRACellsinEUTRACoordinationReq>(3); }
+		ListofEUTRACellsinEUTRACoordinationReq const* get_id_ListofEUTRACellsinEUTRACoordinationReq() const { return get<ListofEUTRACellsinEUTRACoordinationReq>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<DataTrafficResourceIndication>(); break;
+			case 2: var.destroy<SpectrumSharingGroupID>(); break;
+			case 3: var.destroy<ListofEUTRACellsinEUTRACoordinationReq>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<DataTrafficResourceIndication>(1);
+			v.template operator()<SpectrumSharingGroupID>(2);
+			v.template operator()<ListofEUTRACellsinEUTRACoordinationReq>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_DataTrafficResourceIndication()); return true;
+			case 2: v(select_id_SpectrumSharingGroupID()); return true;
+			case 3: v(select_id_ListofEUTRACellsinEUTRACoordinationReq()); 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<DataTrafficResourceIndication>()); return true;
+			case 2: v(var.as<SpectrumSharingGroupID>()); return true;
+			case 3: v(var.as<ListofEUTRACellsinEUTRACoordinationReq>()); 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(DataTrafficResourceIndication)];
+			char dummy2[sizeof(ListofEUTRACellsinEUTRACoordinationReq)];
+			char dummy3[sizeof(SpectrumSharingGroupID)];
+
+		};
+		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 == 4; }
+		void clear() {type = 0;}
+		void select_id_DataTrafficResourceIndication() { set(mandatory); type=1;}
+		void select_id_SpectrumSharingGroupID() { set(mandatory); type=2;}
+		void select_id_ListofEUTRACellsinEUTRACoordinationReq() { set(mandatory); type=3;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+ServedCellsToModify-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+{ ID id-DeactivationIndication			CRITICALITY ignore	EXTENSION DeactivationIndication				PRESENCE optional },
+	...
+}
+*/
+
+struct ServedCellsToModify_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 == 2; }
+		void clear() {type = 0;}
+		void select_id_DeactivationIndication() { set(id_DeactivationIndication); 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_DeactivationIndication)) { 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_DeactivationIndication);} 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_DeactivationIndication() { 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;}
+		DeactivationIndication& select_id_DeactivationIndication() { return set<DeactivationIndication>(1); }
+		DeactivationIndication const* get_id_DeactivationIndication() const { return get<DeactivationIndication>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<DeactivationIndication>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<DeactivationIndication>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_DeactivationIndication()); 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<DeactivationIndication>()); 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(DeactivationIndication)];
+
+		};
+		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_DeactivationIndication() { 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};
+
+	};
+
+};
+/*
+ServedCellsToModify-Item::= SEQUENCE {
+	old-ecgi						ECGI,
+	servedCellInfo					ServedCell-Information,
+	neighbour-Info					Neighbour-Information			OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {ServedCellsToModify-Item-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ServedCellsToModify_Item : asn::sequence<4, 0, true, 2>
+{
+	static constexpr const char* name() {return "ServedCellsToModify-Item";}
+	using parent_t = asn::sequence<4, 0, true, 2>;
+	struct old_ecgi_t : ECGI
+	{
+		static constexpr const char* name() {return "old_ecgi_t";}
+		using parent_t = ECGI;
+
+	};
+	old_ecgi_t& ref_old_ecgi() {return old_ecgi;}
+	old_ecgi_t const& ref_old_ecgi() const {return old_ecgi;}
+	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<ServedCellsToModify_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ServedCellsToModify_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(old_ecgi);
+		v(servedCellInfo);
+		v(neighbour_Info);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(old_ecgi);
+		v(servedCellInfo);
+		v(neighbour_Info);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		old_ecgi.clear();
+		servedCellInfo.clear();
+		neighbour_Info.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	old_ecgi_t	old_ecgi;
+	servedCellInfo_t	servedCellInfo;
+	neighbour_Info_t	neighbour_Info;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ServedCellsToModify::= SEQUENCE (SIZE (1..maxCellineNB)) OF ServedCellsToModify-Item
+*/
+
+struct ServedCellsToModify_elm : ServedCellsToModify_Item
+{
+	static constexpr const char* name() {return "ServedCellsToModify_elm";}
+	using parent_t = ServedCellsToModify_Item;
+
+};
+struct ServedCellsToModify : asn::sequenceof<ServedCellsToModify_elm>
+{
+	static constexpr const char* name() {return "ServedCellsToModify";}
+	using parent_t = asn::sequenceof<ServedCellsToModify_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+Old-ECGIs::= SEQUENCE (SIZE (1..maxCellineNB)) OF ECGI
+*/
+
+struct Old_ECGIs_elm : ECGI
+{
+	static constexpr const char* name() {return "Old_ECGIs_elm";}
+	using parent_t = ECGI;
+
+};
+struct Old_ECGIs : asn::sequenceof<Old_ECGIs_elm>
+{
+	static constexpr const char* name() {return "Old-ECGIs";}
+	using parent_t = asn::sequenceof<Old_ECGIs_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+ENBConfigurationUpdate-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ServedCellsToAdd			CRITICALITY reject	TYPE ServedCells					PRESENCE optional}|
+	{ ID id-ServedCellsToModify			CRITICALITY reject	TYPE ServedCellsToModify			PRESENCE optional}|
+	{ ID id-ServedCellsToDelete			CRITICALITY reject	TYPE Old-ECGIs						PRESENCE optional}|
+	{ ID id-GUGroupIDToAddList			CRITICALITY reject	TYPE GUGroupIDList					PRESENCE optional}|
+	{ ID id-GUGroupIDToDeleteList		CRITICALITY reject	TYPE GUGroupIDList					PRESENCE optional}|
+	{ ID id-CoverageModificationList	CRITICALITY reject	TYPE CoverageModificationList		PRESENCE optional},
+	...
+}
+*/
+
+struct ENBConfigurationUpdate_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_ServedCellsToAdd() { set(id_ServedCellsToAdd); type=1;}
+		void select_id_ServedCellsToModify() { set(id_ServedCellsToModify); type=2;}
+		void select_id_ServedCellsToDelete() { set(id_ServedCellsToDelete); type=3;}
+		void select_id_GUGroupIDToAddList() { set(id_GUGroupIDToAddList); type=4;}
+		void select_id_GUGroupIDToDeleteList() { set(id_GUGroupIDToDeleteList); type=5;}
+		void select_id_CoverageModificationList() { set(id_CoverageModificationList); type=6;}
+		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_ServedCellsToAdd)) { type = 1; return true; }
+			else if(equal(id_ServedCellsToModify)) { type = 2; return true; }
+			else if(equal(id_ServedCellsToDelete)) { type = 3; return true; }
+			else if(equal(id_GUGroupIDToAddList)) { type = 4; return true; }
+			else if(equal(id_GUGroupIDToDeleteList)) { type = 5; return true; }
+			else if(equal(id_CoverageModificationList)) { 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_ServedCellsToAdd);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedCellsToModify);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_ServedCellsToDelete);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_GUGroupIDToAddList);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_GUGroupIDToDeleteList);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_CoverageModificationList);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_ServedCellsToAdd() { set(reject); type=1;}
+		void select_id_ServedCellsToModify() { set(reject); type=2;}
+		void select_id_ServedCellsToDelete() { set(reject); type=3;}
+		void select_id_GUGroupIDToAddList() { set(reject); type=4;}
+		void select_id_GUGroupIDToDeleteList() { set(reject); type=5;}
+		void select_id_CoverageModificationList() { set(reject); type=6;}
+		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 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(reject)) { type = 5; return true; }
+			else if(equal(reject)) { 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(reject);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		ServedCells& select_id_ServedCellsToAdd() { return set<ServedCells>(1); }
+		ServedCells const* get_id_ServedCellsToAdd() const { return get<ServedCells>(1); }
+		ServedCellsToModify& select_id_ServedCellsToModify() { return set<ServedCellsToModify>(2); }
+		ServedCellsToModify const* get_id_ServedCellsToModify() const { return get<ServedCellsToModify>(2); }
+		Old_ECGIs& select_id_ServedCellsToDelete() { return set<Old_ECGIs>(3); }
+		Old_ECGIs const* get_id_ServedCellsToDelete() const { return get<Old_ECGIs>(3); }
+		GUGroupIDList& select_id_GUGroupIDToAddList() { return set<GUGroupIDList>(4); }
+		GUGroupIDList const* get_id_GUGroupIDToAddList() const { return get<GUGroupIDList>(4); }
+		GUGroupIDList& select_id_GUGroupIDToDeleteList() { return set<GUGroupIDList>(5); }
+		GUGroupIDList const* get_id_GUGroupIDToDeleteList() const { return get<GUGroupIDList>(5); }
+		CoverageModificationList& select_id_CoverageModificationList() { return set<CoverageModificationList>(6); }
+		CoverageModificationList const* get_id_CoverageModificationList() const { return get<CoverageModificationList>(6); }
+		bool is_unknown() const { return type == 7; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ServedCells>(); break;
+			case 2: var.destroy<ServedCellsToModify>(); break;
+			case 3: var.destroy<Old_ECGIs>(); break;
+			case 4: var.destroy<GUGroupIDList>(); break;
+			case 5: var.destroy<GUGroupIDList>(); break;
+			case 6: var.destroy<CoverageModificationList>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ServedCells>(1);
+			v.template operator()<ServedCellsToModify>(2);
+			v.template operator()<Old_ECGIs>(3);
+			v.template operator()<GUGroupIDList>(4);
+			v.template operator()<GUGroupIDList>(5);
+			v.template operator()<CoverageModificationList>(6);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ServedCellsToAdd()); return true;
+			case 2: v(select_id_ServedCellsToModify()); return true;
+			case 3: v(select_id_ServedCellsToDelete()); return true;
+			case 4: v(select_id_GUGroupIDToAddList()); return true;
+			case 5: v(select_id_GUGroupIDToDeleteList()); return true;
+			case 6: v(select_id_CoverageModificationList()); 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<ServedCells>()); return true;
+			case 2: v(var.as<ServedCellsToModify>()); return true;
+			case 3: v(var.as<Old_ECGIs>()); return true;
+			case 4: v(var.as<GUGroupIDList>()); return true;
+			case 5: v(var.as<GUGroupIDList>()); return true;
+			case 6: v(var.as<CoverageModificationList>()); 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(CoverageModificationList)];
+			char dummy2[sizeof(GUGroupIDList)];
+			char dummy3[sizeof(Old_ECGIs)];
+			char dummy4[sizeof(ServedCells)];
+			char dummy5[sizeof(ServedCellsToModify)];
+
+		};
+		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 == 7; }
+		void clear() {type = 0;}
+		void select_id_ServedCellsToAdd() { set(optional); type=1;}
+		void select_id_ServedCellsToModify() { set(optional); type=2;}
+		void select_id_ServedCellsToDelete() { set(optional); type=3;}
+		void select_id_GUGroupIDToAddList() { set(optional); type=4;}
+		void select_id_GUGroupIDToDeleteList() { set(optional); type=5;}
+		void select_id_CoverageModificationList() { set(optional); type=6;}
+		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(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};
+
+	};
+
+};
+/*
+ENBConfigurationUpdate ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENBConfigurationUpdate-IEs}},
+	...
+}
+*/
+
+struct ENBConfigurationUpdate : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENBConfigurationUpdate";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENBConfigurationUpdate_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENBConfigurationUpdate_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ENBConfigurationUpdateAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-CriticalityDiagnostics		CRITICALITY ignore	TYPE CriticalityDiagnostics			PRESENCE optional},
+...
+}
+*/
+
+struct ENBConfigurationUpdateAcknowledge_IEs
+{
+	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_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); 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_CriticalityDiagnostics)) { 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_CriticalityDiagnostics);} 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_CriticalityDiagnostics() { 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;}
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(1); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<CriticalityDiagnostics>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_CriticalityDiagnostics()); 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<CriticalityDiagnostics>()); 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(CriticalityDiagnostics)];
+
+		};
+		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_CriticalityDiagnostics() { set(optional); 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(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};
+
+	};
+
+};
+/*
+ENBConfigurationUpdateAcknowledge ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENBConfigurationUpdateAcknowledge-IEs}},
+	...
+}
+*/
+
+struct ENBConfigurationUpdateAcknowledge : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENBConfigurationUpdateAcknowledge";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENBConfigurationUpdateAcknowledge_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENBConfigurationUpdateAcknowledge_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ENBConfigurationUpdateFailure-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Cause						CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-TimeToWait					CRITICALITY ignore	TYPE TimeToWait					PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics		CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional},
+	...
+}
+*/
+
+struct ENBConfigurationUpdateFailure_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(id_Cause); type=1;}
+		void select_id_TimeToWait() { set(id_TimeToWait); type=2;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
+		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_Cause)) { type = 1; return true; }
+			else if(equal(id_TimeToWait)) { type = 2; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { 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_Cause);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_TimeToWait);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(ignore); type=1;}
+		void select_id_TimeToWait() { set(ignore); type=2;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
+		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 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		Cause& select_id_Cause() { return set<Cause>(1); }
+		Cause const* get_id_Cause() const { return get<Cause>(1); }
+		TimeToWait& select_id_TimeToWait() { return set<TimeToWait>(2); }
+		TimeToWait const* get_id_TimeToWait() const { return get<TimeToWait>(2); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Cause>(); break;
+			case 2: var.destroy<TimeToWait>(); break;
+			case 3: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Cause>(1);
+			v.template operator()<TimeToWait>(2);
+			v.template operator()<CriticalityDiagnostics>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Cause()); return true;
+			case 2: v(select_id_TimeToWait()); return true;
+			case 3: v(select_id_CriticalityDiagnostics()); 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<Cause>()); return true;
+			case 2: v(var.as<TimeToWait>()); return true;
+			case 3: v(var.as<CriticalityDiagnostics>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(TimeToWait)];
+
+		};
+		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 == 4; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(mandatory); type=1;}
+		void select_id_TimeToWait() { set(optional); type=2;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=3;}
+		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 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(mandatory);} 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};
+
+	};
+
+};
+/*
+ENBConfigurationUpdateFailure ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENBConfigurationUpdateFailure-IEs}},
+	...
+}
+*/
+
+struct ENBConfigurationUpdateFailure : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENBConfigurationUpdateFailure";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENBConfigurationUpdateFailure_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENBConfigurationUpdateFailure_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ENDCCellActivationFailure-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ActivationID					CRITICALITY reject	TYPE ActivationID				PRESENCE mandatory }|
+	{ ID id-Cause						CRITICALITY ignore	TYPE Cause						PRESENCE mandatory }|
+	{ ID id-CriticalityDiagnostics		CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional },
+	...
+}
+*/
+
+struct ENDCCellActivationFailure_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_ActivationID() { set(id_ActivationID); type=1;}
+		void select_id_Cause() { set(id_Cause); type=2;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
+		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_ActivationID)) { type = 1; return true; }
+			else if(equal(id_Cause)) { type = 2; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { 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_ActivationID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_ActivationID() { set(reject); type=1;}
+		void select_id_Cause() { set(ignore); type=2;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
+		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 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(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		ActivationID& select_id_ActivationID() { return set<ActivationID>(1); }
+		ActivationID const* get_id_ActivationID() const { return get<ActivationID>(1); }
+		Cause& select_id_Cause() { return set<Cause>(2); }
+		Cause const* get_id_Cause() const { return get<Cause>(2); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ActivationID>(); break;
+			case 2: var.destroy<Cause>(); break;
+			case 3: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ActivationID>(1);
+			v.template operator()<Cause>(2);
+			v.template operator()<CriticalityDiagnostics>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ActivationID()); return true;
+			case 2: v(select_id_Cause()); return true;
+			case 3: v(select_id_CriticalityDiagnostics()); 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<ActivationID>()); return true;
+			case 2: v(var.as<Cause>()); return true;
+			case 3: v(var.as<CriticalityDiagnostics>()); 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(ActivationID)];
+			char dummy2[sizeof(Cause)];
+			char dummy3[sizeof(CriticalityDiagnostics)];
+
+		};
+		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 == 4; }
+		void clear() {type = 0;}
+		void select_id_ActivationID() { set(mandatory); type=1;}
+		void select_id_Cause() { set(mandatory); type=2;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=3;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+ENDCCellActivationFailure ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCCellActivationFailure-IEs}},
+	...
+}
+*/
+
+struct ENDCCellActivationFailure : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCCellActivationFailure";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCCellActivationFailure_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCCellActivationFailure_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ServedNRCellsToActivate-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ServedNRCellsToActivate_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};
+
+	};
+
+};
+/*
+ServedNRCellsToActivate-Item::= SEQUENCE {
+	nrCellID						NRCGI,
+	iE-Extensions					ProtocolExtensionContainer { {ServedNRCellsToActivate-Item-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ServedNRCellsToActivate_Item : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "ServedNRCellsToActivate-Item";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	struct nrCellID_t : NRCGI
+	{
+		static constexpr const char* name() {return "nrCellID_t";}
+		using parent_t = NRCGI;
+
+	};
+	nrCellID_t& ref_nrCellID() {return nrCellID;}
+	nrCellID_t const& ref_nrCellID() const {return nrCellID;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ServedNRCellsToActivate_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ServedNRCellsToActivate_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(nrCellID);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(nrCellID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		nrCellID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	nrCellID_t	nrCellID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ServedNRCellsToActivate::= SEQUENCE (SIZE (1.. maxCellinengNB)) OF ServedNRCellsToActivate-Item
+*/
+
+struct ServedNRCellsToActivate_elm : ServedNRCellsToActivate_Item
+{
+	static constexpr const char* name() {return "ServedNRCellsToActivate_elm";}
+	using parent_t = ServedNRCellsToActivate_Item;
+
+};
+struct ServedNRCellsToActivate : asn::sequenceof<ServedNRCellsToActivate_elm>
+{
+	static constexpr const char* name() {return "ServedNRCellsToActivate";}
+	using parent_t = asn::sequenceof<ServedNRCellsToActivate_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellinengNB >>;
+
+};
+/*
+ENDCCellActivationRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ServedNRCellsToActivate 	CRITICALITY reject	TYPE ServedNRCellsToActivate			PRESENCE mandatory}|
+	{ ID id-ActivationID			 	CRITICALITY reject	TYPE ActivationID					PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENDCCellActivationRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_ServedNRCellsToActivate() { set(id_ServedNRCellsToActivate); type=1;}
+		void select_id_ActivationID() { set(id_ActivationID); type=2;}
+		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_ServedNRCellsToActivate)) { type = 1; return true; }
+			else if(equal(id_ActivationID)) { 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_ServedNRCellsToActivate);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ActivationID);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_ServedNRCellsToActivate() { set(reject); type=1;}
+		void select_id_ActivationID() { set(reject); type=2;}
+		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 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(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		ServedNRCellsToActivate& select_id_ServedNRCellsToActivate() { return set<ServedNRCellsToActivate>(1); }
+		ServedNRCellsToActivate const* get_id_ServedNRCellsToActivate() const { return get<ServedNRCellsToActivate>(1); }
+		ActivationID& select_id_ActivationID() { return set<ActivationID>(2); }
+		ActivationID const* get_id_ActivationID() const { return get<ActivationID>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ServedNRCellsToActivate>(); break;
+			case 2: var.destroy<ActivationID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ServedNRCellsToActivate>(1);
+			v.template operator()<ActivationID>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ServedNRCellsToActivate()); return true;
+			case 2: v(select_id_ActivationID()); 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<ServedNRCellsToActivate>()); return true;
+			case 2: v(var.as<ActivationID>()); 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(ActivationID)];
+			char dummy2[sizeof(ServedNRCellsToActivate)];
+
+		};
+		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 == 3; }
+		void clear() {type = 0;}
+		void select_id_ServedNRCellsToActivate() { set(mandatory); type=1;}
+		void select_id_ActivationID() { set(mandatory); type=2;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+ENDCCellActivationRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCCellActivationRequest-IEs}},
+	...
+}
+*/
+
+struct ENDCCellActivationRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCCellActivationRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCCellActivationRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCCellActivationRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ENDCCellActivationResponse-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ActivatedNRCellList		CRITICALITY ignore	TYPE ActivatedNRCellList				PRESENCE mandatory}|
+	{ ID id-ActivationID				CRITICALITY reject	TYPE ActivationID					PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics	CRITICALITY ignore	TYPE CriticalityDiagnostics			PRESENCE optional},
+	...
+}
+*/
+
+struct ENDCCellActivationResponse_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_ActivatedNRCellList() { set(id_ActivatedNRCellList); type=1;}
+		void select_id_ActivationID() { set(id_ActivationID); type=2;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
+		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_ActivatedNRCellList)) { type = 1; return true; }
+			else if(equal(id_ActivationID)) { type = 2; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { 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_ActivatedNRCellList);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ActivationID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_ActivatedNRCellList() { set(ignore); type=1;}
+		void select_id_ActivationID() { set(reject); type=2;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
+		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 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		ActivatedNRCellList& select_id_ActivatedNRCellList() { return set<ActivatedNRCellList>(1); }
+		ActivatedNRCellList const* get_id_ActivatedNRCellList() const { return get<ActivatedNRCellList>(1); }
+		ActivationID& select_id_ActivationID() { return set<ActivationID>(2); }
+		ActivationID const* get_id_ActivationID() const { return get<ActivationID>(2); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ActivatedNRCellList>(); break;
+			case 2: var.destroy<ActivationID>(); break;
+			case 3: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ActivatedNRCellList>(1);
+			v.template operator()<ActivationID>(2);
+			v.template operator()<CriticalityDiagnostics>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ActivatedNRCellList()); return true;
+			case 2: v(select_id_ActivationID()); return true;
+			case 3: v(select_id_CriticalityDiagnostics()); 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<ActivatedNRCellList>()); return true;
+			case 2: v(var.as<ActivationID>()); return true;
+			case 3: v(var.as<CriticalityDiagnostics>()); 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(ActivatedNRCellList)];
+			char dummy2[sizeof(ActivationID)];
+			char dummy3[sizeof(CriticalityDiagnostics)];
+
+		};
+		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 == 4; }
+		void clear() {type = 0;}
+		void select_id_ActivatedNRCellList() { set(mandatory); type=1;}
+		void select_id_ActivationID() { set(mandatory); type=2;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=3;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+ENDCCellActivationResponse ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCCellActivationResponse-IEs}},
+	...
+}
+*/
+
+struct ENDCCellActivationResponse : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCCellActivationResponse";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCCellActivationResponse_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCCellActivationResponse_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+FDD-InfoServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct FDD_InfoServedNRCell_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};
+
+	};
+
+};
+/*
+FDD-InfoServedNRCell-Information ::= SEQUENCE {
+	ul-NRFreqInfo				NRFreqInfo,
+	dl-NRFreqInfo				NRFreqInfo,
+	ul-NR-TxBW				NR-TxBW,
+	dl-NR-TxBW				NR-TxBW,
+	iE-Extensions			ProtocolExtensionContainer { {FDD-InfoServedNRCell-Information-ExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct FDD_InfoServedNRCell_Information : asn::sequence<5, 0, true, 1>
+{
+	static constexpr const char* name() {return "FDD-InfoServedNRCell-Information";}
+	using parent_t = asn::sequence<5, 0, true, 1>;
+	struct ul_NRFreqInfo_t : NRFreqInfo
+	{
+		static constexpr const char* name() {return "ul_NRFreqInfo_t";}
+		using parent_t = NRFreqInfo;
+
+	};
+	ul_NRFreqInfo_t& ref_ul_NRFreqInfo() {return ul_NRFreqInfo;}
+	ul_NRFreqInfo_t const& ref_ul_NRFreqInfo() const {return ul_NRFreqInfo;}
+	struct dl_NRFreqInfo_t : NRFreqInfo
+	{
+		static constexpr const char* name() {return "dl_NRFreqInfo_t";}
+		using parent_t = NRFreqInfo;
+
+	};
+	dl_NRFreqInfo_t& ref_dl_NRFreqInfo() {return dl_NRFreqInfo;}
+	dl_NRFreqInfo_t const& ref_dl_NRFreqInfo() const {return dl_NRFreqInfo;}
+	struct ul_NR_TxBW_t : NR_TxBW
+	{
+		static constexpr const char* name() {return "ul_NR_TxBW_t";}
+		using parent_t = NR_TxBW;
+
+	};
+	ul_NR_TxBW_t& ref_ul_NR_TxBW() {return ul_NR_TxBW;}
+	ul_NR_TxBW_t const& ref_ul_NR_TxBW() const {return ul_NR_TxBW;}
+	struct dl_NR_TxBW_t : NR_TxBW
+	{
+		static constexpr const char* name() {return "dl_NR_TxBW_t";}
+		using parent_t = NR_TxBW;
+
+	};
+	dl_NR_TxBW_t& ref_dl_NR_TxBW() {return dl_NR_TxBW;}
+	dl_NR_TxBW_t const& ref_dl_NR_TxBW() const {return dl_NR_TxBW;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<FDD_InfoServedNRCell_Information_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<FDD_InfoServedNRCell_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(ul_NRFreqInfo);
+		v(dl_NRFreqInfo);
+		v(ul_NR_TxBW);
+		v(dl_NR_TxBW);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(ul_NRFreqInfo);
+		v(dl_NRFreqInfo);
+		v(ul_NR_TxBW);
+		v(dl_NR_TxBW);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		ul_NRFreqInfo.clear();
+		dl_NRFreqInfo.clear();
+		ul_NR_TxBW.clear();
+		dl_NR_TxBW.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	ul_NRFreqInfo_t	ul_NRFreqInfo;
+	dl_NRFreqInfo_t	dl_NRFreqInfo;
+	ul_NR_TxBW_t	ul_NR_TxBW;
+	dl_NR_TxBW_t	dl_NR_TxBW;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+TDD-InfoServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct TDD_InfoServedNRCell_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};
+
+	};
+
+};
+/*
+TDD-InfoServedNRCell-Information ::= SEQUENCE {
+	nRFreqInfo				NRFreqInfo,
+	nR-TxBW					NR-TxBW,
+	iE-Extensions			ProtocolExtensionContainer { {TDD-InfoServedNRCell-Information-ExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct TDD_InfoServedNRCell_Information : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "TDD-InfoServedNRCell-Information";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct nRFreqInfo_t : NRFreqInfo
+	{
+		static constexpr const char* name() {return "nRFreqInfo_t";}
+		using parent_t = NRFreqInfo;
+
+	};
+	nRFreqInfo_t& ref_nRFreqInfo() {return nRFreqInfo;}
+	nRFreqInfo_t const& ref_nRFreqInfo() const {return nRFreqInfo;}
+	struct nR_TxBW_t : NR_TxBW
+	{
+		static constexpr const char* name() {return "nR_TxBW_t";}
+		using parent_t = NR_TxBW;
+
+	};
+	nR_TxBW_t& ref_nR_TxBW() {return nR_TxBW;}
+	nR_TxBW_t const& ref_nR_TxBW() const {return nR_TxBW;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<TDD_InfoServedNRCell_Information_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<TDD_InfoServedNRCell_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(nRFreqInfo);
+		v(nR_TxBW);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(nRFreqInfo);
+		v(nR_TxBW);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		nRFreqInfo.clear();
+		nR_TxBW.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	nRFreqInfo_t	nRFreqInfo;
+	nR_TxBW_t	nR_TxBW;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ServedNRCell_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};
+
+	};
+
+};
+/*
+ServedNRCell-Information ::= SEQUENCE {
+	nrpCI				NRPCI,
+	nrCellID			NRCGI,
+	fiveGS-TAC			FiveGS-TAC	OPTIONAL,
+	configured-TAC		TAC			OPTIONAL,
+	broadcastPLMNs		BroadcastPLMNs-Item,
+	nrModeInfo			CHOICE {
+		fdd		FDD-InfoServedNRCell-Information,
+		tdd		TDD-InfoServedNRCell-Information,
+		...
+	},
+	measurementTimingConfiguration	OCTET STRING,
+	iE-Extensions						ProtocolExtensionContainer { {ServedNRCell-Information-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ServedNRCell_Information : asn::sequence<8, 0, true, 3>
+{
+	static constexpr const char* name() {return "ServedNRCell-Information";}
+	using parent_t = asn::sequence<8, 0, true, 3>;
+	struct nrpCI_t : NRPCI
+	{
+		static constexpr const char* name() {return "nrpCI_t";}
+		using parent_t = NRPCI;
+
+	};
+	nrpCI_t& ref_nrpCI() {return nrpCI;}
+	nrpCI_t const& ref_nrpCI() const {return nrpCI;}
+	struct nrCellID_t : NRCGI
+	{
+		static constexpr const char* name() {return "nrCellID_t";}
+		using parent_t = NRCGI;
+
+	};
+	nrCellID_t& ref_nrCellID() {return nrCellID;}
+	nrCellID_t const& ref_nrCellID() const {return nrCellID;}
+	struct fiveGS_TAC_t : FiveGS_TAC
+	{
+		static constexpr const char* name() {return "fiveGS_TAC_t";}
+		using parent_t = FiveGS_TAC;
+		static constexpr bool optional = true;
+
+	};
+	fiveGS_TAC_t& set_fiveGS_TAC() { fiveGS_TAC.setpresent(true); return fiveGS_TAC;}
+	fiveGS_TAC_t const* get_fiveGS_TAC() const {return fiveGS_TAC.is_valid() ? &fiveGS_TAC : nullptr;}
+	struct configured_TAC_t : TAC
+	{
+		static constexpr const char* name() {return "configured_TAC_t";}
+		using parent_t = TAC;
+		static constexpr bool optional = true;
+
+	};
+	configured_TAC_t& set_configured_TAC() { configured_TAC.setpresent(true); return configured_TAC;}
+	configured_TAC_t const* get_configured_TAC() const {return configured_TAC.is_valid() ? &configured_TAC : nullptr;}
+	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 nrModeInfo_t : asn::choice<2, 0, true>
+	{
+		static constexpr const char* name() {return "nrModeInfo_t";}
+		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);  }
+		~nrModeInfo_t() {clear();}
+		struct fdd_t : FDD_InfoServedNRCell_Information
+		{
+			static constexpr const char* name() {return "fdd_t";}
+			using parent_t = FDD_InfoServedNRCell_Information;
+
+		};
+		struct tdd_t : TDD_InfoServedNRCell_Information
+		{
+			static constexpr const char* name() {return "tdd_t";}
+			using parent_t = TDD_InfoServedNRCell_Information;
+
+		};
+		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};
+	};
+	nrModeInfo_t& ref_nrModeInfo() {return nrModeInfo;}
+	nrModeInfo_t const& ref_nrModeInfo() const {return nrModeInfo;}
+	struct measurementTimingConfiguration_t : asn::ostring<>
+	{
+		static constexpr const char* name() {return "measurementTimingConfiguration_t";}
+		using parent_t = asn::ostring<>;
+
+	};
+
+	measurementTimingConfiguration_t& ref_measurementTimingConfiguration() {return measurementTimingConfiguration;}
+	measurementTimingConfiguration_t const& ref_measurementTimingConfiguration() const {return measurementTimingConfiguration;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ServedNRCell_Information_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ServedNRCell_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(nrpCI);
+		v(nrCellID);
+		v(fiveGS_TAC);
+		v(configured_TAC);
+		v(broadcastPLMNs);
+		v(nrModeInfo);
+		v(measurementTimingConfiguration);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(nrpCI);
+		v(nrCellID);
+		v(fiveGS_TAC);
+		v(configured_TAC);
+		v(broadcastPLMNs);
+		v(nrModeInfo);
+		v(measurementTimingConfiguration);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		nrpCI.clear();
+		nrCellID.clear();
+		fiveGS_TAC.clear();
+		configured_TAC.clear();
+		broadcastPLMNs.clear();
+		nrModeInfo.clear();
+		measurementTimingConfiguration.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	nrpCI_t	nrpCI;
+	nrCellID_t	nrCellID;
+	fiveGS_TAC_t	fiveGS_TAC;
+	configured_TAC_t	configured_TAC;
+	broadcastPLMNs_t	broadcastPLMNs;
+	nrModeInfo_t	nrModeInfo;
+	measurementTimingConfiguration_t	measurementTimingConfiguration;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+En-gNBServedCells-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct En_gNBServedCells_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};
+
+	};
+
+};
+/*
+ServedNRcellsENDCX2ManagementList ::= SEQUENCE (SIZE (1.. maxCellinengNB)) OF SEQUENCE {
+	servedNRCellInfo						ServedNRCell-Information,
+	nRNeighbourInfo						NRNeighbour-Information OPTIONAL,
+	iE-Extensions						ProtocolExtensionContainer { {En-gNBServedCells-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ServedNRcellsENDCX2ManagementList_elm : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "ServedNRcellsENDCX2ManagementList_elm";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	struct servedNRCellInfo_t : ServedNRCell_Information
+	{
+		static constexpr const char* name() {return "servedNRCellInfo_t";}
+		using parent_t = ServedNRCell_Information;
+
+	};
+	servedNRCellInfo_t& ref_servedNRCellInfo() {return servedNRCellInfo;}
+	servedNRCellInfo_t const& ref_servedNRCellInfo() const {return servedNRCellInfo;}
+	struct nRNeighbourInfo_t : NRNeighbour_Information
+	{
+		static constexpr const char* name() {return "nRNeighbourInfo_t";}
+		using parent_t = NRNeighbour_Information;
+		static constexpr bool optional = true;
+
+	};
+	nRNeighbourInfo_t& set_nRNeighbourInfo() { nRNeighbourInfo.setpresent(true); return nRNeighbourInfo;}
+	nRNeighbourInfo_t const* get_nRNeighbourInfo() const {return nRNeighbourInfo.is_valid() ? &nRNeighbourInfo : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<En_gNBServedCells_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<En_gNBServedCells_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(servedNRCellInfo);
+		v(nRNeighbourInfo);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(servedNRCellInfo);
+		v(nRNeighbourInfo);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		servedNRCellInfo.clear();
+		nRNeighbourInfo.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	servedNRCellInfo_t	servedNRCellInfo;
+	nRNeighbourInfo_t	nRNeighbourInfo;
+	iE_Extensions_t	iE_Extensions;
+
+};
+struct ServedNRcellsENDCX2ManagementList : asn::sequenceof<ServedNRcellsENDCX2ManagementList_elm>
+{
+	static constexpr const char* name() {return "ServedNRcellsENDCX2ManagementList";}
+	using parent_t = asn::sequenceof<ServedNRcellsENDCX2ManagementList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellinengNB >>;
+
+};
+/*
+ServedNRCellsToModify-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ServedNRCellsToModify_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};
+
+	};
+
+};
+/*
+ServedNRCellsToModify-Item::= SEQUENCE {
+	old-nrcgi						NRCGI,
+	servedNRCellInformation			ServedNRCell-Information,
+	nrNeighbourInformation			NRNeighbour-Information			OPTIONAL,
+	nrDeactivationIndication			DeactivationIndication			OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {ServedNRCellsToModify-Item-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct ServedNRCellsToModify_Item : asn::sequence<5, 0, true, 3>
+{
+	static constexpr const char* name() {return "ServedNRCellsToModify-Item";}
+	using parent_t = asn::sequence<5, 0, true, 3>;
+	struct old_nrcgi_t : NRCGI
+	{
+		static constexpr const char* name() {return "old_nrcgi_t";}
+		using parent_t = NRCGI;
+
+	};
+	old_nrcgi_t& ref_old_nrcgi() {return old_nrcgi;}
+	old_nrcgi_t const& ref_old_nrcgi() const {return old_nrcgi;}
+	struct servedNRCellInformation_t : ServedNRCell_Information
+	{
+		static constexpr const char* name() {return "servedNRCellInformation_t";}
+		using parent_t = ServedNRCell_Information;
+
+	};
+	servedNRCellInformation_t& ref_servedNRCellInformation() {return servedNRCellInformation;}
+	servedNRCellInformation_t const& ref_servedNRCellInformation() const {return servedNRCellInformation;}
+	struct nrNeighbourInformation_t : NRNeighbour_Information
+	{
+		static constexpr const char* name() {return "nrNeighbourInformation_t";}
+		using parent_t = NRNeighbour_Information;
+		static constexpr bool optional = true;
+
+	};
+	nrNeighbourInformation_t& set_nrNeighbourInformation() { nrNeighbourInformation.setpresent(true); return nrNeighbourInformation;}
+	nrNeighbourInformation_t const* get_nrNeighbourInformation() const {return nrNeighbourInformation.is_valid() ? &nrNeighbourInformation : nullptr;}
+	struct nrDeactivationIndication_t : DeactivationIndication
+	{
+		static constexpr const char* name() {return "nrDeactivationIndication_t";}
+		using parent_t = DeactivationIndication;
+		static constexpr bool optional = true;
+
+	};
+	nrDeactivationIndication_t& set_nrDeactivationIndication() { nrDeactivationIndication.setpresent(true); return nrDeactivationIndication;}
+	nrDeactivationIndication_t const* get_nrDeactivationIndication() const {return nrDeactivationIndication.is_valid() ? &nrDeactivationIndication : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ServedNRCellsToModify_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ServedNRCellsToModify_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(old_nrcgi);
+		v(servedNRCellInformation);
+		v(nrNeighbourInformation);
+		v(nrDeactivationIndication);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(old_nrcgi);
+		v(servedNRCellInformation);
+		v(nrNeighbourInformation);
+		v(nrDeactivationIndication);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		old_nrcgi.clear();
+		servedNRCellInformation.clear();
+		nrNeighbourInformation.clear();
+		nrDeactivationIndication.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	old_nrcgi_t	old_nrcgi;
+	servedNRCellInformation_t	servedNRCellInformation;
+	nrNeighbourInformation_t	nrNeighbourInformation;
+	nrDeactivationIndication_t	nrDeactivationIndication;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ServedNRcellsToModifyENDCConfUpdList ::= SEQUENCE (SIZE (1..maxCellinengNB)) OF ServedNRCellsToModify-Item
+*/
+
+struct ServedNRcellsToModifyENDCConfUpdList_elm : ServedNRCellsToModify_Item
+{
+	static constexpr const char* name() {return "ServedNRcellsToModifyENDCConfUpdList_elm";}
+	using parent_t = ServedNRCellsToModify_Item;
+
+};
+struct ServedNRcellsToModifyENDCConfUpdList : asn::sequenceof<ServedNRcellsToModifyENDCConfUpdList_elm>
+{
+	static constexpr const char* name() {return "ServedNRcellsToModifyENDCConfUpdList";}
+	using parent_t = asn::sequenceof<ServedNRcellsToModifyENDCConfUpdList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellinengNB >>;
+
+};
+/*
+ServedNRcellsToDeleteENDCConfUpdList ::= SEQUENCE (SIZE (1..maxCellinengNB)) OF NRCGI
+*/
+
+struct ServedNRcellsToDeleteENDCConfUpdList_elm : NRCGI
+{
+	static constexpr const char* name() {return "ServedNRcellsToDeleteENDCConfUpdList_elm";}
+	using parent_t = NRCGI;
+
+};
+struct ServedNRcellsToDeleteENDCConfUpdList : asn::sequenceof<ServedNRcellsToDeleteENDCConfUpdList_elm>
+{
+	static constexpr const char* name() {return "ServedNRcellsToDeleteENDCConfUpdList";}
+	using parent_t = asn::sequenceof<ServedNRcellsToDeleteENDCConfUpdList_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellinengNB >>;
+
+};
+/*
+En-gNB-ENDCConfigUpdateIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ServedNRcellsENDCX2ManagementList		CRITICALITY reject	TYPE ServedNRcellsENDCX2ManagementList			PRESENCE optional }|
+	{ ID id-ServedNRcellsToModifyListENDCConfUpd		CRITICALITY reject	TYPE ServedNRcellsToModifyENDCConfUpdList		PRESENCE optional }|
+	{ ID id-ServedNRcellsToDeleteListENDCConfUpd		CRITICALITY reject	TYPE ServedNRcellsToDeleteENDCConfUpdList		PRESENCE optional },
+	...
+}
+*/
+
+struct En_gNB_ENDCConfigUpdateIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_ServedNRcellsENDCX2ManagementList() { set(id_ServedNRcellsENDCX2ManagementList); type=1;}
+		void select_id_ServedNRcellsToModifyListENDCConfUpd() { set(id_ServedNRcellsToModifyListENDCConfUpd); type=2;}
+		void select_id_ServedNRcellsToDeleteListENDCConfUpd() { set(id_ServedNRcellsToDeleteListENDCConfUpd); type=3;}
+		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_ServedNRcellsENDCX2ManagementList)) { type = 1; return true; }
+			else if(equal(id_ServedNRcellsToModifyListENDCConfUpd)) { type = 2; return true; }
+			else if(equal(id_ServedNRcellsToDeleteListENDCConfUpd)) { 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_ServedNRcellsENDCX2ManagementList);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedNRcellsToModifyListENDCConfUpd);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_ServedNRcellsToDeleteListENDCConfUpd);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_ServedNRcellsENDCX2ManagementList() { set(reject); type=1;}
+		void select_id_ServedNRcellsToModifyListENDCConfUpd() { set(reject); type=2;}
+		void select_id_ServedNRcellsToDeleteListENDCConfUpd() { set(reject); type=3;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(reject)) { 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		ServedNRcellsENDCX2ManagementList& select_id_ServedNRcellsENDCX2ManagementList() { return set<ServedNRcellsENDCX2ManagementList>(1); }
+		ServedNRcellsENDCX2ManagementList const* get_id_ServedNRcellsENDCX2ManagementList() const { return get<ServedNRcellsENDCX2ManagementList>(1); }
+		ServedNRcellsToModifyENDCConfUpdList& select_id_ServedNRcellsToModifyListENDCConfUpd() { return set<ServedNRcellsToModifyENDCConfUpdList>(2); }
+		ServedNRcellsToModifyENDCConfUpdList const* get_id_ServedNRcellsToModifyListENDCConfUpd() const { return get<ServedNRcellsToModifyENDCConfUpdList>(2); }
+		ServedNRcellsToDeleteENDCConfUpdList& select_id_ServedNRcellsToDeleteListENDCConfUpd() { return set<ServedNRcellsToDeleteENDCConfUpdList>(3); }
+		ServedNRcellsToDeleteENDCConfUpdList const* get_id_ServedNRcellsToDeleteListENDCConfUpd() const { return get<ServedNRcellsToDeleteENDCConfUpdList>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ServedNRcellsENDCX2ManagementList>(); break;
+			case 2: var.destroy<ServedNRcellsToModifyENDCConfUpdList>(); break;
+			case 3: var.destroy<ServedNRcellsToDeleteENDCConfUpdList>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ServedNRcellsENDCX2ManagementList>(1);
+			v.template operator()<ServedNRcellsToModifyENDCConfUpdList>(2);
+			v.template operator()<ServedNRcellsToDeleteENDCConfUpdList>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ServedNRcellsENDCX2ManagementList()); return true;
+			case 2: v(select_id_ServedNRcellsToModifyListENDCConfUpd()); return true;
+			case 3: v(select_id_ServedNRcellsToDeleteListENDCConfUpd()); 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<ServedNRcellsENDCX2ManagementList>()); return true;
+			case 2: v(var.as<ServedNRcellsToModifyENDCConfUpdList>()); return true;
+			case 3: v(var.as<ServedNRcellsToDeleteENDCConfUpdList>()); 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(ServedNRcellsENDCX2ManagementList)];
+			char dummy2[sizeof(ServedNRcellsToDeleteENDCConfUpdList)];
+			char dummy3[sizeof(ServedNRcellsToModifyENDCConfUpdList)];
+
+		};
+		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 == 4; }
+		void clear() {type = 0;}
+		void select_id_ServedNRcellsENDCX2ManagementList() { set(optional); type=1;}
+		void select_id_ServedNRcellsToModifyListENDCConfUpd() { set(optional); type=2;}
+		void select_id_ServedNRcellsToDeleteListENDCConfUpd() { set(optional); type=3;}
+		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(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};
+
+	};
+
+};
+/*
+InitiatingNodeType-EndcConfigUpdate::= CHOICE {
+	init-eNB			ProtocolIE-Container	{{ENB-ENDCConfigUpdateIEs}},
+	init-en-gNB			ProtocolIE-Container	{{En-gNB-ENDCConfigUpdateIEs}},
+	...
+}
+*/
+
+struct InitiatingNodeType_EndcConfigUpdate : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "InitiatingNodeType-EndcConfigUpdate";}
+	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);  }
+	~InitiatingNodeType_EndcConfigUpdate() {clear();}
+	struct init_eNB_t : ProtocolIE_Container<ENB_ENDCConfigUpdateIEs>
+	{
+		static constexpr const char* name() {return "init_eNB_t";}
+		using parent_t = ProtocolIE_Container<ENB_ENDCConfigUpdateIEs>;
+
+	};
+	struct init_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCConfigUpdateIEs>
+	{
+		static constexpr const char* name() {return "init_en_gNB_t";}
+		using parent_t = ProtocolIE_Container<En_gNB_ENDCConfigUpdateIEs>;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<init_eNB_t>(); break;
+		case 2: var.destroy<init_en_gNB_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<init_eNB_t>());
+		case 2: set_index(2); return v(var.build<init_en_gNB_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<init_eNB_t>());
+		case 2: return v(var.as<init_en_gNB_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<init_eNB_t>(1);
+		v.template operator()<init_en_gNB_t>(2);
+
+	}
+	init_eNB_t& select_init_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<init_eNB_t>();} return var.as<init_eNB_t>();}
+	init_eNB_t const* get_init_eNB() const { if(get_index() == 1) { return &var.as<init_eNB_t>();} return nullptr; }
+	init_en_gNB_t& select_init_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<init_en_gNB_t>();} return var.as<init_en_gNB_t>();}
+	init_en_gNB_t const* get_init_en_gNB() const { if(get_index() == 2) { return &var.as<init_en_gNB_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(init_eNB_t)];
+		char dummy2[sizeof(init_en_gNB_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+ENDCConfigurationUpdate-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-InitiatingNodeType-EndcConfigUpdate			CRITICALITY reject	TYPE InitiatingNodeType-EndcConfigUpdate			PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENDCConfigurationUpdate_IEs
+{
+	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_InitiatingNodeType_EndcConfigUpdate() { set(id_InitiatingNodeType_EndcConfigUpdate); 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_InitiatingNodeType_EndcConfigUpdate)) { 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_InitiatingNodeType_EndcConfigUpdate);} 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_InitiatingNodeType_EndcConfigUpdate() { 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;}
+		InitiatingNodeType_EndcConfigUpdate& select_id_InitiatingNodeType_EndcConfigUpdate() { return set<InitiatingNodeType_EndcConfigUpdate>(1); }
+		InitiatingNodeType_EndcConfigUpdate const* get_id_InitiatingNodeType_EndcConfigUpdate() const { return get<InitiatingNodeType_EndcConfigUpdate>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<InitiatingNodeType_EndcConfigUpdate>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<InitiatingNodeType_EndcConfigUpdate>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_InitiatingNodeType_EndcConfigUpdate()); 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<InitiatingNodeType_EndcConfigUpdate>()); 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(InitiatingNodeType_EndcConfigUpdate)];
+
+		};
+		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_InitiatingNodeType_EndcConfigUpdate() { 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};
+
+	};
+
+};
+/*
+ENDCConfigurationUpdate ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCConfigurationUpdate-IEs}},
+	...
+}
+*/
+
+struct ENDCConfigurationUpdate : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCConfigurationUpdate";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCConfigurationUpdate_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCConfigurationUpdate_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+En-gNB-ENDCConfigUpdateAckIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ServedNRcellsENDCX2ManagementList		CRITICALITY reject	TYPE ServedNRcellsENDCX2ManagementList		PRESENCE optional},
+	...
+}
+*/
+
+struct En_gNB_ENDCConfigUpdateAckIEs
+{
+	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_ServedNRcellsENDCX2ManagementList() { set(id_ServedNRcellsENDCX2ManagementList); 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_ServedNRcellsENDCX2ManagementList)) { 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_ServedNRcellsENDCX2ManagementList);} 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_ServedNRcellsENDCX2ManagementList() { 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;}
+		ServedNRcellsENDCX2ManagementList& select_id_ServedNRcellsENDCX2ManagementList() { return set<ServedNRcellsENDCX2ManagementList>(1); }
+		ServedNRcellsENDCX2ManagementList const* get_id_ServedNRcellsENDCX2ManagementList() const { return get<ServedNRcellsENDCX2ManagementList>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ServedNRcellsENDCX2ManagementList>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ServedNRcellsENDCX2ManagementList>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ServedNRcellsENDCX2ManagementList()); 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<ServedNRcellsENDCX2ManagementList>()); 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(ServedNRcellsENDCX2ManagementList)];
+
+		};
+		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_ServedNRcellsENDCX2ManagementList() { set(optional); 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(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};
+
+	};
+
+};
+/*
+RespondingNodeType-EndcConfigUpdate::= CHOICE {
+	respond-eNB			ProtocolIE-Container	{{ENB-ENDCConfigUpdateAckIEs}},
+	respond-en-gNB		ProtocolIE-Container	{{En-gNB-ENDCConfigUpdateAckIEs}},
+	...
+}
+*/
+
+struct RespondingNodeType_EndcConfigUpdate : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "RespondingNodeType-EndcConfigUpdate";}
+	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);  }
+	~RespondingNodeType_EndcConfigUpdate() {clear();}
+	struct respond_eNB_t : ProtocolIE_Container<ENB_ENDCConfigUpdateAckIEs>
+	{
+		static constexpr const char* name() {return "respond_eNB_t";}
+		using parent_t = ProtocolIE_Container<ENB_ENDCConfigUpdateAckIEs>;
+
+	};
+	struct respond_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCConfigUpdateAckIEs>
+	{
+		static constexpr const char* name() {return "respond_en_gNB_t";}
+		using parent_t = ProtocolIE_Container<En_gNB_ENDCConfigUpdateAckIEs>;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<respond_eNB_t>(); break;
+		case 2: var.destroy<respond_en_gNB_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<respond_eNB_t>());
+		case 2: set_index(2); return v(var.build<respond_en_gNB_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<respond_eNB_t>());
+		case 2: return v(var.as<respond_en_gNB_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<respond_eNB_t>(1);
+		v.template operator()<respond_en_gNB_t>(2);
+
+	}
+	respond_eNB_t& select_respond_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<respond_eNB_t>();} return var.as<respond_eNB_t>();}
+	respond_eNB_t const* get_respond_eNB() const { if(get_index() == 1) { return &var.as<respond_eNB_t>();} return nullptr; }
+	respond_en_gNB_t& select_respond_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<respond_en_gNB_t>();} return var.as<respond_en_gNB_t>();}
+	respond_en_gNB_t const* get_respond_en_gNB() const { if(get_index() == 2) { return &var.as<respond_en_gNB_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(respond_eNB_t)];
+		char dummy2[sizeof(respond_en_gNB_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+ENDCConfigurationUpdateAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-RespondingNodeType-EndcConfigUpdate			CRITICALITY reject	TYPE RespondingNodeType-EndcConfigUpdate			PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENDCConfigurationUpdateAcknowledge_IEs
+{
+	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_RespondingNodeType_EndcConfigUpdate() { set(id_RespondingNodeType_EndcConfigUpdate); 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_RespondingNodeType_EndcConfigUpdate)) { 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_RespondingNodeType_EndcConfigUpdate);} 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_RespondingNodeType_EndcConfigUpdate() { 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;}
+		RespondingNodeType_EndcConfigUpdate& select_id_RespondingNodeType_EndcConfigUpdate() { return set<RespondingNodeType_EndcConfigUpdate>(1); }
+		RespondingNodeType_EndcConfigUpdate const* get_id_RespondingNodeType_EndcConfigUpdate() const { return get<RespondingNodeType_EndcConfigUpdate>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<RespondingNodeType_EndcConfigUpdate>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<RespondingNodeType_EndcConfigUpdate>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_RespondingNodeType_EndcConfigUpdate()); 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<RespondingNodeType_EndcConfigUpdate>()); 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(RespondingNodeType_EndcConfigUpdate)];
+
+		};
+		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_RespondingNodeType_EndcConfigUpdate() { 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};
+
+	};
+
+};
+/*
+ENDCConfigurationUpdateAcknowledge ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCConfigurationUpdateAcknowledge-IEs}},
+	...
+}
+*/
+
+struct ENDCConfigurationUpdateAcknowledge : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCConfigurationUpdateAcknowledge";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCConfigurationUpdateAcknowledge_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCConfigurationUpdateAcknowledge_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ENDCConfigurationUpdateFailure-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Cause						CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics		CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional }|
+	{ ID id-TimeToWait					CRITICALITY ignore	TYPE TimeToWait					PRESENCE optional },
+	...
+}
+*/
+
+struct ENDCConfigurationUpdateFailure_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(id_Cause); type=1;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
+		void select_id_TimeToWait() { set(id_TimeToWait); type=3;}
+		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_Cause)) { type = 1; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
+			else if(equal(id_TimeToWait)) { 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_Cause);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_TimeToWait);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(ignore); type=1;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
+		void select_id_TimeToWait() { set(ignore); type=3;}
+		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 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		Cause& select_id_Cause() { return set<Cause>(1); }
+		Cause const* get_id_Cause() const { return get<Cause>(1); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
+		TimeToWait& select_id_TimeToWait() { return set<TimeToWait>(3); }
+		TimeToWait const* get_id_TimeToWait() const { return get<TimeToWait>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Cause>(); break;
+			case 2: var.destroy<CriticalityDiagnostics>(); break;
+			case 3: var.destroy<TimeToWait>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Cause>(1);
+			v.template operator()<CriticalityDiagnostics>(2);
+			v.template operator()<TimeToWait>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Cause()); return true;
+			case 2: v(select_id_CriticalityDiagnostics()); return true;
+			case 3: v(select_id_TimeToWait()); 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<Cause>()); return true;
+			case 2: v(var.as<CriticalityDiagnostics>()); return true;
+			case 3: v(var.as<TimeToWait>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(TimeToWait)];
+
+		};
+		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 == 4; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(mandatory); type=1;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=2;}
+		void select_id_TimeToWait() { set(optional); type=3;}
+		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 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(mandatory);} 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};
+
+	};
+
+};
+/*
+ENDCConfigurationUpdateFailure ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCConfigurationUpdateFailure-IEs}},
+	...
+}
+*/
+
+struct ENDCConfigurationUpdateFailure : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCConfigurationUpdateFailure";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCConfigurationUpdateFailure_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCConfigurationUpdateFailure_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ENDCPartialResetConfirm-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-UEs-Admitted-ToBeReset				CRITICALITY reject	TYPE UEsToBeResetList				PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENDCPartialResetConfirm_IEs
+{
+	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_UEs_Admitted_ToBeReset() { set(id_UEs_Admitted_ToBeReset); 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_UEs_Admitted_ToBeReset)) { 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_UEs_Admitted_ToBeReset);} 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_UEs_Admitted_ToBeReset() { 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;}
+		UEsToBeResetList& select_id_UEs_Admitted_ToBeReset() { return set<UEsToBeResetList>(1); }
+		UEsToBeResetList const* get_id_UEs_Admitted_ToBeReset() const { return get<UEsToBeResetList>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UEsToBeResetList>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UEsToBeResetList>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_UEs_Admitted_ToBeReset()); 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<UEsToBeResetList>()); 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(UEsToBeResetList)];
+
+		};
+		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_UEs_Admitted_ToBeReset() { 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};
+
+	};
+
+};
+/*
+ENDCPartialResetConfirm ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCPartialResetConfirm-IEs}},
+	...
+}
+*/
+
+struct ENDCPartialResetConfirm : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCPartialResetConfirm";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCPartialResetConfirm_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCPartialResetConfirm_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ENDCPartialResetRequired-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-UEs-ToBeReset				CRITICALITY reject	TYPE UEsToBeResetList					PRESENCE mandatory}|
+	{ ID id-Cause						CRITICALITY ignore	TYPE Cause								PRESENCE mandatory },
+	...
+}
+*/
+
+struct ENDCPartialResetRequired_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_UEs_ToBeReset() { set(id_UEs_ToBeReset); type=1;}
+		void select_id_Cause() { set(id_Cause); type=2;}
+		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_UEs_ToBeReset)) { type = 1; return true; }
+			else if(equal(id_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_UEs_ToBeReset);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_UEs_ToBeReset() { set(reject); type=1;}
+		void select_id_Cause() { set(ignore); type=2;}
+		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 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(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		UEsToBeResetList& select_id_UEs_ToBeReset() { return set<UEsToBeResetList>(1); }
+		UEsToBeResetList const* get_id_UEs_ToBeReset() const { return get<UEsToBeResetList>(1); }
+		Cause& select_id_Cause() { return set<Cause>(2); }
+		Cause const* get_id_Cause() const { return get<Cause>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UEsToBeResetList>(); break;
+			case 2: var.destroy<Cause>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UEsToBeResetList>(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_UEs_ToBeReset()); return true;
+			case 2: v(select_id_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<UEsToBeResetList>()); 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(UEsToBeResetList)];
+
+		};
+		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 == 3; }
+		void clear() {type = 0;}
+		void select_id_UEs_ToBeReset() { set(mandatory); type=1;}
+		void select_id_Cause() { set(mandatory); type=2;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+ENDCPartialResetRequired ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCPartialResetRequired-IEs}},
+	...
+}
+*/
+
+struct ENDCPartialResetRequired : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCPartialResetRequired";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCPartialResetRequired_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCPartialResetRequired_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ENDCX2RemovalFailure-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Cause					CRITICALITY ignore		TYPE Cause								PRESENCE mandatory} |
+	{ ID id-CriticalityDiagnostics	CRITICALITY ignore		TYPE CriticalityDiagnostics				PRESENCE optional },
+	...
+}
+*/
+
+struct ENDCX2RemovalFailure_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(id_Cause); type=1;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
+		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_Cause)) { type = 1; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { 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_Cause);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(ignore); type=1;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
+		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 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		Cause& select_id_Cause() { return set<Cause>(1); }
+		Cause const* get_id_Cause() const { return get<Cause>(1); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Cause>(); break;
+			case 2: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Cause>(1);
+			v.template operator()<CriticalityDiagnostics>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Cause()); return true;
+			case 2: v(select_id_CriticalityDiagnostics()); 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<Cause>()); return true;
+			case 2: v(var.as<CriticalityDiagnostics>()); 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(CriticalityDiagnostics)];
+
+		};
+		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 == 3; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(mandatory); type=1;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=2;}
+		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 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(mandatory);} 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};
+
+	};
+
+};
+/*
+ENDCX2RemovalFailure ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCX2RemovalFailure-IEs}},
+	...
+}
+*/
+
+struct ENDCX2RemovalFailure : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCX2RemovalFailure";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCX2RemovalFailure_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCX2RemovalFailure_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+En-gNB-ENDCX2RemovalReqIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Globalen-gNB-ID							CRITICALITY reject	TYPE GlobalGNB-ID										PRESENCE mandatory},
+	...
+}
+*/
+
+struct En_gNB_ENDCX2RemovalReqIEs
+{
+	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_Globalen_gNB_ID() { set(id_Globalen_gNB_ID); 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_Globalen_gNB_ID)) { 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_Globalen_gNB_ID);} 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_Globalen_gNB_ID() { 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;}
+		GlobalGNB_ID& select_id_Globalen_gNB_ID() { return set<GlobalGNB_ID>(1); }
+		GlobalGNB_ID const* get_id_Globalen_gNB_ID() const { return get<GlobalGNB_ID>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GlobalGNB_ID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GlobalGNB_ID>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Globalen_gNB_ID()); 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<GlobalGNB_ID>()); 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(GlobalGNB_ID)];
+
+		};
+		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_Globalen_gNB_ID() { 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};
+
+	};
+
+};
+/*
+InitiatingNodeType-EndcX2Removal ::= CHOICE {
+	init-eNB				ProtocolIE-Container	{{ENB-ENDCX2RemovalReqIEs}},
+	init-en-gNB			ProtocolIE-Container	{{En-gNB-ENDCX2RemovalReqIEs}},
+	...
+}
+*/
+
+struct InitiatingNodeType_EndcX2Removal : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "InitiatingNodeType-EndcX2Removal";}
+	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);  }
+	~InitiatingNodeType_EndcX2Removal() {clear();}
+	struct init_eNB_t : ProtocolIE_Container<ENB_ENDCX2RemovalReqIEs>
+	{
+		static constexpr const char* name() {return "init_eNB_t";}
+		using parent_t = ProtocolIE_Container<ENB_ENDCX2RemovalReqIEs>;
+
+	};
+	struct init_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCX2RemovalReqIEs>
+	{
+		static constexpr const char* name() {return "init_en_gNB_t";}
+		using parent_t = ProtocolIE_Container<En_gNB_ENDCX2RemovalReqIEs>;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<init_eNB_t>(); break;
+		case 2: var.destroy<init_en_gNB_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<init_eNB_t>());
+		case 2: set_index(2); return v(var.build<init_en_gNB_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<init_eNB_t>());
+		case 2: return v(var.as<init_en_gNB_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<init_eNB_t>(1);
+		v.template operator()<init_en_gNB_t>(2);
+
+	}
+	init_eNB_t& select_init_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<init_eNB_t>();} return var.as<init_eNB_t>();}
+	init_eNB_t const* get_init_eNB() const { if(get_index() == 1) { return &var.as<init_eNB_t>();} return nullptr; }
+	init_en_gNB_t& select_init_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<init_en_gNB_t>();} return var.as<init_en_gNB_t>();}
+	init_en_gNB_t const* get_init_en_gNB() const { if(get_index() == 2) { return &var.as<init_en_gNB_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(init_eNB_t)];
+		char dummy2[sizeof(init_en_gNB_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+ENDCX2RemovalRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-InitiatingNodeType-EndcX2Removal			CRITICALITY reject	TYPE InitiatingNodeType-EndcX2Removal		PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENDCX2RemovalRequest_IEs
+{
+	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_InitiatingNodeType_EndcX2Removal() { set(id_InitiatingNodeType_EndcX2Removal); 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_InitiatingNodeType_EndcX2Removal)) { 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_InitiatingNodeType_EndcX2Removal);} 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_InitiatingNodeType_EndcX2Removal() { 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;}
+		InitiatingNodeType_EndcX2Removal& select_id_InitiatingNodeType_EndcX2Removal() { return set<InitiatingNodeType_EndcX2Removal>(1); }
+		InitiatingNodeType_EndcX2Removal const* get_id_InitiatingNodeType_EndcX2Removal() const { return get<InitiatingNodeType_EndcX2Removal>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<InitiatingNodeType_EndcX2Removal>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<InitiatingNodeType_EndcX2Removal>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_InitiatingNodeType_EndcX2Removal()); 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<InitiatingNodeType_EndcX2Removal>()); 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(InitiatingNodeType_EndcX2Removal)];
+
+		};
+		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_InitiatingNodeType_EndcX2Removal() { 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};
+
+	};
+
+};
+/*
+ENDCX2RemovalRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCX2RemovalRequest-IEs}},
+	...
+}
+*/
+
+struct ENDCX2RemovalRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCX2RemovalRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCX2RemovalRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCX2RemovalRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+En-gNB-ENDCX2RemovalReqAckIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Globalen-gNB-ID							CRITICALITY reject	TYPE GlobalGNB-ID										PRESENCE mandatory},
+	...
+}
+*/
+
+struct En_gNB_ENDCX2RemovalReqAckIEs
+{
+	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_Globalen_gNB_ID() { set(id_Globalen_gNB_ID); 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_Globalen_gNB_ID)) { 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_Globalen_gNB_ID);} 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_Globalen_gNB_ID() { 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;}
+		GlobalGNB_ID& select_id_Globalen_gNB_ID() { return set<GlobalGNB_ID>(1); }
+		GlobalGNB_ID const* get_id_Globalen_gNB_ID() const { return get<GlobalGNB_ID>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GlobalGNB_ID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GlobalGNB_ID>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Globalen_gNB_ID()); 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<GlobalGNB_ID>()); 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(GlobalGNB_ID)];
+
+		};
+		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_Globalen_gNB_ID() { 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};
+
+	};
+
+};
+/*
+RespondingNodeType-EndcX2Removal ::= CHOICE {
+	respond-eNB			ProtocolIE-Container	{{ENB-ENDCX2RemovalReqAckIEs}},
+	respond-en-gNB		ProtocolIE-Container	{{En-gNB-ENDCX2RemovalReqAckIEs}},
+	...
+}
+*/
+
+struct RespondingNodeType_EndcX2Removal : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "RespondingNodeType-EndcX2Removal";}
+	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);  }
+	~RespondingNodeType_EndcX2Removal() {clear();}
+	struct respond_eNB_t : ProtocolIE_Container<ENB_ENDCX2RemovalReqAckIEs>
+	{
+		static constexpr const char* name() {return "respond_eNB_t";}
+		using parent_t = ProtocolIE_Container<ENB_ENDCX2RemovalReqAckIEs>;
+
+	};
+	struct respond_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCX2RemovalReqAckIEs>
+	{
+		static constexpr const char* name() {return "respond_en_gNB_t";}
+		using parent_t = ProtocolIE_Container<En_gNB_ENDCX2RemovalReqAckIEs>;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<respond_eNB_t>(); break;
+		case 2: var.destroy<respond_en_gNB_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<respond_eNB_t>());
+		case 2: set_index(2); return v(var.build<respond_en_gNB_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<respond_eNB_t>());
+		case 2: return v(var.as<respond_en_gNB_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<respond_eNB_t>(1);
+		v.template operator()<respond_en_gNB_t>(2);
+
+	}
+	respond_eNB_t& select_respond_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<respond_eNB_t>();} return var.as<respond_eNB_t>();}
+	respond_eNB_t const* get_respond_eNB() const { if(get_index() == 1) { return &var.as<respond_eNB_t>();} return nullptr; }
+	respond_en_gNB_t& select_respond_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<respond_en_gNB_t>();} return var.as<respond_en_gNB_t>();}
+	respond_en_gNB_t const* get_respond_en_gNB() const { if(get_index() == 2) { return &var.as<respond_en_gNB_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(respond_eNB_t)];
+		char dummy2[sizeof(respond_en_gNB_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+ENDCX2RemovalResponse-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-RespondingNodeType-EndcX2Removal		CRITICALITY reject	TYPE RespondingNodeType-EndcX2Removal		PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENDCX2RemovalResponse_IEs
+{
+	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_RespondingNodeType_EndcX2Removal() { set(id_RespondingNodeType_EndcX2Removal); 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_RespondingNodeType_EndcX2Removal)) { 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_RespondingNodeType_EndcX2Removal);} 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_RespondingNodeType_EndcX2Removal() { 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;}
+		RespondingNodeType_EndcX2Removal& select_id_RespondingNodeType_EndcX2Removal() { return set<RespondingNodeType_EndcX2Removal>(1); }
+		RespondingNodeType_EndcX2Removal const* get_id_RespondingNodeType_EndcX2Removal() const { return get<RespondingNodeType_EndcX2Removal>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<RespondingNodeType_EndcX2Removal>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<RespondingNodeType_EndcX2Removal>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_RespondingNodeType_EndcX2Removal()); 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<RespondingNodeType_EndcX2Removal>()); 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(RespondingNodeType_EndcX2Removal)];
+
+		};
+		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_RespondingNodeType_EndcX2Removal() { 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};
+
+	};
+
+};
+/*
+ENDCX2RemovalResponse ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCX2RemovalResponse-IEs}},
+	...
+}
+*/
+
+struct ENDCX2RemovalResponse : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCX2RemovalResponse";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCX2RemovalResponse_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCX2RemovalResponse_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ENDCX2SetupFailure-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Cause					CRITICALITY ignore		TYPE Cause								PRESENCE mandatory} |
+	{ ID id-CriticalityDiagnostics	CRITICALITY ignore		TYPE CriticalityDiagnostics				PRESENCE optional } |
+	{ ID id-TimeToWait				CRITICALITY ignore		TYPE TimeToWait							PRESENCE optional	},
+	...
+}
+*/
+
+struct ENDCX2SetupFailure_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(id_Cause); type=1;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
+		void select_id_TimeToWait() { set(id_TimeToWait); type=3;}
+		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_Cause)) { type = 1; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
+			else if(equal(id_TimeToWait)) { 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_Cause);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_TimeToWait);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(ignore); type=1;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
+		void select_id_TimeToWait() { set(ignore); type=3;}
+		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 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		Cause& select_id_Cause() { return set<Cause>(1); }
+		Cause const* get_id_Cause() const { return get<Cause>(1); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
+		TimeToWait& select_id_TimeToWait() { return set<TimeToWait>(3); }
+		TimeToWait const* get_id_TimeToWait() const { return get<TimeToWait>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Cause>(); break;
+			case 2: var.destroy<CriticalityDiagnostics>(); break;
+			case 3: var.destroy<TimeToWait>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Cause>(1);
+			v.template operator()<CriticalityDiagnostics>(2);
+			v.template operator()<TimeToWait>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Cause()); return true;
+			case 2: v(select_id_CriticalityDiagnostics()); return true;
+			case 3: v(select_id_TimeToWait()); 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<Cause>()); return true;
+			case 2: v(var.as<CriticalityDiagnostics>()); return true;
+			case 3: v(var.as<TimeToWait>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(TimeToWait)];
+
+		};
+		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 == 4; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(mandatory); type=1;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=2;}
+		void select_id_TimeToWait() { set(optional); type=3;}
+		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 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(mandatory);} 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};
+
+	};
+
+};
+/*
+ENDCX2SetupFailure ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCX2SetupFailure-IEs}},
+	...
+}
+*/
+
+struct ENDCX2SetupFailure : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCX2SetupFailure";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCX2SetupFailure_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCX2SetupFailure_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+En-gNB-ENDCX2SetupReqIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Globalen-gNB-ID							CRITICALITY reject	TYPE GlobalGNB-ID										PRESENCE mandatory}|
+	{ ID id-ServedNRcellsENDCX2ManagementList		CRITICALITY reject	TYPE ServedNRcellsENDCX2ManagementList			PRESENCE mandatory},
+	...
+}
+*/
+
+struct En_gNB_ENDCX2SetupReqIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_Globalen_gNB_ID() { set(id_Globalen_gNB_ID); type=1;}
+		void select_id_ServedNRcellsENDCX2ManagementList() { set(id_ServedNRcellsENDCX2ManagementList); type=2;}
+		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_Globalen_gNB_ID)) { type = 1; return true; }
+			else if(equal(id_ServedNRcellsENDCX2ManagementList)) { 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_Globalen_gNB_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedNRcellsENDCX2ManagementList);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_Globalen_gNB_ID() { set(reject); type=1;}
+		void select_id_ServedNRcellsENDCX2ManagementList() { set(reject); type=2;}
+		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 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(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		GlobalGNB_ID& select_id_Globalen_gNB_ID() { return set<GlobalGNB_ID>(1); }
+		GlobalGNB_ID const* get_id_Globalen_gNB_ID() const { return get<GlobalGNB_ID>(1); }
+		ServedNRcellsENDCX2ManagementList& select_id_ServedNRcellsENDCX2ManagementList() { return set<ServedNRcellsENDCX2ManagementList>(2); }
+		ServedNRcellsENDCX2ManagementList const* get_id_ServedNRcellsENDCX2ManagementList() const { return get<ServedNRcellsENDCX2ManagementList>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GlobalGNB_ID>(); break;
+			case 2: var.destroy<ServedNRcellsENDCX2ManagementList>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GlobalGNB_ID>(1);
+			v.template operator()<ServedNRcellsENDCX2ManagementList>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Globalen_gNB_ID()); return true;
+			case 2: v(select_id_ServedNRcellsENDCX2ManagementList()); 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<GlobalGNB_ID>()); return true;
+			case 2: v(var.as<ServedNRcellsENDCX2ManagementList>()); 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(GlobalGNB_ID)];
+			char dummy2[sizeof(ServedNRcellsENDCX2ManagementList)];
+
+		};
+		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 == 3; }
+		void clear() {type = 0;}
+		void select_id_Globalen_gNB_ID() { set(mandatory); type=1;}
+		void select_id_ServedNRcellsENDCX2ManagementList() { set(mandatory); type=2;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+InitiatingNodeType-EndcX2Setup ::= CHOICE {
+	init-eNB				ProtocolIE-Container	{{ENB-ENDCX2SetupReqIEs}},
+	init-en-gNB			ProtocolIE-Container	{{En-gNB-ENDCX2SetupReqIEs}},
+	...
+}
+*/
+
+struct InitiatingNodeType_EndcX2Setup : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "InitiatingNodeType-EndcX2Setup";}
+	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);  }
+	~InitiatingNodeType_EndcX2Setup() {clear();}
+	struct init_eNB_t : ProtocolIE_Container<ENB_ENDCX2SetupReqIEs>
+	{
+		static constexpr const char* name() {return "init_eNB_t";}
+		using parent_t = ProtocolIE_Container<ENB_ENDCX2SetupReqIEs>;
+
+	};
+	struct init_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCX2SetupReqIEs>
+	{
+		static constexpr const char* name() {return "init_en_gNB_t";}
+		using parent_t = ProtocolIE_Container<En_gNB_ENDCX2SetupReqIEs>;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<init_eNB_t>(); break;
+		case 2: var.destroy<init_en_gNB_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<init_eNB_t>());
+		case 2: set_index(2); return v(var.build<init_en_gNB_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<init_eNB_t>());
+		case 2: return v(var.as<init_en_gNB_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<init_eNB_t>(1);
+		v.template operator()<init_en_gNB_t>(2);
+
+	}
+	init_eNB_t& select_init_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<init_eNB_t>();} return var.as<init_eNB_t>();}
+	init_eNB_t const* get_init_eNB() const { if(get_index() == 1) { return &var.as<init_eNB_t>();} return nullptr; }
+	init_en_gNB_t& select_init_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<init_en_gNB_t>();} return var.as<init_en_gNB_t>();}
+	init_en_gNB_t const* get_init_en_gNB() const { if(get_index() == 2) { return &var.as<init_en_gNB_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(init_eNB_t)];
+		char dummy2[sizeof(init_en_gNB_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+ENDCX2SetupRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-InitiatingNodeType-EndcX2Setup			CRITICALITY reject	TYPE InitiatingNodeType-EndcX2Setup		PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENDCX2SetupRequest_IEs
+{
+	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_InitiatingNodeType_EndcX2Setup() { set(id_InitiatingNodeType_EndcX2Setup); 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_InitiatingNodeType_EndcX2Setup)) { 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_InitiatingNodeType_EndcX2Setup);} 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_InitiatingNodeType_EndcX2Setup() { 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;}
+		InitiatingNodeType_EndcX2Setup& select_id_InitiatingNodeType_EndcX2Setup() { return set<InitiatingNodeType_EndcX2Setup>(1); }
+		InitiatingNodeType_EndcX2Setup const* get_id_InitiatingNodeType_EndcX2Setup() const { return get<InitiatingNodeType_EndcX2Setup>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<InitiatingNodeType_EndcX2Setup>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<InitiatingNodeType_EndcX2Setup>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_InitiatingNodeType_EndcX2Setup()); 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<InitiatingNodeType_EndcX2Setup>()); 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(InitiatingNodeType_EndcX2Setup)];
+
+		};
+		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_InitiatingNodeType_EndcX2Setup() { 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};
+
+	};
+
+};
+/*
+ENDCX2SetupRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCX2SetupRequest-IEs}},
+	...
+}
+*/
+
+struct ENDCX2SetupRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCX2SetupRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCX2SetupRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCX2SetupRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+En-gNB-ENDCX2SetupReqAckIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Globalen-gNB-ID							CRITICALITY reject	TYPE GlobalGNB-ID										PRESENCE mandatory}|
+	{ ID id-ServedNRcellsENDCX2ManagementList		CRITICALITY reject	TYPE ServedNRcellsENDCX2ManagementList			PRESENCE mandatory},
+	...
+}
+*/
+
+struct En_gNB_ENDCX2SetupReqAckIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_Globalen_gNB_ID() { set(id_Globalen_gNB_ID); type=1;}
+		void select_id_ServedNRcellsENDCX2ManagementList() { set(id_ServedNRcellsENDCX2ManagementList); type=2;}
+		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_Globalen_gNB_ID)) { type = 1; return true; }
+			else if(equal(id_ServedNRcellsENDCX2ManagementList)) { 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_Globalen_gNB_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedNRcellsENDCX2ManagementList);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_Globalen_gNB_ID() { set(reject); type=1;}
+		void select_id_ServedNRcellsENDCX2ManagementList() { set(reject); type=2;}
+		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 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(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		GlobalGNB_ID& select_id_Globalen_gNB_ID() { return set<GlobalGNB_ID>(1); }
+		GlobalGNB_ID const* get_id_Globalen_gNB_ID() const { return get<GlobalGNB_ID>(1); }
+		ServedNRcellsENDCX2ManagementList& select_id_ServedNRcellsENDCX2ManagementList() { return set<ServedNRcellsENDCX2ManagementList>(2); }
+		ServedNRcellsENDCX2ManagementList const* get_id_ServedNRcellsENDCX2ManagementList() const { return get<ServedNRcellsENDCX2ManagementList>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GlobalGNB_ID>(); break;
+			case 2: var.destroy<ServedNRcellsENDCX2ManagementList>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GlobalGNB_ID>(1);
+			v.template operator()<ServedNRcellsENDCX2ManagementList>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Globalen_gNB_ID()); return true;
+			case 2: v(select_id_ServedNRcellsENDCX2ManagementList()); 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<GlobalGNB_ID>()); return true;
+			case 2: v(var.as<ServedNRcellsENDCX2ManagementList>()); 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(GlobalGNB_ID)];
+			char dummy2[sizeof(ServedNRcellsENDCX2ManagementList)];
+
+		};
+		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 == 3; }
+		void clear() {type = 0;}
+		void select_id_Globalen_gNB_ID() { set(mandatory); type=1;}
+		void select_id_ServedNRcellsENDCX2ManagementList() { set(mandatory); type=2;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+RespondingNodeType-EndcX2Setup ::= CHOICE {
+	respond-eNB			ProtocolIE-Container	{{ENB-ENDCX2SetupReqAckIEs}},
+	respond-en-gNB		ProtocolIE-Container	{{En-gNB-ENDCX2SetupReqAckIEs}},
+	...
+}
+*/
+
+struct RespondingNodeType_EndcX2Setup : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "RespondingNodeType-EndcX2Setup";}
+	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);  }
+	~RespondingNodeType_EndcX2Setup() {clear();}
+	struct respond_eNB_t : ProtocolIE_Container<ENB_ENDCX2SetupReqAckIEs>
+	{
+		static constexpr const char* name() {return "respond_eNB_t";}
+		using parent_t = ProtocolIE_Container<ENB_ENDCX2SetupReqAckIEs>;
+
+	};
+	struct respond_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCX2SetupReqAckIEs>
+	{
+		static constexpr const char* name() {return "respond_en_gNB_t";}
+		using parent_t = ProtocolIE_Container<En_gNB_ENDCX2SetupReqAckIEs>;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<respond_eNB_t>(); break;
+		case 2: var.destroy<respond_en_gNB_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<respond_eNB_t>());
+		case 2: set_index(2); return v(var.build<respond_en_gNB_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<respond_eNB_t>());
+		case 2: return v(var.as<respond_en_gNB_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<respond_eNB_t>(1);
+		v.template operator()<respond_en_gNB_t>(2);
+
+	}
+	respond_eNB_t& select_respond_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<respond_eNB_t>();} return var.as<respond_eNB_t>();}
+	respond_eNB_t const* get_respond_eNB() const { if(get_index() == 1) { return &var.as<respond_eNB_t>();} return nullptr; }
+	respond_en_gNB_t& select_respond_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<respond_en_gNB_t>();} return var.as<respond_en_gNB_t>();}
+	respond_en_gNB_t const* get_respond_en_gNB() const { if(get_index() == 2) { return &var.as<respond_en_gNB_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(respond_eNB_t)];
+		char dummy2[sizeof(respond_en_gNB_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+ENDCX2SetupResponse-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-RespondingNodeType-EndcX2Setup		CRITICALITY reject	TYPE RespondingNodeType-EndcX2Setup		PRESENCE mandatory},
+	...
+}
+*/
+
+struct ENDCX2SetupResponse_IEs
+{
+	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_RespondingNodeType_EndcX2Setup() { set(id_RespondingNodeType_EndcX2Setup); 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_RespondingNodeType_EndcX2Setup)) { 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_RespondingNodeType_EndcX2Setup);} 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_RespondingNodeType_EndcX2Setup() { 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;}
+		RespondingNodeType_EndcX2Setup& select_id_RespondingNodeType_EndcX2Setup() { return set<RespondingNodeType_EndcX2Setup>(1); }
+		RespondingNodeType_EndcX2Setup const* get_id_RespondingNodeType_EndcX2Setup() const { return get<RespondingNodeType_EndcX2Setup>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<RespondingNodeType_EndcX2Setup>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<RespondingNodeType_EndcX2Setup>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_RespondingNodeType_EndcX2Setup()); 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<RespondingNodeType_EndcX2Setup>()); 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(RespondingNodeType_EndcX2Setup)];
+
+		};
+		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_RespondingNodeType_EndcX2Setup() { 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};
+
+	};
+
+};
+/*
+ENDCX2SetupResponse ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ENDCX2SetupResponse-IEs}},
+	...
+}
+*/
+
+struct ENDCX2SetupResponse : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ENDCX2SetupResponse";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ENDCX2SetupResponse_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ENDCX2SetupResponse_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ListofEUTRACellsinNRCoordinationReq ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ECGI
+*/
+
+struct ListofEUTRACellsinNRCoordinationReq_elm : ECGI
+{
+	static constexpr const char* name() {return "ListofEUTRACellsinNRCoordinationReq_elm";}
+	using parent_t = ECGI;
+
+};
+struct ListofEUTRACellsinNRCoordinationReq : asn::sequenceof<ListofEUTRACellsinNRCoordinationReq_elm>
+{
+	static constexpr const char* name() {return "ListofEUTRACellsinNRCoordinationReq";}
+	using parent_t = asn::sequenceof<ListofEUTRACellsinNRCoordinationReq_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+ListofNRCellsinNRCoordinationReq ::= SEQUENCE (SIZE (0..maxnoNRcellsSpectrumSharingWithE-UTRA)) OF NRCGI
+*/
+
+struct ListofNRCellsinNRCoordinationReq_elm : NRCGI
+{
+	static constexpr const char* name() {return "ListofNRCellsinNRCoordinationReq_elm";}
+	using parent_t = NRCGI;
+
+};
+struct ListofNRCellsinNRCoordinationReq : asn::sequenceof<ListofNRCellsinNRCoordinationReq_elm>
+{
+	static constexpr const char* name() {return "ListofNRCellsinNRCoordinationReq";}
+	using parent_t = asn::sequenceof<ListofNRCellsinNRCoordinationReq_elm>;
+	using constraint_t = asn::constraints<false,asn::span<0,  maxnoNRcellsSpectrumSharingWithE_UTRA >>;
+
+};
+/*
+En-gNB-EUTRA-NRCellResourceCoordinationReqIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-DataTrafficResourceIndication			CRITICALITY reject	TYPE DataTrafficResourceIndication				PRESENCE mandatory}|
+	{ ID id-ListofEUTRACellsinNRCoordinationReq		CRITICALITY reject	TYPE ListofEUTRACellsinNRCoordinationReq		PRESENCE mandatory }|
+	{ ID id-SpectrumSharingGroupID					CRITICALITY reject	TYPE SpectrumSharingGroupID						PRESENCE mandatory}|
+	{ ID id-ListofNRCellsinNRCoordinationReq		CRITICALITY reject	TYPE ListofNRCellsinNRCoordinationReq			PRESENCE mandatory},
+	...
+}
+*/
+
+struct En_gNB_EUTRA_NRCellResourceCoordinationReqIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_DataTrafficResourceIndication() { set(id_DataTrafficResourceIndication); type=1;}
+		void select_id_ListofEUTRACellsinNRCoordinationReq() { set(id_ListofEUTRACellsinNRCoordinationReq); type=2;}
+		void select_id_SpectrumSharingGroupID() { set(id_SpectrumSharingGroupID); type=3;}
+		void select_id_ListofNRCellsinNRCoordinationReq() { set(id_ListofNRCellsinNRCoordinationReq); type=4;}
+		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_DataTrafficResourceIndication)) { type = 1; return true; }
+			else if(equal(id_ListofEUTRACellsinNRCoordinationReq)) { type = 2; return true; }
+			else if(equal(id_SpectrumSharingGroupID)) { type = 3; return true; }
+			else if(equal(id_ListofNRCellsinNRCoordinationReq)) { 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_DataTrafficResourceIndication);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ListofEUTRACellsinNRCoordinationReq);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_SpectrumSharingGroupID);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_ListofNRCellsinNRCoordinationReq);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_DataTrafficResourceIndication() { set(reject); type=1;}
+		void select_id_ListofEUTRACellsinNRCoordinationReq() { set(reject); type=2;}
+		void select_id_SpectrumSharingGroupID() { set(reject); type=3;}
+		void select_id_ListofNRCellsinNRCoordinationReq() { set(reject); type=4;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(reject)) { type = 3; return true; }
+			else if(equal(reject)) { 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		DataTrafficResourceIndication& select_id_DataTrafficResourceIndication() { return set<DataTrafficResourceIndication>(1); }
+		DataTrafficResourceIndication const* get_id_DataTrafficResourceIndication() const { return get<DataTrafficResourceIndication>(1); }
+		ListofEUTRACellsinNRCoordinationReq& select_id_ListofEUTRACellsinNRCoordinationReq() { return set<ListofEUTRACellsinNRCoordinationReq>(2); }
+		ListofEUTRACellsinNRCoordinationReq const* get_id_ListofEUTRACellsinNRCoordinationReq() const { return get<ListofEUTRACellsinNRCoordinationReq>(2); }
+		SpectrumSharingGroupID& select_id_SpectrumSharingGroupID() { return set<SpectrumSharingGroupID>(3); }
+		SpectrumSharingGroupID const* get_id_SpectrumSharingGroupID() const { return get<SpectrumSharingGroupID>(3); }
+		ListofNRCellsinNRCoordinationReq& select_id_ListofNRCellsinNRCoordinationReq() { return set<ListofNRCellsinNRCoordinationReq>(4); }
+		ListofNRCellsinNRCoordinationReq const* get_id_ListofNRCellsinNRCoordinationReq() const { return get<ListofNRCellsinNRCoordinationReq>(4); }
+		bool is_unknown() const { return type == 5; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<DataTrafficResourceIndication>(); break;
+			case 2: var.destroy<ListofEUTRACellsinNRCoordinationReq>(); break;
+			case 3: var.destroy<SpectrumSharingGroupID>(); break;
+			case 4: var.destroy<ListofNRCellsinNRCoordinationReq>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<DataTrafficResourceIndication>(1);
+			v.template operator()<ListofEUTRACellsinNRCoordinationReq>(2);
+			v.template operator()<SpectrumSharingGroupID>(3);
+			v.template operator()<ListofNRCellsinNRCoordinationReq>(4);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_DataTrafficResourceIndication()); return true;
+			case 2: v(select_id_ListofEUTRACellsinNRCoordinationReq()); return true;
+			case 3: v(select_id_SpectrumSharingGroupID()); return true;
+			case 4: v(select_id_ListofNRCellsinNRCoordinationReq()); 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<DataTrafficResourceIndication>()); return true;
+			case 2: v(var.as<ListofEUTRACellsinNRCoordinationReq>()); return true;
+			case 3: v(var.as<SpectrumSharingGroupID>()); return true;
+			case 4: v(var.as<ListofNRCellsinNRCoordinationReq>()); 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(DataTrafficResourceIndication)];
+			char dummy2[sizeof(ListofEUTRACellsinNRCoordinationReq)];
+			char dummy3[sizeof(ListofNRCellsinNRCoordinationReq)];
+			char dummy4[sizeof(SpectrumSharingGroupID)];
+
+		};
+		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 == 5; }
+		void clear() {type = 0;}
+		void select_id_DataTrafficResourceIndication() { set(mandatory); type=1;}
+		void select_id_ListofEUTRACellsinNRCoordinationReq() { set(mandatory); type=2;}
+		void select_id_SpectrumSharingGroupID() { set(mandatory); type=3;}
+		void select_id_ListofNRCellsinNRCoordinationReq() { set(mandatory); type=4;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+InitiatingNodeType-EutranrCellResourceCoordination ::= CHOICE {
+	initiate-eNB			ProtocolIE-Container	{{ENB-EUTRA-NRCellResourceCoordinationReqIEs}},
+	initiate-en-gNB			ProtocolIE-Container	{{En-gNB-EUTRA-NRCellResourceCoordinationReqIEs}},
+	...
+}
+*/
+
+struct InitiatingNodeType_EutranrCellResourceCoordination : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "InitiatingNodeType-EutranrCellResourceCoordination";}
+	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);  }
+	~InitiatingNodeType_EutranrCellResourceCoordination() {clear();}
+	struct initiate_eNB_t : ProtocolIE_Container<ENB_EUTRA_NRCellResourceCoordinationReqIEs>
+	{
+		static constexpr const char* name() {return "initiate_eNB_t";}
+		using parent_t = ProtocolIE_Container<ENB_EUTRA_NRCellResourceCoordinationReqIEs>;
+
+	};
+	struct initiate_en_gNB_t : ProtocolIE_Container<En_gNB_EUTRA_NRCellResourceCoordinationReqIEs>
+	{
+		static constexpr const char* name() {return "initiate_en_gNB_t";}
+		using parent_t = ProtocolIE_Container<En_gNB_EUTRA_NRCellResourceCoordinationReqIEs>;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<initiate_eNB_t>(); break;
+		case 2: var.destroy<initiate_en_gNB_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<initiate_eNB_t>());
+		case 2: set_index(2); return v(var.build<initiate_en_gNB_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<initiate_eNB_t>());
+		case 2: return v(var.as<initiate_en_gNB_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<initiate_eNB_t>(1);
+		v.template operator()<initiate_en_gNB_t>(2);
+
+	}
+	initiate_eNB_t& select_initiate_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<initiate_eNB_t>();} return var.as<initiate_eNB_t>();}
+	initiate_eNB_t const* get_initiate_eNB() const { if(get_index() == 1) { return &var.as<initiate_eNB_t>();} return nullptr; }
+	initiate_en_gNB_t& select_initiate_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<initiate_en_gNB_t>();} return var.as<initiate_en_gNB_t>();}
+	initiate_en_gNB_t const* get_initiate_en_gNB() const { if(get_index() == 2) { return &var.as<initiate_en_gNB_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(initiate_eNB_t)];
+		char dummy2[sizeof(initiate_en_gNB_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+EUTRANRCellResourceCoordinationRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-InitiatingNodeType-EutranrCellResourceCoordination		CRITICALITY reject	TYPE InitiatingNodeType-EutranrCellResourceCoordination			PRESENCE mandatory},
+	...
+}
+*/
+
+struct EUTRANRCellResourceCoordinationRequest_IEs
+{
+	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_InitiatingNodeType_EutranrCellResourceCoordination() { set(id_InitiatingNodeType_EutranrCellResourceCoordination); 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_InitiatingNodeType_EutranrCellResourceCoordination)) { 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_InitiatingNodeType_EutranrCellResourceCoordination);} 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_InitiatingNodeType_EutranrCellResourceCoordination() { 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;}
+		InitiatingNodeType_EutranrCellResourceCoordination& select_id_InitiatingNodeType_EutranrCellResourceCoordination() { return set<InitiatingNodeType_EutranrCellResourceCoordination>(1); }
+		InitiatingNodeType_EutranrCellResourceCoordination const* get_id_InitiatingNodeType_EutranrCellResourceCoordination() const { return get<InitiatingNodeType_EutranrCellResourceCoordination>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<InitiatingNodeType_EutranrCellResourceCoordination>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<InitiatingNodeType_EutranrCellResourceCoordination>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_InitiatingNodeType_EutranrCellResourceCoordination()); 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<InitiatingNodeType_EutranrCellResourceCoordination>()); 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(InitiatingNodeType_EutranrCellResourceCoordination)];
+
+		};
+		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_InitiatingNodeType_EutranrCellResourceCoordination() { 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};
+
+	};
+
+};
+/*
+EUTRANRCellResourceCoordinationRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{EUTRANRCellResourceCoordinationRequest-IEs}},
+	...
+}
+*/
+
+struct EUTRANRCellResourceCoordinationRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "EUTRANRCellResourceCoordinationRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<EUTRANRCellResourceCoordinationRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<EUTRANRCellResourceCoordinationRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ListofNRCellsinNRCoordinationResp ::= SEQUENCE (SIZE (0..maxnoNRcellsSpectrumSharingWithE-UTRA)) OF NRCGI
+*/
+
+struct ListofNRCellsinNRCoordinationResp_elm : NRCGI
+{
+	static constexpr const char* name() {return "ListofNRCellsinNRCoordinationResp_elm";}
+	using parent_t = NRCGI;
+
+};
+struct ListofNRCellsinNRCoordinationResp : asn::sequenceof<ListofNRCellsinNRCoordinationResp_elm>
+{
+	static constexpr const char* name() {return "ListofNRCellsinNRCoordinationResp";}
+	using parent_t = asn::sequenceof<ListofNRCellsinNRCoordinationResp_elm>;
+	using constraint_t = asn::constraints<false,asn::span<0,  maxnoNRcellsSpectrumSharingWithE_UTRA >>;
+
+};
+/*
+En-gNB-EUTRA-NRCellResourceCoordinationReqAckIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-DataTrafficResourceIndication		CRITICALITY reject	TYPE DataTrafficResourceIndication			PRESENCE mandatory}|
+	{ ID id-SpectrumSharingGroupID				CRITICALITY reject	TYPE SpectrumSharingGroupID					PRESENCE mandatory}|
+	{ ID id-ListofNRCellsinNRCoordinationResp	CRITICALITY reject	TYPE ListofNRCellsinNRCoordinationResp		PRESENCE mandatory},
+
+
+	...
+}
+*/
+
+struct En_gNB_EUTRA_NRCellResourceCoordinationReqAckIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_DataTrafficResourceIndication() { set(id_DataTrafficResourceIndication); type=1;}
+		void select_id_SpectrumSharingGroupID() { set(id_SpectrumSharingGroupID); type=2;}
+		void select_id_ListofNRCellsinNRCoordinationResp() { set(id_ListofNRCellsinNRCoordinationResp); type=3;}
+		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_DataTrafficResourceIndication)) { type = 1; return true; }
+			else if(equal(id_SpectrumSharingGroupID)) { type = 2; return true; }
+			else if(equal(id_ListofNRCellsinNRCoordinationResp)) { 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_DataTrafficResourceIndication);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SpectrumSharingGroupID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_ListofNRCellsinNRCoordinationResp);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_DataTrafficResourceIndication() { set(reject); type=1;}
+		void select_id_SpectrumSharingGroupID() { set(reject); type=2;}
+		void select_id_ListofNRCellsinNRCoordinationResp() { set(reject); type=3;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(reject)) { 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		DataTrafficResourceIndication& select_id_DataTrafficResourceIndication() { return set<DataTrafficResourceIndication>(1); }
+		DataTrafficResourceIndication const* get_id_DataTrafficResourceIndication() const { return get<DataTrafficResourceIndication>(1); }
+		SpectrumSharingGroupID& select_id_SpectrumSharingGroupID() { return set<SpectrumSharingGroupID>(2); }
+		SpectrumSharingGroupID const* get_id_SpectrumSharingGroupID() const { return get<SpectrumSharingGroupID>(2); }
+		ListofNRCellsinNRCoordinationResp& select_id_ListofNRCellsinNRCoordinationResp() { return set<ListofNRCellsinNRCoordinationResp>(3); }
+		ListofNRCellsinNRCoordinationResp const* get_id_ListofNRCellsinNRCoordinationResp() const { return get<ListofNRCellsinNRCoordinationResp>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<DataTrafficResourceIndication>(); break;
+			case 2: var.destroy<SpectrumSharingGroupID>(); break;
+			case 3: var.destroy<ListofNRCellsinNRCoordinationResp>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<DataTrafficResourceIndication>(1);
+			v.template operator()<SpectrumSharingGroupID>(2);
+			v.template operator()<ListofNRCellsinNRCoordinationResp>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_DataTrafficResourceIndication()); return true;
+			case 2: v(select_id_SpectrumSharingGroupID()); return true;
+			case 3: v(select_id_ListofNRCellsinNRCoordinationResp()); 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<DataTrafficResourceIndication>()); return true;
+			case 2: v(var.as<SpectrumSharingGroupID>()); return true;
+			case 3: v(var.as<ListofNRCellsinNRCoordinationResp>()); 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(DataTrafficResourceIndication)];
+			char dummy2[sizeof(ListofNRCellsinNRCoordinationResp)];
+			char dummy3[sizeof(SpectrumSharingGroupID)];
+
+		};
+		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 == 4; }
+		void clear() {type = 0;}
+		void select_id_DataTrafficResourceIndication() { set(mandatory); type=1;}
+		void select_id_SpectrumSharingGroupID() { set(mandatory); type=2;}
+		void select_id_ListofNRCellsinNRCoordinationResp() { set(mandatory); type=3;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+RespondingNodeType-EutranrCellResourceCoordination ::= CHOICE {
+	respond-eNB			ProtocolIE-Container	{{ENB-EUTRA-NRCellResourceCoordinationReqAckIEs}},
+	respond-en-gNB		ProtocolIE-Container	{{En-gNB-EUTRA-NRCellResourceCoordinationReqAckIEs}},
+	...
+}
+*/
+
+struct RespondingNodeType_EutranrCellResourceCoordination : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "RespondingNodeType-EutranrCellResourceCoordination";}
+	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);  }
+	~RespondingNodeType_EutranrCellResourceCoordination() {clear();}
+	struct respond_eNB_t : ProtocolIE_Container<ENB_EUTRA_NRCellResourceCoordinationReqAckIEs>
+	{
+		static constexpr const char* name() {return "respond_eNB_t";}
+		using parent_t = ProtocolIE_Container<ENB_EUTRA_NRCellResourceCoordinationReqAckIEs>;
+
+	};
+	struct respond_en_gNB_t : ProtocolIE_Container<En_gNB_EUTRA_NRCellResourceCoordinationReqAckIEs>
+	{
+		static constexpr const char* name() {return "respond_en_gNB_t";}
+		using parent_t = ProtocolIE_Container<En_gNB_EUTRA_NRCellResourceCoordinationReqAckIEs>;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<respond_eNB_t>(); break;
+		case 2: var.destroy<respond_en_gNB_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<respond_eNB_t>());
+		case 2: set_index(2); return v(var.build<respond_en_gNB_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<respond_eNB_t>());
+		case 2: return v(var.as<respond_en_gNB_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<respond_eNB_t>(1);
+		v.template operator()<respond_en_gNB_t>(2);
+
+	}
+	respond_eNB_t& select_respond_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<respond_eNB_t>();} return var.as<respond_eNB_t>();}
+	respond_eNB_t const* get_respond_eNB() const { if(get_index() == 1) { return &var.as<respond_eNB_t>();} return nullptr; }
+	respond_en_gNB_t& select_respond_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<respond_en_gNB_t>();} return var.as<respond_en_gNB_t>();}
+	respond_en_gNB_t const* get_respond_en_gNB() const { if(get_index() == 2) { return &var.as<respond_en_gNB_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(respond_eNB_t)];
+		char dummy2[sizeof(respond_en_gNB_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+EUTRANRCellResourceCoordinationResponse-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-RespondingNodeType-EutranrCellResourceCoordination		CRITICALITY reject	TYPE RespondingNodeType-EutranrCellResourceCoordination			PRESENCE mandatory},
+	...
+}
+*/
+
+struct EUTRANRCellResourceCoordinationResponse_IEs
+{
+	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_RespondingNodeType_EutranrCellResourceCoordination() { set(id_RespondingNodeType_EutranrCellResourceCoordination); 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_RespondingNodeType_EutranrCellResourceCoordination)) { 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_RespondingNodeType_EutranrCellResourceCoordination);} 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_RespondingNodeType_EutranrCellResourceCoordination() { 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;}
+		RespondingNodeType_EutranrCellResourceCoordination& select_id_RespondingNodeType_EutranrCellResourceCoordination() { return set<RespondingNodeType_EutranrCellResourceCoordination>(1); }
+		RespondingNodeType_EutranrCellResourceCoordination const* get_id_RespondingNodeType_EutranrCellResourceCoordination() const { return get<RespondingNodeType_EutranrCellResourceCoordination>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<RespondingNodeType_EutranrCellResourceCoordination>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<RespondingNodeType_EutranrCellResourceCoordination>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_RespondingNodeType_EutranrCellResourceCoordination()); 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<RespondingNodeType_EutranrCellResourceCoordination>()); 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(RespondingNodeType_EutranrCellResourceCoordination)];
+
+		};
+		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_RespondingNodeType_EutranrCellResourceCoordination() { 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};
+
+	};
+
+};
+/*
+EUTRANRCellResourceCoordinationResponse ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{EUTRANRCellResourceCoordinationResponse-IEs}},
+	...
+}
+*/
+
+struct EUTRANRCellResourceCoordinationResponse : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "EUTRANRCellResourceCoordinationResponse";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<EUTRANRCellResourceCoordinationResponse_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<EUTRANRCellResourceCoordinationResponse_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ErrorIndication-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Old-eNB-UE-X2AP-ID					CRITICALITY ignore	TYPE UE-X2AP-ID					PRESENCE optional}|
+	{ ID id-New-eNB-UE-X2AP-ID					CRITICALITY ignore	TYPE UE-X2AP-ID					PRESENCE optional}|
+	{ ID id-Cause								CRITICALITY ignore	TYPE Cause						PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics				CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional}|
+	{ ID id-Old-eNB-UE-X2AP-ID-Extension		CRITICALITY ignore	TYPE UE-X2AP-ID-Extension		PRESENCE optional}|
+	{ ID id-New-eNB-UE-X2AP-ID-Extension		CRITICALITY ignore	TYPE UE-X2AP-ID-Extension		PRESENCE optional}|
+	{ ID id-Old-SgNB-UE-X2AP-ID					CRITICALITY ignore	TYPE SgNB-UE-X2AP-ID			PRESENCE optional},
+	...
+}
+*/
+
+struct ErrorIndication_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 8; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=5;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=6;}
+		void select_id_Old_SgNB_UE_X2AP_ID() { set(id_Old_SgNB_UE_X2AP_ID); type=7;}
+		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_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
+			else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
+			else if(equal(id_Old_SgNB_UE_X2AP_ID)) { type = 7; return true; }
+			else { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_Old_eNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_Old_SgNB_UE_X2AP_ID);} return false;
+			case 8: type = 8; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 8; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
+		void select_id_Old_SgNB_UE_X2AP_ID() { set(ignore); type=7;}
+		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 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 { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
+		UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
+		SgNB_UE_X2AP_ID& select_id_Old_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(7); }
+		SgNB_UE_X2AP_ID const* get_id_Old_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(7); }
+		bool is_unknown() const { return type == 8; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 7: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+			v.template operator()<UE_X2AP_ID_Extension>(6);
+			v.template operator()<SgNB_UE_X2AP_ID>(7);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); return true;
+			case 5: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
+			case 6: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
+			case 7: v(select_id_Old_SgNB_UE_X2AP_ID()); return true;
+			case 8: if(type != 8) {clear(); asn::base::set();} type = 8; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 7: v(var.as<SgNB_UE_X2AP_ID>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID)];
+			char dummy5[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 8; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(optional); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(optional); type=2;}
+		void select_id_Cause() { set(optional); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
+		void select_id_Old_SgNB_UE_X2AP_ID() { set(optional); type=7;}
+		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(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 { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ErrorIndication ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ErrorIndication-IEs}},
+	...
+}
+*/
+
+struct ErrorIndication : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ErrorIndication";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ErrorIndication_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ErrorIndication_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+GNBStatusIndicationIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-GNBOverloadInformation		CRITICALITY ignore	TYPE GNBOverloadInformation		PRESENCE mandatory},
+	...
+}
+*/
+
+struct GNBStatusIndicationIEs
+{
+	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_GNBOverloadInformation() { set(id_GNBOverloadInformation); 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_GNBOverloadInformation)) { 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_GNBOverloadInformation);} 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_GNBOverloadInformation() { 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;}
+		GNBOverloadInformation& select_id_GNBOverloadInformation() { return set<GNBOverloadInformation>(1); }
+		GNBOverloadInformation const* get_id_GNBOverloadInformation() const { return get<GNBOverloadInformation>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GNBOverloadInformation>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GNBOverloadInformation>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_GNBOverloadInformation()); 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<GNBOverloadInformation>()); 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(GNBOverloadInformation)];
+
+		};
+		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_GNBOverloadInformation() { 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};
+
+	};
+
+};
+/*
+GNBStatusIndication ::= SEQUENCE {
+	protocolIEs			ProtocolIE-Container	{ { GNBStatusIndicationIEs} },
+	...
+}
+*/
+
+struct GNBStatusIndication : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "GNBStatusIndication";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<GNBStatusIndicationIEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<GNBStatusIndicationIEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+HandoverCancel-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Old-eNB-UE-X2AP-ID					CRITICALITY reject	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-New-eNB-UE-X2AP-ID					CRITICALITY ignore	TYPE UE-X2AP-ID					PRESENCE optional}|
+	{ ID id-Cause								CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-Old-eNB-UE-X2AP-ID-Extension		CRITICALITY reject	TYPE UE-X2AP-ID-Extension		PRESENCE optional}|
+	{ ID id-New-eNB-UE-X2AP-ID-Extension		CRITICALITY ignore	TYPE UE-X2AP-ID-Extension		PRESENCE optional},
+	...
+}
+*/
+
+struct HandoverCancel_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=4;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=5;}
+		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_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
+			else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_Old_eNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
+		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 if(equal(ignore)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(reject)) { type = 4; return true; }
+			else if(equal(ignore)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(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(reject);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<UE_X2AP_ID_Extension>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
+			case 5: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); 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(UE_X2AP_ID)];
+			char dummy3[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(optional); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		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 if(equal(optional)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+HandoverCancel ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{HandoverCancel-IEs}},
+	...
+}
+*/
+
+struct HandoverCancel : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "HandoverCancel";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<HandoverCancel_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<HandoverCancel_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+HandoverPreparationFailure-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Old-eNB-UE-X2AP-ID				CRITICALITY ignore	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-Cause							CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics			CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional}|
+	{ ID id-Old-eNB-UE-X2AP-ID-Extension	CRITICALITY ignore	TYPE UE-X2AP-ID-Extension		PRESENCE optional},
+
+	...
+}
+*/
+
+struct HandoverPreparationFailure_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
+		void select_id_Cause() { set(id_Cause); type=2;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=4;}
+		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_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_Cause)) { type = 2; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
+			else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { 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_Old_eNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_Cause() { set(ignore); type=2;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=4;}
+		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 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		Cause& select_id_Cause() { return set<Cause>(2); }
+		Cause const* get_id_Cause() const { return get<Cause>(2); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
+		UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
+		bool is_unknown() const { return type == 5; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<Cause>(); break;
+			case 3: var.destroy<CriticalityDiagnostics>(); break;
+			case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<Cause>(2);
+			v.template operator()<CriticalityDiagnostics>(3);
+			v.template operator()<UE_X2AP_ID_Extension>(4);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_Cause()); return true;
+			case 3: v(select_id_CriticalityDiagnostics()); return true;
+			case 4: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<Cause>()); return true;
+			case 3: v(var.as<CriticalityDiagnostics>()); return true;
+			case 4: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 5; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_Cause() { set(mandatory); type=2;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=3;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+HandoverPreparationFailure ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{HandoverPreparationFailure-IEs}},
+	...
+}
+*/
+
+struct HandoverPreparationFailure : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "HandoverPreparationFailure";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<HandoverPreparationFailure_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<HandoverPreparationFailure_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+MobilityInformation ::= BIT STRING (SIZE(32))
+*/
+
+struct MobilityInformation : asn::bstring<>
+{
+	using constraint_t = asn::constraints<false,asn::one<32>>;
+	static constexpr const char* name() {return "MobilityInformation";}
+	using parent_t = asn::bstring<>;
+
+};
+
+/*
+HandoverReport-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-HandoverReportType							CRITICALITY ignore	TYPE HandoverReportType									PRESENCE mandatory}|
+	{ ID id-Cause										CRITICALITY ignore	TYPE Cause													PRESENCE mandatory}|
+	{ ID id-SourceCellECGI								CRITICALITY ignore	TYPE ECGI													PRESENCE mandatory}|
+	{ ID id-FailureCellECGI								CRITICALITY ignore	TYPE ECGI													PRESENCE mandatory}|
+	{ ID id-Re-establishmentCellECGI					CRITICALITY ignore	TYPE ECGI													PRESENCE conditional} -- The IE shall be present if the Handover Report Type IE is set to “HO to Wrong Cell” -- |
+	{ ID id-TargetCellInUTRAN							CRITICALITY ignore	TYPE TargetCellInUTRAN									PRESENCE conditional} -- The IE shall be present if the Handover Report Type IE is set to "InterRAT ping-pong" --|
+	{ ID id-SourceCellCRNTI								CRITICALITY ignore	TYPE CRNTI													PRESENCE optional}|
+	{ ID id-MobilityInformation							CRITICALITY ignore	TYPE MobilityInformation									PRESENCE optional}|
+	{ ID id-UE-RLF-Report-Container						CRITICALITY ignore	TYPE UE-RLF-Report-Container							PRESENCE optional}|
+	{ ID id-UE-RLF-Report-Container-for-extended-bands	CRITICALITY ignore	TYPE UE-RLF-Report-Container-for-extended-bands	PRESENCE optional},
+	...
+}
+*/
+
+struct HandoverReport_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 11; }
+		void clear() {type = 0;}
+		void select_id_HandoverReportType() { set(id_HandoverReportType); type=1;}
+		void select_id_Cause() { set(id_Cause); type=2;}
+		void select_id_SourceCellECGI() { set(id_SourceCellECGI); type=3;}
+		void select_id_FailureCellECGI() { set(id_FailureCellECGI); type=4;}
+		void select_id_Re_establishmentCellECGI() { set(id_Re_establishmentCellECGI); type=5;}
+		void select_id_TargetCellInUTRAN() { set(id_TargetCellInUTRAN); type=6;}
+		void select_id_SourceCellCRNTI() { set(id_SourceCellCRNTI); type=7;}
+		void select_id_MobilityInformation() { set(id_MobilityInformation); type=8;}
+		void select_id_UE_RLF_Report_Container() { set(id_UE_RLF_Report_Container); type=9;}
+		void select_id_UE_RLF_Report_Container_for_extended_bands() { set(id_UE_RLF_Report_Container_for_extended_bands); type=10;}
+		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_HandoverReportType)) { type = 1; return true; }
+			else if(equal(id_Cause)) { type = 2; return true; }
+			else if(equal(id_SourceCellECGI)) { type = 3; return true; }
+			else if(equal(id_FailureCellECGI)) { type = 4; return true; }
+			else if(equal(id_Re_establishmentCellECGI)) { type = 5; return true; }
+			else if(equal(id_TargetCellInUTRAN)) { type = 6; return true; }
+			else if(equal(id_SourceCellCRNTI)) { type = 7; return true; }
+			else if(equal(id_MobilityInformation)) { type = 8; return true; }
+			else if(equal(id_UE_RLF_Report_Container)) { type = 9; return true; }
+			else if(equal(id_UE_RLF_Report_Container_for_extended_bands)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_HandoverReportType);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_SourceCellECGI);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_FailureCellECGI);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_Re_establishmentCellECGI);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_TargetCellInUTRAN);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_SourceCellCRNTI);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_MobilityInformation);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_UE_RLF_Report_Container);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(id_UE_RLF_Report_Container_for_extended_bands);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 11; }
+		void clear() {type = 0;}
+		void select_id_HandoverReportType() { set(ignore); type=1;}
+		void select_id_Cause() { set(ignore); type=2;}
+		void select_id_SourceCellECGI() { set(ignore); type=3;}
+		void select_id_FailureCellECGI() { set(ignore); type=4;}
+		void select_id_Re_establishmentCellECGI() { set(ignore); type=5;}
+		void select_id_TargetCellInUTRAN() { set(ignore); type=6;}
+		void select_id_SourceCellCRNTI() { set(ignore); type=7;}
+		void select_id_MobilityInformation() { set(ignore); type=8;}
+		void select_id_UE_RLF_Report_Container() { set(ignore); type=9;}
+		void select_id_UE_RLF_Report_Container_for_extended_bands() { set(ignore); type=10;}
+		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 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 if(equal(ignore)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		HandoverReportType& select_id_HandoverReportType() { return set<HandoverReportType>(1); }
+		HandoverReportType const* get_id_HandoverReportType() const { return get<HandoverReportType>(1); }
+		Cause& select_id_Cause() { return set<Cause>(2); }
+		Cause const* get_id_Cause() const { return get<Cause>(2); }
+		ECGI& select_id_SourceCellECGI() { return set<ECGI>(3); }
+		ECGI const* get_id_SourceCellECGI() const { return get<ECGI>(3); }
+		ECGI& select_id_FailureCellECGI() { return set<ECGI>(4); }
+		ECGI const* get_id_FailureCellECGI() const { return get<ECGI>(4); }
+		ECGI& select_id_Re_establishmentCellECGI() { return set<ECGI>(5); }
+		ECGI const* get_id_Re_establishmentCellECGI() const { return get<ECGI>(5); }
+		TargetCellInUTRAN& select_id_TargetCellInUTRAN() { return set<TargetCellInUTRAN>(6); }
+		TargetCellInUTRAN const* get_id_TargetCellInUTRAN() const { return get<TargetCellInUTRAN>(6); }
+		CRNTI& select_id_SourceCellCRNTI() { return set<CRNTI>(7); }
+		CRNTI const* get_id_SourceCellCRNTI() const { return get<CRNTI>(7); }
+		MobilityInformation& select_id_MobilityInformation() { return set<MobilityInformation>(8); }
+		MobilityInformation const* get_id_MobilityInformation() const { return get<MobilityInformation>(8); }
+		UE_RLF_Report_Container& select_id_UE_RLF_Report_Container() { return set<UE_RLF_Report_Container>(9); }
+		UE_RLF_Report_Container const* get_id_UE_RLF_Report_Container() const { return get<UE_RLF_Report_Container>(9); }
+		UE_RLF_Report_Container_for_extended_bands& select_id_UE_RLF_Report_Container_for_extended_bands() { return set<UE_RLF_Report_Container_for_extended_bands>(10); }
+		UE_RLF_Report_Container_for_extended_bands const* get_id_UE_RLF_Report_Container_for_extended_bands() const { return get<UE_RLF_Report_Container_for_extended_bands>(10); }
+		bool is_unknown() const { return type == 11; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<HandoverReportType>(); break;
+			case 2: var.destroy<Cause>(); break;
+			case 3: var.destroy<ECGI>(); break;
+			case 4: var.destroy<ECGI>(); break;
+			case 5: var.destroy<ECGI>(); break;
+			case 6: var.destroy<TargetCellInUTRAN>(); break;
+			case 7: var.destroy<CRNTI>(); break;
+			case 8: var.destroy<MobilityInformation>(); break;
+			case 9: var.destroy<UE_RLF_Report_Container>(); break;
+			case 10: var.destroy<UE_RLF_Report_Container_for_extended_bands>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<HandoverReportType>(1);
+			v.template operator()<Cause>(2);
+			v.template operator()<ECGI>(3);
+			v.template operator()<ECGI>(4);
+			v.template operator()<ECGI>(5);
+			v.template operator()<TargetCellInUTRAN>(6);
+			v.template operator()<CRNTI>(7);
+			v.template operator()<MobilityInformation>(8);
+			v.template operator()<UE_RLF_Report_Container>(9);
+			v.template operator()<UE_RLF_Report_Container_for_extended_bands>(10);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_HandoverReportType()); return true;
+			case 2: v(select_id_Cause()); return true;
+			case 3: v(select_id_SourceCellECGI()); return true;
+			case 4: v(select_id_FailureCellECGI()); return true;
+			case 5: v(select_id_Re_establishmentCellECGI()); return true;
+			case 6: v(select_id_TargetCellInUTRAN()); return true;
+			case 7: v(select_id_SourceCellCRNTI()); return true;
+			case 8: v(select_id_MobilityInformation()); return true;
+			case 9: v(select_id_UE_RLF_Report_Container()); return true;
+			case 10: v(select_id_UE_RLF_Report_Container_for_extended_bands()); return true;
+			case 11: if(type != 11) {clear(); asn::base::set();} type = 11; 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<HandoverReportType>()); return true;
+			case 2: v(var.as<Cause>()); return true;
+			case 3: v(var.as<ECGI>()); return true;
+			case 4: v(var.as<ECGI>()); return true;
+			case 5: v(var.as<ECGI>()); return true;
+			case 6: v(var.as<TargetCellInUTRAN>()); return true;
+			case 7: v(var.as<CRNTI>()); return true;
+			case 8: v(var.as<MobilityInformation>()); return true;
+			case 9: v(var.as<UE_RLF_Report_Container>()); return true;
+			case 10: v(var.as<UE_RLF_Report_Container_for_extended_bands>()); 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(CRNTI)];
+			char dummy2[sizeof(Cause)];
+			char dummy3[sizeof(ECGI)];
+			char dummy4[sizeof(HandoverReportType)];
+			char dummy5[sizeof(MobilityInformation)];
+			char dummy6[sizeof(TargetCellInUTRAN)];
+			char dummy7[sizeof(UE_RLF_Report_Container)];
+			char dummy8[sizeof(UE_RLF_Report_Container_for_extended_bands)];
+
+		};
+		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 == 11; }
+		void clear() {type = 0;}
+		void select_id_HandoverReportType() { set(mandatory); type=1;}
+		void select_id_Cause() { set(mandatory); type=2;}
+		void select_id_SourceCellECGI() { set(mandatory); type=3;}
+		void select_id_FailureCellECGI() { set(mandatory); type=4;}
+		void select_id_Re_establishmentCellECGI() { set(conditional); type=5;}
+		void select_id_TargetCellInUTRAN() { set(conditional); type=6;}
+		void select_id_SourceCellCRNTI() { set(optional); type=7;}
+		void select_id_MobilityInformation() { set(optional); type=8;}
+		void select_id_UE_RLF_Report_Container() { set(optional); type=9;}
+		void select_id_UE_RLF_Report_Container_for_extended_bands() { set(optional); type=10;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(mandatory)) { type = 4; return true; }
+			else if(equal(conditional)) { type = 5; return true; }
+			else if(equal(conditional)) { 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 if(equal(optional)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(conditional);} 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(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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+HandoverReport ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{HandoverReport-IEs}},
+	...
+}
+*/
+
+struct HandoverReport : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "HandoverReport";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<HandoverReport_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<HandoverReport_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+UE-ContextInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+{ ID id-ManagementBasedMDTallowed			CRITICALITY ignore	EXTENSION ManagementBasedMDTallowed					PRESENCE optional }|
+{ ID id-ManagementBasedMDTPLMNList			CRITICALITY ignore	EXTENSION MDTPLMNList									PRESENCE optional }|
+{ ID id-UESidelinkAggregateMaximumBitRate	CRITICALITY ignore	EXTENSION UESidelinkAggregateMaximumBitRate		PRESENCE optional},
+	...
+}
+*/
+
+struct UE_ContextInformation_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_ManagementBasedMDTallowed() { set(id_ManagementBasedMDTallowed); type=1;}
+		void select_id_ManagementBasedMDTPLMNList() { set(id_ManagementBasedMDTPLMNList); type=2;}
+		void select_id_UESidelinkAggregateMaximumBitRate() { set(id_UESidelinkAggregateMaximumBitRate); 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_ManagementBasedMDTallowed)) { type = 1; return true; }
+			else if(equal(id_ManagementBasedMDTPLMNList)) { type = 2; return true; }
+			else if(equal(id_UESidelinkAggregateMaximumBitRate)) { 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_ManagementBasedMDTallowed);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ManagementBasedMDTPLMNList);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_UESidelinkAggregateMaximumBitRate);} 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_ManagementBasedMDTallowed() { set(ignore); type=1;}
+		void select_id_ManagementBasedMDTPLMNList() { set(ignore); type=2;}
+		void select_id_UESidelinkAggregateMaximumBitRate() { 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;}
+		ManagementBasedMDTallowed& select_id_ManagementBasedMDTallowed() { return set<ManagementBasedMDTallowed>(1); }
+		ManagementBasedMDTallowed const* get_id_ManagementBasedMDTallowed() const { return get<ManagementBasedMDTallowed>(1); }
+		MDTPLMNList& select_id_ManagementBasedMDTPLMNList() { return set<MDTPLMNList>(2); }
+		MDTPLMNList const* get_id_ManagementBasedMDTPLMNList() const { return get<MDTPLMNList>(2); }
+		UESidelinkAggregateMaximumBitRate& select_id_UESidelinkAggregateMaximumBitRate() { return set<UESidelinkAggregateMaximumBitRate>(3); }
+		UESidelinkAggregateMaximumBitRate const* get_id_UESidelinkAggregateMaximumBitRate() const { return get<UESidelinkAggregateMaximumBitRate>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ManagementBasedMDTallowed>(); break;
+			case 2: var.destroy<MDTPLMNList>(); break;
+			case 3: var.destroy<UESidelinkAggregateMaximumBitRate>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ManagementBasedMDTallowed>(1);
+			v.template operator()<MDTPLMNList>(2);
+			v.template operator()<UESidelinkAggregateMaximumBitRate>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ManagementBasedMDTallowed()); return true;
+			case 2: v(select_id_ManagementBasedMDTPLMNList()); return true;
+			case 3: v(select_id_UESidelinkAggregateMaximumBitRate()); 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<ManagementBasedMDTallowed>()); return true;
+			case 2: v(var.as<MDTPLMNList>()); return true;
+			case 3: v(var.as<UESidelinkAggregateMaximumBitRate>()); 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(MDTPLMNList)];
+			char dummy2[sizeof(ManagementBasedMDTallowed)];
+			char dummy3[sizeof(UESidelinkAggregateMaximumBitRate)];
+
+		};
+		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_ManagementBasedMDTallowed() { set(optional); type=1;}
+		void select_id_ManagementBasedMDTPLMNList() { set(optional); type=2;}
+		void select_id_UESidelinkAggregateMaximumBitRate() { 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};
+
+	};
+
+};
+/*
+UE-ContextInformation ::= SEQUENCE {
+	mME-UE-S1AP-ID						UE-S1AP-ID,
+	uESecurityCapabilities				UESecurityCapabilities,
+	aS-SecurityInformation				AS-SecurityInformation,
+	uEaggregateMaximumBitRate			UEAggregateMaximumBitRate,
+	subscriberProfileIDforRFP			SubscriberProfileIDforRFP		OPTIONAL,
+	e-RABs-ToBeSetup-List				E-RABs-ToBeSetup-List,
+	rRC-Context							RRC-Context,
+	handoverRestrictionList				HandoverRestrictionList		OPTIONAL,
+	locationReportingInformation		LocationReportingInformation	OPTIONAL,
+	iE-Extensions						ProtocolExtensionContainer { {UE-ContextInformation-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct UE_ContextInformation : asn::sequence<10, 0, true, 4>
+{
+	static constexpr const char* name() {return "UE-ContextInformation";}
+	using parent_t = asn::sequence<10, 0, true, 4>;
+	struct mME_UE_S1AP_ID_t : UE_S1AP_ID
+	{
+		static constexpr const char* name() {return "mME_UE_S1AP_ID_t";}
+		using parent_t = UE_S1AP_ID;
+
+	};
+	mME_UE_S1AP_ID_t& ref_mME_UE_S1AP_ID() {return mME_UE_S1AP_ID;}
+	mME_UE_S1AP_ID_t const& ref_mME_UE_S1AP_ID() const {return mME_UE_S1AP_ID;}
+	struct uESecurityCapabilities_t : UESecurityCapabilities
+	{
+		static constexpr const char* name() {return "uESecurityCapabilities_t";}
+		using parent_t = UESecurityCapabilities;
+
+	};
+	uESecurityCapabilities_t& ref_uESecurityCapabilities() {return uESecurityCapabilities;}
+	uESecurityCapabilities_t const& ref_uESecurityCapabilities() const {return uESecurityCapabilities;}
+	struct aS_SecurityInformation_t : AS_SecurityInformation
+	{
+		static constexpr const char* name() {return "aS_SecurityInformation_t";}
+		using parent_t = AS_SecurityInformation;
+
+	};
+	aS_SecurityInformation_t& ref_aS_SecurityInformation() {return aS_SecurityInformation;}
+	aS_SecurityInformation_t const& ref_aS_SecurityInformation() const {return aS_SecurityInformation;}
+	struct uEaggregateMaximumBitRate_t : UEAggregateMaximumBitRate
+	{
+		static constexpr const char* name() {return "uEaggregateMaximumBitRate_t";}
+		using parent_t = UEAggregateMaximumBitRate;
+
+	};
+	uEaggregateMaximumBitRate_t& ref_uEaggregateMaximumBitRate() {return uEaggregateMaximumBitRate;}
+	uEaggregateMaximumBitRate_t const& ref_uEaggregateMaximumBitRate() const {return uEaggregateMaximumBitRate;}
+	struct subscriberProfileIDforRFP_t : SubscriberProfileIDforRFP
+	{
+		static constexpr const char* name() {return "subscriberProfileIDforRFP_t";}
+		using parent_t = SubscriberProfileIDforRFP;
+		static constexpr bool optional = true;
+
+	};
+	subscriberProfileIDforRFP_t& set_subscriberProfileIDforRFP() { subscriberProfileIDforRFP.setpresent(true); return subscriberProfileIDforRFP;}
+	subscriberProfileIDforRFP_t const* get_subscriberProfileIDforRFP() const {return subscriberProfileIDforRFP.is_valid() ? &subscriberProfileIDforRFP : nullptr;}
+	struct e_RABs_ToBeSetup_List_t : E_RABs_ToBeSetup_List
+	{
+		static constexpr const char* name() {return "e_RABs_ToBeSetup_List_t";}
+		using parent_t = E_RABs_ToBeSetup_List;
+
+	};
+	e_RABs_ToBeSetup_List_t& ref_e_RABs_ToBeSetup_List() {return e_RABs_ToBeSetup_List;}
+	e_RABs_ToBeSetup_List_t const& ref_e_RABs_ToBeSetup_List() const {return e_RABs_ToBeSetup_List;}
+	struct rRC_Context_t : RRC_Context
+	{
+		static constexpr const char* name() {return "rRC_Context_t";}
+		using parent_t = RRC_Context;
+
+	};
+	rRC_Context_t& ref_rRC_Context() {return rRC_Context;}
+	rRC_Context_t const& ref_rRC_Context() const {return rRC_Context;}
+	struct handoverRestrictionList_t : HandoverRestrictionList
+	{
+		static constexpr const char* name() {return "handoverRestrictionList_t";}
+		using parent_t = HandoverRestrictionList;
+		static constexpr bool optional = true;
+
+	};
+	handoverRestrictionList_t& set_handoverRestrictionList() { handoverRestrictionList.setpresent(true); return handoverRestrictionList;}
+	handoverRestrictionList_t const* get_handoverRestrictionList() const {return handoverRestrictionList.is_valid() ? &handoverRestrictionList : nullptr;}
+	struct locationReportingInformation_t : LocationReportingInformation
+	{
+		static constexpr const char* name() {return "locationReportingInformation_t";}
+		using parent_t = LocationReportingInformation;
+		static constexpr bool optional = true;
+
+	};
+	locationReportingInformation_t& set_locationReportingInformation() { locationReportingInformation.setpresent(true); return locationReportingInformation;}
+	locationReportingInformation_t const* get_locationReportingInformation() const {return locationReportingInformation.is_valid() ? &locationReportingInformation : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextInformation_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UE_ContextInformation_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(mME_UE_S1AP_ID);
+		v(uESecurityCapabilities);
+		v(aS_SecurityInformation);
+		v(uEaggregateMaximumBitRate);
+		v(subscriberProfileIDforRFP);
+		v(e_RABs_ToBeSetup_List);
+		v(rRC_Context);
+		v(handoverRestrictionList);
+		v(locationReportingInformation);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(mME_UE_S1AP_ID);
+		v(uESecurityCapabilities);
+		v(aS_SecurityInformation);
+		v(uEaggregateMaximumBitRate);
+		v(subscriberProfileIDforRFP);
+		v(e_RABs_ToBeSetup_List);
+		v(rRC_Context);
+		v(handoverRestrictionList);
+		v(locationReportingInformation);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		mME_UE_S1AP_ID.clear();
+		uESecurityCapabilities.clear();
+		aS_SecurityInformation.clear();
+		uEaggregateMaximumBitRate.clear();
+		subscriberProfileIDforRFP.clear();
+		e_RABs_ToBeSetup_List.clear();
+		rRC_Context.clear();
+		handoverRestrictionList.clear();
+		locationReportingInformation.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	mME_UE_S1AP_ID_t	mME_UE_S1AP_ID;
+	uESecurityCapabilities_t	uESecurityCapabilities;
+	aS_SecurityInformation_t	aS_SecurityInformation;
+	uEaggregateMaximumBitRate_t	uEaggregateMaximumBitRate;
+	subscriberProfileIDforRFP_t	subscriberProfileIDforRFP;
+	e_RABs_ToBeSetup_List_t	e_RABs_ToBeSetup_List;
+	rRC_Context_t	rRC_Context;
+	handoverRestrictionList_t	handoverRestrictionList;
+	locationReportingInformation_t	locationReportingInformation;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+UE-ContextReferenceAtSeNB-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct UE_ContextReferenceAtSeNB_ItemExtIEs
+{
+	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-ContextReferenceAtSeNB ::= SEQUENCE {
+	source-GlobalSeNB-ID		GlobalENB-ID,
+	seNB-UE-X2AP-ID				UE-X2AP-ID,
+	seNB-UE-X2AP-ID-Extension	UE-X2AP-ID-Extension,
+	iE-Extensions				ProtocolExtensionContainer { {UE-ContextReferenceAtSeNB-ItemExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct UE_ContextReferenceAtSeNB : asn::sequence<4, 0, true, 1>
+{
+	static constexpr const char* name() {return "UE-ContextReferenceAtSeNB";}
+	using parent_t = asn::sequence<4, 0, true, 1>;
+	struct source_GlobalSeNB_ID_t : GlobalENB_ID
+	{
+		static constexpr const char* name() {return "source_GlobalSeNB_ID_t";}
+		using parent_t = GlobalENB_ID;
+
+	};
+	source_GlobalSeNB_ID_t& ref_source_GlobalSeNB_ID() {return source_GlobalSeNB_ID;}
+	source_GlobalSeNB_ID_t const& ref_source_GlobalSeNB_ID() const {return source_GlobalSeNB_ID;}
+	struct seNB_UE_X2AP_ID_t : UE_X2AP_ID
+	{
+		static constexpr const char* name() {return "seNB_UE_X2AP_ID_t";}
+		using parent_t = UE_X2AP_ID;
+
+	};
+	seNB_UE_X2AP_ID_t& ref_seNB_UE_X2AP_ID() {return seNB_UE_X2AP_ID;}
+	seNB_UE_X2AP_ID_t const& ref_seNB_UE_X2AP_ID() const {return seNB_UE_X2AP_ID;}
+	struct seNB_UE_X2AP_ID_Extension_t : UE_X2AP_ID_Extension
+	{
+		static constexpr const char* name() {return "seNB_UE_X2AP_ID_Extension_t";}
+		using parent_t = UE_X2AP_ID_Extension;
+
+	};
+	seNB_UE_X2AP_ID_Extension_t& ref_seNB_UE_X2AP_ID_Extension() {return seNB_UE_X2AP_ID_Extension;}
+	seNB_UE_X2AP_ID_Extension_t const& ref_seNB_UE_X2AP_ID_Extension() const {return seNB_UE_X2AP_ID_Extension;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextReferenceAtSeNB_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UE_ContextReferenceAtSeNB_ItemExtIEs>;
+		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(source_GlobalSeNB_ID);
+		v(seNB_UE_X2AP_ID);
+		v(seNB_UE_X2AP_ID_Extension);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(source_GlobalSeNB_ID);
+		v(seNB_UE_X2AP_ID);
+		v(seNB_UE_X2AP_ID_Extension);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		source_GlobalSeNB_ID.clear();
+		seNB_UE_X2AP_ID.clear();
+		seNB_UE_X2AP_ID_Extension.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	source_GlobalSeNB_ID_t	source_GlobalSeNB_ID;
+	seNB_UE_X2AP_ID_t	seNB_UE_X2AP_ID;
+	seNB_UE_X2AP_ID_Extension_t	seNB_UE_X2AP_ID_Extension;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+UE-ContextReferenceAtWT-ItemExtIEs	X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct UE_ContextReferenceAtWT_ItemExtIEs
+{
+	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-ContextReferenceAtWT ::= SEQUENCE {
+	wTID					WTID,
+	wT-UE-XwAP-ID			WT-UE-XwAP-ID,
+	iE-Extensions			ProtocolExtensionContainer { {UE-ContextReferenceAtWT-ItemExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct UE_ContextReferenceAtWT : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "UE-ContextReferenceAtWT";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct wTID_t : WTID
+	{
+		static constexpr const char* name() {return "wTID_t";}
+		using parent_t = WTID;
+
+	};
+	wTID_t& ref_wTID() {return wTID;}
+	wTID_t const& ref_wTID() const {return wTID;}
+	struct wT_UE_XwAP_ID_t : WT_UE_XwAP_ID
+	{
+		static constexpr const char* name() {return "wT_UE_XwAP_ID_t";}
+		using parent_t = WT_UE_XwAP_ID;
+
+	};
+	wT_UE_XwAP_ID_t& ref_wT_UE_XwAP_ID() {return wT_UE_XwAP_ID;}
+	wT_UE_XwAP_ID_t const& ref_wT_UE_XwAP_ID() const {return wT_UE_XwAP_ID;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextReferenceAtWT_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UE_ContextReferenceAtWT_ItemExtIEs>;
+		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(wTID);
+		v(wT_UE_XwAP_ID);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(wTID);
+		v(wT_UE_XwAP_ID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		wTID.clear();
+		wT_UE_XwAP_ID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	wTID_t	wTID;
+	wT_UE_XwAP_ID_t	wT_UE_XwAP_ID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+UE-ContextReferenceAtSgNB-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct UE_ContextReferenceAtSgNB_ItemExtIEs
+{
+	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-ContextReferenceAtSgNB ::= SEQUENCE {
+	source-GlobalSgNB-ID			GlobalGNB-ID,
+	sgNB-UE-X2AP-ID				SgNB-UE-X2AP-ID,
+	iE-Extensions				ProtocolExtensionContainer { {UE-ContextReferenceAtSgNB-ItemExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct UE_ContextReferenceAtSgNB : asn::sequence<3, 0, true, 1>
+{
+	static constexpr const char* name() {return "UE-ContextReferenceAtSgNB";}
+	using parent_t = asn::sequence<3, 0, true, 1>;
+	struct source_GlobalSgNB_ID_t : GlobalGNB_ID
+	{
+		static constexpr const char* name() {return "source_GlobalSgNB_ID_t";}
+		using parent_t = GlobalGNB_ID;
+
+	};
+	source_GlobalSgNB_ID_t& ref_source_GlobalSgNB_ID() {return source_GlobalSgNB_ID;}
+	source_GlobalSgNB_ID_t const& ref_source_GlobalSgNB_ID() const {return source_GlobalSgNB_ID;}
+	struct sgNB_UE_X2AP_ID_t : SgNB_UE_X2AP_ID
+	{
+		static constexpr const char* name() {return "sgNB_UE_X2AP_ID_t";}
+		using parent_t = SgNB_UE_X2AP_ID;
+
+	};
+	sgNB_UE_X2AP_ID_t& ref_sgNB_UE_X2AP_ID() {return sgNB_UE_X2AP_ID;}
+	sgNB_UE_X2AP_ID_t const& ref_sgNB_UE_X2AP_ID() const {return sgNB_UE_X2AP_ID;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextReferenceAtSgNB_ItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UE_ContextReferenceAtSgNB_ItemExtIEs>;
+		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(source_GlobalSgNB_ID);
+		v(sgNB_UE_X2AP_ID);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(source_GlobalSgNB_ID);
+		v(sgNB_UE_X2AP_ID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		source_GlobalSgNB_ID.clear();
+		sgNB_UE_X2AP_ID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	source_GlobalSgNB_ID_t	source_GlobalSgNB_ID;
+	sgNB_UE_X2AP_ID_t	sgNB_UE_X2AP_ID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+HandoverRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Old-eNB-UE-X2AP-ID					CRITICALITY reject	TYPE UE-X2AP-ID								PRESENCE mandatory}|
+	{ ID id-Cause								CRITICALITY ignore	TYPE Cause									PRESENCE mandatory}|
+	{ ID id-TargetCell-ID						CRITICALITY reject	TYPE ECGI									PRESENCE mandatory}|
+	{ ID id-GUMMEI-ID							CRITICALITY reject	TYPE GUMMEI									PRESENCE mandatory}|
+	{ ID id-UE-ContextInformation				CRITICALITY reject	TYPE UE-ContextInformation					PRESENCE mandatory}|
+	{ ID id-UE-HistoryInformation				CRITICALITY ignore	TYPE UE-HistoryInformation					PRESENCE mandatory}|
+	{ ID id-TraceActivation						CRITICALITY ignore	TYPE TraceActivation						PRESENCE optional}|
+	{ ID id-SRVCCOperationPossible				CRITICALITY ignore	TYPE SRVCCOperationPossible					PRESENCE optional}|
+	{ ID id-CSGMembershipStatus					CRITICALITY reject	TYPE CSGMembershipStatus					PRESENCE optional}|
+	{ ID id-MobilityInformation					CRITICALITY ignore	TYPE MobilityInformation					PRESENCE optional}|
+	{ ID id-Masked-IMEISV						CRITICALITY ignore	TYPE Masked-IMEISV							PRESENCE optional}|
+	{ ID id-UE-HistoryInformationFromTheUE		CRITICALITY ignore	TYPE UE-HistoryInformationFromTheUE		PRESENCE optional}|
+	{ ID id-ExpectedUEBehaviour					CRITICALITY ignore	TYPE ExpectedUEBehaviour					PRESENCE optional}|
+	{ ID id-ProSeAuthorized						CRITICALITY ignore	TYPE ProSeAuthorized						PRESENCE optional}|
+	{ ID id-UE-ContextReferenceAtSeNB			CRITICALITY ignore	TYPE UE-ContextReferenceAtSeNB			PRESENCE optional}|
+	{ ID id-Old-eNB-UE-X2AP-ID-Extension		CRITICALITY reject	TYPE UE-X2AP-ID-Extension					PRESENCE optional}|
+	{ ID id-V2XServicesAuthorized				CRITICALITY ignore	TYPE V2XServicesAuthorized					PRESENCE optional}|
+	{ ID id-UE-ContextReferenceAtWT				CRITICALITY ignore	TYPE UE-ContextReferenceAtWT				PRESENCE optional}|
+	{ ID id-NRUESecurityCapabilities				CRITICALITY ignore	TYPE NRUESecurityCapabilities				PRESENCE optional}|
+	{ ID id-UE-ContextReferenceAtSgNB			CRITICALITY ignore	TYPE UE-ContextReferenceAtSgNB			PRESENCE optional}|
+	{ ID id-AerialUEsubscriptionInformation		CRITICALITY ignore	TYPE AerialUEsubscriptionInformation	PRESENCE optional}|
+	{ ID id-Subscription-Based-UE-DifferentiationInfo		CRITICALITY ignore	TYPE Subscription-Based-UE-DifferentiationInfo				PRESENCE optional},
+	...
+}
+*/
+
+struct HandoverRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 23; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
+		void select_id_Cause() { set(id_Cause); type=2;}
+		void select_id_TargetCell_ID() { set(id_TargetCell_ID); type=3;}
+		void select_id_GUMMEI_ID() { set(id_GUMMEI_ID); type=4;}
+		void select_id_UE_ContextInformation() { set(id_UE_ContextInformation); type=5;}
+		void select_id_UE_HistoryInformation() { set(id_UE_HistoryInformation); type=6;}
+		void select_id_TraceActivation() { set(id_TraceActivation); type=7;}
+		void select_id_SRVCCOperationPossible() { set(id_SRVCCOperationPossible); type=8;}
+		void select_id_CSGMembershipStatus() { set(id_CSGMembershipStatus); type=9;}
+		void select_id_MobilityInformation() { set(id_MobilityInformation); type=10;}
+		void select_id_Masked_IMEISV() { set(id_Masked_IMEISV); type=11;}
+		void select_id_UE_HistoryInformationFromTheUE() { set(id_UE_HistoryInformationFromTheUE); type=12;}
+		void select_id_ExpectedUEBehaviour() { set(id_ExpectedUEBehaviour); type=13;}
+		void select_id_ProSeAuthorized() { set(id_ProSeAuthorized); type=14;}
+		void select_id_UE_ContextReferenceAtSeNB() { set(id_UE_ContextReferenceAtSeNB); type=15;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=16;}
+		void select_id_V2XServicesAuthorized() { set(id_V2XServicesAuthorized); type=17;}
+		void select_id_UE_ContextReferenceAtWT() { set(id_UE_ContextReferenceAtWT); type=18;}
+		void select_id_NRUESecurityCapabilities() { set(id_NRUESecurityCapabilities); type=19;}
+		void select_id_UE_ContextReferenceAtSgNB() { set(id_UE_ContextReferenceAtSgNB); type=20;}
+		void select_id_AerialUEsubscriptionInformation() { set(id_AerialUEsubscriptionInformation); type=21;}
+		void select_id_Subscription_Based_UE_DifferentiationInfo() { set(id_Subscription_Based_UE_DifferentiationInfo); type=22;}
+		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_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_Cause)) { type = 2; return true; }
+			else if(equal(id_TargetCell_ID)) { type = 3; return true; }
+			else if(equal(id_GUMMEI_ID)) { type = 4; return true; }
+			else if(equal(id_UE_ContextInformation)) { type = 5; return true; }
+			else if(equal(id_UE_HistoryInformation)) { type = 6; return true; }
+			else if(equal(id_TraceActivation)) { type = 7; return true; }
+			else if(equal(id_SRVCCOperationPossible)) { type = 8; return true; }
+			else if(equal(id_CSGMembershipStatus)) { type = 9; return true; }
+			else if(equal(id_MobilityInformation)) { type = 10; return true; }
+			else if(equal(id_Masked_IMEISV)) { type = 11; return true; }
+			else if(equal(id_UE_HistoryInformationFromTheUE)) { type = 12; return true; }
+			else if(equal(id_ExpectedUEBehaviour)) { type = 13; return true; }
+			else if(equal(id_ProSeAuthorized)) { type = 14; return true; }
+			else if(equal(id_UE_ContextReferenceAtSeNB)) { type = 15; return true; }
+			else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 16; return true; }
+			else if(equal(id_V2XServicesAuthorized)) { type = 17; return true; }
+			else if(equal(id_UE_ContextReferenceAtWT)) { type = 18; return true; }
+			else if(equal(id_NRUESecurityCapabilities)) { type = 19; return true; }
+			else if(equal(id_UE_ContextReferenceAtSgNB)) { type = 20; return true; }
+			else if(equal(id_AerialUEsubscriptionInformation)) { type = 21; return true; }
+			else if(equal(id_Subscription_Based_UE_DifferentiationInfo)) { type = 22; return true; }
+			else { type = 23; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_Old_eNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_TargetCell_ID);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_GUMMEI_ID);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_UE_ContextInformation);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_UE_HistoryInformation);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_TraceActivation);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_SRVCCOperationPossible);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_CSGMembershipStatus);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(id_MobilityInformation);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(id_Masked_IMEISV);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(id_UE_HistoryInformationFromTheUE);} return false;
+			case 13: type = 13; if(v(ref_nested())) { return equal(id_ExpectedUEBehaviour);} return false;
+			case 14: type = 14; if(v(ref_nested())) { return equal(id_ProSeAuthorized);} return false;
+			case 15: type = 15; if(v(ref_nested())) { return equal(id_UE_ContextReferenceAtSeNB);} return false;
+			case 16: type = 16; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
+			case 17: type = 17; if(v(ref_nested())) { return equal(id_V2XServicesAuthorized);} return false;
+			case 18: type = 18; if(v(ref_nested())) { return equal(id_UE_ContextReferenceAtWT);} return false;
+			case 19: type = 19; if(v(ref_nested())) { return equal(id_NRUESecurityCapabilities);} return false;
+			case 20: type = 20; if(v(ref_nested())) { return equal(id_UE_ContextReferenceAtSgNB);} return false;
+			case 21: type = 21; if(v(ref_nested())) { return equal(id_AerialUEsubscriptionInformation);} return false;
+			case 22: type = 22; if(v(ref_nested())) { return equal(id_Subscription_Based_UE_DifferentiationInfo);} return false;
+			case 23: type = 23; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 23; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_Cause() { set(ignore); type=2;}
+		void select_id_TargetCell_ID() { set(reject); type=3;}
+		void select_id_GUMMEI_ID() { set(reject); type=4;}
+		void select_id_UE_ContextInformation() { set(reject); type=5;}
+		void select_id_UE_HistoryInformation() { set(ignore); type=6;}
+		void select_id_TraceActivation() { set(ignore); type=7;}
+		void select_id_SRVCCOperationPossible() { set(ignore); type=8;}
+		void select_id_CSGMembershipStatus() { set(reject); type=9;}
+		void select_id_MobilityInformation() { set(ignore); type=10;}
+		void select_id_Masked_IMEISV() { set(ignore); type=11;}
+		void select_id_UE_HistoryInformationFromTheUE() { set(ignore); type=12;}
+		void select_id_ExpectedUEBehaviour() { set(ignore); type=13;}
+		void select_id_ProSeAuthorized() { set(ignore); type=14;}
+		void select_id_UE_ContextReferenceAtSeNB() { set(ignore); type=15;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(reject); type=16;}
+		void select_id_V2XServicesAuthorized() { set(ignore); type=17;}
+		void select_id_UE_ContextReferenceAtWT() { set(ignore); type=18;}
+		void select_id_NRUESecurityCapabilities() { set(ignore); type=19;}
+		void select_id_UE_ContextReferenceAtSgNB() { set(ignore); type=20;}
+		void select_id_AerialUEsubscriptionInformation() { set(ignore); type=21;}
+		void select_id_Subscription_Based_UE_DifferentiationInfo() { set(ignore); type=22;}
+		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 if(equal(ignore)) { type = 2; return true; }
+			else if(equal(reject)) { type = 3; return true; }
+			else if(equal(reject)) { type = 4; return true; }
+			else if(equal(reject)) { 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(reject)) { type = 9; return true; }
+			else if(equal(ignore)) { type = 10; return true; }
+			else if(equal(ignore)) { type = 11; return true; }
+			else if(equal(ignore)) { type = 12; return true; }
+			else if(equal(ignore)) { type = 13; return true; }
+			else if(equal(ignore)) { type = 14; return true; }
+			else if(equal(ignore)) { type = 15; return true; }
+			else if(equal(reject)) { type = 16; return true; }
+			else if(equal(ignore)) { type = 17; return true; }
+			else if(equal(ignore)) { type = 18; return true; }
+			else if(equal(ignore)) { type = 19; return true; }
+			else if(equal(ignore)) { type = 20; return true; }
+			else if(equal(ignore)) { type = 21; return true; }
+			else if(equal(ignore)) { type = 22; return true; }
+			else { type = 23; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(ignore);} 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(reject);} 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(reject);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 13: type = 13; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 14: type = 14; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 15: type = 15; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 16: type = 16; if(v(ref_nested())) { return equal(reject);} return false;
+			case 17: type = 17; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 18: type = 18; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 19: type = 19; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 20: type = 20; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 21: type = 21; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 22: type = 22; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 23: type = 23; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		Cause& select_id_Cause() { return set<Cause>(2); }
+		Cause const* get_id_Cause() const { return get<Cause>(2); }
+		ECGI& select_id_TargetCell_ID() { return set<ECGI>(3); }
+		ECGI const* get_id_TargetCell_ID() const { return get<ECGI>(3); }
+		GUMMEI& select_id_GUMMEI_ID() { return set<GUMMEI>(4); }
+		GUMMEI const* get_id_GUMMEI_ID() const { return get<GUMMEI>(4); }
+		UE_ContextInformation& select_id_UE_ContextInformation() { return set<UE_ContextInformation>(5); }
+		UE_ContextInformation const* get_id_UE_ContextInformation() const { return get<UE_ContextInformation>(5); }
+		UE_HistoryInformation& select_id_UE_HistoryInformation() { return set<UE_HistoryInformation>(6); }
+		UE_HistoryInformation const* get_id_UE_HistoryInformation() const { return get<UE_HistoryInformation>(6); }
+		TraceActivation& select_id_TraceActivation() { return set<TraceActivation>(7); }
+		TraceActivation const* get_id_TraceActivation() const { return get<TraceActivation>(7); }
+		SRVCCOperationPossible& select_id_SRVCCOperationPossible() { return set<SRVCCOperationPossible>(8); }
+		SRVCCOperationPossible const* get_id_SRVCCOperationPossible() const { return get<SRVCCOperationPossible>(8); }
+		CSGMembershipStatus& select_id_CSGMembershipStatus() { return set<CSGMembershipStatus>(9); }
+		CSGMembershipStatus const* get_id_CSGMembershipStatus() const { return get<CSGMembershipStatus>(9); }
+		MobilityInformation& select_id_MobilityInformation() { return set<MobilityInformation>(10); }
+		MobilityInformation const* get_id_MobilityInformation() const { return get<MobilityInformation>(10); }
+		Masked_IMEISV& select_id_Masked_IMEISV() { return set<Masked_IMEISV>(11); }
+		Masked_IMEISV const* get_id_Masked_IMEISV() const { return get<Masked_IMEISV>(11); }
+		UE_HistoryInformationFromTheUE& select_id_UE_HistoryInformationFromTheUE() { return set<UE_HistoryInformationFromTheUE>(12); }
+		UE_HistoryInformationFromTheUE const* get_id_UE_HistoryInformationFromTheUE() const { return get<UE_HistoryInformationFromTheUE>(12); }
+		ExpectedUEBehaviour& select_id_ExpectedUEBehaviour() { return set<ExpectedUEBehaviour>(13); }
+		ExpectedUEBehaviour const* get_id_ExpectedUEBehaviour() const { return get<ExpectedUEBehaviour>(13); }
+		ProSeAuthorized& select_id_ProSeAuthorized() { return set<ProSeAuthorized>(14); }
+		ProSeAuthorized const* get_id_ProSeAuthorized() const { return get<ProSeAuthorized>(14); }
+		UE_ContextReferenceAtSeNB& select_id_UE_ContextReferenceAtSeNB() { return set<UE_ContextReferenceAtSeNB>(15); }
+		UE_ContextReferenceAtSeNB const* get_id_UE_ContextReferenceAtSeNB() const { return get<UE_ContextReferenceAtSeNB>(15); }
+		UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(16); }
+		UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(16); }
+		V2XServicesAuthorized& select_id_V2XServicesAuthorized() { return set<V2XServicesAuthorized>(17); }
+		V2XServicesAuthorized const* get_id_V2XServicesAuthorized() const { return get<V2XServicesAuthorized>(17); }
+		UE_ContextReferenceAtWT& select_id_UE_ContextReferenceAtWT() { return set<UE_ContextReferenceAtWT>(18); }
+		UE_ContextReferenceAtWT const* get_id_UE_ContextReferenceAtWT() const { return get<UE_ContextReferenceAtWT>(18); }
+		NRUESecurityCapabilities& select_id_NRUESecurityCapabilities() { return set<NRUESecurityCapabilities>(19); }
+		NRUESecurityCapabilities const* get_id_NRUESecurityCapabilities() const { return get<NRUESecurityCapabilities>(19); }
+		UE_ContextReferenceAtSgNB& select_id_UE_ContextReferenceAtSgNB() { return set<UE_ContextReferenceAtSgNB>(20); }
+		UE_ContextReferenceAtSgNB const* get_id_UE_ContextReferenceAtSgNB() const { return get<UE_ContextReferenceAtSgNB>(20); }
+		AerialUEsubscriptionInformation& select_id_AerialUEsubscriptionInformation() { return set<AerialUEsubscriptionInformation>(21); }
+		AerialUEsubscriptionInformation const* get_id_AerialUEsubscriptionInformation() const { return get<AerialUEsubscriptionInformation>(21); }
+		Subscription_Based_UE_DifferentiationInfo& select_id_Subscription_Based_UE_DifferentiationInfo() { return set<Subscription_Based_UE_DifferentiationInfo>(22); }
+		Subscription_Based_UE_DifferentiationInfo const* get_id_Subscription_Based_UE_DifferentiationInfo() const { return get<Subscription_Based_UE_DifferentiationInfo>(22); }
+		bool is_unknown() const { return type == 23; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<Cause>(); break;
+			case 3: var.destroy<ECGI>(); break;
+			case 4: var.destroy<GUMMEI>(); break;
+			case 5: var.destroy<UE_ContextInformation>(); break;
+			case 6: var.destroy<UE_HistoryInformation>(); break;
+			case 7: var.destroy<TraceActivation>(); break;
+			case 8: var.destroy<SRVCCOperationPossible>(); break;
+			case 9: var.destroy<CSGMembershipStatus>(); break;
+			case 10: var.destroy<MobilityInformation>(); break;
+			case 11: var.destroy<Masked_IMEISV>(); break;
+			case 12: var.destroy<UE_HistoryInformationFromTheUE>(); break;
+			case 13: var.destroy<ExpectedUEBehaviour>(); break;
+			case 14: var.destroy<ProSeAuthorized>(); break;
+			case 15: var.destroy<UE_ContextReferenceAtSeNB>(); break;
+			case 16: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 17: var.destroy<V2XServicesAuthorized>(); break;
+			case 18: var.destroy<UE_ContextReferenceAtWT>(); break;
+			case 19: var.destroy<NRUESecurityCapabilities>(); break;
+			case 20: var.destroy<UE_ContextReferenceAtSgNB>(); break;
+			case 21: var.destroy<AerialUEsubscriptionInformation>(); break;
+			case 22: var.destroy<Subscription_Based_UE_DifferentiationInfo>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<Cause>(2);
+			v.template operator()<ECGI>(3);
+			v.template operator()<GUMMEI>(4);
+			v.template operator()<UE_ContextInformation>(5);
+			v.template operator()<UE_HistoryInformation>(6);
+			v.template operator()<TraceActivation>(7);
+			v.template operator()<SRVCCOperationPossible>(8);
+			v.template operator()<CSGMembershipStatus>(9);
+			v.template operator()<MobilityInformation>(10);
+			v.template operator()<Masked_IMEISV>(11);
+			v.template operator()<UE_HistoryInformationFromTheUE>(12);
+			v.template operator()<ExpectedUEBehaviour>(13);
+			v.template operator()<ProSeAuthorized>(14);
+			v.template operator()<UE_ContextReferenceAtSeNB>(15);
+			v.template operator()<UE_X2AP_ID_Extension>(16);
+			v.template operator()<V2XServicesAuthorized>(17);
+			v.template operator()<UE_ContextReferenceAtWT>(18);
+			v.template operator()<NRUESecurityCapabilities>(19);
+			v.template operator()<UE_ContextReferenceAtSgNB>(20);
+			v.template operator()<AerialUEsubscriptionInformation>(21);
+			v.template operator()<Subscription_Based_UE_DifferentiationInfo>(22);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_Cause()); return true;
+			case 3: v(select_id_TargetCell_ID()); return true;
+			case 4: v(select_id_GUMMEI_ID()); return true;
+			case 5: v(select_id_UE_ContextInformation()); return true;
+			case 6: v(select_id_UE_HistoryInformation()); return true;
+			case 7: v(select_id_TraceActivation()); return true;
+			case 8: v(select_id_SRVCCOperationPossible()); return true;
+			case 9: v(select_id_CSGMembershipStatus()); return true;
+			case 10: v(select_id_MobilityInformation()); return true;
+			case 11: v(select_id_Masked_IMEISV()); return true;
+			case 12: v(select_id_UE_HistoryInformationFromTheUE()); return true;
+			case 13: v(select_id_ExpectedUEBehaviour()); return true;
+			case 14: v(select_id_ProSeAuthorized()); return true;
+			case 15: v(select_id_UE_ContextReferenceAtSeNB()); return true;
+			case 16: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
+			case 17: v(select_id_V2XServicesAuthorized()); return true;
+			case 18: v(select_id_UE_ContextReferenceAtWT()); return true;
+			case 19: v(select_id_NRUESecurityCapabilities()); return true;
+			case 20: v(select_id_UE_ContextReferenceAtSgNB()); return true;
+			case 21: v(select_id_AerialUEsubscriptionInformation()); return true;
+			case 22: v(select_id_Subscription_Based_UE_DifferentiationInfo()); return true;
+			case 23: if(type != 23) {clear(); asn::base::set();} type = 23; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<Cause>()); return true;
+			case 3: v(var.as<ECGI>()); return true;
+			case 4: v(var.as<GUMMEI>()); return true;
+			case 5: v(var.as<UE_ContextInformation>()); return true;
+			case 6: v(var.as<UE_HistoryInformation>()); return true;
+			case 7: v(var.as<TraceActivation>()); return true;
+			case 8: v(var.as<SRVCCOperationPossible>()); return true;
+			case 9: v(var.as<CSGMembershipStatus>()); return true;
+			case 10: v(var.as<MobilityInformation>()); return true;
+			case 11: v(var.as<Masked_IMEISV>()); return true;
+			case 12: v(var.as<UE_HistoryInformationFromTheUE>()); return true;
+			case 13: v(var.as<ExpectedUEBehaviour>()); return true;
+			case 14: v(var.as<ProSeAuthorized>()); return true;
+			case 15: v(var.as<UE_ContextReferenceAtSeNB>()); return true;
+			case 16: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 17: v(var.as<V2XServicesAuthorized>()); return true;
+			case 18: v(var.as<UE_ContextReferenceAtWT>()); return true;
+			case 19: v(var.as<NRUESecurityCapabilities>()); return true;
+			case 20: v(var.as<UE_ContextReferenceAtSgNB>()); return true;
+			case 21: v(var.as<AerialUEsubscriptionInformation>()); return true;
+			case 22: v(var.as<Subscription_Based_UE_DifferentiationInfo>()); 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(AerialUEsubscriptionInformation)];
+			char dummy2[sizeof(CSGMembershipStatus)];
+			char dummy3[sizeof(Cause)];
+			char dummy4[sizeof(ECGI)];
+			char dummy5[sizeof(ExpectedUEBehaviour)];
+			char dummy6[sizeof(GUMMEI)];
+			char dummy7[sizeof(Masked_IMEISV)];
+			char dummy8[sizeof(MobilityInformation)];
+			char dummy9[sizeof(NRUESecurityCapabilities)];
+			char dummy10[sizeof(ProSeAuthorized)];
+			char dummy11[sizeof(SRVCCOperationPossible)];
+			char dummy12[sizeof(Subscription_Based_UE_DifferentiationInfo)];
+			char dummy13[sizeof(TraceActivation)];
+			char dummy14[sizeof(UE_ContextInformation)];
+			char dummy15[sizeof(UE_ContextReferenceAtSeNB)];
+			char dummy16[sizeof(UE_ContextReferenceAtSgNB)];
+			char dummy17[sizeof(UE_ContextReferenceAtWT)];
+			char dummy18[sizeof(UE_HistoryInformation)];
+			char dummy19[sizeof(UE_HistoryInformationFromTheUE)];
+			char dummy20[sizeof(UE_X2AP_ID)];
+			char dummy21[sizeof(UE_X2AP_ID_Extension)];
+			char dummy22[sizeof(V2XServicesAuthorized)];
+
+		};
+		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 == 23; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_Cause() { set(mandatory); type=2;}
+		void select_id_TargetCell_ID() { set(mandatory); type=3;}
+		void select_id_GUMMEI_ID() { set(mandatory); type=4;}
+		void select_id_UE_ContextInformation() { set(mandatory); type=5;}
+		void select_id_UE_HistoryInformation() { set(mandatory); type=6;}
+		void select_id_TraceActivation() { set(optional); type=7;}
+		void select_id_SRVCCOperationPossible() { set(optional); type=8;}
+		void select_id_CSGMembershipStatus() { set(optional); type=9;}
+		void select_id_MobilityInformation() { set(optional); type=10;}
+		void select_id_Masked_IMEISV() { set(optional); type=11;}
+		void select_id_UE_HistoryInformationFromTheUE() { set(optional); type=12;}
+		void select_id_ExpectedUEBehaviour() { set(optional); type=13;}
+		void select_id_ProSeAuthorized() { set(optional); type=14;}
+		void select_id_UE_ContextReferenceAtSeNB() { set(optional); type=15;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=16;}
+		void select_id_V2XServicesAuthorized() { set(optional); type=17;}
+		void select_id_UE_ContextReferenceAtWT() { set(optional); type=18;}
+		void select_id_NRUESecurityCapabilities() { set(optional); type=19;}
+		void select_id_UE_ContextReferenceAtSgNB() { set(optional); type=20;}
+		void select_id_AerialUEsubscriptionInformation() { set(optional); type=21;}
+		void select_id_Subscription_Based_UE_DifferentiationInfo() { set(optional); type=22;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(mandatory)) { type = 4; return true; }
+			else if(equal(mandatory)) { type = 5; return true; }
+			else if(equal(mandatory)) { 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 if(equal(optional)) { type = 10; return true; }
+			else if(equal(optional)) { type = 11; return true; }
+			else if(equal(optional)) { type = 12; return true; }
+			else if(equal(optional)) { type = 13; return true; }
+			else if(equal(optional)) { type = 14; return true; }
+			else if(equal(optional)) { type = 15; return true; }
+			else if(equal(optional)) { type = 16; return true; }
+			else if(equal(optional)) { type = 17; return true; }
+			else if(equal(optional)) { type = 18; return true; }
+			else if(equal(optional)) { type = 19; return true; }
+			else if(equal(optional)) { type = 20; return true; }
+			else if(equal(optional)) { type = 21; return true; }
+			else if(equal(optional)) { type = 22; return true; }
+			else { type = 23; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(mandatory);} 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
+			case 13: type = 13; if(v(ref_nested())) { return equal(optional);} return false;
+			case 14: type = 14; if(v(ref_nested())) { return equal(optional);} return false;
+			case 15: type = 15; if(v(ref_nested())) { return equal(optional);} return false;
+			case 16: type = 16; if(v(ref_nested())) { return equal(optional);} return false;
+			case 17: type = 17; if(v(ref_nested())) { return equal(optional);} return false;
+			case 18: type = 18; if(v(ref_nested())) { return equal(optional);} return false;
+			case 19: type = 19; if(v(ref_nested())) { return equal(optional);} return false;
+			case 20: type = 20; if(v(ref_nested())) { return equal(optional);} return false;
+			case 21: type = 21; if(v(ref_nested())) { return equal(optional);} return false;
+			case 22: type = 22; if(v(ref_nested())) { return equal(optional);} return false;
+			case 23: type = 23; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+HandoverRequest ::= SEQUENCE {
+	protocolIEs			ProtocolIE-Container	{{HandoverRequest-IEs}},
+	...
+}
+*/
+
+struct HandoverRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "HandoverRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<HandoverRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<HandoverRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+HandoverRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Old-eNB-UE-X2AP-ID							CRITICALITY ignore	TYPE UE-X2AP-ID		PRESENCE mandatory}|
+	{ ID id-New-eNB-UE-X2AP-ID							CRITICALITY ignore	TYPE UE-X2AP-ID		PRESENCE mandatory}|
+	{ ID id-E-RABs-Admitted-List						CRITICALITY ignore	TYPE E-RABs-Admitted-List	PRESENCE mandatory}|
+	{ ID id-E-RABs-NotAdmitted-List						CRITICALITY ignore	TYPE E-RAB-List		PRESENCE optional}|
+	{ ID id-TargeteNBtoSource-eNBTransparentContainer	CRITICALITY ignore	TYPE TargeteNBtoSource-eNBTransparentContainer	PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics						CRITICALITY ignore	TYPE CriticalityDiagnostics	PRESENCE optional}|
+	{ ID id-UE-ContextKeptIndicator						CRITICALITY ignore	TYPE UE-ContextKeptIndicator	PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension					CRITICALITY ignore	TYPE UE-X2AP-ID-Extension	PRESENCE optional}|
+	{ ID id-Old-eNB-UE-X2AP-ID-Extension				CRITICALITY ignore	TYPE UE-X2AP-ID-Extension	PRESENCE optional}|
+	{ ID id-New-eNB-UE-X2AP-ID-Extension				CRITICALITY reject	TYPE UE-X2AP-ID-Extension	PRESENCE optional}|
+	{ ID id-WT-UE-ContextKeptIndicator					CRITICALITY ignore	TYPE UE-ContextKeptIndicator	PRESENCE optional},
+	...
+}
+*/
+
+struct HandoverRequestAcknowledge_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 12; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
+		void select_id_E_RABs_Admitted_List() { set(id_E_RABs_Admitted_List); type=3;}
+		void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=4;}
+		void select_id_TargeteNBtoSource_eNBTransparentContainer() { set(id_TargeteNBtoSource_eNBTransparentContainer); type=5;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=6;}
+		void select_id_UE_ContextKeptIndicator() { set(id_UE_ContextKeptIndicator); type=7;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=8;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=9;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=10;}
+		void select_id_WT_UE_ContextKeptIndicator() { set(id_WT_UE_ContextKeptIndicator); type=11;}
+		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_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_E_RABs_Admitted_List)) { type = 3; return true; }
+			else if(equal(id_E_RABs_NotAdmitted_List)) { type = 4; return true; }
+			else if(equal(id_TargeteNBtoSource_eNBTransparentContainer)) { type = 5; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 6; return true; }
+			else if(equal(id_UE_ContextKeptIndicator)) { type = 7; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 8; return true; }
+			else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
+			else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
+			else if(equal(id_WT_UE_ContextKeptIndicator)) { type = 11; return true; }
+			else { type = 12; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_Old_eNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_List);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_TargeteNBtoSource_eNBTransparentContainer);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_UE_ContextKeptIndicator);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(id_WT_UE_ContextKeptIndicator);} return false;
+			case 12: type = 12; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 12; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_E_RABs_Admitted_List() { set(ignore); type=3;}
+		void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=4;}
+		void select_id_TargeteNBtoSource_eNBTransparentContainer() { set(ignore); type=5;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=6;}
+		void select_id_UE_ContextKeptIndicator() { set(ignore); type=7;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=8;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=9;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(reject); type=10;}
+		void select_id_WT_UE_ContextKeptIndicator() { set(ignore); type=11;}
+		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 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 if(equal(reject)) { type = 10; return true; }
+			else if(equal(ignore)) { type = 11; return true; }
+			else { type = 12; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(reject);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 12: type = 12; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		E_RABs_Admitted_List& select_id_E_RABs_Admitted_List() { return set<E_RABs_Admitted_List>(3); }
+		E_RABs_Admitted_List const* get_id_E_RABs_Admitted_List() const { return get<E_RABs_Admitted_List>(3); }
+		E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(4); }
+		E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(4); }
+		TargeteNBtoSource_eNBTransparentContainer& select_id_TargeteNBtoSource_eNBTransparentContainer() { return set<TargeteNBtoSource_eNBTransparentContainer>(5); }
+		TargeteNBtoSource_eNBTransparentContainer const* get_id_TargeteNBtoSource_eNBTransparentContainer() const { return get<TargeteNBtoSource_eNBTransparentContainer>(5); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(6); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(6); }
+		UE_ContextKeptIndicator& select_id_UE_ContextKeptIndicator() { return set<UE_ContextKeptIndicator>(7); }
+		UE_ContextKeptIndicator const* get_id_UE_ContextKeptIndicator() const { return get<UE_ContextKeptIndicator>(7); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(8); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(8); }
+		UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
+		UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
+		UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
+		UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
+		UE_ContextKeptIndicator& select_id_WT_UE_ContextKeptIndicator() { return set<UE_ContextKeptIndicator>(11); }
+		UE_ContextKeptIndicator const* get_id_WT_UE_ContextKeptIndicator() const { return get<UE_ContextKeptIndicator>(11); }
+		bool is_unknown() const { return type == 12; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<E_RABs_Admitted_List>(); break;
+			case 4: var.destroy<E_RAB_List>(); break;
+			case 5: var.destroy<TargeteNBtoSource_eNBTransparentContainer>(); break;
+			case 6: var.destroy<CriticalityDiagnostics>(); break;
+			case 7: var.destroy<UE_ContextKeptIndicator>(); break;
+			case 8: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 11: var.destroy<UE_ContextKeptIndicator>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<E_RABs_Admitted_List>(3);
+			v.template operator()<E_RAB_List>(4);
+			v.template operator()<TargeteNBtoSource_eNBTransparentContainer>(5);
+			v.template operator()<CriticalityDiagnostics>(6);
+			v.template operator()<UE_ContextKeptIndicator>(7);
+			v.template operator()<UE_X2AP_ID_Extension>(8);
+			v.template operator()<UE_X2AP_ID_Extension>(9);
+			v.template operator()<UE_X2AP_ID_Extension>(10);
+			v.template operator()<UE_ContextKeptIndicator>(11);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_E_RABs_Admitted_List()); return true;
+			case 4: v(select_id_E_RABs_NotAdmitted_List()); return true;
+			case 5: v(select_id_TargeteNBtoSource_eNBTransparentContainer()); return true;
+			case 6: v(select_id_CriticalityDiagnostics()); return true;
+			case 7: v(select_id_UE_ContextKeptIndicator()); return true;
+			case 8: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
+			case 9: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
+			case 10: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
+			case 11: v(select_id_WT_UE_ContextKeptIndicator()); return true;
+			case 12: if(type != 12) {clear(); asn::base::set();} type = 12; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<E_RABs_Admitted_List>()); return true;
+			case 4: v(var.as<E_RAB_List>()); return true;
+			case 5: v(var.as<TargeteNBtoSource_eNBTransparentContainer>()); return true;
+			case 6: v(var.as<CriticalityDiagnostics>()); return true;
+			case 7: v(var.as<UE_ContextKeptIndicator>()); return true;
+			case 8: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 10: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 11: v(var.as<UE_ContextKeptIndicator>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(E_RAB_List)];
+			char dummy3[sizeof(E_RABs_Admitted_List)];
+			char dummy4[sizeof(TargeteNBtoSource_eNBTransparentContainer)];
+			char dummy5[sizeof(UE_ContextKeptIndicator)];
+			char dummy6[sizeof(UE_X2AP_ID)];
+			char dummy7[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 12; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_E_RABs_Admitted_List() { set(mandatory); type=3;}
+		void select_id_E_RABs_NotAdmitted_List() { set(optional); type=4;}
+		void select_id_TargeteNBtoSource_eNBTransparentContainer() { set(mandatory); type=5;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=6;}
+		void select_id_UE_ContextKeptIndicator() { set(optional); type=7;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=8;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
+		void select_id_WT_UE_ContextKeptIndicator() { set(optional); type=11;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(mandatory)) { 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 if(equal(optional)) { type = 10; return true; }
+			else if(equal(optional)) { type = 11; return true; }
+			else { type = 12; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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(mandatory);} 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
+			case 12: type = 12; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+HandoverRequestAcknowledge ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{HandoverRequestAcknowledge-IEs}},
+	...
+}
+*/
+
+struct HandoverRequestAcknowledge : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "HandoverRequestAcknowledge";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<HandoverRequestAcknowledge_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<HandoverRequestAcknowledge_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+LoadInformation-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-CellInformation				CRITICALITY ignore	TYPE CellInformation-List		PRESENCE mandatory} ,
+	...
+}
+*/
+
+struct LoadInformation_IEs
+{
+	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_CellInformation() { set(id_CellInformation); 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_CellInformation)) { 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_CellInformation);} 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_CellInformation() { 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;}
+		CellInformation_List& select_id_CellInformation() { return set<CellInformation_List>(1); }
+		CellInformation_List const* get_id_CellInformation() const { return get<CellInformation_List>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<CellInformation_List>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<CellInformation_List>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_CellInformation()); 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<CellInformation_List>()); 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(CellInformation_List)];
+
+		};
+		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_CellInformation() { 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};
+
+	};
+
+};
+/*
+LoadInformation ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{LoadInformation-IEs}},
+	...
+}
+*/
+
+struct LoadInformation : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "LoadInformation";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<LoadInformation_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<LoadInformation_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+MeasurementInitiationResult-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct MeasurementInitiationResult_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};
+
+	};
+
+};
+/*
+MeasurementInitiationResult-Item ::= SEQUENCE {
+	cell-ID											ECGI,
+	measurementFailureCause-List					MeasurementFailureCause-List	OPTIONAL,
+	iE-Extensions									ProtocolExtensionContainer { {MeasurementInitiationResult-Item-ExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct MeasurementInitiationResult_Item : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "MeasurementInitiationResult-Item";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	struct cell_ID_t : ECGI
+	{
+		static constexpr const char* name() {return "cell_ID_t";}
+		using parent_t = ECGI;
+
+	};
+	cell_ID_t& ref_cell_ID() {return cell_ID;}
+	cell_ID_t const& ref_cell_ID() const {return cell_ID;}
+	struct measurementFailureCause_List_t : MeasurementFailureCause_List
+	{
+		static constexpr const char* name() {return "measurementFailureCause_List_t";}
+		using parent_t = MeasurementFailureCause_List;
+		static constexpr bool optional = true;
+
+	};
+	measurementFailureCause_List_t& set_measurementFailureCause_List() { measurementFailureCause_List.setpresent(true); return measurementFailureCause_List;}
+	measurementFailureCause_List_t const* get_measurementFailureCause_List() const {return measurementFailureCause_List.is_valid() ? &measurementFailureCause_List : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<MeasurementInitiationResult_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<MeasurementInitiationResult_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(cell_ID);
+		v(measurementFailureCause_List);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(cell_ID);
+		v(measurementFailureCause_List);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		cell_ID.clear();
+		measurementFailureCause_List.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	cell_ID_t	cell_ID;
+	measurementFailureCause_List_t	measurementFailureCause_List;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+MeasurementInitiationResult-ItemIEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeasurementInitiationResult-Item	CRITICALITY ignore	TYPE MeasurementInitiationResult-Item	PRESENCE mandatory}
+}
+*/
+
+struct MeasurementInitiationResult_ItemIEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_MeasurementInitiationResult_Item() { set(id_MeasurementInitiationResult_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_MeasurementInitiationResult_Item)) { type = 1; return true; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeasurementInitiationResult_Item);} return false;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_MeasurementInitiationResult_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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<false>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		MeasurementInitiationResult_Item& select_id_MeasurementInitiationResult_Item() { return set<MeasurementInitiationResult_Item>(1); }
+		MeasurementInitiationResult_Item const* get_id_MeasurementInitiationResult_Item() const { return get<MeasurementInitiationResult_Item>(1); }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<MeasurementInitiationResult_Item>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<MeasurementInitiationResult_Item>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeasurementInitiationResult_Item()); 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<MeasurementInitiationResult_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(MeasurementInitiationResult_Item)];
+
+		};
+		asn::variant<sizeof(union_type)> var;
+		size_t type {0};
+
+	};
+	struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
+	{
+		size_t get_index() const {return type;}
+		void clear() {type = 0;}
+		void select_id_MeasurementInitiationResult_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; }
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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;
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+MeasurementInitiationResult-List ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {MeasurementInitiationResult-ItemIEs} }
+*/
+
+struct MeasurementInitiationResult_List_elm : ProtocolIE_Single_Container<MeasurementInitiationResult_ItemIEs>
+{
+	static constexpr const char* name() {return "MeasurementInitiationResult_List_elm";}
+	using parent_t = ProtocolIE_Single_Container<MeasurementInitiationResult_ItemIEs>;
+
+};
+struct MeasurementInitiationResult_List : asn::sequenceof<MeasurementInitiationResult_List_elm>
+{
+	static constexpr const char* name() {return "MeasurementInitiationResult-List";}
+	using parent_t = asn::sequenceof<MeasurementInitiationResult_List_elm>;
+	using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
+
+};
+/*
+MobilityChangeAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ENB1-Cell-ID			CRITICALITY reject	TYPE ECGI							PRESENCE mandatory}|
+	{ ID id-ENB2-Cell-ID			CRITICALITY reject	TYPE ECGI							PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics	CRITICALITY ignore	TYPE CriticalityDiagnostics			PRESENCE optional},
+	...
+}
+*/
+
+struct MobilityChangeAcknowledge_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Cell_ID() { set(id_ENB1_Cell_ID); type=1;}
+		void select_id_ENB2_Cell_ID() { set(id_ENB2_Cell_ID); type=2;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
+		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_ENB1_Cell_ID)) { type = 1; return true; }
+			else if(equal(id_ENB2_Cell_ID)) { type = 2; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { 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_ENB1_Cell_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Cell_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Cell_ID() { set(reject); type=1;}
+		void select_id_ENB2_Cell_ID() { set(reject); type=2;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
+		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 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(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(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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		ECGI& select_id_ENB1_Cell_ID() { return set<ECGI>(1); }
+		ECGI const* get_id_ENB1_Cell_ID() const { return get<ECGI>(1); }
+		ECGI& select_id_ENB2_Cell_ID() { return set<ECGI>(2); }
+		ECGI const* get_id_ENB2_Cell_ID() const { return get<ECGI>(2); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ECGI>(); break;
+			case 2: var.destroy<ECGI>(); break;
+			case 3: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ECGI>(1);
+			v.template operator()<ECGI>(2);
+			v.template operator()<CriticalityDiagnostics>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ENB1_Cell_ID()); return true;
+			case 2: v(select_id_ENB2_Cell_ID()); return true;
+			case 3: v(select_id_CriticalityDiagnostics()); 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<ECGI>()); return true;
+			case 2: v(var.as<ECGI>()); return true;
+			case 3: v(var.as<CriticalityDiagnostics>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(ECGI)];
+
+		};
+		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 == 4; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Cell_ID() { set(mandatory); type=1;}
+		void select_id_ENB2_Cell_ID() { set(mandatory); type=2;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=3;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+MobilityChangeAcknowledge ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{MobilityChangeAcknowledge-IEs}},
+	...
+}
+*/
+
+struct MobilityChangeAcknowledge : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "MobilityChangeAcknowledge";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<MobilityChangeAcknowledge_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<MobilityChangeAcknowledge_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+MobilityChangeFailure-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ENB1-Cell-ID									CRITICALITY ignore	TYPE ECGI												PRESENCE mandatory}|
+	{ ID id-ENB2-Cell-ID									CRITICALITY ignore	TYPE ECGI												PRESENCE mandatory}|
+	{ ID id-Cause											CRITICALITY ignore	TYPE Cause												PRESENCE mandatory}|
+	{ ID id-ENB2-Mobility-Parameters-Modification-Range		CRITICALITY ignore	TYPE MobilityParametersModificationRange		PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics							CRITICALITY ignore	TYPE CriticalityDiagnostics						PRESENCE optional},
+	...
+}
+*/
+
+struct MobilityChangeFailure_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Cell_ID() { set(id_ENB1_Cell_ID); type=1;}
+		void select_id_ENB2_Cell_ID() { set(id_ENB2_Cell_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_ENB2_Mobility_Parameters_Modification_Range() { set(id_ENB2_Mobility_Parameters_Modification_Range); type=4;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=5;}
+		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_ENB1_Cell_ID)) { type = 1; return true; }
+			else if(equal(id_ENB2_Cell_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_ENB2_Mobility_Parameters_Modification_Range)) { type = 4; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_ENB1_Cell_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Cell_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_ENB2_Mobility_Parameters_Modification_Range);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Cell_ID() { set(ignore); type=1;}
+		void select_id_ENB2_Cell_ID() { set(ignore); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_ENB2_Mobility_Parameters_Modification_Range() { set(ignore); type=4;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=5;}
+		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 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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		ECGI& select_id_ENB1_Cell_ID() { return set<ECGI>(1); }
+		ECGI const* get_id_ENB1_Cell_ID() const { return get<ECGI>(1); }
+		ECGI& select_id_ENB2_Cell_ID() { return set<ECGI>(2); }
+		ECGI const* get_id_ENB2_Cell_ID() const { return get<ECGI>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		MobilityParametersModificationRange& select_id_ENB2_Mobility_Parameters_Modification_Range() { return set<MobilityParametersModificationRange>(4); }
+		MobilityParametersModificationRange const* get_id_ENB2_Mobility_Parameters_Modification_Range() const { return get<MobilityParametersModificationRange>(4); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(5); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ECGI>(); break;
+			case 2: var.destroy<ECGI>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<MobilityParametersModificationRange>(); break;
+			case 5: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ECGI>(1);
+			v.template operator()<ECGI>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<MobilityParametersModificationRange>(4);
+			v.template operator()<CriticalityDiagnostics>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ENB1_Cell_ID()); return true;
+			case 2: v(select_id_ENB2_Cell_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_ENB2_Mobility_Parameters_Modification_Range()); return true;
+			case 5: v(select_id_CriticalityDiagnostics()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<ECGI>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<MobilityParametersModificationRange>()); return true;
+			case 5: v(var.as<CriticalityDiagnostics>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(ECGI)];
+			char dummy4[sizeof(MobilityParametersModificationRange)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Cell_ID() { set(mandatory); type=1;}
+		void select_id_ENB2_Cell_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_ENB2_Mobility_Parameters_Modification_Range() { set(optional); type=4;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=5;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+MobilityChangeFailure ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{MobilityChangeFailure-IEs}},
+	...
+}
+*/
+
+struct MobilityChangeFailure : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "MobilityChangeFailure";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<MobilityChangeFailure_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<MobilityChangeFailure_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+MobilityChangeRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ENB1-Cell-ID						CRITICALITY reject	TYPE ECGI											PRESENCE mandatory}|
+	{ ID id-ENB2-Cell-ID						CRITICALITY reject	TYPE ECGI											PRESENCE mandatory}|
+	{ ID id-ENB1-Mobility-Parameters			CRITICALITY ignore	TYPE MobilityParametersInformation				PRESENCE optional}|
+	{ ID id-ENB2-Proposed-Mobility-Parameters	CRITICALITY reject	TYPE MobilityParametersInformation				PRESENCE mandatory}|
+	{ ID id-Cause								CRITICALITY reject	TYPE Cause											PRESENCE mandatory},
+	...
+}
+*/
+
+struct MobilityChangeRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Cell_ID() { set(id_ENB1_Cell_ID); type=1;}
+		void select_id_ENB2_Cell_ID() { set(id_ENB2_Cell_ID); type=2;}
+		void select_id_ENB1_Mobility_Parameters() { set(id_ENB1_Mobility_Parameters); type=3;}
+		void select_id_ENB2_Proposed_Mobility_Parameters() { set(id_ENB2_Proposed_Mobility_Parameters); type=4;}
+		void select_id_Cause() { set(id_Cause); type=5;}
+		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_ENB1_Cell_ID)) { type = 1; return true; }
+			else if(equal(id_ENB2_Cell_ID)) { type = 2; return true; }
+			else if(equal(id_ENB1_Mobility_Parameters)) { type = 3; return true; }
+			else if(equal(id_ENB2_Proposed_Mobility_Parameters)) { type = 4; return true; }
+			else if(equal(id_Cause)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_ENB1_Cell_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Cell_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_ENB1_Mobility_Parameters);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_ENB2_Proposed_Mobility_Parameters);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Cell_ID() { set(reject); type=1;}
+		void select_id_ENB2_Cell_ID() { set(reject); type=2;}
+		void select_id_ENB1_Mobility_Parameters() { set(ignore); type=3;}
+		void select_id_ENB2_Proposed_Mobility_Parameters() { set(reject); type=4;}
+		void select_id_Cause() { set(reject); type=5;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(reject)) { type = 4; return true; }
+			else if(equal(reject)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(ignore);} 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(reject);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		ECGI& select_id_ENB1_Cell_ID() { return set<ECGI>(1); }
+		ECGI const* get_id_ENB1_Cell_ID() const { return get<ECGI>(1); }
+		ECGI& select_id_ENB2_Cell_ID() { return set<ECGI>(2); }
+		ECGI const* get_id_ENB2_Cell_ID() const { return get<ECGI>(2); }
+		MobilityParametersInformation& select_id_ENB1_Mobility_Parameters() { return set<MobilityParametersInformation>(3); }
+		MobilityParametersInformation const* get_id_ENB1_Mobility_Parameters() const { return get<MobilityParametersInformation>(3); }
+		MobilityParametersInformation& select_id_ENB2_Proposed_Mobility_Parameters() { return set<MobilityParametersInformation>(4); }
+		MobilityParametersInformation const* get_id_ENB2_Proposed_Mobility_Parameters() const { return get<MobilityParametersInformation>(4); }
+		Cause& select_id_Cause() { return set<Cause>(5); }
+		Cause const* get_id_Cause() const { return get<Cause>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<ECGI>(); break;
+			case 2: var.destroy<ECGI>(); break;
+			case 3: var.destroy<MobilityParametersInformation>(); break;
+			case 4: var.destroy<MobilityParametersInformation>(); break;
+			case 5: var.destroy<Cause>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<ECGI>(1);
+			v.template operator()<ECGI>(2);
+			v.template operator()<MobilityParametersInformation>(3);
+			v.template operator()<MobilityParametersInformation>(4);
+			v.template operator()<Cause>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ENB1_Cell_ID()); return true;
+			case 2: v(select_id_ENB2_Cell_ID()); return true;
+			case 3: v(select_id_ENB1_Mobility_Parameters()); return true;
+			case 4: v(select_id_ENB2_Proposed_Mobility_Parameters()); return true;
+			case 5: v(select_id_Cause()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<ECGI>()); return true;
+			case 3: v(var.as<MobilityParametersInformation>()); return true;
+			case 4: v(var.as<MobilityParametersInformation>()); return true;
+			case 5: 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(ECGI)];
+			char dummy3[sizeof(MobilityParametersInformation)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Cell_ID() { set(mandatory); type=1;}
+		void select_id_ENB2_Cell_ID() { set(mandatory); type=2;}
+		void select_id_ENB1_Mobility_Parameters() { set(optional); type=3;}
+		void select_id_ENB2_Proposed_Mobility_Parameters() { set(mandatory); type=4;}
+		void select_id_Cause() { set(mandatory); type=5;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(optional)) { type = 3; return true; }
+			else if(equal(mandatory)) { type = 4; return true; }
+			else if(equal(mandatory)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} 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(mandatory);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+MobilityChangeRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{MobilityChangeRequest-IEs}},
+	...
+}
+*/
+
+struct MobilityChangeRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "MobilityChangeRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<MobilityChangeRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<MobilityChangeRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+PartialSuccessIndicator ::= ENUMERATED {
+	partial-success-allowed,
+...
+}
+*/
+
+struct PartialSuccessIndicator : asn::enumerated<1, 0, true>
+{
+	static constexpr const char* name() {return "PartialSuccessIndicator";}
+	using parent_t = asn::enumerated<1, 0, true>;
+	typedef enum {
+		partial_success_allowed
+	} index_t;
+
+};
+
+/*
+PrivateMessage-IEs X2AP-PRIVATE-IES ::= {
+	...
+}
+*/
+
+struct PrivateMessage_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PRIVATE_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PRIVATE_IES::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_PRIVATE_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PRIVATE_IES::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 Value_t : asn::typefield<true>
+	{
+		~Value_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_PRIVATE_IES::presence_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 1; }
+		void clear() {type = 0;}
+		X2AP_PRIVATE_IES::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};
+
+	};
+
+};
+/*
+PrivateMessage ::= SEQUENCE {
+	privateIEs		PrivateIE-Container	{{PrivateMessage-IEs}},
+	...
+}
+*/
+
+struct PrivateMessage : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "PrivateMessage";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct privateIEs_t : PrivateIE_Container<PrivateMessage_IEs>
+	{
+		static constexpr const char* name() {return "privateIEs_t";}
+		using parent_t = PrivateIE_Container<PrivateMessage_IEs>;
+
+	};
+	privateIEs_t& ref_privateIEs() {return privateIEs;}
+	privateIEs_t const& ref_privateIEs() const {return privateIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(privateIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(privateIEs);
+
+	};
+	void clear()
+	{
+		privateIEs.clear();
+
+	};
+	private:
+	privateIEs_t	privateIEs;
+
+};
+/*
+RLFIndication-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-FailureCellPCI								CRITICALITY ignore	TYPE PCI														PRESENCE mandatory}|
+	{ ID id-Re-establishmentCellECGI					CRITICALITY ignore	TYPE ECGI														PRESENCE mandatory}|
+	{ ID id-FailureCellCRNTI							CRITICALITY ignore	TYPE CRNTI														PRESENCE mandatory}|
+	{ ID id-ShortMAC-I									CRITICALITY ignore	TYPE ShortMAC-I													PRESENCE optional}|
+	{ ID id-UE-RLF-Report-Container						CRITICALITY ignore	TYPE UE-RLF-Report-Container								PRESENCE optional}|
+	{ ID id-RRCConnSetupIndicator						CRITICALITY reject	TYPE RRCConnSetupIndicator									PRESENCE optional}|
+	{ ID id-RRCConnReestabIndicator						CRITICALITY ignore	TYPE RRCConnReestabIndicator								PRESENCE optional}|
+	{ ID id-UE-RLF-Report-Container-for-extended-bands	CRITICALITY ignore	TYPE UE-RLF-Report-Container-for-extended-bands		PRESENCE optional},
+	...
+}
+*/
+
+struct RLFIndication_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 9; }
+		void clear() {type = 0;}
+		void select_id_FailureCellPCI() { set(id_FailureCellPCI); type=1;}
+		void select_id_Re_establishmentCellECGI() { set(id_Re_establishmentCellECGI); type=2;}
+		void select_id_FailureCellCRNTI() { set(id_FailureCellCRNTI); type=3;}
+		void select_id_ShortMAC_I() { set(id_ShortMAC_I); type=4;}
+		void select_id_UE_RLF_Report_Container() { set(id_UE_RLF_Report_Container); type=5;}
+		void select_id_RRCConnSetupIndicator() { set(id_RRCConnSetupIndicator); type=6;}
+		void select_id_RRCConnReestabIndicator() { set(id_RRCConnReestabIndicator); type=7;}
+		void select_id_UE_RLF_Report_Container_for_extended_bands() { set(id_UE_RLF_Report_Container_for_extended_bands); type=8;}
+		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_FailureCellPCI)) { type = 1; return true; }
+			else if(equal(id_Re_establishmentCellECGI)) { type = 2; return true; }
+			else if(equal(id_FailureCellCRNTI)) { type = 3; return true; }
+			else if(equal(id_ShortMAC_I)) { type = 4; return true; }
+			else if(equal(id_UE_RLF_Report_Container)) { type = 5; return true; }
+			else if(equal(id_RRCConnSetupIndicator)) { type = 6; return true; }
+			else if(equal(id_RRCConnReestabIndicator)) { type = 7; return true; }
+			else if(equal(id_UE_RLF_Report_Container_for_extended_bands)) { type = 8; return true; }
+			else { type = 9; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_FailureCellPCI);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_Re_establishmentCellECGI);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_FailureCellCRNTI);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_ShortMAC_I);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_UE_RLF_Report_Container);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_RRCConnSetupIndicator);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_RRCConnReestabIndicator);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_UE_RLF_Report_Container_for_extended_bands);} return false;
+			case 9: type = 9; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 9; }
+		void clear() {type = 0;}
+		void select_id_FailureCellPCI() { set(ignore); type=1;}
+		void select_id_Re_establishmentCellECGI() { set(ignore); type=2;}
+		void select_id_FailureCellCRNTI() { set(ignore); type=3;}
+		void select_id_ShortMAC_I() { set(ignore); type=4;}
+		void select_id_UE_RLF_Report_Container() { set(ignore); type=5;}
+		void select_id_RRCConnSetupIndicator() { set(reject); type=6;}
+		void select_id_RRCConnReestabIndicator() { set(ignore); type=7;}
+		void select_id_UE_RLF_Report_Container_for_extended_bands() { set(ignore); type=8;}
+		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 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(reject)) { type = 6; return true; }
+			else if(equal(ignore)) { type = 7; return true; }
+			else if(equal(ignore)) { type = 8; return true; }
+			else { type = 9; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(reject);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		PCI& select_id_FailureCellPCI() { return set<PCI>(1); }
+		PCI const* get_id_FailureCellPCI() const { return get<PCI>(1); }
+		ECGI& select_id_Re_establishmentCellECGI() { return set<ECGI>(2); }
+		ECGI const* get_id_Re_establishmentCellECGI() const { return get<ECGI>(2); }
+		CRNTI& select_id_FailureCellCRNTI() { return set<CRNTI>(3); }
+		CRNTI const* get_id_FailureCellCRNTI() const { return get<CRNTI>(3); }
+		ShortMAC_I& select_id_ShortMAC_I() { return set<ShortMAC_I>(4); }
+		ShortMAC_I const* get_id_ShortMAC_I() const { return get<ShortMAC_I>(4); }
+		UE_RLF_Report_Container& select_id_UE_RLF_Report_Container() { return set<UE_RLF_Report_Container>(5); }
+		UE_RLF_Report_Container const* get_id_UE_RLF_Report_Container() const { return get<UE_RLF_Report_Container>(5); }
+		RRCConnSetupIndicator& select_id_RRCConnSetupIndicator() { return set<RRCConnSetupIndicator>(6); }
+		RRCConnSetupIndicator const* get_id_RRCConnSetupIndicator() const { return get<RRCConnSetupIndicator>(6); }
+		RRCConnReestabIndicator& select_id_RRCConnReestabIndicator() { return set<RRCConnReestabIndicator>(7); }
+		RRCConnReestabIndicator const* get_id_RRCConnReestabIndicator() const { return get<RRCConnReestabIndicator>(7); }
+		UE_RLF_Report_Container_for_extended_bands& select_id_UE_RLF_Report_Container_for_extended_bands() { return set<UE_RLF_Report_Container_for_extended_bands>(8); }
+		UE_RLF_Report_Container_for_extended_bands const* get_id_UE_RLF_Report_Container_for_extended_bands() const { return get<UE_RLF_Report_Container_for_extended_bands>(8); }
+		bool is_unknown() const { return type == 9; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<PCI>(); break;
+			case 2: var.destroy<ECGI>(); break;
+			case 3: var.destroy<CRNTI>(); break;
+			case 4: var.destroy<ShortMAC_I>(); break;
+			case 5: var.destroy<UE_RLF_Report_Container>(); break;
+			case 6: var.destroy<RRCConnSetupIndicator>(); break;
+			case 7: var.destroy<RRCConnReestabIndicator>(); break;
+			case 8: var.destroy<UE_RLF_Report_Container_for_extended_bands>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<PCI>(1);
+			v.template operator()<ECGI>(2);
+			v.template operator()<CRNTI>(3);
+			v.template operator()<ShortMAC_I>(4);
+			v.template operator()<UE_RLF_Report_Container>(5);
+			v.template operator()<RRCConnSetupIndicator>(6);
+			v.template operator()<RRCConnReestabIndicator>(7);
+			v.template operator()<UE_RLF_Report_Container_for_extended_bands>(8);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_FailureCellPCI()); return true;
+			case 2: v(select_id_Re_establishmentCellECGI()); return true;
+			case 3: v(select_id_FailureCellCRNTI()); return true;
+			case 4: v(select_id_ShortMAC_I()); return true;
+			case 5: v(select_id_UE_RLF_Report_Container()); return true;
+			case 6: v(select_id_RRCConnSetupIndicator()); return true;
+			case 7: v(select_id_RRCConnReestabIndicator()); return true;
+			case 8: v(select_id_UE_RLF_Report_Container_for_extended_bands()); return true;
+			case 9: if(type != 9) {clear(); asn::base::set();} type = 9; 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<PCI>()); return true;
+			case 2: v(var.as<ECGI>()); return true;
+			case 3: v(var.as<CRNTI>()); return true;
+			case 4: v(var.as<ShortMAC_I>()); return true;
+			case 5: v(var.as<UE_RLF_Report_Container>()); return true;
+			case 6: v(var.as<RRCConnSetupIndicator>()); return true;
+			case 7: v(var.as<RRCConnReestabIndicator>()); return true;
+			case 8: v(var.as<UE_RLF_Report_Container_for_extended_bands>()); 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(CRNTI)];
+			char dummy2[sizeof(ECGI)];
+			char dummy3[sizeof(PCI)];
+			char dummy4[sizeof(RRCConnReestabIndicator)];
+			char dummy5[sizeof(RRCConnSetupIndicator)];
+			char dummy6[sizeof(ShortMAC_I)];
+			char dummy7[sizeof(UE_RLF_Report_Container)];
+			char dummy8[sizeof(UE_RLF_Report_Container_for_extended_bands)];
+
+		};
+		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 == 9; }
+		void clear() {type = 0;}
+		void select_id_FailureCellPCI() { set(mandatory); type=1;}
+		void select_id_Re_establishmentCellECGI() { set(mandatory); type=2;}
+		void select_id_FailureCellCRNTI() { set(mandatory); type=3;}
+		void select_id_ShortMAC_I() { set(optional); type=4;}
+		void select_id_UE_RLF_Report_Container() { set(optional); type=5;}
+		void select_id_RRCConnSetupIndicator() { set(optional); type=6;}
+		void select_id_RRCConnReestabIndicator() { set(optional); type=7;}
+		void select_id_UE_RLF_Report_Container_for_extended_bands() { set(optional); type=8;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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 { type = 9; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+RLFIndication ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{RLFIndication-IEs}},
+	...
+}
+*/
+
+struct RLFIndication : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "RLFIndication";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<RLFIndication_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<RLFIndication_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+RNL-Header-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct RNL_Header_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};
+
+	};
+
+};
+/*
+RNL-Header ::= SEQUENCE {
+	source-GlobalENB-ID	GlobalENB-ID,
+	target-GlobalENB-ID	GlobalENB-ID	OPTIONAL,
+	iE-Extensions						ProtocolExtensionContainer { {RNL-Header-Item-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct RNL_Header : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "RNL-Header";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	struct source_GlobalENB_ID_t : GlobalENB_ID
+	{
+		static constexpr const char* name() {return "source_GlobalENB_ID_t";}
+		using parent_t = GlobalENB_ID;
+
+	};
+	source_GlobalENB_ID_t& ref_source_GlobalENB_ID() {return source_GlobalENB_ID;}
+	source_GlobalENB_ID_t const& ref_source_GlobalENB_ID() const {return source_GlobalENB_ID;}
+	struct target_GlobalENB_ID_t : GlobalENB_ID
+	{
+		static constexpr const char* name() {return "target_GlobalENB_ID_t";}
+		using parent_t = GlobalENB_ID;
+		static constexpr bool optional = true;
+
+	};
+	target_GlobalENB_ID_t& set_target_GlobalENB_ID() { target_GlobalENB_ID.setpresent(true); return target_GlobalENB_ID;}
+	target_GlobalENB_ID_t const* get_target_GlobalENB_ID() const {return target_GlobalENB_ID.is_valid() ? &target_GlobalENB_ID : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<RNL_Header_Item_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<RNL_Header_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(source_GlobalENB_ID);
+		v(target_GlobalENB_ID);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(source_GlobalENB_ID);
+		v(target_GlobalENB_ID);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		source_GlobalENB_ID.clear();
+		target_GlobalENB_ID.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	source_GlobalENB_ID_t	source_GlobalENB_ID;
+	target_GlobalENB_ID_t	target_GlobalENB_ID;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+RRCTransfer-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID						CRITICALITY reject	TYPE SgNB-UE-X2AP-ID				PRESENCE mandatory}|
+	{ ID id-SplitSRB								CRITICALITY reject	TYPE SplitSRB					PRESENCE optional}|
+	{ ID id-UENRMeasurement						CRITICALITY reject	TYPE UENRMeasurement				PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension		PRESENCE optional},
+	...
+}
+*/
+
+struct RRCTransfer_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_SplitSRB() { set(id_SplitSRB); type=3;}
+		void select_id_UENRMeasurement() { set(id_UENRMeasurement); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_SplitSRB)) { type = 3; return true; }
+			else if(equal(id_UENRMeasurement)) { type = 4; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_SplitSRB);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_UENRMeasurement);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_SplitSRB() { set(reject); type=3;}
+		void select_id_UENRMeasurement() { set(reject); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
+		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 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(reject)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(reject);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		SplitSRB& select_id_SplitSRB() { return set<SplitSRB>(3); }
+		SplitSRB const* get_id_SplitSRB() const { return get<SplitSRB>(3); }
+		UENRMeasurement& select_id_UENRMeasurement() { return set<UENRMeasurement>(4); }
+		UENRMeasurement const* get_id_UENRMeasurement() const { return get<UENRMeasurement>(4); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<SplitSRB>(); break;
+			case 4: var.destroy<UENRMeasurement>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<SplitSRB>(3);
+			v.template operator()<UENRMeasurement>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_SplitSRB()); return true;
+			case 4: v(select_id_UENRMeasurement()); return true;
+			case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<SplitSRB>()); return true;
+			case 4: v(var.as<UENRMeasurement>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); 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(SgNB_UE_X2AP_ID)];
+			char dummy2[sizeof(SplitSRB)];
+			char dummy3[sizeof(UENRMeasurement)];
+			char dummy4[sizeof(UE_X2AP_ID)];
+			char dummy5[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_SplitSRB() { set(optional); type=3;}
+		void select_id_UENRMeasurement() { set(optional); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		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 if(equal(mandatory)) { 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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+RRCTransfer ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{RRCTransfer-IEs}},
+	...
+}
+*/
+
+struct RRCTransfer : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "RRCTransfer";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<RRCTransfer_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<RRCTransfer_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ReportingPeriodicity ::= ENUMERATED {
+	one-thousand-ms,
+	two-thousand-ms,
+	five-thousand-ms,
+	ten-thousand-ms,
+...
+}
+*/
+
+struct ReportingPeriodicity : asn::enumerated<4, 0, true>
+{
+	static constexpr const char* name() {return "ReportingPeriodicity";}
+	using parent_t = asn::enumerated<4, 0, true>;
+	typedef enum {
+		one_thousand_ms
+		,two_thousand_ms
+		,five_thousand_ms
+		,ten_thousand_ms
+	} index_t;
+
+};
+
+/*
+ResetRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Cause				CRITICALITY ignore	TYPE Cause				PRESENCE mandatory},
+	...
+}
+*/
+
+struct ResetRequest_IEs
+{
+	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_Cause() { set(id_Cause); 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_Cause)) { 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_Cause);} 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_Cause() { 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;}
+		Cause& select_id_Cause() { return set<Cause>(1); }
+		Cause const* get_id_Cause() const { return get<Cause>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Cause>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Cause>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Cause()); 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<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)];
+
+		};
+		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_Cause() { 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};
+
+	};
+
+};
+/*
+ResetRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ResetRequest-IEs}},
+	...
+}
+*/
+
+struct ResetRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ResetRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ResetRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ResetRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ResetResponse-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-CriticalityDiagnostics	CRITICALITY ignore	TYPE CriticalityDiagnostics			PRESENCE optional },
+	...
+}
+*/
+
+struct ResetResponse_IEs
+{
+	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_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); 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_CriticalityDiagnostics)) { 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_CriticalityDiagnostics);} 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_CriticalityDiagnostics() { 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;}
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(1); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<CriticalityDiagnostics>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_CriticalityDiagnostics()); 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<CriticalityDiagnostics>()); 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(CriticalityDiagnostics)];
+
+		};
+		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_CriticalityDiagnostics() { set(optional); 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(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};
+
+	};
+
+};
+/*
+ResetResponse ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ResetResponse-IEs}},
+	...
+}
+*/
+
+struct ResetResponse : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ResetResponse";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ResetResponse_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ResetResponse_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ResourceStatusFailure-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ENB1-Measurement-ID						CRITICALITY reject	TYPE Measurement-ID									PRESENCE mandatory}|
+	{ ID id-ENB2-Measurement-ID						CRITICALITY reject	TYPE Measurement-ID									PRESENCE mandatory}|
+	{ ID id-Cause									CRITICALITY ignore	TYPE Cause											PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics					CRITICALITY ignore	TYPE CriticalityDiagnostics						PRESENCE optional}|
+	{ ID id-CompleteFailureCauseInformation-List	CRITICALITY ignore	TYPE CompleteFailureCauseInformation-List	PRESENCE optional},
+	...
+}
+*/
+
+struct ResourceStatusFailure_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Measurement_ID() { set(id_ENB1_Measurement_ID); type=1;}
+		void select_id_ENB2_Measurement_ID() { set(id_ENB2_Measurement_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		void select_id_CompleteFailureCauseInformation_List() { set(id_CompleteFailureCauseInformation_List); type=5;}
+		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_ENB1_Measurement_ID)) { type = 1; return true; }
+			else if(equal(id_ENB2_Measurement_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
+			else if(equal(id_CompleteFailureCauseInformation_List)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_ENB1_Measurement_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Measurement_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_CompleteFailureCauseInformation_List);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Measurement_ID() { set(reject); type=1;}
+		void select_id_ENB2_Measurement_ID() { set(reject); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		void select_id_CompleteFailureCauseInformation_List() { set(ignore); type=5;}
+		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 if(equal(reject)) { 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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		Measurement_ID& select_id_ENB1_Measurement_ID() { return set<Measurement_ID>(1); }
+		Measurement_ID const* get_id_ENB1_Measurement_ID() const { return get<Measurement_ID>(1); }
+		Measurement_ID& select_id_ENB2_Measurement_ID() { return set<Measurement_ID>(2); }
+		Measurement_ID const* get_id_ENB2_Measurement_ID() const { return get<Measurement_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		CompleteFailureCauseInformation_List& select_id_CompleteFailureCauseInformation_List() { return set<CompleteFailureCauseInformation_List>(5); }
+		CompleteFailureCauseInformation_List const* get_id_CompleteFailureCauseInformation_List() const { return get<CompleteFailureCauseInformation_List>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Measurement_ID>(); break;
+			case 2: var.destroy<Measurement_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			case 5: var.destroy<CompleteFailureCauseInformation_List>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Measurement_ID>(1);
+			v.template operator()<Measurement_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+			v.template operator()<CompleteFailureCauseInformation_List>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ENB1_Measurement_ID()); return true;
+			case 2: v(select_id_ENB2_Measurement_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); return true;
+			case 5: v(select_id_CompleteFailureCauseInformation_List()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<Measurement_ID>()); return true;
+			case 2: v(var.as<Measurement_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); return true;
+			case 5: v(var.as<CompleteFailureCauseInformation_List>()); 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(CompleteFailureCauseInformation_List)];
+			char dummy3[sizeof(CriticalityDiagnostics)];
+			char dummy4[sizeof(Measurement_ID)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Measurement_ID() { set(mandatory); type=1;}
+		void select_id_ENB2_Measurement_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		void select_id_CompleteFailureCauseInformation_List() { set(optional); type=5;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+ResourceStatusFailure ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ResourceStatusFailure-IEs}},
+	...
+}
+*/
+
+struct ResourceStatusFailure : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ResourceStatusFailure";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ResourceStatusFailure_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ResourceStatusFailure_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ResourceStatusRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ENB1-Measurement-ID			CRITICALITY reject	TYPE Measurement-ID					PRESENCE mandatory}|
+	{ ID id-ENB2-Measurement-ID			CRITICALITY ignore	TYPE Measurement-ID					PRESENCE conditional}|-- The IE shall be present if the Registration Request IE is set to “Stop”, “Partial stop” or to “Add”--
+	{ ID id-Registration-Request		CRITICALITY reject	TYPE Registration-Request			PRESENCE mandatory}|
+	{ ID id-ReportCharacteristics		CRITICALITY reject	TYPE ReportCharacteristics			PRESENCE optional}|
+	{ ID id-CellToReport				CRITICALITY ignore	TYPE CellToReport-List				PRESENCE mandatory}|
+	{ ID id-ReportingPeriodicity		CRITICALITY ignore	TYPE ReportingPeriodicity			PRESENCE optional}|
+	{ ID id-PartialSuccessIndicator		CRITICALITY ignore	TYPE PartialSuccessIndicator		PRESENCE optional}|
+	{ ID id-ReportingPeriodicityRSRPMR	CRITICALITY ignore	TYPE ReportingPeriodicityRSRPMR		PRESENCE optional}|
+	{ ID id-ReportingPeriodicityCSIR	CRITICALITY ignore	TYPE ReportingPeriodicityCSIR		PRESENCE optional},
+	...
+}
+*/
+
+struct ResourceStatusRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 10; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Measurement_ID() { set(id_ENB1_Measurement_ID); type=1;}
+		void select_id_ENB2_Measurement_ID() { set(id_ENB2_Measurement_ID); type=2;}
+		void select_id_Registration_Request() { set(id_Registration_Request); type=3;}
+		void select_id_ReportCharacteristics() { set(id_ReportCharacteristics); type=4;}
+		void select_id_CellToReport() { set(id_CellToReport); type=5;}
+		void select_id_ReportingPeriodicity() { set(id_ReportingPeriodicity); type=6;}
+		void select_id_PartialSuccessIndicator() { set(id_PartialSuccessIndicator); type=7;}
+		void select_id_ReportingPeriodicityRSRPMR() { set(id_ReportingPeriodicityRSRPMR); type=8;}
+		void select_id_ReportingPeriodicityCSIR() { set(id_ReportingPeriodicityCSIR); type=9;}
+		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_ENB1_Measurement_ID)) { type = 1; return true; }
+			else if(equal(id_ENB2_Measurement_ID)) { type = 2; return true; }
+			else if(equal(id_Registration_Request)) { type = 3; return true; }
+			else if(equal(id_ReportCharacteristics)) { type = 4; return true; }
+			else if(equal(id_CellToReport)) { type = 5; return true; }
+			else if(equal(id_ReportingPeriodicity)) { type = 6; return true; }
+			else if(equal(id_PartialSuccessIndicator)) { type = 7; return true; }
+			else if(equal(id_ReportingPeriodicityRSRPMR)) { type = 8; return true; }
+			else if(equal(id_ReportingPeriodicityCSIR)) { 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_ENB1_Measurement_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Measurement_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Registration_Request);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_ReportCharacteristics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_CellToReport);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_ReportingPeriodicity);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_PartialSuccessIndicator);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_ReportingPeriodicityRSRPMR);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_ReportingPeriodicityCSIR);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 10; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Measurement_ID() { set(reject); type=1;}
+		void select_id_ENB2_Measurement_ID() { set(ignore); type=2;}
+		void select_id_Registration_Request() { set(reject); type=3;}
+		void select_id_ReportCharacteristics() { set(reject); type=4;}
+		void select_id_CellToReport() { set(ignore); type=5;}
+		void select_id_ReportingPeriodicity() { set(ignore); type=6;}
+		void select_id_PartialSuccessIndicator() { set(ignore); type=7;}
+		void select_id_ReportingPeriodicityRSRPMR() { set(ignore); type=8;}
+		void select_id_ReportingPeriodicityCSIR() { set(ignore); type=9;}
+		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 if(equal(ignore)) { 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 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(reject);} 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(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; 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		Measurement_ID& select_id_ENB1_Measurement_ID() { return set<Measurement_ID>(1); }
+		Measurement_ID const* get_id_ENB1_Measurement_ID() const { return get<Measurement_ID>(1); }
+		Measurement_ID& select_id_ENB2_Measurement_ID() { return set<Measurement_ID>(2); }
+		Measurement_ID const* get_id_ENB2_Measurement_ID() const { return get<Measurement_ID>(2); }
+		Registration_Request& select_id_Registration_Request() { return set<Registration_Request>(3); }
+		Registration_Request const* get_id_Registration_Request() const { return get<Registration_Request>(3); }
+		ReportCharacteristics& select_id_ReportCharacteristics() { return set<ReportCharacteristics>(4); }
+		ReportCharacteristics const* get_id_ReportCharacteristics() const { return get<ReportCharacteristics>(4); }
+		CellToReport_List& select_id_CellToReport() { return set<CellToReport_List>(5); }
+		CellToReport_List const* get_id_CellToReport() const { return get<CellToReport_List>(5); }
+		ReportingPeriodicity& select_id_ReportingPeriodicity() { return set<ReportingPeriodicity>(6); }
+		ReportingPeriodicity const* get_id_ReportingPeriodicity() const { return get<ReportingPeriodicity>(6); }
+		PartialSuccessIndicator& select_id_PartialSuccessIndicator() { return set<PartialSuccessIndicator>(7); }
+		PartialSuccessIndicator const* get_id_PartialSuccessIndicator() const { return get<PartialSuccessIndicator>(7); }
+		ReportingPeriodicityRSRPMR& select_id_ReportingPeriodicityRSRPMR() { return set<ReportingPeriodicityRSRPMR>(8); }
+		ReportingPeriodicityRSRPMR const* get_id_ReportingPeriodicityRSRPMR() const { return get<ReportingPeriodicityRSRPMR>(8); }
+		ReportingPeriodicityCSIR& select_id_ReportingPeriodicityCSIR() { return set<ReportingPeriodicityCSIR>(9); }
+		ReportingPeriodicityCSIR const* get_id_ReportingPeriodicityCSIR() const { return get<ReportingPeriodicityCSIR>(9); }
+		bool is_unknown() const { return type == 10; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Measurement_ID>(); break;
+			case 2: var.destroy<Measurement_ID>(); break;
+			case 3: var.destroy<Registration_Request>(); break;
+			case 4: var.destroy<ReportCharacteristics>(); break;
+			case 5: var.destroy<CellToReport_List>(); break;
+			case 6: var.destroy<ReportingPeriodicity>(); break;
+			case 7: var.destroy<PartialSuccessIndicator>(); break;
+			case 8: var.destroy<ReportingPeriodicityRSRPMR>(); break;
+			case 9: var.destroy<ReportingPeriodicityCSIR>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Measurement_ID>(1);
+			v.template operator()<Measurement_ID>(2);
+			v.template operator()<Registration_Request>(3);
+			v.template operator()<ReportCharacteristics>(4);
+			v.template operator()<CellToReport_List>(5);
+			v.template operator()<ReportingPeriodicity>(6);
+			v.template operator()<PartialSuccessIndicator>(7);
+			v.template operator()<ReportingPeriodicityRSRPMR>(8);
+			v.template operator()<ReportingPeriodicityCSIR>(9);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ENB1_Measurement_ID()); return true;
+			case 2: v(select_id_ENB2_Measurement_ID()); return true;
+			case 3: v(select_id_Registration_Request()); return true;
+			case 4: v(select_id_ReportCharacteristics()); return true;
+			case 5: v(select_id_CellToReport()); return true;
+			case 6: v(select_id_ReportingPeriodicity()); return true;
+			case 7: v(select_id_PartialSuccessIndicator()); return true;
+			case 8: v(select_id_ReportingPeriodicityRSRPMR()); return true;
+			case 9: v(select_id_ReportingPeriodicityCSIR()); 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<Measurement_ID>()); return true;
+			case 2: v(var.as<Measurement_ID>()); return true;
+			case 3: v(var.as<Registration_Request>()); return true;
+			case 4: v(var.as<ReportCharacteristics>()); return true;
+			case 5: v(var.as<CellToReport_List>()); return true;
+			case 6: v(var.as<ReportingPeriodicity>()); return true;
+			case 7: v(var.as<PartialSuccessIndicator>()); return true;
+			case 8: v(var.as<ReportingPeriodicityRSRPMR>()); return true;
+			case 9: v(var.as<ReportingPeriodicityCSIR>()); 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(CellToReport_List)];
+			char dummy2[sizeof(Measurement_ID)];
+			char dummy3[sizeof(PartialSuccessIndicator)];
+			char dummy4[sizeof(Registration_Request)];
+			char dummy5[sizeof(ReportCharacteristics)];
+			char dummy6[sizeof(ReportingPeriodicity)];
+			char dummy7[sizeof(ReportingPeriodicityCSIR)];
+			char dummy8[sizeof(ReportingPeriodicityRSRPMR)];
+
+		};
+		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 == 10; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Measurement_ID() { set(mandatory); type=1;}
+		void select_id_ENB2_Measurement_ID() { set(conditional); type=2;}
+		void select_id_Registration_Request() { set(mandatory); type=3;}
+		void select_id_ReportCharacteristics() { set(optional); type=4;}
+		void select_id_CellToReport() { set(mandatory); type=5;}
+		void select_id_ReportingPeriodicity() { set(optional); type=6;}
+		void select_id_PartialSuccessIndicator() { set(optional); type=7;}
+		void select_id_ReportingPeriodicityRSRPMR() { set(optional); type=8;}
+		void select_id_ReportingPeriodicityCSIR() { set(optional); type=9;}
+		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 if(equal(conditional)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} 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(mandatory);} 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(mandatory);} 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};
+
+	};
+
+};
+/*
+ResourceStatusRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ResourceStatusRequest-IEs}},
+	...
+}
+*/
+
+struct ResourceStatusRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ResourceStatusRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ResourceStatusRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ResourceStatusRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ResourceStatusResponse-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ENB1-Measurement-ID					CRITICALITY reject	TYPE Measurement-ID							PRESENCE mandatory}|
+	{ ID id-ENB2-Measurement-ID					CRITICALITY reject	TYPE Measurement-ID							PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics				CRITICALITY ignore	TYPE CriticalityDiagnostics					PRESENCE optional}|
+	{ ID id-MeasurementInitiationResult-List	CRITICALITY ignore	TYPE MeasurementInitiationResult-List	PRESENCE optional},
+	...
+}
+*/
+
+struct ResourceStatusResponse_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Measurement_ID() { set(id_ENB1_Measurement_ID); type=1;}
+		void select_id_ENB2_Measurement_ID() { set(id_ENB2_Measurement_ID); type=2;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
+		void select_id_MeasurementInitiationResult_List() { set(id_MeasurementInitiationResult_List); type=4;}
+		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_ENB1_Measurement_ID)) { type = 1; return true; }
+			else if(equal(id_ENB2_Measurement_ID)) { type = 2; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
+			else if(equal(id_MeasurementInitiationResult_List)) { 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_ENB1_Measurement_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Measurement_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_MeasurementInitiationResult_List);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Measurement_ID() { set(reject); type=1;}
+		void select_id_ENB2_Measurement_ID() { set(reject); type=2;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
+		void select_id_MeasurementInitiationResult_List() { set(ignore); type=4;}
+		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 if(equal(reject)) { 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(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(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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		Measurement_ID& select_id_ENB1_Measurement_ID() { return set<Measurement_ID>(1); }
+		Measurement_ID const* get_id_ENB1_Measurement_ID() const { return get<Measurement_ID>(1); }
+		Measurement_ID& select_id_ENB2_Measurement_ID() { return set<Measurement_ID>(2); }
+		Measurement_ID const* get_id_ENB2_Measurement_ID() const { return get<Measurement_ID>(2); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
+		MeasurementInitiationResult_List& select_id_MeasurementInitiationResult_List() { return set<MeasurementInitiationResult_List>(4); }
+		MeasurementInitiationResult_List const* get_id_MeasurementInitiationResult_List() const { return get<MeasurementInitiationResult_List>(4); }
+		bool is_unknown() const { return type == 5; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Measurement_ID>(); break;
+			case 2: var.destroy<Measurement_ID>(); break;
+			case 3: var.destroy<CriticalityDiagnostics>(); break;
+			case 4: var.destroy<MeasurementInitiationResult_List>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Measurement_ID>(1);
+			v.template operator()<Measurement_ID>(2);
+			v.template operator()<CriticalityDiagnostics>(3);
+			v.template operator()<MeasurementInitiationResult_List>(4);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ENB1_Measurement_ID()); return true;
+			case 2: v(select_id_ENB2_Measurement_ID()); return true;
+			case 3: v(select_id_CriticalityDiagnostics()); return true;
+			case 4: v(select_id_MeasurementInitiationResult_List()); 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<Measurement_ID>()); return true;
+			case 2: v(var.as<Measurement_ID>()); return true;
+			case 3: v(var.as<CriticalityDiagnostics>()); return true;
+			case 4: v(var.as<MeasurementInitiationResult_List>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(MeasurementInitiationResult_List)];
+			char dummy3[sizeof(Measurement_ID)];
+
+		};
+		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 == 5; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Measurement_ID() { set(mandatory); type=1;}
+		void select_id_ENB2_Measurement_ID() { set(mandatory); type=2;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=3;}
+		void select_id_MeasurementInitiationResult_List() { set(optional); type=4;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+ResourceStatusResponse ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ResourceStatusResponse-IEs}},
+	...
+}
+*/
+
+struct ResourceStatusResponse : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ResourceStatusResponse";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ResourceStatusResponse_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ResourceStatusResponse_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ResourceStatusUpdate-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-ENB1-Measurement-ID		CRITICALITY reject	TYPE Measurement-ID					PRESENCE mandatory}|
+	{ ID id-ENB2-Measurement-ID		CRITICALITY reject	TYPE Measurement-ID					PRESENCE mandatory}|
+	{ ID id-CellMeasurementResult	CRITICALITY ignore	TYPE CellMeasurementResult-List		PRESENCE mandatory},
+	...
+}
+*/
+
+struct ResourceStatusUpdate_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Measurement_ID() { set(id_ENB1_Measurement_ID); type=1;}
+		void select_id_ENB2_Measurement_ID() { set(id_ENB2_Measurement_ID); type=2;}
+		void select_id_CellMeasurementResult() { set(id_CellMeasurementResult); type=3;}
+		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_ENB1_Measurement_ID)) { type = 1; return true; }
+			else if(equal(id_ENB2_Measurement_ID)) { type = 2; return true; }
+			else if(equal(id_CellMeasurementResult)) { 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_ENB1_Measurement_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Measurement_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_CellMeasurementResult);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Measurement_ID() { set(reject); type=1;}
+		void select_id_ENB2_Measurement_ID() { set(reject); type=2;}
+		void select_id_CellMeasurementResult() { set(ignore); type=3;}
+		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 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(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(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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		Measurement_ID& select_id_ENB1_Measurement_ID() { return set<Measurement_ID>(1); }
+		Measurement_ID const* get_id_ENB1_Measurement_ID() const { return get<Measurement_ID>(1); }
+		Measurement_ID& select_id_ENB2_Measurement_ID() { return set<Measurement_ID>(2); }
+		Measurement_ID const* get_id_ENB2_Measurement_ID() const { return get<Measurement_ID>(2); }
+		CellMeasurementResult_List& select_id_CellMeasurementResult() { return set<CellMeasurementResult_List>(3); }
+		CellMeasurementResult_List const* get_id_CellMeasurementResult() const { return get<CellMeasurementResult_List>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Measurement_ID>(); break;
+			case 2: var.destroy<Measurement_ID>(); break;
+			case 3: var.destroy<CellMeasurementResult_List>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Measurement_ID>(1);
+			v.template operator()<Measurement_ID>(2);
+			v.template operator()<CellMeasurementResult_List>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_ENB1_Measurement_ID()); return true;
+			case 2: v(select_id_ENB2_Measurement_ID()); return true;
+			case 3: v(select_id_CellMeasurementResult()); 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<Measurement_ID>()); return true;
+			case 2: v(var.as<Measurement_ID>()); return true;
+			case 3: v(var.as<CellMeasurementResult_List>()); 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(CellMeasurementResult_List)];
+			char dummy2[sizeof(Measurement_ID)];
+
+		};
+		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 == 4; }
+		void clear() {type = 0;}
+		void select_id_ENB1_Measurement_ID() { set(mandatory); type=1;}
+		void select_id_ENB2_Measurement_ID() { set(mandatory); type=2;}
+		void select_id_CellMeasurementResult() { set(mandatory); type=3;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+ResourceStatusUpdate ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ResourceStatusUpdate-IEs}},
+	...
+}
+*/
+
+struct ResourceStatusUpdate : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "ResourceStatusUpdate";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<ResourceStatusUpdate_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<ResourceStatusUpdate_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+ResponseInformationSeNBReconfComp-SuccessItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ResponseInformationSeNBReconfComp_SuccessItemExtIEs
+{
+	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};
+
+	};
+
+};
+/*
+ResponseInformationSeNBReconfComp-SuccessItem ::= SEQUENCE {
+	meNBtoSeNBContainer				MeNBtoSeNBContainer OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {ResponseInformationSeNBReconfComp-SuccessItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct ResponseInformationSeNBReconfComp_SuccessItem : asn::sequence<2, 0, true, 2>
+{
+	static constexpr const char* name() {return "ResponseInformationSeNBReconfComp-SuccessItem";}
+	using parent_t = asn::sequence<2, 0, true, 2>;
+	struct meNBtoSeNBContainer_t : MeNBtoSeNBContainer
+	{
+		static constexpr const char* name() {return "meNBtoSeNBContainer_t";}
+		using parent_t = MeNBtoSeNBContainer;
+		static constexpr bool optional = true;
+
+	};
+	meNBtoSeNBContainer_t& set_meNBtoSeNBContainer() { meNBtoSeNBContainer.setpresent(true); return meNBtoSeNBContainer;}
+	meNBtoSeNBContainer_t const* get_meNBtoSeNBContainer() const {return meNBtoSeNBContainer.is_valid() ? &meNBtoSeNBContainer : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ResponseInformationSeNBReconfComp_SuccessItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ResponseInformationSeNBReconfComp_SuccessItemExtIEs>;
+		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(meNBtoSeNBContainer);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(meNBtoSeNBContainer);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		meNBtoSeNBContainer.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	meNBtoSeNBContainer_t	meNBtoSeNBContainer;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ResponseInformationSeNBReconfComp-RejectByMeNBItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ResponseInformationSeNBReconfComp_RejectByMeNBItemExtIEs
+{
+	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};
+
+	};
+
+};
+/*
+ResponseInformationSeNBReconfComp-RejectByMeNBItem ::= SEQUENCE {
+	cause							Cause,
+	meNBtoSeNBContainer				MeNBtoSeNBContainer																						OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {ResponseInformationSeNBReconfComp-RejectByMeNBItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct ResponseInformationSeNBReconfComp_RejectByMeNBItem : asn::sequence<3, 0, true, 2>
+{
+	static constexpr const char* name() {return "ResponseInformationSeNBReconfComp-RejectByMeNBItem";}
+	using parent_t = asn::sequence<3, 0, true, 2>;
+	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 meNBtoSeNBContainer_t : MeNBtoSeNBContainer
+	{
+		static constexpr const char* name() {return "meNBtoSeNBContainer_t";}
+		using parent_t = MeNBtoSeNBContainer;
+		static constexpr bool optional = true;
+
+	};
+	meNBtoSeNBContainer_t& set_meNBtoSeNBContainer() { meNBtoSeNBContainer.setpresent(true); return meNBtoSeNBContainer;}
+	meNBtoSeNBContainer_t const* get_meNBtoSeNBContainer() const {return meNBtoSeNBContainer.is_valid() ? &meNBtoSeNBContainer : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ResponseInformationSeNBReconfComp_RejectByMeNBItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ResponseInformationSeNBReconfComp_RejectByMeNBItemExtIEs>;
+		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(cause);
+		v(meNBtoSeNBContainer);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(cause);
+		v(meNBtoSeNBContainer);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		cause.clear();
+		meNBtoSeNBContainer.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	cause_t	cause;
+	meNBtoSeNBContainer_t	meNBtoSeNBContainer;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ResponseInformationSeNBReconfComp ::= CHOICE {
+	success				ResponseInformationSeNBReconfComp-SuccessItem,
+	reject-by-MeNB		ResponseInformationSeNBReconfComp-RejectByMeNBItem,
+	...
+}
+*/
+
+struct ResponseInformationSeNBReconfComp : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "ResponseInformationSeNBReconfComp";}
+	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);  }
+	~ResponseInformationSeNBReconfComp() {clear();}
+	struct success_t : ResponseInformationSeNBReconfComp_SuccessItem
+	{
+		static constexpr const char* name() {return "success_t";}
+		using parent_t = ResponseInformationSeNBReconfComp_SuccessItem;
+
+	};
+	struct reject_by_MeNB_t : ResponseInformationSeNBReconfComp_RejectByMeNBItem
+	{
+		static constexpr const char* name() {return "reject_by_MeNB_t";}
+		using parent_t = ResponseInformationSeNBReconfComp_RejectByMeNBItem;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<success_t>(); break;
+		case 2: var.destroy<reject_by_MeNB_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<success_t>());
+		case 2: set_index(2); return v(var.build<reject_by_MeNB_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<success_t>());
+		case 2: return v(var.as<reject_by_MeNB_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<success_t>(1);
+		v.template operator()<reject_by_MeNB_t>(2);
+
+	}
+	success_t& select_success() { if(get_index() != 1) { clear(); set_index(1); return var.build<success_t>();} return var.as<success_t>();}
+	success_t const* get_success() const { if(get_index() == 1) { return &var.as<success_t>();} return nullptr; }
+	reject_by_MeNB_t& select_reject_by_MeNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<reject_by_MeNB_t>();} return var.as<reject_by_MeNB_t>();}
+	reject_by_MeNB_t const* get_reject_by_MeNB() const { if(get_index() == 2) { return &var.as<reject_by_MeNB_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(success_t)];
+		char dummy2[sizeof(reject_by_MeNB_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+ResponseInformationSgNBReconfComp-SuccessItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ResponseInformationSgNBReconfComp_SuccessItemExtIEs
+{
+	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};
+
+	};
+
+};
+/*
+ResponseInformationSgNBReconfComp-SuccessItem ::= SEQUENCE {
+	meNBtoSgNBContainer				MeNBtoSgNBContainer					OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {ResponseInformationSgNBReconfComp-SuccessItemExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct ResponseInformationSgNBReconfComp_SuccessItem : asn::sequence<2, 0, true, 2>
+{
+	static constexpr const char* name() {return "ResponseInformationSgNBReconfComp-SuccessItem";}
+	using parent_t = asn::sequence<2, 0, true, 2>;
+	struct meNBtoSgNBContainer_t : MeNBtoSgNBContainer
+	{
+		static constexpr const char* name() {return "meNBtoSgNBContainer_t";}
+		using parent_t = MeNBtoSgNBContainer;
+		static constexpr bool optional = true;
+
+	};
+	meNBtoSgNBContainer_t& set_meNBtoSgNBContainer() { meNBtoSgNBContainer.setpresent(true); return meNBtoSgNBContainer;}
+	meNBtoSgNBContainer_t const* get_meNBtoSgNBContainer() const {return meNBtoSgNBContainer.is_valid() ? &meNBtoSgNBContainer : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<ResponseInformationSgNBReconfComp_SuccessItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ResponseInformationSgNBReconfComp_SuccessItemExtIEs>;
+		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(meNBtoSgNBContainer);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(meNBtoSgNBContainer);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		meNBtoSgNBContainer.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	meNBtoSgNBContainer_t	meNBtoSgNBContainer;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ResponseInformationSgNBReconfComp-RejectByMeNBItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct ResponseInformationSgNBReconfComp_RejectByMeNBItemExtIEs
+{
+	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};
+
+	};
+
+};
+/*
+ResponseInformationSgNBReconfComp-RejectByMeNBItem ::= SEQUENCE {
+	cause							Cause,
+	iE-Extensions					ProtocolExtensionContainer { {ResponseInformationSgNBReconfComp-RejectByMeNBItemExtIEs} }		OPTIONAL,
+	...
+}
+*/
+
+struct ResponseInformationSgNBReconfComp_RejectByMeNBItem : asn::sequence<2, 0, true, 1>
+{
+	static constexpr const char* name() {return "ResponseInformationSgNBReconfComp-RejectByMeNBItem";}
+	using parent_t = asn::sequence<2, 0, true, 1>;
+	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<ResponseInformationSgNBReconfComp_RejectByMeNBItemExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<ResponseInformationSgNBReconfComp_RejectByMeNBItemExtIEs>;
+		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(cause);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(cause);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		cause.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	cause_t	cause;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+ResponseInformationSgNBReconfComp ::= CHOICE {
+	success-SgNBReconfComp				ResponseInformationSgNBReconfComp-SuccessItem,
+	reject-by-MeNB-SgNBReconfComp		ResponseInformationSgNBReconfComp-RejectByMeNBItem,
+	...
+}
+*/
+
+struct ResponseInformationSgNBReconfComp : asn::choice<2, 0, true>
+{
+	static constexpr const char* name() {return "ResponseInformationSgNBReconfComp";}
+	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);  }
+	~ResponseInformationSgNBReconfComp() {clear();}
+	struct success_SgNBReconfComp_t : ResponseInformationSgNBReconfComp_SuccessItem
+	{
+		static constexpr const char* name() {return "success_SgNBReconfComp_t";}
+		using parent_t = ResponseInformationSgNBReconfComp_SuccessItem;
+
+	};
+	struct reject_by_MeNB_SgNBReconfComp_t : ResponseInformationSgNBReconfComp_RejectByMeNBItem
+	{
+		static constexpr const char* name() {return "reject_by_MeNB_SgNBReconfComp_t";}
+		using parent_t = ResponseInformationSgNBReconfComp_RejectByMeNBItem;
+
+	};
+	void clear()
+	{
+		switch(get_index())
+		{
+		case 1: var.destroy<success_SgNBReconfComp_t>(); break;
+		case 2: var.destroy<reject_by_MeNB_SgNBReconfComp_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<success_SgNBReconfComp_t>());
+		case 2: set_index(2); return v(var.build<reject_by_MeNB_SgNBReconfComp_t>());
+		}
+		return false;
+
+	}
+	template<typename V> bool encode(V& v) const
+	{
+		switch(get_index())
+		{
+		case 1: return v(var.as<success_SgNBReconfComp_t>());
+		case 2: return v(var.as<reject_by_MeNB_SgNBReconfComp_t>());
+		}
+		return false;
+	}
+	template<typename V> static inline void enumerate(V& v)
+	{
+		v.template operator()<success_SgNBReconfComp_t>(1);
+		v.template operator()<reject_by_MeNB_SgNBReconfComp_t>(2);
+
+	}
+	success_SgNBReconfComp_t& select_success_SgNBReconfComp() { if(get_index() != 1) { clear(); set_index(1); return var.build<success_SgNBReconfComp_t>();} return var.as<success_SgNBReconfComp_t>();}
+	success_SgNBReconfComp_t const* get_success_SgNBReconfComp() const { if(get_index() == 1) { return &var.as<success_SgNBReconfComp_t>();} return nullptr; }
+	reject_by_MeNB_SgNBReconfComp_t& select_reject_by_MeNB_SgNBReconfComp() { if(get_index() != 2) { clear(); set_index(2); return var.build<reject_by_MeNB_SgNBReconfComp_t>();} return var.as<reject_by_MeNB_SgNBReconfComp_t>();}
+	reject_by_MeNB_SgNBReconfComp_t const* get_reject_by_MeNB_SgNBReconfComp() const { if(get_index() == 2) { return &var.as<reject_by_MeNB_SgNBReconfComp_t>();} return nullptr; }
+	private:
+	void set_index(index_type i) {index = i; base::set();}
+	union union_type
+	{
+		char dummy1[sizeof(success_SgNBReconfComp_t)];
+		char dummy2[sizeof(reject_by_MeNB_SgNBReconfComp_t)];
+
+	};
+	asn::variant<sizeof(union_type)>	var;
+	index_type	index {0};
+};
+/*
+RetrieveUEContextFailure-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-New-eNB-UE-X2AP-ID				CRITICALITY ignore	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-New-eNB-UE-X2AP-ID-Extension	CRITICALITY ignore	TYPE UE-X2AP-ID-Extension		PRESENCE optional}|
+	{ ID id-Cause							CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics			CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional},
+	...
+}
+*/
+
+struct RetrieveUEContextFailure_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		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_New_eNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { 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_New_eNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		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 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(2); }
+		UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		bool is_unknown() const { return type == 5; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID_Extension>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_New_eNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 5; }
+		void clear() {type = 0;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		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 if(equal(optional)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} 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(mandatory);} 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};
+
+	};
+
+};
+/*
+RetrieveUEContextFailure ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ RetrieveUEContextFailure-IEs}},
+	...
+}
+*/
+
+struct RetrieveUEContextFailure : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "RetrieveUEContextFailure";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<RetrieveUEContextFailure_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<RetrieveUEContextFailure_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+RetrieveUEContextRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-New-eNB-UE-X2AP-ID					CRITICALITY reject	TYPE UE-X2AP-ID				PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension	PRESENCE optional}|
+	{ ID id-resumeID							CRITICALITY reject	TYPE ResumeID				PRESENCE mandatory}|
+	{ ID id-ShortMAC-I							CRITICALITY reject	TYPE ShortMAC-I				PRESENCE mandatory}|
+	{ ID id-NewEUTRANCellIdentifier				CRITICALITY reject	TYPE EUTRANCellIdentifier	PRESENCE mandatory}|
+	{ID id-FailureCellCRNTI						CRITICALITY reject	TYPE CRNTI					PRESENCE optional}|
+	{ID id-FailureCellPCI						CRITICALITY reject	TYPE PCI					PRESENCE optional},
+	...
+}
+*/
+
+struct RetrieveUEContextRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 8; }
+		void clear() {type = 0;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=2;}
+		void select_id_resumeID() { set(id_resumeID); type=3;}
+		void select_id_ShortMAC_I() { set(id_ShortMAC_I); type=4;}
+		void select_id_NewEUTRANCellIdentifier() { set(id_NewEUTRANCellIdentifier); type=5;}
+		void select_id_FailureCellCRNTI() { set(id_FailureCellCRNTI); type=6;}
+		void select_id_FailureCellPCI() { set(id_FailureCellPCI); type=7;}
+		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_New_eNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 2; return true; }
+			else if(equal(id_resumeID)) { type = 3; return true; }
+			else if(equal(id_ShortMAC_I)) { type = 4; return true; }
+			else if(equal(id_NewEUTRANCellIdentifier)) { type = 5; return true; }
+			else if(equal(id_FailureCellCRNTI)) { type = 6; return true; }
+			else if(equal(id_FailureCellPCI)) { type = 7; return true; }
+			else { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_New_eNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_resumeID);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_ShortMAC_I);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_NewEUTRANCellIdentifier);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_FailureCellCRNTI);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_FailureCellPCI);} return false;
+			case 8: type = 8; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 8; }
+		void clear() {type = 0;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=2;}
+		void select_id_resumeID() { set(reject); type=3;}
+		void select_id_ShortMAC_I() { set(reject); type=4;}
+		void select_id_NewEUTRANCellIdentifier() { set(reject); type=5;}
+		void select_id_FailureCellCRNTI() { set(reject); type=6;}
+		void select_id_FailureCellPCI() { set(reject); type=7;}
+		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 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(reject)) { type = 5; return true; }
+			else if(equal(reject)) { type = 6; return true; }
+			else if(equal(reject)) { type = 7; return true; }
+			else { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(reject);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
+			case 8: type = 8; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(2); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(2); }
+		ResumeID& select_id_resumeID() { return set<ResumeID>(3); }
+		ResumeID const* get_id_resumeID() const { return get<ResumeID>(3); }
+		ShortMAC_I& select_id_ShortMAC_I() { return set<ShortMAC_I>(4); }
+		ShortMAC_I const* get_id_ShortMAC_I() const { return get<ShortMAC_I>(4); }
+		EUTRANCellIdentifier& select_id_NewEUTRANCellIdentifier() { return set<EUTRANCellIdentifier>(5); }
+		EUTRANCellIdentifier const* get_id_NewEUTRANCellIdentifier() const { return get<EUTRANCellIdentifier>(5); }
+		CRNTI& select_id_FailureCellCRNTI() { return set<CRNTI>(6); }
+		CRNTI const* get_id_FailureCellCRNTI() const { return get<CRNTI>(6); }
+		PCI& select_id_FailureCellPCI() { return set<PCI>(7); }
+		PCI const* get_id_FailureCellPCI() const { return get<PCI>(7); }
+		bool is_unknown() const { return type == 8; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 3: var.destroy<ResumeID>(); break;
+			case 4: var.destroy<ShortMAC_I>(); break;
+			case 5: var.destroy<EUTRANCellIdentifier>(); break;
+			case 6: var.destroy<CRNTI>(); break;
+			case 7: var.destroy<PCI>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID_Extension>(2);
+			v.template operator()<ResumeID>(3);
+			v.template operator()<ShortMAC_I>(4);
+			v.template operator()<EUTRANCellIdentifier>(5);
+			v.template operator()<CRNTI>(6);
+			v.template operator()<PCI>(7);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_New_eNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
+			case 3: v(select_id_resumeID()); return true;
+			case 4: v(select_id_ShortMAC_I()); return true;
+			case 5: v(select_id_NewEUTRANCellIdentifier()); return true;
+			case 6: v(select_id_FailureCellCRNTI()); return true;
+			case 7: v(select_id_FailureCellPCI()); return true;
+			case 8: if(type != 8) {clear(); asn::base::set();} type = 8; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 3: v(var.as<ResumeID>()); return true;
+			case 4: v(var.as<ShortMAC_I>()); return true;
+			case 5: v(var.as<EUTRANCellIdentifier>()); return true;
+			case 6: v(var.as<CRNTI>()); return true;
+			case 7: v(var.as<PCI>()); 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(CRNTI)];
+			char dummy2[sizeof(EUTRANCellIdentifier)];
+			char dummy3[sizeof(PCI)];
+			char dummy4[sizeof(ResumeID)];
+			char dummy5[sizeof(ShortMAC_I)];
+			char dummy6[sizeof(UE_X2AP_ID)];
+			char dummy7[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 8; }
+		void clear() {type = 0;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=2;}
+		void select_id_resumeID() { set(mandatory); type=3;}
+		void select_id_ShortMAC_I() { set(mandatory); type=4;}
+		void select_id_NewEUTRANCellIdentifier() { set(mandatory); type=5;}
+		void select_id_FailureCellCRNTI() { set(optional); type=6;}
+		void select_id_FailureCellPCI() { set(optional); type=7;}
+		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 if(equal(optional)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(mandatory)) { type = 4; return true; }
+			else if(equal(mandatory)) { type = 5; return true; }
+			else if(equal(optional)) { type = 6; return true; }
+			else if(equal(optional)) { type = 7; return true; }
+			else { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+RetrieveUEContextRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ RetrieveUEContextRequest-IEs}},
+	...
+}
+*/
+
+struct RetrieveUEContextRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "RetrieveUEContextRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<RetrieveUEContextRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<RetrieveUEContextRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+UE-ContextInformationRetrieve-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+{ ID id-UESidelinkAggregateMaximumBitRate	CRITICALITY ignore	EXTENSION UESidelinkAggregateMaximumBitRate		PRESENCE optional},
+	...
+}
+*/
+
+struct UE_ContextInformationRetrieve_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_UESidelinkAggregateMaximumBitRate() { set(id_UESidelinkAggregateMaximumBitRate); 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_UESidelinkAggregateMaximumBitRate)) { 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_UESidelinkAggregateMaximumBitRate);} 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_UESidelinkAggregateMaximumBitRate() { 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;}
+		UESidelinkAggregateMaximumBitRate& select_id_UESidelinkAggregateMaximumBitRate() { return set<UESidelinkAggregateMaximumBitRate>(1); }
+		UESidelinkAggregateMaximumBitRate const* get_id_UESidelinkAggregateMaximumBitRate() const { return get<UESidelinkAggregateMaximumBitRate>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UESidelinkAggregateMaximumBitRate>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UESidelinkAggregateMaximumBitRate>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_UESidelinkAggregateMaximumBitRate()); 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<UESidelinkAggregateMaximumBitRate>()); 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(UESidelinkAggregateMaximumBitRate)];
+
+		};
+		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_UESidelinkAggregateMaximumBitRate() { 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};
+
+	};
+
+};
+/*
+UE-ContextInformationRetrieve ::= SEQUENCE {
+	mME-UE-S1AP-ID						UE-S1AP-ID,
+	uESecurityCapabilities				UESecurityCapabilities,
+	aS-SecurityInformation				AS-SecurityInformation,
+	uEaggregateMaximumBitRate			UEAggregateMaximumBitRate,
+	subscriberProfileIDforRFP			SubscriberProfileIDforRFP		OPTIONAL,
+	e-RABs-ToBeSetup-ListRetrieve		E-RABs-ToBeSetup-ListRetrieve,
+	rRC-Context							RRC-Context,
+	handoverRestrictionList				HandoverRestrictionList			OPTIONAL,
+	locationReportingInformation		LocationReportingInformation	OPTIONAL,
+	managBasedMDTallowed				ManagementBasedMDTallowed		OPTIONAL,
+	managBasedMDTPLMNList				MDTPLMNList						OPTIONAL,
+	iE-Extensions						ProtocolExtensionContainer { {UE-ContextInformationRetrieve-ExtIEs} } OPTIONAL,
+	...
+}
+*/
+
+struct UE_ContextInformationRetrieve : asn::sequence<12, 0, true, 6>
+{
+	static constexpr const char* name() {return "UE-ContextInformationRetrieve";}
+	using parent_t = asn::sequence<12, 0, true, 6>;
+	struct mME_UE_S1AP_ID_t : UE_S1AP_ID
+	{
+		static constexpr const char* name() {return "mME_UE_S1AP_ID_t";}
+		using parent_t = UE_S1AP_ID;
+
+	};
+	mME_UE_S1AP_ID_t& ref_mME_UE_S1AP_ID() {return mME_UE_S1AP_ID;}
+	mME_UE_S1AP_ID_t const& ref_mME_UE_S1AP_ID() const {return mME_UE_S1AP_ID;}
+	struct uESecurityCapabilities_t : UESecurityCapabilities
+	{
+		static constexpr const char* name() {return "uESecurityCapabilities_t";}
+		using parent_t = UESecurityCapabilities;
+
+	};
+	uESecurityCapabilities_t& ref_uESecurityCapabilities() {return uESecurityCapabilities;}
+	uESecurityCapabilities_t const& ref_uESecurityCapabilities() const {return uESecurityCapabilities;}
+	struct aS_SecurityInformation_t : AS_SecurityInformation
+	{
+		static constexpr const char* name() {return "aS_SecurityInformation_t";}
+		using parent_t = AS_SecurityInformation;
+
+	};
+	aS_SecurityInformation_t& ref_aS_SecurityInformation() {return aS_SecurityInformation;}
+	aS_SecurityInformation_t const& ref_aS_SecurityInformation() const {return aS_SecurityInformation;}
+	struct uEaggregateMaximumBitRate_t : UEAggregateMaximumBitRate
+	{
+		static constexpr const char* name() {return "uEaggregateMaximumBitRate_t";}
+		using parent_t = UEAggregateMaximumBitRate;
+
+	};
+	uEaggregateMaximumBitRate_t& ref_uEaggregateMaximumBitRate() {return uEaggregateMaximumBitRate;}
+	uEaggregateMaximumBitRate_t const& ref_uEaggregateMaximumBitRate() const {return uEaggregateMaximumBitRate;}
+	struct subscriberProfileIDforRFP_t : SubscriberProfileIDforRFP
+	{
+		static constexpr const char* name() {return "subscriberProfileIDforRFP_t";}
+		using parent_t = SubscriberProfileIDforRFP;
+		static constexpr bool optional = true;
+
+	};
+	subscriberProfileIDforRFP_t& set_subscriberProfileIDforRFP() { subscriberProfileIDforRFP.setpresent(true); return subscriberProfileIDforRFP;}
+	subscriberProfileIDforRFP_t const* get_subscriberProfileIDforRFP() const {return subscriberProfileIDforRFP.is_valid() ? &subscriberProfileIDforRFP : nullptr;}
+	struct e_RABs_ToBeSetup_ListRetrieve_t : E_RABs_ToBeSetup_ListRetrieve
+	{
+		static constexpr const char* name() {return "e_RABs_ToBeSetup_ListRetrieve_t";}
+		using parent_t = E_RABs_ToBeSetup_ListRetrieve;
+
+	};
+	e_RABs_ToBeSetup_ListRetrieve_t& ref_e_RABs_ToBeSetup_ListRetrieve() {return e_RABs_ToBeSetup_ListRetrieve;}
+	e_RABs_ToBeSetup_ListRetrieve_t const& ref_e_RABs_ToBeSetup_ListRetrieve() const {return e_RABs_ToBeSetup_ListRetrieve;}
+	struct rRC_Context_t : RRC_Context
+	{
+		static constexpr const char* name() {return "rRC_Context_t";}
+		using parent_t = RRC_Context;
+
+	};
+	rRC_Context_t& ref_rRC_Context() {return rRC_Context;}
+	rRC_Context_t const& ref_rRC_Context() const {return rRC_Context;}
+	struct handoverRestrictionList_t : HandoverRestrictionList
+	{
+		static constexpr const char* name() {return "handoverRestrictionList_t";}
+		using parent_t = HandoverRestrictionList;
+		static constexpr bool optional = true;
+
+	};
+	handoverRestrictionList_t& set_handoverRestrictionList() { handoverRestrictionList.setpresent(true); return handoverRestrictionList;}
+	handoverRestrictionList_t const* get_handoverRestrictionList() const {return handoverRestrictionList.is_valid() ? &handoverRestrictionList : nullptr;}
+	struct locationReportingInformation_t : LocationReportingInformation
+	{
+		static constexpr const char* name() {return "locationReportingInformation_t";}
+		using parent_t = LocationReportingInformation;
+		static constexpr bool optional = true;
+
+	};
+	locationReportingInformation_t& set_locationReportingInformation() { locationReportingInformation.setpresent(true); return locationReportingInformation;}
+	locationReportingInformation_t const* get_locationReportingInformation() const {return locationReportingInformation.is_valid() ? &locationReportingInformation : nullptr;}
+	struct managBasedMDTallowed_t : ManagementBasedMDTallowed
+	{
+		static constexpr const char* name() {return "managBasedMDTallowed_t";}
+		using parent_t = ManagementBasedMDTallowed;
+		static constexpr bool optional = true;
+
+	};
+	managBasedMDTallowed_t& set_managBasedMDTallowed() { managBasedMDTallowed.setpresent(true); return managBasedMDTallowed;}
+	managBasedMDTallowed_t const* get_managBasedMDTallowed() const {return managBasedMDTallowed.is_valid() ? &managBasedMDTallowed : nullptr;}
+	struct managBasedMDTPLMNList_t : MDTPLMNList
+	{
+		static constexpr const char* name() {return "managBasedMDTPLMNList_t";}
+		using parent_t = MDTPLMNList;
+		static constexpr bool optional = true;
+
+	};
+	managBasedMDTPLMNList_t& set_managBasedMDTPLMNList() { managBasedMDTPLMNList.setpresent(true); return managBasedMDTPLMNList;}
+	managBasedMDTPLMNList_t const* get_managBasedMDTPLMNList() const {return managBasedMDTPLMNList.is_valid() ? &managBasedMDTPLMNList : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextInformationRetrieve_ExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UE_ContextInformationRetrieve_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(mME_UE_S1AP_ID);
+		v(uESecurityCapabilities);
+		v(aS_SecurityInformation);
+		v(uEaggregateMaximumBitRate);
+		v(subscriberProfileIDforRFP);
+		v(e_RABs_ToBeSetup_ListRetrieve);
+		v(rRC_Context);
+		v(handoverRestrictionList);
+		v(locationReportingInformation);
+		v(managBasedMDTallowed);
+		v(managBasedMDTPLMNList);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(mME_UE_S1AP_ID);
+		v(uESecurityCapabilities);
+		v(aS_SecurityInformation);
+		v(uEaggregateMaximumBitRate);
+		v(subscriberProfileIDforRFP);
+		v(e_RABs_ToBeSetup_ListRetrieve);
+		v(rRC_Context);
+		v(handoverRestrictionList);
+		v(locationReportingInformation);
+		v(managBasedMDTallowed);
+		v(managBasedMDTPLMNList);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		mME_UE_S1AP_ID.clear();
+		uESecurityCapabilities.clear();
+		aS_SecurityInformation.clear();
+		uEaggregateMaximumBitRate.clear();
+		subscriberProfileIDforRFP.clear();
+		e_RABs_ToBeSetup_ListRetrieve.clear();
+		rRC_Context.clear();
+		handoverRestrictionList.clear();
+		locationReportingInformation.clear();
+		managBasedMDTallowed.clear();
+		managBasedMDTPLMNList.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	mME_UE_S1AP_ID_t	mME_UE_S1AP_ID;
+	uESecurityCapabilities_t	uESecurityCapabilities;
+	aS_SecurityInformation_t	aS_SecurityInformation;
+	uEaggregateMaximumBitRate_t	uEaggregateMaximumBitRate;
+	subscriberProfileIDforRFP_t	subscriberProfileIDforRFP;
+	e_RABs_ToBeSetup_ListRetrieve_t	e_RABs_ToBeSetup_ListRetrieve;
+	rRC_Context_t	rRC_Context;
+	handoverRestrictionList_t	handoverRestrictionList;
+	locationReportingInformation_t	locationReportingInformation;
+	managBasedMDTallowed_t	managBasedMDTallowed;
+	managBasedMDTPLMNList_t	managBasedMDTPLMNList;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+RetrieveUEContextResponse-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-New-eNB-UE-X2AP-ID				CRITICALITY ignore	TYPE UE-X2AP-ID							PRESENCE mandatory}|
+	{ ID id-New-eNB-UE-X2AP-ID-Extension	CRITICALITY ignore	TYPE UE-X2AP-ID-Extension				PRESENCE optional}|
+	{ ID id-Old-eNB-UE-X2AP-ID				CRITICALITY ignore	TYPE UE-X2AP-ID							PRESENCE mandatory}|
+	{ ID id-Old-eNB-UE-X2AP-ID-Extension	CRITICALITY ignore	TYPE UE-X2AP-ID-Extension				PRESENCE optional}|
+	{ ID id-GUMMEI-ID						CRITICALITY reject	TYPE GUMMEI								PRESENCE mandatory}|
+	{ ID id-UE-ContextInformationRetrieve	CRITICALITY reject	TYPE UE-ContextInformationRetrieve	PRESENCE mandatory}|
+	{ ID id-TraceActivation					CRITICALITY ignore	TYPE TraceActivation					PRESENCE optional}|
+	{ ID id-SRVCCOperationPossible			CRITICALITY ignore	TYPE SRVCCOperationPossible				PRESENCE optional}|
+	{ ID id-Masked-IMEISV					CRITICALITY ignore	TYPE Masked-IMEISV						PRESENCE optional}|
+	{ ID id-ExpectedUEBehaviour				CRITICALITY ignore	TYPE ExpectedUEBehaviour				PRESENCE optional}|
+	{ ID id-ProSeAuthorized					CRITICALITY ignore	TYPE ProSeAuthorized					PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics			CRITICALITY ignore	TYPE CriticalityDiagnostics				PRESENCE optional}|
+	{ ID id-V2XServicesAuthorized			CRITICALITY ignore	TYPE V2XServicesAuthorized				PRESENCE optional}|
+	{ ID id-AerialUEsubscriptionInformation	CRITICALITY ignore	TYPE AerialUEsubscriptionInformation	PRESENCE optional}|
+	{ ID id-Subscription-Based-UE-DifferentiationInfo			CRITICALITY ignore	TYPE Subscription-Based-UE-DifferentiationInfo				PRESENCE optional},
+	...
+}
+*/
+
+struct RetrieveUEContextResponse_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 16; }
+		void clear() {type = 0;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=2;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=3;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=4;}
+		void select_id_GUMMEI_ID() { set(id_GUMMEI_ID); type=5;}
+		void select_id_UE_ContextInformationRetrieve() { set(id_UE_ContextInformationRetrieve); type=6;}
+		void select_id_TraceActivation() { set(id_TraceActivation); type=7;}
+		void select_id_SRVCCOperationPossible() { set(id_SRVCCOperationPossible); type=8;}
+		void select_id_Masked_IMEISV() { set(id_Masked_IMEISV); type=9;}
+		void select_id_ExpectedUEBehaviour() { set(id_ExpectedUEBehaviour); type=10;}
+		void select_id_ProSeAuthorized() { set(id_ProSeAuthorized); type=11;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=12;}
+		void select_id_V2XServicesAuthorized() { set(id_V2XServicesAuthorized); type=13;}
+		void select_id_AerialUEsubscriptionInformation() { set(id_AerialUEsubscriptionInformation); type=14;}
+		void select_id_Subscription_Based_UE_DifferentiationInfo() { set(id_Subscription_Based_UE_DifferentiationInfo); type=15;}
+		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_New_eNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 2; return true; }
+			else if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 3; return true; }
+			else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
+			else if(equal(id_GUMMEI_ID)) { type = 5; return true; }
+			else if(equal(id_UE_ContextInformationRetrieve)) { type = 6; return true; }
+			else if(equal(id_TraceActivation)) { type = 7; return true; }
+			else if(equal(id_SRVCCOperationPossible)) { type = 8; return true; }
+			else if(equal(id_Masked_IMEISV)) { type = 9; return true; }
+			else if(equal(id_ExpectedUEBehaviour)) { type = 10; return true; }
+			else if(equal(id_ProSeAuthorized)) { type = 11; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 12; return true; }
+			else if(equal(id_V2XServicesAuthorized)) { type = 13; return true; }
+			else if(equal(id_AerialUEsubscriptionInformation)) { type = 14; return true; }
+			else if(equal(id_Subscription_Based_UE_DifferentiationInfo)) { type = 15; return true; }
+			else { type = 16; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_New_eNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_GUMMEI_ID);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_UE_ContextInformationRetrieve);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_TraceActivation);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_SRVCCOperationPossible);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_Masked_IMEISV);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(id_ExpectedUEBehaviour);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(id_ProSeAuthorized);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 13: type = 13; if(v(ref_nested())) { return equal(id_V2XServicesAuthorized);} return false;
+			case 14: type = 14; if(v(ref_nested())) { return equal(id_AerialUEsubscriptionInformation);} return false;
+			case 15: type = 15; if(v(ref_nested())) { return equal(id_Subscription_Based_UE_DifferentiationInfo);} return false;
+			case 16: type = 16; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 16; }
+		void clear() {type = 0;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=2;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=3;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=4;}
+		void select_id_GUMMEI_ID() { set(reject); type=5;}
+		void select_id_UE_ContextInformationRetrieve() { set(reject); type=6;}
+		void select_id_TraceActivation() { set(ignore); type=7;}
+		void select_id_SRVCCOperationPossible() { set(ignore); type=8;}
+		void select_id_Masked_IMEISV() { set(ignore); type=9;}
+		void select_id_ExpectedUEBehaviour() { set(ignore); type=10;}
+		void select_id_ProSeAuthorized() { set(ignore); type=11;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=12;}
+		void select_id_V2XServicesAuthorized() { set(ignore); type=13;}
+		void select_id_AerialUEsubscriptionInformation() { set(ignore); type=14;}
+		void select_id_Subscription_Based_UE_DifferentiationInfo() { set(ignore); type=15;}
+		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 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(reject)) { type = 5; return true; }
+			else if(equal(reject)) { 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 if(equal(ignore)) { type = 10; return true; }
+			else if(equal(ignore)) { type = 11; return true; }
+			else if(equal(ignore)) { type = 12; return true; }
+			else if(equal(ignore)) { type = 13; return true; }
+			else if(equal(ignore)) { type = 14; return true; }
+			else if(equal(ignore)) { type = 15; return true; }
+			else { type = 16; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(reject);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(reject);} 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; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 13: type = 13; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 14: type = 14; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 15: type = 15; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 16: type = 16; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(2); }
+		UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(2); }
+		UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(3); }
+		UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(3); }
+		UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
+		GUMMEI& select_id_GUMMEI_ID() { return set<GUMMEI>(5); }
+		GUMMEI const* get_id_GUMMEI_ID() const { return get<GUMMEI>(5); }
+		UE_ContextInformationRetrieve& select_id_UE_ContextInformationRetrieve() { return set<UE_ContextInformationRetrieve>(6); }
+		UE_ContextInformationRetrieve const* get_id_UE_ContextInformationRetrieve() const { return get<UE_ContextInformationRetrieve>(6); }
+		TraceActivation& select_id_TraceActivation() { return set<TraceActivation>(7); }
+		TraceActivation const* get_id_TraceActivation() const { return get<TraceActivation>(7); }
+		SRVCCOperationPossible& select_id_SRVCCOperationPossible() { return set<SRVCCOperationPossible>(8); }
+		SRVCCOperationPossible const* get_id_SRVCCOperationPossible() const { return get<SRVCCOperationPossible>(8); }
+		Masked_IMEISV& select_id_Masked_IMEISV() { return set<Masked_IMEISV>(9); }
+		Masked_IMEISV const* get_id_Masked_IMEISV() const { return get<Masked_IMEISV>(9); }
+		ExpectedUEBehaviour& select_id_ExpectedUEBehaviour() { return set<ExpectedUEBehaviour>(10); }
+		ExpectedUEBehaviour const* get_id_ExpectedUEBehaviour() const { return get<ExpectedUEBehaviour>(10); }
+		ProSeAuthorized& select_id_ProSeAuthorized() { return set<ProSeAuthorized>(11); }
+		ProSeAuthorized const* get_id_ProSeAuthorized() const { return get<ProSeAuthorized>(11); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(12); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(12); }
+		V2XServicesAuthorized& select_id_V2XServicesAuthorized() { return set<V2XServicesAuthorized>(13); }
+		V2XServicesAuthorized const* get_id_V2XServicesAuthorized() const { return get<V2XServicesAuthorized>(13); }
+		AerialUEsubscriptionInformation& select_id_AerialUEsubscriptionInformation() { return set<AerialUEsubscriptionInformation>(14); }
+		AerialUEsubscriptionInformation const* get_id_AerialUEsubscriptionInformation() const { return get<AerialUEsubscriptionInformation>(14); }
+		Subscription_Based_UE_DifferentiationInfo& select_id_Subscription_Based_UE_DifferentiationInfo() { return set<Subscription_Based_UE_DifferentiationInfo>(15); }
+		Subscription_Based_UE_DifferentiationInfo const* get_id_Subscription_Based_UE_DifferentiationInfo() const { return get<Subscription_Based_UE_DifferentiationInfo>(15); }
+		bool is_unknown() const { return type == 16; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 3: var.destroy<UE_X2AP_ID>(); break;
+			case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 5: var.destroy<GUMMEI>(); break;
+			case 6: var.destroy<UE_ContextInformationRetrieve>(); break;
+			case 7: var.destroy<TraceActivation>(); break;
+			case 8: var.destroy<SRVCCOperationPossible>(); break;
+			case 9: var.destroy<Masked_IMEISV>(); break;
+			case 10: var.destroy<ExpectedUEBehaviour>(); break;
+			case 11: var.destroy<ProSeAuthorized>(); break;
+			case 12: var.destroy<CriticalityDiagnostics>(); break;
+			case 13: var.destroy<V2XServicesAuthorized>(); break;
+			case 14: var.destroy<AerialUEsubscriptionInformation>(); break;
+			case 15: var.destroy<Subscription_Based_UE_DifferentiationInfo>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID_Extension>(2);
+			v.template operator()<UE_X2AP_ID>(3);
+			v.template operator()<UE_X2AP_ID_Extension>(4);
+			v.template operator()<GUMMEI>(5);
+			v.template operator()<UE_ContextInformationRetrieve>(6);
+			v.template operator()<TraceActivation>(7);
+			v.template operator()<SRVCCOperationPossible>(8);
+			v.template operator()<Masked_IMEISV>(9);
+			v.template operator()<ExpectedUEBehaviour>(10);
+			v.template operator()<ProSeAuthorized>(11);
+			v.template operator()<CriticalityDiagnostics>(12);
+			v.template operator()<V2XServicesAuthorized>(13);
+			v.template operator()<AerialUEsubscriptionInformation>(14);
+			v.template operator()<Subscription_Based_UE_DifferentiationInfo>(15);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_New_eNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
+			case 3: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
+			case 4: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
+			case 5: v(select_id_GUMMEI_ID()); return true;
+			case 6: v(select_id_UE_ContextInformationRetrieve()); return true;
+			case 7: v(select_id_TraceActivation()); return true;
+			case 8: v(select_id_SRVCCOperationPossible()); return true;
+			case 9: v(select_id_Masked_IMEISV()); return true;
+			case 10: v(select_id_ExpectedUEBehaviour()); return true;
+			case 11: v(select_id_ProSeAuthorized()); return true;
+			case 12: v(select_id_CriticalityDiagnostics()); return true;
+			case 13: v(select_id_V2XServicesAuthorized()); return true;
+			case 14: v(select_id_AerialUEsubscriptionInformation()); return true;
+			case 15: v(select_id_Subscription_Based_UE_DifferentiationInfo()); return true;
+			case 16: if(type != 16) {clear(); asn::base::set();} type = 16; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 3: v(var.as<UE_X2AP_ID>()); return true;
+			case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 5: v(var.as<GUMMEI>()); return true;
+			case 6: v(var.as<UE_ContextInformationRetrieve>()); return true;
+			case 7: v(var.as<TraceActivation>()); return true;
+			case 8: v(var.as<SRVCCOperationPossible>()); return true;
+			case 9: v(var.as<Masked_IMEISV>()); return true;
+			case 10: v(var.as<ExpectedUEBehaviour>()); return true;
+			case 11: v(var.as<ProSeAuthorized>()); return true;
+			case 12: v(var.as<CriticalityDiagnostics>()); return true;
+			case 13: v(var.as<V2XServicesAuthorized>()); return true;
+			case 14: v(var.as<AerialUEsubscriptionInformation>()); return true;
+			case 15: v(var.as<Subscription_Based_UE_DifferentiationInfo>()); 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(AerialUEsubscriptionInformation)];
+			char dummy2[sizeof(CriticalityDiagnostics)];
+			char dummy3[sizeof(ExpectedUEBehaviour)];
+			char dummy4[sizeof(GUMMEI)];
+			char dummy5[sizeof(Masked_IMEISV)];
+			char dummy6[sizeof(ProSeAuthorized)];
+			char dummy7[sizeof(SRVCCOperationPossible)];
+			char dummy8[sizeof(Subscription_Based_UE_DifferentiationInfo)];
+			char dummy9[sizeof(TraceActivation)];
+			char dummy10[sizeof(UE_ContextInformationRetrieve)];
+			char dummy11[sizeof(UE_X2AP_ID)];
+			char dummy12[sizeof(UE_X2AP_ID_Extension)];
+			char dummy13[sizeof(V2XServicesAuthorized)];
+
+		};
+		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 == 16; }
+		void clear() {type = 0;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=2;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=3;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
+		void select_id_GUMMEI_ID() { set(mandatory); type=5;}
+		void select_id_UE_ContextInformationRetrieve() { set(mandatory); type=6;}
+		void select_id_TraceActivation() { set(optional); type=7;}
+		void select_id_SRVCCOperationPossible() { set(optional); type=8;}
+		void select_id_Masked_IMEISV() { set(optional); type=9;}
+		void select_id_ExpectedUEBehaviour() { set(optional); type=10;}
+		void select_id_ProSeAuthorized() { set(optional); type=11;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=12;}
+		void select_id_V2XServicesAuthorized() { set(optional); type=13;}
+		void select_id_AerialUEsubscriptionInformation() { set(optional); type=14;}
+		void select_id_Subscription_Based_UE_DifferentiationInfo() { set(optional); type=15;}
+		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 if(equal(optional)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(mandatory)) { type = 5; return true; }
+			else if(equal(mandatory)) { 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 if(equal(optional)) { type = 10; return true; }
+			else if(equal(optional)) { type = 11; return true; }
+			else if(equal(optional)) { type = 12; return true; }
+			else if(equal(optional)) { type = 13; return true; }
+			else if(equal(optional)) { type = 14; return true; }
+			else if(equal(optional)) { type = 15; return true; }
+			else { type = 16; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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(mandatory);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(mandatory);} 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
+			case 13: type = 13; if(v(ref_nested())) { return equal(optional);} return false;
+			case 14: type = 14; if(v(ref_nested())) { return equal(optional);} return false;
+			case 15: type = 15; if(v(ref_nested())) { return equal(optional);} return false;
+			case 16: type = 16; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+RetrieveUEContextResponse ::= SEQUENCE {
+	protocolIEs			ProtocolIE-Container	{{ RetrieveUEContextResponse-IEs}},
+	...
+}
+*/
+
+struct RetrieveUEContextResponse : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "RetrieveUEContextResponse";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<RetrieveUEContextResponse_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<RetrieveUEContextResponse_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SNStatusTransfer-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Old-eNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID										PRESENCE mandatory}|
+	{ ID id-New-eNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID										PRESENCE mandatory}|
+	{ ID id-E-RABs-SubjectToStatusTransfer-List		CRITICALITY ignore	TYPE E-RABs-SubjectToStatusTransfer-List		PRESENCE mandatory}|
+	{ ID id-Old-eNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension							PRESENCE optional}|
+	{ ID id-New-eNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension							PRESENCE optional}|
+	{ ID id-SgNB-UE-X2AP-ID							CRITICALITY ignore	TYPE SgNB-UE-X2AP-ID									PRESENCE optional},
+	...
+}
+*/
+
+struct SNStatusTransfer_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
+		void select_id_E_RABs_SubjectToStatusTransfer_List() { set(id_E_RABs_SubjectToStatusTransfer_List); type=3;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=4;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=5;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=6;}
+		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_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_E_RABs_SubjectToStatusTransfer_List)) { type = 3; return true; }
+			else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
+			else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { 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_Old_eNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToStatusTransfer_List);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_E_RABs_SubjectToStatusTransfer_List() { set(ignore); type=3;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
+		void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=6;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(reject)) { type = 4; return true; }
+			else if(equal(reject)) { 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(ignore);} 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(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		E_RABs_SubjectToStatusTransfer_List& select_id_E_RABs_SubjectToStatusTransfer_List() { return set<E_RABs_SubjectToStatusTransfer_List>(3); }
+		E_RABs_SubjectToStatusTransfer_List const* get_id_E_RABs_SubjectToStatusTransfer_List() const { return get<E_RABs_SubjectToStatusTransfer_List>(3); }
+		UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(6); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(6); }
+		bool is_unknown() const { return type == 7; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<E_RABs_SubjectToStatusTransfer_List>(); break;
+			case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 6: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<E_RABs_SubjectToStatusTransfer_List>(3);
+			v.template operator()<UE_X2AP_ID_Extension>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+			v.template operator()<SgNB_UE_X2AP_ID>(6);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_E_RABs_SubjectToStatusTransfer_List()); return true;
+			case 4: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
+			case 5: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
+			case 6: v(select_id_SgNB_UE_X2AP_ID()); 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<E_RABs_SubjectToStatusTransfer_List>()); return true;
+			case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 6: v(var.as<SgNB_UE_X2AP_ID>()); 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_RABs_SubjectToStatusTransfer_List)];
+			char dummy2[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy3[sizeof(UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 7; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_E_RABs_SubjectToStatusTransfer_List() { set(mandatory); type=3;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		void select_id_SgNB_UE_X2AP_ID() { set(optional); type=6;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+SNStatusTransfer ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SNStatusTransfer-IEs}},
+	...
+}
+*/
+
+struct SNStatusTransfer : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SNStatusTransfer";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SNStatusTransfer_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SNStatusTransfer_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SeNBAdditionRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID					CRITICALITY reject	TYPE UE-X2AP-ID							PRESENCE mandatory}|
+	{ ID id-UE-SecurityCapabilities			CRITICALITY reject	TYPE UESecurityCapabilities				PRESENCE conditional}|
+	-- This IE shall be present if the Bearer Option IE is set to the value “SCG bearer” --
+	{ ID id-SeNBSecurityKey					CRITICALITY reject	TYPE SeNBSecurityKey					PRESENCE conditional}|
+	-- This IE shall be present if the Bearer Option IE is set to the value “SCG bearer” --
+	{ ID id-SeNBUEAggregateMaximumBitRate	CRITICALITY reject	TYPE UEAggregateMaximumBitRate			PRESENCE mandatory}|
+	{ ID id-ServingPLMN						CRITICALITY ignore	TYPE PLMN-Identity						PRESENCE optional}|
+	{ ID id-E-RABs-ToBeAdded-List			CRITICALITY reject	TYPE E-RABs-ToBeAdded-List				PRESENCE mandatory}|
+	{ ID id-MeNBtoSeNBContainer				CRITICALITY reject	TYPE MeNBtoSeNBContainer				PRESENCE mandatory}|
+	{ ID id-CSGMembershipStatus				CRITICALITY reject	TYPE CSGMembershipStatus				PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID					CRITICALITY reject	TYPE UE-X2AP-ID							PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension		CRITICALITY reject	TYPE UE-X2AP-ID-Extension				PRESENCE optional}|
+	{ ID id-ExpectedUEBehaviour				CRITICALITY ignore	TYPE ExpectedUEBehaviour				PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension		CRITICALITY reject	TYPE UE-X2AP-ID-Extension				PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBAdditionRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 13; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_UE_SecurityCapabilities() { set(id_UE_SecurityCapabilities); type=2;}
+		void select_id_SeNBSecurityKey() { set(id_SeNBSecurityKey); type=3;}
+		void select_id_SeNBUEAggregateMaximumBitRate() { set(id_SeNBUEAggregateMaximumBitRate); type=4;}
+		void select_id_ServingPLMN() { set(id_ServingPLMN); type=5;}
+		void select_id_E_RABs_ToBeAdded_List() { set(id_E_RABs_ToBeAdded_List); type=6;}
+		void select_id_MeNBtoSeNBContainer() { set(id_MeNBtoSeNBContainer); type=7;}
+		void select_id_CSGMembershipStatus() { set(id_CSGMembershipStatus); type=8;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=9;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=10;}
+		void select_id_ExpectedUEBehaviour() { set(id_ExpectedUEBehaviour); type=11;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=12;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_UE_SecurityCapabilities)) { type = 2; return true; }
+			else if(equal(id_SeNBSecurityKey)) { type = 3; return true; }
+			else if(equal(id_SeNBUEAggregateMaximumBitRate)) { type = 4; return true; }
+			else if(equal(id_ServingPLMN)) { type = 5; return true; }
+			else if(equal(id_E_RABs_ToBeAdded_List)) { type = 6; return true; }
+			else if(equal(id_MeNBtoSeNBContainer)) { type = 7; return true; }
+			else if(equal(id_CSGMembershipStatus)) { type = 8; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 9; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
+			else if(equal(id_ExpectedUEBehaviour)) { type = 11; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 12; return true; }
+			else { type = 13; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_UE_SecurityCapabilities);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_SeNBSecurityKey);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_SeNBUEAggregateMaximumBitRate);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_ServingPLMN);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_List);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNBtoSeNBContainer);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_CSGMembershipStatus);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(id_ExpectedUEBehaviour);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 13: type = 13; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 13; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_UE_SecurityCapabilities() { set(reject); type=2;}
+		void select_id_SeNBSecurityKey() { set(reject); type=3;}
+		void select_id_SeNBUEAggregateMaximumBitRate() { set(reject); type=4;}
+		void select_id_ServingPLMN() { set(ignore); type=5;}
+		void select_id_E_RABs_ToBeAdded_List() { set(reject); type=6;}
+		void select_id_MeNBtoSeNBContainer() { set(reject); type=7;}
+		void select_id_CSGMembershipStatus() { set(reject); type=8;}
+		void select_id_SeNB_UE_X2AP_ID() { set(reject); type=9;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=10;}
+		void select_id_ExpectedUEBehaviour() { set(ignore); type=11;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=12;}
+		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 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(reject)) { type = 6; return true; }
+			else if(equal(reject)) { type = 7; return true; }
+			else if(equal(reject)) { type = 8; return true; }
+			else if(equal(reject)) { type = 9; return true; }
+			else if(equal(reject)) { type = 10; return true; }
+			else if(equal(ignore)) { type = 11; return true; }
+			else if(equal(reject)) { type = 12; return true; }
+			else { type = 13; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(reject);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(reject);} return false;
+			case 13: type = 13; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UESecurityCapabilities& select_id_UE_SecurityCapabilities() { return set<UESecurityCapabilities>(2); }
+		UESecurityCapabilities const* get_id_UE_SecurityCapabilities() const { return get<UESecurityCapabilities>(2); }
+		SeNBSecurityKey& select_id_SeNBSecurityKey() { return set<SeNBSecurityKey>(3); }
+		SeNBSecurityKey const* get_id_SeNBSecurityKey() const { return get<SeNBSecurityKey>(3); }
+		UEAggregateMaximumBitRate& select_id_SeNBUEAggregateMaximumBitRate() { return set<UEAggregateMaximumBitRate>(4); }
+		UEAggregateMaximumBitRate const* get_id_SeNBUEAggregateMaximumBitRate() const { return get<UEAggregateMaximumBitRate>(4); }
+		PLMN_Identity& select_id_ServingPLMN() { return set<PLMN_Identity>(5); }
+		PLMN_Identity const* get_id_ServingPLMN() const { return get<PLMN_Identity>(5); }
+		E_RABs_ToBeAdded_List& select_id_E_RABs_ToBeAdded_List() { return set<E_RABs_ToBeAdded_List>(6); }
+		E_RABs_ToBeAdded_List const* get_id_E_RABs_ToBeAdded_List() const { return get<E_RABs_ToBeAdded_List>(6); }
+		MeNBtoSeNBContainer& select_id_MeNBtoSeNBContainer() { return set<MeNBtoSeNBContainer>(7); }
+		MeNBtoSeNBContainer const* get_id_MeNBtoSeNBContainer() const { return get<MeNBtoSeNBContainer>(7); }
+		CSGMembershipStatus& select_id_CSGMembershipStatus() { return set<CSGMembershipStatus>(8); }
+		CSGMembershipStatus const* get_id_CSGMembershipStatus() const { return get<CSGMembershipStatus>(8); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(9); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(9); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
+		ExpectedUEBehaviour& select_id_ExpectedUEBehaviour() { return set<ExpectedUEBehaviour>(11); }
+		ExpectedUEBehaviour const* get_id_ExpectedUEBehaviour() const { return get<ExpectedUEBehaviour>(11); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(12); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(12); }
+		bool is_unknown() const { return type == 13; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UESecurityCapabilities>(); break;
+			case 3: var.destroy<SeNBSecurityKey>(); break;
+			case 4: var.destroy<UEAggregateMaximumBitRate>(); break;
+			case 5: var.destroy<PLMN_Identity>(); break;
+			case 6: var.destroy<E_RABs_ToBeAdded_List>(); break;
+			case 7: var.destroy<MeNBtoSeNBContainer>(); break;
+			case 8: var.destroy<CSGMembershipStatus>(); break;
+			case 9: var.destroy<UE_X2AP_ID>(); break;
+			case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 11: var.destroy<ExpectedUEBehaviour>(); break;
+			case 12: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UESecurityCapabilities>(2);
+			v.template operator()<SeNBSecurityKey>(3);
+			v.template operator()<UEAggregateMaximumBitRate>(4);
+			v.template operator()<PLMN_Identity>(5);
+			v.template operator()<E_RABs_ToBeAdded_List>(6);
+			v.template operator()<MeNBtoSeNBContainer>(7);
+			v.template operator()<CSGMembershipStatus>(8);
+			v.template operator()<UE_X2AP_ID>(9);
+			v.template operator()<UE_X2AP_ID_Extension>(10);
+			v.template operator()<ExpectedUEBehaviour>(11);
+			v.template operator()<UE_X2AP_ID_Extension>(12);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_UE_SecurityCapabilities()); return true;
+			case 3: v(select_id_SeNBSecurityKey()); return true;
+			case 4: v(select_id_SeNBUEAggregateMaximumBitRate()); return true;
+			case 5: v(select_id_ServingPLMN()); return true;
+			case 6: v(select_id_E_RABs_ToBeAdded_List()); return true;
+			case 7: v(select_id_MeNBtoSeNBContainer()); return true;
+			case 8: v(select_id_CSGMembershipStatus()); return true;
+			case 9: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 10: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
+			case 11: v(select_id_ExpectedUEBehaviour()); return true;
+			case 12: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 13: if(type != 13) {clear(); asn::base::set();} type = 13; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UESecurityCapabilities>()); return true;
+			case 3: v(var.as<SeNBSecurityKey>()); return true;
+			case 4: v(var.as<UEAggregateMaximumBitRate>()); return true;
+			case 5: v(var.as<PLMN_Identity>()); return true;
+			case 6: v(var.as<E_RABs_ToBeAdded_List>()); return true;
+			case 7: v(var.as<MeNBtoSeNBContainer>()); return true;
+			case 8: v(var.as<CSGMembershipStatus>()); return true;
+			case 9: v(var.as<UE_X2AP_ID>()); return true;
+			case 10: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 11: v(var.as<ExpectedUEBehaviour>()); return true;
+			case 12: v(var.as<UE_X2AP_ID_Extension>()); 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(CSGMembershipStatus)];
+			char dummy2[sizeof(E_RABs_ToBeAdded_List)];
+			char dummy3[sizeof(ExpectedUEBehaviour)];
+			char dummy4[sizeof(MeNBtoSeNBContainer)];
+			char dummy5[sizeof(PLMN_Identity)];
+			char dummy6[sizeof(SeNBSecurityKey)];
+			char dummy7[sizeof(UEAggregateMaximumBitRate)];
+			char dummy8[sizeof(UESecurityCapabilities)];
+			char dummy9[sizeof(UE_X2AP_ID)];
+			char dummy10[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 13; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_UE_SecurityCapabilities() { set(conditional); type=2;}
+		void select_id_SeNBSecurityKey() { set(conditional); type=3;}
+		void select_id_SeNBUEAggregateMaximumBitRate() { set(mandatory); type=4;}
+		void select_id_ServingPLMN() { set(optional); type=5;}
+		void select_id_E_RABs_ToBeAdded_List() { set(mandatory); type=6;}
+		void select_id_MeNBtoSeNBContainer() { set(mandatory); type=7;}
+		void select_id_CSGMembershipStatus() { set(optional); type=8;}
+		void select_id_SeNB_UE_X2AP_ID() { set(optional); type=9;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
+		void select_id_ExpectedUEBehaviour() { set(optional); type=11;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=12;}
+		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 if(equal(conditional)) { type = 2; return true; }
+			else if(equal(conditional)) { type = 3; return true; }
+			else if(equal(mandatory)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else if(equal(mandatory)) { type = 6; return true; }
+			else if(equal(mandatory)) { type = 7; return true; }
+			else if(equal(optional)) { type = 8; return true; }
+			else if(equal(optional)) { type = 9; return true; }
+			else if(equal(optional)) { type = 10; return true; }
+			else if(equal(optional)) { type = 11; return true; }
+			else if(equal(optional)) { type = 12; return true; }
+			else { type = 13; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; 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(mandatory);} 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(mandatory);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(mandatory);} 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
+			case 13: type = 13; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SeNBAdditionRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SeNBAdditionRequest-IEs}},
+	...
+}
+*/
+
+struct SeNBAdditionRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBAdditionRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBAdditionRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBAdditionRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SeNBAdditionRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID							PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID							PRESENCE mandatory}|
+	{ ID id-E-RABs-Admitted-ToBeAdded-List		CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeAdded-List	PRESENCE mandatory}|
+	{ ID id-E-RABs-NotAdmitted-List				CRITICALITY ignore	TYPE E-RAB-List							PRESENCE optional}|
+	{ ID id-SeNBtoMeNBContainer					CRITICALITY reject	TYPE SeNBtoMeNBContainer				PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics				CRITICALITY ignore	TYPE CriticalityDiagnostics				PRESENCE optional}|
+	{ ID id-GW-TransportLayerAddress			CRITICALITY ignore	TYPE TransportLayerAddress				PRESENCE optional}|
+	{ ID id-SIPTO-L-GW-TransportLayerAddress	CRITICALITY ignore	TYPE TransportLayerAddress				PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension				PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension				PRESENCE optional}|
+	{ ID id-Tunnel-Information-for-BBF			CRITICALITY ignore	TYPE TunnelInformation					PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBAdditionRequestAcknowledge_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 12; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
+		void select_id_E_RABs_Admitted_ToBeAdded_List() { set(id_E_RABs_Admitted_ToBeAdded_List); type=3;}
+		void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=4;}
+		void select_id_SeNBtoMeNBContainer() { set(id_SeNBtoMeNBContainer); type=5;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=6;}
+		void select_id_GW_TransportLayerAddress() { set(id_GW_TransportLayerAddress); type=7;}
+		void select_id_SIPTO_L_GW_TransportLayerAddress() { set(id_SIPTO_L_GW_TransportLayerAddress); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=10;}
+		void select_id_Tunnel_Information_for_BBF() { set(id_Tunnel_Information_for_BBF); type=11;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_E_RABs_Admitted_ToBeAdded_List)) { type = 3; return true; }
+			else if(equal(id_E_RABs_NotAdmitted_List)) { type = 4; return true; }
+			else if(equal(id_SeNBtoMeNBContainer)) { type = 5; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 6; return true; }
+			else if(equal(id_GW_TransportLayerAddress)) { type = 7; return true; }
+			else if(equal(id_SIPTO_L_GW_TransportLayerAddress)) { type = 8; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
+			else if(equal(id_Tunnel_Information_for_BBF)) { type = 11; return true; }
+			else { type = 12; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_List);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_SeNBtoMeNBContainer);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_GW_TransportLayerAddress);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_SIPTO_L_GW_TransportLayerAddress);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(id_Tunnel_Information_for_BBF);} return false;
+			case 12: type = 12; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 12; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_E_RABs_Admitted_ToBeAdded_List() { set(ignore); type=3;}
+		void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=4;}
+		void select_id_SeNBtoMeNBContainer() { set(reject); type=5;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=6;}
+		void select_id_GW_TransportLayerAddress() { set(ignore); type=7;}
+		void select_id_SIPTO_L_GW_TransportLayerAddress() { set(ignore); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=9;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=10;}
+		void select_id_Tunnel_Information_for_BBF() { set(ignore); type=11;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(ignore)) { type = 4; return true; }
+			else if(equal(reject)) { 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(reject)) { type = 9; return true; }
+			else if(equal(reject)) { type = 10; return true; }
+			else if(equal(ignore)) { type = 11; return true; }
+			else { type = 12; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(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(reject);} 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(reject);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 12: type = 12; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		E_RABs_Admitted_ToBeAdded_List& select_id_E_RABs_Admitted_ToBeAdded_List() { return set<E_RABs_Admitted_ToBeAdded_List>(3); }
+		E_RABs_Admitted_ToBeAdded_List const* get_id_E_RABs_Admitted_ToBeAdded_List() const { return get<E_RABs_Admitted_ToBeAdded_List>(3); }
+		E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(4); }
+		E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(4); }
+		SeNBtoMeNBContainer& select_id_SeNBtoMeNBContainer() { return set<SeNBtoMeNBContainer>(5); }
+		SeNBtoMeNBContainer const* get_id_SeNBtoMeNBContainer() const { return get<SeNBtoMeNBContainer>(5); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(6); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(6); }
+		TransportLayerAddress& select_id_GW_TransportLayerAddress() { return set<TransportLayerAddress>(7); }
+		TransportLayerAddress const* get_id_GW_TransportLayerAddress() const { return get<TransportLayerAddress>(7); }
+		TransportLayerAddress& select_id_SIPTO_L_GW_TransportLayerAddress() { return set<TransportLayerAddress>(8); }
+		TransportLayerAddress const* get_id_SIPTO_L_GW_TransportLayerAddress() const { return get<TransportLayerAddress>(8); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
+		TunnelInformation& select_id_Tunnel_Information_for_BBF() { return set<TunnelInformation>(11); }
+		TunnelInformation const* get_id_Tunnel_Information_for_BBF() const { return get<TunnelInformation>(11); }
+		bool is_unknown() const { return type == 12; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<E_RABs_Admitted_ToBeAdded_List>(); break;
+			case 4: var.destroy<E_RAB_List>(); break;
+			case 5: var.destroy<SeNBtoMeNBContainer>(); break;
+			case 6: var.destroy<CriticalityDiagnostics>(); break;
+			case 7: var.destroy<TransportLayerAddress>(); break;
+			case 8: var.destroy<TransportLayerAddress>(); break;
+			case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 11: var.destroy<TunnelInformation>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<E_RABs_Admitted_ToBeAdded_List>(3);
+			v.template operator()<E_RAB_List>(4);
+			v.template operator()<SeNBtoMeNBContainer>(5);
+			v.template operator()<CriticalityDiagnostics>(6);
+			v.template operator()<TransportLayerAddress>(7);
+			v.template operator()<TransportLayerAddress>(8);
+			v.template operator()<UE_X2AP_ID_Extension>(9);
+			v.template operator()<UE_X2AP_ID_Extension>(10);
+			v.template operator()<TunnelInformation>(11);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_E_RABs_Admitted_ToBeAdded_List()); return true;
+			case 4: v(select_id_E_RABs_NotAdmitted_List()); return true;
+			case 5: v(select_id_SeNBtoMeNBContainer()); return true;
+			case 6: v(select_id_CriticalityDiagnostics()); return true;
+			case 7: v(select_id_GW_TransportLayerAddress()); return true;
+			case 8: v(select_id_SIPTO_L_GW_TransportLayerAddress()); return true;
+			case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 10: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
+			case 11: v(select_id_Tunnel_Information_for_BBF()); return true;
+			case 12: if(type != 12) {clear(); asn::base::set();} type = 12; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<E_RABs_Admitted_ToBeAdded_List>()); return true;
+			case 4: v(var.as<E_RAB_List>()); return true;
+			case 5: v(var.as<SeNBtoMeNBContainer>()); return true;
+			case 6: v(var.as<CriticalityDiagnostics>()); return true;
+			case 7: v(var.as<TransportLayerAddress>()); return true;
+			case 8: v(var.as<TransportLayerAddress>()); return true;
+			case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 10: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 11: v(var.as<TunnelInformation>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(E_RAB_List)];
+			char dummy3[sizeof(E_RABs_Admitted_ToBeAdded_List)];
+			char dummy4[sizeof(SeNBtoMeNBContainer)];
+			char dummy5[sizeof(TransportLayerAddress)];
+			char dummy6[sizeof(TunnelInformation)];
+			char dummy7[sizeof(UE_X2AP_ID)];
+			char dummy8[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 12; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_E_RABs_Admitted_ToBeAdded_List() { set(mandatory); type=3;}
+		void select_id_E_RABs_NotAdmitted_List() { set(optional); type=4;}
+		void select_id_SeNBtoMeNBContainer() { set(mandatory); type=5;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=6;}
+		void select_id_GW_TransportLayerAddress() { set(optional); type=7;}
+		void select_id_SIPTO_L_GW_TransportLayerAddress() { set(optional); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
+		void select_id_Tunnel_Information_for_BBF() { set(optional); type=11;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(mandatory)) { 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 if(equal(optional)) { type = 10; return true; }
+			else if(equal(optional)) { type = 11; return true; }
+			else { type = 12; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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(mandatory);} 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
+			case 12: type = 12; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SeNBAdditionRequestAcknowledge ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SeNBAdditionRequestAcknowledge-IEs}},
+	...
+}
+*/
+
+struct SeNBAdditionRequestAcknowledge : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBAdditionRequestAcknowledge";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBAdditionRequestAcknowledge_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBAdditionRequestAcknowledge_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SeNBAdditionRequestReject-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID					CRITICALITY reject	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID					CRITICALITY reject	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-Cause							CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics			CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension		CRITICALITY reject	TYPE UE-X2AP-ID-Extension		PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension		CRITICALITY reject	TYPE UE-X2AP-ID-Extension		PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBAdditionRequestReject_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=6;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=6;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(ignore)) { type = 4; return true; }
+			else if(equal(reject)) { type = 5; return true; }
+			else if(equal(reject)) { 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(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(reject);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
+		bool is_unknown() const { return type == 7; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+			v.template operator()<UE_X2AP_ID_Extension>(6);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); return true;
+			case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: v(select_id_SeNB_UE_X2AP_ID_Extension()); 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 6: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+SeNBAdditionRequestReject ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SeNBAdditionRequestReject-IEs}},
+	...
+}
+*/
+
+struct SeNBAdditionRequestReject : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBAdditionRequestReject";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBAdditionRequestReject_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBAdditionRequestReject_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SeNBCounterCheckRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-E-RABs-SubjectToCounterCheck-List	CRITICALITY ignore	TYPE E-RABs-SubjectToCounterCheck-List		PRESENCE mandatory}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY ignore	TYPE UE-X2AP-ID-Extension						PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension			CRITICALITY ignore	TYPE UE-X2AP-ID-Extension						PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBCounterCheckRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
+		void select_id_E_RABs_SubjectToCounterCheck_List() { set(id_E_RABs_SubjectToCounterCheck_List); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=5;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_E_RABs_SubjectToCounterCheck_List)) { type = 3; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToCounterCheck_List);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_E_RABs_SubjectToCounterCheck_List() { set(ignore); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=4;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
+		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 if(equal(reject)) { 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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		E_RABs_SubjectToCounterCheck_List& select_id_E_RABs_SubjectToCounterCheck_List() { return set<E_RABs_SubjectToCounterCheck_List>(3); }
+		E_RABs_SubjectToCounterCheck_List const* get_id_E_RABs_SubjectToCounterCheck_List() const { return get<E_RABs_SubjectToCounterCheck_List>(3); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<E_RABs_SubjectToCounterCheck_List>(); break;
+			case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<E_RABs_SubjectToCounterCheck_List>(3);
+			v.template operator()<UE_X2AP_ID_Extension>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_E_RABs_SubjectToCounterCheck_List()); return true;
+			case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 5: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<E_RABs_SubjectToCounterCheck_List>()); return true;
+			case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); 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_RABs_SubjectToCounterCheck_List)];
+			char dummy2[sizeof(UE_X2AP_ID)];
+			char dummy3[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_E_RABs_SubjectToCounterCheck_List() { set(mandatory); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SeNBCounterCheckRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SeNBCounterCheckRequest-IEs}},
+	...
+}
+*/
+
+struct SeNBCounterCheckRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBCounterCheckRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBCounterCheckRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBCounterCheckRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SeNBModificationConfirm-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY ignore	TYPE UE-X2AP-ID						PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID						CRITICALITY ignore	TYPE UE-X2AP-ID						PRESENCE mandatory}|
+	{ ID id-MeNBtoSeNBContainer					CRITICALITY ignore	TYPE MeNBtoSeNBContainer			PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics				CRITICALITY ignore	TYPE CriticalityDiagnostics			PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY ignore	TYPE UE-X2AP-ID-Extension			PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension			CRITICALITY ignore	TYPE UE-X2AP-ID-Extension			PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBModificationConfirm_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
+		void select_id_MeNBtoSeNBContainer() { set(id_MeNBtoSeNBContainer); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=6;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_MeNBtoSeNBContainer)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_MeNBtoSeNBContainer);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_MeNBtoSeNBContainer() { set(ignore); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
+		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 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 { 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		MeNBtoSeNBContainer& select_id_MeNBtoSeNBContainer() { return set<MeNBtoSeNBContainer>(3); }
+		MeNBtoSeNBContainer const* get_id_MeNBtoSeNBContainer() const { return get<MeNBtoSeNBContainer>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
+		bool is_unknown() const { return type == 7; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<MeNBtoSeNBContainer>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<MeNBtoSeNBContainer>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+			v.template operator()<UE_X2AP_ID_Extension>(6);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_MeNBtoSeNBContainer()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); return true;
+			case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: v(select_id_SeNB_UE_X2AP_ID_Extension()); 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<MeNBtoSeNBContainer>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 6: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(MeNBtoSeNBContainer)];
+			char dummy3[sizeof(UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_MeNBtoSeNBContainer() { set(optional); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+SeNBModificationConfirm ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SeNBModificationConfirm-IEs}},
+	...
+}
+*/
+
+struct SeNBModificationConfirm : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBModificationConfirm";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBModificationConfirm_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBModificationConfirm_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SeNBModificationRefuse-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY ignore	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID						CRITICALITY ignore	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-Cause								CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-MeNBtoSeNBContainer					CRITICALITY ignore	TYPE MeNBtoSeNBContainer		PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics				CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY ignore	TYPE UE-X2AP-ID-Extension		PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension			CRITICALITY ignore	TYPE UE-X2AP-ID-Extension		PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBModificationRefuse_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 8; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_MeNBtoSeNBContainer() { set(id_MeNBtoSeNBContainer); type=4;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=7;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_MeNBtoSeNBContainer)) { type = 4; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 5; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
+			else { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNBtoSeNBContainer);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
+			case 8: type = 8; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 8; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_MeNBtoSeNBContainer() { set(ignore); type=4;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=7;}
+		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 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 { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		MeNBtoSeNBContainer& select_id_MeNBtoSeNBContainer() { return set<MeNBtoSeNBContainer>(4); }
+		MeNBtoSeNBContainer const* get_id_MeNBtoSeNBContainer() const { return get<MeNBtoSeNBContainer>(4); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(5); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(5); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
+		bool is_unknown() const { return type == 8; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<MeNBtoSeNBContainer>(); break;
+			case 5: var.destroy<CriticalityDiagnostics>(); break;
+			case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<MeNBtoSeNBContainer>(4);
+			v.template operator()<CriticalityDiagnostics>(5);
+			v.template operator()<UE_X2AP_ID_Extension>(6);
+			v.template operator()<UE_X2AP_ID_Extension>(7);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_MeNBtoSeNBContainer()); return true;
+			case 5: v(select_id_CriticalityDiagnostics()); return true;
+			case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 7: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
+			case 8: if(type != 8) {clear(); asn::base::set();} type = 8; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<MeNBtoSeNBContainer>()); return true;
+			case 5: v(var.as<CriticalityDiagnostics>()); return true;
+			case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 7: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(MeNBtoSeNBContainer)];
+			char dummy4[sizeof(UE_X2AP_ID)];
+			char dummy5[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 8; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_MeNBtoSeNBContainer() { set(optional); type=4;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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 { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SeNBModificationRefuse ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{SeNBModificationRefuse-IEs}},
+	...
+}
+*/
+
+struct SeNBModificationRefuse : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBModificationRefuse";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRefuse_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBModificationRefuse_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+UE-ContextInformationSeNBModReqExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	...
+}
+*/
+
+struct UE_ContextInformationSeNBModReqExtIEs
+{
+	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-ContextInformationSeNBModReq ::= SEQUENCE {
+	uE-SecurityCapabilities			UESecurityCapabilities															OPTIONAL,
+	seNB-SecurityKey				SeNBSecurityKey 																OPTIONAL,
+	seNBUEAggregateMaximumBitRate	UEAggregateMaximumBitRate														OPTIONAL,
+	e-RABs-ToBeAdded				E-RABs-ToBeAdded-List-ModReq													OPTIONAL,
+	e-RABs-ToBeModified				E-RABs-ToBeModified-List-ModReq													OPTIONAL,
+	e-RABs-ToBeReleased				E-RABs-ToBeReleased-List-ModReq													OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {UE-ContextInformationSeNBModReqExtIEs} }	OPTIONAL,
+	...
+}
+*/
+
+struct UE_ContextInformationSeNBModReq : asn::sequence<7, 0, true, 7>
+{
+	static constexpr const char* name() {return "UE-ContextInformationSeNBModReq";}
+	using parent_t = asn::sequence<7, 0, true, 7>;
+	struct uE_SecurityCapabilities_t : UESecurityCapabilities
+	{
+		static constexpr const char* name() {return "uE_SecurityCapabilities_t";}
+		using parent_t = UESecurityCapabilities;
+		static constexpr bool optional = true;
+
+	};
+	uE_SecurityCapabilities_t& set_uE_SecurityCapabilities() { uE_SecurityCapabilities.setpresent(true); return uE_SecurityCapabilities;}
+	uE_SecurityCapabilities_t const* get_uE_SecurityCapabilities() const {return uE_SecurityCapabilities.is_valid() ? &uE_SecurityCapabilities : nullptr;}
+	struct seNB_SecurityKey_t : SeNBSecurityKey
+	{
+		static constexpr const char* name() {return "seNB_SecurityKey_t";}
+		using parent_t = SeNBSecurityKey;
+		static constexpr bool optional = true;
+
+	};
+	seNB_SecurityKey_t& set_seNB_SecurityKey() { seNB_SecurityKey.setpresent(true); return seNB_SecurityKey;}
+	seNB_SecurityKey_t const* get_seNB_SecurityKey() const {return seNB_SecurityKey.is_valid() ? &seNB_SecurityKey : nullptr;}
+	struct seNBUEAggregateMaximumBitRate_t : UEAggregateMaximumBitRate
+	{
+		static constexpr const char* name() {return "seNBUEAggregateMaximumBitRate_t";}
+		using parent_t = UEAggregateMaximumBitRate;
+		static constexpr bool optional = true;
+
+	};
+	seNBUEAggregateMaximumBitRate_t& set_seNBUEAggregateMaximumBitRate() { seNBUEAggregateMaximumBitRate.setpresent(true); return seNBUEAggregateMaximumBitRate;}
+	seNBUEAggregateMaximumBitRate_t const* get_seNBUEAggregateMaximumBitRate() const {return seNBUEAggregateMaximumBitRate.is_valid() ? &seNBUEAggregateMaximumBitRate : nullptr;}
+	struct e_RABs_ToBeAdded_t : E_RABs_ToBeAdded_List_ModReq
+	{
+		static constexpr const char* name() {return "e_RABs_ToBeAdded_t";}
+		using parent_t = E_RABs_ToBeAdded_List_ModReq;
+		static constexpr bool optional = true;
+
+	};
+	e_RABs_ToBeAdded_t& set_e_RABs_ToBeAdded() { e_RABs_ToBeAdded.setpresent(true); return e_RABs_ToBeAdded;}
+	e_RABs_ToBeAdded_t const* get_e_RABs_ToBeAdded() const {return e_RABs_ToBeAdded.is_valid() ? &e_RABs_ToBeAdded : nullptr;}
+	struct e_RABs_ToBeModified_t : E_RABs_ToBeModified_List_ModReq
+	{
+		static constexpr const char* name() {return "e_RABs_ToBeModified_t";}
+		using parent_t = E_RABs_ToBeModified_List_ModReq;
+		static constexpr bool optional = true;
+
+	};
+	e_RABs_ToBeModified_t& set_e_RABs_ToBeModified() { e_RABs_ToBeModified.setpresent(true); return e_RABs_ToBeModified;}
+	e_RABs_ToBeModified_t const* get_e_RABs_ToBeModified() const {return e_RABs_ToBeModified.is_valid() ? &e_RABs_ToBeModified : nullptr;}
+	struct e_RABs_ToBeReleased_t : E_RABs_ToBeReleased_List_ModReq
+	{
+		static constexpr const char* name() {return "e_RABs_ToBeReleased_t";}
+		using parent_t = E_RABs_ToBeReleased_List_ModReq;
+		static constexpr bool optional = true;
+
+	};
+	e_RABs_ToBeReleased_t& set_e_RABs_ToBeReleased() { e_RABs_ToBeReleased.setpresent(true); return e_RABs_ToBeReleased;}
+	e_RABs_ToBeReleased_t const* get_e_RABs_ToBeReleased() const {return e_RABs_ToBeReleased.is_valid() ? &e_RABs_ToBeReleased : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextInformationSeNBModReqExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UE_ContextInformationSeNBModReqExtIEs>;
+		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(uE_SecurityCapabilities);
+		v(seNB_SecurityKey);
+		v(seNBUEAggregateMaximumBitRate);
+		v(e_RABs_ToBeAdded);
+		v(e_RABs_ToBeModified);
+		v(e_RABs_ToBeReleased);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(uE_SecurityCapabilities);
+		v(seNB_SecurityKey);
+		v(seNBUEAggregateMaximumBitRate);
+		v(e_RABs_ToBeAdded);
+		v(e_RABs_ToBeModified);
+		v(e_RABs_ToBeReleased);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		uE_SecurityCapabilities.clear();
+		seNB_SecurityKey.clear();
+		seNBUEAggregateMaximumBitRate.clear();
+		e_RABs_ToBeAdded.clear();
+		e_RABs_ToBeModified.clear();
+		e_RABs_ToBeReleased.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	uE_SecurityCapabilities_t	uE_SecurityCapabilities;
+	seNB_SecurityKey_t	seNB_SecurityKey;
+	seNBUEAggregateMaximumBitRate_t	seNBUEAggregateMaximumBitRate;
+	e_RABs_ToBeAdded_t	e_RABs_ToBeAdded;
+	e_RABs_ToBeModified_t	e_RABs_ToBeModified;
+	e_RABs_ToBeReleased_t	e_RABs_ToBeReleased;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+SeNBModificationRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID								PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID								PRESENCE mandatory}|
+	{ ID id-Cause								CRITICALITY ignore	TYPE Cause									PRESENCE mandatory}|
+	{ ID id-SCGChangeIndication					CRITICALITY ignore	TYPE SCGChangeIndication					PRESENCE optional}|
+	{ ID id-ServingPLMN							CRITICALITY ignore	TYPE PLMN-Identity							PRESENCE optional}|
+	{ ID id-UE-ContextInformationSeNBModReq		CRITICALITY reject	TYPE UE-ContextInformationSeNBModReq	PRESENCE optional}|
+	{ ID id-MeNBtoSeNBContainer					CRITICALITY ignore	TYPE MeNBtoSeNBContainer					PRESENCE optional}|
+	{ ID id-CSGMembershipStatus					CRITICALITY reject	TYPE CSGMembershipStatus					PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension					PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension					PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBModificationRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 11; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_SCGChangeIndication() { set(id_SCGChangeIndication); type=4;}
+		void select_id_ServingPLMN() { set(id_ServingPLMN); type=5;}
+		void select_id_UE_ContextInformationSeNBModReq() { set(id_UE_ContextInformationSeNBModReq); type=6;}
+		void select_id_MeNBtoSeNBContainer() { set(id_MeNBtoSeNBContainer); type=7;}
+		void select_id_CSGMembershipStatus() { set(id_CSGMembershipStatus); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=10;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_SCGChangeIndication)) { type = 4; return true; }
+			else if(equal(id_ServingPLMN)) { type = 5; return true; }
+			else if(equal(id_UE_ContextInformationSeNBModReq)) { type = 6; return true; }
+			else if(equal(id_MeNBtoSeNBContainer)) { type = 7; return true; }
+			else if(equal(id_CSGMembershipStatus)) { type = 8; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_SCGChangeIndication);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_ServingPLMN);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_UE_ContextInformationSeNBModReq);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNBtoSeNBContainer);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_CSGMembershipStatus);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 11; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_SCGChangeIndication() { set(ignore); type=4;}
+		void select_id_ServingPLMN() { set(ignore); type=5;}
+		void select_id_UE_ContextInformationSeNBModReq() { set(reject); type=6;}
+		void select_id_MeNBtoSeNBContainer() { set(ignore); type=7;}
+		void select_id_CSGMembershipStatus() { set(reject); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=9;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=10;}
+		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 if(equal(reject)) { 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(reject)) { type = 6; return true; }
+			else if(equal(ignore)) { type = 7; return true; }
+			else if(equal(reject)) { type = 8; return true; }
+			else if(equal(reject)) { type = 9; return true; }
+			else if(equal(reject)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(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(reject);} 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(reject);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		SCGChangeIndication& select_id_SCGChangeIndication() { return set<SCGChangeIndication>(4); }
+		SCGChangeIndication const* get_id_SCGChangeIndication() const { return get<SCGChangeIndication>(4); }
+		PLMN_Identity& select_id_ServingPLMN() { return set<PLMN_Identity>(5); }
+		PLMN_Identity const* get_id_ServingPLMN() const { return get<PLMN_Identity>(5); }
+		UE_ContextInformationSeNBModReq& select_id_UE_ContextInformationSeNBModReq() { return set<UE_ContextInformationSeNBModReq>(6); }
+		UE_ContextInformationSeNBModReq const* get_id_UE_ContextInformationSeNBModReq() const { return get<UE_ContextInformationSeNBModReq>(6); }
+		MeNBtoSeNBContainer& select_id_MeNBtoSeNBContainer() { return set<MeNBtoSeNBContainer>(7); }
+		MeNBtoSeNBContainer const* get_id_MeNBtoSeNBContainer() const { return get<MeNBtoSeNBContainer>(7); }
+		CSGMembershipStatus& select_id_CSGMembershipStatus() { return set<CSGMembershipStatus>(8); }
+		CSGMembershipStatus const* get_id_CSGMembershipStatus() const { return get<CSGMembershipStatus>(8); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
+		bool is_unknown() const { return type == 11; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<SCGChangeIndication>(); break;
+			case 5: var.destroy<PLMN_Identity>(); break;
+			case 6: var.destroy<UE_ContextInformationSeNBModReq>(); break;
+			case 7: var.destroy<MeNBtoSeNBContainer>(); break;
+			case 8: var.destroy<CSGMembershipStatus>(); break;
+			case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<SCGChangeIndication>(4);
+			v.template operator()<PLMN_Identity>(5);
+			v.template operator()<UE_ContextInformationSeNBModReq>(6);
+			v.template operator()<MeNBtoSeNBContainer>(7);
+			v.template operator()<CSGMembershipStatus>(8);
+			v.template operator()<UE_X2AP_ID_Extension>(9);
+			v.template operator()<UE_X2AP_ID_Extension>(10);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_SCGChangeIndication()); return true;
+			case 5: v(select_id_ServingPLMN()); return true;
+			case 6: v(select_id_UE_ContextInformationSeNBModReq()); return true;
+			case 7: v(select_id_MeNBtoSeNBContainer()); return true;
+			case 8: v(select_id_CSGMembershipStatus()); return true;
+			case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 10: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
+			case 11: if(type != 11) {clear(); asn::base::set();} type = 11; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<SCGChangeIndication>()); return true;
+			case 5: v(var.as<PLMN_Identity>()); return true;
+			case 6: v(var.as<UE_ContextInformationSeNBModReq>()); return true;
+			case 7: v(var.as<MeNBtoSeNBContainer>()); return true;
+			case 8: v(var.as<CSGMembershipStatus>()); return true;
+			case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 10: v(var.as<UE_X2AP_ID_Extension>()); 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(CSGMembershipStatus)];
+			char dummy2[sizeof(Cause)];
+			char dummy3[sizeof(MeNBtoSeNBContainer)];
+			char dummy4[sizeof(PLMN_Identity)];
+			char dummy5[sizeof(SCGChangeIndication)];
+			char dummy6[sizeof(UE_ContextInformationSeNBModReq)];
+			char dummy7[sizeof(UE_X2AP_ID)];
+			char dummy8[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 11; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_SCGChangeIndication() { set(optional); type=4;}
+		void select_id_ServingPLMN() { set(optional); type=5;}
+		void select_id_UE_ContextInformationSeNBModReq() { set(optional); type=6;}
+		void select_id_MeNBtoSeNBContainer() { set(optional); type=7;}
+		void select_id_CSGMembershipStatus() { set(optional); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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 if(equal(optional)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SeNBModificationRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ SeNBModificationRequest-IEs}},
+	...
+}
+*/
+
+struct SeNBModificationRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBModificationRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBModificationRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SeNBModificationRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID								CRITICALITY ignore	TYPE UE-X2AP-ID											PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID								CRITICALITY ignore	TYPE UE-X2AP-ID											PRESENCE mandatory}|
+	{ ID id-E-RABs-Admitted-ToBeAdded-ModAckList		CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeAdded-ModAckList		PRESENCE optional}|
+	{ ID id-E-RABs-Admitted-ToBeModified-ModAckList		CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeModified-ModAckList	PRESENCE optional}|
+	{ ID id-E-RABs-Admitted-ToBeReleased-ModAckList		CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeReleased-ModAckList	PRESENCE optional}|
+	{ ID id-E-RABs-NotAdmitted-List						CRITICALITY ignore	TYPE E-RAB-List											PRESENCE optional}|
+	{ ID id-SeNBtoMeNBContainer							CRITICALITY ignore	TYPE SeNBtoMeNBContainer								PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics						CRITICALITY ignore	TYPE CriticalityDiagnostics							PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension					CRITICALITY ignore	TYPE UE-X2AP-ID-Extension							PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension					CRITICALITY ignore	TYPE UE-X2AP-ID-Extension							PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBModificationRequestAcknowledge_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 11; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
+		void select_id_E_RABs_Admitted_ToBeAdded_ModAckList() { set(id_E_RABs_Admitted_ToBeAdded_ModAckList); type=3;}
+		void select_id_E_RABs_Admitted_ToBeModified_ModAckList() { set(id_E_RABs_Admitted_ToBeModified_ModAckList); type=4;}
+		void select_id_E_RABs_Admitted_ToBeReleased_ModAckList() { set(id_E_RABs_Admitted_ToBeReleased_ModAckList); type=5;}
+		void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=6;}
+		void select_id_SeNBtoMeNBContainer() { set(id_SeNBtoMeNBContainer); type=7;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=10;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_E_RABs_Admitted_ToBeAdded_ModAckList)) { type = 3; return true; }
+			else if(equal(id_E_RABs_Admitted_ToBeModified_ModAckList)) { type = 4; return true; }
+			else if(equal(id_E_RABs_Admitted_ToBeReleased_ModAckList)) { type = 5; return true; }
+			else if(equal(id_E_RABs_NotAdmitted_List)) { type = 6; return true; }
+			else if(equal(id_SeNBtoMeNBContainer)) { type = 7; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 8; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_ModAckList);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeModified_ModAckList);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_ModAckList);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_SeNBtoMeNBContainer);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 11; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_E_RABs_Admitted_ToBeAdded_ModAckList() { set(ignore); type=3;}
+		void select_id_E_RABs_Admitted_ToBeModified_ModAckList() { set(ignore); type=4;}
+		void select_id_E_RABs_Admitted_ToBeReleased_ModAckList() { set(ignore); type=5;}
+		void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=6;}
+		void select_id_SeNBtoMeNBContainer() { set(ignore); type=7;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=9;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=10;}
+		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 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 if(equal(ignore)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		E_RABs_Admitted_ToBeAdded_ModAckList& select_id_E_RABs_Admitted_ToBeAdded_ModAckList() { return set<E_RABs_Admitted_ToBeAdded_ModAckList>(3); }
+		E_RABs_Admitted_ToBeAdded_ModAckList const* get_id_E_RABs_Admitted_ToBeAdded_ModAckList() const { return get<E_RABs_Admitted_ToBeAdded_ModAckList>(3); }
+		E_RABs_Admitted_ToBeModified_ModAckList& select_id_E_RABs_Admitted_ToBeModified_ModAckList() { return set<E_RABs_Admitted_ToBeModified_ModAckList>(4); }
+		E_RABs_Admitted_ToBeModified_ModAckList const* get_id_E_RABs_Admitted_ToBeModified_ModAckList() const { return get<E_RABs_Admitted_ToBeModified_ModAckList>(4); }
+		E_RABs_Admitted_ToBeReleased_ModAckList& select_id_E_RABs_Admitted_ToBeReleased_ModAckList() { return set<E_RABs_Admitted_ToBeReleased_ModAckList>(5); }
+		E_RABs_Admitted_ToBeReleased_ModAckList const* get_id_E_RABs_Admitted_ToBeReleased_ModAckList() const { return get<E_RABs_Admitted_ToBeReleased_ModAckList>(5); }
+		E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(6); }
+		E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(6); }
+		SeNBtoMeNBContainer& select_id_SeNBtoMeNBContainer() { return set<SeNBtoMeNBContainer>(7); }
+		SeNBtoMeNBContainer const* get_id_SeNBtoMeNBContainer() const { return get<SeNBtoMeNBContainer>(7); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(8); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(8); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
+		bool is_unknown() const { return type == 11; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<E_RABs_Admitted_ToBeAdded_ModAckList>(); break;
+			case 4: var.destroy<E_RABs_Admitted_ToBeModified_ModAckList>(); break;
+			case 5: var.destroy<E_RABs_Admitted_ToBeReleased_ModAckList>(); break;
+			case 6: var.destroy<E_RAB_List>(); break;
+			case 7: var.destroy<SeNBtoMeNBContainer>(); break;
+			case 8: var.destroy<CriticalityDiagnostics>(); break;
+			case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<E_RABs_Admitted_ToBeAdded_ModAckList>(3);
+			v.template operator()<E_RABs_Admitted_ToBeModified_ModAckList>(4);
+			v.template operator()<E_RABs_Admitted_ToBeReleased_ModAckList>(5);
+			v.template operator()<E_RAB_List>(6);
+			v.template operator()<SeNBtoMeNBContainer>(7);
+			v.template operator()<CriticalityDiagnostics>(8);
+			v.template operator()<UE_X2AP_ID_Extension>(9);
+			v.template operator()<UE_X2AP_ID_Extension>(10);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_E_RABs_Admitted_ToBeAdded_ModAckList()); return true;
+			case 4: v(select_id_E_RABs_Admitted_ToBeModified_ModAckList()); return true;
+			case 5: v(select_id_E_RABs_Admitted_ToBeReleased_ModAckList()); return true;
+			case 6: v(select_id_E_RABs_NotAdmitted_List()); return true;
+			case 7: v(select_id_SeNBtoMeNBContainer()); return true;
+			case 8: v(select_id_CriticalityDiagnostics()); return true;
+			case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 10: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
+			case 11: if(type != 11) {clear(); asn::base::set();} type = 11; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<E_RABs_Admitted_ToBeAdded_ModAckList>()); return true;
+			case 4: v(var.as<E_RABs_Admitted_ToBeModified_ModAckList>()); return true;
+			case 5: v(var.as<E_RABs_Admitted_ToBeReleased_ModAckList>()); return true;
+			case 6: v(var.as<E_RAB_List>()); return true;
+			case 7: v(var.as<SeNBtoMeNBContainer>()); return true;
+			case 8: v(var.as<CriticalityDiagnostics>()); return true;
+			case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 10: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(E_RAB_List)];
+			char dummy3[sizeof(E_RABs_Admitted_ToBeAdded_ModAckList)];
+			char dummy4[sizeof(E_RABs_Admitted_ToBeModified_ModAckList)];
+			char dummy5[sizeof(E_RABs_Admitted_ToBeReleased_ModAckList)];
+			char dummy6[sizeof(SeNBtoMeNBContainer)];
+			char dummy7[sizeof(UE_X2AP_ID)];
+			char dummy8[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 11; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_E_RABs_Admitted_ToBeAdded_ModAckList() { set(optional); type=3;}
+		void select_id_E_RABs_Admitted_ToBeModified_ModAckList() { set(optional); type=4;}
+		void select_id_E_RABs_Admitted_ToBeReleased_ModAckList() { set(optional); type=5;}
+		void select_id_E_RABs_NotAdmitted_List() { set(optional); type=6;}
+		void select_id_SeNBtoMeNBContainer() { set(optional); type=7;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
+		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 if(equal(mandatory)) { 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 if(equal(optional)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SeNBModificationRequestAcknowledge ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SeNBModificationRequestAcknowledge-IEs}},
+	...
+}
+*/
+
+struct SeNBModificationRequestAcknowledge : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBModificationRequestAcknowledge";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRequestAcknowledge_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBModificationRequestAcknowledge_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SeNBModificationRequestReject-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY ignore	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID						CRITICALITY ignore	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-Cause								CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics				CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY ignore	TYPE UE-X2AP-ID-Extension		PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension			CRITICALITY ignore	TYPE UE-X2AP-ID-Extension		PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBModificationRequestReject_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=6;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
+		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 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 { 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
+		bool is_unknown() const { return type == 7; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+			v.template operator()<UE_X2AP_ID_Extension>(6);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); return true;
+			case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: v(select_id_SeNB_UE_X2AP_ID_Extension()); 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 6: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+SeNBModificationRequestReject ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SeNBModificationRequestReject-IEs}},
+	...
+}
+*/
+
+struct SeNBModificationRequestReject : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBModificationRequestReject";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRequestReject_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBModificationRequestReject_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SeNBModificationRequired-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID							PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID							PRESENCE mandatory}|
+	{ ID id-Cause								CRITICALITY ignore	TYPE Cause								PRESENCE mandatory}|
+	{ ID id-SCGChangeIndication					CRITICALITY ignore	TYPE SCGChangeIndication				PRESENCE optional}|
+	{ ID id-E-RABs-ToBeReleased-ModReqd			CRITICALITY ignore	TYPE E-RABs-ToBeReleased-ModReqd		PRESENCE optional}|
+	{ ID id-SeNBtoMeNBContainer					CRITICALITY ignore	TYPE SeNBtoMeNBContainer				PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension				PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension				PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBModificationRequired_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 9; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_SCGChangeIndication() { set(id_SCGChangeIndication); type=4;}
+		void select_id_E_RABs_ToBeReleased_ModReqd() { set(id_E_RABs_ToBeReleased_ModReqd); type=5;}
+		void select_id_SeNBtoMeNBContainer() { set(id_SeNBtoMeNBContainer); type=6;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=7;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=8;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_SCGChangeIndication)) { type = 4; return true; }
+			else if(equal(id_E_RABs_ToBeReleased_ModReqd)) { type = 5; return true; }
+			else if(equal(id_SeNBtoMeNBContainer)) { type = 6; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 8; return true; }
+			else { type = 9; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_SCGChangeIndication);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_ModReqd);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNBtoMeNBContainer);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
+			case 9: type = 9; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 9; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_SCGChangeIndication() { set(ignore); type=4;}
+		void select_id_E_RABs_ToBeReleased_ModReqd() { set(ignore); type=5;}
+		void select_id_SeNBtoMeNBContainer() { set(ignore); type=6;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=7;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=8;}
+		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 if(equal(reject)) { 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(reject)) { type = 7; return true; }
+			else if(equal(reject)) { type = 8; return true; }
+			else { type = 9; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(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(reject);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
+			case 9: type = 9; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		SCGChangeIndication& select_id_SCGChangeIndication() { return set<SCGChangeIndication>(4); }
+		SCGChangeIndication const* get_id_SCGChangeIndication() const { return get<SCGChangeIndication>(4); }
+		E_RABs_ToBeReleased_ModReqd& select_id_E_RABs_ToBeReleased_ModReqd() { return set<E_RABs_ToBeReleased_ModReqd>(5); }
+		E_RABs_ToBeReleased_ModReqd const* get_id_E_RABs_ToBeReleased_ModReqd() const { return get<E_RABs_ToBeReleased_ModReqd>(5); }
+		SeNBtoMeNBContainer& select_id_SeNBtoMeNBContainer() { return set<SeNBtoMeNBContainer>(6); }
+		SeNBtoMeNBContainer const* get_id_SeNBtoMeNBContainer() const { return get<SeNBtoMeNBContainer>(6); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(8); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(8); }
+		bool is_unknown() const { return type == 9; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<SCGChangeIndication>(); break;
+			case 5: var.destroy<E_RABs_ToBeReleased_ModReqd>(); break;
+			case 6: var.destroy<SeNBtoMeNBContainer>(); break;
+			case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 8: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<SCGChangeIndication>(4);
+			v.template operator()<E_RABs_ToBeReleased_ModReqd>(5);
+			v.template operator()<SeNBtoMeNBContainer>(6);
+			v.template operator()<UE_X2AP_ID_Extension>(7);
+			v.template operator()<UE_X2AP_ID_Extension>(8);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_SCGChangeIndication()); return true;
+			case 5: v(select_id_E_RABs_ToBeReleased_ModReqd()); return true;
+			case 6: v(select_id_SeNBtoMeNBContainer()); return true;
+			case 7: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 8: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
+			case 9: if(type != 9) {clear(); asn::base::set();} type = 9; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<SCGChangeIndication>()); return true;
+			case 5: v(var.as<E_RABs_ToBeReleased_ModReqd>()); return true;
+			case 6: v(var.as<SeNBtoMeNBContainer>()); return true;
+			case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 8: v(var.as<UE_X2AP_ID_Extension>()); 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(E_RABs_ToBeReleased_ModReqd)];
+			char dummy3[sizeof(SCGChangeIndication)];
+			char dummy4[sizeof(SeNBtoMeNBContainer)];
+			char dummy5[sizeof(UE_X2AP_ID)];
+			char dummy6[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 9; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_SCGChangeIndication() { set(optional); type=4;}
+		void select_id_E_RABs_ToBeReleased_ModReqd() { set(optional); type=5;}
+		void select_id_SeNBtoMeNBContainer() { set(optional); type=6;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=8;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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 { type = 9; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SeNBModificationRequired ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{SeNBModificationRequired-IEs}},
+	...
+}
+*/
+
+struct SeNBModificationRequired : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBModificationRequired";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRequired_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBModificationRequired_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SeNBReconfigurationComplete-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID							CRITICALITY reject	TYPE UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID							CRITICALITY reject	TYPE UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-ResponseInformationSeNBReconfComp		CRITICALITY ignore	TYPE ResponseInformationSeNBReconfComp	PRESENCE mandatory}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension				CRITICALITY reject	TYPE UE-X2AP-ID-Extension						PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension				CRITICALITY reject	TYPE UE-X2AP-ID-Extension						PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBReconfigurationComplete_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
+		void select_id_ResponseInformationSeNBReconfComp() { set(id_ResponseInformationSeNBReconfComp); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=5;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_ResponseInformationSeNBReconfComp)) { type = 3; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_ResponseInformationSeNBReconfComp);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_ResponseInformationSeNBReconfComp() { set(ignore); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(reject)) { type = 4; return true; }
+			else if(equal(reject)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(ignore);} 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(reject);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		ResponseInformationSeNBReconfComp& select_id_ResponseInformationSeNBReconfComp() { return set<ResponseInformationSeNBReconfComp>(3); }
+		ResponseInformationSeNBReconfComp const* get_id_ResponseInformationSeNBReconfComp() const { return get<ResponseInformationSeNBReconfComp>(3); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<ResponseInformationSeNBReconfComp>(); break;
+			case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<ResponseInformationSeNBReconfComp>(3);
+			v.template operator()<UE_X2AP_ID_Extension>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_ResponseInformationSeNBReconfComp()); return true;
+			case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 5: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<ResponseInformationSeNBReconfComp>()); return true;
+			case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); 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(ResponseInformationSeNBReconfComp)];
+			char dummy2[sizeof(UE_X2AP_ID)];
+			char dummy3[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_ResponseInformationSeNBReconfComp() { set(mandatory); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SeNBReconfigurationComplete ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SeNBReconfigurationComplete-IEs}},
+	...
+}
+*/
+
+struct SeNBReconfigurationComplete : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBReconfigurationComplete";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBReconfigurationComplete_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBReconfigurationComplete_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SeNBReleaseConfirm-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID							CRITICALITY ignore	TYPE UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID							CRITICALITY ignore	TYPE UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-E-RABs-ToBeReleased-List-RelConf		CRITICALITY ignore	TYPE E-RABs-ToBeReleased-List-RelConf		PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics					CRITICALITY ignore	TYPE CriticalityDiagnostics					PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension				CRITICALITY ignore	TYPE UE-X2AP-ID-Extension						PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension				CRITICALITY ignore	TYPE UE-X2AP-ID-Extension						PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBReleaseConfirm_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
+		void select_id_E_RABs_ToBeReleased_List_RelConf() { set(id_E_RABs_ToBeReleased_List_RelConf); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=6;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_E_RABs_ToBeReleased_List_RelConf)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_List_RelConf);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_E_RABs_ToBeReleased_List_RelConf() { set(ignore); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
+		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 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 { 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		E_RABs_ToBeReleased_List_RelConf& select_id_E_RABs_ToBeReleased_List_RelConf() { return set<E_RABs_ToBeReleased_List_RelConf>(3); }
+		E_RABs_ToBeReleased_List_RelConf const* get_id_E_RABs_ToBeReleased_List_RelConf() const { return get<E_RABs_ToBeReleased_List_RelConf>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
+		bool is_unknown() const { return type == 7; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<E_RABs_ToBeReleased_List_RelConf>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<E_RABs_ToBeReleased_List_RelConf>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+			v.template operator()<UE_X2AP_ID_Extension>(6);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_E_RABs_ToBeReleased_List_RelConf()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); return true;
+			case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: v(select_id_SeNB_UE_X2AP_ID_Extension()); 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<E_RABs_ToBeReleased_List_RelConf>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 6: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(E_RABs_ToBeReleased_List_RelConf)];
+			char dummy3[sizeof(UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_E_RABs_ToBeReleased_List_RelConf() { set(optional); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+SeNBReleaseConfirm ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SeNBReleaseConfirm-IEs}},
+	...
+}
+*/
+
+struct SeNBReleaseConfirm : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBReleaseConfirm";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBReleaseConfirm_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBReleaseConfirm_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SeNBReleaseRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID									PRESENCE optional}|
+	{ ID id-Cause								CRITICALITY ignore	TYPE Cause										PRESENCE optional}|
+	{ ID id-E-RABs-ToBeReleased-List-RelReq		CRITICALITY ignore	TYPE E-RABs-ToBeReleased-List-RelReq		PRESENCE optional}|
+	{ ID id-UE-ContextKeptIndicator				CRITICALITY ignore	TYPE UE-ContextKeptIndicator					PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension						PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension						PRESENCE optional}|
+	{ ID id-MakeBeforeBreakIndicator			CRITICALITY ignore	TYPE MakeBeforeBreakIndicator					PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBReleaseRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 9; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_E_RABs_ToBeReleased_List_RelReq() { set(id_E_RABs_ToBeReleased_List_RelReq); type=4;}
+		void select_id_UE_ContextKeptIndicator() { set(id_UE_ContextKeptIndicator); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=7;}
+		void select_id_MakeBeforeBreakIndicator() { set(id_MakeBeforeBreakIndicator); type=8;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_E_RABs_ToBeReleased_List_RelReq)) { type = 4; return true; }
+			else if(equal(id_UE_ContextKeptIndicator)) { type = 5; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
+			else if(equal(id_MakeBeforeBreakIndicator)) { type = 8; return true; }
+			else { type = 9; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_List_RelReq);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_UE_ContextKeptIndicator);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_MakeBeforeBreakIndicator);} return false;
+			case 9: type = 9; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 9; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_E_RABs_ToBeReleased_List_RelReq() { set(ignore); type=4;}
+		void select_id_UE_ContextKeptIndicator() { set(ignore); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=6;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=7;}
+		void select_id_MakeBeforeBreakIndicator() { set(ignore); type=8;}
+		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 if(equal(reject)) { 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(reject)) { type = 6; return true; }
+			else if(equal(reject)) { type = 7; return true; }
+			else if(equal(ignore)) { type = 8; return true; }
+			else { type = 9; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(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(reject);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 9: type = 9; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		E_RABs_ToBeReleased_List_RelReq& select_id_E_RABs_ToBeReleased_List_RelReq() { return set<E_RABs_ToBeReleased_List_RelReq>(4); }
+		E_RABs_ToBeReleased_List_RelReq const* get_id_E_RABs_ToBeReleased_List_RelReq() const { return get<E_RABs_ToBeReleased_List_RelReq>(4); }
+		UE_ContextKeptIndicator& select_id_UE_ContextKeptIndicator() { return set<UE_ContextKeptIndicator>(5); }
+		UE_ContextKeptIndicator const* get_id_UE_ContextKeptIndicator() const { return get<UE_ContextKeptIndicator>(5); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
+		MakeBeforeBreakIndicator& select_id_MakeBeforeBreakIndicator() { return set<MakeBeforeBreakIndicator>(8); }
+		MakeBeforeBreakIndicator const* get_id_MakeBeforeBreakIndicator() const { return get<MakeBeforeBreakIndicator>(8); }
+		bool is_unknown() const { return type == 9; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<E_RABs_ToBeReleased_List_RelReq>(); break;
+			case 5: var.destroy<UE_ContextKeptIndicator>(); break;
+			case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 8: var.destroy<MakeBeforeBreakIndicator>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<E_RABs_ToBeReleased_List_RelReq>(4);
+			v.template operator()<UE_ContextKeptIndicator>(5);
+			v.template operator()<UE_X2AP_ID_Extension>(6);
+			v.template operator()<UE_X2AP_ID_Extension>(7);
+			v.template operator()<MakeBeforeBreakIndicator>(8);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_E_RABs_ToBeReleased_List_RelReq()); return true;
+			case 5: v(select_id_UE_ContextKeptIndicator()); return true;
+			case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 7: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
+			case 8: v(select_id_MakeBeforeBreakIndicator()); return true;
+			case 9: if(type != 9) {clear(); asn::base::set();} type = 9; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<E_RABs_ToBeReleased_List_RelReq>()); return true;
+			case 5: v(var.as<UE_ContextKeptIndicator>()); return true;
+			case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 8: v(var.as<MakeBeforeBreakIndicator>()); 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(E_RABs_ToBeReleased_List_RelReq)];
+			char dummy3[sizeof(MakeBeforeBreakIndicator)];
+			char dummy4[sizeof(UE_ContextKeptIndicator)];
+			char dummy5[sizeof(UE_X2AP_ID)];
+			char dummy6[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 9; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(optional); type=2;}
+		void select_id_Cause() { set(optional); type=3;}
+		void select_id_E_RABs_ToBeReleased_List_RelReq() { set(optional); type=4;}
+		void select_id_UE_ContextKeptIndicator() { set(optional); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
+		void select_id_MakeBeforeBreakIndicator() { set(optional); type=8;}
+		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 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 { type = 9; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SeNBReleaseRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{SeNBReleaseRequest-IEs}},
+	...
+}
+*/
+
+struct SeNBReleaseRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBReleaseRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBReleaseRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBReleaseRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SeNBReleaseRequired-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID					CRITICALITY reject	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-SeNB-UE-X2AP-ID					CRITICALITY reject	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-Cause							CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension		CRITICALITY reject	TYPE UE-X2AP-ID-Extension		PRESENCE optional}|
+	{ ID id-SeNB-UE-X2AP-ID-Extension		CRITICALITY reject	TYPE UE-X2AP-ID-Extension		PRESENCE optional},
+	...
+}
+*/
+
+struct SeNBReleaseRequired_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=5;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
+			else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(reject)) { type = 4; return true; }
+			else if(equal(reject)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(ignore);} 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(reject);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<UE_X2AP_ID_Extension>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 5: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); 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(UE_X2AP_ID)];
+			char dummy3[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
+		void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SeNBReleaseRequired ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SeNBReleaseRequired-IEs}},
+	...
+}
+*/
+
+struct SeNBReleaseRequired : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SeNBReleaseRequired";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SeNBReleaseRequired_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SeNBReleaseRequired_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SecondaryRATDataUsageReport-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID								PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID						CRITICALITY reject	TYPE SgNB-UE-X2AP-ID							PRESENCE mandatory}|
+	{ ID id-SecondaryRATUsageReportList			CRITICALITY reject	TYPE SecondaryRATUsageReportList			PRESENCE mandatory}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension					PRESENCE optional},
+	...
+}
+*/
+
+struct SecondaryRATDataUsageReport_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_SecondaryRATUsageReportList() { set(id_SecondaryRATUsageReportList); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_SecondaryRATUsageReportList)) { type = 3; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_SecondaryRATUsageReportList);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_SecondaryRATUsageReportList() { set(reject); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(reject)) { type = 3; return true; }
+			else if(equal(reject)) { 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		SecondaryRATUsageReportList& select_id_SecondaryRATUsageReportList() { return set<SecondaryRATUsageReportList>(3); }
+		SecondaryRATUsageReportList const* get_id_SecondaryRATUsageReportList() const { return get<SecondaryRATUsageReportList>(3); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
+		bool is_unknown() const { return type == 5; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<SecondaryRATUsageReportList>(); break;
+			case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<SecondaryRATUsageReportList>(3);
+			v.template operator()<UE_X2AP_ID_Extension>(4);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_SecondaryRATUsageReportList()); return true;
+			case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<SecondaryRATUsageReportList>()); return true;
+			case 4: v(var.as<UE_X2AP_ID_Extension>()); 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(SecondaryRATUsageReportList)];
+			char dummy2[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy3[sizeof(UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 5; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_SecondaryRATUsageReportList() { set(mandatory); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+SecondaryRATDataUsageReport ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{SecondaryRATDataUsageReport-IEs}},
+	...
+}
+*/
+
+struct SecondaryRATDataUsageReport : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SecondaryRATDataUsageReport";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SecondaryRATDataUsageReport_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SecondaryRATDataUsageReport_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBActivityNotification-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID								PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID						CRITICALITY reject	TYPE SgNB-UE-X2AP-ID							PRESENCE mandatory}|
+	{ ID id-UEContextLevelUserPlaneActivity		CRITICALITY ignore	TYPE UserPlaneTrafficActivityReport		PRESENCE optional}|
+	{ ID id-ERABActivityNotifyItemList			CRITICALITY ignore	TYPE ERABActivityNotifyItemList			PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension					PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBActivityNotification_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_UEContextLevelUserPlaneActivity() { set(id_UEContextLevelUserPlaneActivity); type=3;}
+		void select_id_ERABActivityNotifyItemList() { set(id_ERABActivityNotifyItemList); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_UEContextLevelUserPlaneActivity)) { type = 3; return true; }
+			else if(equal(id_ERABActivityNotifyItemList)) { type = 4; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_UEContextLevelUserPlaneActivity);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_ERABActivityNotifyItemList);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_UEContextLevelUserPlaneActivity() { set(ignore); type=3;}
+		void select_id_ERABActivityNotifyItemList() { set(ignore); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(ignore)) { type = 4; return true; }
+			else if(equal(reject)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(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(reject);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		UserPlaneTrafficActivityReport& select_id_UEContextLevelUserPlaneActivity() { return set<UserPlaneTrafficActivityReport>(3); }
+		UserPlaneTrafficActivityReport const* get_id_UEContextLevelUserPlaneActivity() const { return get<UserPlaneTrafficActivityReport>(3); }
+		ERABActivityNotifyItemList& select_id_ERABActivityNotifyItemList() { return set<ERABActivityNotifyItemList>(4); }
+		ERABActivityNotifyItemList const* get_id_ERABActivityNotifyItemList() const { return get<ERABActivityNotifyItemList>(4); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<UserPlaneTrafficActivityReport>(); break;
+			case 4: var.destroy<ERABActivityNotifyItemList>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<UserPlaneTrafficActivityReport>(3);
+			v.template operator()<ERABActivityNotifyItemList>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_UEContextLevelUserPlaneActivity()); return true;
+			case 4: v(select_id_ERABActivityNotifyItemList()); return true;
+			case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<UserPlaneTrafficActivityReport>()); return true;
+			case 4: v(var.as<ERABActivityNotifyItemList>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); 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(ERABActivityNotifyItemList)];
+			char dummy2[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy3[sizeof(UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID_Extension)];
+			char dummy5[sizeof(UserPlaneTrafficActivityReport)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_UEContextLevelUserPlaneActivity() { set(optional); type=3;}
+		void select_id_ERABActivityNotifyItemList() { set(optional); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		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 if(equal(mandatory)) { 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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBActivityNotification ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{SgNBActivityNotification-IEs}},
+	...
+}
+*/
+
+struct SgNBActivityNotification : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBActivityNotification";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBActivityNotification_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBActivityNotification_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBAdditionRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID							CRITICALITY reject	TYPE UE-X2AP-ID										PRESENCE mandatory}|
+	{ ID id-NRUESecurityCapabilities					CRITICALITY reject	TYPE NRUESecurityCapabilities					PRESENCE mandatory}|
+	{ ID id-SgNBSecurityKey							CRITICALITY reject	TYPE SgNBSecurityKey									PRESENCE mandatory}|
+	{ ID id-SgNBUEAggregateMaximumBitRate			CRITICALITY reject	TYPE UEAggregateMaximumBitRate					PRESENCE mandatory}|
+	{ ID id-SelectedPLMN								CRITICALITY ignore	TYPE PLMN-Identity									PRESENCE optional}|
+	{ ID id-HandoverRestrictionList					CRITICALITY ignore	TYPE HandoverRestrictionList						PRESENCE optional}|
+	{ ID id-E-RABs-ToBeAdded-SgNBAddReqList			CRITICALITY reject	TYPE E-RABs-ToBeAdded-SgNBAddReqList			PRESENCE mandatory}|
+	{ ID id-MeNBtoSgNBContainer						CRITICALITY reject	TYPE MeNBtoSgNBContainer								PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID							CRITICALITY reject	TYPE SgNB-UE-X2AP-ID									PRESENCE optional}|
+	{ ID id-ExpectedUEBehaviour						CRITICALITY ignore	TYPE ExpectedUEBehaviour								PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension				CRITICALITY reject	TYPE UE-X2AP-ID-Extension							PRESENCE optional}|
+	{ ID id-RequestedSplitSRBs						CRITICALITY reject	TYPE SplitSRBs										PRESENCE optional}|
+	{ ID id-MeNBResourceCoordinationInformation		CRITICALITY ignore	TYPE MeNBResourceCoordinationInformation		PRESENCE optional}|
+	{ ID id-SGNB-Addition-Trigger-Ind				CRITICALITY reject	TYPE SGNB-Addition-Trigger-Ind					PRESENCE optional}|
+	{ ID id-SubscriberProfileIDforRFP				CRITICALITY ignore	TYPE SubscriberProfileIDforRFP					PRESENCE optional}|
+	{ ID id-MeNBCell-ID								CRITICALITY reject	TYPE ECGI											PRESENCE mandatory},
+	...
+}
+*/
+
+struct SgNBAdditionRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 17; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_NRUESecurityCapabilities() { set(id_NRUESecurityCapabilities); type=2;}
+		void select_id_SgNBSecurityKey() { set(id_SgNBSecurityKey); type=3;}
+		void select_id_SgNBUEAggregateMaximumBitRate() { set(id_SgNBUEAggregateMaximumBitRate); type=4;}
+		void select_id_SelectedPLMN() { set(id_SelectedPLMN); type=5;}
+		void select_id_HandoverRestrictionList() { set(id_HandoverRestrictionList); type=6;}
+		void select_id_E_RABs_ToBeAdded_SgNBAddReqList() { set(id_E_RABs_ToBeAdded_SgNBAddReqList); type=7;}
+		void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=8;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=9;}
+		void select_id_ExpectedUEBehaviour() { set(id_ExpectedUEBehaviour); type=10;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=11;}
+		void select_id_RequestedSplitSRBs() { set(id_RequestedSplitSRBs); type=12;}
+		void select_id_MeNBResourceCoordinationInformation() { set(id_MeNBResourceCoordinationInformation); type=13;}
+		void select_id_SGNB_Addition_Trigger_Ind() { set(id_SGNB_Addition_Trigger_Ind); type=14;}
+		void select_id_SubscriberProfileIDforRFP() { set(id_SubscriberProfileIDforRFP); type=15;}
+		void select_id_MeNBCell_ID() { set(id_MeNBCell_ID); type=16;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_NRUESecurityCapabilities)) { type = 2; return true; }
+			else if(equal(id_SgNBSecurityKey)) { type = 3; return true; }
+			else if(equal(id_SgNBUEAggregateMaximumBitRate)) { type = 4; return true; }
+			else if(equal(id_SelectedPLMN)) { type = 5; return true; }
+			else if(equal(id_HandoverRestrictionList)) { type = 6; return true; }
+			else if(equal(id_E_RABs_ToBeAdded_SgNBAddReqList)) { type = 7; return true; }
+			else if(equal(id_MeNBtoSgNBContainer)) { type = 8; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 9; return true; }
+			else if(equal(id_ExpectedUEBehaviour)) { type = 10; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 11; return true; }
+			else if(equal(id_RequestedSplitSRBs)) { type = 12; return true; }
+			else if(equal(id_MeNBResourceCoordinationInformation)) { type = 13; return true; }
+			else if(equal(id_SGNB_Addition_Trigger_Ind)) { type = 14; return true; }
+			else if(equal(id_SubscriberProfileIDforRFP)) { type = 15; return true; }
+			else if(equal(id_MeNBCell_ID)) { type = 16; return true; }
+			else { type = 17; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_NRUESecurityCapabilities);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_SgNBSecurityKey);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_SgNBUEAggregateMaximumBitRate);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_SelectedPLMN);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_HandoverRestrictionList);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_SgNBAddReqList);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(id_ExpectedUEBehaviour);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(id_RequestedSplitSRBs);} return false;
+			case 13: type = 13; if(v(ref_nested())) { return equal(id_MeNBResourceCoordinationInformation);} return false;
+			case 14: type = 14; if(v(ref_nested())) { return equal(id_SGNB_Addition_Trigger_Ind);} return false;
+			case 15: type = 15; if(v(ref_nested())) { return equal(id_SubscriberProfileIDforRFP);} return false;
+			case 16: type = 16; if(v(ref_nested())) { return equal(id_MeNBCell_ID);} return false;
+			case 17: type = 17; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 17; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_NRUESecurityCapabilities() { set(reject); type=2;}
+		void select_id_SgNBSecurityKey() { set(reject); type=3;}
+		void select_id_SgNBUEAggregateMaximumBitRate() { set(reject); type=4;}
+		void select_id_SelectedPLMN() { set(ignore); type=5;}
+		void select_id_HandoverRestrictionList() { set(ignore); type=6;}
+		void select_id_E_RABs_ToBeAdded_SgNBAddReqList() { set(reject); type=7;}
+		void select_id_MeNBtoSgNBContainer() { set(reject); type=8;}
+		void select_id_SgNB_UE_X2AP_ID() { set(reject); type=9;}
+		void select_id_ExpectedUEBehaviour() { set(ignore); type=10;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=11;}
+		void select_id_RequestedSplitSRBs() { set(reject); type=12;}
+		void select_id_MeNBResourceCoordinationInformation() { set(ignore); type=13;}
+		void select_id_SGNB_Addition_Trigger_Ind() { set(reject); type=14;}
+		void select_id_SubscriberProfileIDforRFP() { set(ignore); type=15;}
+		void select_id_MeNBCell_ID() { set(reject); type=16;}
+		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 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 if(equal(reject)) { type = 7; return true; }
+			else if(equal(reject)) { type = 8; return true; }
+			else if(equal(reject)) { type = 9; return true; }
+			else if(equal(ignore)) { type = 10; return true; }
+			else if(equal(reject)) { type = 11; return true; }
+			else if(equal(reject)) { type = 12; return true; }
+			else if(equal(ignore)) { type = 13; return true; }
+			else if(equal(reject)) { type = 14; return true; }
+			else if(equal(ignore)) { type = 15; return true; }
+			else if(equal(reject)) { type = 16; return true; }
+			else { type = 17; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(reject);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(reject);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(reject);} return false;
+			case 13: type = 13; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 14: type = 14; if(v(ref_nested())) { return equal(reject);} return false;
+			case 15: type = 15; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 16: type = 16; if(v(ref_nested())) { return equal(reject);} return false;
+			case 17: type = 17; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		NRUESecurityCapabilities& select_id_NRUESecurityCapabilities() { return set<NRUESecurityCapabilities>(2); }
+		NRUESecurityCapabilities const* get_id_NRUESecurityCapabilities() const { return get<NRUESecurityCapabilities>(2); }
+		SgNBSecurityKey& select_id_SgNBSecurityKey() { return set<SgNBSecurityKey>(3); }
+		SgNBSecurityKey const* get_id_SgNBSecurityKey() const { return get<SgNBSecurityKey>(3); }
+		UEAggregateMaximumBitRate& select_id_SgNBUEAggregateMaximumBitRate() { return set<UEAggregateMaximumBitRate>(4); }
+		UEAggregateMaximumBitRate const* get_id_SgNBUEAggregateMaximumBitRate() const { return get<UEAggregateMaximumBitRate>(4); }
+		PLMN_Identity& select_id_SelectedPLMN() { return set<PLMN_Identity>(5); }
+		PLMN_Identity const* get_id_SelectedPLMN() const { return get<PLMN_Identity>(5); }
+		HandoverRestrictionList& select_id_HandoverRestrictionList() { return set<HandoverRestrictionList>(6); }
+		HandoverRestrictionList const* get_id_HandoverRestrictionList() const { return get<HandoverRestrictionList>(6); }
+		E_RABs_ToBeAdded_SgNBAddReqList& select_id_E_RABs_ToBeAdded_SgNBAddReqList() { return set<E_RABs_ToBeAdded_SgNBAddReqList>(7); }
+		E_RABs_ToBeAdded_SgNBAddReqList const* get_id_E_RABs_ToBeAdded_SgNBAddReqList() const { return get<E_RABs_ToBeAdded_SgNBAddReqList>(7); }
+		MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(8); }
+		MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(8); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(9); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(9); }
+		ExpectedUEBehaviour& select_id_ExpectedUEBehaviour() { return set<ExpectedUEBehaviour>(10); }
+		ExpectedUEBehaviour const* get_id_ExpectedUEBehaviour() const { return get<ExpectedUEBehaviour>(10); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(11); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(11); }
+		SplitSRBs& select_id_RequestedSplitSRBs() { return set<SplitSRBs>(12); }
+		SplitSRBs const* get_id_RequestedSplitSRBs() const { return get<SplitSRBs>(12); }
+		MeNBResourceCoordinationInformation& select_id_MeNBResourceCoordinationInformation() { return set<MeNBResourceCoordinationInformation>(13); }
+		MeNBResourceCoordinationInformation const* get_id_MeNBResourceCoordinationInformation() const { return get<MeNBResourceCoordinationInformation>(13); }
+		SGNB_Addition_Trigger_Ind& select_id_SGNB_Addition_Trigger_Ind() { return set<SGNB_Addition_Trigger_Ind>(14); }
+		SGNB_Addition_Trigger_Ind const* get_id_SGNB_Addition_Trigger_Ind() const { return get<SGNB_Addition_Trigger_Ind>(14); }
+		SubscriberProfileIDforRFP& select_id_SubscriberProfileIDforRFP() { return set<SubscriberProfileIDforRFP>(15); }
+		SubscriberProfileIDforRFP const* get_id_SubscriberProfileIDforRFP() const { return get<SubscriberProfileIDforRFP>(15); }
+		ECGI& select_id_MeNBCell_ID() { return set<ECGI>(16); }
+		ECGI const* get_id_MeNBCell_ID() const { return get<ECGI>(16); }
+		bool is_unknown() const { return type == 17; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<NRUESecurityCapabilities>(); break;
+			case 3: var.destroy<SgNBSecurityKey>(); break;
+			case 4: var.destroy<UEAggregateMaximumBitRate>(); break;
+			case 5: var.destroy<PLMN_Identity>(); break;
+			case 6: var.destroy<HandoverRestrictionList>(); break;
+			case 7: var.destroy<E_RABs_ToBeAdded_SgNBAddReqList>(); break;
+			case 8: var.destroy<MeNBtoSgNBContainer>(); break;
+			case 9: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 10: var.destroy<ExpectedUEBehaviour>(); break;
+			case 11: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 12: var.destroy<SplitSRBs>(); break;
+			case 13: var.destroy<MeNBResourceCoordinationInformation>(); break;
+			case 14: var.destroy<SGNB_Addition_Trigger_Ind>(); break;
+			case 15: var.destroy<SubscriberProfileIDforRFP>(); break;
+			case 16: var.destroy<ECGI>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<NRUESecurityCapabilities>(2);
+			v.template operator()<SgNBSecurityKey>(3);
+			v.template operator()<UEAggregateMaximumBitRate>(4);
+			v.template operator()<PLMN_Identity>(5);
+			v.template operator()<HandoverRestrictionList>(6);
+			v.template operator()<E_RABs_ToBeAdded_SgNBAddReqList>(7);
+			v.template operator()<MeNBtoSgNBContainer>(8);
+			v.template operator()<SgNB_UE_X2AP_ID>(9);
+			v.template operator()<ExpectedUEBehaviour>(10);
+			v.template operator()<UE_X2AP_ID_Extension>(11);
+			v.template operator()<SplitSRBs>(12);
+			v.template operator()<MeNBResourceCoordinationInformation>(13);
+			v.template operator()<SGNB_Addition_Trigger_Ind>(14);
+			v.template operator()<SubscriberProfileIDforRFP>(15);
+			v.template operator()<ECGI>(16);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_NRUESecurityCapabilities()); return true;
+			case 3: v(select_id_SgNBSecurityKey()); return true;
+			case 4: v(select_id_SgNBUEAggregateMaximumBitRate()); return true;
+			case 5: v(select_id_SelectedPLMN()); return true;
+			case 6: v(select_id_HandoverRestrictionList()); return true;
+			case 7: v(select_id_E_RABs_ToBeAdded_SgNBAddReqList()); return true;
+			case 8: v(select_id_MeNBtoSgNBContainer()); return true;
+			case 9: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 10: v(select_id_ExpectedUEBehaviour()); return true;
+			case 11: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 12: v(select_id_RequestedSplitSRBs()); return true;
+			case 13: v(select_id_MeNBResourceCoordinationInformation()); return true;
+			case 14: v(select_id_SGNB_Addition_Trigger_Ind()); return true;
+			case 15: v(select_id_SubscriberProfileIDforRFP()); return true;
+			case 16: v(select_id_MeNBCell_ID()); return true;
+			case 17: if(type != 17) {clear(); asn::base::set();} type = 17; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<NRUESecurityCapabilities>()); return true;
+			case 3: v(var.as<SgNBSecurityKey>()); return true;
+			case 4: v(var.as<UEAggregateMaximumBitRate>()); return true;
+			case 5: v(var.as<PLMN_Identity>()); return true;
+			case 6: v(var.as<HandoverRestrictionList>()); return true;
+			case 7: v(var.as<E_RABs_ToBeAdded_SgNBAddReqList>()); return true;
+			case 8: v(var.as<MeNBtoSgNBContainer>()); return true;
+			case 9: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 10: v(var.as<ExpectedUEBehaviour>()); return true;
+			case 11: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 12: v(var.as<SplitSRBs>()); return true;
+			case 13: v(var.as<MeNBResourceCoordinationInformation>()); return true;
+			case 14: v(var.as<SGNB_Addition_Trigger_Ind>()); return true;
+			case 15: v(var.as<SubscriberProfileIDforRFP>()); return true;
+			case 16: v(var.as<ECGI>()); 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(E_RABs_ToBeAdded_SgNBAddReqList)];
+			char dummy3[sizeof(ExpectedUEBehaviour)];
+			char dummy4[sizeof(HandoverRestrictionList)];
+			char dummy5[sizeof(MeNBResourceCoordinationInformation)];
+			char dummy6[sizeof(MeNBtoSgNBContainer)];
+			char dummy7[sizeof(NRUESecurityCapabilities)];
+			char dummy8[sizeof(PLMN_Identity)];
+			char dummy9[sizeof(SGNB_Addition_Trigger_Ind)];
+			char dummy10[sizeof(SgNBSecurityKey)];
+			char dummy11[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy12[sizeof(SplitSRBs)];
+			char dummy13[sizeof(SubscriberProfileIDforRFP)];
+			char dummy14[sizeof(UEAggregateMaximumBitRate)];
+			char dummy15[sizeof(UE_X2AP_ID)];
+			char dummy16[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 17; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_NRUESecurityCapabilities() { set(mandatory); type=2;}
+		void select_id_SgNBSecurityKey() { set(mandatory); type=3;}
+		void select_id_SgNBUEAggregateMaximumBitRate() { set(mandatory); type=4;}
+		void select_id_SelectedPLMN() { set(optional); type=5;}
+		void select_id_HandoverRestrictionList() { set(optional); type=6;}
+		void select_id_E_RABs_ToBeAdded_SgNBAddReqList() { set(mandatory); type=7;}
+		void select_id_MeNBtoSgNBContainer() { set(mandatory); type=8;}
+		void select_id_SgNB_UE_X2AP_ID() { set(optional); type=9;}
+		void select_id_ExpectedUEBehaviour() { set(optional); type=10;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=11;}
+		void select_id_RequestedSplitSRBs() { set(optional); type=12;}
+		void select_id_MeNBResourceCoordinationInformation() { set(optional); type=13;}
+		void select_id_SGNB_Addition_Trigger_Ind() { set(optional); type=14;}
+		void select_id_SubscriberProfileIDforRFP() { set(optional); type=15;}
+		void select_id_MeNBCell_ID() { set(mandatory); type=16;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(mandatory)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else if(equal(optional)) { type = 6; return true; }
+			else if(equal(mandatory)) { type = 7; return true; }
+			else if(equal(mandatory)) { type = 8; return true; }
+			else if(equal(optional)) { type = 9; return true; }
+			else if(equal(optional)) { type = 10; return true; }
+			else if(equal(optional)) { type = 11; return true; }
+			else if(equal(optional)) { type = 12; return true; }
+			else if(equal(optional)) { type = 13; return true; }
+			else if(equal(optional)) { type = 14; return true; }
+			else if(equal(optional)) { type = 15; return true; }
+			else if(equal(mandatory)) { type = 16; return true; }
+			else { type = 17; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} 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(mandatory);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
+			case 13: type = 13; if(v(ref_nested())) { return equal(optional);} return false;
+			case 14: type = 14; if(v(ref_nested())) { return equal(optional);} return false;
+			case 15: type = 15; if(v(ref_nested())) { return equal(optional);} return false;
+			case 16: type = 16; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 17: type = 17; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBAdditionRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container {{SgNBAdditionRequest-IEs}},
+	...
+}
+*/
+
+struct SgNBAdditionRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBAdditionRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBAdditionRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBAdditionRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBAdditionRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID								CRITICALITY reject	TYPE UE-X2AP-ID													PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID								CRITICALITY reject	TYPE SgNB-UE-X2AP-ID												PRESENCE mandatory}|
+	{ ID id-E-RABs-Admitted-ToBeAdded-SgNBAddReqAckList	CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeAdded-SgNBAddReqAckList			PRESENCE mandatory}|
+	{ ID id-E-RABs-NotAdmitted-List						CRITICALITY ignore	TYPE E-RAB-List													PRESENCE optional}|
+	{ ID id-SgNBtoMeNBContainer							CRITICALITY reject	TYPE SgNBtoMeNBContainer										PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics						CRITICALITY ignore	TYPE CriticalityDiagnostics									PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension					CRITICALITY reject	TYPE UE-X2AP-ID-Extension									PRESENCE optional}|
+	{ ID id-AdmittedSplitSRBs							CRITICALITY reject	TYPE SplitSRBs													PRESENCE optional}|
+	{ ID id-SgNBResourceCoordinationInformation			CRITICALITY ignore	TYPE SgNBResourceCoordinationInformation				PRESENCE optional}|
+	{ ID id-RRCConfigIndication							CRITICALITY reject	TYPE RRC-Config-Ind												PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBAdditionRequestAcknowledge_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 11; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() { set(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList); type=3;}
+		void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=4;}
+		void select_id_SgNBtoMeNBContainer() { set(id_SgNBtoMeNBContainer); type=5;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=6;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=7;}
+		void select_id_AdmittedSplitSRBs() { set(id_AdmittedSplitSRBs); type=8;}
+		void select_id_SgNBResourceCoordinationInformation() { set(id_SgNBResourceCoordinationInformation); type=9;}
+		void select_id_RRCConfigIndication() { set(id_RRCConfigIndication); type=10;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList)) { type = 3; return true; }
+			else if(equal(id_E_RABs_NotAdmitted_List)) { type = 4; return true; }
+			else if(equal(id_SgNBtoMeNBContainer)) { type = 5; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 6; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
+			else if(equal(id_AdmittedSplitSRBs)) { type = 8; return true; }
+			else if(equal(id_SgNBResourceCoordinationInformation)) { type = 9; return true; }
+			else if(equal(id_RRCConfigIndication)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_SgNBtoMeNBContainer);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_AdmittedSplitSRBs);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_SgNBResourceCoordinationInformation);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(id_RRCConfigIndication);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 11; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() { set(ignore); type=3;}
+		void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=4;}
+		void select_id_SgNBtoMeNBContainer() { set(reject); type=5;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=6;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=7;}
+		void select_id_AdmittedSplitSRBs() { set(reject); type=8;}
+		void select_id_SgNBResourceCoordinationInformation() { set(ignore); type=9;}
+		void select_id_RRCConfigIndication() { set(reject); type=10;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(ignore)) { type = 4; return true; }
+			else if(equal(reject)) { type = 5; return true; }
+			else if(equal(ignore)) { type = 6; return true; }
+			else if(equal(reject)) { type = 7; return true; }
+			else if(equal(reject)) { type = 8; return true; }
+			else if(equal(ignore)) { type = 9; return true; }
+			else if(equal(reject)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(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(reject);} 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(reject);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList& select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() { return set<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>(3); }
+		E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList const* get_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() const { return get<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>(3); }
+		E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(4); }
+		E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(4); }
+		SgNBtoMeNBContainer& select_id_SgNBtoMeNBContainer() { return set<SgNBtoMeNBContainer>(5); }
+		SgNBtoMeNBContainer const* get_id_SgNBtoMeNBContainer() const { return get<SgNBtoMeNBContainer>(5); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(6); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(6); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
+		SplitSRBs& select_id_AdmittedSplitSRBs() { return set<SplitSRBs>(8); }
+		SplitSRBs const* get_id_AdmittedSplitSRBs() const { return get<SplitSRBs>(8); }
+		SgNBResourceCoordinationInformation& select_id_SgNBResourceCoordinationInformation() { return set<SgNBResourceCoordinationInformation>(9); }
+		SgNBResourceCoordinationInformation const* get_id_SgNBResourceCoordinationInformation() const { return get<SgNBResourceCoordinationInformation>(9); }
+		RRC_Config_Ind& select_id_RRCConfigIndication() { return set<RRC_Config_Ind>(10); }
+		RRC_Config_Ind const* get_id_RRCConfigIndication() const { return get<RRC_Config_Ind>(10); }
+		bool is_unknown() const { return type == 11; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>(); break;
+			case 4: var.destroy<E_RAB_List>(); break;
+			case 5: var.destroy<SgNBtoMeNBContainer>(); break;
+			case 6: var.destroy<CriticalityDiagnostics>(); break;
+			case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 8: var.destroy<SplitSRBs>(); break;
+			case 9: var.destroy<SgNBResourceCoordinationInformation>(); break;
+			case 10: var.destroy<RRC_Config_Ind>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>(3);
+			v.template operator()<E_RAB_List>(4);
+			v.template operator()<SgNBtoMeNBContainer>(5);
+			v.template operator()<CriticalityDiagnostics>(6);
+			v.template operator()<UE_X2AP_ID_Extension>(7);
+			v.template operator()<SplitSRBs>(8);
+			v.template operator()<SgNBResourceCoordinationInformation>(9);
+			v.template operator()<RRC_Config_Ind>(10);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList()); return true;
+			case 4: v(select_id_E_RABs_NotAdmitted_List()); return true;
+			case 5: v(select_id_SgNBtoMeNBContainer()); return true;
+			case 6: v(select_id_CriticalityDiagnostics()); return true;
+			case 7: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 8: v(select_id_AdmittedSplitSRBs()); return true;
+			case 9: v(select_id_SgNBResourceCoordinationInformation()); return true;
+			case 10: v(select_id_RRCConfigIndication()); return true;
+			case 11: if(type != 11) {clear(); asn::base::set();} type = 11; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>()); return true;
+			case 4: v(var.as<E_RAB_List>()); return true;
+			case 5: v(var.as<SgNBtoMeNBContainer>()); return true;
+			case 6: v(var.as<CriticalityDiagnostics>()); return true;
+			case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 8: v(var.as<SplitSRBs>()); return true;
+			case 9: v(var.as<SgNBResourceCoordinationInformation>()); return true;
+			case 10: v(var.as<RRC_Config_Ind>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(E_RAB_List)];
+			char dummy3[sizeof(E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList)];
+			char dummy4[sizeof(RRC_Config_Ind)];
+			char dummy5[sizeof(SgNBResourceCoordinationInformation)];
+			char dummy6[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy7[sizeof(SgNBtoMeNBContainer)];
+			char dummy8[sizeof(SplitSRBs)];
+			char dummy9[sizeof(UE_X2AP_ID)];
+			char dummy10[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 11; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() { set(mandatory); type=3;}
+		void select_id_E_RABs_NotAdmitted_List() { set(optional); type=4;}
+		void select_id_SgNBtoMeNBContainer() { set(mandatory); type=5;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=6;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
+		void select_id_AdmittedSplitSRBs() { set(optional); type=8;}
+		void select_id_SgNBResourceCoordinationInformation() { set(optional); type=9;}
+		void select_id_RRCConfigIndication() { set(optional); type=10;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(mandatory)) { 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 if(equal(optional)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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(mandatory);} 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBAdditionRequestAcknowledge ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SgNBAdditionRequestAcknowledge-IEs}},
+	...
+}
+*/
+
+struct SgNBAdditionRequestAcknowledge : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBAdditionRequestAcknowledge";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBAdditionRequestAcknowledge_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBAdditionRequestAcknowledge_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBAdditionRequestReject-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID					CRITICALITY reject	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID					CRITICALITY reject	TYPE SgNB-UE-X2AP-ID			PRESENCE optional}|
+	{ ID id-Cause							CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics			CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension		CRITICALITY reject	TYPE UE-X2AP-ID-Extension		PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBAdditionRequestReject_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(ignore)) { type = 4; return true; }
+			else if(equal(reject)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(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(reject);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); return true;
+			case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID)];
+			char dummy5[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(optional); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		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 if(equal(optional)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBAdditionRequestReject ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SgNBAdditionRequestReject-IEs}},
+	...
+}
+*/
+
+struct SgNBAdditionRequestReject : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBAdditionRequestReject";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBAdditionRequestReject_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBAdditionRequestReject_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBChangeConfirm-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID							CRITICALITY ignore	TYPE UE-X2AP-ID										PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID							CRITICALITY ignore	TYPE SgNB-UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-E-RABs-ToBeReleased-SgNBChaConfList		CRITICALITY ignore	TYPE E-RABs-ToBeReleased-SgNBChaConfList		PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics					CRITICALITY ignore	TYPE CriticalityDiagnostics						PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension				CRITICALITY ignore	TYPE UE-X2AP-ID-Extension							PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBChangeConfirm_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_E_RABs_ToBeReleased_SgNBChaConfList() { set(id_E_RABs_ToBeReleased_SgNBChaConfList); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_E_RABs_ToBeReleased_SgNBChaConfList)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBChaConfList);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_E_RABs_ToBeReleased_SgNBChaConfList() { set(ignore); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
+		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 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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		E_RABs_ToBeReleased_SgNBChaConfList& select_id_E_RABs_ToBeReleased_SgNBChaConfList() { return set<E_RABs_ToBeReleased_SgNBChaConfList>(3); }
+		E_RABs_ToBeReleased_SgNBChaConfList const* get_id_E_RABs_ToBeReleased_SgNBChaConfList() const { return get<E_RABs_ToBeReleased_SgNBChaConfList>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<E_RABs_ToBeReleased_SgNBChaConfList>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<E_RABs_ToBeReleased_SgNBChaConfList>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_E_RABs_ToBeReleased_SgNBChaConfList()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); return true;
+			case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<E_RABs_ToBeReleased_SgNBChaConfList>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(E_RABs_ToBeReleased_SgNBChaConfList)];
+			char dummy3[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID)];
+			char dummy5[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_E_RABs_ToBeReleased_SgNBChaConfList() { set(optional); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		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 if(equal(mandatory)) { 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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBChangeConfirm ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SgNBChangeConfirm-IEs}},
+	...
+}
+*/
+
+struct SgNBChangeConfirm : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBChangeConfirm";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBChangeConfirm_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBChangeConfirm_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBChangeRefuse-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY ignore	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID						CRITICALITY ignore	TYPE SgNB-UE-X2AP-ID				PRESENCE mandatory}|
+	{ ID id-Cause								CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics				CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension		PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBChangeRefuse_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
+		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 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(reject)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(reject);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); return true;
+			case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID)];
+			char dummy5[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBChangeRefuse ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{SgNBChangeRefuse-IEs}},
+	...
+}
+*/
+
+struct SgNBChangeRefuse : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBChangeRefuse";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBChangeRefuse_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBChangeRefuse_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBChangeRequired-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID						CRITICALITY reject	TYPE SgNB-UE-X2AP-ID				PRESENCE mandatory}|
+	{ ID id-Target-SgNB-ID						CRITICALITY reject	TYPE GlobalGNB-ID						PRESENCE mandatory}|
+	{ ID id-Cause								CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-SgNBtoMeNBContainer					CRITICALITY reject	TYPE SgNBtoMeNBContainer			PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension		PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBChangeRequired_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_Target_SgNB_ID() { set(id_Target_SgNB_ID); type=3;}
+		void select_id_Cause() { set(id_Cause); type=4;}
+		void select_id_SgNBtoMeNBContainer() { set(id_SgNBtoMeNBContainer); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Target_SgNB_ID)) { type = 3; return true; }
+			else if(equal(id_Cause)) { type = 4; return true; }
+			else if(equal(id_SgNBtoMeNBContainer)) { type = 5; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Target_SgNB_ID);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_SgNBtoMeNBContainer);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_Target_SgNB_ID() { set(reject); type=3;}
+		void select_id_Cause() { set(ignore); type=4;}
+		void select_id_SgNBtoMeNBContainer() { set(reject); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=6;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(reject)) { type = 3; return true; }
+			else if(equal(ignore)) { type = 4; return true; }
+			else if(equal(reject)) { type = 5; return true; }
+			else if(equal(reject)) { 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(ignore);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		GlobalGNB_ID& select_id_Target_SgNB_ID() { return set<GlobalGNB_ID>(3); }
+		GlobalGNB_ID const* get_id_Target_SgNB_ID() const { return get<GlobalGNB_ID>(3); }
+		Cause& select_id_Cause() { return set<Cause>(4); }
+		Cause const* get_id_Cause() const { return get<Cause>(4); }
+		SgNBtoMeNBContainer& select_id_SgNBtoMeNBContainer() { return set<SgNBtoMeNBContainer>(5); }
+		SgNBtoMeNBContainer const* get_id_SgNBtoMeNBContainer() const { return get<SgNBtoMeNBContainer>(5); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
+		bool is_unknown() const { return type == 7; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<GlobalGNB_ID>(); break;
+			case 4: var.destroy<Cause>(); break;
+			case 5: var.destroy<SgNBtoMeNBContainer>(); break;
+			case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<GlobalGNB_ID>(3);
+			v.template operator()<Cause>(4);
+			v.template operator()<SgNBtoMeNBContainer>(5);
+			v.template operator()<UE_X2AP_ID_Extension>(6);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Target_SgNB_ID()); return true;
+			case 4: v(select_id_Cause()); return true;
+			case 5: v(select_id_SgNBtoMeNBContainer()); return true;
+			case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<GlobalGNB_ID>()); return true;
+			case 4: v(var.as<Cause>()); return true;
+			case 5: v(var.as<SgNBtoMeNBContainer>()); return true;
+			case 6: v(var.as<UE_X2AP_ID_Extension>()); 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(GlobalGNB_ID)];
+			char dummy3[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy4[sizeof(SgNBtoMeNBContainer)];
+			char dummy5[sizeof(UE_X2AP_ID)];
+			char dummy6[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Target_SgNB_ID() { set(mandatory); type=3;}
+		void select_id_Cause() { set(mandatory); type=4;}
+		void select_id_SgNBtoMeNBContainer() { set(optional); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+SgNBChangeRequired ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{SgNBChangeRequired-IEs}},
+	...
+}
+*/
+
+struct SgNBChangeRequired : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBChangeRequired";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBChangeRequired_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBChangeRequired_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBCounterCheckRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID								CRITICALITY reject	TYPE UE-X2AP-ID											PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID								CRITICALITY reject	TYPE SgNB-UE-X2AP-ID										PRESENCE mandatory}|
+	{ ID id-E-RABs-SubjectToSgNBCounterCheck-List		CRITICALITY ignore	TYPE E-RABs-SubjectToSgNBCounterCheck-List		PRESENCE mandatory}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension					CRITICALITY ignore	TYPE UE-X2AP-ID-Extension							PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBCounterCheckRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_E_RABs_SubjectToSgNBCounterCheck_List() { set(id_E_RABs_SubjectToSgNBCounterCheck_List); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_E_RABs_SubjectToSgNBCounterCheck_List)) { type = 3; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToSgNBCounterCheck_List);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_E_RABs_SubjectToSgNBCounterCheck_List() { set(ignore); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=4;}
+		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 if(equal(reject)) { 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(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(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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		E_RABs_SubjectToSgNBCounterCheck_List& select_id_E_RABs_SubjectToSgNBCounterCheck_List() { return set<E_RABs_SubjectToSgNBCounterCheck_List>(3); }
+		E_RABs_SubjectToSgNBCounterCheck_List const* get_id_E_RABs_SubjectToSgNBCounterCheck_List() const { return get<E_RABs_SubjectToSgNBCounterCheck_List>(3); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
+		bool is_unknown() const { return type == 5; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<E_RABs_SubjectToSgNBCounterCheck_List>(); break;
+			case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<E_RABs_SubjectToSgNBCounterCheck_List>(3);
+			v.template operator()<UE_X2AP_ID_Extension>(4);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_E_RABs_SubjectToSgNBCounterCheck_List()); return true;
+			case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<E_RABs_SubjectToSgNBCounterCheck_List>()); return true;
+			case 4: v(var.as<UE_X2AP_ID_Extension>()); 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_RABs_SubjectToSgNBCounterCheck_List)];
+			char dummy2[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy3[sizeof(UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 5; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_E_RABs_SubjectToSgNBCounterCheck_List() { set(mandatory); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+SgNBCounterCheckRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SgNBCounterCheckRequest-IEs}},
+	...
+}
+*/
+
+struct SgNBCounterCheckRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBCounterCheckRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBCounterCheckRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBCounterCheckRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBModificationConfirm-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID									CRITICALITY ignore	TYPE UE-X2AP-ID											PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID									CRITICALITY ignore	TYPE SgNB-UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-E-RABs-AdmittedToBeModified-SgNBModConfList		CRITICALITY ignore	TYPE E-RABs-AdmittedToBeModified-SgNBModConfList		PRESENCE optional}|
+	{ ID id-MeNBtoSgNBContainer								CRITICALITY ignore	TYPE MeNBtoSgNBContainer							PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics							CRITICALITY ignore	TYPE CriticalityDiagnostics						PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension						CRITICALITY ignore	TYPE UE-X2AP-ID-Extension							PRESENCE optional}|
+	{ ID id-MeNBResourceCoordinationInformation				CRITICALITY ignore	TYPE MeNBResourceCoordinationInformation		PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBModificationConfirm_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 8; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_E_RABs_AdmittedToBeModified_SgNBModConfList() { set(id_E_RABs_AdmittedToBeModified_SgNBModConfList); type=3;}
+		void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=4;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
+		void select_id_MeNBResourceCoordinationInformation() { set(id_MeNBResourceCoordinationInformation); type=7;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_E_RABs_AdmittedToBeModified_SgNBModConfList)) { type = 3; return true; }
+			else if(equal(id_MeNBtoSgNBContainer)) { type = 4; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 5; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
+			else if(equal(id_MeNBResourceCoordinationInformation)) { type = 7; return true; }
+			else { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_AdmittedToBeModified_SgNBModConfList);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNBResourceCoordinationInformation);} return false;
+			case 8: type = 8; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 8; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_E_RABs_AdmittedToBeModified_SgNBModConfList() { set(ignore); type=3;}
+		void select_id_MeNBtoSgNBContainer() { set(ignore); type=4;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
+		void select_id_MeNBResourceCoordinationInformation() { set(ignore); type=7;}
+		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 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 { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		E_RABs_AdmittedToBeModified_SgNBModConfList& select_id_E_RABs_AdmittedToBeModified_SgNBModConfList() { return set<E_RABs_AdmittedToBeModified_SgNBModConfList>(3); }
+		E_RABs_AdmittedToBeModified_SgNBModConfList const* get_id_E_RABs_AdmittedToBeModified_SgNBModConfList() const { return get<E_RABs_AdmittedToBeModified_SgNBModConfList>(3); }
+		MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(4); }
+		MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(4); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(5); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(5); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
+		MeNBResourceCoordinationInformation& select_id_MeNBResourceCoordinationInformation() { return set<MeNBResourceCoordinationInformation>(7); }
+		MeNBResourceCoordinationInformation const* get_id_MeNBResourceCoordinationInformation() const { return get<MeNBResourceCoordinationInformation>(7); }
+		bool is_unknown() const { return type == 8; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<E_RABs_AdmittedToBeModified_SgNBModConfList>(); break;
+			case 4: var.destroy<MeNBtoSgNBContainer>(); break;
+			case 5: var.destroy<CriticalityDiagnostics>(); break;
+			case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 7: var.destroy<MeNBResourceCoordinationInformation>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<E_RABs_AdmittedToBeModified_SgNBModConfList>(3);
+			v.template operator()<MeNBtoSgNBContainer>(4);
+			v.template operator()<CriticalityDiagnostics>(5);
+			v.template operator()<UE_X2AP_ID_Extension>(6);
+			v.template operator()<MeNBResourceCoordinationInformation>(7);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_E_RABs_AdmittedToBeModified_SgNBModConfList()); return true;
+			case 4: v(select_id_MeNBtoSgNBContainer()); return true;
+			case 5: v(select_id_CriticalityDiagnostics()); return true;
+			case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 7: v(select_id_MeNBResourceCoordinationInformation()); return true;
+			case 8: if(type != 8) {clear(); asn::base::set();} type = 8; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<E_RABs_AdmittedToBeModified_SgNBModConfList>()); return true;
+			case 4: v(var.as<MeNBtoSgNBContainer>()); return true;
+			case 5: v(var.as<CriticalityDiagnostics>()); return true;
+			case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 7: v(var.as<MeNBResourceCoordinationInformation>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(E_RABs_AdmittedToBeModified_SgNBModConfList)];
+			char dummy3[sizeof(MeNBResourceCoordinationInformation)];
+			char dummy4[sizeof(MeNBtoSgNBContainer)];
+			char dummy5[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy6[sizeof(UE_X2AP_ID)];
+			char dummy7[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 8; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_E_RABs_AdmittedToBeModified_SgNBModConfList() { set(optional); type=3;}
+		void select_id_MeNBtoSgNBContainer() { set(optional); type=4;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
+		void select_id_MeNBResourceCoordinationInformation() { set(optional); type=7;}
+		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 if(equal(mandatory)) { 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 { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBModificationConfirm ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SgNBModificationConfirm-IEs}},
+	...
+}
+*/
+
+struct SgNBModificationConfirm : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBModificationConfirm";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBModificationConfirm_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBModificationConfirm_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBModificationRefuse-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY ignore	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID						CRITICALITY ignore	TYPE SgNB-UE-X2AP-ID				PRESENCE mandatory}|
+	{ ID id-Cause								CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-MeNBtoSgNBContainer					CRITICALITY ignore	TYPE MeNBtoSgNBContainer			PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics				CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY ignore	TYPE UE-X2AP-ID-Extension		PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBModificationRefuse_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=4;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_MeNBtoSgNBContainer)) { type = 4; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 5; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_MeNBtoSgNBContainer() { set(ignore); type=4;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
+		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 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 { 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(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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(4); }
+		MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(4); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(5); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(5); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
+		bool is_unknown() const { return type == 7; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<MeNBtoSgNBContainer>(); break;
+			case 5: var.destroy<CriticalityDiagnostics>(); break;
+			case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<MeNBtoSgNBContainer>(4);
+			v.template operator()<CriticalityDiagnostics>(5);
+			v.template operator()<UE_X2AP_ID_Extension>(6);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_MeNBtoSgNBContainer()); return true;
+			case 5: v(select_id_CriticalityDiagnostics()); return true;
+			case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<MeNBtoSgNBContainer>()); return true;
+			case 5: v(var.as<CriticalityDiagnostics>()); return true;
+			case 6: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(MeNBtoSgNBContainer)];
+			char dummy4[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy5[sizeof(UE_X2AP_ID)];
+			char dummy6[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 7; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_MeNBtoSgNBContainer() { set(optional); type=4;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+SgNBModificationRefuse ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{SgNBModificationRefuse-IEs}},
+	...
+}
+*/
+
+struct SgNBModificationRefuse : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBModificationRefuse";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRefuse_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBModificationRefuse_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+UE-ContextInformationSgNBModReqExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+	{	ID id-SubscriberProfileIDforRFP					CRITICALITY ignore	EXTENSION SubscriberProfileIDforRFP									PRESENCE optional},
+	...
+}
+*/
+
+struct UE_ContextInformationSgNBModReqExtIEs
+{
+	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_SubscriberProfileIDforRFP() { set(id_SubscriberProfileIDforRFP); 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_SubscriberProfileIDforRFP)) { 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_SubscriberProfileIDforRFP);} 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_SubscriberProfileIDforRFP() { 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;}
+		SubscriberProfileIDforRFP& select_id_SubscriberProfileIDforRFP() { return set<SubscriberProfileIDforRFP>(1); }
+		SubscriberProfileIDforRFP const* get_id_SubscriberProfileIDforRFP() const { return get<SubscriberProfileIDforRFP>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<SubscriberProfileIDforRFP>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<SubscriberProfileIDforRFP>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_SubscriberProfileIDforRFP()); 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<SubscriberProfileIDforRFP>()); 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(SubscriberProfileIDforRFP)];
+
+		};
+		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_SubscriberProfileIDforRFP() { 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};
+
+	};
+
+};
+/*
+UE-ContextInformation-SgNBModReq ::= SEQUENCE {
+	nRUE-SecurityCapabilities		NRUESecurityCapabilities															OPTIONAL,
+	sgNB-SecurityKey				SgNBSecurityKey 																	OPTIONAL,
+	sgNBUEAggregateMaximumBitRate	UEAggregateMaximumBitRate															OPTIONAL,
+	e-RABs-ToBeAdded				E-RABs-ToBeAdded-SgNBModReq-List													OPTIONAL,
+	e-RABs-ToBeModified				E-RABs-ToBeModified-SgNBModReq-List													OPTIONAL,
+	e-RABs-ToBeReleased				E-RABs-ToBeReleased-SgNBModReq-List													OPTIONAL,
+	iE-Extensions					ProtocolExtensionContainer { {UE-ContextInformationSgNBModReqExtIEs} }			OPTIONAL,
+	...
+}
+*/
+
+struct UE_ContextInformation_SgNBModReq : asn::sequence<7, 0, true, 7>
+{
+	static constexpr const char* name() {return "UE-ContextInformation-SgNBModReq";}
+	using parent_t = asn::sequence<7, 0, true, 7>;
+	struct nRUE_SecurityCapabilities_t : NRUESecurityCapabilities
+	{
+		static constexpr const char* name() {return "nRUE_SecurityCapabilities_t";}
+		using parent_t = NRUESecurityCapabilities;
+		static constexpr bool optional = true;
+
+	};
+	nRUE_SecurityCapabilities_t& set_nRUE_SecurityCapabilities() { nRUE_SecurityCapabilities.setpresent(true); return nRUE_SecurityCapabilities;}
+	nRUE_SecurityCapabilities_t const* get_nRUE_SecurityCapabilities() const {return nRUE_SecurityCapabilities.is_valid() ? &nRUE_SecurityCapabilities : nullptr;}
+	struct sgNB_SecurityKey_t : SgNBSecurityKey
+	{
+		static constexpr const char* name() {return "sgNB_SecurityKey_t";}
+		using parent_t = SgNBSecurityKey;
+		static constexpr bool optional = true;
+
+	};
+	sgNB_SecurityKey_t& set_sgNB_SecurityKey() { sgNB_SecurityKey.setpresent(true); return sgNB_SecurityKey;}
+	sgNB_SecurityKey_t const* get_sgNB_SecurityKey() const {return sgNB_SecurityKey.is_valid() ? &sgNB_SecurityKey : nullptr;}
+	struct sgNBUEAggregateMaximumBitRate_t : UEAggregateMaximumBitRate
+	{
+		static constexpr const char* name() {return "sgNBUEAggregateMaximumBitRate_t";}
+		using parent_t = UEAggregateMaximumBitRate;
+		static constexpr bool optional = true;
+
+	};
+	sgNBUEAggregateMaximumBitRate_t& set_sgNBUEAggregateMaximumBitRate() { sgNBUEAggregateMaximumBitRate.setpresent(true); return sgNBUEAggregateMaximumBitRate;}
+	sgNBUEAggregateMaximumBitRate_t const* get_sgNBUEAggregateMaximumBitRate() const {return sgNBUEAggregateMaximumBitRate.is_valid() ? &sgNBUEAggregateMaximumBitRate : nullptr;}
+	struct e_RABs_ToBeAdded_t : E_RABs_ToBeAdded_SgNBModReq_List
+	{
+		static constexpr const char* name() {return "e_RABs_ToBeAdded_t";}
+		using parent_t = E_RABs_ToBeAdded_SgNBModReq_List;
+		static constexpr bool optional = true;
+
+	};
+	e_RABs_ToBeAdded_t& set_e_RABs_ToBeAdded() { e_RABs_ToBeAdded.setpresent(true); return e_RABs_ToBeAdded;}
+	e_RABs_ToBeAdded_t const* get_e_RABs_ToBeAdded() const {return e_RABs_ToBeAdded.is_valid() ? &e_RABs_ToBeAdded : nullptr;}
+	struct e_RABs_ToBeModified_t : E_RABs_ToBeModified_SgNBModReq_List
+	{
+		static constexpr const char* name() {return "e_RABs_ToBeModified_t";}
+		using parent_t = E_RABs_ToBeModified_SgNBModReq_List;
+		static constexpr bool optional = true;
+
+	};
+	e_RABs_ToBeModified_t& set_e_RABs_ToBeModified() { e_RABs_ToBeModified.setpresent(true); return e_RABs_ToBeModified;}
+	e_RABs_ToBeModified_t const* get_e_RABs_ToBeModified() const {return e_RABs_ToBeModified.is_valid() ? &e_RABs_ToBeModified : nullptr;}
+	struct e_RABs_ToBeReleased_t : E_RABs_ToBeReleased_SgNBModReq_List
+	{
+		static constexpr const char* name() {return "e_RABs_ToBeReleased_t";}
+		using parent_t = E_RABs_ToBeReleased_SgNBModReq_List;
+		static constexpr bool optional = true;
+
+	};
+	e_RABs_ToBeReleased_t& set_e_RABs_ToBeReleased() { e_RABs_ToBeReleased.setpresent(true); return e_RABs_ToBeReleased;}
+	e_RABs_ToBeReleased_t const* get_e_RABs_ToBeReleased() const {return e_RABs_ToBeReleased.is_valid() ? &e_RABs_ToBeReleased : nullptr;}
+	struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextInformationSgNBModReqExtIEs>
+	{
+		static constexpr const char* name() {return "iE_Extensions_t";}
+		using parent_t = ProtocolExtensionContainer<UE_ContextInformationSgNBModReqExtIEs>;
+		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(nRUE_SecurityCapabilities);
+		v(sgNB_SecurityKey);
+		v(sgNBUEAggregateMaximumBitRate);
+		v(e_RABs_ToBeAdded);
+		v(e_RABs_ToBeModified);
+		v(e_RABs_ToBeReleased);
+		v(iE_Extensions);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(nRUE_SecurityCapabilities);
+		v(sgNB_SecurityKey);
+		v(sgNBUEAggregateMaximumBitRate);
+		v(e_RABs_ToBeAdded);
+		v(e_RABs_ToBeModified);
+		v(e_RABs_ToBeReleased);
+		v(iE_Extensions);
+
+	};
+	void clear()
+	{
+		nRUE_SecurityCapabilities.clear();
+		sgNB_SecurityKey.clear();
+		sgNBUEAggregateMaximumBitRate.clear();
+		e_RABs_ToBeAdded.clear();
+		e_RABs_ToBeModified.clear();
+		e_RABs_ToBeReleased.clear();
+		iE_Extensions.clear();
+
+	};
+	private:
+	nRUE_SecurityCapabilities_t	nRUE_SecurityCapabilities;
+	sgNB_SecurityKey_t	sgNB_SecurityKey;
+	sgNBUEAggregateMaximumBitRate_t	sgNBUEAggregateMaximumBitRate;
+	e_RABs_ToBeAdded_t	e_RABs_ToBeAdded;
+	e_RABs_ToBeModified_t	e_RABs_ToBeModified;
+	e_RABs_ToBeReleased_t	e_RABs_ToBeReleased;
+	iE_Extensions_t	iE_Extensions;
+
+};
+/*
+SgNBModificationRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY reject	TYPE UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID						CRITICALITY reject	TYPE SgNB-UE-X2AP-ID							PRESENCE mandatory}|
+	{ ID id-Cause								CRITICALITY ignore	TYPE Cause										PRESENCE mandatory}|
+	{ ID id-SelectedPLMN						CRITICALITY ignore	TYPE PLMN-Identity								PRESENCE optional}|
+	{ ID id-HandoverRestrictionList				CRITICALITY ignore	TYPE HandoverRestrictionList					PRESENCE optional}|
+	{ ID	id-SCGConfigurationQuery			CRITICALITY ignore	TYPE SCGConfigurationQuery						PRESENCE optional}|
+	{ ID id-UE-ContextInformation-SgNBModReq	CRITICALITY reject	TYPE UE-ContextInformation-SgNBModReq		PRESENCE optional}|
+	{ ID id-MeNBtoSgNBContainer					CRITICALITY reject	TYPE MeNBtoSgNBContainer						PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY reject	TYPE UE-X2AP-ID-Extension						PRESENCE optional}|
+	{ ID id-MeNBResourceCoordinationInformation	CRITICALITY ignore	TYPE MeNBResourceCoordinationInformation	PRESENCE optional}|
+	{ ID id-RequestedSplitSRBs					CRITICALITY ignore	TYPE SplitSRBs									PRESENCE optional}|
+	{ ID id-RequestedSplitSRBsrelease			CRITICALITY ignore	TYPE SplitSRBs									PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBModificationRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 13; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_SelectedPLMN() { set(id_SelectedPLMN); type=4;}
+		void select_id_HandoverRestrictionList() { set(id_HandoverRestrictionList); type=5;}
+		void select_id_SCGConfigurationQuery() { set(id_SCGConfigurationQuery); type=6;}
+		void select_id_UE_ContextInformation_SgNBModReq() { set(id_UE_ContextInformation_SgNBModReq); type=7;}
+		void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
+		void select_id_MeNBResourceCoordinationInformation() { set(id_MeNBResourceCoordinationInformation); type=10;}
+		void select_id_RequestedSplitSRBs() { set(id_RequestedSplitSRBs); type=11;}
+		void select_id_RequestedSplitSRBsrelease() { set(id_RequestedSplitSRBsrelease); type=12;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_SelectedPLMN)) { type = 4; return true; }
+			else if(equal(id_HandoverRestrictionList)) { type = 5; return true; }
+			else if(equal(id_SCGConfigurationQuery)) { type = 6; return true; }
+			else if(equal(id_UE_ContextInformation_SgNBModReq)) { type = 7; return true; }
+			else if(equal(id_MeNBtoSgNBContainer)) { type = 8; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
+			else if(equal(id_MeNBResourceCoordinationInformation)) { type = 10; return true; }
+			else if(equal(id_RequestedSplitSRBs)) { type = 11; return true; }
+			else if(equal(id_RequestedSplitSRBsrelease)) { type = 12; return true; }
+			else { type = 13; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_SelectedPLMN);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_HandoverRestrictionList);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_SCGConfigurationQuery);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_UE_ContextInformation_SgNBModReq);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(id_MeNBResourceCoordinationInformation);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(id_RequestedSplitSRBs);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(id_RequestedSplitSRBsrelease);} return false;
+			case 13: type = 13; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 13; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_SelectedPLMN() { set(ignore); type=4;}
+		void select_id_HandoverRestrictionList() { set(ignore); type=5;}
+		void select_id_SCGConfigurationQuery() { set(ignore); type=6;}
+		void select_id_UE_ContextInformation_SgNBModReq() { set(reject); type=7;}
+		void select_id_MeNBtoSgNBContainer() { set(reject); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=9;}
+		void select_id_MeNBResourceCoordinationInformation() { set(ignore); type=10;}
+		void select_id_RequestedSplitSRBs() { set(ignore); type=11;}
+		void select_id_RequestedSplitSRBsrelease() { set(ignore); type=12;}
+		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 if(equal(reject)) { 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(reject)) { type = 7; return true; }
+			else if(equal(reject)) { type = 8; return true; }
+			else if(equal(reject)) { type = 9; return true; }
+			else if(equal(ignore)) { type = 10; return true; }
+			else if(equal(ignore)) { type = 11; return true; }
+			else if(equal(ignore)) { type = 12; return true; }
+			else { type = 13; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(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(reject);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 13: type = 13; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		PLMN_Identity& select_id_SelectedPLMN() { return set<PLMN_Identity>(4); }
+		PLMN_Identity const* get_id_SelectedPLMN() const { return get<PLMN_Identity>(4); }
+		HandoverRestrictionList& select_id_HandoverRestrictionList() { return set<HandoverRestrictionList>(5); }
+		HandoverRestrictionList const* get_id_HandoverRestrictionList() const { return get<HandoverRestrictionList>(5); }
+		SCGConfigurationQuery& select_id_SCGConfigurationQuery() { return set<SCGConfigurationQuery>(6); }
+		SCGConfigurationQuery const* get_id_SCGConfigurationQuery() const { return get<SCGConfigurationQuery>(6); }
+		UE_ContextInformation_SgNBModReq& select_id_UE_ContextInformation_SgNBModReq() { return set<UE_ContextInformation_SgNBModReq>(7); }
+		UE_ContextInformation_SgNBModReq const* get_id_UE_ContextInformation_SgNBModReq() const { return get<UE_ContextInformation_SgNBModReq>(7); }
+		MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(8); }
+		MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(8); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
+		MeNBResourceCoordinationInformation& select_id_MeNBResourceCoordinationInformation() { return set<MeNBResourceCoordinationInformation>(10); }
+		MeNBResourceCoordinationInformation const* get_id_MeNBResourceCoordinationInformation() const { return get<MeNBResourceCoordinationInformation>(10); }
+		SplitSRBs& select_id_RequestedSplitSRBs() { return set<SplitSRBs>(11); }
+		SplitSRBs const* get_id_RequestedSplitSRBs() const { return get<SplitSRBs>(11); }
+		SplitSRBs& select_id_RequestedSplitSRBsrelease() { return set<SplitSRBs>(12); }
+		SplitSRBs const* get_id_RequestedSplitSRBsrelease() const { return get<SplitSRBs>(12); }
+		bool is_unknown() const { return type == 13; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<PLMN_Identity>(); break;
+			case 5: var.destroy<HandoverRestrictionList>(); break;
+			case 6: var.destroy<SCGConfigurationQuery>(); break;
+			case 7: var.destroy<UE_ContextInformation_SgNBModReq>(); break;
+			case 8: var.destroy<MeNBtoSgNBContainer>(); break;
+			case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 10: var.destroy<MeNBResourceCoordinationInformation>(); break;
+			case 11: var.destroy<SplitSRBs>(); break;
+			case 12: var.destroy<SplitSRBs>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<PLMN_Identity>(4);
+			v.template operator()<HandoverRestrictionList>(5);
+			v.template operator()<SCGConfigurationQuery>(6);
+			v.template operator()<UE_ContextInformation_SgNBModReq>(7);
+			v.template operator()<MeNBtoSgNBContainer>(8);
+			v.template operator()<UE_X2AP_ID_Extension>(9);
+			v.template operator()<MeNBResourceCoordinationInformation>(10);
+			v.template operator()<SplitSRBs>(11);
+			v.template operator()<SplitSRBs>(12);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_SelectedPLMN()); return true;
+			case 5: v(select_id_HandoverRestrictionList()); return true;
+			case 6: v(select_id_SCGConfigurationQuery()); return true;
+			case 7: v(select_id_UE_ContextInformation_SgNBModReq()); return true;
+			case 8: v(select_id_MeNBtoSgNBContainer()); return true;
+			case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 10: v(select_id_MeNBResourceCoordinationInformation()); return true;
+			case 11: v(select_id_RequestedSplitSRBs()); return true;
+			case 12: v(select_id_RequestedSplitSRBsrelease()); return true;
+			case 13: if(type != 13) {clear(); asn::base::set();} type = 13; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<PLMN_Identity>()); return true;
+			case 5: v(var.as<HandoverRestrictionList>()); return true;
+			case 6: v(var.as<SCGConfigurationQuery>()); return true;
+			case 7: v(var.as<UE_ContextInformation_SgNBModReq>()); return true;
+			case 8: v(var.as<MeNBtoSgNBContainer>()); return true;
+			case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 10: v(var.as<MeNBResourceCoordinationInformation>()); return true;
+			case 11: v(var.as<SplitSRBs>()); return true;
+			case 12: v(var.as<SplitSRBs>()); 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(HandoverRestrictionList)];
+			char dummy3[sizeof(MeNBResourceCoordinationInformation)];
+			char dummy4[sizeof(MeNBtoSgNBContainer)];
+			char dummy5[sizeof(PLMN_Identity)];
+			char dummy6[sizeof(SCGConfigurationQuery)];
+			char dummy7[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy8[sizeof(SplitSRBs)];
+			char dummy9[sizeof(UE_ContextInformation_SgNBModReq)];
+			char dummy10[sizeof(UE_X2AP_ID)];
+			char dummy11[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 13; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_SelectedPLMN() { set(optional); type=4;}
+		void select_id_HandoverRestrictionList() { set(optional); type=5;}
+		void select_id_SCGConfigurationQuery() { set(optional); type=6;}
+		void select_id_UE_ContextInformation_SgNBModReq() { set(optional); type=7;}
+		void select_id_MeNBtoSgNBContainer() { set(optional); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
+		void select_id_MeNBResourceCoordinationInformation() { set(optional); type=10;}
+		void select_id_RequestedSplitSRBs() { set(optional); type=11;}
+		void select_id_RequestedSplitSRBsrelease() { set(optional); type=12;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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 if(equal(optional)) { type = 10; return true; }
+			else if(equal(optional)) { type = 11; return true; }
+			else if(equal(optional)) { type = 12; return true; }
+			else { type = 13; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
+			case 13: type = 13; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBModificationRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{ SgNBModificationRequest-IEs}},
+	...
+}
+*/
+
+struct SgNBModificationRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBModificationRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBModificationRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBModificationRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID								CRITICALITY ignore	TYPE UE-X2AP-ID													PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID								CRITICALITY ignore	TYPE SgNB-UE-X2AP-ID												PRESENCE mandatory}|
+	{ ID id-E-RABs-Admitted-ToBeAdded-SgNBModAckList		CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeAdded-SgNBModAckList			PRESENCE optional}|
+	{ ID id-E-RABs-Admitted-ToBeModified-SgNBModAckList	CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeModified-SgNBModAckList		PRESENCE optional}|
+	{ ID id-E-RABs-Admitted-ToBeReleased-SgNBModAckList	CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeReleased-SgNBModAckList		PRESENCE optional}|
+	{ ID id-E-RABs-NotAdmitted-List						CRITICALITY ignore	TYPE E-RAB-List													PRESENCE optional}|
+	{ ID id-SgNBtoMeNBContainer							CRITICALITY ignore	TYPE SgNBtoMeNBContainer										PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics						CRITICALITY ignore	TYPE CriticalityDiagnostics									PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension					CRITICALITY ignore	TYPE UE-X2AP-ID-Extension									PRESENCE optional}|
+	{ ID id-SgNBResourceCoordinationInformation			CRITICALITY ignore	TYPE SgNBResourceCoordinationInformation				PRESENCE optional}|
+	{ ID id-AdmittedSplitSRBs							CRITICALITY ignore	TYPE SplitSRBs													PRESENCE optional}|
+	{ ID id-AdmittedSplitSRBsrelease						CRITICALITY ignore	TYPE SplitSRBs													PRESENCE optional}|
+	{ ID id-RRCConfigIndication							CRITICALITY reject	TYPE RRC-Config-Ind			PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBModificationRequestAcknowledge_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 14; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() { set(id_E_RABs_Admitted_ToBeAdded_SgNBModAckList); type=3;}
+		void select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() { set(id_E_RABs_Admitted_ToBeModified_SgNBModAckList); type=4;}
+		void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() { set(id_E_RABs_Admitted_ToBeReleased_SgNBModAckList); type=5;}
+		void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=6;}
+		void select_id_SgNBtoMeNBContainer() { set(id_SgNBtoMeNBContainer); type=7;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
+		void select_id_SgNBResourceCoordinationInformation() { set(id_SgNBResourceCoordinationInformation); type=10;}
+		void select_id_AdmittedSplitSRBs() { set(id_AdmittedSplitSRBs); type=11;}
+		void select_id_AdmittedSplitSRBsrelease() { set(id_AdmittedSplitSRBsrelease); type=12;}
+		void select_id_RRCConfigIndication() { set(id_RRCConfigIndication); type=13;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_E_RABs_Admitted_ToBeAdded_SgNBModAckList)) { type = 3; return true; }
+			else if(equal(id_E_RABs_Admitted_ToBeModified_SgNBModAckList)) { type = 4; return true; }
+			else if(equal(id_E_RABs_Admitted_ToBeReleased_SgNBModAckList)) { type = 5; return true; }
+			else if(equal(id_E_RABs_NotAdmitted_List)) { type = 6; return true; }
+			else if(equal(id_SgNBtoMeNBContainer)) { type = 7; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 8; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
+			else if(equal(id_SgNBResourceCoordinationInformation)) { type = 10; return true; }
+			else if(equal(id_AdmittedSplitSRBs)) { type = 11; return true; }
+			else if(equal(id_AdmittedSplitSRBsrelease)) { type = 12; return true; }
+			else if(equal(id_RRCConfigIndication)) { type = 13; return true; }
+			else { type = 14; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_SgNBModAckList);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeModified_SgNBModAckList);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_SgNBModAckList);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_SgNBtoMeNBContainer);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(id_SgNBResourceCoordinationInformation);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(id_AdmittedSplitSRBs);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(id_AdmittedSplitSRBsrelease);} return false;
+			case 13: type = 13; if(v(ref_nested())) { return equal(id_RRCConfigIndication);} return false;
+			case 14: type = 14; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 14; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() { set(ignore); type=3;}
+		void select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() { set(ignore); type=4;}
+		void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() { set(ignore); type=5;}
+		void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=6;}
+		void select_id_SgNBtoMeNBContainer() { set(ignore); type=7;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=9;}
+		void select_id_SgNBResourceCoordinationInformation() { set(ignore); type=10;}
+		void select_id_AdmittedSplitSRBs() { set(ignore); type=11;}
+		void select_id_AdmittedSplitSRBsrelease() { set(ignore); type=12;}
+		void select_id_RRCConfigIndication() { set(reject); type=13;}
+		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 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 if(equal(ignore)) { type = 10; return true; }
+			else if(equal(ignore)) { type = 11; return true; }
+			else if(equal(ignore)) { type = 12; return true; }
+			else if(equal(reject)) { type = 13; return true; }
+			else { type = 14; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 13: type = 13; if(v(ref_nested())) { return equal(reject);} return false;
+			case 14: type = 14; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		E_RABs_Admitted_ToBeAdded_SgNBModAckList& select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() { return set<E_RABs_Admitted_ToBeAdded_SgNBModAckList>(3); }
+		E_RABs_Admitted_ToBeAdded_SgNBModAckList const* get_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() const { return get<E_RABs_Admitted_ToBeAdded_SgNBModAckList>(3); }
+		E_RABs_Admitted_ToBeModified_SgNBModAckList& select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() { return set<E_RABs_Admitted_ToBeModified_SgNBModAckList>(4); }
+		E_RABs_Admitted_ToBeModified_SgNBModAckList const* get_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() const { return get<E_RABs_Admitted_ToBeModified_SgNBModAckList>(4); }
+		E_RABs_Admitted_ToBeReleased_SgNBModAckList& select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() { return set<E_RABs_Admitted_ToBeReleased_SgNBModAckList>(5); }
+		E_RABs_Admitted_ToBeReleased_SgNBModAckList const* get_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() const { return get<E_RABs_Admitted_ToBeReleased_SgNBModAckList>(5); }
+		E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(6); }
+		E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(6); }
+		SgNBtoMeNBContainer& select_id_SgNBtoMeNBContainer() { return set<SgNBtoMeNBContainer>(7); }
+		SgNBtoMeNBContainer const* get_id_SgNBtoMeNBContainer() const { return get<SgNBtoMeNBContainer>(7); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(8); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(8); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
+		SgNBResourceCoordinationInformation& select_id_SgNBResourceCoordinationInformation() { return set<SgNBResourceCoordinationInformation>(10); }
+		SgNBResourceCoordinationInformation const* get_id_SgNBResourceCoordinationInformation() const { return get<SgNBResourceCoordinationInformation>(10); }
+		SplitSRBs& select_id_AdmittedSplitSRBs() { return set<SplitSRBs>(11); }
+		SplitSRBs const* get_id_AdmittedSplitSRBs() const { return get<SplitSRBs>(11); }
+		SplitSRBs& select_id_AdmittedSplitSRBsrelease() { return set<SplitSRBs>(12); }
+		SplitSRBs const* get_id_AdmittedSplitSRBsrelease() const { return get<SplitSRBs>(12); }
+		RRC_Config_Ind& select_id_RRCConfigIndication() { return set<RRC_Config_Ind>(13); }
+		RRC_Config_Ind const* get_id_RRCConfigIndication() const { return get<RRC_Config_Ind>(13); }
+		bool is_unknown() const { return type == 14; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<E_RABs_Admitted_ToBeAdded_SgNBModAckList>(); break;
+			case 4: var.destroy<E_RABs_Admitted_ToBeModified_SgNBModAckList>(); break;
+			case 5: var.destroy<E_RABs_Admitted_ToBeReleased_SgNBModAckList>(); break;
+			case 6: var.destroy<E_RAB_List>(); break;
+			case 7: var.destroy<SgNBtoMeNBContainer>(); break;
+			case 8: var.destroy<CriticalityDiagnostics>(); break;
+			case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 10: var.destroy<SgNBResourceCoordinationInformation>(); break;
+			case 11: var.destroy<SplitSRBs>(); break;
+			case 12: var.destroy<SplitSRBs>(); break;
+			case 13: var.destroy<RRC_Config_Ind>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<E_RABs_Admitted_ToBeAdded_SgNBModAckList>(3);
+			v.template operator()<E_RABs_Admitted_ToBeModified_SgNBModAckList>(4);
+			v.template operator()<E_RABs_Admitted_ToBeReleased_SgNBModAckList>(5);
+			v.template operator()<E_RAB_List>(6);
+			v.template operator()<SgNBtoMeNBContainer>(7);
+			v.template operator()<CriticalityDiagnostics>(8);
+			v.template operator()<UE_X2AP_ID_Extension>(9);
+			v.template operator()<SgNBResourceCoordinationInformation>(10);
+			v.template operator()<SplitSRBs>(11);
+			v.template operator()<SplitSRBs>(12);
+			v.template operator()<RRC_Config_Ind>(13);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList()); return true;
+			case 4: v(select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList()); return true;
+			case 5: v(select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList()); return true;
+			case 6: v(select_id_E_RABs_NotAdmitted_List()); return true;
+			case 7: v(select_id_SgNBtoMeNBContainer()); return true;
+			case 8: v(select_id_CriticalityDiagnostics()); return true;
+			case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 10: v(select_id_SgNBResourceCoordinationInformation()); return true;
+			case 11: v(select_id_AdmittedSplitSRBs()); return true;
+			case 12: v(select_id_AdmittedSplitSRBsrelease()); return true;
+			case 13: v(select_id_RRCConfigIndication()); return true;
+			case 14: if(type != 14) {clear(); asn::base::set();} type = 14; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<E_RABs_Admitted_ToBeAdded_SgNBModAckList>()); return true;
+			case 4: v(var.as<E_RABs_Admitted_ToBeModified_SgNBModAckList>()); return true;
+			case 5: v(var.as<E_RABs_Admitted_ToBeReleased_SgNBModAckList>()); return true;
+			case 6: v(var.as<E_RAB_List>()); return true;
+			case 7: v(var.as<SgNBtoMeNBContainer>()); return true;
+			case 8: v(var.as<CriticalityDiagnostics>()); return true;
+			case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 10: v(var.as<SgNBResourceCoordinationInformation>()); return true;
+			case 11: v(var.as<SplitSRBs>()); return true;
+			case 12: v(var.as<SplitSRBs>()); return true;
+			case 13: v(var.as<RRC_Config_Ind>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(E_RAB_List)];
+			char dummy3[sizeof(E_RABs_Admitted_ToBeAdded_SgNBModAckList)];
+			char dummy4[sizeof(E_RABs_Admitted_ToBeModified_SgNBModAckList)];
+			char dummy5[sizeof(E_RABs_Admitted_ToBeReleased_SgNBModAckList)];
+			char dummy6[sizeof(RRC_Config_Ind)];
+			char dummy7[sizeof(SgNBResourceCoordinationInformation)];
+			char dummy8[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy9[sizeof(SgNBtoMeNBContainer)];
+			char dummy10[sizeof(SplitSRBs)];
+			char dummy11[sizeof(UE_X2AP_ID)];
+			char dummy12[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 14; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() { set(optional); type=3;}
+		void select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() { set(optional); type=4;}
+		void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() { set(optional); type=5;}
+		void select_id_E_RABs_NotAdmitted_List() { set(optional); type=6;}
+		void select_id_SgNBtoMeNBContainer() { set(optional); type=7;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=8;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
+		void select_id_SgNBResourceCoordinationInformation() { set(optional); type=10;}
+		void select_id_AdmittedSplitSRBs() { set(optional); type=11;}
+		void select_id_AdmittedSplitSRBsrelease() { set(optional); type=12;}
+		void select_id_RRCConfigIndication() { set(optional); type=13;}
+		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 if(equal(mandatory)) { 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 if(equal(optional)) { type = 10; return true; }
+			else if(equal(optional)) { type = 11; return true; }
+			else if(equal(optional)) { type = 12; return true; }
+			else if(equal(optional)) { type = 13; return true; }
+			else { type = 14; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
+			case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
+			case 13: type = 13; if(v(ref_nested())) { return equal(optional);} return false;
+			case 14: type = 14; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBModificationRequestAcknowledge ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SgNBModificationRequestAcknowledge-IEs}},
+	...
+}
+*/
+
+struct SgNBModificationRequestAcknowledge : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBModificationRequestAcknowledge";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRequestAcknowledge_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBModificationRequestAcknowledge_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBModificationRequestReject-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID						CRITICALITY ignore	TYPE UE-X2AP-ID					PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID						CRITICALITY ignore	TYPE SgNB-UE-X2AP-ID				PRESENCE mandatory}|
+	{ ID id-Cause								CRITICALITY ignore	TYPE Cause						PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics				CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension			CRITICALITY ignore	TYPE UE-X2AP-ID-Extension		PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBModificationRequestReject_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
+		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 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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); return true;
+			case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID)];
+			char dummy5[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBModificationRequestReject ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SgNBModificationRequestReject-IEs}},
+	...
+}
+*/
+
+struct SgNBModificationRequestReject : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBModificationRequestReject";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRequestReject_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBModificationRequestReject_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBModificationRequired-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID							CRITICALITY reject	TYPE UE-X2AP-ID										PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID							CRITICALITY reject	TYPE SgNB-UE-X2AP-ID								PRESENCE mandatory}|
+	{ ID id-Cause									CRITICALITY ignore	TYPE Cause											PRESENCE mandatory}|
+	{ ID id-PDCPChangeIndication					CRITICALITY ignore	TYPE PDCPChangeIndication							PRESENCE optional}|
+	{ ID id-E-RABs-ToBeReleased-SgNBModReqdList		CRITICALITY ignore	TYPE E-RABs-ToBeReleased-SgNBModReqdList		PRESENCE optional}|
+	{ ID id-SgNBtoMeNBContainer						CRITICALITY ignore	TYPE SgNBtoMeNBContainer							PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension				CRITICALITY reject	TYPE UE-X2AP-ID-Extension							PRESENCE optional}|
+	{ ID id-E-RABs-ToBeModified-SgNBModReqdList		CRITICALITY ignore	TYPE E-RABs-ToBeModified-SgNBModReqdList		PRESENCE optional}|
+	{ ID id-SgNBResourceCoordinationInformation		CRITICALITY ignore	TYPE SgNBResourceCoordinationInformation		PRESENCE optional}|
+	{ ID id-RRCConfigIndication						CRITICALITY reject	TYPE RRC-Config-Ind									PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBModificationRequired_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 11; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_PDCPChangeIndication() { set(id_PDCPChangeIndication); type=4;}
+		void select_id_E_RABs_ToBeReleased_SgNBModReqdList() { set(id_E_RABs_ToBeReleased_SgNBModReqdList); type=5;}
+		void select_id_SgNBtoMeNBContainer() { set(id_SgNBtoMeNBContainer); type=6;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=7;}
+		void select_id_E_RABs_ToBeModified_SgNBModReqdList() { set(id_E_RABs_ToBeModified_SgNBModReqdList); type=8;}
+		void select_id_SgNBResourceCoordinationInformation() { set(id_SgNBResourceCoordinationInformation); type=9;}
+		void select_id_RRCConfigIndication() { set(id_RRCConfigIndication); type=10;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_PDCPChangeIndication)) { type = 4; return true; }
+			else if(equal(id_E_RABs_ToBeReleased_SgNBModReqdList)) { type = 5; return true; }
+			else if(equal(id_SgNBtoMeNBContainer)) { type = 6; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
+			else if(equal(id_E_RABs_ToBeModified_SgNBModReqdList)) { type = 8; return true; }
+			else if(equal(id_SgNBResourceCoordinationInformation)) { type = 9; return true; }
+			else if(equal(id_RRCConfigIndication)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_PDCPChangeIndication);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBModReqdList);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_SgNBtoMeNBContainer);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 8: type = 8; if(v(ref_nested())) { return equal(id_E_RABs_ToBeModified_SgNBModReqdList);} return false;
+			case 9: type = 9; if(v(ref_nested())) { return equal(id_SgNBResourceCoordinationInformation);} return false;
+			case 10: type = 10; if(v(ref_nested())) { return equal(id_RRCConfigIndication);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 11; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_PDCPChangeIndication() { set(ignore); type=4;}
+		void select_id_E_RABs_ToBeReleased_SgNBModReqdList() { set(ignore); type=5;}
+		void select_id_SgNBtoMeNBContainer() { set(ignore); type=6;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=7;}
+		void select_id_E_RABs_ToBeModified_SgNBModReqdList() { set(ignore); type=8;}
+		void select_id_SgNBResourceCoordinationInformation() { set(ignore); type=9;}
+		void select_id_RRCConfigIndication() { set(reject); type=10;}
+		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 if(equal(reject)) { 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(reject)) { type = 7; return true; }
+			else if(equal(ignore)) { type = 8; return true; }
+			else if(equal(ignore)) { type = 9; return true; }
+			else if(equal(reject)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(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(reject);} 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; if(v(ref_nested())) { return equal(reject);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		PDCPChangeIndication& select_id_PDCPChangeIndication() { return set<PDCPChangeIndication>(4); }
+		PDCPChangeIndication const* get_id_PDCPChangeIndication() const { return get<PDCPChangeIndication>(4); }
+		E_RABs_ToBeReleased_SgNBModReqdList& select_id_E_RABs_ToBeReleased_SgNBModReqdList() { return set<E_RABs_ToBeReleased_SgNBModReqdList>(5); }
+		E_RABs_ToBeReleased_SgNBModReqdList const* get_id_E_RABs_ToBeReleased_SgNBModReqdList() const { return get<E_RABs_ToBeReleased_SgNBModReqdList>(5); }
+		SgNBtoMeNBContainer& select_id_SgNBtoMeNBContainer() { return set<SgNBtoMeNBContainer>(6); }
+		SgNBtoMeNBContainer const* get_id_SgNBtoMeNBContainer() const { return get<SgNBtoMeNBContainer>(6); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
+		E_RABs_ToBeModified_SgNBModReqdList& select_id_E_RABs_ToBeModified_SgNBModReqdList() { return set<E_RABs_ToBeModified_SgNBModReqdList>(8); }
+		E_RABs_ToBeModified_SgNBModReqdList const* get_id_E_RABs_ToBeModified_SgNBModReqdList() const { return get<E_RABs_ToBeModified_SgNBModReqdList>(8); }
+		SgNBResourceCoordinationInformation& select_id_SgNBResourceCoordinationInformation() { return set<SgNBResourceCoordinationInformation>(9); }
+		SgNBResourceCoordinationInformation const* get_id_SgNBResourceCoordinationInformation() const { return get<SgNBResourceCoordinationInformation>(9); }
+		RRC_Config_Ind& select_id_RRCConfigIndication() { return set<RRC_Config_Ind>(10); }
+		RRC_Config_Ind const* get_id_RRCConfigIndication() const { return get<RRC_Config_Ind>(10); }
+		bool is_unknown() const { return type == 11; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<PDCPChangeIndication>(); break;
+			case 5: var.destroy<E_RABs_ToBeReleased_SgNBModReqdList>(); break;
+			case 6: var.destroy<SgNBtoMeNBContainer>(); break;
+			case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 8: var.destroy<E_RABs_ToBeModified_SgNBModReqdList>(); break;
+			case 9: var.destroy<SgNBResourceCoordinationInformation>(); break;
+			case 10: var.destroy<RRC_Config_Ind>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<PDCPChangeIndication>(4);
+			v.template operator()<E_RABs_ToBeReleased_SgNBModReqdList>(5);
+			v.template operator()<SgNBtoMeNBContainer>(6);
+			v.template operator()<UE_X2AP_ID_Extension>(7);
+			v.template operator()<E_RABs_ToBeModified_SgNBModReqdList>(8);
+			v.template operator()<SgNBResourceCoordinationInformation>(9);
+			v.template operator()<RRC_Config_Ind>(10);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_PDCPChangeIndication()); return true;
+			case 5: v(select_id_E_RABs_ToBeReleased_SgNBModReqdList()); return true;
+			case 6: v(select_id_SgNBtoMeNBContainer()); return true;
+			case 7: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 8: v(select_id_E_RABs_ToBeModified_SgNBModReqdList()); return true;
+			case 9: v(select_id_SgNBResourceCoordinationInformation()); return true;
+			case 10: v(select_id_RRCConfigIndication()); return true;
+			case 11: if(type != 11) {clear(); asn::base::set();} type = 11; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<PDCPChangeIndication>()); return true;
+			case 5: v(var.as<E_RABs_ToBeReleased_SgNBModReqdList>()); return true;
+			case 6: v(var.as<SgNBtoMeNBContainer>()); return true;
+			case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 8: v(var.as<E_RABs_ToBeModified_SgNBModReqdList>()); return true;
+			case 9: v(var.as<SgNBResourceCoordinationInformation>()); return true;
+			case 10: v(var.as<RRC_Config_Ind>()); 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(E_RABs_ToBeModified_SgNBModReqdList)];
+			char dummy3[sizeof(E_RABs_ToBeReleased_SgNBModReqdList)];
+			char dummy4[sizeof(PDCPChangeIndication)];
+			char dummy5[sizeof(RRC_Config_Ind)];
+			char dummy6[sizeof(SgNBResourceCoordinationInformation)];
+			char dummy7[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy8[sizeof(SgNBtoMeNBContainer)];
+			char dummy9[sizeof(UE_X2AP_ID)];
+			char dummy10[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 11; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_PDCPChangeIndication() { set(optional); type=4;}
+		void select_id_E_RABs_ToBeReleased_SgNBModReqdList() { set(optional); type=5;}
+		void select_id_SgNBtoMeNBContainer() { set(optional); type=6;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
+		void select_id_E_RABs_ToBeModified_SgNBModReqdList() { set(optional); type=8;}
+		void select_id_SgNBResourceCoordinationInformation() { set(optional); type=9;}
+		void select_id_RRCConfigIndication() { set(optional); type=10;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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 if(equal(optional)) { type = 10; return true; }
+			else { type = 11; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 11: type = 11; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBModificationRequired ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{SgNBModificationRequired-IEs}},
+	...
+}
+*/
+
+struct SgNBModificationRequired : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBModificationRequired";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRequired_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBModificationRequired_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBReconfigurationComplete-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID							CRITICALITY reject	TYPE UE-X2AP-ID											PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID							CRITICALITY reject	TYPE SgNB-UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-ResponseInformationSgNBReconfComp		CRITICALITY ignore	TYPE ResponseInformationSgNBReconfComp			PRESENCE mandatory}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension				CRITICALITY reject	TYPE UE-X2AP-ID-Extension								PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBReconfigurationComplete_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_ResponseInformationSgNBReconfComp() { set(id_ResponseInformationSgNBReconfComp); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_ResponseInformationSgNBReconfComp)) { type = 3; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_ResponseInformationSgNBReconfComp);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_ResponseInformationSgNBReconfComp() { set(ignore); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(reject)) { 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(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(ignore);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		ResponseInformationSgNBReconfComp& select_id_ResponseInformationSgNBReconfComp() { return set<ResponseInformationSgNBReconfComp>(3); }
+		ResponseInformationSgNBReconfComp const* get_id_ResponseInformationSgNBReconfComp() const { return get<ResponseInformationSgNBReconfComp>(3); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
+		bool is_unknown() const { return type == 5; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<ResponseInformationSgNBReconfComp>(); break;
+			case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<ResponseInformationSgNBReconfComp>(3);
+			v.template operator()<UE_X2AP_ID_Extension>(4);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_ResponseInformationSgNBReconfComp()); return true;
+			case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<ResponseInformationSgNBReconfComp>()); return true;
+			case 4: v(var.as<UE_X2AP_ID_Extension>()); 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(ResponseInformationSgNBReconfComp)];
+			char dummy2[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy3[sizeof(UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 5; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_ResponseInformationSgNBReconfComp() { set(mandatory); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+SgNBReconfigurationComplete ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SgNBReconfigurationComplete-IEs}},
+	...
+}
+*/
+
+struct SgNBReconfigurationComplete : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBReconfigurationComplete";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBReconfigurationComplete_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBReconfigurationComplete_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBReleaseConfirm-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID							CRITICALITY ignore	TYPE UE-X2AP-ID										PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID							CRITICALITY ignore	TYPE SgNB-UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-E-RABs-ToBeReleased-SgNBRelConfList		CRITICALITY ignore	TYPE E-RABs-ToBeReleased-SgNBRelConfList		PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics					CRITICALITY ignore	TYPE CriticalityDiagnostics						PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension				CRITICALITY ignore	TYPE UE-X2AP-ID-Extension							PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBReleaseConfirm_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_E_RABs_ToBeReleased_SgNBRelConfList() { set(id_E_RABs_ToBeReleased_SgNBRelConfList); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_E_RABs_ToBeReleased_SgNBRelConfList)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelConfList);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_E_RABs_ToBeReleased_SgNBRelConfList() { set(ignore); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
+		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 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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		E_RABs_ToBeReleased_SgNBRelConfList& select_id_E_RABs_ToBeReleased_SgNBRelConfList() { return set<E_RABs_ToBeReleased_SgNBRelConfList>(3); }
+		E_RABs_ToBeReleased_SgNBRelConfList const* get_id_E_RABs_ToBeReleased_SgNBRelConfList() const { return get<E_RABs_ToBeReleased_SgNBRelConfList>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<E_RABs_ToBeReleased_SgNBRelConfList>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<E_RABs_ToBeReleased_SgNBRelConfList>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_E_RABs_ToBeReleased_SgNBRelConfList()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); return true;
+			case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<E_RABs_ToBeReleased_SgNBRelConfList>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(E_RABs_ToBeReleased_SgNBRelConfList)];
+			char dummy3[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID)];
+			char dummy5[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_E_RABs_ToBeReleased_SgNBRelConfList() { set(optional); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		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 if(equal(mandatory)) { 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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBReleaseConfirm ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SgNBReleaseConfirm-IEs}},
+	...
+}
+*/
+
+struct SgNBReleaseConfirm : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBReleaseConfirm";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseConfirm_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBReleaseConfirm_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBReleaseRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID							CRITICALITY reject	TYPE UE-X2AP-ID										PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID							CRITICALITY reject	TYPE SgNB-UE-X2AP-ID									PRESENCE optional}|
+	{ ID id-Cause									CRITICALITY ignore	TYPE Cause											PRESENCE mandatory}|
+	{ ID id-E-RABs-ToBeReleased-SgNBRelReqList		CRITICALITY ignore	TYPE E-RABs-ToBeReleased-SgNBRelReqList		PRESENCE optional}|
+	{ ID id-UE-ContextKeptIndicator					CRITICALITY ignore	TYPE UE-ContextKeptIndicator						PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension				CRITICALITY reject	TYPE UE-X2AP-ID-Extension							PRESENCE optional}|
+	{ ID id-MeNBtoSgNBContainer						CRITICALITY reject	TYPE MeNBtoSgNBContainer								PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBReleaseRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 8; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_E_RABs_ToBeReleased_SgNBRelReqList() { set(id_E_RABs_ToBeReleased_SgNBRelReqList); type=4;}
+		void select_id_UE_ContextKeptIndicator() { set(id_UE_ContextKeptIndicator); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
+		void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=7;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_E_RABs_ToBeReleased_SgNBRelReqList)) { type = 4; return true; }
+			else if(equal(id_UE_ContextKeptIndicator)) { type = 5; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
+			else if(equal(id_MeNBtoSgNBContainer)) { type = 7; return true; }
+			else { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelReqList);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_UE_ContextKeptIndicator);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
+			case 8: type = 8; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 8; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_E_RABs_ToBeReleased_SgNBRelReqList() { set(ignore); type=4;}
+		void select_id_UE_ContextKeptIndicator() { set(ignore); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=6;}
+		void select_id_MeNBtoSgNBContainer() { set(reject); type=7;}
+		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 if(equal(reject)) { 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(reject)) { type = 6; return true; }
+			else if(equal(reject)) { type = 7; return true; }
+			else { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(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(reject);} return false;
+			case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
+			case 8: type = 8; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		E_RABs_ToBeReleased_SgNBRelReqList& select_id_E_RABs_ToBeReleased_SgNBRelReqList() { return set<E_RABs_ToBeReleased_SgNBRelReqList>(4); }
+		E_RABs_ToBeReleased_SgNBRelReqList const* get_id_E_RABs_ToBeReleased_SgNBRelReqList() const { return get<E_RABs_ToBeReleased_SgNBRelReqList>(4); }
+		UE_ContextKeptIndicator& select_id_UE_ContextKeptIndicator() { return set<UE_ContextKeptIndicator>(5); }
+		UE_ContextKeptIndicator const* get_id_UE_ContextKeptIndicator() const { return get<UE_ContextKeptIndicator>(5); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
+		MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(7); }
+		MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(7); }
+		bool is_unknown() const { return type == 8; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<E_RABs_ToBeReleased_SgNBRelReqList>(); break;
+			case 5: var.destroy<UE_ContextKeptIndicator>(); break;
+			case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 7: var.destroy<MeNBtoSgNBContainer>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<E_RABs_ToBeReleased_SgNBRelReqList>(4);
+			v.template operator()<UE_ContextKeptIndicator>(5);
+			v.template operator()<UE_X2AP_ID_Extension>(6);
+			v.template operator()<MeNBtoSgNBContainer>(7);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_E_RABs_ToBeReleased_SgNBRelReqList()); return true;
+			case 5: v(select_id_UE_ContextKeptIndicator()); return true;
+			case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 7: v(select_id_MeNBtoSgNBContainer()); return true;
+			case 8: if(type != 8) {clear(); asn::base::set();} type = 8; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<E_RABs_ToBeReleased_SgNBRelReqList>()); return true;
+			case 5: v(var.as<UE_ContextKeptIndicator>()); return true;
+			case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 7: v(var.as<MeNBtoSgNBContainer>()); 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(E_RABs_ToBeReleased_SgNBRelReqList)];
+			char dummy3[sizeof(MeNBtoSgNBContainer)];
+			char dummy4[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy5[sizeof(UE_ContextKeptIndicator)];
+			char dummy6[sizeof(UE_X2AP_ID)];
+			char dummy7[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 8; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(optional); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_E_RABs_ToBeReleased_SgNBRelReqList() { set(optional); type=4;}
+		void select_id_UE_ContextKeptIndicator() { set(optional); type=5;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
+		void select_id_MeNBtoSgNBContainer() { set(optional); type=7;}
+		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 if(equal(optional)) { type = 2; return true; }
+			else if(equal(mandatory)) { 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 { type = 8; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(optional);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBReleaseRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{SgNBReleaseRequest-IEs}},
+	...
+}
+*/
+
+struct SgNBReleaseRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBReleaseRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBReleaseRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBReleaseRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID									CRITICALITY ignore	TYPE UE-X2AP-ID											PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID									CRITICALITY ignore	TYPE SgNB-UE-X2AP-ID								PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics							CRITICALITY ignore	TYPE CriticalityDiagnostics						PRESENCE optional }|
+	{ ID id-MeNB-UE-X2AP-ID-Extension						CRITICALITY reject	TYPE UE-X2AP-ID-Extension							PRESENCE optional }|
+	{ ID id-E-RABs-Admitted-ToBeReleased-SgNBRelReqAckList	CRITICALITY ignore	TYPE E-RABs-Admitted-ToBeReleased-SgNBRelReqAckList	PRESENCE optional },
+	...
+}
+*/
+
+struct SgNBReleaseRequestAcknowledge_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
+		void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() { set(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList); type=5;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
+			else if(equal(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
+		void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() { set(ignore); type=5;}
+		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 if(equal(ignore)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(reject)) { type = 4; return true; }
+			else if(equal(ignore)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(reject);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
+		E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList& select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() { return set<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>(5); }
+		E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList const* get_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() const { return get<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<CriticalityDiagnostics>(); break;
+			case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 5: var.destroy<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<CriticalityDiagnostics>(3);
+			v.template operator()<UE_X2AP_ID_Extension>(4);
+			v.template operator()<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_CriticalityDiagnostics()); return true;
+			case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 5: v(select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<CriticalityDiagnostics>()); return true;
+			case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 5: v(var.as<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList)];
+			char dummy3[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID)];
+			char dummy5[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
+		void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() { set(optional); type=5;}
+		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 if(equal(mandatory)) { 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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBReleaseRequestAcknowledge ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{SgNBReleaseRequestAcknowledge-IEs}},
+	...
+}
+*/
+
+struct SgNBReleaseRequestAcknowledge : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBReleaseRequestAcknowledge";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseRequestAcknowledge_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBReleaseRequestAcknowledge_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBReleaseRequestReject-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID							CRITICALITY ignore	TYPE UE-X2AP-ID										PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID							CRITICALITY ignore	TYPE SgNB-UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-Cause									CRITICALITY ignore	TYPE Cause											PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics					CRITICALITY ignore	TYPE CriticalityDiagnostics						PRESENCE optional}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension				CRITICALITY reject	TYPE UE-X2AP-ID-Extension							PRESENCE optional},
+	...
+}
+*/
+
+struct SgNBReleaseRequestReject_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
+		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 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(reject)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(reject);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+			v.template operator()<UE_X2AP_ID_Extension>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); return true;
+			case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); return true;
+			case 5: v(var.as<UE_X2AP_ID_Extension>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID)];
+			char dummy5[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBReleaseRequestReject ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container		{{SgNBReleaseRequestReject-IEs}},
+	...
+}
+*/
+
+struct SgNBReleaseRequestReject : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBReleaseRequestReject";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseRequestReject_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBReleaseRequestReject_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+SgNBReleaseRequired-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-MeNB-UE-X2AP-ID							CRITICALITY reject	TYPE UE-X2AP-ID											PRESENCE mandatory}|
+	{ ID id-SgNB-UE-X2AP-ID							CRITICALITY reject	TYPE SgNB-UE-X2AP-ID										PRESENCE mandatory}|
+	{ ID id-Cause									CRITICALITY ignore	TYPE Cause												PRESENCE mandatory}|
+	{ ID id-MeNB-UE-X2AP-ID-Extension				CRITICALITY reject	TYPE UE-X2AP-ID-Extension							PRESENCE optional }|
+	{ ID id-E-RABs-ToBeReleased-SgNBRelReqdList		CRITICALITY ignore	TYPE E-RABs-ToBeReleased-SgNBRelReqdList		PRESENCE optional },
+	...
+}
+*/
+
+struct SgNBReleaseRequired_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
+		void select_id_Cause() { set(id_Cause); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
+		void select_id_E_RABs_ToBeReleased_SgNBRelReqdList() { set(id_E_RABs_ToBeReleased_SgNBRelReqdList); type=5;}
+		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_MeNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Cause)) { type = 3; return true; }
+			else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
+			else if(equal(id_E_RABs_ToBeReleased_SgNBRelReqdList)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_MeNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelReqdList);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_Cause() { set(ignore); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
+		void select_id_E_RABs_ToBeReleased_SgNBRelReqdList() { set(ignore); type=5;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(ignore)) { type = 3; return true; }
+			else if(equal(reject)) { type = 4; return true; }
+			else if(equal(ignore)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(ignore);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
+		Cause& select_id_Cause() { return set<Cause>(3); }
+		Cause const* get_id_Cause() const { return get<Cause>(3); }
+		UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
+		E_RABs_ToBeReleased_SgNBRelReqdList& select_id_E_RABs_ToBeReleased_SgNBRelReqdList() { return set<E_RABs_ToBeReleased_SgNBRelReqdList>(5); }
+		E_RABs_ToBeReleased_SgNBRelReqdList const* get_id_E_RABs_ToBeReleased_SgNBRelReqdList() const { return get<E_RABs_ToBeReleased_SgNBRelReqdList>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			case 3: var.destroy<Cause>(); break;
+			case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 5: var.destroy<E_RABs_ToBeReleased_SgNBRelReqdList>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<SgNB_UE_X2AP_ID>(2);
+			v.template operator()<Cause>(3);
+			v.template operator()<UE_X2AP_ID_Extension>(4);
+			v.template operator()<E_RABs_ToBeReleased_SgNBRelReqdList>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Cause()); return true;
+			case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
+			case 5: v(select_id_E_RABs_ToBeReleased_SgNBRelReqdList()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
+			case 3: v(var.as<Cause>()); return true;
+			case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 5: v(var.as<E_RABs_ToBeReleased_SgNBRelReqdList>()); 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(E_RABs_ToBeReleased_SgNBRelReqdList)];
+			char dummy3[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID)];
+			char dummy5[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Cause() { set(mandatory); type=3;}
+		void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
+		void select_id_E_RABs_ToBeReleased_SgNBRelReqdList() { set(optional); type=5;}
+		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 if(equal(mandatory)) { type = 2; return true; }
+			else if(equal(mandatory)) { type = 3; return true; }
+			else if(equal(optional)) { type = 4; return true; }
+			else if(equal(optional)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+SgNBReleaseRequired ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{SgNBReleaseRequired-IEs}},
+	...
+}
+*/
+
+struct SgNBReleaseRequired : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "SgNBReleaseRequired";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseRequired_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<SgNBReleaseRequired_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+UEContextRelease-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Old-eNB-UE-X2AP-ID					CRITICALITY reject	TYPE UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-New-eNB-UE-X2AP-ID					CRITICALITY reject	TYPE UE-X2AP-ID									PRESENCE mandatory}|
+	{ ID id-Old-eNB-UE-X2AP-ID-Extension		CRITICALITY reject	TYPE UE-X2AP-ID-Extension						PRESENCE optional}|
+	{ ID id-New-eNB-UE-X2AP-ID-Extension		CRITICALITY reject	TYPE UE-X2AP-ID-Extension						PRESENCE optional}|
+	{ ID id-SIPTO-BearerDeactivationIndication	CRITICALITY ignore	TYPE SIPTOBearerDeactivationIndication		PRESENCE optional}|
+	{ ID id-SgNB-UE-X2AP-ID						CRITICALITY ignore	TYPE SgNB-UE-X2AP-ID							PRESENCE optional},
+	...
+}
+*/
+
+struct UEContextRelease_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=3;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=4;}
+		void select_id_SIPTO_BearerDeactivationIndication() { set(id_SIPTO_BearerDeactivationIndication); type=5;}
+		void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=6;}
+		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_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
+			else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
+			else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 3; return true; }
+			else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
+			else if(equal(id_SIPTO_BearerDeactivationIndication)) { type = 5; return true; }
+			else if(equal(id_SgNB_UE_X2AP_ID)) { 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_Old_eNB_UE_X2AP_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_SIPTO_BearerDeactivationIndication);} return false;
+			case 6: type = 6; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 7; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(reject); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(reject); type=2;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(reject); type=3;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
+		void select_id_SIPTO_BearerDeactivationIndication() { set(ignore); type=5;}
+		void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=6;}
+		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 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
+		UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
+		UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
+		UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
+		UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(3); }
+		UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(3); }
+		UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
+		UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
+		SIPTOBearerDeactivationIndication& select_id_SIPTO_BearerDeactivationIndication() { return set<SIPTOBearerDeactivationIndication>(5); }
+		SIPTOBearerDeactivationIndication const* get_id_SIPTO_BearerDeactivationIndication() const { return get<SIPTOBearerDeactivationIndication>(5); }
+		SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(6); }
+		SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(6); }
+		bool is_unknown() const { return type == 7; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<UE_X2AP_ID>(); break;
+			case 2: var.destroy<UE_X2AP_ID>(); break;
+			case 3: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
+			case 5: var.destroy<SIPTOBearerDeactivationIndication>(); break;
+			case 6: var.destroy<SgNB_UE_X2AP_ID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<UE_X2AP_ID>(1);
+			v.template operator()<UE_X2AP_ID>(2);
+			v.template operator()<UE_X2AP_ID_Extension>(3);
+			v.template operator()<UE_X2AP_ID_Extension>(4);
+			v.template operator()<SIPTOBearerDeactivationIndication>(5);
+			v.template operator()<SgNB_UE_X2AP_ID>(6);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
+			case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
+			case 3: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
+			case 4: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
+			case 5: v(select_id_SIPTO_BearerDeactivationIndication()); return true;
+			case 6: v(select_id_SgNB_UE_X2AP_ID()); 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<UE_X2AP_ID>()); return true;
+			case 2: v(var.as<UE_X2AP_ID>()); return true;
+			case 3: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
+			case 5: v(var.as<SIPTOBearerDeactivationIndication>()); return true;
+			case 6: v(var.as<SgNB_UE_X2AP_ID>()); 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(SIPTOBearerDeactivationIndication)];
+			char dummy2[sizeof(SgNB_UE_X2AP_ID)];
+			char dummy3[sizeof(UE_X2AP_ID)];
+			char dummy4[sizeof(UE_X2AP_ID_Extension)];
+
+		};
+		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 == 7; }
+		void clear() {type = 0;}
+		void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
+		void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=2;}
+		void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=3;}
+		void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
+		void select_id_SIPTO_BearerDeactivationIndication() { set(optional); type=5;}
+		void select_id_SgNB_UE_X2AP_ID() { set(optional); type=6;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+UEContextRelease ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{UEContextRelease-IEs}},
+	...
+}
+*/
+
+struct UEContextRelease : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "UEContextRelease";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<UEContextRelease_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<UEContextRelease_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+X2AP-Message ::= OCTET STRING
+*/
+
+struct X2AP_Message : asn::ostring<>
+{
+	static constexpr const char* name() {return "X2AP-Message";}
+	using parent_t = asn::ostring<>;
+
+};
+
+/*
+X2APMessageTransfer-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-RNL-Header	CRITICALITY reject	TYPE RNL-Header				PRESENCE mandatory}|
+	{ ID id-x2APMessage	CRITICALITY reject	TYPE X2AP-Message			PRESENCE optional},
+	...
+}
+*/
+
+struct X2APMessageTransfer_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_RNL_Header() { set(id_RNL_Header); type=1;}
+		void select_id_x2APMessage() { set(id_x2APMessage); type=2;}
+		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_RNL_Header)) { type = 1; return true; }
+			else if(equal(id_x2APMessage)) { 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_RNL_Header);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_x2APMessage);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_RNL_Header() { set(reject); type=1;}
+		void select_id_x2APMessage() { set(reject); type=2;}
+		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 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(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		RNL_Header& select_id_RNL_Header() { return set<RNL_Header>(1); }
+		RNL_Header const* get_id_RNL_Header() const { return get<RNL_Header>(1); }
+		X2AP_Message& select_id_x2APMessage() { return set<X2AP_Message>(2); }
+		X2AP_Message const* get_id_x2APMessage() const { return get<X2AP_Message>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<RNL_Header>(); break;
+			case 2: var.destroy<X2AP_Message>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<RNL_Header>(1);
+			v.template operator()<X2AP_Message>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_RNL_Header()); return true;
+			case 2: v(select_id_x2APMessage()); 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<RNL_Header>()); return true;
+			case 2: v(var.as<X2AP_Message>()); 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(RNL_Header)];
+			char dummy2[sizeof(X2AP_Message)];
+
+		};
+		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 == 3; }
+		void clear() {type = 0;}
+		void select_id_RNL_Header() { set(mandatory); type=1;}
+		void select_id_x2APMessage() { set(optional); type=2;}
+		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 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(mandatory);} 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};
+
+	};
+
+};
+/*
+X2APMessageTransfer ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{X2APMessageTransfer-IEs}},
+	...
+}
+*/
+
+struct X2APMessageTransfer : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "X2APMessageTransfer";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<X2APMessageTransfer_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<X2APMessageTransfer_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+X2Release-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-GlobalENB-ID			CRITICALITY reject	TYPE GlobalENB-ID			PRESENCE mandatory},
+...
+}
+*/
+
+struct X2Release_IEs
+{
+	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_GlobalENB_ID() { set(id_GlobalENB_ID); 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_GlobalENB_ID)) { 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_GlobalENB_ID);} 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_GlobalENB_ID() { 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;}
+		GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
+		GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
+		bool is_unknown() const { return type == 2; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GlobalENB_ID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GlobalENB_ID>(1);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_GlobalENB_ID()); 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<GlobalENB_ID>()); 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(GlobalENB_ID)];
+
+		};
+		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_GlobalENB_ID() { 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};
+
+	};
+
+};
+/*
+X2Release ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{X2Release-IEs}},
+	...
+}
+*/
+
+struct X2Release : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "X2Release";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<X2Release_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<X2Release_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+X2RemovalFailure-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Cause						CRITICALITY ignore	TYPE Cause							PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics		CRITICALITY ignore	TYPE CriticalityDiagnostics			PRESENCE optional},
+	...
+}
+*/
+
+struct X2RemovalFailure_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(id_Cause); type=1;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
+		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_Cause)) { type = 1; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { 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_Cause);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(ignore); type=1;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
+		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 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		Cause& select_id_Cause() { return set<Cause>(1); }
+		Cause const* get_id_Cause() const { return get<Cause>(1); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Cause>(); break;
+			case 2: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Cause>(1);
+			v.template operator()<CriticalityDiagnostics>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Cause()); return true;
+			case 2: v(select_id_CriticalityDiagnostics()); 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<Cause>()); return true;
+			case 2: v(var.as<CriticalityDiagnostics>()); 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(CriticalityDiagnostics)];
+
+		};
+		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 == 3; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(mandatory); type=1;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=2;}
+		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 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(mandatory);} 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};
+
+	};
+
+};
+/*
+X2RemovalFailure ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{X2RemovalFailure-IEs}},
+	...
+}
+*/
+
+struct X2RemovalFailure : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "X2RemovalFailure";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<X2RemovalFailure_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<X2RemovalFailure_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+X2RemovalRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-GlobalENB-ID				CRITICALITY reject	TYPE GlobalENB-ID			PRESENCE mandatory}|
+	{ ID id-X2RemovalThreshold			CRITICALITY reject	TYPE X2BenefitValue			PRESENCE optional},
+...
+}
+*/
+
+struct X2RemovalRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
+		void select_id_X2RemovalThreshold() { set(id_X2RemovalThreshold); type=2;}
+		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_GlobalENB_ID)) { type = 1; return true; }
+			else if(equal(id_X2RemovalThreshold)) { 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_GlobalENB_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_X2RemovalThreshold);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(reject); type=1;}
+		void select_id_X2RemovalThreshold() { set(reject); type=2;}
+		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 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(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
+		GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
+		X2BenefitValue& select_id_X2RemovalThreshold() { return set<X2BenefitValue>(2); }
+		X2BenefitValue const* get_id_X2RemovalThreshold() const { return get<X2BenefitValue>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GlobalENB_ID>(); break;
+			case 2: var.destroy<X2BenefitValue>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GlobalENB_ID>(1);
+			v.template operator()<X2BenefitValue>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_GlobalENB_ID()); return true;
+			case 2: v(select_id_X2RemovalThreshold()); 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<GlobalENB_ID>()); return true;
+			case 2: v(var.as<X2BenefitValue>()); 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(GlobalENB_ID)];
+			char dummy2[sizeof(X2BenefitValue)];
+
+		};
+		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 == 3; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(mandatory); type=1;}
+		void select_id_X2RemovalThreshold() { set(optional); type=2;}
+		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 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(mandatory);} 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};
+
+	};
+
+};
+/*
+X2RemovalRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{X2RemovalRequest-IEs}},
+	...
+}
+*/
+
+struct X2RemovalRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "X2RemovalRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<X2RemovalRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<X2RemovalRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+X2RemovalResponse-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-GlobalENB-ID				CRITICALITY reject	TYPE GlobalENB-ID				PRESENCE mandatory}|
+	{ ID id-CriticalityDiagnostics		CRITICALITY ignore	TYPE CriticalityDiagnostics		PRESENCE optional},
+	...
+}
+*/
+
+struct X2RemovalResponse_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
+		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_GlobalENB_ID)) { type = 1; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { 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_GlobalENB_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 3; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(reject); type=1;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
+		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 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(reject);} 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
+		GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
+		bool is_unknown() const { return type == 3; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GlobalENB_ID>(); break;
+			case 2: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GlobalENB_ID>(1);
+			v.template operator()<CriticalityDiagnostics>(2);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_GlobalENB_ID()); return true;
+			case 2: v(select_id_CriticalityDiagnostics()); 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<GlobalENB_ID>()); return true;
+			case 2: v(var.as<CriticalityDiagnostics>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(GlobalENB_ID)];
+
+		};
+		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 == 3; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(mandatory); type=1;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=2;}
+		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 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(mandatory);} 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};
+
+	};
+
+};
+/*
+X2RemovalResponse ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{X2RemovalResponse-IEs}},
+	...
+}
+*/
+
+struct X2RemovalResponse : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "X2RemovalResponse";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<X2RemovalResponse_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<X2RemovalResponse_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+X2SetupFailure-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-Cause					CRITICALITY ignore		TYPE Cause								PRESENCE mandatory} |
+	{ ID id-TimeToWait				CRITICALITY ignore		TYPE TimeToWait							PRESENCE optional} |
+	{ ID id-CriticalityDiagnostics	CRITICALITY ignore		TYPE CriticalityDiagnostics				PRESENCE optional },
+
+	...
+}
+*/
+
+struct X2SetupFailure_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(id_Cause); type=1;}
+		void select_id_TimeToWait() { set(id_TimeToWait); type=2;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
+		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_Cause)) { type = 1; return true; }
+			else if(equal(id_TimeToWait)) { type = 2; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { 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_Cause);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_TimeToWait);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 4; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(ignore); type=1;}
+		void select_id_TimeToWait() { set(ignore); type=2;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
+		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 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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		Cause& select_id_Cause() { return set<Cause>(1); }
+		Cause const* get_id_Cause() const { return get<Cause>(1); }
+		TimeToWait& select_id_TimeToWait() { return set<TimeToWait>(2); }
+		TimeToWait const* get_id_TimeToWait() const { return get<TimeToWait>(2); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
+		bool is_unknown() const { return type == 4; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<Cause>(); break;
+			case 2: var.destroy<TimeToWait>(); break;
+			case 3: var.destroy<CriticalityDiagnostics>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<Cause>(1);
+			v.template operator()<TimeToWait>(2);
+			v.template operator()<CriticalityDiagnostics>(3);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_Cause()); return true;
+			case 2: v(select_id_TimeToWait()); return true;
+			case 3: v(select_id_CriticalityDiagnostics()); 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<Cause>()); return true;
+			case 2: v(var.as<TimeToWait>()); return true;
+			case 3: v(var.as<CriticalityDiagnostics>()); 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(CriticalityDiagnostics)];
+			char dummy3[sizeof(TimeToWait)];
+
+		};
+		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 == 4; }
+		void clear() {type = 0;}
+		void select_id_Cause() { set(mandatory); type=1;}
+		void select_id_TimeToWait() { set(optional); type=2;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=3;}
+		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 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(mandatory);} 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};
+
+	};
+
+};
+/*
+X2SetupFailure ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{X2SetupFailure-IEs}},
+	...
+}
+*/
+
+struct X2SetupFailure : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "X2SetupFailure";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<X2SetupFailure_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<X2SetupFailure_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+X2SetupRequest-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-GlobalENB-ID			CRITICALITY reject	TYPE GlobalENB-ID			PRESENCE mandatory}|
+	{ ID id-ServedCells				CRITICALITY reject	TYPE ServedCells			PRESENCE mandatory}|
+	{ ID id-GUGroupIDList			CRITICALITY reject	TYPE GUGroupIDList			PRESENCE optional}|
+	{ ID id-LHN-ID					CRITICALITY ignore	TYPE LHN-ID					PRESENCE optional},
+...
+}
+*/
+
+struct X2SetupRequest_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
+		void select_id_ServedCells() { set(id_ServedCells); type=2;}
+		void select_id_GUGroupIDList() { set(id_GUGroupIDList); type=3;}
+		void select_id_LHN_ID() { set(id_LHN_ID); type=4;}
+		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_GlobalENB_ID)) { type = 1; return true; }
+			else if(equal(id_ServedCells)) { type = 2; return true; }
+			else if(equal(id_GUGroupIDList)) { type = 3; return true; }
+			else if(equal(id_LHN_ID)) { 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_GlobalENB_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedCells);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_GUGroupIDList);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_LHN_ID);} 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_IES::criticality_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 5; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(reject); type=1;}
+		void select_id_ServedCells() { set(reject); type=2;}
+		void select_id_GUGroupIDList() { set(reject); type=3;}
+		void select_id_LHN_ID() { set(ignore); type=4;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(reject)) { 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(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(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 Value_t : asn::typefield<true>
+	{
+		~Value_t()	{clear();}
+		size_t get_index() const {return type;}
+		GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
+		GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
+		ServedCells& select_id_ServedCells() { return set<ServedCells>(2); }
+		ServedCells const* get_id_ServedCells() const { return get<ServedCells>(2); }
+		GUGroupIDList& select_id_GUGroupIDList() { return set<GUGroupIDList>(3); }
+		GUGroupIDList const* get_id_GUGroupIDList() const { return get<GUGroupIDList>(3); }
+		LHN_ID& select_id_LHN_ID() { return set<LHN_ID>(4); }
+		LHN_ID const* get_id_LHN_ID() const { return get<LHN_ID>(4); }
+		bool is_unknown() const { return type == 5; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GlobalENB_ID>(); break;
+			case 2: var.destroy<ServedCells>(); break;
+			case 3: var.destroy<GUGroupIDList>(); break;
+			case 4: var.destroy<LHN_ID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GlobalENB_ID>(1);
+			v.template operator()<ServedCells>(2);
+			v.template operator()<GUGroupIDList>(3);
+			v.template operator()<LHN_ID>(4);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_GlobalENB_ID()); return true;
+			case 2: v(select_id_ServedCells()); return true;
+			case 3: v(select_id_GUGroupIDList()); return true;
+			case 4: v(select_id_LHN_ID()); 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<GlobalENB_ID>()); return true;
+			case 2: v(var.as<ServedCells>()); return true;
+			case 3: v(var.as<GUGroupIDList>()); return true;
+			case 4: v(var.as<LHN_ID>()); 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(GUGroupIDList)];
+			char dummy2[sizeof(GlobalENB_ID)];
+			char dummy3[sizeof(LHN_ID)];
+			char dummy4[sizeof(ServedCells)];
+
+		};
+		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 == 5; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(mandatory); type=1;}
+		void select_id_ServedCells() { set(mandatory); type=2;}
+		void select_id_GUGroupIDList() { set(optional); type=3;}
+		void select_id_LHN_ID() { set(optional); type=4;}
+		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 if(equal(mandatory)) { 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(mandatory);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} 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};
+
+	};
+
+};
+/*
+X2SetupRequest ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{X2SetupRequest-IEs}},
+	...
+}
+*/
+
+struct X2SetupRequest : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "X2SetupRequest";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<X2SetupRequest_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<X2SetupRequest_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};
+/*
+X2SetupResponse-IEs X2AP-PROTOCOL-IES ::= {
+	{ ID id-GlobalENB-ID				CRITICALITY reject	TYPE GlobalENB-ID			PRESENCE mandatory}|
+	{ ID id-ServedCells					CRITICALITY reject	TYPE ServedCells			PRESENCE mandatory}|
+	{ ID id-GUGroupIDList				CRITICALITY reject	TYPE GUGroupIDList			PRESENCE optional}|
+	{ ID id-CriticalityDiagnostics		CRITICALITY ignore	TYPE CriticalityDiagnostics	PRESENCE optional}|
+	{ ID id-LHN-ID						CRITICALITY ignore	TYPE LHN-ID					PRESENCE optional},
+	...
+}
+*/
+
+struct X2SetupResponse_IEs
+{
+	struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
+	{
+		size_t get_index() const {return type;}
+		bool is_unknown() const { return type == 6; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
+		void select_id_ServedCells() { set(id_ServedCells); type=2;}
+		void select_id_GUGroupIDList() { set(id_GUGroupIDList); type=3;}
+		void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
+		void select_id_LHN_ID() { set(id_LHN_ID); type=5;}
+		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_GlobalENB_ID)) { type = 1; return true; }
+			else if(equal(id_ServedCells)) { type = 2; return true; }
+			else if(equal(id_GUGroupIDList)) { type = 3; return true; }
+			else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
+			else if(equal(id_LHN_ID)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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_GlobalENB_ID);} return false;
+			case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedCells);} return false;
+			case 3: type = 3; if(v(ref_nested())) { return equal(id_GUGroupIDList);} return false;
+			case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(id_LHN_ID);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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 == 6; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(reject); type=1;}
+		void select_id_ServedCells() { set(reject); type=2;}
+		void select_id_GUGroupIDList() { set(reject); type=3;}
+		void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
+		void select_id_LHN_ID() { set(ignore); type=5;}
+		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 if(equal(reject)) { type = 2; return true; }
+			else if(equal(reject)) { type = 3; return true; }
+			else if(equal(ignore)) { type = 4; return true; }
+			else if(equal(ignore)) { type = 5; return true; }
+			else { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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(ignore);} return false;
+			case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
+			case 6: type = 6; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<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;}
+		GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
+		GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
+		ServedCells& select_id_ServedCells() { return set<ServedCells>(2); }
+		ServedCells const* get_id_ServedCells() const { return get<ServedCells>(2); }
+		GUGroupIDList& select_id_GUGroupIDList() { return set<GUGroupIDList>(3); }
+		GUGroupIDList const* get_id_GUGroupIDList() const { return get<GUGroupIDList>(3); }
+		CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+		CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+		LHN_ID& select_id_LHN_ID() { return set<LHN_ID>(5); }
+		LHN_ID const* get_id_LHN_ID() const { return get<LHN_ID>(5); }
+		bool is_unknown() const { return type == 6; }
+		void clear()
+		{
+			switch(type)
+			{
+			case 1: var.destroy<GlobalENB_ID>(); break;
+			case 2: var.destroy<ServedCells>(); break;
+			case 3: var.destroy<GUGroupIDList>(); break;
+			case 4: var.destroy<CriticalityDiagnostics>(); break;
+			case 5: var.destroy<LHN_ID>(); break;
+			}
+			type = 0; ref_nested().clear();
+		}
+		template<typename V> static inline void enumerate(V& v)
+		{
+			v.template operator()<GlobalENB_ID>(1);
+			v.template operator()<ServedCells>(2);
+			v.template operator()<GUGroupIDList>(3);
+			v.template operator()<CriticalityDiagnostics>(4);
+			v.template operator()<LHN_ID>(5);
+
+		}
+		protected:
+		template<typename V> bool decode(size_t index, V& v)
+		{
+			clear();
+			switch(index)
+			{
+			case 1: v(select_id_GlobalENB_ID()); return true;
+			case 2: v(select_id_ServedCells()); return true;
+			case 3: v(select_id_GUGroupIDList()); return true;
+			case 4: v(select_id_CriticalityDiagnostics()); return true;
+			case 5: v(select_id_LHN_ID()); return true;
+			case 6: if(type != 6) {clear(); asn::base::set();} type = 6; 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<GlobalENB_ID>()); return true;
+			case 2: v(var.as<ServedCells>()); return true;
+			case 3: v(var.as<GUGroupIDList>()); return true;
+			case 4: v(var.as<CriticalityDiagnostics>()); return true;
+			case 5: v(var.as<LHN_ID>()); 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(CriticalityDiagnostics)];
+			char dummy2[sizeof(GUGroupIDList)];
+			char dummy3[sizeof(GlobalENB_ID)];
+			char dummy4[sizeof(LHN_ID)];
+			char dummy5[sizeof(ServedCells)];
+
+		};
+		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 == 6; }
+		void clear() {type = 0;}
+		void select_id_GlobalENB_ID() { set(mandatory); type=1;}
+		void select_id_ServedCells() { set(mandatory); type=2;}
+		void select_id_GUGroupIDList() { set(optional); type=3;}
+		void select_id_CriticalityDiagnostics() { set(optional); type=4;}
+		void select_id_LHN_ID() { set(optional); type=5;}
+		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 if(equal(mandatory)) { 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 { type = 6; return true;}
+			return false;
+
+		}
+		template<typename V> bool encode(V& 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; if(v(ref_nested())) { return equal(mandatory);} 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; return v(ref_nested());
+			ref_nested().clear();
+			}
+			return false;
+
+		}
+		template<typename V> bool encode(size_t index, V& v) const
+		{
+			if(index != type) {return false;} return v(ref_nested());
+
+		}
+		private:
+		size_t type {0};
+
+	};
+
+};
+/*
+X2SetupResponse ::= SEQUENCE {
+	protocolIEs		ProtocolIE-Container	{{X2SetupResponse-IEs}},
+	...
+}
+*/
+
+struct X2SetupResponse : asn::sequence<1, 0, true, 0>
+{
+	static constexpr const char* name() {return "X2SetupResponse";}
+	using parent_t = asn::sequence<1, 0, true, 0>;
+	struct protocolIEs_t : ProtocolIE_Container<X2SetupResponse_IEs>
+	{
+		static constexpr const char* name() {return "protocolIEs_t";}
+		using parent_t = ProtocolIE_Container<X2SetupResponse_IEs>;
+
+	};
+	protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+	protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+	template<typename V> void decode(V& v)
+	{
+		v(protocolIEs);
+
+	};
+	template<typename V> void encode(V& v) const
+	{
+		v(protocolIEs);
+
+	};
+	void clear()
+	{
+		protocolIEs.clear();
+
+	};
+	private:
+	protocolIEs_t	protocolIEs;
+
+};