sabp: Generate C/H files for SABP; create libosmo-sabp

This uses the (modified) Osmocom asn1c on the (modified) SABP ASN.1
syntax to generate C code + header files for SABP parsing/encoding.

It also adds some helper code for message encoding and decoding as well
as a new libosmo-sabp shared library which can be used by programs to
implement SABP related functionality.

Change-Id: Ib9580d1af96354398da4c9f97b28a0e23d56e275

65 files changed, 8871 insertions, 6 deletions

diff --git a/src/.gitignore b/src/.gitignore
index 55bca01..0b4676f 100644
--- a/src/.gitignore
+++ b/src/.gitignore
@@ -7,4 +7,7 @@ rua_encoder.c
 ranap_decoder.c
 ranap_encoder.c
 
+sabp_decoder.c
+sabp_encoder.c
+
 hnbgw
diff --git a/src/Makefile.am b/src/Makefile.am
index 928092f..b1f8153 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,10 +1,10 @@
-SUBDIRS = hnbap rua ranap tests
+SUBDIRS = hnbap rua ranap sabp tests
 
 # Build {hnbap,rua,ranap}_{encoder,decoder}.c using asn1tostruct
 ASN1_ROOT = $(top_srcdir)/asn1
 ASN1TOSTRUCT = $(ASN1_ROOT)/utils/asn1tostruct.py
-BUILT_SOURCES = hnbap_decoder.c hnbap_encoder.c rua_decoder.c rua_encoder.c \
-	gen_hnbap.stamp gen_rua.stamp gen_ranap.stamp
+BUILT_SOURCES = hnbap_decoder.c hnbap_encoder.c rua_decoder.c rua_encoder.c sabp_encoder.c sabp_decoder.c \
+	gen_hnbap.stamp gen_rua.stamp gen_ranap.stamp gen_sabp.stamp
 
 gen_hnbap.stamp: $(ASN1_ROOT)/hnbap/HNBAP-PDU-Contents.asn $(ASN1TOSTRUCT)
 	$(ASN1TOSTRUCT) -f $<
@@ -42,20 +42,40 @@ gen_ranap.stamp: $(ASN1_ROOT)/ranap/RANAP-PDU-Contents.asn $(ASN1TOSTRUCT)
 
 ranap_decoder.c ranap_encoder.c: gen_ranap.stamp
 
+gen_sabp.stamp: $(ASN1_ROOT)/sabp/SABP-PDU-Contents.asn $(ASN1TOSTRUCT)
+	$(ASN1TOSTRUCT) -p SABP_ -f $<
+#	We also need to replace the include in the newly generated .c files:
+	sed -i 's,^#include "sabp_ies_defs.h",#include <osmocom/sabp/sabp_ies_defs.h>,' sabp_encoder.c sabp_decoder.c
+	sed -i 's,^#include "sabp_common.h",#include <osmocom/sabp/sabp_common.h>,' sabp_encoder.c sabp_decoder.c sabp_ies_defs.h
+	mv sabp_ies_defs.h $(top_builddir)/include/osmocom/sabp/
+#	this is ugly ^. sabp_ies_defs.h is generated from asn1tostruct.py here, but
+#	it should live in include/osmocom/sabp/.
+	touch $(top_builddir)/src/$@
+
+sabp_decoder.c sabp_encoder.c: gen_sabp.stamp
+
+
 AM_CFLAGS = -Wall -I$(top_srcdir)/include -I$(top_builddir)/include \
 	    $(OSMOCORE_CFLAGS) $(OSMOVTY_CFLAGS) $(OSMOCTRL_CFLAGS) $(OSMOGSM_CFLAGS) \
 	    $(OSMONETIF_CFLAGS) $(ASN1C_CFLAGS) $(OSMOSIGTRAN_CFLAGS)
 
-# build the shared RANAP library
+# build the shared RANAP + SABP library
 #
 RANAP_LIBVERSION=2:2:0
-lib_LTLIBRARIES = libosmo-ranap.la
+SABP_LIBVERSION=0:0:0
+lib_LTLIBRARIES = libosmo-ranap.la libosmo-sabp.la
 libosmo_ranap_la_LDFLAGS = $(AM_LDFLAGS) -version-info $(RANAP_LIBVERSION)
 libosmo_ranap_la_LIBADD = $(OSMOCORE_LIBS) $(OSMOGSM_LIBS) $(OSMOVTY_LIBS) $(OSMOSIGTRAN_LIBS) \
 			  $(ASN1C_LIBS) ranap/libosmo-asn1-ranap.la
 libosmo_ranap_la_SOURCES = ranap_common.c ranap_encoder.c ranap_decoder.c ranap_msg_factory.c iu_helpers.c \
 			   ranap_common_cn.c iu_client.c iu_client_vty.c
 
+libosmo_sabp_la_LDFLAGS = $(AM_LDFLAGS) -version-info $(SABP_LIBVERSION)
+libosmo_sabp_la_LIBADD = $(OSMOCORE_LIBS) $(OSMOGSM_LIBS) $(OSMOVTY_LIBS) $(OSMOSIGTRAN_LIBS) \
+			  $(ASN1C_LIBS) sabp/libosmo-asn1-sabp.la
+libosmo_sabp_la_SOURCES = sabp_common.c sabp_encoder.c sabp_decoder.c 
+
+
 # build the actual HomeNodeB gateway
 #
 bin_PROGRAMS = osmo-hnbgw
@@ -80,6 +100,7 @@ regenerate-from-asn1-source:
 	$(MAKE) -C hnbap regen
 	$(MAKE) -C ranap regen
 	$(MAKE) -C rua regen
+	$(MAKE) -C sabp regen
 
 DISTCLEANFILES = \
 	hnbap_decoder.c \
@@ -88,6 +109,9 @@ DISTCLEANFILES = \
 	rua_encoder.c \
 	ranap_decoder.c \
 	ranap_encoder.c \
+	sabp_decoder.c \
+	sabp_encoder.c \
 	gen_hnbap.stamp \
 	gen_rua.stamp \
-	gen_ranap.stamp
+	gen_ranap.stamp \
+	gen_sabp.stamp
diff --git a/src/sabp/Makefile.am b/src/sabp/Makefile.am
new file mode 100644
index 0000000..a30674c
--- /dev/null
+++ b/src/sabp/Makefile.am
@@ -0,0 +1,148 @@
+ASN_MODULE_SRC=	\
+	SABP_InitiatingMessage.c	\
+	SABP_SABP-PDU.c	\
+	SABP_SuccessfulOutcome.c	\
+	SABP_UnsuccessfulOutcome.c	\
+	SABP_Criticality.c	\
+	SABP_Presence.c	\
+	SABP_ProcedureCode.c	\
+	SABP_ProtocolExtensionID.c	\
+	SABP_ProtocolIE-ID.c	\
+	SABP_TriggeringMessage.c	\
+	SABP_IE-Extensions.c	\
+	SABP_Available-Bandwidth.c	\
+	SABP_Broadcast-Message-Content.c	\
+	SABP_Broadcast-Message-Content-Validity-Indicator.c	\
+	SABP_Category.c	\
+	SABP_Cause.c	\
+	SABP_Criticality-Diagnostics.c	\
+	SABP_CriticalityDiagnostics-IE-List.c	\
+	SABP_MessageStructure.c	\
+	SABP_Data-Coding-Scheme.c	\
+	SABP_Failure-List.c	\
+	SABP_Failure-List-Item.c	\
+	SABP_Message-Identifier.c	\
+	SABP_New-Serial-Number.c	\
+	SABP_Number-of-Broadcasts-Completed-List.c	\
+	SABP_Number-of-Broadcasts-Completed-List-Item.c	\
+	SABP_Number-Of-Broadcasts-Completed-Info.c	\
+	SABP_Number-of-Broadcasts-Requested.c	\
+	SABP_Old-Serial-Number.c	\
+	SABP_Paging-ETWS-Indicator.c	\
+	SABP_Radio-Resource-Loading-List.c	\
+	SABP_Radio-Resource-Loading-List-Item.c	\
+	SABP_Recovery-Indication.c	\
+	SABP_RepetitionNumber0.c	\
+	SABP_RepetitionNumber1.c	\
+	SABP_Repetition-Period.c	\
+	SABP_Serial-Number.c	\
+	SABP_Service-Area-Identifier.c	\
+	SABP_Service-Areas-List.c	\
+	SABP_TypeOfError.c	\
+	SABP_WarningSecurityInfo.c	\
+	SABP_Warning-Type.c	\
+	SABP_Write-Replace.c	\
+	SABP_Write-Replace-Complete.c	\
+	SABP_Write-Replace-Failure.c	\
+	SABP_Kill.c	\
+	SABP_Kill-Complete.c	\
+	SABP_Kill-Failure.c	\
+	SABP_Load-Query.c	\
+	SABP_Load-Query-Complete.c	\
+	SABP_Load-Query-Failure.c	\
+	SABP_Message-Status-Query.c	\
+	SABP_Message-Status-Query-Complete.c	\
+	SABP_Message-Status-Query-Failure.c	\
+	SABP_Reset.c	\
+	SABP_Reset-Complete.c	\
+	SABP_Reset-Failure.c	\
+	SABP_Restart.c	\
+	SABP_Failure.c	\
+	SABP_Error-Indication.c	\
+	SABP_IE.c \
+	$(NULL)
+
+ASN_MODULE_INC=	\
+	SABP_InitiatingMessage.h	\
+	SABP_SABP-PDU.h	\
+	SABP_SuccessfulOutcome.h	\
+	SABP_UnsuccessfulOutcome.h	\
+	SABP_Criticality.h	\
+	SABP_Presence.h	\
+	SABP_ProcedureCode.h	\
+	SABP_ProtocolExtensionID.h	\
+	SABP_ProtocolIE-ID.h	\
+	SABP_TriggeringMessage.h	\
+	SABP_IE-Extensions.h	\
+	SABP_Available-Bandwidth.h	\
+	SABP_Broadcast-Message-Content.h	\
+	SABP_Broadcast-Message-Content-Validity-Indicator.h	\
+	SABP_Category.h	\
+	SABP_Cause.h	\
+	SABP_Criticality-Diagnostics.h	\
+	SABP_CriticalityDiagnostics-IE-List.h	\
+	SABP_MessageStructure.h	\
+	SABP_Data-Coding-Scheme.h	\
+	SABP_Failure-List.h	\
+	SABP_Failure-List-Item.h	\
+	SABP_Message-Identifier.h	\
+	SABP_New-Serial-Number.h	\
+	SABP_Number-of-Broadcasts-Completed-List.h	\
+	SABP_Number-of-Broadcasts-Completed-List-Item.h	\
+	SABP_Number-Of-Broadcasts-Completed-Info.h	\
+	SABP_Number-of-Broadcasts-Requested.h	\
+	SABP_Old-Serial-Number.h	\
+	SABP_Paging-ETWS-Indicator.h	\
+	SABP_Radio-Resource-Loading-List.h	\
+	SABP_Radio-Resource-Loading-List-Item.h	\
+	SABP_Recovery-Indication.h	\
+	SABP_RepetitionNumber0.h	\
+	SABP_RepetitionNumber1.h	\
+	SABP_Repetition-Period.h	\
+	SABP_Serial-Number.h	\
+	SABP_Service-Area-Identifier.h	\
+	SABP_Service-Areas-List.h	\
+	SABP_TypeOfError.h	\
+	SABP_WarningSecurityInfo.h	\
+	SABP_Warning-Type.h	\
+	SABP_Write-Replace.h	\
+	SABP_Write-Replace-Complete.h	\
+	SABP_Write-Replace-Failure.h	\
+	SABP_Kill.h	\
+	SABP_Kill-Complete.h	\
+	SABP_Kill-Failure.h	\
+	SABP_Load-Query.h	\
+	SABP_Load-Query-Complete.h	\
+	SABP_Load-Query-Failure.h	\
+	SABP_Message-Status-Query.h	\
+	SABP_Message-Status-Query-Complete.h	\
+	SABP_Message-Status-Query-Failure.h	\
+	SABP_Reset.h	\
+	SABP_Reset-Complete.h	\
+	SABP_Reset-Failure.h	\
+	SABP_Restart.h	\
+	SABP_Failure.h	\
+	SABP_Error-Indication.h	\
+	SABP_IE.h \
+	$(NULL)
+
+AM_CFLAGS = -I$(top_srcdir)/include $(ASN1C_CFLAGS) $(OSMOCORE_CFLAGS)
+
+noinst_LTLIBRARIES=libosmo-asn1-sabp.la
+libosmo_asn1_sabp_la_SOURCES=$(ASN_MODULE_SRC)
+libosmo_asn1_sabp_la_LIBADD=$(ASN1C_LDADD)
+
+regen: regenerate-from-asn1-source
+
+regenerate-from-asn1-source:
+	ASN1C_PREFIX="SABP_" asn1c -gen-PER $(top_srcdir)/asn1/sabp/SABP-CommonDataTypes.asn $(top_srcdir)/asn1/sabp/SABP-Constants.asn $(top_srcdir)/asn1/sabp/SABP-IEs.asn $(top_srcdir)/asn1/sabp/SABP-PDU.asn
+#	remove the local copy of the runtime code
+	@rm ANY.* INTEGER.* NativeEnumerated.* NativeInteger.* asn_* OCTET_STRING.* converter-sample.c per_* xer_* constr* der_* ber_* BIT_STRING.*
+#	change include style to `#include <dir/foo.h>'
+	sed -i 's/Member/MemberA/' SABP_MessageStructure.[ch]
+	sed -i 's/Member/MemberB/' SABP_Criticality-Diagnostics.[ch]
+#	add missing includes
+	sed -i '/#include "SABP_Serial-Number.h"/a #include <constr_CHOICE.h>' SABP_Old-Serial-Number.h SABP_New-Serial-Number.h
+#	change include style to `#include <dir/foo.h>'
+	$(top_srcdir)/move-asn1-header-files.sh osmocom/sabp $(ASN_MODULE_INC)
+
diff --git a/src/sabp/SABP_Available-Bandwidth.c b/src/sabp/SABP_Available-Bandwidth.c
new file mode 100644
index 0000000..491c69b
--- /dev/null
+++ b/src/sabp/SABP_Available-Bandwidth.c
@@ -0,0 +1,165 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Available-Bandwidth.h>
+
+int
+SABP_Available_Bandwidth_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0l && value <= 20480l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Available_Bandwidth_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeInteger.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeInteger.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+SABP_Available_Bandwidth_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Available_Bandwidth_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Available_Bandwidth_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Available_Bandwidth_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Available_Bandwidth_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Available_Bandwidth_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Available_Bandwidth_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Available_Bandwidth_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Available_Bandwidth_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Available_Bandwidth_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Available_Bandwidth_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Available_Bandwidth_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Available_Bandwidth_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Available_Bandwidth_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Available_Bandwidth_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Available_Bandwidth_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Available_Bandwidth_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Available_Bandwidth_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Available_Bandwidth_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Available_Bandwidth_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Available_Bandwidth_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 15,  15,  0l,  20480l }	/* (0..20480) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Available_Bandwidth_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Available_Bandwidth = {
+	"SABP_Available-Bandwidth",
+	"SABP_Available-Bandwidth",
+	SABP_Available_Bandwidth_free,
+	SABP_Available_Bandwidth_print,
+	SABP_Available_Bandwidth_constraint,
+	SABP_Available_Bandwidth_decode_ber,
+	SABP_Available_Bandwidth_encode_der,
+	SABP_Available_Bandwidth_decode_xer,
+	SABP_Available_Bandwidth_encode_xer,
+	SABP_Available_Bandwidth_decode_uper,
+	SABP_Available_Bandwidth_encode_uper,
+	SABP_Available_Bandwidth_decode_aper,
+	SABP_Available_Bandwidth_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Available_Bandwidth_tags_1,
+	sizeof(asn_DEF_SABP_Available_Bandwidth_tags_1)
+		/sizeof(asn_DEF_SABP_Available_Bandwidth_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Available_Bandwidth_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Available_Bandwidth_tags_1)
+		/sizeof(asn_DEF_SABP_Available_Bandwidth_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Available_Bandwidth_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_Broadcast-Message-Content-Validity-Indicator.c b/src/sabp/SABP_Broadcast-Message-Content-Validity-Indicator.c
new file mode 100644
index 0000000..698863b
--- /dev/null
+++ b/src/sabp/SABP_Broadcast-Message-Content-Validity-Indicator.c
@@ -0,0 +1,165 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Broadcast-Message-Content-Validity-Indicator.h>
+
+int
+SABP_Broadcast_Message_Content_Validity_Indicator_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Broadcast_Message_Content_Validity_Indicator_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeEnumerated.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeEnumerated.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+SABP_Broadcast_Message_Content_Validity_Indicator_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Broadcast_Message_Content_Validity_Indicator_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Broadcast_Message_Content_Validity_Indicator_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Broadcast_Message_Content_Validity_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Broadcast_Message_Content_Validity_Indicator_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Broadcast_Message_Content_Validity_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Broadcast_Message_Content_Validity_Indicator_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Broadcast_Message_Content_Validity_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Broadcast_Message_Content_Validity_Indicator_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Broadcast_Message_Content_Validity_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Broadcast_Message_Content_Validity_Indicator_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Broadcast_Message_Content_Validity_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Broadcast_Message_Content_Validity_Indicator_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Broadcast_Message_Content_Validity_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Broadcast_Message_Content_Validity_Indicator_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Broadcast_Message_Content_Validity_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Broadcast_Message_Content_Validity_Indicator_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Broadcast_Message_Content_Validity_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Broadcast_Message_Content_Validity_Indicator_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Broadcast_Message_Content_Validity_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Broadcast_Message_Content_Validity_Indicator_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  0,  0,  0l,  0l }	/* (0..0,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_SABP_Broadcast_Message_Content_Validity_Indicator_value2enum_1[] = {
+	{ 0,	35,	"broadcast-Message-Content-not-valid" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_SABP_Broadcast_Message_Content_Validity_Indicator_enum2value_1[] = {
+	0	/* broadcast-Message-Content-not-valid(0) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_SABP_Broadcast_Message_Content_Validity_Indicator_specs_1 = {
+	asn_MAP_SABP_Broadcast_Message_Content_Validity_Indicator_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_SABP_Broadcast_Message_Content_Validity_Indicator_enum2value_1,	/* N => "tag"; sorted by N */
+	1,	/* Number of elements in the maps */
+	2,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Broadcast_Message_Content_Validity_Indicator_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Broadcast_Message_Content_Validity_Indicator = {
+	"SABP_Broadcast-Message-Content-Validity-Indicator",
+	"SABP_Broadcast-Message-Content-Validity-Indicator",
+	SABP_Broadcast_Message_Content_Validity_Indicator_free,
+	SABP_Broadcast_Message_Content_Validity_Indicator_print,
+	SABP_Broadcast_Message_Content_Validity_Indicator_constraint,
+	SABP_Broadcast_Message_Content_Validity_Indicator_decode_ber,
+	SABP_Broadcast_Message_Content_Validity_Indicator_encode_der,
+	SABP_Broadcast_Message_Content_Validity_Indicator_decode_xer,
+	SABP_Broadcast_Message_Content_Validity_Indicator_encode_xer,
+	SABP_Broadcast_Message_Content_Validity_Indicator_decode_uper,
+	SABP_Broadcast_Message_Content_Validity_Indicator_encode_uper,
+	SABP_Broadcast_Message_Content_Validity_Indicator_decode_aper,
+	SABP_Broadcast_Message_Content_Validity_Indicator_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Broadcast_Message_Content_Validity_Indicator_tags_1,
+	sizeof(asn_DEF_SABP_Broadcast_Message_Content_Validity_Indicator_tags_1)
+		/sizeof(asn_DEF_SABP_Broadcast_Message_Content_Validity_Indicator_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Broadcast_Message_Content_Validity_Indicator_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Broadcast_Message_Content_Validity_Indicator_tags_1)
+		/sizeof(asn_DEF_SABP_Broadcast_Message_Content_Validity_Indicator_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Broadcast_Message_Content_Validity_Indicator_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_SABP_Broadcast_Message_Content_Validity_Indicator_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Broadcast-Message-Content.c b/src/sabp/SABP_Broadcast-Message-Content.c
new file mode 100644
index 0000000..8c21f26
--- /dev/null
+++ b/src/sabp/SABP_Broadcast-Message-Content.c
@@ -0,0 +1,171 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Broadcast-Message-Content.h>
+
+int
+SABP_Broadcast_Message_Content_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(st->size > 0) {
+		/* Size in bits */
+		size = 8 * st->size - (st->bits_unused & 0x07);
+	} else {
+		size = 0;
+	}
+	
+	if((size >= 1l && size <= 9968l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using BIT_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Broadcast_Message_Content_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_BIT_STRING.free_struct;
+	td->print_struct   = asn_DEF_BIT_STRING.print_struct;
+	td->check_constraints = asn_DEF_BIT_STRING.check_constraints;
+	td->ber_decoder    = asn_DEF_BIT_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_BIT_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_BIT_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_BIT_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_BIT_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_BIT_STRING.uper_encoder;
+	td->aper_decoder   = asn_DEF_BIT_STRING.aper_decoder;
+	td->aper_encoder   = asn_DEF_BIT_STRING.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_BIT_STRING.per_constraints;
+	td->elements       = asn_DEF_BIT_STRING.elements;
+	td->elements_count = asn_DEF_BIT_STRING.elements_count;
+	td->specifics      = asn_DEF_BIT_STRING.specifics;
+}
+
+void
+SABP_Broadcast_Message_Content_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Broadcast_Message_Content_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Broadcast_Message_Content_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Broadcast_Message_Content_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Broadcast_Message_Content_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Broadcast_Message_Content_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Broadcast_Message_Content_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Broadcast_Message_Content_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Broadcast_Message_Content_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Broadcast_Message_Content_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Broadcast_Message_Content_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Broadcast_Message_Content_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Broadcast_Message_Content_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Broadcast_Message_Content_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Broadcast_Message_Content_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Broadcast_Message_Content_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Broadcast_Message_Content_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Broadcast_Message_Content_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Broadcast_Message_Content_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Broadcast_Message_Content_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Broadcast_Message_Content_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 14,  14,  1l,  9968l }	/* (SIZE(1..9968)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Broadcast_Message_Content_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Broadcast_Message_Content = {
+	"SABP_Broadcast-Message-Content",
+	"SABP_Broadcast-Message-Content",
+	SABP_Broadcast_Message_Content_free,
+	SABP_Broadcast_Message_Content_print,
+	SABP_Broadcast_Message_Content_constraint,
+	SABP_Broadcast_Message_Content_decode_ber,
+	SABP_Broadcast_Message_Content_encode_der,
+	SABP_Broadcast_Message_Content_decode_xer,
+	SABP_Broadcast_Message_Content_encode_xer,
+	SABP_Broadcast_Message_Content_decode_uper,
+	SABP_Broadcast_Message_Content_encode_uper,
+	SABP_Broadcast_Message_Content_decode_aper,
+	SABP_Broadcast_Message_Content_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Broadcast_Message_Content_tags_1,
+	sizeof(asn_DEF_SABP_Broadcast_Message_Content_tags_1)
+		/sizeof(asn_DEF_SABP_Broadcast_Message_Content_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Broadcast_Message_Content_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Broadcast_Message_Content_tags_1)
+		/sizeof(asn_DEF_SABP_Broadcast_Message_Content_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Broadcast_Message_Content_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_Category.c b/src/sabp/SABP_Category.c
new file mode 100644
index 0000000..4bb9d82
--- /dev/null
+++ b/src/sabp/SABP_Category.c
@@ -0,0 +1,171 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Category.h>
+
+int
+SABP_Category_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Category_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeEnumerated.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeEnumerated.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+SABP_Category_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Category_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Category_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Category_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Category_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Category_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Category_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Category_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Category_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Category_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Category_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Category_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Category_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Category_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Category_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Category_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Category_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Category_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Category_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Category_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Category_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0l,  3l }	/* (0..3,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_SABP_Category_value2enum_1[] = {
+	{ 0,	13,	"high-priority" },
+	{ 1,	19,	"background-priority" },
+	{ 2,	15,	"normal-priority" },
+	{ 3,	16,	"default-priority" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_SABP_Category_enum2value_1[] = {
+	1,	/* background-priority(1) */
+	3,	/* default-priority(3) */
+	0,	/* high-priority(0) */
+	2	/* normal-priority(2) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_SABP_Category_specs_1 = {
+	asn_MAP_SABP_Category_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_SABP_Category_enum2value_1,	/* N => "tag"; sorted by N */
+	4,	/* Number of elements in the maps */
+	5,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Category_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Category = {
+	"SABP_Category",
+	"SABP_Category",
+	SABP_Category_free,
+	SABP_Category_print,
+	SABP_Category_constraint,
+	SABP_Category_decode_ber,
+	SABP_Category_encode_der,
+	SABP_Category_decode_xer,
+	SABP_Category_encode_xer,
+	SABP_Category_decode_uper,
+	SABP_Category_encode_uper,
+	SABP_Category_decode_aper,
+	SABP_Category_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Category_tags_1,
+	sizeof(asn_DEF_SABP_Category_tags_1)
+		/sizeof(asn_DEF_SABP_Category_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Category_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Category_tags_1)
+		/sizeof(asn_DEF_SABP_Category_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Category_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_SABP_Category_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Cause.c b/src/sabp/SABP_Cause.c
new file mode 100644
index 0000000..389c47f
--- /dev/null
+++ b/src/sabp/SABP_Cause.c
@@ -0,0 +1,165 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Cause.h>
+
+int
+SABP_Cause_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0l && value <= 255l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Cause_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeInteger.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeInteger.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+SABP_Cause_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Cause_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Cause_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Cause_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Cause_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Cause_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Cause_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Cause_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Cause_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Cause_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Cause_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Cause_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Cause_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Cause_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Cause_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Cause_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Cause_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Cause_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Cause_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Cause_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Cause_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 8,  8,  0l,  255l }	/* (0..255) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Cause_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Cause = {
+	"SABP_Cause",
+	"SABP_Cause",
+	SABP_Cause_free,
+	SABP_Cause_print,
+	SABP_Cause_constraint,
+	SABP_Cause_decode_ber,
+	SABP_Cause_encode_der,
+	SABP_Cause_decode_xer,
+	SABP_Cause_encode_xer,
+	SABP_Cause_decode_uper,
+	SABP_Cause_encode_uper,
+	SABP_Cause_decode_aper,
+	SABP_Cause_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Cause_tags_1,
+	sizeof(asn_DEF_SABP_Cause_tags_1)
+		/sizeof(asn_DEF_SABP_Cause_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Cause_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Cause_tags_1)
+		/sizeof(asn_DEF_SABP_Cause_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Cause_constr_1,
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_Criticality-Diagnostics.c b/src/sabp/SABP_Criticality-Diagnostics.c
new file mode 100644
index 0000000..76ef94f
--- /dev/null
+++ b/src/sabp/SABP_Criticality-Diagnostics.c
@@ -0,0 +1,103 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Criticality-Diagnostics.h>
+
+static asn_TYPE_member_t asn_MBR_SABP_Criticality_Diagnostics_1[] = {
+	{ ATF_POINTER, 5, offsetof(struct SABP_Criticality_Diagnostics, procedureCode),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_ProcedureCode,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"procedureCode"
+		},
+	{ ATF_POINTER, 4, offsetof(struct SABP_Criticality_Diagnostics, triggeringMessage),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_TriggeringMessage,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"triggeringMessage"
+		},
+	{ ATF_POINTER, 3, offsetof(struct SABP_Criticality_Diagnostics, procedureCriticality),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_Criticality,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"procedureCriticality"
+		},
+	{ ATF_POINTER, 2, offsetof(struct SABP_Criticality_Diagnostics, iEsCriticalityDiagnostics),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_CriticalityDiagnostics_IE_List,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iEsCriticalityDiagnostics"
+		},
+	{ ATF_POINTER, 1, offsetof(struct SABP_Criticality_Diagnostics, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_SABP_Criticality_Diagnostics_oms_1[] = { 0, 1, 2, 3, 4 };
+static const ber_tlv_tag_t asn_DEF_SABP_Criticality_Diagnostics_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Criticality_Diagnostics_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* procedureCode */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* triggeringMessage */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* procedureCriticality */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* iEsCriticalityDiagnostics */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Criticality_Diagnostics_specs_1 = {
+	sizeof(struct SABP_Criticality_Diagnostics),
+	offsetof(struct SABP_Criticality_Diagnostics, _asn_ctx),
+	asn_MAP_SABP_Criticality_Diagnostics_tag2el_1,
+	5,	/* Count of tags in the map */
+	asn_MAP_SABP_Criticality_Diagnostics_oms_1,	/* Optional members */
+	5, 0,	/* Root/Additions */
+	4,	/* Start extensions */
+	6	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Criticality_Diagnostics = {
+	"SABP_Criticality-Diagnostics",
+	"SABP_Criticality-Diagnostics",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Criticality_Diagnostics_tags_1,
+	sizeof(asn_DEF_SABP_Criticality_Diagnostics_tags_1)
+		/sizeof(asn_DEF_SABP_Criticality_Diagnostics_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Criticality_Diagnostics_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Criticality_Diagnostics_tags_1)
+		/sizeof(asn_DEF_SABP_Criticality_Diagnostics_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Criticality_Diagnostics_1,
+	5,	/* Elements count */
+	&asn_SPC_SABP_Criticality_Diagnostics_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Criticality.c b/src/sabp/SABP_Criticality.c
new file mode 100644
index 0000000..15a7b26
--- /dev/null
+++ b/src/sabp/SABP_Criticality.c
@@ -0,0 +1,167 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-CommonDataTypes"
+ * 	found in "../../asn1/sabp/SABP-CommonDataTypes.asn"
+ */
+
+#include <osmocom/sabp/SABP_Criticality.h>
+
+int
+SABP_Criticality_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Criticality_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeEnumerated.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeEnumerated.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+SABP_Criticality_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Criticality_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Criticality_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Criticality_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Criticality_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Criticality_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Criticality_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Criticality_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Criticality_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Criticality_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Criticality_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Criticality_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Criticality_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Criticality_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Criticality_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Criticality_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Criticality_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Criticality_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Criticality_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Criticality_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Criticality_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 2,  2,  0l,  2l }	/* (0..2) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_SABP_Criticality_value2enum_1[] = {
+	{ 0,	6,	"reject" },
+	{ 1,	6,	"ignore" },
+	{ 2,	6,	"notify" }
+};
+static const unsigned int asn_MAP_SABP_Criticality_enum2value_1[] = {
+	1,	/* ignore(1) */
+	2,	/* notify(2) */
+	0	/* reject(0) */
+};
+static const asn_INTEGER_specifics_t asn_SPC_SABP_Criticality_specs_1 = {
+	asn_MAP_SABP_Criticality_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_SABP_Criticality_enum2value_1,	/* N => "tag"; sorted by N */
+	3,	/* Number of elements in the maps */
+	0,	/* Enumeration is not extensible */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Criticality_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Criticality = {
+	"SABP_Criticality",
+	"SABP_Criticality",
+	SABP_Criticality_free,
+	SABP_Criticality_print,
+	SABP_Criticality_constraint,
+	SABP_Criticality_decode_ber,
+	SABP_Criticality_encode_der,
+	SABP_Criticality_decode_xer,
+	SABP_Criticality_encode_xer,
+	SABP_Criticality_decode_uper,
+	SABP_Criticality_encode_uper,
+	SABP_Criticality_decode_aper,
+	SABP_Criticality_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Criticality_tags_1,
+	sizeof(asn_DEF_SABP_Criticality_tags_1)
+		/sizeof(asn_DEF_SABP_Criticality_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Criticality_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Criticality_tags_1)
+		/sizeof(asn_DEF_SABP_Criticality_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Criticality_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_SABP_Criticality_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_CriticalityDiagnostics-IE-List.c b/src/sabp/SABP_CriticalityDiagnostics-IE-List.c
new file mode 100644
index 0000000..8d5c403
--- /dev/null
+++ b/src/sabp/SABP_CriticalityDiagnostics-IE-List.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_CriticalityDiagnostics-IE-List.h>
+
+static asn_per_constraints_t asn_PER_type_SABP_CriticalityDiagnostics_IE_List_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 8,  8,  1l,  256l }	/* (SIZE(1..256)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_Member_2[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Member, iECriticality),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_Criticality,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iECriticality"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Member, iE_ID),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_ProtocolIE_ID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-ID"
+		},
+	{ ATF_POINTER, 2, offsetof(struct Member, repetitionNumber),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_RepetitionNumber0,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"repetitionNumber"
+		},
+	{ ATF_POINTER, 1, offsetof(struct Member, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_Member_oms_2[] = { 2, 3 };
+static const ber_tlv_tag_t asn_DEF_Member_tags_2[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_Member_tag2el_2[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* iECriticality */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* iE-ID */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* repetitionNumber */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_Member_specs_2 = {
+	sizeof(struct Member),
+	offsetof(struct Member, _asn_ctx),
+	asn_MAP_Member_tag2el_2,
+	4,	/* Count of tags in the map */
+	asn_MAP_Member_oms_2,	/* Optional members */
+	2, 0,	/* Root/Additions */
+	3,	/* Start extensions */
+	5	/* Stop extensions */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_Member_2 = {
+	"SEQUENCE",
+	"SEQUENCE",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Member_tags_2,
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	asn_DEF_Member_tags_2,	/* Same as above */
+	sizeof(asn_DEF_Member_tags_2)
+		/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_Member_2,
+	4,	/* Elements count */
+	&asn_SPC_Member_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_CriticalityDiagnostics_IE_List_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_Member_2,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_CriticalityDiagnostics_IE_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_SABP_CriticalityDiagnostics_IE_List_specs_1 = {
+	sizeof(struct SABP_CriticalityDiagnostics_IE_List),
+	offsetof(struct SABP_CriticalityDiagnostics_IE_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_CriticalityDiagnostics_IE_List = {
+	"SABP_CriticalityDiagnostics-IE-List",
+	"SABP_CriticalityDiagnostics-IE-List",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_CriticalityDiagnostics_IE_List_tags_1,
+	sizeof(asn_DEF_SABP_CriticalityDiagnostics_IE_List_tags_1)
+		/sizeof(asn_DEF_SABP_CriticalityDiagnostics_IE_List_tags_1[0]), /* 1 */
+	asn_DEF_SABP_CriticalityDiagnostics_IE_List_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_CriticalityDiagnostics_IE_List_tags_1)
+		/sizeof(asn_DEF_SABP_CriticalityDiagnostics_IE_List_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_CriticalityDiagnostics_IE_List_constr_1,
+	asn_MBR_SABP_CriticalityDiagnostics_IE_List_1,
+	1,	/* Single element */
+	&asn_SPC_SABP_CriticalityDiagnostics_IE_List_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Data-Coding-Scheme.c b/src/sabp/SABP_Data-Coding-Scheme.c
new file mode 100644
index 0000000..e04f69d
--- /dev/null
+++ b/src/sabp/SABP_Data-Coding-Scheme.c
@@ -0,0 +1,171 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Data-Coding-Scheme.h>
+
+int
+SABP_Data_Coding_Scheme_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(st->size > 0) {
+		/* Size in bits */
+		size = 8 * st->size - (st->bits_unused & 0x07);
+	} else {
+		size = 0;
+	}
+	
+	if((size == 8l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using BIT_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Data_Coding_Scheme_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_BIT_STRING.free_struct;
+	td->print_struct   = asn_DEF_BIT_STRING.print_struct;
+	td->check_constraints = asn_DEF_BIT_STRING.check_constraints;
+	td->ber_decoder    = asn_DEF_BIT_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_BIT_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_BIT_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_BIT_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_BIT_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_BIT_STRING.uper_encoder;
+	td->aper_decoder   = asn_DEF_BIT_STRING.aper_decoder;
+	td->aper_encoder   = asn_DEF_BIT_STRING.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_BIT_STRING.per_constraints;
+	td->elements       = asn_DEF_BIT_STRING.elements;
+	td->elements_count = asn_DEF_BIT_STRING.elements_count;
+	td->specifics      = asn_DEF_BIT_STRING.specifics;
+}
+
+void
+SABP_Data_Coding_Scheme_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Data_Coding_Scheme_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Data_Coding_Scheme_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Data_Coding_Scheme_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Data_Coding_Scheme_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Data_Coding_Scheme_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Data_Coding_Scheme_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Data_Coding_Scheme_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Data_Coding_Scheme_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Data_Coding_Scheme_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Data_Coding_Scheme_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Data_Coding_Scheme_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Data_Coding_Scheme_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Data_Coding_Scheme_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Data_Coding_Scheme_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Data_Coding_Scheme_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Data_Coding_Scheme_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Data_Coding_Scheme_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Data_Coding_Scheme_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Data_Coding_Scheme_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Data_Coding_Scheme_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  8l,  8l }	/* (SIZE(8..8)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Data_Coding_Scheme_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Data_Coding_Scheme = {
+	"SABP_Data-Coding-Scheme",
+	"SABP_Data-Coding-Scheme",
+	SABP_Data_Coding_Scheme_free,
+	SABP_Data_Coding_Scheme_print,
+	SABP_Data_Coding_Scheme_constraint,
+	SABP_Data_Coding_Scheme_decode_ber,
+	SABP_Data_Coding_Scheme_encode_der,
+	SABP_Data_Coding_Scheme_decode_xer,
+	SABP_Data_Coding_Scheme_encode_xer,
+	SABP_Data_Coding_Scheme_decode_uper,
+	SABP_Data_Coding_Scheme_encode_uper,
+	SABP_Data_Coding_Scheme_decode_aper,
+	SABP_Data_Coding_Scheme_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Data_Coding_Scheme_tags_1,
+	sizeof(asn_DEF_SABP_Data_Coding_Scheme_tags_1)
+		/sizeof(asn_DEF_SABP_Data_Coding_Scheme_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Data_Coding_Scheme_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Data_Coding_Scheme_tags_1)
+		/sizeof(asn_DEF_SABP_Data_Coding_Scheme_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Data_Coding_Scheme_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_Error-Indication.c b/src/sabp/SABP_Error-Indication.c
new file mode 100644
index 0000000..78e62ad
--- /dev/null
+++ b/src/sabp/SABP_Error-Indication.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Error-Indication.h>
+
+static int
+memb_error_Indication_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_error_Indication_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_error_Indication_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_error_Indication_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_error_Indication_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_error_Indication_ies_specs_2 = {
+	sizeof(struct error_Indication_ies),
+	offsetof(struct error_Indication_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_error_Indication_ies_2 = {
+	"error-Indication-ies",
+	"error-Indication-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_error_Indication_ies_tags_2,
+	sizeof(asn_DEF_error_Indication_ies_tags_2)
+		/sizeof(asn_DEF_error_Indication_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_error_Indication_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_error_Indication_ies_tags_2)
+		/sizeof(asn_DEF_error_Indication_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_error_Indication_ies_constr_2,
+	asn_MBR_error_Indication_ies_2,
+	1,	/* Single element */
+	&asn_SPC_error_Indication_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Error_Indication_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Error_Indication, error_Indication_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_error_Indication_ies_2,
+		memb_error_Indication_ies_constraint_1,
+		&asn_PER_memb_error_Indication_ies_constr_2,
+		0,
+		"error-Indication-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Error_Indication_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Error_Indication_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* error-Indication-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Error_Indication_specs_1 = {
+	sizeof(struct SABP_Error_Indication),
+	offsetof(struct SABP_Error_Indication, _asn_ctx),
+	asn_MAP_SABP_Error_Indication_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Error_Indication = {
+	"SABP_Error-Indication",
+	"SABP_Error-Indication",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Error_Indication_tags_1,
+	sizeof(asn_DEF_SABP_Error_Indication_tags_1)
+		/sizeof(asn_DEF_SABP_Error_Indication_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Error_Indication_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Error_Indication_tags_1)
+		/sizeof(asn_DEF_SABP_Error_Indication_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Error_Indication_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Error_Indication_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Failure-List-Item.c b/src/sabp/SABP_Failure-List-Item.c
new file mode 100644
index 0000000..0891016
--- /dev/null
+++ b/src/sabp/SABP_Failure-List-Item.c
@@ -0,0 +1,83 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Failure-List-Item.h>
+
+static asn_TYPE_member_t asn_MBR_SABP_Failure_List_Item_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Failure_List_Item, service_area_identifier),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_Service_Area_Identifier,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"service-area-identifier"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Failure_List_Item, cause),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_Cause,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"cause"
+		},
+	{ ATF_POINTER, 1, offsetof(struct SABP_Failure_List_Item, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_SABP_Failure_List_Item_oms_1[] = { 2 };
+static const ber_tlv_tag_t asn_DEF_SABP_Failure_List_Item_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Failure_List_Item_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* service-area-identifier */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* cause */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Failure_List_Item_specs_1 = {
+	sizeof(struct SABP_Failure_List_Item),
+	offsetof(struct SABP_Failure_List_Item, _asn_ctx),
+	asn_MAP_SABP_Failure_List_Item_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_SABP_Failure_List_Item_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	2,	/* Start extensions */
+	4	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Failure_List_Item = {
+	"SABP_Failure-List-Item",
+	"SABP_Failure-List-Item",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Failure_List_Item_tags_1,
+	sizeof(asn_DEF_SABP_Failure_List_Item_tags_1)
+		/sizeof(asn_DEF_SABP_Failure_List_Item_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Failure_List_Item_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Failure_List_Item_tags_1)
+		/sizeof(asn_DEF_SABP_Failure_List_Item_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Failure_List_Item_1,
+	3,	/* Elements count */
+	&asn_SPC_SABP_Failure_List_Item_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Failure-List.c b/src/sabp/SABP_Failure-List.c
new file mode 100644
index 0000000..1b2bc16
--- /dev/null
+++ b/src/sabp/SABP_Failure-List.c
@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Failure-List.h>
+
+static asn_per_constraints_t asn_PER_type_SABP_Failure_List_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  1l,  65535l }	/* (SIZE(1..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_SABP_Failure_List_1[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_Failure_List_Item,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Failure_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_SABP_Failure_List_specs_1 = {
+	sizeof(struct SABP_Failure_List),
+	offsetof(struct SABP_Failure_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Failure_List = {
+	"SABP_Failure-List",
+	"SABP_Failure-List",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Failure_List_tags_1,
+	sizeof(asn_DEF_SABP_Failure_List_tags_1)
+		/sizeof(asn_DEF_SABP_Failure_List_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Failure_List_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Failure_List_tags_1)
+		/sizeof(asn_DEF_SABP_Failure_List_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Failure_List_constr_1,
+	asn_MBR_SABP_Failure_List_1,
+	1,	/* Single element */
+	&asn_SPC_SABP_Failure_List_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Failure.c b/src/sabp/SABP_Failure.c
new file mode 100644
index 0000000..685fe44
--- /dev/null
+++ b/src/sabp/SABP_Failure.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Failure.h>
+
+static int
+memb_failure_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_failure_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_failure_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_failure_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_failure_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_failure_ies_specs_2 = {
+	sizeof(struct failure_ies),
+	offsetof(struct failure_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_failure_ies_2 = {
+	"failure-ies",
+	"failure-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_failure_ies_tags_2,
+	sizeof(asn_DEF_failure_ies_tags_2)
+		/sizeof(asn_DEF_failure_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_failure_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_failure_ies_tags_2)
+		/sizeof(asn_DEF_failure_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_failure_ies_constr_2,
+	asn_MBR_failure_ies_2,
+	1,	/* Single element */
+	&asn_SPC_failure_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Failure_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Failure, failure_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_failure_ies_2,
+		memb_failure_ies_constraint_1,
+		&asn_PER_memb_failure_ies_constr_2,
+		0,
+		"failure-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Failure_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Failure_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* failure-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Failure_specs_1 = {
+	sizeof(struct SABP_Failure),
+	offsetof(struct SABP_Failure, _asn_ctx),
+	asn_MAP_SABP_Failure_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Failure = {
+	"SABP_Failure",
+	"SABP_Failure",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Failure_tags_1,
+	sizeof(asn_DEF_SABP_Failure_tags_1)
+		/sizeof(asn_DEF_SABP_Failure_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Failure_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Failure_tags_1)
+		/sizeof(asn_DEF_SABP_Failure_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Failure_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Failure_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_IE-Extensions.c b/src/sabp/SABP_IE-Extensions.c
new file mode 100644
index 0000000..f462546
--- /dev/null
+++ b/src/sabp/SABP_IE-Extensions.c
@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_IE-Extensions.h>
+
+static asn_per_constraints_t asn_PER_type_SABP_IE_Extensions_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  1l,  65535l }	/* (SIZE(1..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_SABP_IE_Extensions_1[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_IE_Extensions_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_SABP_IE_Extensions_specs_1 = {
+	sizeof(struct SABP_IE_Extensions),
+	offsetof(struct SABP_IE_Extensions, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_IE_Extensions = {
+	"SABP_IE-Extensions",
+	"SABP_IE-Extensions",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_IE_Extensions_tags_1,
+	sizeof(asn_DEF_SABP_IE_Extensions_tags_1)
+		/sizeof(asn_DEF_SABP_IE_Extensions_tags_1[0]), /* 1 */
+	asn_DEF_SABP_IE_Extensions_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_IE_Extensions_tags_1)
+		/sizeof(asn_DEF_SABP_IE_Extensions_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_IE_Extensions_constr_1,
+	asn_MBR_SABP_IE_Extensions_1,
+	1,	/* Single element */
+	&asn_SPC_SABP_IE_Extensions_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_IE.c b/src/sabp/SABP_IE.c
new file mode 100644
index 0000000..2259b88
--- /dev/null
+++ b/src/sabp/SABP_IE.c
@@ -0,0 +1,81 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_IE.h>
+
+static asn_TYPE_member_t asn_MBR_SABP_IE_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_IE, id),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_ProtocolIE_ID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"id"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_IE, criticality),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_Criticality,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"criticality"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_IE, value),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_ANY,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"value"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_IE_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_IE_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* id */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_IE_specs_1 = {
+	sizeof(struct SABP_IE),
+	offsetof(struct SABP_IE, _asn_ctx),
+	asn_MAP_SABP_IE_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_IE = {
+	"SABP_IE",
+	"SABP_IE",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_IE_tags_1,
+	sizeof(asn_DEF_SABP_IE_tags_1)
+		/sizeof(asn_DEF_SABP_IE_tags_1[0]), /* 1 */
+	asn_DEF_SABP_IE_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_IE_tags_1)
+		/sizeof(asn_DEF_SABP_IE_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_IE_1,
+	3,	/* Elements count */
+	&asn_SPC_SABP_IE_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_InitiatingMessage.c b/src/sabp/SABP_InitiatingMessage.c
new file mode 100644
index 0000000..b31ddae
--- /dev/null
+++ b/src/sabp/SABP_InitiatingMessage.c
@@ -0,0 +1,81 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_InitiatingMessage.h>
+
+static asn_TYPE_member_t asn_MBR_SABP_InitiatingMessage_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_InitiatingMessage, procedureCode),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_ProcedureCode,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"procedureCode"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_InitiatingMessage, criticality),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_Criticality,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"criticality"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_InitiatingMessage, value),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_ANY,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"value"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_InitiatingMessage_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_InitiatingMessage_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* procedureCode */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_InitiatingMessage_specs_1 = {
+	sizeof(struct SABP_InitiatingMessage),
+	offsetof(struct SABP_InitiatingMessage, _asn_ctx),
+	asn_MAP_SABP_InitiatingMessage_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_InitiatingMessage = {
+	"SABP_InitiatingMessage",
+	"SABP_InitiatingMessage",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_InitiatingMessage_tags_1,
+	sizeof(asn_DEF_SABP_InitiatingMessage_tags_1)
+		/sizeof(asn_DEF_SABP_InitiatingMessage_tags_1[0]), /* 1 */
+	asn_DEF_SABP_InitiatingMessage_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_InitiatingMessage_tags_1)
+		/sizeof(asn_DEF_SABP_InitiatingMessage_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_InitiatingMessage_1,
+	3,	/* Elements count */
+	&asn_SPC_SABP_InitiatingMessage_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Kill-Complete.c b/src/sabp/SABP_Kill-Complete.c
new file mode 100644
index 0000000..f7b1a85
--- /dev/null
+++ b/src/sabp/SABP_Kill-Complete.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Kill-Complete.h>
+
+static int
+memb_kill_Complete_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_kill_Complete_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_kill_Complete_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_kill_Complete_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_kill_Complete_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_kill_Complete_ies_specs_2 = {
+	sizeof(struct kill_Complete_ies),
+	offsetof(struct kill_Complete_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_kill_Complete_ies_2 = {
+	"kill-Complete-ies",
+	"kill-Complete-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_kill_Complete_ies_tags_2,
+	sizeof(asn_DEF_kill_Complete_ies_tags_2)
+		/sizeof(asn_DEF_kill_Complete_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_kill_Complete_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_kill_Complete_ies_tags_2)
+		/sizeof(asn_DEF_kill_Complete_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_kill_Complete_ies_constr_2,
+	asn_MBR_kill_Complete_ies_2,
+	1,	/* Single element */
+	&asn_SPC_kill_Complete_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Kill_Complete_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Kill_Complete, kill_Complete_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_kill_Complete_ies_2,
+		memb_kill_Complete_ies_constraint_1,
+		&asn_PER_memb_kill_Complete_ies_constr_2,
+		0,
+		"kill-Complete-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Kill_Complete_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Kill_Complete_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* kill-Complete-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Kill_Complete_specs_1 = {
+	sizeof(struct SABP_Kill_Complete),
+	offsetof(struct SABP_Kill_Complete, _asn_ctx),
+	asn_MAP_SABP_Kill_Complete_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Kill_Complete = {
+	"SABP_Kill-Complete",
+	"SABP_Kill-Complete",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Kill_Complete_tags_1,
+	sizeof(asn_DEF_SABP_Kill_Complete_tags_1)
+		/sizeof(asn_DEF_SABP_Kill_Complete_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Kill_Complete_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Kill_Complete_tags_1)
+		/sizeof(asn_DEF_SABP_Kill_Complete_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Kill_Complete_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Kill_Complete_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Kill-Failure.c b/src/sabp/SABP_Kill-Failure.c
new file mode 100644
index 0000000..730d403
--- /dev/null
+++ b/src/sabp/SABP_Kill-Failure.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Kill-Failure.h>
+
+static int
+memb_kill_Failure_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_kill_Failure_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_kill_Failure_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_kill_Failure_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_kill_Failure_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_kill_Failure_ies_specs_2 = {
+	sizeof(struct kill_Failure_ies),
+	offsetof(struct kill_Failure_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_kill_Failure_ies_2 = {
+	"kill-Failure-ies",
+	"kill-Failure-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_kill_Failure_ies_tags_2,
+	sizeof(asn_DEF_kill_Failure_ies_tags_2)
+		/sizeof(asn_DEF_kill_Failure_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_kill_Failure_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_kill_Failure_ies_tags_2)
+		/sizeof(asn_DEF_kill_Failure_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_kill_Failure_ies_constr_2,
+	asn_MBR_kill_Failure_ies_2,
+	1,	/* Single element */
+	&asn_SPC_kill_Failure_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Kill_Failure_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Kill_Failure, kill_Failure_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_kill_Failure_ies_2,
+		memb_kill_Failure_ies_constraint_1,
+		&asn_PER_memb_kill_Failure_ies_constr_2,
+		0,
+		"kill-Failure-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Kill_Failure_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Kill_Failure_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* kill-Failure-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Kill_Failure_specs_1 = {
+	sizeof(struct SABP_Kill_Failure),
+	offsetof(struct SABP_Kill_Failure, _asn_ctx),
+	asn_MAP_SABP_Kill_Failure_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Kill_Failure = {
+	"SABP_Kill-Failure",
+	"SABP_Kill-Failure",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Kill_Failure_tags_1,
+	sizeof(asn_DEF_SABP_Kill_Failure_tags_1)
+		/sizeof(asn_DEF_SABP_Kill_Failure_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Kill_Failure_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Kill_Failure_tags_1)
+		/sizeof(asn_DEF_SABP_Kill_Failure_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Kill_Failure_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Kill_Failure_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Kill.c b/src/sabp/SABP_Kill.c
new file mode 100644
index 0000000..0210a19
--- /dev/null
+++ b/src/sabp/SABP_Kill.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Kill.h>
+
+static int
+memb_kill_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_kill_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_kill_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_kill_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_kill_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_kill_ies_specs_2 = {
+	sizeof(struct kill_ies),
+	offsetof(struct kill_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_kill_ies_2 = {
+	"kill-ies",
+	"kill-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_kill_ies_tags_2,
+	sizeof(asn_DEF_kill_ies_tags_2)
+		/sizeof(asn_DEF_kill_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_kill_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_kill_ies_tags_2)
+		/sizeof(asn_DEF_kill_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_kill_ies_constr_2,
+	asn_MBR_kill_ies_2,
+	1,	/* Single element */
+	&asn_SPC_kill_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Kill_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Kill, kill_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_kill_ies_2,
+		memb_kill_ies_constraint_1,
+		&asn_PER_memb_kill_ies_constr_2,
+		0,
+		"kill-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Kill_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Kill_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* kill-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Kill_specs_1 = {
+	sizeof(struct SABP_Kill),
+	offsetof(struct SABP_Kill, _asn_ctx),
+	asn_MAP_SABP_Kill_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Kill = {
+	"SABP_Kill",
+	"SABP_Kill",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Kill_tags_1,
+	sizeof(asn_DEF_SABP_Kill_tags_1)
+		/sizeof(asn_DEF_SABP_Kill_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Kill_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Kill_tags_1)
+		/sizeof(asn_DEF_SABP_Kill_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Kill_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Kill_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Load-Query-Complete.c b/src/sabp/SABP_Load-Query-Complete.c
new file mode 100644
index 0000000..d633890
--- /dev/null
+++ b/src/sabp/SABP_Load-Query-Complete.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Load-Query-Complete.h>
+
+static int
+memb_load_Query_Complete_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_load_Query_Complete_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_load_Query_Complete_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_load_Query_Complete_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_load_Query_Complete_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_load_Query_Complete_ies_specs_2 = {
+	sizeof(struct load_Query_Complete_ies),
+	offsetof(struct load_Query_Complete_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_load_Query_Complete_ies_2 = {
+	"load-Query-Complete-ies",
+	"load-Query-Complete-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_load_Query_Complete_ies_tags_2,
+	sizeof(asn_DEF_load_Query_Complete_ies_tags_2)
+		/sizeof(asn_DEF_load_Query_Complete_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_load_Query_Complete_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_load_Query_Complete_ies_tags_2)
+		/sizeof(asn_DEF_load_Query_Complete_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_load_Query_Complete_ies_constr_2,
+	asn_MBR_load_Query_Complete_ies_2,
+	1,	/* Single element */
+	&asn_SPC_load_Query_Complete_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Load_Query_Complete_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Load_Query_Complete, load_Query_Complete_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_load_Query_Complete_ies_2,
+		memb_load_Query_Complete_ies_constraint_1,
+		&asn_PER_memb_load_Query_Complete_ies_constr_2,
+		0,
+		"load-Query-Complete-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Load_Query_Complete_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Load_Query_Complete_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* load-Query-Complete-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Load_Query_Complete_specs_1 = {
+	sizeof(struct SABP_Load_Query_Complete),
+	offsetof(struct SABP_Load_Query_Complete, _asn_ctx),
+	asn_MAP_SABP_Load_Query_Complete_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Load_Query_Complete = {
+	"SABP_Load-Query-Complete",
+	"SABP_Load-Query-Complete",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Load_Query_Complete_tags_1,
+	sizeof(asn_DEF_SABP_Load_Query_Complete_tags_1)
+		/sizeof(asn_DEF_SABP_Load_Query_Complete_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Load_Query_Complete_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Load_Query_Complete_tags_1)
+		/sizeof(asn_DEF_SABP_Load_Query_Complete_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Load_Query_Complete_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Load_Query_Complete_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Load-Query-Failure.c b/src/sabp/SABP_Load-Query-Failure.c
new file mode 100644
index 0000000..948e4ad
--- /dev/null
+++ b/src/sabp/SABP_Load-Query-Failure.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Load-Query-Failure.h>
+
+static int
+memb_load_Query_Failure_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_load_Query_Failure_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_load_Query_Failure_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_load_Query_Failure_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_load_Query_Failure_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_load_Query_Failure_ies_specs_2 = {
+	sizeof(struct load_Query_Failure_ies),
+	offsetof(struct load_Query_Failure_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_load_Query_Failure_ies_2 = {
+	"load-Query-Failure-ies",
+	"load-Query-Failure-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_load_Query_Failure_ies_tags_2,
+	sizeof(asn_DEF_load_Query_Failure_ies_tags_2)
+		/sizeof(asn_DEF_load_Query_Failure_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_load_Query_Failure_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_load_Query_Failure_ies_tags_2)
+		/sizeof(asn_DEF_load_Query_Failure_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_load_Query_Failure_ies_constr_2,
+	asn_MBR_load_Query_Failure_ies_2,
+	1,	/* Single element */
+	&asn_SPC_load_Query_Failure_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Load_Query_Failure_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Load_Query_Failure, load_Query_Failure_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_load_Query_Failure_ies_2,
+		memb_load_Query_Failure_ies_constraint_1,
+		&asn_PER_memb_load_Query_Failure_ies_constr_2,
+		0,
+		"load-Query-Failure-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Load_Query_Failure_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Load_Query_Failure_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* load-Query-Failure-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Load_Query_Failure_specs_1 = {
+	sizeof(struct SABP_Load_Query_Failure),
+	offsetof(struct SABP_Load_Query_Failure, _asn_ctx),
+	asn_MAP_SABP_Load_Query_Failure_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Load_Query_Failure = {
+	"SABP_Load-Query-Failure",
+	"SABP_Load-Query-Failure",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Load_Query_Failure_tags_1,
+	sizeof(asn_DEF_SABP_Load_Query_Failure_tags_1)
+		/sizeof(asn_DEF_SABP_Load_Query_Failure_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Load_Query_Failure_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Load_Query_Failure_tags_1)
+		/sizeof(asn_DEF_SABP_Load_Query_Failure_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Load_Query_Failure_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Load_Query_Failure_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Load-Query.c b/src/sabp/SABP_Load-Query.c
new file mode 100644
index 0000000..2283840
--- /dev/null
+++ b/src/sabp/SABP_Load-Query.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Load-Query.h>
+
+static int
+memb_load_Query_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_load_Query_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_load_Query_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_load_Query_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_load_Query_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_load_Query_ies_specs_2 = {
+	sizeof(struct load_Query_ies),
+	offsetof(struct load_Query_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_load_Query_ies_2 = {
+	"load-Query-ies",
+	"load-Query-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_load_Query_ies_tags_2,
+	sizeof(asn_DEF_load_Query_ies_tags_2)
+		/sizeof(asn_DEF_load_Query_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_load_Query_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_load_Query_ies_tags_2)
+		/sizeof(asn_DEF_load_Query_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_load_Query_ies_constr_2,
+	asn_MBR_load_Query_ies_2,
+	1,	/* Single element */
+	&asn_SPC_load_Query_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Load_Query_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Load_Query, load_Query_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_load_Query_ies_2,
+		memb_load_Query_ies_constraint_1,
+		&asn_PER_memb_load_Query_ies_constr_2,
+		0,
+		"load-Query-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Load_Query_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Load_Query_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* load-Query-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Load_Query_specs_1 = {
+	sizeof(struct SABP_Load_Query),
+	offsetof(struct SABP_Load_Query, _asn_ctx),
+	asn_MAP_SABP_Load_Query_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Load_Query = {
+	"SABP_Load-Query",
+	"SABP_Load-Query",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Load_Query_tags_1,
+	sizeof(asn_DEF_SABP_Load_Query_tags_1)
+		/sizeof(asn_DEF_SABP_Load_Query_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Load_Query_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Load_Query_tags_1)
+		/sizeof(asn_DEF_SABP_Load_Query_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Load_Query_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Load_Query_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Message-Identifier.c b/src/sabp/SABP_Message-Identifier.c
new file mode 100644
index 0000000..2789dcc
--- /dev/null
+++ b/src/sabp/SABP_Message-Identifier.c
@@ -0,0 +1,171 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Message-Identifier.h>
+
+int
+SABP_Message_Identifier_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(st->size > 0) {
+		/* Size in bits */
+		size = 8 * st->size - (st->bits_unused & 0x07);
+	} else {
+		size = 0;
+	}
+	
+	if((size == 16l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using BIT_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Message_Identifier_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_BIT_STRING.free_struct;
+	td->print_struct   = asn_DEF_BIT_STRING.print_struct;
+	td->check_constraints = asn_DEF_BIT_STRING.check_constraints;
+	td->ber_decoder    = asn_DEF_BIT_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_BIT_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_BIT_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_BIT_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_BIT_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_BIT_STRING.uper_encoder;
+	td->aper_decoder   = asn_DEF_BIT_STRING.aper_decoder;
+	td->aper_encoder   = asn_DEF_BIT_STRING.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_BIT_STRING.per_constraints;
+	td->elements       = asn_DEF_BIT_STRING.elements;
+	td->elements_count = asn_DEF_BIT_STRING.elements_count;
+	td->specifics      = asn_DEF_BIT_STRING.specifics;
+}
+
+void
+SABP_Message_Identifier_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Message_Identifier_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Message_Identifier_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Message_Identifier_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Message_Identifier_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Message_Identifier_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Message_Identifier_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Message_Identifier_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Message_Identifier_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Message_Identifier_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Message_Identifier_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Message_Identifier_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Message_Identifier_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Message_Identifier_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Message_Identifier_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Message_Identifier_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Message_Identifier_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Message_Identifier_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Message_Identifier_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Message_Identifier_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Message_Identifier_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  16l,  16l }	/* (SIZE(16..16)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Message_Identifier_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Message_Identifier = {
+	"SABP_Message-Identifier",
+	"SABP_Message-Identifier",
+	SABP_Message_Identifier_free,
+	SABP_Message_Identifier_print,
+	SABP_Message_Identifier_constraint,
+	SABP_Message_Identifier_decode_ber,
+	SABP_Message_Identifier_encode_der,
+	SABP_Message_Identifier_decode_xer,
+	SABP_Message_Identifier_encode_xer,
+	SABP_Message_Identifier_decode_uper,
+	SABP_Message_Identifier_encode_uper,
+	SABP_Message_Identifier_decode_aper,
+	SABP_Message_Identifier_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Message_Identifier_tags_1,
+	sizeof(asn_DEF_SABP_Message_Identifier_tags_1)
+		/sizeof(asn_DEF_SABP_Message_Identifier_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Message_Identifier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Message_Identifier_tags_1)
+		/sizeof(asn_DEF_SABP_Message_Identifier_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Message_Identifier_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_Message-Status-Query-Complete.c b/src/sabp/SABP_Message-Status-Query-Complete.c
new file mode 100644
index 0000000..dd222e0
--- /dev/null
+++ b/src/sabp/SABP_Message-Status-Query-Complete.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Message-Status-Query-Complete.h>
+
+static int
+memb_message_Status_Query_Complete_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_message_Status_Query_Complete_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_message_Status_Query_Complete_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_message_Status_Query_Complete_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_message_Status_Query_Complete_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_message_Status_Query_Complete_ies_specs_2 = {
+	sizeof(struct message_Status_Query_Complete_ies),
+	offsetof(struct message_Status_Query_Complete_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_message_Status_Query_Complete_ies_2 = {
+	"message-Status-Query-Complete-ies",
+	"message-Status-Query-Complete-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_message_Status_Query_Complete_ies_tags_2,
+	sizeof(asn_DEF_message_Status_Query_Complete_ies_tags_2)
+		/sizeof(asn_DEF_message_Status_Query_Complete_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_message_Status_Query_Complete_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_message_Status_Query_Complete_ies_tags_2)
+		/sizeof(asn_DEF_message_Status_Query_Complete_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_message_Status_Query_Complete_ies_constr_2,
+	asn_MBR_message_Status_Query_Complete_ies_2,
+	1,	/* Single element */
+	&asn_SPC_message_Status_Query_Complete_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Message_Status_Query_Complete_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Message_Status_Query_Complete, message_Status_Query_Complete_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_message_Status_Query_Complete_ies_2,
+		memb_message_Status_Query_Complete_ies_constraint_1,
+		&asn_PER_memb_message_Status_Query_Complete_ies_constr_2,
+		0,
+		"message-Status-Query-Complete-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Message_Status_Query_Complete_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Message_Status_Query_Complete_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* message-Status-Query-Complete-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Message_Status_Query_Complete_specs_1 = {
+	sizeof(struct SABP_Message_Status_Query_Complete),
+	offsetof(struct SABP_Message_Status_Query_Complete, _asn_ctx),
+	asn_MAP_SABP_Message_Status_Query_Complete_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Message_Status_Query_Complete = {
+	"SABP_Message-Status-Query-Complete",
+	"SABP_Message-Status-Query-Complete",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Message_Status_Query_Complete_tags_1,
+	sizeof(asn_DEF_SABP_Message_Status_Query_Complete_tags_1)
+		/sizeof(asn_DEF_SABP_Message_Status_Query_Complete_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Message_Status_Query_Complete_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Message_Status_Query_Complete_tags_1)
+		/sizeof(asn_DEF_SABP_Message_Status_Query_Complete_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Message_Status_Query_Complete_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Message_Status_Query_Complete_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Message-Status-Query-Failure.c b/src/sabp/SABP_Message-Status-Query-Failure.c
new file mode 100644
index 0000000..4a42757
--- /dev/null
+++ b/src/sabp/SABP_Message-Status-Query-Failure.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Message-Status-Query-Failure.h>
+
+static int
+memb_message_Status_Query_Failure_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_message_Status_Query_Failure_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_message_Status_Query_Failure_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_message_Status_Query_Failure_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_message_Status_Query_Failure_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_message_Status_Query_Failure_ies_specs_2 = {
+	sizeof(struct message_Status_Query_Failure_ies),
+	offsetof(struct message_Status_Query_Failure_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_message_Status_Query_Failure_ies_2 = {
+	"message-Status-Query-Failure-ies",
+	"message-Status-Query-Failure-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_message_Status_Query_Failure_ies_tags_2,
+	sizeof(asn_DEF_message_Status_Query_Failure_ies_tags_2)
+		/sizeof(asn_DEF_message_Status_Query_Failure_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_message_Status_Query_Failure_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_message_Status_Query_Failure_ies_tags_2)
+		/sizeof(asn_DEF_message_Status_Query_Failure_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_message_Status_Query_Failure_ies_constr_2,
+	asn_MBR_message_Status_Query_Failure_ies_2,
+	1,	/* Single element */
+	&asn_SPC_message_Status_Query_Failure_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Message_Status_Query_Failure_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Message_Status_Query_Failure, message_Status_Query_Failure_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_message_Status_Query_Failure_ies_2,
+		memb_message_Status_Query_Failure_ies_constraint_1,
+		&asn_PER_memb_message_Status_Query_Failure_ies_constr_2,
+		0,
+		"message-Status-Query-Failure-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Message_Status_Query_Failure_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Message_Status_Query_Failure_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* message-Status-Query-Failure-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Message_Status_Query_Failure_specs_1 = {
+	sizeof(struct SABP_Message_Status_Query_Failure),
+	offsetof(struct SABP_Message_Status_Query_Failure, _asn_ctx),
+	asn_MAP_SABP_Message_Status_Query_Failure_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Message_Status_Query_Failure = {
+	"SABP_Message-Status-Query-Failure",
+	"SABP_Message-Status-Query-Failure",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Message_Status_Query_Failure_tags_1,
+	sizeof(asn_DEF_SABP_Message_Status_Query_Failure_tags_1)
+		/sizeof(asn_DEF_SABP_Message_Status_Query_Failure_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Message_Status_Query_Failure_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Message_Status_Query_Failure_tags_1)
+		/sizeof(asn_DEF_SABP_Message_Status_Query_Failure_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Message_Status_Query_Failure_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Message_Status_Query_Failure_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Message-Status-Query.c b/src/sabp/SABP_Message-Status-Query.c
new file mode 100644
index 0000000..8055733
--- /dev/null
+++ b/src/sabp/SABP_Message-Status-Query.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Message-Status-Query.h>
+
+static int
+memb_message_Status_Query_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_message_Status_Query_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_message_Status_Query_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_message_Status_Query_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_message_Status_Query_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_message_Status_Query_ies_specs_2 = {
+	sizeof(struct message_Status_Query_ies),
+	offsetof(struct message_Status_Query_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_message_Status_Query_ies_2 = {
+	"message-Status-Query-ies",
+	"message-Status-Query-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_message_Status_Query_ies_tags_2,
+	sizeof(asn_DEF_message_Status_Query_ies_tags_2)
+		/sizeof(asn_DEF_message_Status_Query_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_message_Status_Query_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_message_Status_Query_ies_tags_2)
+		/sizeof(asn_DEF_message_Status_Query_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_message_Status_Query_ies_constr_2,
+	asn_MBR_message_Status_Query_ies_2,
+	1,	/* Single element */
+	&asn_SPC_message_Status_Query_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Message_Status_Query_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Message_Status_Query, message_Status_Query_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_message_Status_Query_ies_2,
+		memb_message_Status_Query_ies_constraint_1,
+		&asn_PER_memb_message_Status_Query_ies_constr_2,
+		0,
+		"message-Status-Query-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Message_Status_Query_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Message_Status_Query_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* message-Status-Query-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Message_Status_Query_specs_1 = {
+	sizeof(struct SABP_Message_Status_Query),
+	offsetof(struct SABP_Message_Status_Query, _asn_ctx),
+	asn_MAP_SABP_Message_Status_Query_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Message_Status_Query = {
+	"SABP_Message-Status-Query",
+	"SABP_Message-Status-Query",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Message_Status_Query_tags_1,
+	sizeof(asn_DEF_SABP_Message_Status_Query_tags_1)
+		/sizeof(asn_DEF_SABP_Message_Status_Query_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Message_Status_Query_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Message_Status_Query_tags_1)
+		/sizeof(asn_DEF_SABP_Message_Status_Query_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Message_Status_Query_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Message_Status_Query_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_MessageStructure.c b/src/sabp/SABP_MessageStructure.c
new file mode 100644
index 0000000..db4c0d6
--- /dev/null
+++ b/src/sabp/SABP_MessageStructure.c
@@ -0,0 +1,135 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_MessageStructure.h>
+
+static asn_per_constraints_t asn_PER_type_SABP_MessageStructure_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 8,  8,  1l,  256l }	/* (SIZE(1..256)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_MemberA_2[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct MemberA, iE_ID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_ProtocolIE_ID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-ID"
+		},
+	{ ATF_POINTER, 2, offsetof(struct MemberA, repetitionNumber),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_RepetitionNumber1,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"repetitionNumber"
+		},
+	{ ATF_POINTER, 1, offsetof(struct MemberA, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_MemberA_oms_2[] = { 1, 2 };
+static const ber_tlv_tag_t asn_DEF_MemberA_tags_2[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_MemberA_tag2el_2[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* iE-ID */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* repetitionNumber */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_MemberA_specs_2 = {
+	sizeof(struct MemberA),
+	offsetof(struct MemberA, _asn_ctx),
+	asn_MAP_MemberA_tag2el_2,
+	3,	/* Count of tags in the map */
+	asn_MAP_MemberA_oms_2,	/* Optional members */
+	2, 0,	/* Root/Additions */
+	2,	/* Start extensions */
+	4	/* Stop extensions */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_MemberA_2 = {
+	"SEQUENCE",
+	"SEQUENCE",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_MemberA_tags_2,
+	sizeof(asn_DEF_MemberA_tags_2)
+		/sizeof(asn_DEF_MemberA_tags_2[0]), /* 1 */
+	asn_DEF_MemberA_tags_2,	/* Same as above */
+	sizeof(asn_DEF_MemberA_tags_2)
+		/sizeof(asn_DEF_MemberA_tags_2[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_MemberA_2,
+	3,	/* Elements count */
+	&asn_SPC_MemberA_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_MessageStructure_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_MemberA_2,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_MessageStructure_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_SABP_MessageStructure_specs_1 = {
+	sizeof(struct SABP_MessageStructure),
+	offsetof(struct SABP_MessageStructure, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_MessageStructure = {
+	"SABP_MessageStructure",
+	"SABP_MessageStructure",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_MessageStructure_tags_1,
+	sizeof(asn_DEF_SABP_MessageStructure_tags_1)
+		/sizeof(asn_DEF_SABP_MessageStructure_tags_1[0]), /* 1 */
+	asn_DEF_SABP_MessageStructure_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_MessageStructure_tags_1)
+		/sizeof(asn_DEF_SABP_MessageStructure_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_MessageStructure_constr_1,
+	asn_MBR_SABP_MessageStructure_1,
+	1,	/* Single element */
+	&asn_SPC_SABP_MessageStructure_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_New-Serial-Number.c b/src/sabp/SABP_New-Serial-Number.c
new file mode 100644
index 0000000..e279250
--- /dev/null
+++ b/src/sabp/SABP_New-Serial-Number.c
@@ -0,0 +1,157 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_New-Serial-Number.h>
+
+int
+SABP_New_Serial_Number_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(1 /* No applicable constraints whatsoever */) {
+		/* Nothing is here. See below */
+	}
+	
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_SABP_Serial_Number.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using SABP_Serial_Number,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_New_Serial_Number_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_SABP_Serial_Number.free_struct;
+	td->print_struct   = asn_DEF_SABP_Serial_Number.print_struct;
+	td->check_constraints = asn_DEF_SABP_Serial_Number.check_constraints;
+	td->ber_decoder    = asn_DEF_SABP_Serial_Number.ber_decoder;
+	td->der_encoder    = asn_DEF_SABP_Serial_Number.der_encoder;
+	td->xer_decoder    = asn_DEF_SABP_Serial_Number.xer_decoder;
+	td->xer_encoder    = asn_DEF_SABP_Serial_Number.xer_encoder;
+	td->uper_decoder   = asn_DEF_SABP_Serial_Number.uper_decoder;
+	td->uper_encoder   = asn_DEF_SABP_Serial_Number.uper_encoder;
+	td->aper_decoder   = asn_DEF_SABP_Serial_Number.aper_decoder;
+	td->aper_encoder   = asn_DEF_SABP_Serial_Number.aper_encoder;
+	/* The next four lines are here because of -fknown-extern-type */
+	td->tags           = asn_DEF_SABP_Serial_Number.tags;
+	td->tags_count     = asn_DEF_SABP_Serial_Number.tags_count;
+	td->all_tags       = asn_DEF_SABP_Serial_Number.all_tags;
+	td->all_tags_count = asn_DEF_SABP_Serial_Number.all_tags_count;
+	/* End of these lines */
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_SABP_Serial_Number.per_constraints;
+	td->elements       = asn_DEF_SABP_Serial_Number.elements;
+	td->elements_count = asn_DEF_SABP_Serial_Number.elements_count;
+	td->specifics      = asn_DEF_SABP_Serial_Number.specifics;
+}
+
+void
+SABP_New_Serial_Number_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_New_Serial_Number_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_New_Serial_Number_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_New_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_New_Serial_Number_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_New_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_New_Serial_Number_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_New_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_New_Serial_Number_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_New_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_New_Serial_Number_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_New_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_New_Serial_Number_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_New_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_New_Serial_Number_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_New_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_New_Serial_Number_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_New_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_New_Serial_Number_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_New_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_TYPE_descriptor_t asn_DEF_SABP_New_Serial_Number = {
+	"SABP_New-Serial-Number",
+	"SABP_New-Serial-Number",
+	SABP_New_Serial_Number_free,
+	SABP_New_Serial_Number_print,
+	SABP_New_Serial_Number_constraint,
+	SABP_New_Serial_Number_decode_ber,
+	SABP_New_Serial_Number_encode_der,
+	SABP_New_Serial_Number_decode_xer,
+	SABP_New_Serial_Number_encode_xer,
+	SABP_New_Serial_Number_decode_uper,
+	SABP_New_Serial_Number_encode_uper,
+	SABP_New_Serial_Number_decode_aper,
+	SABP_New_Serial_Number_encode_aper,
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_Number-Of-Broadcasts-Completed-Info.c b/src/sabp/SABP_Number-Of-Broadcasts-Completed-Info.c
new file mode 100644
index 0000000..19dab85
--- /dev/null
+++ b/src/sabp/SABP_Number-Of-Broadcasts-Completed-Info.c
@@ -0,0 +1,167 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Number-Of-Broadcasts-Completed-Info.h>
+
+int
+SABP_Number_Of_Broadcasts_Completed_Info_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Number_Of_Broadcasts_Completed_Info_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeEnumerated.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeEnumerated.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+SABP_Number_Of_Broadcasts_Completed_Info_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Number_Of_Broadcasts_Completed_Info_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Number_Of_Broadcasts_Completed_Info_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Number_Of_Broadcasts_Completed_Info_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Number_Of_Broadcasts_Completed_Info_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Number_Of_Broadcasts_Completed_Info_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Number_Of_Broadcasts_Completed_Info_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Number_Of_Broadcasts_Completed_Info_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Number_Of_Broadcasts_Completed_Info_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Number_Of_Broadcasts_Completed_Info_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Number_Of_Broadcasts_Completed_Info_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Number_Of_Broadcasts_Completed_Info_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Number_Of_Broadcasts_Completed_Info_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Number_Of_Broadcasts_Completed_Info_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Number_Of_Broadcasts_Completed_Info_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Number_Of_Broadcasts_Completed_Info_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Number_Of_Broadcasts_Completed_Info_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Number_Of_Broadcasts_Completed_Info_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Number_Of_Broadcasts_Completed_Info_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Number_Of_Broadcasts_Completed_Info_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Number_Of_Broadcasts_Completed_Info_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  1,  1,  0l,  1l }	/* (0..1,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_SABP_Number_Of_Broadcasts_Completed_Info_value2enum_1[] = {
+	{ 0,	8,	"overflow" },
+	{ 1,	7,	"unknown" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_SABP_Number_Of_Broadcasts_Completed_Info_enum2value_1[] = {
+	0,	/* overflow(0) */
+	1	/* unknown(1) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_SABP_Number_Of_Broadcasts_Completed_Info_specs_1 = {
+	asn_MAP_SABP_Number_Of_Broadcasts_Completed_Info_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_SABP_Number_Of_Broadcasts_Completed_Info_enum2value_1,	/* N => "tag"; sorted by N */
+	2,	/* Number of elements in the maps */
+	3,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Number_Of_Broadcasts_Completed_Info_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Number_Of_Broadcasts_Completed_Info = {
+	"SABP_Number-Of-Broadcasts-Completed-Info",
+	"SABP_Number-Of-Broadcasts-Completed-Info",
+	SABP_Number_Of_Broadcasts_Completed_Info_free,
+	SABP_Number_Of_Broadcasts_Completed_Info_print,
+	SABP_Number_Of_Broadcasts_Completed_Info_constraint,
+	SABP_Number_Of_Broadcasts_Completed_Info_decode_ber,
+	SABP_Number_Of_Broadcasts_Completed_Info_encode_der,
+	SABP_Number_Of_Broadcasts_Completed_Info_decode_xer,
+	SABP_Number_Of_Broadcasts_Completed_Info_encode_xer,
+	SABP_Number_Of_Broadcasts_Completed_Info_decode_uper,
+	SABP_Number_Of_Broadcasts_Completed_Info_encode_uper,
+	SABP_Number_Of_Broadcasts_Completed_Info_decode_aper,
+	SABP_Number_Of_Broadcasts_Completed_Info_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Number_Of_Broadcasts_Completed_Info_tags_1,
+	sizeof(asn_DEF_SABP_Number_Of_Broadcasts_Completed_Info_tags_1)
+		/sizeof(asn_DEF_SABP_Number_Of_Broadcasts_Completed_Info_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Number_Of_Broadcasts_Completed_Info_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Number_Of_Broadcasts_Completed_Info_tags_1)
+		/sizeof(asn_DEF_SABP_Number_Of_Broadcasts_Completed_Info_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Number_Of_Broadcasts_Completed_Info_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_SABP_Number_Of_Broadcasts_Completed_Info_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Number-of-Broadcasts-Completed-List-Item.c b/src/sabp/SABP_Number-of-Broadcasts-Completed-List-Item.c
new file mode 100644
index 0000000..77075e3
--- /dev/null
+++ b/src/sabp/SABP_Number-of-Broadcasts-Completed-List-Item.c
@@ -0,0 +1,123 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Number-of-Broadcasts-Completed-List-Item.h>
+
+static int
+memb_number_of_broadcasts_completed_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0l && value <= 65535l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_number_of_broadcasts_completed_constr_3 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (0..65535) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_SABP_Number_of_Broadcasts_Completed_List_Item_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Number_of_Broadcasts_Completed_List_Item, service_area_identifier),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_Service_Area_Identifier,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"service-area-identifier"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Number_of_Broadcasts_Completed_List_Item, number_of_broadcasts_completed),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_number_of_broadcasts_completed_constraint_1,
+		&asn_PER_memb_number_of_broadcasts_completed_constr_3,
+		0,
+		"number-of-broadcasts-completed"
+		},
+	{ ATF_POINTER, 2, offsetof(struct SABP_Number_of_Broadcasts_Completed_List_Item, number_of_broadcasts_completed_info),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_Number_Of_Broadcasts_Completed_Info,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"number-of-broadcasts-completed-info"
+		},
+	{ ATF_POINTER, 1, offsetof(struct SABP_Number_of_Broadcasts_Completed_List_Item, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_SABP_Number_of_Broadcasts_Completed_List_Item_oms_1[] = { 2, 3 };
+static const ber_tlv_tag_t asn_DEF_SABP_Number_of_Broadcasts_Completed_List_Item_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Number_of_Broadcasts_Completed_List_Item_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* service-area-identifier */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* number-of-broadcasts-completed */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* number-of-broadcasts-completed-info */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Number_of_Broadcasts_Completed_List_Item_specs_1 = {
+	sizeof(struct SABP_Number_of_Broadcasts_Completed_List_Item),
+	offsetof(struct SABP_Number_of_Broadcasts_Completed_List_Item, _asn_ctx),
+	asn_MAP_SABP_Number_of_Broadcasts_Completed_List_Item_tag2el_1,
+	4,	/* Count of tags in the map */
+	asn_MAP_SABP_Number_of_Broadcasts_Completed_List_Item_oms_1,	/* Optional members */
+	2, 0,	/* Root/Additions */
+	3,	/* Start extensions */
+	5	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Number_of_Broadcasts_Completed_List_Item = {
+	"SABP_Number-of-Broadcasts-Completed-List-Item",
+	"SABP_Number-of-Broadcasts-Completed-List-Item",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Number_of_Broadcasts_Completed_List_Item_tags_1,
+	sizeof(asn_DEF_SABP_Number_of_Broadcasts_Completed_List_Item_tags_1)
+		/sizeof(asn_DEF_SABP_Number_of_Broadcasts_Completed_List_Item_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Number_of_Broadcasts_Completed_List_Item_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Number_of_Broadcasts_Completed_List_Item_tags_1)
+		/sizeof(asn_DEF_SABP_Number_of_Broadcasts_Completed_List_Item_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Number_of_Broadcasts_Completed_List_Item_1,
+	4,	/* Elements count */
+	&asn_SPC_SABP_Number_of_Broadcasts_Completed_List_Item_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Number-of-Broadcasts-Completed-List.c b/src/sabp/SABP_Number-of-Broadcasts-Completed-List.c
new file mode 100644
index 0000000..56ea92a
--- /dev/null
+++ b/src/sabp/SABP_Number-of-Broadcasts-Completed-List.c
@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Number-of-Broadcasts-Completed-List.h>
+
+static asn_per_constraints_t asn_PER_type_SABP_Number_of_Broadcasts_Completed_List_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  1l,  65535l }	/* (SIZE(1..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_SABP_Number_of_Broadcasts_Completed_List_1[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_Number_of_Broadcasts_Completed_List_Item,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Number_of_Broadcasts_Completed_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_SABP_Number_of_Broadcasts_Completed_List_specs_1 = {
+	sizeof(struct SABP_Number_of_Broadcasts_Completed_List),
+	offsetof(struct SABP_Number_of_Broadcasts_Completed_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Number_of_Broadcasts_Completed_List = {
+	"SABP_Number-of-Broadcasts-Completed-List",
+	"SABP_Number-of-Broadcasts-Completed-List",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Number_of_Broadcasts_Completed_List_tags_1,
+	sizeof(asn_DEF_SABP_Number_of_Broadcasts_Completed_List_tags_1)
+		/sizeof(asn_DEF_SABP_Number_of_Broadcasts_Completed_List_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Number_of_Broadcasts_Completed_List_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Number_of_Broadcasts_Completed_List_tags_1)
+		/sizeof(asn_DEF_SABP_Number_of_Broadcasts_Completed_List_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Number_of_Broadcasts_Completed_List_constr_1,
+	asn_MBR_SABP_Number_of_Broadcasts_Completed_List_1,
+	1,	/* Single element */
+	&asn_SPC_SABP_Number_of_Broadcasts_Completed_List_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Number-of-Broadcasts-Requested.c b/src/sabp/SABP_Number-of-Broadcasts-Requested.c
new file mode 100644
index 0000000..10654a0
--- /dev/null
+++ b/src/sabp/SABP_Number-of-Broadcasts-Requested.c
@@ -0,0 +1,165 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Number-of-Broadcasts-Requested.h>
+
+int
+SABP_Number_of_Broadcasts_Requested_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0l && value <= 65535l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Number_of_Broadcasts_Requested_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeInteger.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeInteger.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+SABP_Number_of_Broadcasts_Requested_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Number_of_Broadcasts_Requested_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Number_of_Broadcasts_Requested_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Number_of_Broadcasts_Requested_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Number_of_Broadcasts_Requested_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Number_of_Broadcasts_Requested_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Number_of_Broadcasts_Requested_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Number_of_Broadcasts_Requested_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Number_of_Broadcasts_Requested_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Number_of_Broadcasts_Requested_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Number_of_Broadcasts_Requested_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Number_of_Broadcasts_Requested_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Number_of_Broadcasts_Requested_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Number_of_Broadcasts_Requested_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Number_of_Broadcasts_Requested_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Number_of_Broadcasts_Requested_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Number_of_Broadcasts_Requested_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Number_of_Broadcasts_Requested_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Number_of_Broadcasts_Requested_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Number_of_Broadcasts_Requested_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Number_of_Broadcasts_Requested_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (0..65535) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Number_of_Broadcasts_Requested_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Number_of_Broadcasts_Requested = {
+	"SABP_Number-of-Broadcasts-Requested",
+	"SABP_Number-of-Broadcasts-Requested",
+	SABP_Number_of_Broadcasts_Requested_free,
+	SABP_Number_of_Broadcasts_Requested_print,
+	SABP_Number_of_Broadcasts_Requested_constraint,
+	SABP_Number_of_Broadcasts_Requested_decode_ber,
+	SABP_Number_of_Broadcasts_Requested_encode_der,
+	SABP_Number_of_Broadcasts_Requested_decode_xer,
+	SABP_Number_of_Broadcasts_Requested_encode_xer,
+	SABP_Number_of_Broadcasts_Requested_decode_uper,
+	SABP_Number_of_Broadcasts_Requested_encode_uper,
+	SABP_Number_of_Broadcasts_Requested_decode_aper,
+	SABP_Number_of_Broadcasts_Requested_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Number_of_Broadcasts_Requested_tags_1,
+	sizeof(asn_DEF_SABP_Number_of_Broadcasts_Requested_tags_1)
+		/sizeof(asn_DEF_SABP_Number_of_Broadcasts_Requested_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Number_of_Broadcasts_Requested_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Number_of_Broadcasts_Requested_tags_1)
+		/sizeof(asn_DEF_SABP_Number_of_Broadcasts_Requested_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Number_of_Broadcasts_Requested_constr_1,
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_Old-Serial-Number.c b/src/sabp/SABP_Old-Serial-Number.c
new file mode 100644
index 0000000..53766aa
--- /dev/null
+++ b/src/sabp/SABP_Old-Serial-Number.c
@@ -0,0 +1,157 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Old-Serial-Number.h>
+
+int
+SABP_Old_Serial_Number_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	if(1 /* No applicable constraints whatsoever */) {
+		/* Nothing is here. See below */
+	}
+	
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_SABP_Serial_Number.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using SABP_Serial_Number,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Old_Serial_Number_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_SABP_Serial_Number.free_struct;
+	td->print_struct   = asn_DEF_SABP_Serial_Number.print_struct;
+	td->check_constraints = asn_DEF_SABP_Serial_Number.check_constraints;
+	td->ber_decoder    = asn_DEF_SABP_Serial_Number.ber_decoder;
+	td->der_encoder    = asn_DEF_SABP_Serial_Number.der_encoder;
+	td->xer_decoder    = asn_DEF_SABP_Serial_Number.xer_decoder;
+	td->xer_encoder    = asn_DEF_SABP_Serial_Number.xer_encoder;
+	td->uper_decoder   = asn_DEF_SABP_Serial_Number.uper_decoder;
+	td->uper_encoder   = asn_DEF_SABP_Serial_Number.uper_encoder;
+	td->aper_decoder   = asn_DEF_SABP_Serial_Number.aper_decoder;
+	td->aper_encoder   = asn_DEF_SABP_Serial_Number.aper_encoder;
+	/* The next four lines are here because of -fknown-extern-type */
+	td->tags           = asn_DEF_SABP_Serial_Number.tags;
+	td->tags_count     = asn_DEF_SABP_Serial_Number.tags_count;
+	td->all_tags       = asn_DEF_SABP_Serial_Number.all_tags;
+	td->all_tags_count = asn_DEF_SABP_Serial_Number.all_tags_count;
+	/* End of these lines */
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_SABP_Serial_Number.per_constraints;
+	td->elements       = asn_DEF_SABP_Serial_Number.elements;
+	td->elements_count = asn_DEF_SABP_Serial_Number.elements_count;
+	td->specifics      = asn_DEF_SABP_Serial_Number.specifics;
+}
+
+void
+SABP_Old_Serial_Number_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Old_Serial_Number_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Old_Serial_Number_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Old_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Old_Serial_Number_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Old_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Old_Serial_Number_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Old_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Old_Serial_Number_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Old_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Old_Serial_Number_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Old_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Old_Serial_Number_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Old_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Old_Serial_Number_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Old_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Old_Serial_Number_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Old_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Old_Serial_Number_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Old_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_TYPE_descriptor_t asn_DEF_SABP_Old_Serial_Number = {
+	"SABP_Old-Serial-Number",
+	"SABP_Old-Serial-Number",
+	SABP_Old_Serial_Number_free,
+	SABP_Old_Serial_Number_print,
+	SABP_Old_Serial_Number_constraint,
+	SABP_Old_Serial_Number_decode_ber,
+	SABP_Old_Serial_Number_encode_der,
+	SABP_Old_Serial_Number_decode_xer,
+	SABP_Old_Serial_Number_encode_xer,
+	SABP_Old_Serial_Number_decode_uper,
+	SABP_Old_Serial_Number_encode_uper,
+	SABP_Old_Serial_Number_decode_aper,
+	SABP_Old_Serial_Number_encode_aper,
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_Paging-ETWS-Indicator.c b/src/sabp/SABP_Paging-ETWS-Indicator.c
new file mode 100644
index 0000000..056ec17
--- /dev/null
+++ b/src/sabp/SABP_Paging-ETWS-Indicator.c
@@ -0,0 +1,165 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Paging-ETWS-Indicator.h>
+
+int
+SABP_Paging_ETWS_Indicator_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Paging_ETWS_Indicator_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeEnumerated.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeEnumerated.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+SABP_Paging_ETWS_Indicator_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Paging_ETWS_Indicator_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Paging_ETWS_Indicator_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Paging_ETWS_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Paging_ETWS_Indicator_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Paging_ETWS_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Paging_ETWS_Indicator_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Paging_ETWS_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Paging_ETWS_Indicator_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Paging_ETWS_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Paging_ETWS_Indicator_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Paging_ETWS_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Paging_ETWS_Indicator_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Paging_ETWS_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Paging_ETWS_Indicator_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Paging_ETWS_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Paging_ETWS_Indicator_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Paging_ETWS_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Paging_ETWS_Indicator_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Paging_ETWS_Indicator_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Paging_ETWS_Indicator_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  0,  0,  0l,  0l }	/* (0..0,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_SABP_Paging_ETWS_Indicator_value2enum_1[] = {
+	{ 0,	6,	"paging" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_SABP_Paging_ETWS_Indicator_enum2value_1[] = {
+	0	/* paging(0) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_SABP_Paging_ETWS_Indicator_specs_1 = {
+	asn_MAP_SABP_Paging_ETWS_Indicator_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_SABP_Paging_ETWS_Indicator_enum2value_1,	/* N => "tag"; sorted by N */
+	1,	/* Number of elements in the maps */
+	2,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Paging_ETWS_Indicator_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Paging_ETWS_Indicator = {
+	"SABP_Paging-ETWS-Indicator",
+	"SABP_Paging-ETWS-Indicator",
+	SABP_Paging_ETWS_Indicator_free,
+	SABP_Paging_ETWS_Indicator_print,
+	SABP_Paging_ETWS_Indicator_constraint,
+	SABP_Paging_ETWS_Indicator_decode_ber,
+	SABP_Paging_ETWS_Indicator_encode_der,
+	SABP_Paging_ETWS_Indicator_decode_xer,
+	SABP_Paging_ETWS_Indicator_encode_xer,
+	SABP_Paging_ETWS_Indicator_decode_uper,
+	SABP_Paging_ETWS_Indicator_encode_uper,
+	SABP_Paging_ETWS_Indicator_decode_aper,
+	SABP_Paging_ETWS_Indicator_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Paging_ETWS_Indicator_tags_1,
+	sizeof(asn_DEF_SABP_Paging_ETWS_Indicator_tags_1)
+		/sizeof(asn_DEF_SABP_Paging_ETWS_Indicator_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Paging_ETWS_Indicator_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Paging_ETWS_Indicator_tags_1)
+		/sizeof(asn_DEF_SABP_Paging_ETWS_Indicator_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Paging_ETWS_Indicator_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_SABP_Paging_ETWS_Indicator_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Presence.c b/src/sabp/SABP_Presence.c
new file mode 100644
index 0000000..c63bdd9
--- /dev/null
+++ b/src/sabp/SABP_Presence.c
@@ -0,0 +1,167 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-CommonDataTypes"
+ * 	found in "../../asn1/sabp/SABP-CommonDataTypes.asn"
+ */
+
+#include <osmocom/sabp/SABP_Presence.h>
+
+int
+SABP_Presence_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Presence_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeEnumerated.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeEnumerated.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+SABP_Presence_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Presence_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Presence_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Presence_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Presence_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Presence_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Presence_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Presence_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Presence_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Presence_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Presence_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Presence_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Presence_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Presence_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Presence_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Presence_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Presence_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Presence_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Presence_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Presence_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Presence_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 2,  2,  0l,  2l }	/* (0..2) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_SABP_Presence_value2enum_1[] = {
+	{ 0,	8,	"optional" },
+	{ 1,	11,	"conditional" },
+	{ 2,	9,	"mandatory" }
+};
+static const unsigned int asn_MAP_SABP_Presence_enum2value_1[] = {
+	1,	/* conditional(1) */
+	2,	/* mandatory(2) */
+	0	/* optional(0) */
+};
+static const asn_INTEGER_specifics_t asn_SPC_SABP_Presence_specs_1 = {
+	asn_MAP_SABP_Presence_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_SABP_Presence_enum2value_1,	/* N => "tag"; sorted by N */
+	3,	/* Number of elements in the maps */
+	0,	/* Enumeration is not extensible */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Presence_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Presence = {
+	"SABP_Presence",
+	"SABP_Presence",
+	SABP_Presence_free,
+	SABP_Presence_print,
+	SABP_Presence_constraint,
+	SABP_Presence_decode_ber,
+	SABP_Presence_encode_der,
+	SABP_Presence_decode_xer,
+	SABP_Presence_encode_xer,
+	SABP_Presence_decode_uper,
+	SABP_Presence_encode_uper,
+	SABP_Presence_decode_aper,
+	SABP_Presence_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Presence_tags_1,
+	sizeof(asn_DEF_SABP_Presence_tags_1)
+		/sizeof(asn_DEF_SABP_Presence_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Presence_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Presence_tags_1)
+		/sizeof(asn_DEF_SABP_Presence_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Presence_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_SABP_Presence_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_ProcedureCode.c b/src/sabp/SABP_ProcedureCode.c
new file mode 100644
index 0000000..50b962d
--- /dev/null
+++ b/src/sabp/SABP_ProcedureCode.c
@@ -0,0 +1,165 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-CommonDataTypes"
+ * 	found in "../../asn1/sabp/SABP-CommonDataTypes.asn"
+ */
+
+#include <osmocom/sabp/SABP_ProcedureCode.h>
+
+int
+SABP_ProcedureCode_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0l && value <= 255l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_ProcedureCode_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeInteger.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeInteger.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+SABP_ProcedureCode_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_ProcedureCode_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_ProcedureCode_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_ProcedureCode_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_ProcedureCode_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_ProcedureCode_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_ProcedureCode_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_ProcedureCode_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_ProcedureCode_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_ProcedureCode_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_ProcedureCode_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_ProcedureCode_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_ProcedureCode_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_ProcedureCode_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_ProcedureCode_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_ProcedureCode_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_ProcedureCode_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_ProcedureCode_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_ProcedureCode_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_ProcedureCode_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_ProcedureCode_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 8,  8,  0l,  255l }	/* (0..255) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_ProcedureCode_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_ProcedureCode = {
+	"SABP_ProcedureCode",
+	"SABP_ProcedureCode",
+	SABP_ProcedureCode_free,
+	SABP_ProcedureCode_print,
+	SABP_ProcedureCode_constraint,
+	SABP_ProcedureCode_decode_ber,
+	SABP_ProcedureCode_encode_der,
+	SABP_ProcedureCode_decode_xer,
+	SABP_ProcedureCode_encode_xer,
+	SABP_ProcedureCode_decode_uper,
+	SABP_ProcedureCode_encode_uper,
+	SABP_ProcedureCode_decode_aper,
+	SABP_ProcedureCode_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_ProcedureCode_tags_1,
+	sizeof(asn_DEF_SABP_ProcedureCode_tags_1)
+		/sizeof(asn_DEF_SABP_ProcedureCode_tags_1[0]), /* 1 */
+	asn_DEF_SABP_ProcedureCode_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_ProcedureCode_tags_1)
+		/sizeof(asn_DEF_SABP_ProcedureCode_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_ProcedureCode_constr_1,
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_ProtocolExtensionID.c b/src/sabp/SABP_ProtocolExtensionID.c
new file mode 100644
index 0000000..f4d6752
--- /dev/null
+++ b/src/sabp/SABP_ProtocolExtensionID.c
@@ -0,0 +1,165 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-CommonDataTypes"
+ * 	found in "../../asn1/sabp/SABP-CommonDataTypes.asn"
+ */
+
+#include <osmocom/sabp/SABP_ProtocolExtensionID.h>
+
+int
+SABP_ProtocolExtensionID_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0l && value <= 65535l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_ProtocolExtensionID_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeInteger.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeInteger.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+SABP_ProtocolExtensionID_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_ProtocolExtensionID_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_ProtocolExtensionID_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_ProtocolExtensionID_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_ProtocolExtensionID_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_ProtocolExtensionID_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_ProtocolExtensionID_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_ProtocolExtensionID_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_ProtocolExtensionID_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_ProtocolExtensionID_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_ProtocolExtensionID_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_ProtocolExtensionID_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_ProtocolExtensionID_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_ProtocolExtensionID_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_ProtocolExtensionID_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_ProtocolExtensionID_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_ProtocolExtensionID_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_ProtocolExtensionID_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_ProtocolExtensionID_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_ProtocolExtensionID_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_ProtocolExtensionID_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (0..65535) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_ProtocolExtensionID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_ProtocolExtensionID = {
+	"SABP_ProtocolExtensionID",
+	"SABP_ProtocolExtensionID",
+	SABP_ProtocolExtensionID_free,
+	SABP_ProtocolExtensionID_print,
+	SABP_ProtocolExtensionID_constraint,
+	SABP_ProtocolExtensionID_decode_ber,
+	SABP_ProtocolExtensionID_encode_der,
+	SABP_ProtocolExtensionID_decode_xer,
+	SABP_ProtocolExtensionID_encode_xer,
+	SABP_ProtocolExtensionID_decode_uper,
+	SABP_ProtocolExtensionID_encode_uper,
+	SABP_ProtocolExtensionID_decode_aper,
+	SABP_ProtocolExtensionID_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_ProtocolExtensionID_tags_1,
+	sizeof(asn_DEF_SABP_ProtocolExtensionID_tags_1)
+		/sizeof(asn_DEF_SABP_ProtocolExtensionID_tags_1[0]), /* 1 */
+	asn_DEF_SABP_ProtocolExtensionID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_ProtocolExtensionID_tags_1)
+		/sizeof(asn_DEF_SABP_ProtocolExtensionID_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_ProtocolExtensionID_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_ProtocolIE-ID.c b/src/sabp/SABP_ProtocolIE-ID.c
new file mode 100644
index 0000000..a3b013a
--- /dev/null
+++ b/src/sabp/SABP_ProtocolIE-ID.c
@@ -0,0 +1,165 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-CommonDataTypes"
+ * 	found in "../../asn1/sabp/SABP-CommonDataTypes.asn"
+ */
+
+#include <osmocom/sabp/SABP_ProtocolIE-ID.h>
+
+int
+SABP_ProtocolIE_ID_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0l && value <= 65535l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_ProtocolIE_ID_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeInteger.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeInteger.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+SABP_ProtocolIE_ID_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_ProtocolIE_ID_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_ProtocolIE_ID_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_ProtocolIE_ID_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_ProtocolIE_ID_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_ProtocolIE_ID_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_ProtocolIE_ID_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_ProtocolIE_ID_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_ProtocolIE_ID_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_ProtocolIE_ID_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_ProtocolIE_ID_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_ProtocolIE_ID_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_ProtocolIE_ID_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_ProtocolIE_ID_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_ProtocolIE_ID_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_ProtocolIE_ID_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_ProtocolIE_ID_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_ProtocolIE_ID_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_ProtocolIE_ID_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_ProtocolIE_ID_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_ProtocolIE_ID_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (0..65535) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_ProtocolIE_ID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_ProtocolIE_ID = {
+	"SABP_ProtocolIE-ID",
+	"SABP_ProtocolIE-ID",
+	SABP_ProtocolIE_ID_free,
+	SABP_ProtocolIE_ID_print,
+	SABP_ProtocolIE_ID_constraint,
+	SABP_ProtocolIE_ID_decode_ber,
+	SABP_ProtocolIE_ID_encode_der,
+	SABP_ProtocolIE_ID_decode_xer,
+	SABP_ProtocolIE_ID_encode_xer,
+	SABP_ProtocolIE_ID_decode_uper,
+	SABP_ProtocolIE_ID_encode_uper,
+	SABP_ProtocolIE_ID_decode_aper,
+	SABP_ProtocolIE_ID_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_ProtocolIE_ID_tags_1,
+	sizeof(asn_DEF_SABP_ProtocolIE_ID_tags_1)
+		/sizeof(asn_DEF_SABP_ProtocolIE_ID_tags_1[0]), /* 1 */
+	asn_DEF_SABP_ProtocolIE_ID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_ProtocolIE_ID_tags_1)
+		/sizeof(asn_DEF_SABP_ProtocolIE_ID_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_ProtocolIE_ID_constr_1,
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_Radio-Resource-Loading-List-Item.c b/src/sabp/SABP_Radio-Resource-Loading-List-Item.c
new file mode 100644
index 0000000..a7837f2
--- /dev/null
+++ b/src/sabp/SABP_Radio-Resource-Loading-List-Item.c
@@ -0,0 +1,83 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Radio-Resource-Loading-List-Item.h>
+
+static asn_TYPE_member_t asn_MBR_SABP_Radio_Resource_Loading_List_Item_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Radio_Resource_Loading_List_Item, service_area_identifier),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_Service_Area_Identifier,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"service-area-identifier"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Radio_Resource_Loading_List_Item, available_bandwidth),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_Available_Bandwidth,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"available-bandwidth"
+		},
+	{ ATF_POINTER, 1, offsetof(struct SABP_Radio_Resource_Loading_List_Item, iE_Extensions),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_IE_Extensions,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"iE-Extensions"
+		},
+};
+static const int asn_MAP_SABP_Radio_Resource_Loading_List_Item_oms_1[] = { 2 };
+static const ber_tlv_tag_t asn_DEF_SABP_Radio_Resource_Loading_List_Item_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Radio_Resource_Loading_List_Item_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* service-area-identifier */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* available-bandwidth */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* iE-Extensions */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Radio_Resource_Loading_List_Item_specs_1 = {
+	sizeof(struct SABP_Radio_Resource_Loading_List_Item),
+	offsetof(struct SABP_Radio_Resource_Loading_List_Item, _asn_ctx),
+	asn_MAP_SABP_Radio_Resource_Loading_List_Item_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_SABP_Radio_Resource_Loading_List_Item_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	2,	/* Start extensions */
+	4	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Radio_Resource_Loading_List_Item = {
+	"SABP_Radio-Resource-Loading-List-Item",
+	"SABP_Radio-Resource-Loading-List-Item",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Radio_Resource_Loading_List_Item_tags_1,
+	sizeof(asn_DEF_SABP_Radio_Resource_Loading_List_Item_tags_1)
+		/sizeof(asn_DEF_SABP_Radio_Resource_Loading_List_Item_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Radio_Resource_Loading_List_Item_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Radio_Resource_Loading_List_Item_tags_1)
+		/sizeof(asn_DEF_SABP_Radio_Resource_Loading_List_Item_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Radio_Resource_Loading_List_Item_1,
+	3,	/* Elements count */
+	&asn_SPC_SABP_Radio_Resource_Loading_List_Item_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Radio-Resource-Loading-List.c b/src/sabp/SABP_Radio-Resource-Loading-List.c
new file mode 100644
index 0000000..6adbfc7
--- /dev/null
+++ b/src/sabp/SABP_Radio-Resource-Loading-List.c
@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Radio-Resource-Loading-List.h>
+
+static asn_per_constraints_t asn_PER_type_SABP_Radio_Resource_Loading_List_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  1l,  65535l }	/* (SIZE(1..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_SABP_Radio_Resource_Loading_List_1[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_Radio_Resource_Loading_List_Item,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Radio_Resource_Loading_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_SABP_Radio_Resource_Loading_List_specs_1 = {
+	sizeof(struct SABP_Radio_Resource_Loading_List),
+	offsetof(struct SABP_Radio_Resource_Loading_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Radio_Resource_Loading_List = {
+	"SABP_Radio-Resource-Loading-List",
+	"SABP_Radio-Resource-Loading-List",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Radio_Resource_Loading_List_tags_1,
+	sizeof(asn_DEF_SABP_Radio_Resource_Loading_List_tags_1)
+		/sizeof(asn_DEF_SABP_Radio_Resource_Loading_List_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Radio_Resource_Loading_List_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Radio_Resource_Loading_List_tags_1)
+		/sizeof(asn_DEF_SABP_Radio_Resource_Loading_List_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Radio_Resource_Loading_List_constr_1,
+	asn_MBR_SABP_Radio_Resource_Loading_List_1,
+	1,	/* Single element */
+	&asn_SPC_SABP_Radio_Resource_Loading_List_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Recovery-Indication.c b/src/sabp/SABP_Recovery-Indication.c
new file mode 100644
index 0000000..e4c07e4
--- /dev/null
+++ b/src/sabp/SABP_Recovery-Indication.c
@@ -0,0 +1,165 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Recovery-Indication.h>
+
+int
+SABP_Recovery_Indication_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Recovery_Indication_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeEnumerated.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeEnumerated.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+SABP_Recovery_Indication_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Recovery_Indication_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Recovery_Indication_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Recovery_Indication_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Recovery_Indication_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Recovery_Indication_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Recovery_Indication_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Recovery_Indication_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Recovery_Indication_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Recovery_Indication_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Recovery_Indication_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Recovery_Indication_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Recovery_Indication_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Recovery_Indication_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Recovery_Indication_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Recovery_Indication_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Recovery_Indication_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Recovery_Indication_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Recovery_Indication_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Recovery_Indication_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Recovery_Indication_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 1,  1,  0l,  1l }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_SABP_Recovery_Indication_value2enum_1[] = {
+	{ 0,	9,	"data-lost" },
+	{ 1,	14,	"data-available" }
+};
+static const unsigned int asn_MAP_SABP_Recovery_Indication_enum2value_1[] = {
+	1,	/* data-available(1) */
+	0	/* data-lost(0) */
+};
+static const asn_INTEGER_specifics_t asn_SPC_SABP_Recovery_Indication_specs_1 = {
+	asn_MAP_SABP_Recovery_Indication_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_SABP_Recovery_Indication_enum2value_1,	/* N => "tag"; sorted by N */
+	2,	/* Number of elements in the maps */
+	0,	/* Enumeration is not extensible */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Recovery_Indication_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Recovery_Indication = {
+	"SABP_Recovery-Indication",
+	"SABP_Recovery-Indication",
+	SABP_Recovery_Indication_free,
+	SABP_Recovery_Indication_print,
+	SABP_Recovery_Indication_constraint,
+	SABP_Recovery_Indication_decode_ber,
+	SABP_Recovery_Indication_encode_der,
+	SABP_Recovery_Indication_decode_xer,
+	SABP_Recovery_Indication_encode_xer,
+	SABP_Recovery_Indication_decode_uper,
+	SABP_Recovery_Indication_encode_uper,
+	SABP_Recovery_Indication_decode_aper,
+	SABP_Recovery_Indication_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Recovery_Indication_tags_1,
+	sizeof(asn_DEF_SABP_Recovery_Indication_tags_1)
+		/sizeof(asn_DEF_SABP_Recovery_Indication_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Recovery_Indication_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Recovery_Indication_tags_1)
+		/sizeof(asn_DEF_SABP_Recovery_Indication_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Recovery_Indication_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_SABP_Recovery_Indication_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Repetition-Period.c b/src/sabp/SABP_Repetition-Period.c
new file mode 100644
index 0000000..2286dfc
--- /dev/null
+++ b/src/sabp/SABP_Repetition-Period.c
@@ -0,0 +1,165 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Repetition-Period.h>
+
+int
+SABP_Repetition_Period_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 1l && value <= 4096l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Repetition_Period_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeInteger.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeInteger.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+SABP_Repetition_Period_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Repetition_Period_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Repetition_Period_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Repetition_Period_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Repetition_Period_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Repetition_Period_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Repetition_Period_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Repetition_Period_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Repetition_Period_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Repetition_Period_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Repetition_Period_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Repetition_Period_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Repetition_Period_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Repetition_Period_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Repetition_Period_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Repetition_Period_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Repetition_Period_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Repetition_Period_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Repetition_Period_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Repetition_Period_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Repetition_Period_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 12,  12,  1l,  4096l }	/* (1..4096) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Repetition_Period_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Repetition_Period = {
+	"SABP_Repetition-Period",
+	"SABP_Repetition-Period",
+	SABP_Repetition_Period_free,
+	SABP_Repetition_Period_print,
+	SABP_Repetition_Period_constraint,
+	SABP_Repetition_Period_decode_ber,
+	SABP_Repetition_Period_encode_der,
+	SABP_Repetition_Period_decode_xer,
+	SABP_Repetition_Period_encode_xer,
+	SABP_Repetition_Period_decode_uper,
+	SABP_Repetition_Period_encode_uper,
+	SABP_Repetition_Period_decode_aper,
+	SABP_Repetition_Period_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Repetition_Period_tags_1,
+	sizeof(asn_DEF_SABP_Repetition_Period_tags_1)
+		/sizeof(asn_DEF_SABP_Repetition_Period_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Repetition_Period_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Repetition_Period_tags_1)
+		/sizeof(asn_DEF_SABP_Repetition_Period_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Repetition_Period_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_RepetitionNumber0.c b/src/sabp/SABP_RepetitionNumber0.c
new file mode 100644
index 0000000..affee21
--- /dev/null
+++ b/src/sabp/SABP_RepetitionNumber0.c
@@ -0,0 +1,165 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_RepetitionNumber0.h>
+
+int
+SABP_RepetitionNumber0_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0l && value <= 255l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_RepetitionNumber0_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeInteger.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeInteger.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+SABP_RepetitionNumber0_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_RepetitionNumber0_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_RepetitionNumber0_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_RepetitionNumber0_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_RepetitionNumber0_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_RepetitionNumber0_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_RepetitionNumber0_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_RepetitionNumber0_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_RepetitionNumber0_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_RepetitionNumber0_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_RepetitionNumber0_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_RepetitionNumber0_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_RepetitionNumber0_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_RepetitionNumber0_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_RepetitionNumber0_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_RepetitionNumber0_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_RepetitionNumber0_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_RepetitionNumber0_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_RepetitionNumber0_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_RepetitionNumber0_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_RepetitionNumber0_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 8,  8,  0l,  255l }	/* (0..255) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_RepetitionNumber0_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_RepetitionNumber0 = {
+	"SABP_RepetitionNumber0",
+	"SABP_RepetitionNumber0",
+	SABP_RepetitionNumber0_free,
+	SABP_RepetitionNumber0_print,
+	SABP_RepetitionNumber0_constraint,
+	SABP_RepetitionNumber0_decode_ber,
+	SABP_RepetitionNumber0_encode_der,
+	SABP_RepetitionNumber0_decode_xer,
+	SABP_RepetitionNumber0_encode_xer,
+	SABP_RepetitionNumber0_decode_uper,
+	SABP_RepetitionNumber0_encode_uper,
+	SABP_RepetitionNumber0_decode_aper,
+	SABP_RepetitionNumber0_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_RepetitionNumber0_tags_1,
+	sizeof(asn_DEF_SABP_RepetitionNumber0_tags_1)
+		/sizeof(asn_DEF_SABP_RepetitionNumber0_tags_1[0]), /* 1 */
+	asn_DEF_SABP_RepetitionNumber0_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_RepetitionNumber0_tags_1)
+		/sizeof(asn_DEF_SABP_RepetitionNumber0_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_RepetitionNumber0_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_RepetitionNumber1.c b/src/sabp/SABP_RepetitionNumber1.c
new file mode 100644
index 0000000..d4209dd
--- /dev/null
+++ b/src/sabp/SABP_RepetitionNumber1.c
@@ -0,0 +1,165 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_RepetitionNumber1.h>
+
+int
+SABP_RepetitionNumber1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 1l && value <= 256l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_RepetitionNumber1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeInteger.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeInteger.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+SABP_RepetitionNumber1_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_RepetitionNumber1_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_RepetitionNumber1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_RepetitionNumber1_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_RepetitionNumber1_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_RepetitionNumber1_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_RepetitionNumber1_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_RepetitionNumber1_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_RepetitionNumber1_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_RepetitionNumber1_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_RepetitionNumber1_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_RepetitionNumber1_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_RepetitionNumber1_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_RepetitionNumber1_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_RepetitionNumber1_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_RepetitionNumber1_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_RepetitionNumber1_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_RepetitionNumber1_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_RepetitionNumber1_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_RepetitionNumber1_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_RepetitionNumber1_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 8,  8,  1l,  256l }	/* (1..256) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_RepetitionNumber1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_RepetitionNumber1 = {
+	"SABP_RepetitionNumber1",
+	"SABP_RepetitionNumber1",
+	SABP_RepetitionNumber1_free,
+	SABP_RepetitionNumber1_print,
+	SABP_RepetitionNumber1_constraint,
+	SABP_RepetitionNumber1_decode_ber,
+	SABP_RepetitionNumber1_encode_der,
+	SABP_RepetitionNumber1_decode_xer,
+	SABP_RepetitionNumber1_encode_xer,
+	SABP_RepetitionNumber1_decode_uper,
+	SABP_RepetitionNumber1_encode_uper,
+	SABP_RepetitionNumber1_decode_aper,
+	SABP_RepetitionNumber1_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_RepetitionNumber1_tags_1,
+	sizeof(asn_DEF_SABP_RepetitionNumber1_tags_1)
+		/sizeof(asn_DEF_SABP_RepetitionNumber1_tags_1[0]), /* 1 */
+	asn_DEF_SABP_RepetitionNumber1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_RepetitionNumber1_tags_1)
+		/sizeof(asn_DEF_SABP_RepetitionNumber1_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_RepetitionNumber1_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_Reset-Complete.c b/src/sabp/SABP_Reset-Complete.c
new file mode 100644
index 0000000..849d3e2
--- /dev/null
+++ b/src/sabp/SABP_Reset-Complete.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Reset-Complete.h>
+
+static int
+memb_reset_Complete_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_reset_Complete_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_reset_Complete_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_reset_Complete_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_reset_Complete_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_reset_Complete_ies_specs_2 = {
+	sizeof(struct reset_Complete_ies),
+	offsetof(struct reset_Complete_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_reset_Complete_ies_2 = {
+	"reset-Complete-ies",
+	"reset-Complete-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_reset_Complete_ies_tags_2,
+	sizeof(asn_DEF_reset_Complete_ies_tags_2)
+		/sizeof(asn_DEF_reset_Complete_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_reset_Complete_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_reset_Complete_ies_tags_2)
+		/sizeof(asn_DEF_reset_Complete_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_reset_Complete_ies_constr_2,
+	asn_MBR_reset_Complete_ies_2,
+	1,	/* Single element */
+	&asn_SPC_reset_Complete_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Reset_Complete_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Reset_Complete, reset_Complete_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_reset_Complete_ies_2,
+		memb_reset_Complete_ies_constraint_1,
+		&asn_PER_memb_reset_Complete_ies_constr_2,
+		0,
+		"reset-Complete-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Reset_Complete_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Reset_Complete_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* reset-Complete-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Reset_Complete_specs_1 = {
+	sizeof(struct SABP_Reset_Complete),
+	offsetof(struct SABP_Reset_Complete, _asn_ctx),
+	asn_MAP_SABP_Reset_Complete_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Reset_Complete = {
+	"SABP_Reset-Complete",
+	"SABP_Reset-Complete",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Reset_Complete_tags_1,
+	sizeof(asn_DEF_SABP_Reset_Complete_tags_1)
+		/sizeof(asn_DEF_SABP_Reset_Complete_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Reset_Complete_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Reset_Complete_tags_1)
+		/sizeof(asn_DEF_SABP_Reset_Complete_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Reset_Complete_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Reset_Complete_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Reset-Failure.c b/src/sabp/SABP_Reset-Failure.c
new file mode 100644
index 0000000..c4ef4de
--- /dev/null
+++ b/src/sabp/SABP_Reset-Failure.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Reset-Failure.h>
+
+static int
+memb_reset_Failure_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_reset_Failure_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_reset_Failure_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_reset_Failure_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_reset_Failure_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_reset_Failure_ies_specs_2 = {
+	sizeof(struct reset_Failure_ies),
+	offsetof(struct reset_Failure_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_reset_Failure_ies_2 = {
+	"reset-Failure-ies",
+	"reset-Failure-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_reset_Failure_ies_tags_2,
+	sizeof(asn_DEF_reset_Failure_ies_tags_2)
+		/sizeof(asn_DEF_reset_Failure_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_reset_Failure_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_reset_Failure_ies_tags_2)
+		/sizeof(asn_DEF_reset_Failure_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_reset_Failure_ies_constr_2,
+	asn_MBR_reset_Failure_ies_2,
+	1,	/* Single element */
+	&asn_SPC_reset_Failure_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Reset_Failure_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Reset_Failure, reset_Failure_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_reset_Failure_ies_2,
+		memb_reset_Failure_ies_constraint_1,
+		&asn_PER_memb_reset_Failure_ies_constr_2,
+		0,
+		"reset-Failure-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Reset_Failure_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Reset_Failure_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* reset-Failure-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Reset_Failure_specs_1 = {
+	sizeof(struct SABP_Reset_Failure),
+	offsetof(struct SABP_Reset_Failure, _asn_ctx),
+	asn_MAP_SABP_Reset_Failure_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Reset_Failure = {
+	"SABP_Reset-Failure",
+	"SABP_Reset-Failure",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Reset_Failure_tags_1,
+	sizeof(asn_DEF_SABP_Reset_Failure_tags_1)
+		/sizeof(asn_DEF_SABP_Reset_Failure_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Reset_Failure_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Reset_Failure_tags_1)
+		/sizeof(asn_DEF_SABP_Reset_Failure_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Reset_Failure_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Reset_Failure_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Reset.c b/src/sabp/SABP_Reset.c
new file mode 100644
index 0000000..0f18f90
--- /dev/null
+++ b/src/sabp/SABP_Reset.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Reset.h>
+
+static int
+memb_reset_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_reset_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_reset_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_reset_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_reset_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_reset_ies_specs_2 = {
+	sizeof(struct reset_ies),
+	offsetof(struct reset_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_reset_ies_2 = {
+	"reset-ies",
+	"reset-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_reset_ies_tags_2,
+	sizeof(asn_DEF_reset_ies_tags_2)
+		/sizeof(asn_DEF_reset_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_reset_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_reset_ies_tags_2)
+		/sizeof(asn_DEF_reset_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_reset_ies_constr_2,
+	asn_MBR_reset_ies_2,
+	1,	/* Single element */
+	&asn_SPC_reset_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Reset_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Reset, reset_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_reset_ies_2,
+		memb_reset_ies_constraint_1,
+		&asn_PER_memb_reset_ies_constr_2,
+		0,
+		"reset-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Reset_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Reset_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* reset-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Reset_specs_1 = {
+	sizeof(struct SABP_Reset),
+	offsetof(struct SABP_Reset, _asn_ctx),
+	asn_MAP_SABP_Reset_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Reset = {
+	"SABP_Reset",
+	"SABP_Reset",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Reset_tags_1,
+	sizeof(asn_DEF_SABP_Reset_tags_1)
+		/sizeof(asn_DEF_SABP_Reset_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Reset_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Reset_tags_1)
+		/sizeof(asn_DEF_SABP_Reset_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Reset_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Reset_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Restart.c b/src/sabp/SABP_Restart.c
new file mode 100644
index 0000000..a77bca7
--- /dev/null
+++ b/src/sabp/SABP_Restart.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Restart.h>
+
+static int
+memb_restart_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_restart_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_restart_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_restart_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_restart_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_restart_ies_specs_2 = {
+	sizeof(struct restart_ies),
+	offsetof(struct restart_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_restart_ies_2 = {
+	"restart-ies",
+	"restart-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_restart_ies_tags_2,
+	sizeof(asn_DEF_restart_ies_tags_2)
+		/sizeof(asn_DEF_restart_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_restart_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_restart_ies_tags_2)
+		/sizeof(asn_DEF_restart_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_restart_ies_constr_2,
+	asn_MBR_restart_ies_2,
+	1,	/* Single element */
+	&asn_SPC_restart_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Restart_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Restart, restart_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_restart_ies_2,
+		memb_restart_ies_constraint_1,
+		&asn_PER_memb_restart_ies_constr_2,
+		0,
+		"restart-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Restart_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Restart_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* restart-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Restart_specs_1 = {
+	sizeof(struct SABP_Restart),
+	offsetof(struct SABP_Restart, _asn_ctx),
+	asn_MAP_SABP_Restart_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Restart = {
+	"SABP_Restart",
+	"SABP_Restart",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Restart_tags_1,
+	sizeof(asn_DEF_SABP_Restart_tags_1)
+		/sizeof(asn_DEF_SABP_Restart_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Restart_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Restart_tags_1)
+		/sizeof(asn_DEF_SABP_Restart_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Restart_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Restart_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_SABP-PDU.c b/src/sabp/SABP_SABP-PDU.c
new file mode 100644
index 0000000..a11315c
--- /dev/null
+++ b/src/sabp/SABP_SABP-PDU.c
@@ -0,0 +1,82 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_SABP-PDU.h>
+
+static asn_per_constraints_t asn_PER_type_SABP_SABP_PDU_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0l,  2l }	/* (0..2,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_SABP_SABP_PDU_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_SABP_PDU, choice.initiatingMessage),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_InitiatingMessage,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"initiatingMessage"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_SABP_PDU, choice.successfulOutcome),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_SuccessfulOutcome,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"successfulOutcome"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_SABP_PDU, choice.unsuccessfulOutcome),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_UnsuccessfulOutcome,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"unsuccessfulOutcome"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_SABP_PDU_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* initiatingMessage */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* successfulOutcome */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* unsuccessfulOutcome */
+};
+static asn_CHOICE_specifics_t asn_SPC_SABP_SABP_PDU_specs_1 = {
+	sizeof(struct SABP_SABP_PDU),
+	offsetof(struct SABP_SABP_PDU, _asn_ctx),
+	offsetof(struct SABP_SABP_PDU, present),
+	sizeof(((struct SABP_SABP_PDU *)0)->present),
+	asn_MAP_SABP_SABP_PDU_tag2el_1,
+	3,	/* Count of tags in the map */
+	0,
+	3	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_SABP_PDU = {
+	"SABP_SABP-PDU",
+	"SABP_SABP-PDU",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	CHOICE_decode_uper,
+	CHOICE_encode_uper,
+	CHOICE_decode_aper,
+	CHOICE_encode_aper,
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	&asn_PER_type_SABP_SABP_PDU_constr_1,
+	asn_MBR_SABP_SABP_PDU_1,
+	3,	/* Elements count */
+	&asn_SPC_SABP_SABP_PDU_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Serial-Number.c b/src/sabp/SABP_Serial-Number.c
new file mode 100644
index 0000000..b0308ed
--- /dev/null
+++ b/src/sabp/SABP_Serial-Number.c
@@ -0,0 +1,171 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Serial-Number.h>
+
+int
+SABP_Serial_Number_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(st->size > 0) {
+		/* Size in bits */
+		size = 8 * st->size - (st->bits_unused & 0x07);
+	} else {
+		size = 0;
+	}
+	
+	if((size == 16l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using BIT_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Serial_Number_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_BIT_STRING.free_struct;
+	td->print_struct   = asn_DEF_BIT_STRING.print_struct;
+	td->check_constraints = asn_DEF_BIT_STRING.check_constraints;
+	td->ber_decoder    = asn_DEF_BIT_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_BIT_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_BIT_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_BIT_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_BIT_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_BIT_STRING.uper_encoder;
+	td->aper_decoder   = asn_DEF_BIT_STRING.aper_decoder;
+	td->aper_encoder   = asn_DEF_BIT_STRING.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_BIT_STRING.per_constraints;
+	td->elements       = asn_DEF_BIT_STRING.elements;
+	td->elements_count = asn_DEF_BIT_STRING.elements_count;
+	td->specifics      = asn_DEF_BIT_STRING.specifics;
+}
+
+void
+SABP_Serial_Number_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Serial_Number_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Serial_Number_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Serial_Number_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Serial_Number_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Serial_Number_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Serial_Number_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Serial_Number_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Serial_Number_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Serial_Number_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Serial_Number_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Serial_Number_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Serial_Number_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  16l,  16l }	/* (SIZE(16..16)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Serial_Number_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Serial_Number = {
+	"SABP_Serial-Number",
+	"SABP_Serial-Number",
+	SABP_Serial_Number_free,
+	SABP_Serial_Number_print,
+	SABP_Serial_Number_constraint,
+	SABP_Serial_Number_decode_ber,
+	SABP_Serial_Number_encode_der,
+	SABP_Serial_Number_decode_xer,
+	SABP_Serial_Number_encode_xer,
+	SABP_Serial_Number_decode_uper,
+	SABP_Serial_Number_encode_uper,
+	SABP_Serial_Number_decode_aper,
+	SABP_Serial_Number_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Serial_Number_tags_1,
+	sizeof(asn_DEF_SABP_Serial_Number_tags_1)
+		/sizeof(asn_DEF_SABP_Serial_Number_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Serial_Number_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Serial_Number_tags_1)
+		/sizeof(asn_DEF_SABP_Serial_Number_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Serial_Number_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_Service-Area-Identifier.c b/src/sabp/SABP_Service-Area-Identifier.c
new file mode 100644
index 0000000..7c98288
--- /dev/null
+++ b/src/sabp/SABP_Service-Area-Identifier.c
@@ -0,0 +1,174 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Service-Area-Identifier.h>
+
+static int
+memb_pLMNidentity_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 3l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_lac_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 2l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_sac_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 2l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_pLMNidentity_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  3l,  3l }	/* (SIZE(3..3)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_lac_constr_3 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  2l,  2l }	/* (SIZE(2..2)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_sac_constr_4 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  2l,  2l }	/* (SIZE(2..2)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_SABP_Service_Area_Identifier_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Service_Area_Identifier, pLMNidentity),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_pLMNidentity_constraint_1,
+		&asn_PER_memb_pLMNidentity_constr_2,
+		0,
+		"pLMNidentity"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Service_Area_Identifier, lac),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_lac_constraint_1,
+		&asn_PER_memb_lac_constr_3,
+		0,
+		"lac"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Service_Area_Identifier, sac),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_sac_constraint_1,
+		&asn_PER_memb_sac_constr_4,
+		0,
+		"sac"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Service_Area_Identifier_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Service_Area_Identifier_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* pLMNidentity */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* lac */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* sac */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Service_Area_Identifier_specs_1 = {
+	sizeof(struct SABP_Service_Area_Identifier),
+	offsetof(struct SABP_Service_Area_Identifier, _asn_ctx),
+	asn_MAP_SABP_Service_Area_Identifier_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Service_Area_Identifier = {
+	"SABP_Service-Area-Identifier",
+	"SABP_Service-Area-Identifier",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Service_Area_Identifier_tags_1,
+	sizeof(asn_DEF_SABP_Service_Area_Identifier_tags_1)
+		/sizeof(asn_DEF_SABP_Service_Area_Identifier_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Service_Area_Identifier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Service_Area_Identifier_tags_1)
+		/sizeof(asn_DEF_SABP_Service_Area_Identifier_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Service_Area_Identifier_1,
+	3,	/* Elements count */
+	&asn_SPC_SABP_Service_Area_Identifier_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Service-Areas-List.c b/src/sabp/SABP_Service-Areas-List.c
new file mode 100644
index 0000000..b055363
--- /dev/null
+++ b/src/sabp/SABP_Service-Areas-List.c
@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Service-Areas-List.h>
+
+static asn_per_constraints_t asn_PER_type_SABP_Service_Areas_List_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  1l,  65535l }	/* (SIZE(1..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_SABP_Service_Areas_List_1[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_Service_Area_Identifier,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Service_Areas_List_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_SABP_Service_Areas_List_specs_1 = {
+	sizeof(struct SABP_Service_Areas_List),
+	offsetof(struct SABP_Service_Areas_List, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Service_Areas_List = {
+	"SABP_Service-Areas-List",
+	"SABP_Service-Areas-List",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Service_Areas_List_tags_1,
+	sizeof(asn_DEF_SABP_Service_Areas_List_tags_1)
+		/sizeof(asn_DEF_SABP_Service_Areas_List_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Service_Areas_List_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Service_Areas_List_tags_1)
+		/sizeof(asn_DEF_SABP_Service_Areas_List_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Service_Areas_List_constr_1,
+	asn_MBR_SABP_Service_Areas_List_1,
+	1,	/* Single element */
+	&asn_SPC_SABP_Service_Areas_List_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_SuccessfulOutcome.c b/src/sabp/SABP_SuccessfulOutcome.c
new file mode 100644
index 0000000..f1f9996
--- /dev/null
+++ b/src/sabp/SABP_SuccessfulOutcome.c
@@ -0,0 +1,81 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_SuccessfulOutcome.h>
+
+static asn_TYPE_member_t asn_MBR_SABP_SuccessfulOutcome_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_SuccessfulOutcome, procedureCode),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_ProcedureCode,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"procedureCode"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_SuccessfulOutcome, criticality),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_Criticality,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"criticality"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_SuccessfulOutcome, value),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_ANY,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"value"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_SuccessfulOutcome_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_SuccessfulOutcome_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* procedureCode */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_SuccessfulOutcome_specs_1 = {
+	sizeof(struct SABP_SuccessfulOutcome),
+	offsetof(struct SABP_SuccessfulOutcome, _asn_ctx),
+	asn_MAP_SABP_SuccessfulOutcome_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_SuccessfulOutcome = {
+	"SABP_SuccessfulOutcome",
+	"SABP_SuccessfulOutcome",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_SuccessfulOutcome_tags_1,
+	sizeof(asn_DEF_SABP_SuccessfulOutcome_tags_1)
+		/sizeof(asn_DEF_SABP_SuccessfulOutcome_tags_1[0]), /* 1 */
+	asn_DEF_SABP_SuccessfulOutcome_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_SuccessfulOutcome_tags_1)
+		/sizeof(asn_DEF_SABP_SuccessfulOutcome_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_SuccessfulOutcome_1,
+	3,	/* Elements count */
+	&asn_SPC_SABP_SuccessfulOutcome_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_TriggeringMessage.c b/src/sabp/SABP_TriggeringMessage.c
new file mode 100644
index 0000000..ec0c4b5
--- /dev/null
+++ b/src/sabp/SABP_TriggeringMessage.c
@@ -0,0 +1,169 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-CommonDataTypes"
+ * 	found in "../../asn1/sabp/SABP-CommonDataTypes.asn"
+ */
+
+#include <osmocom/sabp/SABP_TriggeringMessage.h>
+
+int
+SABP_TriggeringMessage_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_TriggeringMessage_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeEnumerated.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeEnumerated.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+SABP_TriggeringMessage_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_TriggeringMessage_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_TriggeringMessage_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_TriggeringMessage_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_TriggeringMessage_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_TriggeringMessage_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_TriggeringMessage_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_TriggeringMessage_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_TriggeringMessage_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_TriggeringMessage_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_TriggeringMessage_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_TriggeringMessage_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_TriggeringMessage_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_TriggeringMessage_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_TriggeringMessage_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_TriggeringMessage_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_TriggeringMessage_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_TriggeringMessage_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_TriggeringMessage_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_TriggeringMessage_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_TriggeringMessage_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 2,  2,  0l,  3l }	/* (0..3) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_SABP_TriggeringMessage_value2enum_1[] = {
+	{ 0,	18,	"initiating-message" },
+	{ 1,	18,	"successful-outcome" },
+	{ 2,	20,	"unsuccessful-outcome" },
+	{ 3,	7,	"outcome" }
+};
+static const unsigned int asn_MAP_SABP_TriggeringMessage_enum2value_1[] = {
+	0,	/* initiating-message(0) */
+	3,	/* outcome(3) */
+	1,	/* successful-outcome(1) */
+	2	/* unsuccessful-outcome(2) */
+};
+static const asn_INTEGER_specifics_t asn_SPC_SABP_TriggeringMessage_specs_1 = {
+	asn_MAP_SABP_TriggeringMessage_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_SABP_TriggeringMessage_enum2value_1,	/* N => "tag"; sorted by N */
+	4,	/* Number of elements in the maps */
+	0,	/* Enumeration is not extensible */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_SABP_TriggeringMessage_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_TriggeringMessage = {
+	"SABP_TriggeringMessage",
+	"SABP_TriggeringMessage",
+	SABP_TriggeringMessage_free,
+	SABP_TriggeringMessage_print,
+	SABP_TriggeringMessage_constraint,
+	SABP_TriggeringMessage_decode_ber,
+	SABP_TriggeringMessage_encode_der,
+	SABP_TriggeringMessage_decode_xer,
+	SABP_TriggeringMessage_encode_xer,
+	SABP_TriggeringMessage_decode_uper,
+	SABP_TriggeringMessage_encode_uper,
+	SABP_TriggeringMessage_decode_aper,
+	SABP_TriggeringMessage_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_TriggeringMessage_tags_1,
+	sizeof(asn_DEF_SABP_TriggeringMessage_tags_1)
+		/sizeof(asn_DEF_SABP_TriggeringMessage_tags_1[0]), /* 1 */
+	asn_DEF_SABP_TriggeringMessage_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_TriggeringMessage_tags_1)
+		/sizeof(asn_DEF_SABP_TriggeringMessage_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_TriggeringMessage_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_SABP_TriggeringMessage_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_TypeOfError.c b/src/sabp/SABP_TypeOfError.c
new file mode 100644
index 0000000..e6ec48c
--- /dev/null
+++ b/src/sabp/SABP_TypeOfError.c
@@ -0,0 +1,167 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_TypeOfError.h>
+
+int
+SABP_TypeOfError_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_TypeOfError_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	td->aper_decoder   = asn_DEF_NativeEnumerated.aper_decoder;
+	td->aper_encoder   = asn_DEF_NativeEnumerated.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+SABP_TypeOfError_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_TypeOfError_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_TypeOfError_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_TypeOfError_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_TypeOfError_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_TypeOfError_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_TypeOfError_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_TypeOfError_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_TypeOfError_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_TypeOfError_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_TypeOfError_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_TypeOfError_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_TypeOfError_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_TypeOfError_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_TypeOfError_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_TypeOfError_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_TypeOfError_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_TypeOfError_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_TypeOfError_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_TypeOfError_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_TypeOfError_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  1,  1,  0l,  1l }	/* (0..1,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_SABP_TypeOfError_value2enum_1[] = {
+	{ 0,	14,	"not-understood" },
+	{ 1,	7,	"missing" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_SABP_TypeOfError_enum2value_1[] = {
+	1,	/* missing(1) */
+	0	/* not-understood(0) */
+	/* This list is extensible */
+};
+static const asn_INTEGER_specifics_t asn_SPC_SABP_TypeOfError_specs_1 = {
+	asn_MAP_SABP_TypeOfError_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_SABP_TypeOfError_enum2value_1,	/* N => "tag"; sorted by N */
+	2,	/* Number of elements in the maps */
+	3,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_SABP_TypeOfError_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_TypeOfError = {
+	"SABP_TypeOfError",
+	"SABP_TypeOfError",
+	SABP_TypeOfError_free,
+	SABP_TypeOfError_print,
+	SABP_TypeOfError_constraint,
+	SABP_TypeOfError_decode_ber,
+	SABP_TypeOfError_encode_der,
+	SABP_TypeOfError_decode_xer,
+	SABP_TypeOfError_encode_xer,
+	SABP_TypeOfError_decode_uper,
+	SABP_TypeOfError_encode_uper,
+	SABP_TypeOfError_decode_aper,
+	SABP_TypeOfError_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_TypeOfError_tags_1,
+	sizeof(asn_DEF_SABP_TypeOfError_tags_1)
+		/sizeof(asn_DEF_SABP_TypeOfError_tags_1[0]), /* 1 */
+	asn_DEF_SABP_TypeOfError_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_TypeOfError_tags_1)
+		/sizeof(asn_DEF_SABP_TypeOfError_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_TypeOfError_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_SABP_TypeOfError_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_UnsuccessfulOutcome.c b/src/sabp/SABP_UnsuccessfulOutcome.c
new file mode 100644
index 0000000..423e8dc
--- /dev/null
+++ b/src/sabp/SABP_UnsuccessfulOutcome.c
@@ -0,0 +1,81 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_UnsuccessfulOutcome.h>
+
+static asn_TYPE_member_t asn_MBR_SABP_UnsuccessfulOutcome_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_UnsuccessfulOutcome, procedureCode),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_ProcedureCode,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"procedureCode"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_UnsuccessfulOutcome, criticality),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SABP_Criticality,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"criticality"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_UnsuccessfulOutcome, value),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_ANY,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"value"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_UnsuccessfulOutcome_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_UnsuccessfulOutcome_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* procedureCode */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* criticality */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* value */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_UnsuccessfulOutcome_specs_1 = {
+	sizeof(struct SABP_UnsuccessfulOutcome),
+	offsetof(struct SABP_UnsuccessfulOutcome, _asn_ctx),
+	asn_MAP_SABP_UnsuccessfulOutcome_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_UnsuccessfulOutcome = {
+	"SABP_UnsuccessfulOutcome",
+	"SABP_UnsuccessfulOutcome",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_UnsuccessfulOutcome_tags_1,
+	sizeof(asn_DEF_SABP_UnsuccessfulOutcome_tags_1)
+		/sizeof(asn_DEF_SABP_UnsuccessfulOutcome_tags_1[0]), /* 1 */
+	asn_DEF_SABP_UnsuccessfulOutcome_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_UnsuccessfulOutcome_tags_1)
+		/sizeof(asn_DEF_SABP_UnsuccessfulOutcome_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_UnsuccessfulOutcome_1,
+	3,	/* Elements count */
+	&asn_SPC_SABP_UnsuccessfulOutcome_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Warning-Type.c b/src/sabp/SABP_Warning-Type.c
new file mode 100644
index 0000000..4792b6c
--- /dev/null
+++ b/src/sabp/SABP_Warning-Type.c
@@ -0,0 +1,166 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_Warning-Type.h>
+
+int
+SABP_Warning_Type_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 2l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_Warning_Type_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->check_constraints = asn_DEF_OCTET_STRING.check_constraints;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	td->aper_decoder   = asn_DEF_OCTET_STRING.aper_decoder;
+	td->aper_encoder   = asn_DEF_OCTET_STRING.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+SABP_Warning_Type_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_Warning_Type_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_Warning_Type_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Warning_Type_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Warning_Type_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_Warning_Type_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_Warning_Type_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Warning_Type_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Warning_Type_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_Warning_Type_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_Warning_Type_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_Warning_Type_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_Warning_Type_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Warning_Type_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_Warning_Type_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Warning_Type_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_Warning_Type_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_Warning_Type_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_Warning_Type_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_Warning_Type_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_Warning_Type_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  2l,  2l }	/* (SIZE(2..2)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Warning_Type_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Warning_Type = {
+	"SABP_Warning-Type",
+	"SABP_Warning-Type",
+	SABP_Warning_Type_free,
+	SABP_Warning_Type_print,
+	SABP_Warning_Type_constraint,
+	SABP_Warning_Type_decode_ber,
+	SABP_Warning_Type_encode_der,
+	SABP_Warning_Type_decode_xer,
+	SABP_Warning_Type_encode_xer,
+	SABP_Warning_Type_decode_uper,
+	SABP_Warning_Type_encode_uper,
+	SABP_Warning_Type_decode_aper,
+	SABP_Warning_Type_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Warning_Type_tags_1,
+	sizeof(asn_DEF_SABP_Warning_Type_tags_1)
+		/sizeof(asn_DEF_SABP_Warning_Type_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Warning_Type_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Warning_Type_tags_1)
+		/sizeof(asn_DEF_SABP_Warning_Type_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_Warning_Type_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_WarningSecurityInfo.c b/src/sabp/SABP_WarningSecurityInfo.c
new file mode 100644
index 0000000..21eda36
--- /dev/null
+++ b/src/sabp/SABP_WarningSecurityInfo.c
@@ -0,0 +1,166 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-IEs"
+ * 	found in "../../asn1/sabp/SABP-IEs.asn"
+ */
+
+#include <osmocom/sabp/SABP_WarningSecurityInfo.h>
+
+int
+SABP_WarningSecurityInfo_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 50l)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+SABP_WarningSecurityInfo_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->check_constraints = asn_DEF_OCTET_STRING.check_constraints;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	td->aper_decoder   = asn_DEF_OCTET_STRING.aper_decoder;
+	td->aper_encoder   = asn_DEF_OCTET_STRING.aper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+SABP_WarningSecurityInfo_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	SABP_WarningSecurityInfo_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+SABP_WarningSecurityInfo_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_WarningSecurityInfo_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_WarningSecurityInfo_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	SABP_WarningSecurityInfo_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+SABP_WarningSecurityInfo_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_WarningSecurityInfo_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_WarningSecurityInfo_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	SABP_WarningSecurityInfo_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+SABP_WarningSecurityInfo_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	SABP_WarningSecurityInfo_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+SABP_WarningSecurityInfo_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_WarningSecurityInfo_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+SABP_WarningSecurityInfo_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_WarningSecurityInfo_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+asn_enc_rval_t
+SABP_WarningSecurityInfo_encode_aper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	SABP_WarningSecurityInfo_1_inherit_TYPE_descriptor(td);
+	return td->aper_encoder(td, constraints, structure, per_out);
+}
+
+asn_dec_rval_t
+SABP_WarningSecurityInfo_decode_aper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	SABP_WarningSecurityInfo_1_inherit_TYPE_descriptor(td);
+	return td->aper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+static asn_per_constraints_t asn_PER_type_SABP_WarningSecurityInfo_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  50l,  50l }	/* (SIZE(50..50)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_SABP_WarningSecurityInfo_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_WarningSecurityInfo = {
+	"SABP_WarningSecurityInfo",
+	"SABP_WarningSecurityInfo",
+	SABP_WarningSecurityInfo_free,
+	SABP_WarningSecurityInfo_print,
+	SABP_WarningSecurityInfo_constraint,
+	SABP_WarningSecurityInfo_decode_ber,
+	SABP_WarningSecurityInfo_encode_der,
+	SABP_WarningSecurityInfo_decode_xer,
+	SABP_WarningSecurityInfo_encode_xer,
+	SABP_WarningSecurityInfo_decode_uper,
+	SABP_WarningSecurityInfo_encode_uper,
+	SABP_WarningSecurityInfo_decode_aper,
+	SABP_WarningSecurityInfo_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_WarningSecurityInfo_tags_1,
+	sizeof(asn_DEF_SABP_WarningSecurityInfo_tags_1)
+		/sizeof(asn_DEF_SABP_WarningSecurityInfo_tags_1[0]), /* 1 */
+	asn_DEF_SABP_WarningSecurityInfo_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_WarningSecurityInfo_tags_1)
+		/sizeof(asn_DEF_SABP_WarningSecurityInfo_tags_1[0]), /* 1 */
+	&asn_PER_type_SABP_WarningSecurityInfo_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/src/sabp/SABP_Write-Replace-Complete.c b/src/sabp/SABP_Write-Replace-Complete.c
new file mode 100644
index 0000000..a3365a4
--- /dev/null
+++ b/src/sabp/SABP_Write-Replace-Complete.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Write-Replace-Complete.h>
+
+static int
+memb_write_Replace_Complete_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_write_Replace_Complete_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_write_Replace_Complete_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_write_Replace_Complete_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_write_Replace_Complete_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_write_Replace_Complete_ies_specs_2 = {
+	sizeof(struct write_Replace_Complete_ies),
+	offsetof(struct write_Replace_Complete_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_write_Replace_Complete_ies_2 = {
+	"write-Replace-Complete-ies",
+	"write-Replace-Complete-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_write_Replace_Complete_ies_tags_2,
+	sizeof(asn_DEF_write_Replace_Complete_ies_tags_2)
+		/sizeof(asn_DEF_write_Replace_Complete_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_write_Replace_Complete_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_write_Replace_Complete_ies_tags_2)
+		/sizeof(asn_DEF_write_Replace_Complete_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_write_Replace_Complete_ies_constr_2,
+	asn_MBR_write_Replace_Complete_ies_2,
+	1,	/* Single element */
+	&asn_SPC_write_Replace_Complete_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Write_Replace_Complete_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Write_Replace_Complete, write_Replace_Complete_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_write_Replace_Complete_ies_2,
+		memb_write_Replace_Complete_ies_constraint_1,
+		&asn_PER_memb_write_Replace_Complete_ies_constr_2,
+		0,
+		"write-Replace-Complete-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Write_Replace_Complete_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Write_Replace_Complete_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* write-Replace-Complete-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Write_Replace_Complete_specs_1 = {
+	sizeof(struct SABP_Write_Replace_Complete),
+	offsetof(struct SABP_Write_Replace_Complete, _asn_ctx),
+	asn_MAP_SABP_Write_Replace_Complete_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Write_Replace_Complete = {
+	"SABP_Write-Replace-Complete",
+	"SABP_Write-Replace-Complete",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Write_Replace_Complete_tags_1,
+	sizeof(asn_DEF_SABP_Write_Replace_Complete_tags_1)
+		/sizeof(asn_DEF_SABP_Write_Replace_Complete_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Write_Replace_Complete_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Write_Replace_Complete_tags_1)
+		/sizeof(asn_DEF_SABP_Write_Replace_Complete_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Write_Replace_Complete_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Write_Replace_Complete_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Write-Replace-Failure.c b/src/sabp/SABP_Write-Replace-Failure.c
new file mode 100644
index 0000000..b36baeb
--- /dev/null
+++ b/src/sabp/SABP_Write-Replace-Failure.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Write-Replace-Failure.h>
+
+static int
+memb_write_Replace_Failure_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_write_Replace_Failure_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_write_Replace_Failure_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_write_Replace_Failure_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_write_Replace_Failure_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_write_Replace_Failure_ies_specs_2 = {
+	sizeof(struct write_Replace_Failure_ies),
+	offsetof(struct write_Replace_Failure_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_write_Replace_Failure_ies_2 = {
+	"write-Replace-Failure-ies",
+	"write-Replace-Failure-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_write_Replace_Failure_ies_tags_2,
+	sizeof(asn_DEF_write_Replace_Failure_ies_tags_2)
+		/sizeof(asn_DEF_write_Replace_Failure_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_write_Replace_Failure_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_write_Replace_Failure_ies_tags_2)
+		/sizeof(asn_DEF_write_Replace_Failure_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_write_Replace_Failure_ies_constr_2,
+	asn_MBR_write_Replace_Failure_ies_2,
+	1,	/* Single element */
+	&asn_SPC_write_Replace_Failure_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Write_Replace_Failure_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Write_Replace_Failure, write_Replace_Failure_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_write_Replace_Failure_ies_2,
+		memb_write_Replace_Failure_ies_constraint_1,
+		&asn_PER_memb_write_Replace_Failure_ies_constr_2,
+		0,
+		"write-Replace-Failure-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Write_Replace_Failure_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Write_Replace_Failure_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* write-Replace-Failure-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Write_Replace_Failure_specs_1 = {
+	sizeof(struct SABP_Write_Replace_Failure),
+	offsetof(struct SABP_Write_Replace_Failure, _asn_ctx),
+	asn_MAP_SABP_Write_Replace_Failure_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Write_Replace_Failure = {
+	"SABP_Write-Replace-Failure",
+	"SABP_Write-Replace-Failure",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Write_Replace_Failure_tags_1,
+	sizeof(asn_DEF_SABP_Write_Replace_Failure_tags_1)
+		/sizeof(asn_DEF_SABP_Write_Replace_Failure_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Write_Replace_Failure_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Write_Replace_Failure_tags_1)
+		/sizeof(asn_DEF_SABP_Write_Replace_Failure_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Write_Replace_Failure_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Write_Replace_Failure_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp/SABP_Write-Replace.c b/src/sabp/SABP_Write-Replace.c
new file mode 100644
index 0000000..11a2bb4
--- /dev/null
+++ b/src/sabp/SABP_Write-Replace.c
@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "SABP-PDU"
+ * 	found in "../../asn1/sabp/SABP-PDU.asn"
+ */
+
+#include <osmocom/sabp/SABP_Write-Replace.h>
+
+static int
+memb_write_Replace_ies_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	/* Determine the number of elements */
+	size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
+	
+	if((size <= 65535l)) {
+		/* Perform validation of the inner elements */
+		return td->check_constraints(td, sptr, ctfailcb, app_key);
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_type_write_Replace_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_write_Replace_ies_constr_2 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 16,  16,  0l,  65535l }	/* (SIZE(0..65535)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_write_Replace_ies_2[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_SABP_IE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_write_Replace_ies_tags_2[] = {
+	(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_write_Replace_ies_specs_2 = {
+	sizeof(struct write_Replace_ies),
+	offsetof(struct write_Replace_ies, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_write_Replace_ies_2 = {
+	"write-Replace-ies",
+	"write-Replace-ies",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	SEQUENCE_OF_decode_aper,
+	SEQUENCE_OF_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_write_Replace_ies_tags_2,
+	sizeof(asn_DEF_write_Replace_ies_tags_2)
+		/sizeof(asn_DEF_write_Replace_ies_tags_2[0]) - 1, /* 1 */
+	asn_DEF_write_Replace_ies_tags_2,	/* Same as above */
+	sizeof(asn_DEF_write_Replace_ies_tags_2)
+		/sizeof(asn_DEF_write_Replace_ies_tags_2[0]), /* 2 */
+	&asn_PER_type_write_Replace_ies_constr_2,
+	asn_MBR_write_Replace_ies_2,
+	1,	/* Single element */
+	&asn_SPC_write_Replace_ies_specs_2	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_SABP_Write_Replace_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct SABP_Write_Replace, write_Replace_ies),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		0,
+		&asn_DEF_write_Replace_ies_2,
+		memb_write_Replace_ies_constraint_1,
+		&asn_PER_memb_write_Replace_ies_constr_2,
+		0,
+		"write-Replace-ies"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_SABP_Write_Replace_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_SABP_Write_Replace_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* write-Replace-ies */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_SABP_Write_Replace_specs_1 = {
+	sizeof(struct SABP_Write_Replace),
+	offsetof(struct SABP_Write_Replace, _asn_ctx),
+	asn_MAP_SABP_Write_Replace_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	0,	/* Start extensions */
+	2	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_SABP_Write_Replace = {
+	"SABP_Write-Replace",
+	"SABP_Write-Replace",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	SEQUENCE_decode_aper,
+	SEQUENCE_encode_aper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_SABP_Write_Replace_tags_1,
+	sizeof(asn_DEF_SABP_Write_Replace_tags_1)
+		/sizeof(asn_DEF_SABP_Write_Replace_tags_1[0]), /* 1 */
+	asn_DEF_SABP_Write_Replace_tags_1,	/* Same as above */
+	sizeof(asn_DEF_SABP_Write_Replace_tags_1)
+		/sizeof(asn_DEF_SABP_Write_Replace_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_SABP_Write_Replace_1,
+	1,	/* Elements count */
+	&asn_SPC_SABP_Write_Replace_specs_1	/* Additional specs */
+};
+
diff --git a/src/sabp_common.c b/src/sabp_common.c
new file mode 100644
index 0000000..cdb0e32
--- /dev/null
+++ b/src/sabp_common.c
@@ -0,0 +1,215 @@
+/* common SABP code */
+
+/* (C) 2015 by Harald Welte <laforge@gnumonks.org>
+ * All Rights Reserved
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <stdint.h>
+
+#include <osmocom/core/msgb.h>
+
+#include <osmocom/sabp/sabp_common.h>
+#include <asn1c/asn1helpers.h>
+
+extern int asn1_xer_print;
+int _sabp_DSABP = 0;
+#define DSABP _sabp_DSABP
+
+const struct value_string sabp_presence_vals[] = {
+	{ SABP_SABP_PDU_PR_initiatingMessage,	"Initiating" },
+	{ SABP_SABP_PDU_PR_successfulOutcome,	"Successful Outcome" },
+	{ SABP_SABP_PDU_PR_unsuccessfulOutcome,	"Unsuccessful Outcome" },
+	{ 0, NULL }
+};
+
+const struct value_string sabp_procedure_code_vals[] = {
+	{ SABP_ProcedureCode_id_Write_Replace, "Write-Replace" },
+	{ SABP_ProcedureCode_id_Kill, "Kill" },
+	{ SABP_ProcedureCode_id_Load_Status_Enquiry, "Load-Status-Enquiry" },
+	{ SABP_ProcedureCode_id_Message_Status_Query, "Message-Status-Query" },
+	{ SABP_ProcedureCode_id_Restart_Indication, "Restart-Indication" },
+	{ SABP_ProcedureCode_id_Reset, "Reset" },
+	{ SABP_ProcedureCode_id_Failure_Indication, "Failure-Indication" },
+	{ SABP_ProcedureCode_id_Error_Indication, "Error-Indication" },
+	{ 0, NULL }
+};
+
+const struct value_string sabp_cause_vals[] = {
+	{ SABP_Cause_parameter_not_recognised, "Parameter not recognized" },
+	{ SABP_Cause_parameter_value_invalid, "Parameter value invalid" },
+	{ SABP_Cause_valid_CN_message_not_identified, "Valid CN message not identified" },
+	{ SABP_Cause_service_area_identity_not_valid, "Service Area Identity not valid" },
+	{ SABP_Cause_unrecognised_message, "Unrecognised message" },
+	{ SABP_Cause_missing_mandatory_element, "Missing mandatory element" },
+	{ SABP_Cause_rNC_capacity_exceeded, "RNC capacity exceeded" },
+	{ SABP_Cause_rNC_memory_exceeded, "RNC memory exceeded" },
+	{ SABP_Cause_service_area_broadcast_not_supported, "Service Area Broadcast not supported" },
+	{ SABP_Cause_service_area_broadcast_not_operational, "Service Area Broadcast not operational" },
+	{ SABP_Cause_message_reference_already_used, "Message Reference already used" },
+	{ SABP_Cause_unspecifed_error, "Unspecified Error" },
+	{ SABP_Cause_transfer_syntax_error, "Transfer Syntax Error" },
+	{ SABP_Cause_semantic_error, "Semantic Error" },
+	{ SABP_Cause_message_not_compatible_with_receiver_state,
+						"Message not compatible with receiver state" },
+	{ SABP_Cause_abstract_syntax_error_reject, "Abstract Syntax Error - Reject" },
+	{ SABP_Cause_abstract_syntax_error_ignore_and_notify,
+						"Abstract Syntax Error - Ignore and Notify" },
+	{ SABP_Cause_abstract_syntax_error_falsely_constructed_message,
+						"Abstract Syntax Error - Falsely constructed message" },
+	{ 0, NULL }
+};
+
+static struct msgb *sabp_msgb_alloc(void)
+{
+	return msgb_alloc_headroom(1024+512, 512, "SABP Tx");
+}
+
+static struct msgb *_sabp_gen_msg(SABP_SABP_PDU_t *pdu)
+{
+	struct msgb *msg = sabp_msgb_alloc();
+	asn_enc_rval_t rval;
+
+	if (!msg)
+		return NULL;
+
+	rval = aper_encode_to_buffer(&asn_DEF_SABP_SABP_PDU, pdu,
+				       msg->data, msgb_tailroom(msg));
+	if (rval.encoded < 0) {
+		LOGP(DSABP, LOGL_ERROR, "Error encoding type: %s\n",
+				rval.failed_type->name);
+
+	}
+
+	msgb_put(msg, rval.encoded/8);
+
+	return msg;
+}
+
+struct msgb *sabp_generate_initiating_message(e_SABP_ProcedureCode procedureCode,
+					  SABP_Criticality_t criticality,
+					  asn_TYPE_descriptor_t *td, void *sptr)
+{
+	SABP_SABP_PDU_t pdu;
+	struct msgb *msg;
+	int rc;
+
+	memset(&pdu, 0, sizeof(pdu));
+
+	pdu.present = SABP_SABP_PDU_PR_initiatingMessage;
+	pdu.choice.initiatingMessage.procedureCode = procedureCode;
+	pdu.choice.initiatingMessage.criticality = criticality;
+	rc = ANY_fromType_aper(&pdu.choice.initiatingMessage.value, td, sptr);
+	if (rc < 0) {
+		LOGP(DSABP, LOGL_ERROR, "Error in ANY_fromType_aper\n");
+		return NULL;
+	}
+
+	msg = _sabp_gen_msg(&pdu);
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_SABP_SABP_PDU, &pdu);
+
+	return msg;
+}
+
+struct msgb *sabp_generate_successful_outcome(
+					   e_SABP_ProcedureCode procedureCode,
+					   SABP_Criticality_t criticality,
+					   asn_TYPE_descriptor_t * td,
+					   void *sptr)
+{
+	SABP_SABP_PDU_t pdu;
+	struct msgb *msg;
+	int rc;
+
+	memset(&pdu, 0, sizeof(pdu));
+
+	pdu.present = SABP_SABP_PDU_PR_successfulOutcome;
+	pdu.choice.successfulOutcome.procedureCode = procedureCode;
+	pdu.choice.successfulOutcome.criticality = criticality;
+	rc = ANY_fromType_aper(&pdu.choice.successfulOutcome.value, td, sptr);
+	if (rc < 0) {
+		LOGP(DSABP, LOGL_ERROR, "Error in ANY_fromType_aper\n");
+		return NULL;
+	}
+
+	msg = _sabp_gen_msg(&pdu);
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_SABP_SABP_PDU, &pdu);
+
+	return msg;
+}
+
+struct msgb *sabp_generate_unsuccessful_outcome(
+					e_SABP_ProcedureCode procedureCode,
+					SABP_Criticality_t criticality,
+					asn_TYPE_descriptor_t * td,
+					void *sptr)
+{
+	SABP_SABP_PDU_t pdu;
+	struct msgb *msg;
+	int rc;
+
+	memset(&pdu, 0, sizeof(pdu));
+
+	pdu.present = SABP_SABP_PDU_PR_unsuccessfulOutcome;
+	pdu.choice.unsuccessfulOutcome.procedureCode = procedureCode;
+	pdu.choice.unsuccessfulOutcome.criticality = criticality;
+	rc = ANY_fromType_aper(&pdu.choice.unsuccessfulOutcome.value, td, sptr);
+	if (rc < 0) {
+		LOGP(DSABP, LOGL_ERROR, "Error in ANY_fromType_aper\n");
+		return NULL;
+	}
+
+	msg = _sabp_gen_msg(&pdu);
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_SABP_SABP_PDU, &pdu);
+
+	return msg;
+}
+
+SABP_IE_t *sabp_new_ie(SABP_ProtocolIE_ID_t id,
+			SABP_Criticality_t criticality,
+			asn_TYPE_descriptor_t * type, void *sptr)
+{
+	SABP_IE_t *buff;
+	int rc;
+
+	if ((buff = CALLOC(1, sizeof(*buff))) == NULL) {
+		// Possible error on malloc
+		return NULL;
+	}
+
+	buff->id = id;
+	buff->criticality = criticality;
+
+	rc = ANY_fromType_aper(&buff->value, type, sptr);
+	if (rc < 0) {
+		LOGP(DSABP, LOGL_ERROR, "Error in ANY_fromType_aper\n");
+		FREEMEM(buff);
+		return NULL;
+	}
+
+	if (asn1_xer_print)
+		if (xer_fprint(stdout, &asn_DEF_SABP_IE, buff) < 0) {
+			FREEMEM(buff);
+			return NULL;
+		}
+
+	return buff;
+}
+
+void sabp_set_log_area(int log_area)
+{
+	_sabp_DSABP = log_area;
+}