diff --git a/skeletons/INTEGER.c b/skeletons/INTEGER.c
index 5d992d9..eed8217 100644
--- a/skeletons/INTEGER.c
+++ b/skeletons/INTEGER.c
@@ -544,12 +544,12 @@
 	(void)flags;
 	
 	if(!st || !st->buf)
-		_ASN_ENCODE_FAILED;
+		ASN__ENCODE_FAILED;
 
 	er.encoded = INTEGER__dump(td, st, cb, app_key, 1);
-	if(er.encoded < 0) _ASN_ENCODE_FAILED;
+	if(er.encoded < 0) ASN__ENCODE_FAILED;
 
-	_ASN_ENCODED_OK(er);
+	ASN__ENCODED_OK(er);
 }
 
 #ifndef	ASN_DISABLE_PER_SUPPORT
@@ -567,7 +567,7 @@
 
 	if(!st) {
 		st = (INTEGER_t *)(*sptr = CALLOC(1, sizeof(*st)));
-		if(!st) _ASN_DECODE_FAILED;
+		if(!st) ASN__DECODE_FAILED;
 	}
 
 	if(!constraints) constraints = td->per_constraints;
@@ -575,7 +575,7 @@
 
 	if(ct && ct->flags & APC_EXTENSIBLE) {
 		int inext = per_get_few_bits(pd, 1);
-		if(inext < 0) _ASN_DECODE_STARVED;
+		if(inext < 0) ASN__DECODE_STARVED;
 		if(inext) ct = 0;
 	}
 
@@ -585,12 +585,12 @@
 	if(ct) {
 		if(ct->flags & APC_SEMI_CONSTRAINED) {
 			st->buf = (uint8_t *)CALLOC(1, 2);
-			if(!st->buf) _ASN_DECODE_FAILED;
+			if(!st->buf) ASN__DECODE_FAILED;
 			st->size = 1;
 		} else if(ct->flags & APC_CONSTRAINED && ct->range_bits >= 0) {
 			size_t size = (ct->range_bits + 7) >> 3;
 			st->buf = (uint8_t *)MALLOC(1 + size + 1);
-			if(!st->buf) _ASN_DECODE_FAILED;
+			if(!st->buf) ASN__DECODE_FAILED;
 			st->size = size;
 		}
 	}
@@ -601,28 +601,28 @@
 		ASN_DEBUG("Integer with range %d bits", ct->range_bits);
 		if(ct->range_bits >= 0) {
 			if((size_t)ct->range_bits > 8 * sizeof(unsigned long))
-				_ASN_DECODE_FAILED;
+				ASN__DECODE_FAILED;
 
 			if(specs && specs->field_unsigned) {
 				unsigned long uvalue;
 				if(uper_get_constrained_whole_number(pd,
 					&uvalue, ct->range_bits))
-					_ASN_DECODE_STARVED;
+					ASN__DECODE_STARVED;
 				ASN_DEBUG("Got value %lu + low %ld",
 					uvalue, ct->lower_bound);
 				uvalue += ct->lower_bound;
 				if(asn_ulong2INTEGER(st, uvalue))
-					_ASN_DECODE_FAILED;
+					ASN__DECODE_FAILED;
 			} else {
 				unsigned long svalue;
 				if(uper_get_constrained_whole_number(pd,
 					&svalue, ct->range_bits))
-					_ASN_DECODE_STARVED;
+					ASN__DECODE_STARVED;
 				ASN_DEBUG("Got value %ld + low %ld",
 					svalue, ct->lower_bound);
 				svalue += ct->lower_bound;
 				if(asn_long2INTEGER(st, svalue))
-					_ASN_DECODE_FAILED;
+					ASN__DECODE_FAILED;
 			}
 			return rval;
 		}
@@ -638,14 +638,14 @@
 
 		/* Get the PER length */
 		len = uper_get_length(pd, -1, &repeat);
-		if(len < 0) _ASN_DECODE_STARVED;
+		if(len < 0) ASN__DECODE_STARVED;
 
 		p = REALLOC(st->buf, st->size + len + 1);
-		if(!p) _ASN_DECODE_FAILED;
+		if(!p) ASN__DECODE_FAILED;
 		st->buf = (uint8_t *)p;
 
 		ret = per_get_many_bits(pd, &st->buf[st->size], 0, 8 * len);
-		if(ret < 0) _ASN_DECODE_STARVED;
+		if(ret < 0) ASN__DECODE_STARVED;
 		st->size += len;
 	} while(repeat);
 	st->buf[st->size] = 0;	/* JIC */
@@ -657,9 +657,9 @@
 		 */
 		long value;
 		if(asn_INTEGER2long(st, &value))
-			_ASN_DECODE_FAILED;
+			ASN__DECODE_FAILED;
 		if(asn_long2INTEGER(st, value + ct->lower_bound))
-			_ASN_DECODE_FAILED;
+			ASN__DECODE_FAILED;
 	}
 
 	return rval;
@@ -677,7 +677,7 @@
 	long value = 0;
 	unsigned long v = 0;
 
-	if(!st || st->size == 0) _ASN_ENCODE_FAILED;
+	if(!st || st->size == 0) ASN__ENCODE_FAILED;
 
 	if(!constraints) constraints = td->per_constraints;
 	ct = constraints ? &constraints->value : 0;
@@ -689,7 +689,7 @@
 		if(specs && specs->field_unsigned) {
 			unsigned long uval;
 			if(asn_INTEGER2ulong(st, &uval))
-				_ASN_ENCODE_FAILED;
+				ASN__ENCODE_FAILED;
 			/* Check proper range */
 			if(ct->flags & APC_SEMI_CONSTRAINED) {
 				if(uval < (unsigned long)ct->lower_bound)
@@ -706,7 +706,7 @@
 			value = uval;
 		} else {
 			if(asn_INTEGER2long(st, &value))
-				_ASN_ENCODE_FAILED;
+				ASN__ENCODE_FAILED;
 			/* Check proper range */
 			if(ct->flags & APC_SEMI_CONSTRAINED) {
 				if(value < ct->lower_bound)
@@ -723,10 +723,10 @@
 		}
 		if(ct->flags & APC_EXTENSIBLE) {
 			if(per_put_few_bits(po, inext, 1))
-				_ASN_ENCODE_FAILED;
+				ASN__ENCODE_FAILED;
 			if(inext) ct = 0;
 		} else if(inext) {
-			_ASN_ENCODE_FAILED;
+			ASN__ENCODE_FAILED;
 		}
 	}
 
@@ -738,26 +738,26 @@
 			value, value - ct->lower_bound, ct->range_bits);
 		v = value - ct->lower_bound;
 		if(uper_put_constrained_whole_number_u(po, v, ct->range_bits))
-			_ASN_ENCODE_FAILED;
-		_ASN_ENCODED_OK(er);
+			ASN__ENCODE_FAILED;
+		ASN__ENCODED_OK(er);
 	}
 
 	if(ct && ct->lower_bound) {
 		ASN_DEBUG("Adjust lower bound to %ld", ct->lower_bound);
 		/* TODO: adjust lower bound */
-		_ASN_ENCODE_FAILED;
+		ASN__ENCODE_FAILED;
 	}
 
 	for(buf = st->buf, end = st->buf + st->size; buf < end;) {
 		ssize_t mayEncode = uper_put_length(po, end - buf);
 		if(mayEncode < 0)
-			_ASN_ENCODE_FAILED;
+			ASN__ENCODE_FAILED;
 		if(per_put_many_bits(po, buf, 8 * mayEncode))
-			_ASN_ENCODE_FAILED;
+			ASN__ENCODE_FAILED;
 		buf += mayEncode;
 	}
 
-	_ASN_ENCODED_OK(er);
+	ASN__ENCODED_OK(er);
 }
 
 #endif	/* ASN_DISABLE_PER_SUPPORT */