diff --git a/skeletons/ANY.c b/skeletons/ANY.c
index e0add1c..3c82561 100644
--- a/skeletons/ANY.c
+++ b/skeletons/ANY.c
@@ -181,7 +181,7 @@
 
 asn_dec_rval_t
 ANY_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
-                asn_per_constraints_t *constraints, void **sptr,
+                const asn_per_constraints_t *constraints, void **sptr,
                 asn_per_data_t *pd) {
     asn_OCTET_STRING_specifics_t *specs =
         td->specifics ? (asn_OCTET_STRING_specifics_t *)td->specifics
@@ -236,8 +236,9 @@
 }
 
 asn_enc_rval_t
-ANY_encode_uper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
-                void *sptr, asn_per_outp_t *po) {
+ANY_encode_uper(asn_TYPE_descriptor_t *td,
+                const asn_per_constraints_t *constraints, void *sptr,
+                asn_per_outp_t *po) {
     const ANY_t *st = (const ANY_t *)sptr;
     asn_enc_rval_t er = {0, 0, 0};
     const uint8_t *buf;
diff --git a/skeletons/BIT_STRING.h b/skeletons/BIT_STRING.h
index ffca5f7..f74c433 100644
--- a/skeletons/BIT_STRING.h
+++ b/skeletons/BIT_STRING.h
@@ -13,7 +13,7 @@
 
 typedef struct BIT_STRING_s {
 	uint8_t *buf;	/* BIT STRING body */
-	int size;	/* Size of the above buffer */
+	size_t size;	/* Size of the above buffer */
 
 	int bits_unused;/* Unused trailing bits in the last octet (0..7) */
 
diff --git a/skeletons/BOOLEAN.c b/skeletons/BOOLEAN.c
index a9ac6c4..735a907 100644
--- a/skeletons/BOOLEAN.c
+++ b/skeletons/BOOLEAN.c
@@ -249,8 +249,9 @@
 
 asn_dec_rval_t
 BOOLEAN_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
-	asn_dec_rval_t rv;
+                    const asn_per_constraints_t *constraints, void **sptr,
+                    asn_per_data_t *pd) {
+    asn_dec_rval_t rv;
 	BOOLEAN_t *st = (BOOLEAN_t *)*sptr;
 
 	(void)opt_codec_ctx;
@@ -281,8 +282,9 @@
 
 asn_enc_rval_t
 BOOLEAN_encode_uper(asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+                    const asn_per_constraints_t *constraints, void *sptr,
+                    asn_per_outp_t *po) {
+    const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
 	asn_enc_rval_t er = { 0, 0, 0 };
 
 	(void)constraints;
diff --git a/skeletons/ENUMERATED.c b/skeletons/ENUMERATED.c
index ea89745..34bb9bd 100644
--- a/skeletons/ENUMERATED.c
+++ b/skeletons/ENUMERATED.c
@@ -50,9 +50,11 @@
 };
 
 asn_dec_rval_t
-ENUMERATED_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
-	asn_dec_rval_t rval;
+ENUMERATED_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
+                       asn_TYPE_descriptor_t *td,
+                       const asn_per_constraints_t *constraints, void **sptr,
+                       asn_per_data_t *pd) {
+    asn_dec_rval_t rval;
 	ENUMERATED_t *st = (ENUMERATED_t *)*sptr;
 	long value;
 	void *vptr = &value;
@@ -72,8 +74,9 @@
 
 asn_enc_rval_t
 ENUMERATED_encode_uper(asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-	ENUMERATED_t *st = (ENUMERATED_t *)sptr;
+                       const asn_per_constraints_t *constraints, void *sptr,
+                       asn_per_outp_t *po) {
+    ENUMERATED_t *st = (ENUMERATED_t *)sptr;
 	long value;
 
 	if(asn_INTEGER2long(st, &value))
diff --git a/skeletons/INTEGER.c b/skeletons/INTEGER.c
index 81e7964..4e085fb 100644
--- a/skeletons/INTEGER.c
+++ b/skeletons/INTEGER.c
@@ -565,11 +565,12 @@
 
 asn_dec_rval_t
 INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
-	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+                    const asn_per_constraints_t *constraints, void **sptr,
+                    asn_per_data_t *pd) {
+    asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
 	asn_dec_rval_t rval = { RC_OK, 0 };
 	INTEGER_t *st = (INTEGER_t *)*sptr;
-	asn_per_constraint_t *ct;
+	const asn_per_constraint_t *ct;
 	int repeat;
 
 	(void)opt_codec_ctx;
@@ -676,13 +677,14 @@
 
 asn_enc_rval_t
 INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+                    const asn_per_constraints_t *constraints, void *sptr,
+                    asn_per_outp_t *po) {
+    asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
 	asn_enc_rval_t er;
 	INTEGER_t *st = (INTEGER_t *)sptr;
 	const uint8_t *buf;
 	const uint8_t *end;
-	asn_per_constraint_t *ct;
+	const asn_per_constraint_t *ct;
 	long value = 0;
 	unsigned long v = 0;
 
diff --git a/skeletons/INTEGER_oer.c b/skeletons/INTEGER_oer.c
index b90698f..3462f7c 100644
--- a/skeletons/INTEGER_oer.c
+++ b/skeletons/INTEGER_oer.c
@@ -11,7 +11,7 @@
 
 asn_dec_rval_t
 INTEGER_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
-                   asn_oer_constraints_t *constraints, void **sptr,
+                   const asn_oer_constraints_t *constraints, void **sptr,
                    const void *ptr, size_t size) {
     asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
     asn_dec_rval_t rval = {RC_OK, 0};
@@ -99,7 +99,7 @@
  */
 asn_enc_rval_t
 INTEGER_encode_oer(asn_TYPE_descriptor_t *td,
-                   asn_oer_constraints_t *constraints, void *sptr,
+                   const asn_oer_constraints_t *constraints, void *sptr,
                    asn_app_consume_bytes_f *cb, void *app_key) {
     const INTEGER_t *st = sptr;
     asn_enc_rval_t er;
diff --git a/skeletons/NULL.c b/skeletons/NULL.c
index 2482eb7..2a88e7e 100644
--- a/skeletons/NULL.c
+++ b/skeletons/NULL.c
@@ -123,8 +123,9 @@
 
 asn_dec_rval_t
 NULL_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
-	asn_dec_rval_t rv;
+                 const asn_per_constraints_t *constraints, void **sptr,
+                 asn_per_data_t *pd) {
+    asn_dec_rval_t rv;
 
 	(void)opt_codec_ctx;
 	(void)td;
@@ -150,9 +151,10 @@
 }
 
 asn_enc_rval_t
-NULL_encode_uper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
-		void *sptr, asn_per_outp_t *po) {
-	asn_enc_rval_t er;
+NULL_encode_uper(asn_TYPE_descriptor_t *td,
+                 const asn_per_constraints_t *constraints, void *sptr,
+                 asn_per_outp_t *po) {
+    asn_enc_rval_t er;
 
 	(void)td;
 	(void)constraints;
diff --git a/skeletons/NativeEnumerated.c b/skeletons/NativeEnumerated.c
index e9ce38f..9de6dbf 100644
--- a/skeletons/NativeEnumerated.c
+++ b/skeletons/NativeEnumerated.c
@@ -85,12 +85,12 @@
 
 asn_dec_rval_t
 NativeEnumerated_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
-	asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
+	asn_TYPE_descriptor_t *td, const asn_per_constraints_t *constraints,
 	void **sptr, asn_per_data_t *pd) {
 	asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
 	asn_dec_rval_t rval = { RC_OK, 0 };
 	long *native = (long *)*sptr;
-	asn_per_constraint_t *ct;
+	const asn_per_constraint_t *ct;
 	long value;
 
 	(void)opt_codec_ctx;
@@ -151,11 +151,12 @@
 
 asn_enc_rval_t
 NativeEnumerated_encode_uper(asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-	asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
+                             const asn_per_constraints_t *constraints,
+                             void *sptr, asn_per_outp_t *po) {
+    asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
 	asn_enc_rval_t er;
 	long native, value;
-	asn_per_constraint_t *ct;
+	const asn_per_constraint_t *ct;
 	int inext = 0;
 	asn_INTEGER_enum_map_t key;
 	const asn_INTEGER_enum_map_t *kf;
diff --git a/skeletons/NativeInteger.c b/skeletons/NativeInteger.c
index fea9b9f..c49c6d2 100644
--- a/skeletons/NativeInteger.c
+++ b/skeletons/NativeInteger.c
@@ -248,10 +248,10 @@
 
 asn_dec_rval_t
 NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
-	asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
-
-	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+                          asn_TYPE_descriptor_t *td,
+                          const asn_per_constraints_t *constraints, void **sptr,
+                          asn_per_data_t *pd) {
+    asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
 	asn_dec_rval_t rval;
 	long *native = (long *)*sptr;
 	INTEGER_t tmpint;
@@ -284,8 +284,9 @@
 
 asn_enc_rval_t
 NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+                          const asn_per_constraints_t *constraints, void *sptr,
+                          asn_per_outp_t *po) {
+    asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
 	asn_enc_rval_t er;
 	long native;
 	INTEGER_t tmpint;
diff --git a/skeletons/NativeInteger_oer.c b/skeletons/NativeInteger_oer.c
index 7633a77..8cd9fec 100644
--- a/skeletons/NativeInteger_oer.c
+++ b/skeletons/NativeInteger_oer.c
@@ -12,8 +12,8 @@
 asn_dec_rval_t
 NativeInteger_decode_oer(asn_codec_ctx_t *opt_codec_ctx,
                          asn_TYPE_descriptor_t *td,
-                         asn_oer_constraints_t *constraints, void **nint_ptr,
-                         const void *ptr, size_t size) {
+                         const asn_oer_constraints_t *constraints,
+                         void **nint_ptr, const void *ptr, size_t size) {
     asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
     asn_dec_rval_t rval = {RC_OK, 0};
     long *native = (long *)*nint_ptr;
@@ -68,8 +68,8 @@
  */
 asn_enc_rval_t
 NativeInteger_encode_oer(asn_TYPE_descriptor_t *td,
-                   asn_oer_constraints_t *constraints, void *sptr,
-                   asn_app_consume_bytes_f *cb, void *app_key) {
+                         const asn_oer_constraints_t *constraints, void *sptr,
+                         asn_app_consume_bytes_f *cb, void *app_key) {
     asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
     INTEGER_t tmpint;
     long native;
diff --git a/skeletons/NativeReal.c b/skeletons/NativeReal.c
index 6297b6b..0278a92 100644
--- a/skeletons/NativeReal.c
+++ b/skeletons/NativeReal.c
@@ -206,9 +206,10 @@
  */
 asn_dec_rval_t
 NativeReal_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
-	asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
-		void **dbl_ptr, asn_per_data_t *pd) {
-	double *Dbl = (double *)*dbl_ptr;
+                       asn_TYPE_descriptor_t *td,
+                       const asn_per_constraints_t *constraints, void **dbl_ptr,
+                       asn_per_data_t *pd) {
+    double *Dbl = (double *)*dbl_ptr;
 	asn_dec_rval_t rval;
 	REAL_t tmp;
 	void *ptmp = &tmp;
@@ -246,8 +247,9 @@
  */
 asn_enc_rval_t
 NativeReal_encode_uper(asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-	double Dbl = *(const double *)sptr;
+                       const asn_per_constraints_t *constraints, void *sptr,
+                       asn_per_outp_t *po) {
+    double Dbl = *(const double *)sptr;
 	asn_enc_rval_t erval;
 	REAL_t tmp;
 
diff --git a/skeletons/OBJECT_IDENTIFIER.c b/skeletons/OBJECT_IDENTIFIER.c
index 6e19e0f..a3d9e72 100644
--- a/skeletons/OBJECT_IDENTIFIER.c
+++ b/skeletons/OBJECT_IDENTIFIER.c
@@ -237,9 +237,9 @@
 static ssize_t
 OBJECT_IDENTIFIER__dump_body(const OBJECT_IDENTIFIER_t *st, asn_app_consume_bytes_f *cb, void *app_key) {
 	ssize_t wrote_len = 0;
-	int startn;
+	size_t startn;
 	int add = 0;
-	int i;
+	size_t i;
 
 	for(i = 0, startn = 0; i < st->size; i++) {
 		uint8_t b = st->buf[i];
@@ -379,7 +379,7 @@
 	int num_arcs = 0;
 	int startn = 0;
 	int add = 0;
-	int i;
+	size_t i;
 
 	if(!oid || !oid->buf || (arc_slots && arc_type_size <= 1)) {
 		errno = EINVAL;
diff --git a/skeletons/OCTET_STRING.c b/skeletons/OCTET_STRING.c
index 597d2b3..c145631 100644
--- a/skeletons/OCTET_STRING.c
+++ b/skeletons/OCTET_STRING.c
@@ -124,14 +124,14 @@
  * No, I am not going to explain what the following stuff is.
  */
 struct _stack_el {
-	ber_tlv_len_t	left;	/* What's left to read (or -1) */
-	ber_tlv_len_t	got;	/* What was actually processed */
-	int	cont_level;	/* Depth of subcontainment */
-	int	want_nulls;	/* Want null "end of content" octets? */
-	int	bits_chopped;	/* Flag in BIT STRING mode */
-	ber_tlv_tag_t	tag;	/* For debugging purposes */
-	struct _stack_el *prev;
-	struct _stack_el *next;
+    ber_tlv_len_t left;     /* What's left to read (or -1) */
+    ber_tlv_len_t got;      /* What was actually processed */
+    size_t cont_level;      /* Depth of subcontainment */
+    int want_nulls;         /* Want null "end of content" octets? */
+    int bits_chopped;       /* Flag in BIT STRING mode */
+    ber_tlv_tag_t tag;      /* For debugging purposes */
+    struct _stack_el *prev;
+    struct _stack_el *next;
 };
 struct _stack {
 	struct _stack_el *tail;
@@ -344,7 +344,7 @@
 		case ASN_OSUBV_STR:
 		default:
 			if(sel) {
-				int level = sel->cont_level;
+				size_t level = sel->cont_level;
 				if(level < td->all_tags_count) {
 					expected_tag = td->all_tags[level];
 					break;
@@ -801,8 +801,8 @@
 	uint8_t *buf;
 
 	/* Reallocate buffer according to high cap estimation */
-	ssize_t _ns = st->size + (chunk_size + 1) / 2;
-	void *nptr = REALLOC(st->buf, _ns + 1);
+	size_t new_size = st->size + (chunk_size + 1) / 2;
+	void *nptr = REALLOC(st->buf, new_size + 1);
 	if(!nptr) return -1;
 	st->buf = (uint8_t *)nptr;
 	buf = st->buf + st->size;
@@ -859,7 +859,7 @@
 	}
 
 	st->size = buf - st->buf;	/* Adjust the buffer size */
-	assert(st->size <= _ns);
+	assert(st->size <= new_size);
 	st->buf[st->size] = 0;		/* Courtesy termination */
 
 	return (chunk_stop - (const char *)chunk_buf);	/* Converted size */
@@ -876,8 +876,8 @@
 	uint8_t *buf;
 
 	/* Reallocate buffer according to high cap estimation */
-	ssize_t _ns = st->size + (chunk_size + 7) / 8;
-	void *nptr = REALLOC(st->buf, _ns + 1);
+	size_t new_size = st->size + (chunk_size + 7) / 8;
+	void *nptr = REALLOC(st->buf, new_size + 1);
 	if(!nptr) return -1;
 	st->buf = (uint8_t *)nptr;
 	buf = st->buf + st->size;
@@ -921,7 +921,7 @@
 		st->bits_unused = bits_unused;
 	}
 
-	assert(st->size <= _ns);
+	assert(st->size <= new_size);
 	st->buf[st->size] = 0;		/* Courtesy termination */
 
 	return chunk_size;	/* Converted in full */
@@ -977,8 +977,8 @@
 	uint8_t *buf;
 
 	/* Reallocate buffer */
-	ssize_t _ns = st->size + chunk_size;
-	void *nptr = REALLOC(st->buf, _ns + 1);
+	size_t new_size = st->size + chunk_size;
+	void *nptr = REALLOC(st->buf, new_size + 1);
 	if(!nptr) return -1;
 	st->buf = (uint8_t *)nptr;
 	buf = st->buf + st->size;
@@ -1101,7 +1101,7 @@
 	}
 
 	st->size = buf - st->buf;
-	assert(st->size <= _ns);
+	assert(st->size <= new_size);
 	st->buf[st->size] = 0;		/* Courtesy termination */
 
 	return chunk_size;	/* Converted in full */
@@ -1205,7 +1205,7 @@
 static int
 OCTET_STRING_per_get_characters(asn_per_data_t *po, uint8_t *buf,
 		size_t units, unsigned int bpc, unsigned int unit_bits,
-		long lb, long ub, asn_per_constraints_t *pc) {
+		long lb, long ub, const asn_per_constraints_t *pc) {
 	uint8_t *end = buf + units * bpc;
 
 	ASN_DEBUG("Expanding %d characters into (%ld..%ld):%d",
@@ -1269,7 +1269,7 @@
 static int
 OCTET_STRING_per_put_characters(asn_per_outp_t *po, const uint8_t *buf,
 		size_t units, unsigned int bpc, unsigned int unit_bits,
-		long lb, long ub, asn_per_constraints_t *pc) {
+		long lb, long ub, const asn_per_constraints_t *pc) {
 	const uint8_t *end = buf + units * bpc;
 
 	ASN_DEBUG("Squeezing %d characters into (%ld..%ld):%d (%d bpc)",
@@ -1335,16 +1335,16 @@
 
 asn_dec_rval_t
 OCTET_STRING_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
-	asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
-	void **sptr, asn_per_data_t *pd) {
-
-	asn_OCTET_STRING_specifics_t *specs = td->specifics
+                         asn_TYPE_descriptor_t *td,
+                         const asn_per_constraints_t *constraints, void **sptr,
+                         asn_per_data_t *pd) {
+    asn_OCTET_STRING_specifics_t *specs = td->specifics
 		? (asn_OCTET_STRING_specifics_t *)td->specifics
 		: &asn_SPC_OCTET_STRING_specs;
-	asn_per_constraints_t *pc = constraints ? constraints
-				: td->per_constraints;
-	asn_per_constraint_t *cval;
-	asn_per_constraint_t *csiz;
+    const asn_per_constraints_t *pc =
+        constraints ? constraints : td->per_constraints;
+    const asn_per_constraint_t *cval;
+	const asn_per_constraint_t *csiz;
 	asn_dec_rval_t rval = { RC_OK, 0 };
 	BIT_STRING_t *st = (BIT_STRING_t *)*sptr;
 	ssize_t consumed_myself = 0;
@@ -1507,15 +1507,15 @@
 
 asn_enc_rval_t
 OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
-        asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-
-	asn_OCTET_STRING_specifics_t *specs = td->specifics
+                         const asn_per_constraints_t *constraints, void *sptr,
+                         asn_per_outp_t *po) {
+    asn_OCTET_STRING_specifics_t *specs = td->specifics
 		? (asn_OCTET_STRING_specifics_t *)td->specifics
 		: &asn_SPC_OCTET_STRING_specs;
-	asn_per_constraints_t *pc = constraints ? constraints
+	const asn_per_constraints_t *pc = constraints ? constraints
 				: td->per_constraints;
-	asn_per_constraint_t *cval;
-	asn_per_constraint_t *csiz;
+	const asn_per_constraint_t *cval;
+	const asn_per_constraint_t *csiz;
 	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
 	asn_enc_rval_t er = { 0, 0, 0 };
 	int inext = 0;		/* Lies not within extension root */
diff --git a/skeletons/OCTET_STRING.h b/skeletons/OCTET_STRING.h
index 59f8848..63e7da8 100644
--- a/skeletons/OCTET_STRING.h
+++ b/skeletons/OCTET_STRING.h
@@ -13,7 +13,7 @@
 
 typedef struct OCTET_STRING {
 	uint8_t *buf;	/* Buffer with consecutive OCTET_STRING bits */
-	int size;	/* Size of the buffer */
+	size_t size;	/* Size of the buffer */
 
 	asn_struct_ctx_t _asn_ctx;	/* Parsing across buffer boundaries */
 } OCTET_STRING_t;
diff --git a/skeletons/OCTET_STRING_oer.c b/skeletons/OCTET_STRING_oer.c
index 7fa76c0..b30dbe7 100644
--- a/skeletons/OCTET_STRING_oer.c
+++ b/skeletons/OCTET_STRING_oer.c
@@ -11,15 +11,15 @@
 
 asn_dec_rval_t
 OCTET_STRING_decode_oer(asn_codec_ctx_t *opt_codec_ctx,
-                         asn_TYPE_descriptor_t *td,
-                         asn_oer_constraints_t *constraints, void **sptr,
-                         const void *ptr, size_t size) {
+                        asn_TYPE_descriptor_t *td,
+                        const asn_oer_constraints_t *constraints, void **sptr,
+                        const void *ptr, size_t size) {
     asn_OCTET_STRING_specifics_t *specs =
         td->specifics
             ? (asn_OCTET_STRING_specifics_t *)td->specifics
             : (asn_OCTET_STRING_specifics_t *)&asn_DEF_OCTET_STRING.specifics;
     OCTET_STRING_t *st = (OCTET_STRING_t *)*sptr;
-    asn_oer_constraints_t *cts =
+    const asn_oer_constraints_t *cts =
         constraints ? constraints : td->oer_constraints;
     ssize_t ct_size = cts ? cts->size : -1;
     asn_dec_rval_t rval = {RC_OK, 0};
@@ -102,14 +102,14 @@
  */
 asn_enc_rval_t
 OCTET_STRING_encode_oer(asn_TYPE_descriptor_t *td,
-                   asn_oer_constraints_t *constraints, void *sptr,
-                   asn_app_consume_bytes_f *cb, void *app_key) {
+                        const asn_oer_constraints_t *constraints, void *sptr,
+                        asn_app_consume_bytes_f *cb, void *app_key) {
     asn_OCTET_STRING_specifics_t *specs =
         td->specifics
             ? (asn_OCTET_STRING_specifics_t *)td->specifics
             : (asn_OCTET_STRING_specifics_t *)&asn_DEF_OCTET_STRING.specifics;
     OCTET_STRING_t *st = (OCTET_STRING_t *)sptr;
-    asn_oer_constraints_t *cts =
+    const asn_oer_constraints_t *cts =
         constraints ? constraints : td->oer_constraints;
     ssize_t ct_size = cts ? cts->size : -1;
     asn_enc_rval_t er = {0, 0, 0};
diff --git a/skeletons/REAL.c b/skeletons/REAL.c
index 1204415..4761b6d 100644
--- a/skeletons/REAL.c
+++ b/skeletons/REAL.c
@@ -391,17 +391,18 @@
 }
 
 asn_dec_rval_t
-REAL_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
-	asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
-	void **sptr, asn_per_data_t *pd) {
-	(void)constraints;	/* No PER visible constraints */
+REAL_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+                 const asn_per_constraints_t *constraints, void **sptr,
+                 asn_per_data_t *pd) {
+    (void)constraints;	/* No PER visible constraints */
 	return OCTET_STRING_decode_uper(opt_codec_ctx, td, 0, sptr, pd);
 }
 
 asn_enc_rval_t
 REAL_encode_uper(asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-	(void)constraints;	/* No PER visible constraints */
+                 const asn_per_constraints_t *constraints, void *sptr,
+                 asn_per_outp_t *po) {
+    (void)constraints;	/* No PER visible constraints */
 	return OCTET_STRING_encode_uper(td, 0, sptr, po);
 }
 
@@ -538,7 +539,7 @@
 	sign = (octv & 0x40);	/* bit 7 */
 	scaleF = (octv & 0x0C) >> 2;	/* bits 4 to 3 */
 
-	if(st->size <= (int)(1 + (octv & 0x03))) {
+	if(st->size <= 1 + (octv & 0x03)) {
 		errno = EINVAL;
 		return -1;
 	}
@@ -546,7 +547,7 @@
 	elen = (octv & 0x03);	/* bits 2 to 1; 8.5.6.4 */
 	if(elen == 0x03) {	/* bits 2 to 1 = 11; 8.5.6.4, case d) */
 		elen = st->buf[1];	/* unsigned binary number */
-		if(elen == 0 || st->size <= (int)(2 + elen)) {
+		if(elen == 0 || st->size <= (2 + elen)) {
 			errno = EINVAL;
 			return -1;
 		}
diff --git a/skeletons/RELATIVE-OID.c b/skeletons/RELATIVE-OID.c
index 6fc9eac..3d1d415 100644
--- a/skeletons/RELATIVE-OID.c
+++ b/skeletons/RELATIVE-OID.c
@@ -57,8 +57,8 @@
 RELATIVE_OID__dump_body(const RELATIVE_OID_t *st, asn_app_consume_bytes_f *cb, void *app_key) {
 	ssize_t wrote = 0;
 	ssize_t ret;
-	int startn;
-	int i;
+	size_t startn;
+	size_t i;
 
 	for(i = 0, startn = 0; i < st->size; i++) {
 		uint8_t b = st->buf[i];
@@ -179,8 +179,8 @@
 	void *arcs, unsigned int arc_type_size, unsigned int arc_slots) {
 	void *arcs_end = (char *)arcs + (arc_slots * arc_type_size);
 	int num_arcs = 0;
-	int startn = 0;
-	int i;
+	size_t startn = 0;
+	size_t i;
 
 	if(!roid || !roid->buf) {
 		errno = EINVAL;
diff --git a/skeletons/asn_codecs_prim.h b/skeletons/asn_codecs_prim.h
index 0f683fd..7b75029 100644
--- a/skeletons/asn_codecs_prim.h
+++ b/skeletons/asn_codecs_prim.h
@@ -13,7 +13,7 @@
 
 typedef struct ASN__PRIMITIVE_TYPE_s {
 	uint8_t *buf;	/* Buffer with consecutive primitive encoding bytes */
-	int size;	/* Size of the buffer */
+    size_t size;    /* Size of the buffer */
 } ASN__PRIMITIVE_TYPE_t;	/* Do not use this type directly! */
 
 asn_struct_free_f ASN__PRIMITIVE_TYPE_free;
diff --git a/skeletons/ber_decoder.c b/skeletons/ber_decoder.c
index b3a6329..63c65bc 100644
--- a/skeletons/ber_decoder.c
+++ b/skeletons/ber_decoder.c
@@ -112,7 +112,7 @@
 		td->name, (long)size, tag_mode, step, tagno);
 	/* assert(td->tags_count >= 1) May not be the case for CHOICE or ANY */
 
-	if(tag_mode == 0 && tagno == td->tags_count) {
+	if(tag_mode == 0 && tagno == (int)td->tags_count) {
 		/*
 		 * This must be the _untagged_ ANY type,
 		 * which outermost tag isn't known in advance.
@@ -134,9 +134,9 @@
 			(long)(tag_len + len_len));
 		ADVANCE(tag_len + len_len);
 	} else {
-		assert(tagno < td->tags_count);	/* At least one loop */
+		assert(tagno < (int)td->tags_count);	/* At least one loop */
 	}
-	for((void)tagno; tagno < td->tags_count; tagno++, step++) {
+	for((void)tagno; tagno < (int)td->tags_count; tagno++, step++) {
 
 		/*
 		 * Fetch and process T from TLV.
@@ -186,7 +186,7 @@
 		 * If this one is the last one, check that the tag form
 		 * matches the one given in descriptor.
 		 */
-		if(tagno < (td->tags_count - 1)) {
+		if(tagno < ((int)td->tags_count - 1)) {
 			if(tlv_constr == 0) {
 				ASN_DEBUG("tlv_constr = %d, expfail",
 					tlv_constr);
diff --git a/skeletons/constr_CHOICE.c b/skeletons/constr_CHOICE.c
index 158101b..04cc4b7 100644
--- a/skeletons/constr_CHOICE.c
+++ b/skeletons/constr_CHOICE.c
@@ -376,7 +376,7 @@
 	 * If the structure was not initialized, it cannot be encoded:
 	 * can't deduce what to encode in the choice type.
 	 */
-	if(present <= 0 || present > td->elements_count) {
+	if(present <= 0 || (unsigned)present > td->elements_count) {
 		if(present == 0 && td->elements_count == 0) {
 			/* The CHOICE is empty?! */
 			erval.encoded = 0;
@@ -457,7 +457,7 @@
 	 */
 	present = _fetch_present_idx(ptr, specs->pres_offset, specs->pres_size);
 
-	if(present > 0 || present <= td->elements_count) {
+	if(present > 0 && (unsigned)present <= td->elements_count) {
 		const asn_TYPE_member_t *elm = &td->elements[present-1];
 		const void *memb_ptr;
 
@@ -493,7 +493,7 @@
 	 * Figure out which CHOICE element is encoded.
 	 */
 	present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size);
-	if(present > 0 && present <= td->elements_count) {
+	if(present > 0 && (unsigned)present <= td->elements_count) {
 		asn_TYPE_member_t *elm = &td->elements[present-1];
 		const void *memb_ptr;
 
@@ -561,7 +561,7 @@
 
 	asn_dec_rval_t rval;		/* Return value of a decoder */
 	ssize_t consumed_myself = 0;	/* Consumed bytes from ptr */
-	int edx;			/* Element index */
+	size_t edx;			/* Element index */
 
 	/*
 	 * Create the target structure if it is not present already.
@@ -787,7 +787,7 @@
 	 */
 	present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size);
 
-	if(present <= 0 || present > td->elements_count) {
+	if(present <= 0 || (unsigned)present > td->elements_count) {
 		ASN__ENCODE_FAILED;
 	}  else {
 		asn_enc_rval_t tmper;
@@ -826,10 +826,11 @@
 
 asn_dec_rval_t
 CHOICE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
-	asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
+                   const asn_per_constraints_t *constraints, void **sptr,
+                   asn_per_data_t *pd) {
+    asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
 	asn_dec_rval_t rv;
-	asn_per_constraint_t *ct;
+	const asn_per_constraint_t *ct;
 	asn_TYPE_member_t *elm;	/* CHOICE's element */
 	void *memb_ptr;
 	void **memb_ptr2;
@@ -870,7 +871,7 @@
 		value = uper_get_nsnnwn(pd);
 		if(value < 0) ASN__DECODE_STARVED;
 		value += specs->ext_start;
-		if(value >= td->elements_count)
+		if((unsigned)value >= td->elements_count)
 			ASN__DECODE_FAILED;
 	}
 
@@ -904,13 +905,14 @@
 			elm->name, td->name, rv.code);
 	return rv;
 }
-   
+
 asn_enc_rval_t
 CHOICE_encode_uper(asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-	asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
+                   const asn_per_constraints_t *constraints, void *sptr,
+                   asn_per_outp_t *po) {
+    asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
 	asn_TYPE_member_t *elm;	/* CHOICE's element */
-	asn_per_constraint_t *ct;
+	const asn_per_constraint_t *ct;
 	void *memb_ptr;
 	int present;
 	int present_enc;
@@ -930,7 +932,7 @@
 	 * If the structure was not initialized properly, it cannot be encoded:
 	 * can't deduce what to encode in the choice type.
 	 */
-	if(present <= 0 || present > td->elements_count)
+	if(present <= 0 || (unsigned)present > td->elements_count)
 		ASN__ENCODE_FAILED;
 	else
 		present--;
@@ -1005,7 +1007,7 @@
 	/*
 	 * Print that element.
 	 */
-	if(present > 0 && present <= td->elements_count) {
+	if(present > 0 && (unsigned)present <= td->elements_count) {
 		asn_TYPE_member_t *elm = &td->elements[present-1];
 		const void *memb_ptr;
 
@@ -1048,7 +1050,7 @@
 	/*
 	 * Free that element.
 	 */
-	if(present > 0 && present <= td->elements_count) {
+	if(present > 0 && (unsigned)present <= td->elements_count) {
 		asn_TYPE_member_t *elm = &td->elements[present-1];
 		void *memb_ptr;
 
diff --git a/skeletons/constr_CHOICE.h b/skeletons/constr_CHOICE.h
index e824a22..85b06ea 100644
--- a/skeletons/constr_CHOICE.h
+++ b/skeletons/constr_CHOICE.h
@@ -25,15 +25,15 @@
 	 * Tags to members mapping table.
 	 */
 	const asn_TYPE_tag2member_t *tag2el;
-	int tag2el_count;
+    unsigned tag2el_count;
 
-	/* Canonical ordering of CHOICE elements, for PER */
+    /* Canonical ordering of CHOICE elements, for PER */
 	int *canonical_order;
 
 	/*
 	 * Extensions-related stuff.
 	 */
-	int ext_start;		/* First member of extensions, or -1 */
+	signed ext_start;		/* First member of extensions, or -1 */
 } asn_CHOICE_specifics_t;
 
 /*
diff --git a/skeletons/constr_SEQUENCE.c b/skeletons/constr_SEQUENCE.c
index 5923023..15c12e2 100644
--- a/skeletons/constr_SEQUENCE.c
+++ b/skeletons/constr_SEQUENCE.c
@@ -66,8 +66,8 @@
  * Check whether we are inside the extensions group.
  */
 #define	IN_EXTENSION_GROUP(specs, memb_idx)	\
-	( ((memb_idx) > (specs)->ext_after)	\
-	&&((memb_idx) < (specs)->ext_before))
+	( (((signed)(memb_idx)) > (specs)->ext_after)	\
+	&&(((signed)(memb_idx)) < (specs)->ext_before))
 
 
 /*
@@ -127,7 +127,7 @@
 	asn_dec_rval_t rval;	/* Return code from subparsers */
 
 	ssize_t consumed_myself = 0;	/* Consumed bytes from ptr */
-	int edx;			/* SEQUENCE element's index */
+	size_t edx;			/* SEQUENCE element's index */
 
 	ASN_DEBUG("Decoding %s as SEQUENCE", td->name);
 	
@@ -186,14 +186,14 @@
 		 * that member:
 		 * 	step = (<member_number> * 2 + <microphase>).
 		 */
-	  for(edx = (ctx->step >> 1); edx < td->elements_count;
+	  for(edx = ((size_t)ctx->step >> 1); edx < td->elements_count;
 			edx++, ctx->step = (ctx->step & ~1) + 2) {
 		void *memb_ptr;		/* Pointer to the member */
 		void **memb_ptr2;	/* Pointer to that pointer */
 		ssize_t tag_len;	/* Length of TLV's T */
-		int opt_edx_end;	/* Next non-optional element */
+		size_t opt_edx_end;	/* Next non-optional element */
+		size_t n;
 		int use_bsearch;
-		int n;
 
 		if(ctx->step & 1)
 			goto microphase2;
@@ -215,7 +215,7 @@
 			||
 			/* All extensions are optional */
 			(IN_EXTENSION_GROUP(specs, edx)
-				&& specs->ext_before > td->elements_count)
+				&& specs->ext_before > (signed)td->elements_count)
 		   )
 		) {
 			ASN_DEBUG("End of SEQUENCE %s", td->name);
@@ -247,14 +247,14 @@
 				else
 					RETURN(RC_WMORE);
 			} else if(((const uint8_t *)ptr)[1] == 0) {
-			ASN_DEBUG("edx = %d, opt = %d, ec=%d",
+			ASN_DEBUG("edx = %zu, opt = %d, ec=%d",
 				edx, elements[edx].optional,
 				td->elements_count);
 				if((edx + elements[edx].optional
 					== td->elements_count)
 				|| (IN_EXTENSION_GROUP(specs, edx)
 					&& specs->ext_before
-						> td->elements_count)) {
+						> (signed)td->elements_count)) {
 					/*
 					 * Yeah, baby! Found the terminator
 					 * of the indefinite length structure.
@@ -320,7 +320,7 @@
 			if(t2m) {
 				const asn_TYPE_tag2member_t *best = 0;
 				const asn_TYPE_tag2member_t *t2m_f, *t2m_l;
-				int edx_max = edx + elements[edx].optional;
+				size_t edx_max = edx + elements[edx].optional;
 				/*
 				 * Rewind to the first element with that tag,
 				 * `cause bsearch() does not guarantee order.
@@ -516,7 +516,7 @@
 	size_t computed_size = 0;
 	asn_enc_rval_t erval;
 	ssize_t ret;
-	int edx;
+	size_t edx;
 
 	ASN_DEBUG("%s %s as SEQUENCE",
 		cb?"Encoding":"Estimating", td->name);
@@ -623,8 +623,7 @@
 
 	asn_dec_rval_t rval;		/* Return value from a decoder */
 	ssize_t consumed_myself = 0;	/* Consumed bytes from ptr */
-	int edx;			/* Element index */
-	int edx_end;
+	size_t edx;			/* Element index */
 
 	/*
 	 * Create the target structure if it is not present already.
@@ -653,7 +652,6 @@
 		ssize_t ch_size;		/* Chunk size */
 		xer_check_tag_e tcv;		/* Tag check value */
 		asn_TYPE_member_t *elm;
-		int n;
 
 		/*
 		 * Go inside the inner member of a sequence.
@@ -746,7 +744,7 @@
 				   /* All extensions are optional */
 				   (IN_EXTENSION_GROUP(specs, edx)
 					&& specs->ext_before
-						> td->elements_count)
+						> (signed)td->elements_count)
 				) {
 					XER_ADVANCE(ch_size);
 					ctx->phase = 4;	/* Phase out */
@@ -777,7 +775,8 @@
 				/*
 				 * Search which member corresponds to this tag.
 				 */
-				edx_end = edx + elements[edx].optional + 1;
+                size_t n;
+                size_t edx_end = edx + elements[edx].optional + 1;
 				if(edx_end > td->elements_count)
 					edx_end = td->elements_count;
 				for(n = edx; n < edx_end; n++) {
@@ -855,7 +854,7 @@
 		asn_app_consume_bytes_f *cb, void *app_key) {
 	asn_enc_rval_t er;
 	int xcan = (flags & XER_F_CANONICAL);
-	int edx;
+	size_t edx;
 
 	if(!sptr)
 		ASN__ENCODE_FAILED;
@@ -903,7 +902,7 @@
 int
 SEQUENCE_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	int edx;
+	size_t edx;
 	int ret;
 
 	if(!sptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
@@ -950,7 +949,7 @@
 
 void
 SEQUENCE_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only) {
-	int edx;
+	size_t edx;
 
 	if(!td || !sptr)
 		return;
@@ -978,7 +977,7 @@
 int
 SEQUENCE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 		asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-	int edx;
+	size_t edx;
 
 	if(!sptr) {
 		ASN__CTFAIL(app_key, td, sptr,
@@ -1029,14 +1028,15 @@
 
 asn_dec_rval_t
 SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
-	asn_SEQUENCE_specifics_t *specs = (asn_SEQUENCE_specifics_t *)td->specifics;
+                     const asn_per_constraints_t *constraints, void **sptr,
+                     asn_per_data_t *pd) {
+    asn_SEQUENCE_specifics_t *specs = (asn_SEQUENCE_specifics_t *)td->specifics;
 	void *st = *sptr;	/* Target structure. */
 	int extpresent;		/* Extension additions are present */
 	uint8_t *opres;		/* Presence of optional root members */
 	asn_per_data_t opmd;
 	asn_dec_rval_t rv;
-	int edx;
+	size_t edx;
 
 	(void)constraints;
 
@@ -1249,7 +1249,7 @@
 		= (asn_SEQUENCE_specifics_t *)td->specifics;
 	int exts_present = 0;
 	int exts_count = 0;
-	int edx;
+	size_t edx;
 
 	if(specs->ext_before < 0)
 		return 0;
@@ -1296,13 +1296,14 @@
 
 asn_enc_rval_t
 SEQUENCE_encode_uper(asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-	asn_SEQUENCE_specifics_t *specs
+                     const asn_per_constraints_t *constraints, void *sptr,
+                     asn_per_outp_t *po) {
+    asn_SEQUENCE_specifics_t *specs
 		= (asn_SEQUENCE_specifics_t *)td->specifics;
 	asn_enc_rval_t er;
 	int n_extensions;
-	int edx;
-	int i;
+	size_t edx;
+	size_t i;
 
 	(void)constraints;
 
@@ -1320,7 +1321,10 @@
 	 */
 	if(specs->ext_before >= 0) {
 		n_extensions = SEQUENCE_handle_extensions(td, sptr, 0, 0);
-		per_put_few_bits(po, n_extensions ? 1 : 0, 1);
+        if(n_extensions < 0)
+			ASN__ENCODE_FAILED;
+		if(per_put_few_bits(po, n_extensions ? 1 : 0, 1))
+			ASN__ENCODE_FAILED;
 	} else {
 		n_extensions = 0;	/* There are no extensions to encode */
 	}
diff --git a/skeletons/constr_SEQUENCE.h b/skeletons/constr_SEQUENCE.h
index fb96734..a9890de 100644
--- a/skeletons/constr_SEQUENCE.h
+++ b/skeletons/constr_SEQUENCE.h
@@ -22,21 +22,21 @@
 	 * Tags to members mapping table (sorted).
 	 */
 	const asn_TYPE_tag2member_t *tag2el;
-	int tag2el_count;
+    unsigned tag2el_count;
 
-	/*
+    /*
 	 * Optional members of the extensions root (roms) or additions (aoms).
 	 * Meaningful for PER.
 	 */
-	const int *oms;		/* Optional MemberS */
-	int  roms_count;	/* Root optional members count */
-	int  aoms_count;	/* Additions optional members count */
+    const int *oms;         /* Optional MemberS */
+    unsigned roms_count;    /* Root optional members count */
+    unsigned aoms_count;    /* Additions optional members count */
 
-	/*
+    /*
 	 * Description of an extensions group.
 	 */
-	int ext_after;		/* Extensions start after this member */
-	int ext_before;		/* Extensions stop before this member */
+    signed ext_after;       /* Extensions start after this member */
+    signed ext_before;      /* Extensions stop before this member */
 } asn_SEQUENCE_specifics_t;
 
 
diff --git a/skeletons/constr_SEQUENCE_OF.c b/skeletons/constr_SEQUENCE_OF.c
index 8a08ee8..73a7258 100644
--- a/skeletons/constr_SEQUENCE_OF.c
+++ b/skeletons/constr_SEQUENCE_OF.c
@@ -142,9 +142,10 @@
 
 asn_enc_rval_t
 SEQUENCE_OF_encode_uper(asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-	asn_anonymous_sequence_ *list;
-	asn_per_constraint_t *ct;
+                        const asn_per_constraints_t *constraints, void *sptr,
+                        asn_per_outp_t *po) {
+    asn_anonymous_sequence_ *list;
+	const asn_per_constraint_t *ct;
 	asn_enc_rval_t er;
 	asn_TYPE_member_t *elm = td->elements;
 	int seq;
diff --git a/skeletons/constr_SEQUENCE_oer.c b/skeletons/constr_SEQUENCE_oer.c
index bfc48bd..5fb697c 100644
--- a/skeletons/constr_SEQUENCE_oer.c
+++ b/skeletons/constr_SEQUENCE_oer.c
@@ -37,8 +37,8 @@
  * Check whether we are inside the extensions group.
  */
 #define IN_EXTENSION_GROUP(specs, memb_idx)     \
-        ( ((memb_idx) > (specs)->ext_after)     \
-        &&((memb_idx) < (specs)->ext_before))
+        ( (((ssize_t)(memb_idx)) > (specs)->ext_after)     \
+        &&(((ssize_t)(memb_idx)) < (specs)->ext_before))
 
 /*
  * Return a standardized complex structure.
@@ -70,8 +70,8 @@
 
 asn_dec_rval_t
 SEQUENCE_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
-                   asn_oer_constraints_t *constraints, void **struct_ptr,
-                   const void *ptr, size_t size) {
+                    const asn_oer_constraints_t *constraints, void **struct_ptr,
+                    const void *ptr, size_t size) {
     asn_SEQUENCE_specifics_t *specs = (asn_SEQUENCE_specifics_t *)td->specifics;
     asn_dec_rval_t rval = {RC_OK, 0};
     void *st = *struct_ptr; /* Target structure */
@@ -80,6 +80,7 @@
 
 
     (void)opt_codec_ctx;
+    (void)constraints;
     (void)specs;
 
     /*
@@ -378,8 +379,8 @@
  */
 asn_enc_rval_t
 SEQUENCE_encode_oer(asn_TYPE_descriptor_t *td,
-                   asn_oer_constraints_t *constraints, void *sptr,
-                   asn_app_consume_bytes_f *cb, void *app_key) {
+                    const asn_oer_constraints_t *constraints, void *sptr,
+                    asn_app_consume_bytes_f *cb, void *app_key) {
     asn_SEQUENCE_specifics_t *specs = (asn_SEQUENCE_specifics_t *)td->specifics;
     size_t computed_size = 0;
     int has_extensions_bit = (specs->ext_before >= 0);
@@ -388,6 +389,8 @@
     size_t edx;
     int ret;
 
+    (void)constraints;
+
     if(preamble_bits) {
         asn_per_outp_t preamble;
 
@@ -396,8 +399,8 @@
         preamble.op_key = app_key;
 
         if(has_extensions_bit) {
-            for(edx = specs->ext_after + 1; edx < specs->ext_before - 1;
-                edx++) {
+            for(edx = specs->ext_after + 1;
+                (ssize_t)edx < specs->ext_before - 1; edx++) {
                 asn_TYPE_member_t *elm = &td->elements[edx];
                 if(element_ptr(sptr, elm)) {
                     has_extensions = 1;
@@ -491,7 +494,8 @@
         if(ret < 0) ASN__ENCODE_FAILED;
 
         /* Encode presence bitmap #16.4.3 */
-        for(edx = specs->ext_after + 1; edx < specs->ext_before - 1; edx++) {
+        for(edx = specs->ext_after + 1; (ssize_t)edx < specs->ext_before - 1;
+            edx++) {
             asn_TYPE_member_t *elm = &td->elements[edx];
             void *memb_ptr = element_ptr(sptr, elm);
             ret |= per_put_few_bits(&extadds, memb_ptr ? 1 : 0, 1);
@@ -502,7 +506,8 @@
         computed_size += extadds.flushed_bytes;
 
         /* Now, encode extensions */
-        for(edx = specs->ext_after + 1; edx < specs->ext_before - 1; edx++) {
+        for(edx = specs->ext_after + 1; (ssize_t)edx < specs->ext_before - 1;
+            edx++) {
             asn_TYPE_member_t *elm = &td->elements[edx];
             void *memb_ptr = element_ptr(sptr, elm);
 
diff --git a/skeletons/constr_SET.c b/skeletons/constr_SET.c
index 55a0bad..a4f276a 100644
--- a/skeletons/constr_SET.c
+++ b/skeletons/constr_SET.c
@@ -112,7 +112,7 @@
 	asn_dec_rval_t rval;	/* Return code from subparsers */
 
 	ssize_t consumed_myself = 0;	/* Consumed bytes from ptr */
-	int edx;			/* SET element's index */
+	size_t edx;			/* SET element's index */
 
 	ASN_DEBUG("Decoding %s as SET", td->name);
 
@@ -394,7 +394,7 @@
 static int
 _SET_is_populated(asn_TYPE_descriptor_t *td, void *st) {
 	asn_SET_specifics_t *specs = (asn_SET_specifics_t *)td->specifics;
-	int edx;
+	size_t edx;
 
 	/*
 	 * Check that all mandatory elements are present.
@@ -441,9 +441,9 @@
 	int t2m_build_own = (specs->tag2el_count != td->elements_count);
 	const asn_TYPE_tag2member_t *t2m;
 	asn_TYPE_tag2member_t *t2m_build;
-	int t2m_count;
+	size_t t2m_count;
 	ssize_t ret;
-	int edx;
+	size_t edx;
 
 	/*
 	 * Use existing, or build our own tags map.
@@ -603,7 +603,7 @@
 
 	asn_dec_rval_t rval;		/* Return value from a decoder */
 	ssize_t consumed_myself = 0;	/* Consumed bytes from ptr */
-	int edx;			/* Element index */
+	size_t edx;			/* Element index */
 
 	/*
 	 * Create the target structure if it is not present already.
@@ -808,8 +808,8 @@
 	asn_enc_rval_t er;
 	int xcan = (flags & XER_F_CANONICAL);
 	const asn_TYPE_tag2member_t *t2m = specs->tag2el_cxer;
-	int t2m_count = specs->tag2el_cxer_count;
-	int edx;
+	size_t t2m_count = specs->tag2el_cxer_count;
+	size_t edx;
 
 	if(!sptr)
 		ASN__ENCODE_FAILED;
@@ -865,7 +865,7 @@
 int
 SET_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 		asn_app_consume_bytes_f *cb, void *app_key) {
-	int edx;
+	size_t edx;
 	int ret;
 
 	if(!sptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
@@ -911,7 +911,7 @@
 
 void
 SET_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
-	int edx;
+	size_t edx;
 
 	if(!td || !ptr)
 		return;
@@ -939,7 +939,7 @@
 int
 SET_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 		asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-	int edx;
+	size_t edx;
 
 	if(!sptr) {
 		ASN__CTFAIL(app_key, td, sptr,
diff --git a/skeletons/constr_SET.h b/skeletons/constr_SET.h
index 6a3a1aa..702bc05 100644
--- a/skeletons/constr_SET.h
+++ b/skeletons/constr_SET.h
@@ -13,33 +13,33 @@
 
 
 typedef const struct asn_SET_specifics_s {
-	/*
-	 * Target structure description.
-	 */
-	int struct_size;	/* Size of the target structure. */
-	int ctx_offset;		/* Offset of the asn_struct_ctx_t member */
-	int pres_offset;	/* Offset of _presence_map member */
+    /*
+     * Target structure description.
+     */
+    unsigned struct_size;       /* Size of the target structure. */
+    unsigned ctx_offset;        /* Offset of the asn_struct_ctx_t member */
+    unsigned pres_offset;       /* Offset of _presence_map member */
 
-	/*
-	 * Tags to members mapping table (sorted).
-	 * Sometimes suitable for DER encoding (untagged CHOICE is present);
-	 * if so, tag2el_count will be greater than td->elements_count.
-	 */
-	const asn_TYPE_tag2member_t *tag2el;
-	int tag2el_count;
+    /*
+     * Tags to members mapping table (sorted).
+     * Sometimes suitable for DER encoding (untagged CHOICE is present);
+     * if so, tag2el_count will be greater than td->elements_count.
+     */
+    const asn_TYPE_tag2member_t *tag2el;
+    unsigned tag2el_count;
 
-	/*
-	 * Tags to members mapping table, second edition.
-	 * Suitable for CANONICAL-XER encoding.
-	 */
-	const asn_TYPE_tag2member_t *tag2el_cxer;
-	int tag2el_cxer_count;
+    /*
+     * Tags to members mapping table, second edition.
+     * Suitable for CANONICAL-XER encoding.
+     */
+    const asn_TYPE_tag2member_t *tag2el_cxer;
+    unsigned tag2el_cxer_count;
 
-	/*
-	 * Extensions-related stuff.
-	 */
-	int extensible;				/* Whether SET is extensible */
-	const unsigned int *_mandatory_elements;	/* Bitmask of mandatory ones */
+    /*
+     * Extensions-related stuff.
+     */
+    int extensible;                             /* Whether SET is extensible */
+    const unsigned int *_mandatory_elements;    /* Bitmask of mandatory ones */
 } asn_SET_specifics_t;
 
 /*
diff --git a/skeletons/constr_SET_OF.c b/skeletons/constr_SET_OF.c
index 2dbc6e5..51291b8 100644
--- a/skeletons/constr_SET_OF.c
+++ b/skeletons/constr_SET_OF.c
@@ -866,13 +866,14 @@
 
 asn_dec_rval_t
 SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
-        asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
-	asn_dec_rval_t rv;
+                   const asn_per_constraints_t *constraints, void **sptr,
+                   asn_per_data_t *pd) {
+    asn_dec_rval_t rv;
         asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics;
 	asn_TYPE_member_t *elm = td->elements;	/* Single one */
 	void *st = *sptr;
 	asn_anonymous_set_ *list;
-	asn_per_constraint_t *ct;
+	const asn_per_constraint_t *ct;
 	int repeat = 0;
 	ssize_t nelems;
 
diff --git a/skeletons/constr_TYPE.h b/skeletons/constr_TYPE.h
index b1d4a1a..6fc618b 100644
--- a/skeletons/constr_TYPE.h
+++ b/skeletons/constr_TYPE.h
@@ -113,9 +113,9 @@
 	 */
 	asn_outmost_tag_f  *outmost_tag;	/* <optional, internal> */
 	const ber_tlv_tag_t *tags;	/* Effective tags sequence for this type */
-	int tags_count;			/* Number of tags which are expected */
+	unsigned tags_count;			/* Number of tags which are expected */
 	const ber_tlv_tag_t *all_tags;	/* Every tag for BER/containment */
-	int all_tags_count;		/* Number of tags */
+	unsigned all_tags_count;		/* Number of tags */
 
 	asn_oer_constraints_t *oer_constraints;	/* OER constraints */
 	asn_per_constraints_t *per_constraints;	/* PER constraints */
@@ -124,7 +124,7 @@
 	 * An ASN.1 production type members (members of SEQUENCE, SET, CHOICE).
 	 */
 	struct asn_TYPE_member_s *elements;
-	int elements_count;
+	unsigned elements_count;
 
 	/*
 	 * Additional information describing the type, used by appropriate
@@ -143,27 +143,27 @@
 	ATF_OPEN_TYPE	= 0x02	/* ANY type, without meaningful tag */
   };
 typedef struct asn_TYPE_member_s {
-	enum asn_TYPE_flags_e flags;	/* Element's presentation flags */
-	int optional;	/* Following optional members, including current */
-	int memb_offset;		/* Offset of the element */
-	ber_tlv_tag_t tag;		/* Outmost (most immediate) tag */
-	int tag_mode;		/* IMPLICIT/no/EXPLICIT tag at current level */
-	asn_TYPE_descriptor_t *type;	/* Member type descriptor */
-	asn_constr_check_f *memb_constraints;	/* Constraints validator */
-	asn_oer_constraints_t *oer_constraints;	/* OER compiled constraints */
-	asn_per_constraints_t *per_constraints;	/* PER compiled constraints */
-	int (*default_value)(int setval, void **sptr);	/* DEFAULT <value> */
-	const char *name;			/* ASN.1 identifier of the element */
+    enum asn_TYPE_flags_e flags; /* Element's presentation flags */
+    unsigned optional;      /* Following optional members, including current */
+    unsigned memb_offset;   /* Offset of the element */
+    ber_tlv_tag_t tag;      /* Outmost (most immediate) tag */
+    int tag_mode;           /* IMPLICIT/no/EXPLICIT tag at current level */
+    asn_TYPE_descriptor_t *type;            /* Member type descriptor */
+    asn_constr_check_f *memb_constraints;   /* Constraints validator */
+    asn_oer_constraints_t *oer_constraints; /* OER compiled constraints */
+    asn_per_constraints_t *per_constraints; /* PER compiled constraints */
+    int (*default_value)(int setval, void **sptr); /* DEFAULT <value> */
+    const char *name; /* ASN.1 identifier of the element */
 } asn_TYPE_member_t;
 
 /*
  * BER tag to element number mapping.
  */
 typedef struct asn_TYPE_tag2member_s {
-	ber_tlv_tag_t el_tag;	/* Outmost tag of the member */
-	int el_no;		/* Index of the associated member, base 0 */
-	int toff_first;		/* First occurence of the el_tag, relative */
-	int toff_last;		/* Last occurence of the el_tag, relatvie */
+    ber_tlv_tag_t el_tag;   /* Outmost tag of the member */
+    unsigned el_no;         /* Index of the associated member, base 0 */
+    unsigned toff_first;    /* First occurence of the el_tag, relative */
+    unsigned toff_last;		/* Last occurence of the el_tag, relative */
 } asn_TYPE_tag2member_t;
 
 /*
diff --git a/skeletons/oer_decoder.h b/skeletons/oer_decoder.h
index 9e1cb00..2b2a619 100644
--- a/skeletons/oer_decoder.h
+++ b/skeletons/oer_decoder.h
@@ -32,7 +32,7 @@
 typedef asn_dec_rval_t(oer_type_decoder_f)(
     struct asn_codec_ctx_s *opt_codec_ctx,
     struct asn_TYPE_descriptor_s *type_descriptor,
-    asn_oer_constraints_t *constraints,
+    const asn_oer_constraints_t *constraints,
     void **struct_ptr,
     const void *buf_ptr,
     size_t size);
diff --git a/skeletons/oer_encoder.c b/skeletons/oer_encoder.c
index 4358a92..490043c 100644
--- a/skeletons/oer_encoder.c
+++ b/skeletons/oer_encoder.c
@@ -47,7 +47,7 @@
  */
 asn_enc_rval_t
 oer_encode_to_buffer(struct asn_TYPE_descriptor_s *type_descriptor,
-                     asn_oer_constraints_t *constraints,
+                     const asn_oer_constraints_t *constraints,
                      void *struct_ptr,  /* Structure to be encoded */
                      void *buffer,      /* Pre-allocated buffer */
                      size_t buffer_size /* Initial buffer size (maximum) */
diff --git a/skeletons/oer_encoder.h b/skeletons/oer_encoder.h
index 6d33f1c..03ddfce 100644
--- a/skeletons/oer_encoder.h
+++ b/skeletons/oer_encoder.h
@@ -26,7 +26,7 @@
 /* A variant of oer_encode() which encodes data into the pre-allocated buffer */
 asn_enc_rval_t oer_encode_to_buffer(
     struct asn_TYPE_descriptor_s *type_descriptor,
-    asn_oer_constraints_t *constraints,
+    const asn_oer_constraints_t *constraints,
     void *struct_ptr,  /* Structure to be encoded */
     void *buffer,      /* Pre-allocated buffer */
     size_t buffer_size /* Initial buffer size (maximum) */
@@ -37,7 +37,7 @@
  */
 typedef asn_enc_rval_t(oer_type_encoder_f)(
     struct asn_TYPE_descriptor_s *type_descriptor,
-    asn_oer_constraints_t *constraints,
+    const asn_oer_constraints_t *constraints,
     void *struct_ptr,                          /* Structure to be encoded */
     asn_app_consume_bytes_f *consume_bytes_cb, /* Callback */
     void *app_key                              /* Arbitrary callback argument */
diff --git a/skeletons/oer_support.c b/skeletons/oer_support.c
index f228f09..78142c2 100644
--- a/skeletons/oer_support.c
+++ b/skeletons/oer_support.c
@@ -47,7 +47,7 @@
         /* Skip the leading 0-bytes */
     }
 
-    if((bend - b) > sizeof(size_t)) {
+    if((bend - b) > (ssize_t)sizeof(size_t)) {
         /* Length is not representable by the native size_t type */
         *len_r = 0;
         return -1;
diff --git a/skeletons/oer_support.h b/skeletons/oer_support.h
index a529254..92ee694 100644
--- a/skeletons/oer_support.h
+++ b/skeletons/oer_support.h
@@ -15,11 +15,11 @@
 /*
  * Pre-computed OER constraints.
  */
-typedef const struct asn_oer_constraint_number_s {
+typedef struct asn_oer_constraint_number_s {
     unsigned width;    /* ±8,4,2,1 fixed bytes */
     unsigned positive; /* 1 for unsigned number, 0 for signed */
 } asn_oer_constraint_number_t;
-typedef const struct asn_oer_constraints_s {
+typedef struct asn_oer_constraints_s {
     asn_oer_constraint_number_t value;
     ssize_t size;    /* -1 (no constraint) or >= 0 */
 } asn_oer_constraints_t;
diff --git a/skeletons/per_decoder.h b/skeletons/per_decoder.h
index 8397a54..803341a 100644
--- a/skeletons/per_decoder.h
+++ b/skeletons/per_decoder.h
@@ -44,7 +44,7 @@
  */
 typedef asn_dec_rval_t (per_type_decoder_f)(asn_codec_ctx_t *opt_codec_ctx,
 		struct asn_TYPE_descriptor_s *type_descriptor,
-		asn_per_constraints_t *constraints,
+		const asn_per_constraints_t *constraints,
 		void **struct_ptr,
 		asn_per_data_t *per_data
 	);
diff --git a/skeletons/per_encoder.c b/skeletons/per_encoder.c
index 47f3c91..2ccfdf0 100644
--- a/skeletons/per_encoder.c
+++ b/skeletons/per_encoder.c
@@ -2,7 +2,7 @@
 #include <asn_internal.h>
 #include <per_encoder.h>
 
-static asn_enc_rval_t uper_encode_internal(asn_TYPE_descriptor_t *td, asn_per_constraints_t *, void *sptr, asn_app_consume_bytes_f *cb, void *app_key);
+static asn_enc_rval_t uper_encode_internal(asn_TYPE_descriptor_t *td, const asn_per_constraints_t *, void *sptr, asn_app_consume_bytes_f *cb, void *app_key);
 
 asn_enc_rval_t
 uper_encode(asn_TYPE_descriptor_t *td, void *sptr, asn_app_consume_bytes_f *cb, void *app_key) {
@@ -65,8 +65,10 @@
 	return 0;
 }
 ssize_t
-uper_encode_to_new_buffer(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, void **buffer_r) {
-	asn_enc_rval_t er;
+uper_encode_to_new_buffer(asn_TYPE_descriptor_t *td,
+                          const asn_per_constraints_t *constraints, void *sptr,
+                          void **buffer_r) {
+    asn_enc_rval_t er;
 	enc_dyn_arg key;
 
 	memset(&key, 0, sizeof(key));
@@ -116,8 +118,10 @@
 }
 
 static asn_enc_rval_t
-uper_encode_internal(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_app_consume_bytes_f *cb, void *app_key) {
-	asn_per_outp_t po;
+uper_encode_internal(asn_TYPE_descriptor_t *td,
+                     const asn_per_constraints_t *constraints, void *sptr,
+                     asn_app_consume_bytes_f *cb, void *app_key) {
+    asn_per_outp_t po;
 	asn_enc_rval_t er;
 
 	/*
diff --git a/skeletons/per_encoder.h b/skeletons/per_encoder.h
index 95a6506..fd090ac 100644
--- a/skeletons/per_encoder.h
+++ b/skeletons/per_encoder.h
@@ -47,7 +47,7 @@
  */
 ssize_t uper_encode_to_new_buffer(
 	struct asn_TYPE_descriptor_s *type_descriptor,
-	asn_per_constraints_t *constraints,
+	const asn_per_constraints_t *constraints,
 	void *struct_ptr,	/* Structure to be encoded */
 	void **buffer_r		/* Buffer allocated and returned */
 );
@@ -57,7 +57,7 @@
  */
 typedef asn_enc_rval_t (per_type_encoder_f)(
 	struct asn_TYPE_descriptor_s *type_descriptor,
-	asn_per_constraints_t *constraints,
+	const asn_per_constraints_t *constraints,
 	void *struct_ptr,
 	asn_per_outp_t *per_output
 );
diff --git a/skeletons/per_opentype.c b/skeletons/per_opentype.c
index 404aa72..589bb4a 100644
--- a/skeletons/per_opentype.c
+++ b/skeletons/per_opentype.c
@@ -16,7 +16,10 @@
 
 static int uper_ugot_refill(asn_per_data_t *pd);
 static int per_skip_bits(asn_per_data_t *pd, int skip_nbits);
-static asn_dec_rval_t uper_sot_suck(asn_codec_ctx_t *, asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd);
+static asn_dec_rval_t uper_sot_suck(asn_codec_ctx_t *,
+                                    asn_TYPE_descriptor_t *td,
+                                    const asn_per_constraints_t *constraints,
+                                    void **sptr, asn_per_data_t *pd);
 
 /*
  * Encode an "open type field".
@@ -55,7 +58,7 @@
 
 static asn_dec_rval_t
 uper_open_type_get_simple(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+	const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
 	asn_dec_rval_t rv;
 	ssize_t chunk_bytes;
 	int repeat;
@@ -243,9 +246,9 @@
 
 asn_dec_rval_t
 uper_open_type_get(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
-
-	return uper_open_type_get_simple(ctx, td, constraints, sptr, pd);
+                   const asn_per_constraints_t *constraints, void **sptr,
+                   asn_per_data_t *pd) {
+    return uper_open_type_get_simple(ctx, td, constraints, sptr, pd);
 }
 
 int
@@ -269,7 +272,7 @@
 
 static asn_dec_rval_t
 uper_sot_suck(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
-	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+	const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
 	asn_dec_rval_t rv;
 
 	(void)ctx;
diff --git a/skeletons/per_opentype.h b/skeletons/per_opentype.h
index facfaa6..d34f758 100644
--- a/skeletons/per_opentype.h
+++ b/skeletons/per_opentype.h
@@ -9,7 +9,7 @@
 extern "C" {
 #endif
 
-asn_dec_rval_t uper_open_type_get(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd);
+asn_dec_rval_t uper_open_type_get(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd);
 
 int uper_open_type_skip(asn_codec_ctx_t *opt_codec_ctx, asn_per_data_t *pd);
 
diff --git a/skeletons/per_support.h b/skeletons/per_support.h
index 0e4e189..4dcc9e6 100644
--- a/skeletons/per_support.h
+++ b/skeletons/per_support.h
@@ -15,7 +15,7 @@
 /*
  * Pre-computed PER constraints.
  */
-typedef const struct asn_per_constraint_s {
+typedef struct asn_per_constraint_s {
 	enum asn_per_constraint_flags {
 		APC_UNCONSTRAINED	= 0x0,	/* No PER visible constraints */
 		APC_SEMI_CONSTRAINED	= 0x1,	/* Constrained at "lb" */
@@ -27,9 +27,9 @@
 	long lower_bound;		/* "lb" value */
 	long upper_bound;		/* "ub" value */
 } asn_per_constraint_t;
-typedef const struct asn_per_constraints_s {
-	struct asn_per_constraint_s value;
-	struct asn_per_constraint_s size;
+typedef struct asn_per_constraints_s {
+	asn_per_constraint_t value;
+	asn_per_constraint_t size;
 	int (*value2code)(unsigned int value);
 	int (*code2value)(unsigned int code);
 } asn_per_constraints_t;
diff --git a/skeletons/tests/check-GeneralizedTime.c b/skeletons/tests/check-GeneralizedTime.c
index 63d2e66..4b1fd18 100644
--- a/skeletons/tests/check-GeneralizedTime.c
+++ b/skeletons/tests/check-GeneralizedTime.c
@@ -54,7 +54,7 @@
 		assert(expect);
 		printf("[%s] vs [%s] (%d)\n",
 			gt->buf, expect, force_gmt);
-		assert(gt->size == (int)strlen((char *)gt->buf));
+		assert(gt->size == strlen((char *)gt->buf));
 		assert(!strcmp((char *)gt->buf, expect));
 	} else {
 		assert(!expect);
diff --git a/skeletons/tests/check-INTEGER.c b/skeletons/tests/check-INTEGER.c
index 4ec9fd5..8c4496c 100644
--- a/skeletons/tests/check-INTEGER.c
+++ b/skeletons/tests/check-INTEGER.c
@@ -14,7 +14,7 @@
 }
 
 static void
-check(uint8_t *buf, int size, long check_long, int check_ret) {
+check(uint8_t *buf, size_t size, long check_long, int check_ret) {
 	char scratch[128];
 	char verify[32];
 	INTEGER_t val;
diff --git a/skeletons/tests/check-OCTET_STRING.c b/skeletons/tests/check-OCTET_STRING.c
index 3aad01a..30564c1 100644
--- a/skeletons/tests/check-OCTET_STRING.c
+++ b/skeletons/tests/check-OCTET_STRING.c
@@ -10,8 +10,8 @@
 
 static void
 check(enum encoding_type type, char *tagname, char *xmlbuf, char *verify) {
-	int xmllen = strlen(xmlbuf);
-	int verlen = verify ? strlen(verify) : 0;
+	size_t xmllen = strlen(xmlbuf);
+	size_t verlen = verify ? strlen(verify) : 0;
 	asn_TYPE_descriptor_t *td = &asn_DEF_OCTET_STRING;
 	OCTET_STRING_t *st = 0;
 	OCTET_STRING_t **stp = &st;
@@ -32,7 +32,7 @@
 	}
 
 	rc = decoder(0, td, (void **)stp, tagname, xmlbuf, xmllen);
-	printf("[%s] => [%s]:%d vs [%s]:%d, code %d\n",
+	printf("[%s] => [%s]:%zu vs [%s]:%zu, code %d\n",
 		xmlbuf,
 		st ? (const char *)st->buf : "", st ? st->size : 0,
 		verify ? verify : "", verlen, rc.code);
diff --git a/skeletons/tests/check-OER-INTEGER.c b/skeletons/tests/check-OER-INTEGER.c
index 314b6b3..f30ea38 100644
--- a/skeletons/tests/check-OER-INTEGER.c
+++ b/skeletons/tests/check-OER-INTEGER.c
@@ -10,11 +10,10 @@
 #define CHECK_ENCODE_BAD(a, b, c) check_encode(__LINE__, 1, a, b, c);
 
 static asn_oer_constraints_t *
-setup_constraints(int lineno, const char *process, unsigned width,
-                  unsigned positive) {
+setup_constraints(unsigned width, unsigned positive) {
     static struct asn_oer_constraints_s empty_constraints;
-    struct asn_oer_constraints_s *constraints = &empty_constraints;
-    struct asn_oer_constraint_number_s *ct_value = &constraints->value;
+    asn_oer_constraints_t *constraints = &empty_constraints;
+    asn_oer_constraint_number_t *ct_value = &constraints->value;
 
     memset(&empty_constraints, 0, sizeof(empty_constraints));
 
@@ -33,8 +32,7 @@
 
     INTEGER_t *st = NULL;
     asn_dec_rval_t ret;
-    asn_oer_constraints_t *constraints =
-        setup_constraints(lineno, "decoding", width, positive);
+    asn_oer_constraints_t *constraints = setup_constraints(width, positive);
 
     fprintf(stderr, "%d: buf[%zu]={%d, %d, ...}\n", lineno, size,
             ((const uint8_t *)buf)[0],
@@ -105,7 +103,7 @@
     asn_enc_rval_t er;
     asn_dec_rval_t ret;
     asn_oer_constraints_t *constraints =
-        setup_constraints(lineno, "encoding", lower_bound, upper_bound);
+        setup_constraints(lower_bound, upper_bound);
 
     if(asn_imax2INTEGER(stOut, value) == -1) {
         assert(!"Unreachable imax2INTEGER failure");
@@ -164,8 +162,7 @@
 
     INTEGER_t *stOut = (INTEGER_t *)calloc(1, sizeof(*stOut));
     asn_enc_rval_t er;
-    asn_oer_constraints_t *constraints =
-        setup_constraints(lineno, "encoding", width, positive);
+    asn_oer_constraints_t *constraints = setup_constraints(width, positive);
 
     if(asn_imax2INTEGER(stOut, value) == -1) {
         assert(!"Unreachable imax2INTEGER failure");
diff --git a/skeletons/tests/check-OIDs.c b/skeletons/tests/check-OIDs.c
index 05b4993..fbb0948 100644
--- a/skeletons/tests/check-OIDs.c
+++ b/skeletons/tests/check-OIDs.c
@@ -30,7 +30,7 @@
 	rval = ber_decode(0, &asn_DEF_OBJECT_IDENTIFIER, (void *)&oid, buf, len);
 	assert(rval.code == RC_OK);
 
-	assert(oid->size == (ssize_t)len - 2);
+	assert((ssize_t)oid->size == (ssize_t)len - 2);
 
 	/*
 	 * Print the contents for visual debugging.
@@ -77,7 +77,7 @@
 	rval = ber_decode(0, &asn_DEF_RELATIVE_OID, (void *)&oid, buf, len);
 	assert(rval.code == RC_OK);
 
-	assert(oid->size == (ssize_t)len - 2);
+	assert((ssize_t)oid->size == (ssize_t)len - 2);
 
 	/*
 	 * Print the contents for visual debugging.
diff --git a/skeletons/tests/check-REAL.c b/skeletons/tests/check-REAL.c
index f50bb82..4251c8a 100644
--- a/skeletons/tests/check-REAL.c
+++ b/skeletons/tests/check-REAL.c
@@ -90,7 +90,7 @@
 	printf("converted into [");
 	for(p = rn->buf, end = p + rn->size; p < end; p++)
 		printf("%02x", *p);
-	printf("]: %d\n", rn->size);
+	printf("]: %zu\n", rn->size);
 
 	ret = asn_REAL2double(rn, &val);
 	assert(ret == 0);