diff --git a/library/asn1parse.c b/library/asn1parse.c
index 83c7c58..67c162a 100644
--- a/library/asn1parse.c
+++ b/library/asn1parse.c
@@ -47,7 +47,7 @@
                   size_t *len )
 {
     if( ( end - *p ) < 1 )
-        return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+        return MBEDTLS_ERR_ASN1_OUT_OF_DATA ;
 
     if( ( **p & 0x80 ) == 0 )
         *len = *(*p)++;
@@ -57,7 +57,7 @@
         {
         case 1:
             if( ( end - *p ) < 2 )
-                return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+                return MBEDTLS_ERR_ASN1_OUT_OF_DATA ;
 
             *len = (*p)[1];
             (*p) += 2;
@@ -65,7 +65,7 @@
 
         case 2:
             if( ( end - *p ) < 3 )
-                return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+                return MBEDTLS_ERR_ASN1_OUT_OF_DATA ;
 
             *len = ( (size_t)(*p)[1] << 8 ) | (*p)[2];
             (*p) += 3;
@@ -73,7 +73,7 @@
 
         case 3:
             if( ( end - *p ) < 4 )
-                return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+                return MBEDTLS_ERR_ASN1_OUT_OF_DATA ;
 
             *len = ( (size_t)(*p)[1] << 16 ) |
                    ( (size_t)(*p)[2] << 8  ) | (*p)[3];
@@ -82,7 +82,7 @@
 
         case 4:
             if( ( end - *p ) < 5 )
-                return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+                return MBEDTLS_ERR_ASN1_OUT_OF_DATA ;
 
             *len = ( (size_t)(*p)[1] << 24 ) | ( (size_t)(*p)[2] << 16 ) |
                    ( (size_t)(*p)[3] << 8  ) |           (*p)[4];
@@ -90,14 +90,14 @@
             break;
 
         default:
-            return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
+            return MBEDTLS_ERR_ASN1_INVALID_LENGTH ;
         }
     }
 
     if( *len > (size_t) ( end - *p ) )
-        return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+        return MBEDTLS_ERR_ASN1_OUT_OF_DATA ;
 
-    return( 0 );
+    return 0 ;
 }
 
 int mbedtls_asn1_get_tag( unsigned char **p,
@@ -105,14 +105,14 @@
                   size_t *len, int tag )
 {
     if( ( end - *p ) < 1 )
-        return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+        return MBEDTLS_ERR_ASN1_OUT_OF_DATA ;
 
     if( **p != tag )
-        return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
+        return MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ;
 
     (*p)++;
 
-    return( mbedtls_asn1_get_len( p, end, len ) );
+    return mbedtls_asn1_get_len( p, end, len ) ;
 }
 
 int mbedtls_asn1_get_bool( unsigned char **p,
@@ -123,15 +123,15 @@
     size_t len;
 
     if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_BOOLEAN ) ) != 0 )
-        return( ret );
+        return ret ;
 
     if( len != 1 )
-        return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
+        return MBEDTLS_ERR_ASN1_INVALID_LENGTH ;
 
     *val = ( **p != 0 ) ? 1 : 0;
     (*p)++;
 
-    return( 0 );
+    return 0 ;
 }
 
 static int asn1_get_tagged_int( unsigned char **p,
@@ -142,17 +142,17 @@
     size_t len;
 
     if( ( ret = mbedtls_asn1_get_tag( p, end, &len, tag ) ) != 0 )
-        return( ret );
+        return ret ;
 
     /*
      * len==0 is malformed (0 must be represented as 020100 for INTEGER,
      * or 0A0100 for ENUMERATED tags
      */
     if( len == 0 )
-        return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
+        return MBEDTLS_ERR_ASN1_INVALID_LENGTH ;
     /* This is a cryptography library. Reject negative integers. */
     if( ( **p & 0x80 ) != 0 )
-        return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
+        return MBEDTLS_ERR_ASN1_INVALID_LENGTH ;
 
     /* Skip leading zeros. */
     while( len > 0 && **p == 0 )
@@ -164,9 +164,9 @@
     /* Reject integers that don't fit in an int. This code assumes that
      * the int type has no padding bit. */
     if( len > sizeof( int ) )
-        return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
+        return MBEDTLS_ERR_ASN1_INVALID_LENGTH ;
     if( len == sizeof( int ) && ( **p & 0x80 ) != 0 )
-        return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
+        return MBEDTLS_ERR_ASN1_INVALID_LENGTH ;
 
     *val = 0;
     while( len-- > 0 )
@@ -175,21 +175,21 @@
         (*p)++;
     }
 
-    return( 0 );
+    return 0 ;
 }
 
 int mbedtls_asn1_get_int( unsigned char **p,
                           const unsigned char *end,
                           int *val )
 {
-    return( asn1_get_tagged_int( p, end, MBEDTLS_ASN1_INTEGER, val) );
+    return asn1_get_tagged_int( p, end, MBEDTLS_ASN1_INTEGER, val) ;
 }
 
 int mbedtls_asn1_get_enum( unsigned char **p,
                            const unsigned char *end,
                            int *val )
 {
-    return( asn1_get_tagged_int( p, end, MBEDTLS_ASN1_ENUMERATED, val) );
+    return asn1_get_tagged_int( p, end, MBEDTLS_ASN1_ENUMERATED, val) ;
 }
 
 #if defined(MBEDTLS_BIGNUM_C)
@@ -201,13 +201,13 @@
     size_t len;
 
     if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
-        return( ret );
+        return ret ;
 
     ret = mbedtls_mpi_read_binary( X, *p, len );
 
     *p += len;
 
-    return( ret );
+    return ret ;
 }
 #endif /* MBEDTLS_BIGNUM_C */
 
@@ -218,17 +218,17 @@
 
     /* Certificate type is a single byte bitstring */
     if( ( ret = mbedtls_asn1_get_tag( p, end, &bs->len, MBEDTLS_ASN1_BIT_STRING ) ) != 0 )
-        return( ret );
+        return ret ;
 
     /* Check length, subtract one for actual bit string length */
     if( bs->len < 1 )
-        return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+        return MBEDTLS_ERR_ASN1_OUT_OF_DATA ;
     bs->len -= 1;
 
     /* Get number of unused bits, ensure unused bits <= 7 */
     bs->unused_bits = **p;
     if( bs->unused_bits > 7 )
-        return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
+        return MBEDTLS_ERR_ASN1_INVALID_LENGTH ;
     (*p)++;
 
     /* Get actual bitstring */
@@ -236,9 +236,9 @@
     *p += bs->len;
 
     if( *p != end )
-        return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
+        return MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ;
 
-    return( 0 );
+    return 0 ;
 }
 
 /*
@@ -261,21 +261,21 @@
     if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
             MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
     {
-        return( ret );
+        return ret ;
     }
 
     if( *p + len != end )
-        return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
+        return MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ;
 
     while( *p < end )
     {
         unsigned char const tag = *(*p)++;
 
         if( ( tag & tag_must_mask ) != tag_must_val )
-            return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
+            return MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ;
 
         if( ( ret = mbedtls_asn1_get_len( p, end, &len ) ) != 0 )
-            return( ret );
+            return ret ;
 
         if( ( tag & tag_may_mask ) == tag_may_val )
         {
@@ -283,14 +283,14 @@
             {
                 ret = cb( ctx, tag, *p, len );
                 if( ret != 0 )
-                    return( ret );
+                    return ret ;
             }
         }
 
         *p += len;
     }
 
-    return( 0 );
+    return 0 ;
 }
 
 /*
@@ -302,17 +302,17 @@
     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
 
     if( ( ret = mbedtls_asn1_get_tag( p, end, len, MBEDTLS_ASN1_BIT_STRING ) ) != 0 )
-        return( ret );
+        return ret ;
 
     if( *len == 0 )
-        return( MBEDTLS_ERR_ASN1_INVALID_DATA );
+        return MBEDTLS_ERR_ASN1_INVALID_DATA ;
     --( *len );
 
     if( **p != 0 )
-        return( MBEDTLS_ERR_ASN1_INVALID_DATA );
+        return MBEDTLS_ERR_ASN1_INVALID_DATA ;
     ++( *p );
 
-    return( 0 );
+    return 0 ;
 }
 
 void mbedtls_asn1_sequence_free( mbedtls_asn1_sequence *seq )
@@ -348,7 +348,7 @@
             mbedtls_calloc( 1, sizeof( mbedtls_asn1_sequence ) );
 
         if( cur->next == NULL )
-            return( MBEDTLS_ERR_ASN1_ALLOC_FAILED );
+            return MBEDTLS_ERR_ASN1_ALLOC_FAILED ;
 
         cur = cur->next;
     }
@@ -358,7 +358,7 @@
     cur->buf.tag = tag;
 
     cb_ctx->cur = cur;
-    return( 0 );
+    return 0 ;
 }
 
 /*
@@ -385,16 +385,16 @@
 
     if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
             MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
-        return( ret );
+        return ret ;
 
     if( ( end - *p ) < 1 )
-        return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+        return MBEDTLS_ERR_ASN1_OUT_OF_DATA ;
 
     alg->tag = **p;
     end = *p + len;
 
     if( ( ret = mbedtls_asn1_get_tag( p, end, &alg->len, MBEDTLS_ASN1_OID ) ) != 0 )
-        return( ret );
+        return ret ;
 
     alg->p = *p;
     *p += alg->len;
@@ -402,22 +402,22 @@
     if( *p == end )
     {
         mbedtls_platform_zeroize( params, sizeof(mbedtls_asn1_buf) );
-        return( 0 );
+        return 0 ;
     }
 
     params->tag = **p;
     (*p)++;
 
     if( ( ret = mbedtls_asn1_get_len( p, end, &params->len ) ) != 0 )
-        return( ret );
+        return ret ;
 
     params->p = *p;
     *p += params->len;
 
     if( *p != end )
-        return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
+        return MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ;
 
-    return( 0 );
+    return 0 ;
 }
 
 int mbedtls_asn1_get_alg_null( unsigned char **p,
@@ -430,12 +430,12 @@
     memset( &params, 0, sizeof(mbedtls_asn1_buf) );
 
     if( ( ret = mbedtls_asn1_get_alg( p, end, alg, &params ) ) != 0 )
-        return( ret );
+        return ret ;
 
     if( ( params.tag != MBEDTLS_ASN1_NULL && params.tag != 0 ) || params.len != 0 )
-        return( MBEDTLS_ERR_ASN1_INVALID_DATA );
+        return MBEDTLS_ERR_ASN1_INVALID_DATA ;
 
-    return( 0 );
+    return 0 ;
 }
 
 void mbedtls_asn1_free_named_data( mbedtls_asn1_named_data *cur )
@@ -475,7 +475,7 @@
         list = list->next;
     }
 
-    return( list );
+    return list ;
 }
 
 #endif /* MBEDTLS_ASN1_PARSE_C */