diff --git a/library/psa_crypto.c b/library/psa_crypto.c
index 3722987..c716b7b 100755
--- a/library/psa_crypto.c
+++ b/library/psa_crypto.c
@@ -1203,39 +1203,39 @@
 /* Asymmetric cryptography */
 /****************************************************************/
 
-static psa_status_t verify_RSA_hash_input_and_get_md_type(psa_algorithm_t alg, size_t hash_length, mbedtls_md_type_t *md_alg)
+static psa_status_t verify_RSA_hash_input_and_get_md_type( psa_algorithm_t alg,
+                                                           size_t hash_length,
+                                                           mbedtls_md_type_t *md_alg )
 {
-    psa_algorithm_t hash_alg = PSA_ALG_RSA_GET_HASH(alg);
-    const mbedtls_md_info_t *md_info = mbedtls_md_info_from_psa(hash_alg);
-    *md_alg = hash_alg == 0 ? MBEDTLS_MD_NONE : mbedtls_md_get_type(md_info);
-    if (*md_alg == MBEDTLS_MD_NONE)
+    psa_algorithm_t hash_alg = PSA_ALG_RSA_GET_HASH( alg );
+    const mbedtls_md_info_t *md_info = mbedtls_md_info_from_psa( hash_alg );
+    *md_alg = hash_alg == 0 ? MBEDTLS_MD_NONE : mbedtls_md_get_type( md_info );
+    if( *md_alg == MBEDTLS_MD_NONE )
     {
 #if SIZE_MAX > UINT_MAX
-        if (hash_length > UINT_MAX)
-            return(PSA_ERROR_INVALID_ARGUMENT);
+        if( hash_length > UINT_MAX )
+            return( PSA_ERROR_INVALID_ARGUMENT );
 #endif
     }
     else
     {
-        if (mbedtls_md_get_size(md_info) != hash_length)
-            return(PSA_ERROR_INVALID_ARGUMENT);
-        if (md_info == NULL)
-            return(PSA_ERROR_NOT_SUPPORTED);
+        if( mbedtls_md_get_size( md_info ) != hash_length )
+            return( PSA_ERROR_INVALID_ARGUMENT );
+        if( md_info == NULL )
+            return( PSA_ERROR_NOT_SUPPORTED );
     }
-    return PSA_SUCCESS;
+    return( PSA_SUCCESS );
 }
 
-
-
-psa_status_t psa_asymmetric_sign(psa_key_slot_t key,
-                                 psa_algorithm_t alg,
-                                 const uint8_t *hash,
-                                 size_t hash_length,
-                                 const uint8_t *salt,
-                                 size_t salt_length,
-                                 uint8_t *signature,
-                                 size_t signature_size,
-                                 size_t *signature_length)
+psa_status_t psa_asymmetric_sign( psa_key_slot_t key,
+                                  psa_algorithm_t alg,
+                                  const uint8_t *hash,
+                                  size_t hash_length,
+                                  const uint8_t *salt,
+                                  size_t salt_length,
+                                  uint8_t *signature,
+                                  size_t signature_size,
+                                  size_t *signature_length )
 {
     key_slot_t *slot;
     psa_status_t status;
@@ -1243,7 +1243,6 @@
     (void) salt;
     (void) salt_length;
 
-
     if( key == 0 || key > MBEDTLS_PSA_KEY_SLOT_COUNT )
         return( PSA_ERROR_EMPTY_SLOT );
     slot = &global_data.key_slots[key];
@@ -1251,7 +1250,7 @@
         return( PSA_ERROR_EMPTY_SLOT );
     if( ! PSA_KEY_TYPE_IS_KEYPAIR( slot->type ) )
         return( PSA_ERROR_INVALID_ARGUMENT );
-    if( !( slot->policy.usage & PSA_KEY_USAGE_SIGN ) )
+    if( ! ( slot->policy.usage & PSA_KEY_USAGE_SIGN ) )
         return( PSA_ERROR_NOT_PERMITTED );
 
 #if defined(MBEDTLS_RSA_C)
@@ -1261,9 +1260,9 @@
         int ret;
         mbedtls_md_type_t md_alg;
         status = verify_RSA_hash_input_and_get_md_type( alg, hash_length,
-                                                       &md_alg );
-        if ( status != PSA_SUCCESS )
-            return status;
+                                                        &md_alg );
+        if( status != PSA_SUCCESS )
+            return( status );
 
         if( signature_size < rsa->len )
             return( PSA_ERROR_BUFFER_TOO_SMALL );
@@ -1315,8 +1314,9 @@
         md_info = mbedtls_md_info_from_psa( alg );
         md_alg = mbedtls_md_get_type( md_info );
         ret = mbedtls_ecdsa_write_signature( ecdsa, md_alg, hash, hash_length,
-            signature, signature_length, mbedtls_ctr_drbg_random,
-            &global_data.ctr_drbg );
+                                             signature, signature_length,
+                                             mbedtls_ctr_drbg_random,
+                                             &global_data.ctr_drbg );
         return( mbedtls_to_psa_error( ret ) );
     }
     else
@@ -1326,14 +1326,14 @@
     }
 }
 
-psa_status_t psa_asymmetric_verify(psa_key_slot_t key,
-                                   psa_algorithm_t alg,
-                                   const uint8_t *hash,
-                                   size_t hash_length,
-                                   const uint8_t *salt,
-                                   size_t salt_length,
-                                   uint8_t *signature,
-                                   size_t signature_size)
+psa_status_t psa_asymmetric_verify( psa_key_slot_t key,
+                                    psa_algorithm_t alg,
+                                    const uint8_t *hash,
+                                    size_t hash_length,
+                                    const uint8_t *salt,
+                                    size_t salt_length,
+                                    uint8_t *signature,
+                                    size_t signature_size )
 {
     key_slot_t *slot;
     psa_status_t status;
@@ -1345,20 +1345,20 @@
     slot = &global_data.key_slots[key];
     if( slot->type == PSA_KEY_TYPE_NONE )
         return( PSA_ERROR_EMPTY_SLOT );
-    if (!(slot->policy.usage & PSA_KEY_USAGE_VERIFY))
-        return(PSA_ERROR_NOT_PERMITTED);
+    if( ! ( slot->policy.usage & PSA_KEY_USAGE_VERIFY ) )
+        return( PSA_ERROR_NOT_PERMITTED );
 
- #if defined(MBEDTLS_RSA_C)
+#if defined(MBEDTLS_RSA_C)
     if( ( slot->type == PSA_KEY_TYPE_RSA_KEYPAIR ) ||
         ( slot->type == PSA_KEY_TYPE_RSA_PUBLIC_KEY ) )
     {
         mbedtls_rsa_context *rsa = slot->data.rsa;
         int ret;
         mbedtls_md_type_t md_alg;
-        status = verify_RSA_hash_input_and_get_md_type(alg, hash_length,
-            &md_alg);
-        if (status != PSA_SUCCESS)
-            return status;
+        status = verify_RSA_hash_input_and_get_md_type( alg, hash_length,
+                                                       &md_alg );
+        if( status != PSA_SUCCESS )
+            return( status );
 
         if( signature_size < rsa->len )
             return( PSA_ERROR_BUFFER_TOO_SMALL );
@@ -1369,13 +1369,13 @@
                                      MBEDTLS_MD_NONE );
 
             ret = mbedtls_rsa_pkcs1_verify( rsa,
-                      mbedtls_ctr_drbg_random,
-                      &global_data.ctr_drbg,
-                      MBEDTLS_RSA_PUBLIC,
-                      md_alg,
-                      hash_length,
-                      hash,
-                      signature );
+                                            mbedtls_ctr_drbg_random,
+                                            &global_data.ctr_drbg,
+                                            MBEDTLS_RSA_PUBLIC,
+                                            md_alg,
+                                            hash_length,
+                                            hash,
+                                            signature );
 
         }
         else
@@ -1400,9 +1400,9 @@
         mbedtls_ecp_keypair *ecdsa = slot->data.ecp;
         int ret;
         (void)alg;
-        ret = mbedtls_ecdsa_read_signature(ecdsa, hash, hash_length, signature,
-            signature_size);
-        return(mbedtls_to_psa_error(ret));
+        ret = mbedtls_ecdsa_read_signature( ecdsa, hash, hash_length,
+                                            signature, signature_size );
+        return( mbedtls_to_psa_error( ret ) );
     }
     else
 #endif /* defined(MBEDTLS_ECP_C) */
@@ -1411,16 +1411,15 @@
     }
 }
 
-
-psa_status_t psa_asymmetric_encrypt(psa_key_slot_t key,
-                                    psa_algorithm_t alg,
-                                    const uint8_t *input,
-                                    size_t input_length,
-                                    const uint8_t *salt,
-                                    size_t salt_length,
-                                    uint8_t *output,
-                                    size_t output_size,
-                                    size_t *output_length)
+psa_status_t psa_asymmetric_encrypt( psa_key_slot_t key,
+                                     psa_algorithm_t alg,
+                                     const uint8_t *input,
+                                     size_t input_length,
+                                     const uint8_t *salt,
+                                     size_t salt_length,
+                                     uint8_t *output,
+                                     size_t output_size,
+                                     size_t *output_length )
 {
     key_slot_t *slot;
     (void) salt;
@@ -1434,28 +1433,27 @@
         return( PSA_ERROR_EMPTY_SLOT );
     if( ! PSA_KEY_TYPE_IS_KEYPAIR( slot->type ) )
         return( PSA_ERROR_INVALID_ARGUMENT );
-    if (!(slot->policy.usage & PSA_KEY_USAGE_ENCRYPT))
-        return(PSA_ERROR_NOT_PERMITTED);
-
+    if( ! ( slot->policy.usage & PSA_KEY_USAGE_ENCRYPT ) )
+        return( PSA_ERROR_NOT_PERMITTED );
 
 #if defined(MBEDTLS_RSA_C)
     if( ( slot->type == PSA_KEY_TYPE_RSA_KEYPAIR ) ||
-        ( slot->type == PSA_KEY_TYPE_RSA_PUBLIC_KEY) )
+        ( slot->type == PSA_KEY_TYPE_RSA_PUBLIC_KEY ) )
     {
         mbedtls_rsa_context *rsa = slot->data.rsa;
         int ret;
         if( output_size < rsa->len )
-                return( PSA_ERROR_INVALID_ARGUMENT );
+            return( PSA_ERROR_INVALID_ARGUMENT );
 #if defined(MBEDTLS_PKCS1_V15)
         if( alg == PSA_ALG_RSA_PKCS1V15_CRYPT )
         {
-        ret = mbedtls_rsa_pkcs1_encrypt(  rsa,
-                                        mbedtls_ctr_drbg_random,
-                                        &global_data.ctr_drbg,
-                                        MBEDTLS_RSA_PUBLIC,
-                                        input_length,
-                                        input,
-                                        output );
+            ret = mbedtls_rsa_pkcs1_encrypt( rsa,
+                                             mbedtls_ctr_drbg_random,
+                                             &global_data.ctr_drbg,
+                                             MBEDTLS_RSA_PUBLIC,
+                                             input_length,
+                                             input,
+                                             output );
         }
         else
 #endif /* MBEDTLS_PKCS1_V15 */
@@ -1488,16 +1486,15 @@
 
 }
 
-
-psa_status_t psa_asymmetric_decrypt(psa_key_slot_t key,
-                                    psa_algorithm_t alg,
-                                    const uint8_t *input,
-                                    size_t input_length,
-                                    const uint8_t *salt,
-                                    size_t salt_length,
-                                    uint8_t *output,
-                                    size_t output_size,
-                                    size_t *output_length)
+psa_status_t psa_asymmetric_decrypt( psa_key_slot_t key,
+                                     psa_algorithm_t alg,
+                                     const uint8_t *input,
+                                     size_t input_length,
+                                     const uint8_t *salt,
+                                     size_t salt_length,
+                                     uint8_t *output,
+                                     size_t output_size,
+                                     size_t *output_length )
 {
     key_slot_t *slot;
     (void) salt;
@@ -1511,8 +1508,8 @@
         return( PSA_ERROR_EMPTY_SLOT );
     if( ! PSA_KEY_TYPE_IS_KEYPAIR( slot->type ) )
         return( PSA_ERROR_INVALID_ARGUMENT );
-    if (!(slot->policy.usage & PSA_KEY_USAGE_DECRYPT))
-        return(PSA_ERROR_NOT_PERMITTED);
+    if( ! ( slot->policy.usage & PSA_KEY_USAGE_DECRYPT ) )
+        return( PSA_ERROR_NOT_PERMITTED );
 
 #if defined(MBEDTLS_RSA_C)
     if( slot->type == PSA_KEY_TYPE_RSA_KEYPAIR )
@@ -1526,14 +1523,14 @@
 #if defined(MBEDTLS_PKCS1_V15)
         if( alg == PSA_ALG_RSA_PKCS1V15_CRYPT )
         {
-            ret = mbedtls_rsa_pkcs1_decrypt(  rsa,
-                                            mbedtls_ctr_drbg_random,
-                                            &global_data.ctr_drbg,
-                                            MBEDTLS_RSA_PRIVATE,
-                                            output_length,
-                                            input,
-                                            output,
-                                            output_size );
+            ret = mbedtls_rsa_pkcs1_decrypt( rsa,
+                                             mbedtls_ctr_drbg_random,
+                                             &global_data.ctr_drbg,
+                                             MBEDTLS_RSA_PRIVATE,
+                                             output_length,
+                                             input,
+                                             output,
+                                             output_size );
         }
         else
 #endif /* MBEDTLS_PKCS1_V15 */