run scripts/Lindent.

23 files changed, 3490 insertions, 3271 deletions

diff --git a/cryptodev_cipher.c b/cryptodev_cipher.c
index 1fb1147..591e4eb 100644
--- a/cryptodev_cipher.c
+++ b/cryptodev_cipher.c
@@ -33,7 +33,6 @@
 #include <crypto/hash.h>
 #include "cryptodev_int.h"
 
-
 struct cryptodev_result {
 	struct completion completion;
 	int err;
@@ -50,18 +49,19 @@ static void cryptodev_complete(struct crypto_async_request *req, int err)
 	complete(&res->completion);
 }
 
-int cryptodev_cipher_init(struct cipher_data* out, const char* alg_name, uint8_t * keyp, size_t keylen)
+int cryptodev_cipher_init(struct cipher_data *out, const char *alg_name,
+			  uint8_t * keyp, size_t keylen)
 {
-	
-	struct ablkcipher_alg* alg;
+
+	struct ablkcipher_alg *alg;
 	int ret;
 
 	memset(out, 0, sizeof(*out));
 
 	out->async.s = crypto_alloc_ablkcipher(alg_name, 0, 0);
 	if (unlikely(IS_ERR(out->async.s))) {
-		dprintk(1,KERN_DEBUG,"%s: Failed to load cipher %s\n", __func__,
-			   alg_name);
+		dprintk(1, KERN_DEBUG, "%s: Failed to load cipher %s\n",
+			__func__, alg_name);
 		return -EINVAL;
 	}
 
@@ -69,11 +69,13 @@ int cryptodev_cipher_init(struct cipher_data* out, const char* alg_name, uint8_t
 
 	if (alg != NULL) {
 		/* Was correct key length supplied? */
-		if (alg->max_keysize > 0 && unlikely((keylen < alg->min_keysize) ||
-			(keylen > alg->max_keysize))) {
-			dprintk(1,KERN_DEBUG,"Wrong keylen '%zu' for algorithm '%s'. Use %u to %u.\n",
-				   keylen, alg_name, alg->min_keysize, 
-				   alg->max_keysize);
+		if (alg->max_keysize > 0
+		    && unlikely((keylen < alg->min_keysize)
+				|| (keylen > alg->max_keysize))) {
+			dprintk(1, KERN_DEBUG,
+				"Wrong keylen '%zu' for algorithm '%s'. Use %u to %u.\n",
+				keylen, alg_name, alg->min_keysize,
+				alg->max_keysize);
 			ret = -EINVAL;
 			goto error;
 		}
@@ -81,8 +83,8 @@ int cryptodev_cipher_init(struct cipher_data* out, const char* alg_name, uint8_t
 
 	ret = crypto_ablkcipher_setkey(out->async.s, keyp, keylen);
 	if (unlikely(ret)) {
-		dprintk(1,KERN_DEBUG,"Setting key failed for %s-%zu.\n",
-			alg_name, keylen*8);
+		dprintk(1, KERN_DEBUG, "Setting key failed for %s-%zu.\n",
+			alg_name, keylen * 8);
 		ret = -EINVAL;
 		goto error;
 	}
@@ -101,12 +103,13 @@ int cryptodev_cipher_init(struct cipher_data* out, const char* alg_name, uint8_t
 
 	out->async.request = ablkcipher_request_alloc(out->async.s, GFP_KERNEL);
 	if (unlikely(!out->async.request)) {
-		dprintk(1,KERN_ERR,"error allocating async crypto request\n");
+		dprintk(1, KERN_ERR, "error allocating async crypto request\n");
 		ret = -ENOMEM;
 		goto error;
 	}
 
-	ablkcipher_request_set_callback(out->async.request, CRYPTO_TFM_REQ_MAY_BACKLOG,
+	ablkcipher_request_set_callback(out->async.request,
+					CRYPTO_TFM_REQ_MAY_BACKLOG,
 					cryptodev_complete, out->async.result);
 
 	out->init = 1;
@@ -121,7 +124,7 @@ error:
 	return ret;
 }
 
-void cryptodev_cipher_deinit(struct cipher_data* cdata)
+void cryptodev_cipher_deinit(struct cipher_data *cdata)
 {
 	if (cdata->init) {
 		if (cdata->async.request)
@@ -134,12 +137,13 @@ void cryptodev_cipher_deinit(struct cipher_data* cdata)
 	}
 }
 
-void cryptodev_cipher_set_iv(struct cipher_data* cdata, void *iv, size_t iv_size)
+void cryptodev_cipher_set_iv(struct cipher_data *cdata, void *iv,
+			     size_t iv_size)
 {
-	memcpy(cdata->async.iv, iv, min(iv_size,sizeof(cdata->async.iv)));
+	memcpy(cdata->async.iv, iv, min(iv_size, sizeof(cdata->async.iv)));
 }
 
-static inline int waitfor (struct cryptodev_result* cr, ssize_t ret)
+static inline int waitfor(struct cryptodev_result *cr, ssize_t ret)
 {
 	switch (ret) {
 	case 0:
@@ -154,8 +158,9 @@ static inline int waitfor (struct cryptodev_result* cr, ssize_t ret)
 		 * another request. */
 
 		if (unlikely(cr->err)) {
-			dprintk(0,KERN_ERR,"error from async request: %d \n", cr->err);
-                        return cr->err; 
+			dprintk(0, KERN_ERR, "error from async request: %d \n",
+				cr->err);
+			return cr->err;
 		}
 
 		break;
@@ -166,49 +171,55 @@ static inline int waitfor (struct cryptodev_result* cr, ssize_t ret)
 	return 0;
 }
 
-
-int _cryptodev_cipher_encrypt(struct cipher_data* cdata, const void* plaintext,
-	size_t plaintext_size, void* ciphertext, size_t ciphertext_size)
+int _cryptodev_cipher_encrypt(struct cipher_data *cdata, const void *plaintext,
+			      size_t plaintext_size, void *ciphertext,
+			      size_t ciphertext_size)
 {
-struct scatterlist sg, sg2;
+	struct scatterlist sg, sg2;
 
 	sg_init_one(&sg, plaintext, plaintext_size);
 	sg_init_one(&sg2, ciphertext, ciphertext_size);
 
-	return cryptodev_cipher_encrypt( cdata, &sg, &sg2, plaintext_size);
+	return cryptodev_cipher_encrypt(cdata, &sg, &sg2, plaintext_size);
 }
 
-int _cryptodev_cipher_decrypt(struct cipher_data* cdata, const void* ciphertext,
-	size_t ciphertext_size, void* plaintext, size_t plaintext_size)
+int _cryptodev_cipher_decrypt(struct cipher_data *cdata, const void *ciphertext,
+			      size_t ciphertext_size, void *plaintext,
+			      size_t plaintext_size)
 {
-struct scatterlist sg, sg2;
+	struct scatterlist sg, sg2;
 
 	sg_init_one(&sg, ciphertext, ciphertext_size);
 	sg_init_one(&sg2, plaintext, plaintext_size);
 
-	return cryptodev_cipher_decrypt( cdata, &sg, &sg2, ciphertext_size);
+	return cryptodev_cipher_decrypt(cdata, &sg, &sg2, ciphertext_size);
 }
 
-
-ssize_t cryptodev_cipher_encrypt( struct cipher_data* cdata, const struct scatterlist *sg1, struct scatterlist *sg2, size_t len)
+ssize_t cryptodev_cipher_encrypt(struct cipher_data * cdata,
+				 const struct scatterlist * sg1,
+				 struct scatterlist * sg2, size_t len)
 {
 	int ret;
 
 	INIT_COMPLETION(cdata->async.result->completion);
-	ablkcipher_request_set_crypt(cdata->async.request, (struct scatterlist*)sg1, sg2,
-			len, cdata->async.iv);
+	ablkcipher_request_set_crypt(cdata->async.request,
+				     (struct scatterlist *)sg1, sg2, len,
+				     cdata->async.iv);
 	ret = crypto_ablkcipher_encrypt(cdata->async.request);
 
-	return waitfor(cdata->async.result,ret);
+	return waitfor(cdata->async.result, ret);
 }
 
-ssize_t cryptodev_cipher_decrypt( struct cipher_data* cdata, const struct scatterlist *sg1, struct scatterlist *sg2, size_t len)
+ssize_t cryptodev_cipher_decrypt(struct cipher_data * cdata,
+				 const struct scatterlist * sg1,
+				 struct scatterlist * sg2, size_t len)
 {
 	int ret;
 
 	INIT_COMPLETION(cdata->async.result->completion);
-	ablkcipher_request_set_crypt(cdata->async.request, (struct scatterlist*)sg1, sg2,
-			len, cdata->async.iv);
+	ablkcipher_request_set_crypt(cdata->async.request,
+				     (struct scatterlist *)sg1, sg2, len,
+				     cdata->async.iv);
 	ret = crypto_ablkcipher_decrypt(cdata->async.request);
 
 	return waitfor(cdata->async.result, ret);
@@ -216,14 +227,15 @@ ssize_t cryptodev_cipher_decrypt( struct cipher_data* cdata, const struct scatte
 
 /* Hash functions */
 
-int cryptodev_hash_init(struct hash_data *hdata, const char *alg_name, const void *mackey, size_t mackeylen)
+int cryptodev_hash_init(struct hash_data *hdata, const char *alg_name,
+			const void *mackey, size_t mackeylen)
 {
-int ret;
+	int ret;
 
 	hdata->async.s = crypto_alloc_ahash(alg_name, 0, 0);
 	if (unlikely(IS_ERR(hdata->async.s))) {
-		dprintk(1,KERN_DEBUG,"%s: Failed to load transform for %s\n", __func__,
-				   alg_name);
+		dprintk(1, KERN_DEBUG, "%s: Failed to load transform for %s\n",
+			__func__, alg_name);
 		return -EINVAL;
 	}
 
@@ -232,8 +244,9 @@ int ret;
 
 		ret = crypto_ahash_setkey(hdata->async.s, mackey, mackeylen);
 		if (unlikely(ret)) {
-			dprintk(1,KERN_DEBUG,"Setting hmac key failed for %s-%zu.\n",
-				alg_name, mackeylen*8);
+			dprintk(1, KERN_DEBUG,
+				"Setting hmac key failed for %s-%zu.\n",
+				alg_name, mackeylen * 8);
 			ret = -EINVAL;
 			goto error;
 		}
@@ -252,18 +265,18 @@ int ret;
 
 	hdata->async.request = ahash_request_alloc(hdata->async.s, GFP_KERNEL);
 	if (unlikely(!hdata->async.request)) {
-		dprintk(0,KERN_ERR,"error allocating async crypto request\n");
+		dprintk(0, KERN_ERR, "error allocating async crypto request\n");
 		ret = -ENOMEM;
 		goto error;
 	}
 
-	ahash_request_set_callback(hdata->async.request, CRYPTO_TFM_REQ_MAY_BACKLOG,
-					cryptodev_complete, hdata->async.result);
+	ahash_request_set_callback(hdata->async.request,
+				   CRYPTO_TFM_REQ_MAY_BACKLOG,
+				   cryptodev_complete, hdata->async.result);
 
 	ret = crypto_ahash_init(hdata->async.request);
 	if (unlikely(ret)) {
-		dprintk(0,KERN_ERR,
-			"error in crypto_hash_init()\n");
+		dprintk(0, KERN_ERR, "error in crypto_hash_init()\n");
 		goto error_request;
 	}
 
@@ -304,8 +317,7 @@ int cryptodev_hash_clone(struct hash_data *hdata, struct hash_data *old_data,
 	}
 	ret = crypto_ahash_import(hdata->async.request, state);
 	if (unlikely(ret != 0)) {
-		dprintk(0,KERN_ERR,
-			"error in crypto_hash_init()\n");
+		dprintk(0, KERN_ERR, "error in crypto_hash_init()\n");
 		goto err;
 	}
 
@@ -320,7 +332,7 @@ err:
 	return ret;
 }
 
-void cryptodev_hash_deinit(struct hash_data* hdata)
+void cryptodev_hash_deinit(struct hash_data *hdata)
 {
 	if (hdata->init) {
 		if (hdata->async.request)
@@ -332,13 +344,12 @@ void cryptodev_hash_deinit(struct hash_data* hdata)
 	}
 }
 
-int cryptodev_hash_reset( struct hash_data* hdata)
+int cryptodev_hash_reset(struct hash_data *hdata)
 {
-int ret;
+	int ret;
 	ret = crypto_ahash_init(hdata->async.request);
 	if (unlikely(ret)) {
-		dprintk(0,KERN_ERR,
-			"error in crypto_hash_init()\n");
+		dprintk(0, KERN_ERR, "error in crypto_hash_init()\n");
 		return ret;
 	}
 
@@ -346,29 +357,30 @@ int ret;
 
 }
 
-ssize_t cryptodev_hash_update( struct hash_data* hdata, struct scatterlist *sg, size_t len)
+ssize_t cryptodev_hash_update(struct hash_data * hdata, struct scatterlist * sg,
+			      size_t len)
 {
 	int ret;
 
 	INIT_COMPLETION(hdata->async.result->completion);
-	ahash_request_set_crypt(hdata->async.request, sg, NULL,
-			len);
+	ahash_request_set_crypt(hdata->async.request, sg, NULL, len);
 
 	ret = crypto_ahash_update(hdata->async.request);
 
-	return waitfor(hdata->async.result,ret);
+	return waitfor(hdata->async.result, ret);
 }
 
-ssize_t _cryptodev_hash_update( struct hash_data* hdata, const void* data, size_t len)
+ssize_t _cryptodev_hash_update(struct hash_data * hdata, const void *data,
+			       size_t len)
 {
-struct scatterlist sg;
+	struct scatterlist sg;
 
 	sg_init_one(&sg, data, len);
 
-	return cryptodev_hash_update( hdata, &sg, len);
+	return cryptodev_hash_update(hdata, &sg, len);
 }
 
-int cryptodev_hash_final( struct hash_data* hdata, void* output)
+int cryptodev_hash_final(struct hash_data *hdata, void *output)
 {
 	int ret;
 
@@ -377,5 +389,5 @@ int cryptodev_hash_final( struct hash_data* hdata, void* output)
 
 	ret = crypto_ahash_final(hdata->async.request);
 
-	return waitfor(hdata->async.result,ret);
+	return waitfor(hdata->async.result, ret);
 }
diff --git a/cryptodev_int.h b/cryptodev_int.h
index 4b140ba..5f067bd 100644
--- a/cryptodev_int.h
+++ b/cryptodev_int.h
@@ -25,8 +25,8 @@
 extern int cryptodev_verbosity;
 
 /* For zero copy */
-int __get_userbuf(uint8_t __user *addr, uint32_t len, int write,
-		int pgcount, struct page **pg, struct scatterlist *sg);
+int __get_userbuf(uint8_t __user * addr, uint32_t len, int write,
+		  int pgcount, struct page **pg, struct scatterlist *sg);
 void release_user_pages(struct page **pg, int pagecount);
 
 /* last page - first page + 1 */
@@ -36,34 +36,40 @@ void release_user_pages(struct page **pg, int pagecount);
 
 #define DEFAULT_PREALLOC_PAGES 32
 
-struct cipher_data
-{
-	int init; /* 0 uninitialized */
+struct cipher_data {
+	int init;		/* 0 uninitialized */
 	int blocksize;
 	int ivsize;
 	struct {
-		struct crypto_ablkcipher* s;
+		struct crypto_ablkcipher *s;
 		struct cryptodev_result *result;
 		struct ablkcipher_request *request;
 		uint8_t iv[NCR_CIPHER_MAX_BLOCK_LEN];
 	} async;
 };
 
-int cryptodev_cipher_init(struct cipher_data* out, const char* alg_name, uint8_t * key, size_t keylen);
-void cryptodev_cipher_deinit(struct cipher_data* cdata);
-ssize_t cryptodev_cipher_decrypt( struct cipher_data* cdata, const struct scatterlist *sg1, struct scatterlist *sg2, size_t len);
-ssize_t cryptodev_cipher_encrypt( struct cipher_data* cdata, const struct scatterlist *sg1, struct scatterlist *sg2, size_t len);
+int cryptodev_cipher_init(struct cipher_data *out, const char *alg_name,
+			  uint8_t * key, size_t keylen);
+void cryptodev_cipher_deinit(struct cipher_data *cdata);
+ssize_t cryptodev_cipher_decrypt(struct cipher_data *cdata,
+				 const struct scatterlist *sg1,
+				 struct scatterlist *sg2, size_t len);
+ssize_t cryptodev_cipher_encrypt(struct cipher_data *cdata,
+				 const struct scatterlist *sg1,
+				 struct scatterlist *sg2, size_t len);
 
-void cryptodev_cipher_set_iv(struct cipher_data* cdata, void* iv, size_t iv_size);
-int _cryptodev_cipher_decrypt(struct cipher_data* cdata, const void* ciphertext,
-	size_t ciphertext_size, void* plaintext, size_t plaintext_size);
-int _cryptodev_cipher_encrypt(struct cipher_data* cdata, const void* plaintext,
-	size_t plaintext_size, void* ciphertext, size_t ciphertext_size);
+void cryptodev_cipher_set_iv(struct cipher_data *cdata, void *iv,
+			     size_t iv_size);
+int _cryptodev_cipher_decrypt(struct cipher_data *cdata, const void *ciphertext,
+			      size_t ciphertext_size, void *plaintext,
+			      size_t plaintext_size);
+int _cryptodev_cipher_encrypt(struct cipher_data *cdata, const void *plaintext,
+			      size_t plaintext_size, void *ciphertext,
+			      size_t ciphertext_size);
 
 /* hash stuff */
-struct hash_data
-{
-	int init; /* 0 uninitialized */
+struct hash_data {
+	int init;		/* 0 uninitialized */
 	int digestsize;
 	struct {
 		struct crypto_ahash *s;
@@ -72,12 +78,15 @@ struct hash_data
 	} async;
 };
 
-int cryptodev_hash_final( struct hash_data* hdata, void* output);
-ssize_t cryptodev_hash_update( struct hash_data* hdata, struct scatterlist *sg, size_t len);
-ssize_t _cryptodev_hash_update( struct hash_data* hdata, const void* data, size_t len);
-int cryptodev_hash_reset( struct hash_data* hdata);
-void cryptodev_hash_deinit(struct hash_data* hdata);
-int cryptodev_hash_init(struct hash_data *hdata, const char *alg_name, const void *mackey, size_t mackeylen);
+int cryptodev_hash_final(struct hash_data *hdata, void *output);
+ssize_t cryptodev_hash_update(struct hash_data *hdata, struct scatterlist *sg,
+			      size_t len);
+ssize_t _cryptodev_hash_update(struct hash_data *hdata, const void *data,
+			       size_t len);
+int cryptodev_hash_reset(struct hash_data *hdata);
+void cryptodev_hash_deinit(struct hash_data *hdata);
+int cryptodev_hash_init(struct hash_data *hdata, const char *alg_name,
+			const void *mackey, size_t mackeylen);
 int cryptodev_hash_clone(struct hash_data *hdata, struct hash_data *old_data,
 			 const void *mackey, size_t mackeylen);
 
diff --git a/cryptodev_main.c b/cryptodev_main.c
index 2a11fdb..ebdb523 100644
--- a/cryptodev_main.c
+++ b/cryptodev_main.c
@@ -70,27 +70,28 @@ void release_user_pages(struct page **pg, int pagecount)
 #define PAGEOFFSET(buf) ((unsigned long)buf & ~PAGE_MASK)
 
 /* fetch the pages addr resides in into pg and initialise sg with them */
-int __get_userbuf(uint8_t __user *addr, uint32_t len, int write,
-		int pgcount, struct page **pg, struct scatterlist *sg)
+int __get_userbuf(uint8_t __user * addr, uint32_t len, int write,
+		  int pgcount, struct page **pg, struct scatterlist *sg)
 {
 	int ret, pglen, i = 0;
 	struct scatterlist *sgp;
 
 	down_write(&current->mm->mmap_sem);
 	ret = get_user_pages(current, current->mm,
-			(unsigned long)addr, pgcount, write, 0, pg, NULL);
+			     (unsigned long)addr, pgcount, write, 0, pg, NULL);
 	up_write(&current->mm->mmap_sem);
 	if (ret != pgcount)
 		return -EINVAL;
 
 	sg_init_table(sg, pgcount);
 
-	pglen = min((ptrdiff_t)(PAGE_SIZE - PAGEOFFSET(addr)), (ptrdiff_t)len);
+	pglen =
+	    min((ptrdiff_t) (PAGE_SIZE - PAGEOFFSET(addr)), (ptrdiff_t) len);
 	sg_set_page(sg, pg[i++], pglen, PAGEOFFSET(addr));
 
 	len -= pglen;
 	for (sgp = sg_next(sg); len; sgp = sg_next(sgp)) {
-		pglen = min((uint32_t)PAGE_SIZE, len);
+		pglen = min((uint32_t) PAGE_SIZE, len);
 		sg_set_page(sgp, pg[i++], pglen, 0);
 		len -= pglen;
 	}
@@ -100,8 +101,7 @@ int __get_userbuf(uint8_t __user *addr, uint32_t len, int write,
 
 /* ====== /dev/crypto ====== */
 
-static int
-cryptodev_open(struct inode *inode, struct file *filp)
+static int cryptodev_open(struct inode *inode, struct file *filp)
 {
 	void *ncr;
 
@@ -114,8 +114,7 @@ cryptodev_open(struct inode *inode, struct file *filp)
 	return 0;
 }
 
-static int
-cryptodev_release(struct inode *inode, struct file *filp)
+static int cryptodev_release(struct inode *inode, struct file *filp)
 {
 	void *ncr = filp->private_data;
 
@@ -170,15 +169,14 @@ static struct miscdevice cryptodev = {
 	.fops = &cryptodev_fops,
 };
 
-static int __init
-cryptodev_register(void)
+static int __init cryptodev_register(void)
 {
 	int rc;
 
 	ncr_limits_init();
 	ncr_master_key_reset();
-	
-	rc = misc_register (&cryptodev);
+
+	rc = misc_register(&cryptodev);
 	if (unlikely(rc)) {
 		ncr_limits_deinit();
 		printk(KERN_ERR PFX "registration of /dev/crypto failed\n");
@@ -188,8 +186,7 @@ cryptodev_register(void)
 	return 0;
 }
 
-static void __exit
-cryptodev_deregister(void)
+static void __exit cryptodev_deregister(void)
 {
 	misc_deregister(&cryptodev);
 	ncr_limits_deinit();
diff --git a/examples/ncr.c b/examples/ncr.c
index 468ffc0..13ee298 100644
--- a/examples/ncr.c
+++ b/examples/ncr.c
@@ -27,20 +27,19 @@
 
 static void randomize_data(uint8_t * data, size_t data_size)
 {
-int i;
-	
-	srand(time(0)*getpid());
-	for (i=0;i<data_size;i++) {
+	int i;
+
+	srand(time(0) * getpid());
+	for (i = 0; i < data_size; i++) {
 		data[i] = rand() & 0xff;
 	}
 }
 
 #define KEY_DATA_SIZE 16
 #define WRAPPED_KEY_DATA_SIZE 32
-static int
-test_ncr_key(int cfd)
+static int test_ncr_key(int cfd)
 {
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_generate f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(ALG_AES_CBC)] ALIGN_NL;
@@ -49,7 +48,7 @@ test_ncr_key(int cfd)
 		struct nlattr bits_head ALIGN_NL;
 		uint32_t bits ALIGN_NL;
 	} kgen;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_get_info f;
 		/* This union is only here to stop gcc from complaining about
 		   aliasing. */
@@ -60,7 +59,7 @@ test_ncr_key(int cfd)
 	} kinfo;
 	struct nlattr *nla;
 	ncr_key_t key;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_import f;
 		struct nlattr id_head ALIGN_NL;
 		uint8_t id[2] ALIGN_NL;
@@ -134,7 +133,7 @@ test_ncr_key(int cfd)
 		return 1;
 	}
 
-	if (memcmp(data, data_bak, sizeof(data))!=0) {
+	if (memcmp(data, data_bak, sizeof(data)) != 0) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
 		fprintf(stderr, "data returned but differ!\n");
 		return 1;
@@ -171,7 +170,7 @@ test_ncr_key(int cfd)
 	kgen.flags = NCR_KEY_FLAG_EXPORTABLE;
 	kgen.bits_head.nla_len = NLA_HDRLEN + sizeof(kgen.bits);
 	kgen.bits_head.nla_type = NCR_ATTR_SECRET_KEY_BITS;
-	kgen.bits = 128; /* 16 bytes */
+	kgen.bits = 128;	/* 16 bytes */
 
 	if (ioctl(cfd, NCRIO_KEY_GENERATE, &kgen)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -194,11 +193,12 @@ test_ncr_key(int cfd)
 
 	if (data[0] == 0 && data[1] == 0 && data[2] == 0 && data[4] == 0) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
-		fprintf(stderr, "Generated key: %.2x.%.2x.%.2x.%.2x.%.2x.%.2x.%.2x.%.2x."
-			"%.2x.%.2x.%.2x.%.2x.%.2x.%.2x.%.2x.%.2x\n", data[0], data[1],
-			data[2], data[3], data[4], data[5], data[6], data[7], data[8],
-			data[9], data[10], data[11], data[12], data[13], data[14],
-			data[15]);
+		fprintf(stderr,
+			"Generated key: %.2x.%.2x.%.2x.%.2x.%.2x.%.2x.%.2x.%.2x."
+			"%.2x.%.2x.%.2x.%.2x.%.2x.%.2x.%.2x.%.2x\n", data[0],
+			data[1], data[2], data[3], data[4], data[5], data[6],
+			data[7], data[8], data[9], data[10], data[11], data[12],
+			data[13], data[14], data[15]);
 		return 1;
 	}
 
@@ -207,7 +207,7 @@ test_ncr_key(int cfd)
 	kinfo.f.key = key;
 	nla = &kinfo.u.first_header;
 	nla->nla_type = NCR_ATTR_WANTED_ATTRS;
-	attr_p = (uint16_t *)((char *)nla + NLA_HDRLEN);
+	attr_p = (uint16_t *) ((char *)nla + NLA_HDRLEN);
 	*attr_p++ = NCR_ATTR_ALGORITHM;
 	*attr_p++ = NCR_ATTR_KEY_FLAGS;
 	*attr_p++ = NCR_ATTR_KEY_TYPE;
@@ -258,7 +258,7 @@ test_ncr_key(int cfd)
 				fprintf(stderr, "Attribute too small\n");
 				return 1;
 			}
-			if (*(uint32_t *)data != NCR_KEY_FLAG_EXPORTABLE) {
+			if (*(uint32_t *) data != NCR_KEY_FLAG_EXPORTABLE) {
 				fprintf(stderr, "Unexpected key flags\n");
 				return 1;
 			}
@@ -269,7 +269,7 @@ test_ncr_key(int cfd)
 				fprintf(stderr, "Attribute too small\n");
 				return 1;
 			}
-			if (*(uint32_t *)data != NCR_KEY_TYPE_SECRET) {
+			if (*(uint32_t *) data != NCR_KEY_TYPE_SECRET) {
 				fprintf(stderr, "Unexpected key type\n");
 				return 1;
 			}
@@ -293,7 +293,7 @@ test_ncr_key(int cfd)
 		perror("ioctl(NCRIO_KEY_DEINIT)");
 		return 1;
 	}
-	
+
 	/* test 3: generate an unexportable key in kernel space and
 	 * try to export it.
 	 */
@@ -316,7 +316,7 @@ test_ncr_key(int cfd)
 	kgen.flags = 0;
 	kgen.bits_head.nla_len = NLA_HDRLEN + sizeof(kgen.flags);
 	kgen.bits_head.nla_type = NCR_ATTR_SECRET_KEY_BITS;
-	kgen.bits = 128; /* 16 bytes */
+	kgen.bits = 128;	/* 16 bytes */
 
 	if (ioctl(cfd, NCRIO_KEY_GENERATE, &kgen)) {
 		perror("ioctl(NCRIO_KEY_GENERATE)");
@@ -347,15 +347,12 @@ test_ncr_key(int cfd)
 	return 0;
 }
 
-
-
 /* Key wrapping */
-static int
-test_ncr_wrap_key(int cfd)
+static int test_ncr_wrap_key(int cfd)
 {
 	int i, ret;
 	ncr_key_t key, key2;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_import f;
 		struct nlattr id_head ALIGN_NL;
 		uint8_t id[2] ALIGN_NL;
@@ -366,12 +363,13 @@ test_ncr_wrap_key(int cfd)
 		struct nlattr flags_head ALIGN_NL;
 		uint32_t flags ALIGN_NL;
 	} kimport;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_wrap f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(NCR_WALG_AES_RFC3394)] ALIGN_NL;
-	} kwrap;
-	struct __attribute__((packed)) {
+	}
+	kwrap;
+	struct __attribute__ ((packed)) {
 		struct ncr_key_unwrap f;
 		struct nlattr wrap_algo_head ALIGN_NL;
 		char wrap_algo[sizeof(NCR_WALG_AES_RFC3394)] ALIGN_NL;
@@ -399,7 +397,8 @@ test_ncr_wrap_key(int cfd)
 	memset(&kimport.f, 0, sizeof(kimport.f));
 	kimport.f.input_size = sizeof(kimport);
 	kimport.f.key = key;
-	kimport.f.data = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";
+	kimport.f.data =
+	    "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";
 	kimport.f.data_size = 16;
 	kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
 	kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
@@ -413,7 +412,9 @@ test_ncr_wrap_key(int cfd)
 	strcpy(kimport.algo, ALG_AES_CBC);
 	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
 	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags = NCR_KEY_FLAG_EXPORTABLE|NCR_KEY_FLAG_WRAPPING|NCR_KEY_FLAG_UNWRAPPING;
+	kimport.flags =
+	    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPING |
+	    NCR_KEY_FLAG_UNWRAPPING;
 
 	ret = ioctl(cfd, NCRIO_KEY_IMPORT, &kimport);
 	if (geteuid() == 0 && ret) {
@@ -424,7 +425,8 @@ test_ncr_wrap_key(int cfd)
 
 	if (geteuid() != 0) {
 		/* cannot test further */
-		fprintf(stdout, "\t(Wrapping test not completed. Run as root)\n");
+		fprintf(stdout,
+			"\t(Wrapping test not completed. Run as root)\n");
 		return 0;
 	}
 
@@ -453,7 +455,7 @@ test_ncr_wrap_key(int cfd)
 	strcpy(kimport.algo, ALG_AES_CBC);
 	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
 	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags = NCR_KEY_FLAG_EXPORTABLE|NCR_KEY_FLAG_WRAPPABLE;
+	kimport.flags = NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE;
 
 	if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -480,11 +482,12 @@ test_ncr_wrap_key(int cfd)
 	}
 
 	if (data_size != 24 || memcmp(data,
-		"\x1F\xA6\x8B\x0A\x81\x12\xB4\x47\xAE\xF3\x4B\xD8\xFB\x5A\x7B\x82\x9D\x3E\x86\x23\x71\xD2\xCF\xE5", 24) != 0) {
+				      "\x1F\xA6\x8B\x0A\x81\x12\xB4\x47\xAE\xF3\x4B\xD8\xFB\x5A\x7B\x82\x9D\x3E\x86\x23\x71\xD2\xCF\xE5",
+				      24) != 0) {
 		fprintf(stderr, "Wrapped data do not match.\n");
 
-		fprintf(stderr, "Data[%d]: ",(int) data_size);
-		for(i=0;i<data_size;i++)
+		fprintf(stderr, "Data[%d]: ", (int)data_size);
+		for (i = 0; i < data_size; i++)
 			fprintf(stderr, "%.2x:", data[i]);
 		fprintf(stderr, "\n");
 		return 1;
@@ -516,7 +519,7 @@ test_ncr_wrap_key(int cfd)
 	strcpy(kunwrap.wrap_algo, NCR_WALG_AES_RFC3394);
 	kunwrap.flags_head.nla_len = NLA_HDRLEN + sizeof(kunwrap.flags);
 	kunwrap.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kunwrap.flags = NCR_KEY_FLAG_EXPORTABLE|NCR_KEY_FLAG_WRAPPABLE;
+	kunwrap.flags = NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE;
 
 	if (ioctl(cfd, NCRIO_KEY_UNWRAP, &kunwrap)) {
 		perror("ioctl(NCRIO_KEY_UNWRAP)");
@@ -547,8 +550,8 @@ test_ncr_wrap_key(int cfd)
 
 	if (kdata.data_size != 16 || memcmp(kdata.data, DKEY, 16) != 0) {
 		fprintf(stderr, "Unwrapped data do not match.\n");
-		fprintf(stderr, "Data[%d]: ", (int) kdata.data_size);
-		for(i=0;i<kdata.data_size;i++)
+		fprintf(stderr, "Data[%d]: ", (int)kdata.data_size);
+		for (i = 0; i < kdata.data_size; i++)
 			fprintf(stderr, "%.2x:", data[i]);
 		fprintf(stderr, "\n");
 		return 1;
@@ -560,12 +563,11 @@ test_ncr_wrap_key(int cfd)
 
 /* check whether wrapping of long keys is not allowed with
  * shorted wrapping keys */
-static int
-test_ncr_wrap_key2(int cfd)
+static int test_ncr_wrap_key2(int cfd)
 {
 	int ret;
 	ncr_key_t key, key2;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_import f;
 		struct nlattr id_head ALIGN_NL;
 		uint8_t id[2] ALIGN_NL;
@@ -576,11 +578,12 @@ test_ncr_wrap_key2(int cfd)
 		struct nlattr flags_head ALIGN_NL;
 		uint32_t flags ALIGN_NL;
 	} kimport;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_wrap f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(NCR_WALG_AES_RFC3394)] ALIGN_NL;
-	} kwrap;
+	}
+	kwrap;
 	uint8_t data[WRAPPED_KEY_DATA_SIZE];
 
 	/* test 1: generate a key in userspace import it
@@ -591,7 +594,8 @@ test_ncr_wrap_key2(int cfd)
 
 	if (geteuid() != 0) {
 		/* cannot test further */
-		fprintf(stdout, "\t(Wrapping test not completed. Run as root)\n");
+		fprintf(stdout,
+			"\t(Wrapping test not completed. Run as root)\n");
 		return 0;
 	}
 
@@ -605,7 +609,8 @@ test_ncr_wrap_key2(int cfd)
 	memset(&kimport.f, 0, sizeof(kimport.f));
 	kimport.f.input_size = sizeof(kimport);
 	kimport.f.key = key;
-	kimport.f.data = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";
+	kimport.f.data =
+	    "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";
 	kimport.f.data_size = 16;
 	kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
 	kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
@@ -619,7 +624,9 @@ test_ncr_wrap_key2(int cfd)
 	strcpy(kimport.algo, ALG_AES_CBC);
 	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
 	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags = NCR_KEY_FLAG_EXPORTABLE|NCR_KEY_FLAG_WRAPPING|NCR_KEY_FLAG_UNWRAPPING;
+	kimport.flags =
+	    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPING |
+	    NCR_KEY_FLAG_UNWRAPPING;
 
 	if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -627,7 +634,6 @@ test_ncr_wrap_key2(int cfd)
 		return 1;
 	}
 
-
 	/* convert it to key */
 	key2 = ioctl(cfd, NCRIO_KEY_INIT);
 	if (key2 == -1) {
@@ -638,7 +644,8 @@ test_ncr_wrap_key2(int cfd)
 	memset(&kimport.f, 0, sizeof(kimport.f));
 	kimport.f.input_size = sizeof(kimport);
 	kimport.f.key = key2;
-	kimport.f.data = "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF";
+	kimport.f.data =
+	    "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF";
 	kimport.f.data_size = 32;
 	kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
 	kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
@@ -652,7 +659,7 @@ test_ncr_wrap_key2(int cfd)
 	strcpy(kimport.algo, ALG_AES_CBC);
 	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
 	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags = NCR_KEY_FLAG_EXPORTABLE|NCR_KEY_FLAG_WRAPPABLE;
+	kimport.flags = NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE;
 
 	if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -677,16 +684,15 @@ test_ncr_wrap_key2(int cfd)
 		/* wrapping shouldn't have been allowed */
 		return 1;
 	}
-	
+
 	return 0;
 }
 
-static int
-test_ncr_store_wrap_key(int cfd)
+static int test_ncr_store_wrap_key(int cfd)
 {
 	int i;
 	ncr_key_t key2;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_import f;
 		struct nlattr id_head ALIGN_NL;
 		uint8_t id[2] ALIGN_NL;
@@ -736,7 +742,7 @@ test_ncr_store_wrap_key(int cfd)
 	strcpy(kimport.algo, ALG_AES_CBC);
 	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
 	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags = NCR_KEY_FLAG_EXPORTABLE|NCR_KEY_FLAG_WRAPPABLE;
+	kimport.flags = NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE;
 
 	if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -800,8 +806,8 @@ test_ncr_store_wrap_key(int cfd)
 
 	if (memcmp(data, DKEY, 16) != 0) {
 		fprintf(stderr, "Unwrapped data do not match.\n");
-		fprintf(stderr, "Data[%d]: ", (int) data_size);
-		for(i=0;i<data_size;i++)
+		fprintf(stderr, "Data[%d]: ", (int)data_size);
+		for (i = 0; i < data_size; i++)
 			fprintf(stderr, "%.2x:", data[i]);
 		fprintf(stderr, "\n");
 		return 1;
@@ -812,43 +818,66 @@ test_ncr_store_wrap_key(int cfd)
 }
 
 struct aes_vectors_st {
-	const uint8_t* key;
-	const uint8_t* plaintext;
-	const uint8_t* ciphertext;
+	const uint8_t *key;
+	const uint8_t *plaintext;
+	const uint8_t *ciphertext;
 } aes_vectors[] = {
 	{
-		.key = (uint8_t*)"\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
-		.plaintext = (uint8_t*)"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
-		.ciphertext = (uint8_t*)"\x4b\xc3\xf8\x83\x45\x0c\x11\x3c\x64\xca\x42\xe1\x11\x2a\x9e\x87",
-	},
+	.key =
+		    (uint8_t *)
+		    "\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",.
+		    plaintext =
+		    (uint8_t *)
+		    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",.
+		    ciphertext =
+		    (uint8_t *)
+		    "\x4b\xc3\xf8\x83\x45\x0c\x11\x3c\x64\xca\x42\xe1\x11\x2a\x9e\x87",},
 	{
-		.key = (uint8_t*)"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
-		.plaintext = (uint8_t*)"\xf3\x44\x81\xec\x3c\xc6\x27\xba\xcd\x5d\xc3\xfb\x08\xf2\x73\xe6",
-		.ciphertext = (uint8_t*)"\x03\x36\x76\x3e\x96\x6d\x92\x59\x5a\x56\x7c\xc9\xce\x53\x7f\x5e",
-	},
+	.key =
+		    (uint8_t *)
+		    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",.
+		    plaintext =
+		    (uint8_t *)
+		    "\xf3\x44\x81\xec\x3c\xc6\x27\xba\xcd\x5d\xc3\xfb\x08\xf2\x73\xe6",.
+		    ciphertext =
+		    (uint8_t *)
+		    "\x03\x36\x76\x3e\x96\x6d\x92\x59\x5a\x56\x7c\xc9\xce\x53\x7f\x5e",},
 	{
-		.key = (uint8_t*)"\x10\xa5\x88\x69\xd7\x4b\xe5\xa3\x74\xcf\x86\x7c\xfb\x47\x38\x59",
-		.plaintext = (uint8_t*)"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
-		.ciphertext = (uint8_t*)"\x6d\x25\x1e\x69\x44\xb0\x51\xe0\x4e\xaa\x6f\xb4\xdb\xf7\x84\x65",
-	},
+	.key =
+		    (uint8_t *)
+		    "\x10\xa5\x88\x69\xd7\x4b\xe5\xa3\x74\xcf\x86\x7c\xfb\x47\x38\x59",.
+		    plaintext =
+		    (uint8_t *)
+		    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",.
+		    ciphertext =
+		    (uint8_t *)
+		    "\x6d\x25\x1e\x69\x44\xb0\x51\xe0\x4e\xaa\x6f\xb4\xdb\xf7\x84\x65",},
 	{
-		.key = (uint8_t*)"\xca\xea\x65\xcd\xbb\x75\xe9\x16\x9e\xcd\x22\xeb\xe6\xe5\x46\x75",
-		.plaintext = (uint8_t*)"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
-		.ciphertext = (uint8_t*)"\x6e\x29\x20\x11\x90\x15\x2d\xf4\xee\x05\x81\x39\xde\xf6\x10\xbb",
-	},
+	.key =
+		    (uint8_t *)
+		    "\xca\xea\x65\xcd\xbb\x75\xe9\x16\x9e\xcd\x22\xeb\xe6\xe5\x46\x75",.
+		    plaintext =
+		    (uint8_t *)
+		    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",.
+		    ciphertext =
+		    (uint8_t *)
+		    "\x6e\x29\x20\x11\x90\x15\x2d\xf4\xee\x05\x81\x39\xde\xf6\x10\xbb",},
 	{
-		.key = (uint8_t*)"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe",
-		.plaintext = (uint8_t*)"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
-		.ciphertext = (uint8_t*)"\x9b\xa4\xa9\x14\x3f\x4e\x5d\x40\x48\x52\x1c\x4f\x88\x77\xd8\x8e",
-	},
-};
+.key =
+		    (uint8_t *)
+		    "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe",.
+		    plaintext =
+		    (uint8_t *)
+		    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",.
+		    ciphertext =
+		    (uint8_t *)
+		    "\x9b\xa4\xa9\x14\x3f\x4e\x5d\x40\x48\x52\x1c\x4f\x88\x77\xd8\x8e",},};
 
 /* AES cipher */
-static int
-test_ncr_aes(int cfd)
+static int test_ncr_aes(int cfd)
 {
 	ncr_key_t key;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_import f;
 		struct nlattr id_head ALIGN_NL;
 		uint8_t id[2] ALIGN_NL;
@@ -861,7 +890,7 @@ test_ncr_aes(int cfd)
 	} kimport;
 	uint8_t data[KEY_DATA_SIZE];
 	int i, j;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_once f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(ALG_AES_ECB)] ALIGN_NL;
@@ -882,7 +911,7 @@ test_ncr_aes(int cfd)
 	}
 
 	fprintf(stdout, "Tests on AES Encryption\n");
-	for (i=0;i<sizeof(aes_vectors)/sizeof(aes_vectors[0]);i++) {
+	for (i = 0; i < sizeof(aes_vectors) / sizeof(aes_vectors[0]); i++) {
 
 		memset(&kimport.f, 0, sizeof(kimport.f));
 		kimport.f.input_size = sizeof(kimport);
@@ -935,24 +964,26 @@ test_ncr_aes(int cfd)
 		}
 		/* verify */
 
-		if (data_size != 16 || memcmp(data, aes_vectors[i].ciphertext, 16) != 0) {
+		if (data_size != 16
+		    || memcmp(data, aes_vectors[i].ciphertext, 16) != 0) {
 			fprintf(stderr, "AES test vector %d failed!\n", i);
 
 			fprintf(stderr, "Cipher[%d]: ", (int)data_size);
-			for(j=0;j<data_size;j++)
-			  fprintf(stderr, "%.2x:", (int)data[j]);
+			for (j = 0; j < data_size; j++)
+				fprintf(stderr, "%.2x:", (int)data[j]);
 			fprintf(stderr, "\n");
 
 			fprintf(stderr, "Expected[%d]: ", 16);
-			for(j=0;j<16;j++)
-			  fprintf(stderr, "%.2x:", (int)aes_vectors[i].ciphertext[j]);
+			for (j = 0; j < 16; j++)
+				fprintf(stderr, "%.2x:",
+					(int)aes_vectors[i].ciphertext[j]);
 			fprintf(stderr, "\n");
 			return 1;
 		}
 	}
 
 	fprintf(stdout, "Tests on AES Decryption\n");
-	for (i=0;i<sizeof(aes_vectors)/sizeof(aes_vectors[0]);i++) {
+	for (i = 0; i < sizeof(aes_vectors) / sizeof(aes_vectors[0]); i++) {
 
 		memset(&kimport.f, 0, sizeof(kimport.f));
 		kimport.f.input_size = sizeof(kimport);
@@ -1004,23 +1035,24 @@ test_ncr_aes(int cfd)
 			return 1;
 		}
 
-		if (data_size != 16 || memcmp(data, aes_vectors[i].plaintext, 16) != 0) {
+		if (data_size != 16
+		    || memcmp(data, aes_vectors[i].plaintext, 16) != 0) {
 			fprintf(stderr, "AES test vector %d failed!\n", i);
 
 			fprintf(stderr, "Plain[%d]: ", (int)data_size);
-			for(j=0;j<data_size;j++)
-			  fprintf(stderr, "%.2x:", (int)data[j]);
+			for (j = 0; j < data_size; j++)
+				fprintf(stderr, "%.2x:", (int)data[j]);
 			fprintf(stderr, "\n");
 
 			fprintf(stderr, "Expected[%d]: ", 16);
-			for(j=0;j<16;j++)
-			  fprintf(stderr, "%.2x:", (int)aes_vectors[i].plaintext[j]);
+			for (j = 0; j < 16; j++)
+				fprintf(stderr, "%.2x:",
+					(int)aes_vectors[i].plaintext[j]);
 			fprintf(stderr, "\n");
 			return 1;
 		}
 	}
 
-
 	fprintf(stdout, "\n");
 
 	return 0;
@@ -1028,85 +1060,83 @@ test_ncr_aes(int cfd)
 }
 
 struct hash_vectors_st {
-	const char* algorithm;
-	const uint8_t* key; /* if hmac */
+	const char *algorithm;
+	const uint8_t *key;	/* if hmac */
 	int key_size;
-	const uint8_t* plaintext;
+	const uint8_t *plaintext;
 	int plaintext_size;
-	const uint8_t* output;
+	const uint8_t *output;
 	int output_size;
 	ncr_crypto_op_t op;
 } hash_vectors[] = {
 	{
-		.algorithm = "sha1",
-		.key = NULL,
-		.plaintext = (uint8_t*)"what do ya want for nothing?",
-		.plaintext_size = sizeof("what do ya want for nothing?")-1,
-		.output = (uint8_t*)"\x8f\x82\x03\x94\xf9\x53\x35\x18\x20\x45\xda\x24\xf3\x4d\xe5\x2b\xf8\xbc\x34\x32",
-		.output_size = 20,
-		.op = NCR_OP_SIGN,
-	},
-	{
-		.algorithm = "hmac(md5)",
-		.key = (uint8_t*)"Jefe",
-		.key_size = 4,
-		.plaintext = (uint8_t*)"what do ya want for nothing?",
-		.plaintext_size = sizeof("what do ya want for nothing?")-1,
-		.output = (uint8_t*)"\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7\x38",
-		.output_size = 16,
-		.op = NCR_OP_SIGN,
-	},
-	/* from rfc4231 */
-	{
-		.algorithm = "hmac(sha224)",
-		.key = (uint8_t*)"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
-		.key_size = 20,
-		.plaintext = (uint8_t*)"Hi There",
-		.plaintext_size = sizeof("Hi There")-1,
-		.output = (uint8_t*)"\x89\x6f\xb1\x12\x8a\xbb\xdf\x19\x68\x32\x10\x7c\xd4\x9d\xf3\x3f\x47\xb4\xb1\x16\x99\x12\xba\x4f\x53\x68\x4b\x22",
-		.output_size = 28,
-		.op = NCR_OP_SIGN,
-	},
+	.algorithm = "sha1",.key = NULL,.plaintext =
+		    (uint8_t *) "what do ya want for nothing?",.
+		    plaintext_size =
+		    sizeof("what do ya want for nothing?") - 1,.output =
+		    (uint8_t *)
+		    "\x8f\x82\x03\x94\xf9\x53\x35\x18\x20\x45\xda\x24\xf3\x4d\xe5\x2b\xf8\xbc\x34\x32",.
+		    output_size = 20,.op = NCR_OP_SIGN,}
+	, {
+	.algorithm = "hmac(md5)",.key = (uint8_t *) "Jefe",.key_size =
+		    4,.plaintext =
+		    (uint8_t *) "what do ya want for nothing?",.
+		    plaintext_size =
+		    sizeof("what do ya want for nothing?") - 1,.output =
+		    (uint8_t *)
+		    "\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7\x38",.
+		    output_size = 16,.op = NCR_OP_SIGN,}
+	,
+	    /* from rfc4231 */
 	{
-		.algorithm = "hmac(sha256)",
-		.key = (uint8_t*)"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
-		.key_size = 20,
-		.plaintext = (uint8_t*)"Hi There",
-		.plaintext_size = sizeof("Hi There")-1,
-		.output = (uint8_t*)"\xb0\x34\x4c\x61\xd8\xdb\x38\x53\x5c\xa8\xaf\xce\xaf\x0b\xf1\x2b\x88\x1d\xc2\x00\xc9\x83\x3d\xa7\x26\xe9\x37\x6c\x2e\x32\xcf\xf7",
-		.output_size = 32,
-		.op = NCR_OP_SIGN,
-	},
-	{
-		.algorithm = "hmac(sha384)",
-		.key = (uint8_t*)"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
-		.key_size = 20,
-		.plaintext = (uint8_t*)"Hi There",
-		.plaintext_size = sizeof("Hi There")-1,
-		.output = (uint8_t*)"\xaf\xd0\x39\x44\xd8\x48\x95\x62\x6b\x08\x25\xf4\xab\x46\x90\x7f\x15\xf9\xda\xdb\xe4\x10\x1e\xc6\x82\xaa\x03\x4c\x7c\xeb\xc5\x9c\xfa\xea\x9e\xa9\x07\x6e\xde\x7f\x4a\xf1\x52\xe8\xb2\xfa\x9c\xb6",
-		.output_size = 48,
-		.op = NCR_OP_SIGN,
-	},
-	{
-		.algorithm = "hmac(sha512)",
-		.key = (uint8_t*)"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
-		.key_size = 20,
-		.plaintext = (uint8_t*)"Hi There",
-		.plaintext_size = sizeof("Hi There")-1,
-		.output = (uint8_t*)"\x87\xaa\x7c\xde\xa5\xef\x61\x9d\x4f\xf0\xb4\x24\x1a\x1d\x6c\xb0\x23\x79\xf4\xe2\xce\x4e\xc2\x78\x7a\xd0\xb3\x05\x45\xe1\x7c\xde\xda\xa8\x33\xb7\xd6\xb8\xa7\x02\x03\x8b\x27\x4e\xae\xa3\xf4\xe4\xbe\x9d\x91\x4e\xeb\x61\xf1\x70\x2e\x69\x6c\x20\x3a\x12\x68\x54",
-		.output_size = 64,
-		.op = NCR_OP_SIGN,
-	},
-};
+	.algorithm = "hmac(sha224)",.key =
+		    (uint8_t *)
+		    "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",.
+		    key_size = 20,.plaintext =
+		    (uint8_t *) "Hi There",.plaintext_size =
+		    sizeof("Hi There") - 1,.output =
+		    (uint8_t *)
+		    "\x89\x6f\xb1\x12\x8a\xbb\xdf\x19\x68\x32\x10\x7c\xd4\x9d\xf3\x3f\x47\xb4\xb1\x16\x99\x12\xba\x4f\x53\x68\x4b\x22",.
+		    output_size = 28,.op = NCR_OP_SIGN,}
+	, {
+	.algorithm = "hmac(sha256)",.key =
+		    (uint8_t *)
+		    "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",.
+		    key_size = 20,.plaintext =
+		    (uint8_t *) "Hi There",.plaintext_size =
+		    sizeof("Hi There") - 1,.output =
+		    (uint8_t *)
+		    "\xb0\x34\x4c\x61\xd8\xdb\x38\x53\x5c\xa8\xaf\xce\xaf\x0b\xf1\x2b\x88\x1d\xc2\x00\xc9\x83\x3d\xa7\x26\xe9\x37\x6c\x2e\x32\xcf\xf7",.
+		    output_size = 32,.op = NCR_OP_SIGN,}
+	, {
+	.algorithm = "hmac(sha384)",.key =
+		    (uint8_t *)
+		    "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",.
+		    key_size = 20,.plaintext =
+		    (uint8_t *) "Hi There",.plaintext_size =
+		    sizeof("Hi There") - 1,.output =
+		    (uint8_t *)
+		    "\xaf\xd0\x39\x44\xd8\x48\x95\x62\x6b\x08\x25\xf4\xab\x46\x90\x7f\x15\xf9\xda\xdb\xe4\x10\x1e\xc6\x82\xaa\x03\x4c\x7c\xeb\xc5\x9c\xfa\xea\x9e\xa9\x07\x6e\xde\x7f\x4a\xf1\x52\xe8\xb2\xfa\x9c\xb6",.
+		    output_size = 48,.op = NCR_OP_SIGN,}
+	, {
+	.algorithm = "hmac(sha512)",.key =
+		    (uint8_t *)
+		    "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",.
+		    key_size = 20,.plaintext =
+		    (uint8_t *) "Hi There",.plaintext_size =
+		    sizeof("Hi There") - 1,.output =
+		    (uint8_t *)
+		    "\x87\xaa\x7c\xde\xa5\xef\x61\x9d\x4f\xf0\xb4\x24\x1a\x1d\x6c\xb0\x23\x79\xf4\xe2\xce\x4e\xc2\x78\x7a\xd0\xb3\x05\x45\xe1\x7c\xde\xda\xa8\x33\xb7\xd6\xb8\xa7\x02\x03\x8b\x27\x4e\xae\xa3\xf4\xe4\xbe\x9d\x91\x4e\xeb\x61\xf1\x70\x2e\x69\x6c\x20\x3a\x12\x68\x54",.
+		    output_size = 64,.op = NCR_OP_SIGN,}
+,};
 
 #define HASH_DATA_SIZE 64
 
 /* SHA1 and other hashes */
-static int
-test_ncr_hash(int cfd)
+static int test_ncr_hash(int cfd)
 {
 	ncr_key_t key;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_import f;
 		struct nlattr id_head ALIGN_NL;
 		uint8_t id[2] ALIGN_NL;
@@ -1120,7 +1150,7 @@ test_ncr_hash(int cfd)
 	uint8_t data[HASH_DATA_SIZE];
 	int i, j;
 	size_t data_size;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_once f;
 		struct nlattr key_head ALIGN_NL;
 		uint32_t key ALIGN_NL;
@@ -1140,7 +1170,7 @@ test_ncr_hash(int cfd)
 	}
 
 	fprintf(stdout, "Tests on Hashes\n");
-	for (i=0;i<sizeof(hash_vectors)/sizeof(hash_vectors[0]);i++) {
+	for (i = 0; i < sizeof(hash_vectors) / sizeof(hash_vectors[0]); i++) {
 		size_t algo_size;
 
 		algo_size = strlen(hash_vectors[i].algorithm) + 1;
@@ -1153,16 +1183,16 @@ test_ncr_hash(int cfd)
 			kimport.f.data = hash_vectors[i].key;
 			kimport.f.data_size = hash_vectors[i].key_size;
 			kimport.id_head.nla_len
-				= NLA_HDRLEN + sizeof(kimport.id);
+			    = NLA_HDRLEN + sizeof(kimport.id);
 			kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
 			kimport.id[0] = 'a';
 			kimport.id[1] = 'b';
 			kimport.type_head.nla_len
-				= NLA_HDRLEN + sizeof(kimport.type);
+			    = NLA_HDRLEN + sizeof(kimport.type);
 			kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
 			kimport.type = NCR_KEY_TYPE_SECRET;
 			kimport.flags_head.nla_len
-				= NLA_HDRLEN + sizeof(kimport.flags);
+			    = NLA_HDRLEN + sizeof(kimport.flags);
 			kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
 			kimport.flags = NCR_KEY_FLAG_EXPORTABLE;
 			kimport.algo_head.nla_len = NLA_HDRLEN + algo_size;
@@ -1170,9 +1200,10 @@ test_ncr_hash(int cfd)
 			memcpy(kimport.algo, hash_vectors[i].algorithm,
 			       algo_size);
 			kimport.f.input_size
-				= kimport.algo + algo_size - (char *)&kimport;
+			    = kimport.algo + algo_size - (char *)&kimport;
 			if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
-				fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
+				fprintf(stderr, "Error: %s:%d\n", __func__,
+					__LINE__);
 				perror("ioctl(NCRIO_KEY_IMPORT)");
 				return 1;
 			}
@@ -1204,17 +1235,20 @@ test_ncr_hash(int cfd)
 		}
 
 		if (data_size != hash_vectors[i].output_size ||
-			memcmp(data, hash_vectors[i].output, hash_vectors[i].output_size) != 0) {
+		    memcmp(data, hash_vectors[i].output,
+			   hash_vectors[i].output_size) != 0) {
 			fprintf(stderr, "HASH test vector %d failed!\n", i);
 
 			fprintf(stderr, "Output[%d]: ", (int)data_size);
-			for(j=0;j<data_size;j++)
-			  fprintf(stderr, "%.2x:", (int)data[j]);
+			for (j = 0; j < data_size; j++)
+				fprintf(stderr, "%.2x:", (int)data[j]);
 			fprintf(stderr, "\n");
 
-			fprintf(stderr, "Expected[%d]: ", hash_vectors[i].output_size);
-			for(j=0;j<hash_vectors[i].output_size;j++)
-			  fprintf(stderr, "%.2x:", (int)hash_vectors[i].output[j]);
+			fprintf(stderr, "Expected[%d]: ",
+				hash_vectors[i].output_size);
+			for (j = 0; j < hash_vectors[i].output_size; j++)
+				fprintf(stderr, "%.2x:",
+					(int)hash_vectors[i].output[j]);
 			fprintf(stderr, "\n");
 			return 1;
 		}
@@ -1226,11 +1260,10 @@ test_ncr_hash(int cfd)
 
 }
 
-static int
-test_ncr_hash_clone(int cfd)
+static int test_ncr_hash_clone(int cfd)
 {
 	ncr_key_t key;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_import f;
 		struct nlattr id_head ALIGN_NL;
 		uint8_t id[2] ALIGN_NL;
@@ -1245,26 +1278,26 @@ test_ncr_hash_clone(int cfd)
 	const struct hash_vectors_st *hv;
 	int j;
 	size_t data_size;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_init f;
 		struct nlattr key_head ALIGN_NL;
 		uint32_t key ALIGN_NL;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[128] ALIGN_NL;
 	} kinit;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_update f;
 		struct nlattr input_head ALIGN_NL;
 		struct ncr_session_input_data input ALIGN_NL;
 	} kupdate;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_final f;
 		struct nlattr input_head ALIGN_NL;
 		struct ncr_session_input_data input ALIGN_NL;
 		struct nlattr output_head ALIGN_NL;
 		struct ncr_session_output_buffer output ALIGN_NL;
 	} kfinal;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_once f;
 		struct nlattr clone_head ALIGN_NL;
 		uint32_t clone ALIGN_NL;
@@ -1298,25 +1331,26 @@ test_ncr_hash_clone(int cfd)
 			kimport.f.data = hv->key;
 			kimport.f.data_size = hv->key_size;
 			kimport.id_head.nla_len
-				= NLA_HDRLEN + sizeof(kimport.id);
+			    = NLA_HDRLEN + sizeof(kimport.id);
 			kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
 			kimport.id[0] = 'a';
 			kimport.id[1] = 'b';
 			kimport.type_head.nla_len
-				= NLA_HDRLEN + sizeof(kimport.type);
+			    = NLA_HDRLEN + sizeof(kimport.type);
 			kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
 			kimport.type = NCR_KEY_TYPE_SECRET;
 			kimport.flags_head.nla_len
-				= NLA_HDRLEN + sizeof(kimport.flags);
+			    = NLA_HDRLEN + sizeof(kimport.flags);
 			kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
 			kimport.flags = NCR_KEY_FLAG_EXPORTABLE;
 			kimport.algo_head.nla_len = NLA_HDRLEN + algo_size;
 			kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
 			memcpy(kimport.algo, hv->algorithm, algo_size);
 			kimport.f.input_size
-				= kimport.algo + algo_size - (char *)&kimport;
+			    = kimport.algo + algo_size - (char *)&kimport;
 			if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
-				fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
+				fprintf(stderr, "Error: %s:%d\n", __func__,
+					__LINE__);
 				perror("ioctl(NCRIO_KEY_IMPORT)");
 				return 1;
 			}
@@ -1366,7 +1400,7 @@ test_ncr_hash_clone(int cfd)
 		kclone.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
 		kclone.input.data = hv->plaintext + hv->plaintext_size / 2;
 		kclone.input.data_size
-			= hv->plaintext_size - hv->plaintext_size / 2;
+		    = hv->plaintext_size - hv->plaintext_size / 2;
 		kclone.output_head.nla_len = NLA_HDRLEN + sizeof(kclone.output);
 		kclone.output_head.nla_type = NCR_ATTR_FINAL_OUTPUT_BUFFER;
 		kclone.output.buffer = data;
@@ -1385,7 +1419,7 @@ test_ncr_hash_clone(int cfd)
 				hv - hash_vectors);
 
 			fprintf(stderr, "Output[%zu]: ", data_size);
-			for(j = 0; j < data_size; j++)
+			for (j = 0; j < data_size; j++)
 				fprintf(stderr, "%.2x:", (int)data[j]);
 			fprintf(stderr, "\n");
 
@@ -1404,7 +1438,7 @@ test_ncr_hash_clone(int cfd)
 		kfinal.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
 		kfinal.input.data = hv->plaintext + hv->plaintext_size / 2;
 		kfinal.input.data_size
-			= hv->plaintext_size - hv->plaintext_size / 2;
+		    = hv->plaintext_size - hv->plaintext_size / 2;
 		kfinal.output_head.nla_len = NLA_HDRLEN + sizeof(kfinal.output);
 		kfinal.output_head.nla_type = NCR_ATTR_FINAL_OUTPUT_BUFFER;
 		kfinal.output.buffer = data;
@@ -1423,7 +1457,7 @@ test_ncr_hash_clone(int cfd)
 				hv - hash_vectors);
 
 			fprintf(stderr, "Output[%zu]: ", data_size);
-			for(j = 0; j < data_size; j++)
+			for (j = 0; j < data_size; j++)
 				fprintf(stderr, "%.2x:", (int)data[j]);
 			fprintf(stderr, "\n");
 
@@ -1441,12 +1475,11 @@ test_ncr_hash_clone(int cfd)
 
 }
 
-static int
-test_ncr_hash_key(int cfd)
+static int test_ncr_hash_key(int cfd)
 {
 	ncr_key_t key;
 	ncr_session_t ses;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_import f;
 		struct nlattr id_head ALIGN_NL;
 		uint8_t id[2] ALIGN_NL;
@@ -1460,27 +1493,29 @@ test_ncr_hash_key(int cfd)
 	uint8_t data[HASH_DATA_SIZE];
 	int j;
 	size_t data_size, algo_size;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_init f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[128] ALIGN_NL;
 	} op_init;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_update f;
 		struct nlattr data_head ALIGN_NL;
 		struct ncr_session_input_data data ALIGN_NL;
 	} op_up_data;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_update f;
 		struct nlattr key_head ALIGN_NL;
 		uint32_t key;
 	} op_up_key;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_final f;
 		struct nlattr output_head ALIGN_NL;
 		struct ncr_session_output_buffer output ALIGN_NL;
 	} op_final;
-	const uint8_t *output = (void*)"\xe2\xd7\x2c\x2e\x14\xad\x97\xc8\xd2\xdb\xce\xd8\xb3\x52\x9f\x1c\xb3\x2c\x5c\xec";
+	const uint8_t *output =
+	    (void *)
+	    "\xe2\xd7\x2c\x2e\x14\xad\x97\xc8\xd2\xdb\xce\xd8\xb3\x52\x9f\x1c\xb3\x2c\x5c\xec";
 
 	/* convert it to key */
 	key = ioctl(cfd, NCRIO_KEY_INIT);
@@ -1507,7 +1542,7 @@ test_ncr_hash_key(int cfd)
 	kimport.type = NCR_KEY_TYPE_SECRET;
 	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
 	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags = NCR_KEY_FLAG_EXPORTABLE|NCR_KEY_FLAG_HASHABLE;
+	kimport.flags = NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_HASHABLE;
 	kimport.algo_head.nla_len = NLA_HDRLEN + algo_size;
 	kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
 	memcpy(kimport.algo, hash_vectors[0].algorithm, algo_size);
@@ -1572,35 +1607,31 @@ test_ncr_hash_key(int cfd)
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
 		perror("ioctl(NCRIO_SESSION_FINAL)");
 		return 1;
-	}		
-
+	}
 
 	if (data_size != hash_vectors[0].output_size ||
-			memcmp(data, output, hash_vectors[0].output_size) != 0) {
-			fprintf(stderr, "HASH test vector %d failed!\n", 0);
+	    memcmp(data, output, hash_vectors[0].output_size) != 0) {
+		fprintf(stderr, "HASH test vector %d failed!\n", 0);
 
-			fprintf(stderr, "Output[%d]: ", (int)data_size);
-			for(j=0;j<data_size;j++)
-			  fprintf(stderr, "%.2x:", (int)data[j]);
-			fprintf(stderr, "\n");
+		fprintf(stderr, "Output[%d]: ", (int)data_size);
+		for (j = 0; j < data_size; j++)
+			fprintf(stderr, "%.2x:", (int)data[j]);
+		fprintf(stderr, "\n");
 
-			fprintf(stderr, "Expected[%d]: ", hash_vectors[0].output_size);
-			for(j=0;j<hash_vectors[0].output_size;j++)
-			  fprintf(stderr, "%.2x:", (int)output[j]);
-			fprintf(stderr, "\n");
-			return 1;
+		fprintf(stderr, "Expected[%d]: ", hash_vectors[0].output_size);
+		for (j = 0; j < hash_vectors[0].output_size; j++)
+			fprintf(stderr, "%.2x:", (int)output[j]);
+		fprintf(stderr, "\n");
+		return 1;
 	}
 
-
 	fprintf(stdout, "\n");
 
 	return 0;
 
 }
 
-
-int
-main()
+int main()
 {
 	int fd = -1;
 
diff --git a/examples/pk.c b/examples/pk.c
index 5253500..b2cae68 100644
--- a/examples/pk.c
+++ b/examples/pk.c
@@ -36,99 +36,93 @@
 #define ALG_DSA "dsa"
 #define ALG_RSA "rsa"
 
-static void
-print_hex_datum (gnutls_datum_t * dat)
+static void print_hex_datum(gnutls_datum_t * dat)
 {
-  unsigned int j;
+	unsigned int j;
 #define SPACE "\t"
-  fprintf (stdout, "\n" SPACE);
-  for (j = 0; j < dat->size; j++)
-    {
-      fprintf (stdout, "%.2x:", (unsigned char) dat->data[j]);
-      if ((j + 1) % 15 == 0)
-	fprintf (stdout, "\n" SPACE);
-    }
-  fprintf (stdout, "\n");
+	fprintf(stdout, "\n" SPACE);
+	for (j = 0; j < dat->size; j++) {
+		fprintf(stdout, "%.2x:", (unsigned char)dat->data[j]);
+		if ((j + 1) % 15 == 0)
+			fprintf(stdout, "\n" SPACE);
+	}
+	fprintf(stdout, "\n");
 }
 
 static void
-print_dsa_pkey (gnutls_datum_t * x, gnutls_datum_t * y, gnutls_datum_t * p,
-		gnutls_datum_t * q, gnutls_datum_t * g)
+print_dsa_pkey(gnutls_datum_t * x, gnutls_datum_t * y, gnutls_datum_t * p,
+	       gnutls_datum_t * q, gnutls_datum_t * g)
 {
-  if (x) 
-    {
-      fprintf (stdout, "private key:");
-      print_hex_datum (x);
-    }
-  fprintf (stdout, "public key:");
-  print_hex_datum (y);
-  fprintf (stdout, "p:");
-  print_hex_datum (p);
-  fprintf (stdout, "q:");
-  print_hex_datum (q);
-  fprintf (stdout, "g:");
-  print_hex_datum (g);
+	if (x) {
+		fprintf(stdout, "private key:");
+		print_hex_datum(x);
+	}
+	fprintf(stdout, "public key:");
+	print_hex_datum(y);
+	fprintf(stdout, "p:");
+	print_hex_datum(p);
+	fprintf(stdout, "q:");
+	print_hex_datum(q);
+	fprintf(stdout, "g:");
+	print_hex_datum(g);
 }
 
 static void
-print_rsa_pkey (gnutls_datum_t * m, gnutls_datum_t * e, gnutls_datum_t * d,
-		gnutls_datum_t * p, gnutls_datum_t * q, gnutls_datum_t * u,
-		gnutls_datum_t * exp1, gnutls_datum_t *exp2)
+print_rsa_pkey(gnutls_datum_t * m, gnutls_datum_t * e, gnutls_datum_t * d,
+	       gnutls_datum_t * p, gnutls_datum_t * q, gnutls_datum_t * u,
+	       gnutls_datum_t * exp1, gnutls_datum_t * exp2)
 {
-  fprintf (stdout, "modulus:");
-  print_hex_datum (m);
-  fprintf (stdout, "public exponent:");
-  print_hex_datum (e);
-  if (d) 
-    {
-      fprintf (stdout, "private exponent:");
-      print_hex_datum (d);
-      fprintf (stdout, "prime1:");
-      print_hex_datum (p);
-      fprintf (stdout, "prime2:");
-      print_hex_datum (q);
-      fprintf (stdout, "coefficient:");
-      print_hex_datum (u);
-      if (exp1 && exp2)
-        {
-          fprintf (stdout, "exp1:");
-          print_hex_datum (exp1);
-          fprintf (stdout, "exp2:");
-          print_hex_datum (exp2);
-        }
-    }
+	fprintf(stdout, "modulus:");
+	print_hex_datum(m);
+	fprintf(stdout, "public exponent:");
+	print_hex_datum(e);
+	if (d) {
+		fprintf(stdout, "private exponent:");
+		print_hex_datum(d);
+		fprintf(stdout, "prime1:");
+		print_hex_datum(p);
+		fprintf(stdout, "prime2:");
+		print_hex_datum(q);
+		fprintf(stdout, "coefficient:");
+		print_hex_datum(u);
+		if (exp1 && exp2) {
+			fprintf(stdout, "exp1:");
+			print_hex_datum(exp1);
+			fprintf(stdout, "exp2:");
+			print_hex_datum(exp2);
+		}
+	}
 }
 
-static const char *
-raw_to_string (const unsigned char *raw, size_t raw_size)
+static const char *raw_to_string(const unsigned char *raw, size_t raw_size)
 {
 	static char buf[1024];
 	size_t i;
 	if (raw_size == 0)
 		return NULL;
 
-	if (raw_size * 3 + 1 >= sizeof (buf))
+	if (raw_size * 3 + 1 >= sizeof(buf))
 		return NULL;
 
 	for (i = 0; i < raw_size; i++) {
-		sprintf (&(buf[i * 3]), "%02X%s", raw[i],
+		sprintf(&(buf[i * 3]), "%02X%s", raw[i],
 			(i == raw_size - 1) ? "" : ":");
 	}
-	buf[sizeof (buf) - 1] = '\0';
+	buf[sizeof(buf) - 1] = '\0';
 
 	return buf;
 }
 
-int privkey_info (void* data, int data_size, int verbose)
+int privkey_info(void *data, int data_size, int verbose)
 {
 	gnutls_x509_privkey_t key;
 	size_t size;
 	int ret;
 	gnutls_datum_t der;
-	unsigned char buffer[5*1024];
+	unsigned char buffer[5 * 1024];
 	const char *cprint;
 
-	ret = gnutls_x509_privkey_init (&key);
+	ret = gnutls_x509_privkey_init(&key);
 	if (ret < 0) {
 		fprintf(stderr, "error in privkey_init\n");
 		return 1;
@@ -137,7 +131,7 @@ int privkey_info (void* data, int data_size, int verbose)
 	der.data = data;
 	der.size = data_size;
 
-	ret = gnutls_x509_privkey_import (key, &der, GNUTLS_X509_FMT_DER);
+	ret = gnutls_x509_privkey_import(key, &der, GNUTLS_X509_FMT_DER);
 	if (ret < 0) {
 		fprintf(stderr, "unable to import privkey\n");
 		return 1;
@@ -145,93 +139,108 @@ int privkey_info (void* data, int data_size, int verbose)
 
 	if (verbose > 0) {
 		/* Public key algorithm
-		*/
-		fprintf (stdout, "Public Key Info:\n");
-		ret = gnutls_x509_privkey_get_pk_algorithm (key);
+		 */
+		fprintf(stdout, "Public Key Info:\n");
+		ret = gnutls_x509_privkey_get_pk_algorithm(key);
 
-		fprintf (stdout, "\tPublic Key Algorithm: ");
-		cprint = gnutls_pk_algorithm_get_name (ret);
-		fprintf (stdout, "%s\n", cprint ? cprint : "Unknown");
+		fprintf(stdout, "\tPublic Key Algorithm: ");
+		cprint = gnutls_pk_algorithm_get_name(ret);
+		fprintf(stdout, "%s\n", cprint ? cprint : "Unknown");
 
 		/* Print the raw public and private keys
-		*/
+		 */
 		if (ret == GNUTLS_PK_RSA) {
-			gnutls_datum_t m, e, d, p, q, u, exp1={NULL,0}, exp2={NULL,0};
+			gnutls_datum_t m, e, d, p, q, u, exp1 = { NULL, 0 }
+			, exp2 = {
+			NULL, 0};
 
 #if GNUTLS_VERSION_NUMBER >= 0x020b00
-			ret = gnutls_x509_privkey_export_rsa_raw2 (key, &m, &e, &d, &p, &q, &u, &exp1, &exp2);
+			ret =
+			    gnutls_x509_privkey_export_rsa_raw2(key, &m, &e, &d,
+								&p, &q, &u,
+								&exp1, &exp2);
 #else
-			ret = gnutls_x509_privkey_export_rsa_raw (key, &m, &e, &d, &p, &q, &u);
+			ret =
+			    gnutls_x509_privkey_export_rsa_raw(key, &m, &e, &d,
+							       &p, &q, &u);
 #endif
 			if (ret < 0)
-				fprintf (stderr, "Error in key RSA data export: %s\n",
-					gnutls_strerror (ret));
+				fprintf(stderr,
+					"Error in key RSA data export: %s\n",
+					gnutls_strerror(ret));
 			else {
-				print_rsa_pkey (&m, &e, &d, &p, &q, &u, &exp1, &exp2);
-				gnutls_free (m.data);
-				gnutls_free (e.data);
-				gnutls_free (d.data);
-				gnutls_free (p.data);
-				gnutls_free (q.data);
-				gnutls_free (u.data);
-				gnutls_free (exp1.data);
-				gnutls_free (exp2.data);
+				print_rsa_pkey(&m, &e, &d, &p, &q, &u, &exp1,
+					       &exp2);
+				gnutls_free(m.data);
+				gnutls_free(e.data);
+				gnutls_free(d.data);
+				gnutls_free(p.data);
+				gnutls_free(q.data);
+				gnutls_free(u.data);
+				gnutls_free(exp1.data);
+				gnutls_free(exp2.data);
 			}
 		} else if (ret == GNUTLS_PK_DSA) {
 			gnutls_datum_t p, q, g, y, x;
 
-			ret = gnutls_x509_privkey_export_dsa_raw (key, &p, &q, &g, &y, &x);
+			ret =
+			    gnutls_x509_privkey_export_dsa_raw(key, &p, &q, &g,
+							       &y, &x);
 			if (ret < 0)
-				fprintf (stderr, "Error in key DSA data export: %s\n",
-					gnutls_strerror (ret));
+				fprintf(stderr,
+					"Error in key DSA data export: %s\n",
+					gnutls_strerror(ret));
 			else {
-				print_dsa_pkey (&x, &y, &p, &q, &g);
-				gnutls_free (x.data);
-				gnutls_free (y.data);
-				gnutls_free (p.data);
-				gnutls_free (q.data);
-				gnutls_free (g.data);
+				print_dsa_pkey(&x, &y, &p, &q, &g);
+				gnutls_free(x.data);
+				gnutls_free(y.data);
+				gnutls_free(p.data);
+				gnutls_free(q.data);
+				gnutls_free(g.data);
 			}
 		}
 
-		fprintf (stdout, "\n");
+		fprintf(stdout, "\n");
 
-		size = sizeof (buffer);
-		if ((ret = gnutls_x509_privkey_get_key_id (key, 0, buffer, &size)) < 0) {
-			fprintf (stderr, "Error in key id calculation: %s\n",
-			       gnutls_strerror (ret));
+		size = sizeof(buffer);
+		if ((ret =
+		     gnutls_x509_privkey_get_key_id(key, 0, buffer,
+						    &size)) < 0) {
+			fprintf(stderr, "Error in key id calculation: %s\n",
+				gnutls_strerror(ret));
 		} else {
-			fprintf (stdout, "Public Key ID: %s\n", raw_to_string (buffer, size));
+			fprintf(stdout, "Public Key ID: %s\n",
+				raw_to_string(buffer, size));
 		}
 
-		size = sizeof (buffer);
-		ret = gnutls_x509_privkey_export (key, GNUTLS_X509_FMT_PEM, buffer, &size);
+		size = sizeof(buffer);
+		ret =
+		    gnutls_x509_privkey_export(key, GNUTLS_X509_FMT_PEM, buffer,
+					       &size);
 		if (ret < 0) {
 			fprintf(stderr, "Error in privkey_export\n");
 			return 1;
 		}
 
-		fprintf (stdout, "\n%s\n", buffer);
+		fprintf(stdout, "\n%s\n", buffer);
 	}
 
-	gnutls_x509_privkey_deinit (key);
-	
+	gnutls_x509_privkey_deinit(key);
+
 	return 0;
 }
 
-
-
-int pubkey_info(void* data, int data_size, int verbose)
+int pubkey_info(void *data, int data_size, int verbose)
 {
 #if GNUTLS_VERSION_NUMBER >= 0x020b00
 	gnutls_pubkey_t key;
 	size_t size;
 	int ret;
 	gnutls_datum_t der;
-	unsigned char buffer[5*1024];
+	unsigned char buffer[5 * 1024];
 	const char *cprint;
 
-	ret = gnutls_pubkey_init (&key);
+	ret = gnutls_pubkey_init(&key);
 	if (ret < 0) {
 		fprintf(stderr, "error in pubkey_init\n");
 		return 1;
@@ -240,7 +249,7 @@ int pubkey_info(void* data, int data_size, int verbose)
 	der.data = data;
 	der.size = data_size;
 
-	ret = gnutls_pubkey_import (key, &der, GNUTLS_X509_FMT_DER);
+	ret = gnutls_pubkey_import(key, &der, GNUTLS_X509_FMT_DER);
 	if (ret < 0) {
 		fprintf(stderr, "unable to import pubkey\n");
 		return 1;
@@ -248,110 +257,116 @@ int pubkey_info(void* data, int data_size, int verbose)
 
 	if (verbose > 0) {
 		/* Public key algorithm
-		*/
-		fprintf (stdout, "Public Key Info:\n");
-		ret = gnutls_pubkey_get_pk_algorithm (key, NULL);
+		 */
+		fprintf(stdout, "Public Key Info:\n");
+		ret = gnutls_pubkey_get_pk_algorithm(key, NULL);
 
-		fprintf (stdout, "\tPublic Key Algorithm: ");
-		cprint = gnutls_pk_algorithm_get_name (ret);
-		fprintf (stdout, "%s\n", cprint ? cprint : "Unknown");
+		fprintf(stdout, "\tPublic Key Algorithm: ");
+		cprint = gnutls_pk_algorithm_get_name(ret);
+		fprintf(stdout, "%s\n", cprint ? cprint : "Unknown");
 
 		/* Print the raw public and private keys
-		*/
+		 */
 		if (ret == GNUTLS_PK_RSA) {
 			gnutls_datum_t m, e;
 
-			ret = gnutls_pubkey_get_pk_rsa_raw (key, &m, &e);
+			ret = gnutls_pubkey_get_pk_rsa_raw(key, &m, &e);
 			if (ret < 0)
-				fprintf (stderr, "Error in key RSA data export: %s\n",
-					gnutls_strerror (ret));
+				fprintf(stderr,
+					"Error in key RSA data export: %s\n",
+					gnutls_strerror(ret));
 			else {
-				print_rsa_pkey (&m, &e, NULL, NULL, NULL, NULL, NULL, NULL);
-				gnutls_free (m.data);
-				gnutls_free (e.data);
+				print_rsa_pkey(&m, &e, NULL, NULL, NULL, NULL,
+					       NULL, NULL);
+				gnutls_free(m.data);
+				gnutls_free(e.data);
 			}
 		} else if (ret == GNUTLS_PK_DSA) {
 			gnutls_datum_t p, q, g, y;
 
-			ret = gnutls_pubkey_get_pk_dsa_raw (key, &p, &q, &g, &y);
+			ret = gnutls_pubkey_get_pk_dsa_raw(key, &p, &q, &g, &y);
 			if (ret < 0)
-				fprintf (stderr, "Error in key DSA data export: %s\n",
-					gnutls_strerror (ret));
+				fprintf(stderr,
+					"Error in key DSA data export: %s\n",
+					gnutls_strerror(ret));
 			else {
-				print_dsa_pkey (NULL, &y, &p, &q, &g);
-				gnutls_free (y.data);
-				gnutls_free (p.data);
-				gnutls_free (q.data);
-				gnutls_free (g.data);
+				print_dsa_pkey(NULL, &y, &p, &q, &g);
+				gnutls_free(y.data);
+				gnutls_free(p.data);
+				gnutls_free(q.data);
+				gnutls_free(g.data);
 			}
 		}
 
-		fprintf (stdout, "\n");
+		fprintf(stdout, "\n");
 
-		size = sizeof (buffer);
-		if ((ret = gnutls_pubkey_get_key_id (key, 0, buffer, &size)) < 0) {
-			fprintf (stderr, "Error in key id calculation: %s\n",
-			       gnutls_strerror (ret));
+		size = sizeof(buffer);
+		if ((ret = gnutls_pubkey_get_key_id(key, 0, buffer, &size)) < 0) {
+			fprintf(stderr, "Error in key id calculation: %s\n",
+				gnutls_strerror(ret));
 		} else {
-			fprintf (stdout, "Public Key ID: %s\n", raw_to_string (buffer, size));
+			fprintf(stdout, "Public Key ID: %s\n",
+				raw_to_string(buffer, size));
 		}
 
-		size = sizeof (buffer);
-		ret = gnutls_pubkey_export (key, GNUTLS_X509_FMT_PEM, buffer, &size);
+		size = sizeof(buffer);
+		ret =
+		    gnutls_pubkey_export(key, GNUTLS_X509_FMT_PEM, buffer,
+					 &size);
 		if (ret < 0) {
 			fprintf(stderr, "Error in privkey_export\n");
 			return 1;
 		}
 
-		fprintf (stdout, "\n%s\n", buffer);
+		fprintf(stdout, "\n%s\n", buffer);
 	}
 
-	gnutls_pubkey_deinit (key);
+	gnutls_pubkey_deinit(key);
 #endif
 	return 0;
 }
 
 /* Diffie Hellman */
-const char dh_params_txt[] = "-----BEGIN DH PARAMETERS-----\n"\
-"MIGHAoGBAKMox0/IjuGqSaGMJESYMhdmXiTe1pY8gkSzWZ/ktWaUdaYAzgAZp7r3\n"\
-"OCh68YslS9Oi7/UQjmBbgGuOucMKgq3tYeYzY8G2epIuIzM4TAogaEqwkdSrXlth\n"\
-"MMsP2FhLhHg8m6V6iItitnMOz9r8t3BEf04GRlfzgZraM0gUUwTjAgEF\n"\
-"-----END DH PARAMETERS-----\n";
+const char dh_params_txt[] = "-----BEGIN DH PARAMETERS-----\n"
+    "MIGHAoGBAKMox0/IjuGqSaGMJESYMhdmXiTe1pY8gkSzWZ/ktWaUdaYAzgAZp7r3\n"
+    "OCh68YslS9Oi7/UQjmBbgGuOucMKgq3tYeYzY8G2epIuIzM4TAogaEqwkdSrXlth\n"
+    "MMsP2FhLhHg8m6V6iItitnMOz9r8t3BEf04GRlfzgZraM0gUUwTjAgEF\n"
+    "-----END DH PARAMETERS-----\n";
 
 static int test_ncr_dh(int cfd)
 {
-struct __attribute__((packed)) {
-	struct ncr_key_generate_pair f;
-	struct nlattr algo_head ALIGN_NL;
-	char algo[sizeof(ALG_DH)] ALIGN_NL;
-	struct nlattr flags_head ALIGN_NL;
-	uint32_t flags ALIGN_NL;
-	unsigned char buffer[DATA_SIZE] ALIGN_NL;
-} kgen;
-struct nlattr *nla;
-ncr_key_t private1, public1, public2, private2;
-ncr_key_t z1, z2;
-int ret, j;
-gnutls_datum g, p, params;
-gnutls_dh_params_t dhp;
-unsigned char y1[1024], y2[1024];
-ssize_t y1_size, y2_size;
-struct ncr_key_export kexport;
-struct __attribute__((packed)) {
-	struct ncr_key_derive f;
-	struct nlattr algo_head ALIGN_NL;
-	char algo[sizeof(NCR_DERIVE_DH)] ALIGN_NL;
-	struct nlattr flags_head ALIGN_NL;
-	uint32_t flags ALIGN_NL;
-	struct nlattr public_head ALIGN_NL;
-	unsigned char public[DATA_SIZE] ALIGN_NL;
-} kderive;
+	struct __attribute__ ((packed)) {
+		struct ncr_key_generate_pair f;
+		struct nlattr algo_head ALIGN_NL;
+		char algo[sizeof(ALG_DH)] ALIGN_NL;
+		struct nlattr flags_head ALIGN_NL;
+		uint32_t flags ALIGN_NL;
+		unsigned char buffer[DATA_SIZE] ALIGN_NL;
+	} kgen;
+	struct nlattr *nla;
+	ncr_key_t private1, public1, public2, private2;
+	ncr_key_t z1, z2;
+	int ret, j;
+	gnutls_datum g, p, params;
+	gnutls_dh_params_t dhp;
+	unsigned char y1[1024], y2[1024];
+	ssize_t y1_size, y2_size;
+	struct ncr_key_export kexport;
+	struct __attribute__ ((packed)) {
+		struct ncr_key_derive f;
+		struct nlattr algo_head ALIGN_NL;
+		char algo[sizeof(NCR_DERIVE_DH)] ALIGN_NL;
+		struct nlattr flags_head ALIGN_NL;
+		uint32_t flags ALIGN_NL;
+		struct nlattr public_head ALIGN_NL;
+		unsigned char public[DATA_SIZE] ALIGN_NL;
+	} kderive;
 
 	fprintf(stdout, "Tests on DH key exchange:");
 	fflush(stdout);
 
-	params.data = (void*)dh_params_txt;
-	params.size = sizeof(dh_params_txt)-1;
+	params.data = (void *)dh_params_txt;
+	params.size = sizeof(dh_params_txt) - 1;
 
 	ret = gnutls_dh_params_init(&dhp);
 	if (ret < 0) {
@@ -359,14 +374,14 @@ struct __attribute__((packed)) {
 		fprintf(stderr, "gnutls: %s\n", gnutls_strerror(ret));
 		return 1;
 	}
-	
+
 	ret = gnutls_dh_params_import_pkcs3(dhp, &params, GNUTLS_X509_FMT_PEM);
 	if (ret < 0) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
 		fprintf(stderr, "gnutls: %s\n", gnutls_strerror(ret));
 		return 1;
 	}
-	
+
 	ret = gnutls_dh_params_export_raw(dhp, &p, &g, NULL);
 	if (ret < 0) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -374,7 +389,7 @@ struct __attribute__((packed)) {
 		return 1;
 	}
 
-	for (j=0;j<100;j++) {
+	for (j = 0; j < 100; j++) {
 		/* generate a DH key */
 		private1 = ioctl(cfd, NCRIO_KEY_INIT);
 		if (private1 == -1) {
@@ -416,7 +431,7 @@ struct __attribute__((packed)) {
 			perror("ioctl(NCRIO_KEY_GENERATE_PAIR)");
 			return 1;
 		}
-		
+
 		/* generate another DH key */
 		private2 = ioctl(cfd, NCRIO_KEY_INIT);
 		if (private2 == -1) {
@@ -431,7 +446,7 @@ struct __attribute__((packed)) {
 			perror("ioctl(NCRIO_KEY_INIT)");
 			return 1;
 		}
-		
+
 		memset(&kgen.f, 0, sizeof(kgen.f));
 		kgen.f.private_key = private2;
 		kgen.f.public_key = public2;
@@ -484,7 +499,7 @@ struct __attribute__((packed)) {
 			perror("ioctl(NCRIO_KEY_EXPORT)");
 			return 1;
 		}
-		
+
 		/* z1=y1^x2 */
 		z1 = ioctl(cfd, NCRIO_KEY_INIT);
 		if (z1 == -1) {
@@ -506,7 +521,8 @@ struct __attribute__((packed)) {
 		kderive.public_head.nla_type = NCR_ATTR_DH_PUBLIC;
 		memcpy(kderive.public, y2, y2_size);
 		nla = (struct nlattr *)((char *)&kderive.public_head
-					+ NLA_ALIGN(kderive.public_head.nla_len));
+					+
+					NLA_ALIGN(kderive.public_head.nla_len));
 		kderive.f.input_size = (char *)nla - (char *)&kderive;
 		assert(kderive.f.input_size <= sizeof(kderive));
 
@@ -515,7 +531,7 @@ struct __attribute__((packed)) {
 			perror("ioctl(NCRIO_KEY_DERIVE)");
 			return 1;
 		}
-		
+
 		/* z2=y2^x1 */
 		z2 = ioctl(cfd, NCRIO_KEY_INIT);
 		if (z2 == -1) {
@@ -537,7 +553,8 @@ struct __attribute__((packed)) {
 		kderive.public_head.nla_type = NCR_ATTR_DH_PUBLIC;
 		memcpy(kderive.public, y1, y1_size);
 		nla = (struct nlattr *)((char *)&kderive.public_head
-					+ NLA_ALIGN(kderive.public_head.nla_len));
+					+
+					NLA_ALIGN(kderive.public_head.nla_len));
 		kderive.f.input_size = (char *)nla - (char *)&kderive;
 		assert(kderive.f.input_size <= sizeof(kderive));
 
@@ -546,7 +563,7 @@ struct __attribute__((packed)) {
 			perror("ioctl(NCRIO_KEY_DERIVE)");
 			return 1;
 		}
-		
+
 		/* z1==z2 */
 		memset(&kexport, 0, sizeof(kexport));
 		kexport.key = z1;
@@ -571,21 +588,23 @@ struct __attribute__((packed)) {
 			perror("ioctl(NCRIO_KEY_EXPORT)");
 			return 1;
 		}
-		
-		if (y1_size == 0 || y1_size != y2_size || memcmp(y1, y2, y1_size) != 0) {
+
+		if (y1_size == 0 || y1_size != y2_size
+		    || memcmp(y1, y2, y1_size) != 0) {
 			int i;
 
 			fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
-			fprintf(stderr, "Output in DH does not match (%d, %d)!\n", 
+			fprintf(stderr,
+				"Output in DH does not match (%d, %d)!\n",
 				(int)y1_size, (int)y2_size);
 
-			fprintf(stderr, "Key1[%d]: ", (int) y1_size);
-			for(i=0;i<y1_size;i++)
+			fprintf(stderr, "Key1[%d]: ", (int)y1_size);
+			for (i = 0; i < y1_size; i++)
 				fprintf(stderr, "%.2x:", y1[i]);
 			fprintf(stderr, "\n");
 
-			fprintf(stderr, "Key2[%d]: ", (int) y2_size);
-			for(i=0;i<y2_size;i++)
+			fprintf(stderr, "Key2[%d]: ", (int)y2_size);
+			for (i = 0; i < y2_size; i++)
 				fprintf(stderr, "%.2x:", y2[i]);
 			fprintf(stderr, "\n");
 
@@ -625,13 +644,12 @@ struct __attribute__((packed)) {
 
 /* check whether wrapping of long keys is not allowed with
  * shorted wrapping keys */
-static int
-test_ncr_wrap_key3(int cfd)
+static int test_ncr_wrap_key3(int cfd)
 {
 	int ret, i;
 	ncr_key_t key;
 	size_t data_size;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_import f;
 		struct nlattr id_head ALIGN_NL;
 		uint8_t id[2] ALIGN_NL;
@@ -642,19 +660,20 @@ test_ncr_wrap_key3(int cfd)
 		struct nlattr flags_head ALIGN_NL;
 		uint32_t flags ALIGN_NL;
 	} kimport;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_wrap f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(NCR_WALG_AES_RFC5649)] ALIGN_NL;
-	} kwrap;
-	struct __attribute__((packed)) {
+	}
+	kwrap;
+	struct __attribute__ ((packed)) {
 		struct ncr_key_unwrap f;
 		struct nlattr wrap_algo_head ALIGN_NL;
 		char wrap_algo[sizeof(NCR_WALG_AES_RFC5649)] ALIGN_NL;
 		struct nlattr flags_head ALIGN_NL;
 		uint32_t flags ALIGN_NL;
 	} kunwrap;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_generate_pair f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(ALG_RSA)] ALIGN_NL;
@@ -669,7 +688,7 @@ test_ncr_wrap_key3(int cfd)
 	 * the latter shouldn't because it has security level larger
 	 * then 128 bits (the size of the wrapping key).
 	 */
-	const int sizes[] = {1024, 3248, 5200};
+	const int sizes[] = { 1024, 3248, 5200 };
 
 	fprintf(stdout, "Tests on key wrapping (might take long): ");
 	fflush(stdout);
@@ -691,7 +710,8 @@ test_ncr_wrap_key3(int cfd)
 
 	if (geteuid() != 0) {
 		/* cannot test further */
-		fprintf(stdout, "\t(Wrapping test not completed. Run as root)\n");
+		fprintf(stdout,
+			"\t(Wrapping test not completed. Run as root)\n");
 		return 0;
 	}
 
@@ -705,7 +725,8 @@ test_ncr_wrap_key3(int cfd)
 	memset(&kimport.f, 0, sizeof(kimport.f));
 	kimport.f.input_size = sizeof(kimport);
 	kimport.f.key = key;
-	kimport.f.data = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";
+	kimport.f.data =
+	    "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";
 	kimport.f.data_size = 16;
 	kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
 	kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
@@ -719,19 +740,21 @@ test_ncr_wrap_key3(int cfd)
 	strcpy(kimport.algo, ALG_AES_CBC);
 	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
 	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags = NCR_KEY_FLAG_EXPORTABLE|NCR_KEY_FLAG_WRAPPING|NCR_KEY_FLAG_UNWRAPPING;
+	kimport.flags =
+	    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPING |
+	    NCR_KEY_FLAG_UNWRAPPING;
 
 	if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
 		perror("ioctl(NCRIO_KEY_IMPORT)");
 		return 1;
 	}
-	
-	for (i=0;i<sizeof(sizes)/sizeof(sizes[0]);i++) {
-	
+
+	for (i = 0; i < sizeof(sizes) / sizeof(sizes[0]); i++) {
+
 		fprintf(stdout, ".");
 		fflush(stdout);
-		
+
 		memset(&kgen.f, 0, sizeof(kgen.f));
 		kgen.f.input_size = sizeof(kgen);
 		kgen.f.private_key = privkey;
@@ -741,13 +764,14 @@ test_ncr_wrap_key3(int cfd)
 		strcpy(kgen.algo, ALG_RSA);
 		kgen.flags_head.nla_len = NLA_HDRLEN + sizeof(kgen.flags);
 		kgen.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-		kgen.flags = NCR_KEY_FLAG_EXPORTABLE|NCR_KEY_FLAG_WRAPPABLE;
+		kgen.flags = NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE;
 		kgen.bits_head.nla_len = NLA_HDRLEN + sizeof(kgen.bits);
 		kgen.bits_head.nla_type = NCR_ATTR_RSA_MODULUS_BITS;
 		kgen.bits = sizes[i];
 
 		if (ioctl(cfd, NCRIO_KEY_GENERATE_PAIR, &kgen)) {
-			fprintf(stderr, "Error[%d-%d]: %s:%d\n", i, sizes[i], __func__, __LINE__);
+			fprintf(stderr, "Error[%d-%d]: %s:%d\n", i, sizes[i],
+				__func__, __LINE__);
 			perror("ioctl(NCRIO_KEY_GENERATE_PAIR)");
 			return 1;
 		}
@@ -765,7 +789,8 @@ test_ncr_wrap_key3(int cfd)
 
 		ret = ioctl(cfd, NCRIO_KEY_WRAP, &kwrap);
 		if (ret < 0) {
-			fprintf(stderr, "Error[%d-%d]: %s:%d\n", i, sizes[i], __func__, __LINE__);
+			fprintf(stderr, "Error[%d-%d]: %s:%d\n", i, sizes[i],
+				__func__, __LINE__);
 			/* wrapping of public key should have been allowed! */
 			return 1;
 		}
@@ -783,14 +808,16 @@ test_ncr_wrap_key3(int cfd)
 
 		ret = ioctl(cfd, NCRIO_KEY_WRAP, &kwrap);
 		if (ret < 0 && i != 2) {
-			fprintf(stderr, "Error[%d-%d]: %s:%d\n", i, sizes[i], __func__, __LINE__);
+			fprintf(stderr, "Error[%d-%d]: %s:%d\n", i, sizes[i],
+				__func__, __LINE__);
 			/* wrapping should have been allowed */
 			return 1;
 		} else if (ret >= 0 && i == 2) {
-			fprintf(stderr, "Error[%d-%d]: %s:%d\n", i, sizes[i], __func__, __LINE__);
+			fprintf(stderr, "Error[%d-%d]: %s:%d\n", i, sizes[i],
+				__func__, __LINE__);
 			/* wrapping shouldn't have been allowed */
 			return 1;
-		}			
+		}
 
 		if (ret >= 0) {
 			data_size = ret;
@@ -803,35 +830,37 @@ test_ncr_wrap_key3(int cfd)
 			kunwrap.f.data = data;
 			kunwrap.f.data_size = data_size;
 			kunwrap.wrap_algo_head.nla_len
-				= NLA_HDRLEN + sizeof(kunwrap.wrap_algo);
+			    = NLA_HDRLEN + sizeof(kunwrap.wrap_algo);
 			kunwrap.wrap_algo_head.nla_type
-				= NCR_ATTR_WRAPPING_ALGORITHM;
+			    = NCR_ATTR_WRAPPING_ALGORITHM;
 			strcpy(kunwrap.wrap_algo, NCR_WALG_AES_RFC5649);
 			kunwrap.flags_head.nla_len
-			  = NLA_HDRLEN + sizeof(kunwrap.flags);
+			    = NLA_HDRLEN + sizeof(kunwrap.flags);
 			kunwrap.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
 			kunwrap.flags = 0;
 
 			ret = ioctl(cfd, NCRIO_KEY_UNWRAP, &kunwrap);
 			if (ret) {
-				fprintf(stderr, "Error[%d-%d]: %s:%d\n", i, sizes[i], __func__, __LINE__);
+				fprintf(stderr, "Error[%d-%d]: %s:%d\n", i,
+					sizes[i], __func__, __LINE__);
 				return 1;
-			}			
+			}
 		}
 		fprintf(stdout, "*");
 		fflush(stdout);
 
 	}
-	
+
 	fprintf(stdout, " Success\n");
 	return 0;
 }
 
 #define RSA_ENCRYPT_SIZE 32
 
-static int rsa_key_encrypt(int cfd, ncr_key_t privkey, ncr_key_t pubkey, int oaep)
+static int rsa_key_encrypt(int cfd, ncr_key_t privkey, ncr_key_t pubkey,
+			   int oaep)
 {
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_once f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(ALG_RSA)] ALIGN_NL;
@@ -850,7 +879,8 @@ static int rsa_key_encrypt(int cfd, ncr_key_t privkey, ncr_key_t pubkey, int oae
 	uint8_t vdata[RSA_ENCRYPT_SIZE];
 	size_t enc_size, dec_size;
 
-	fprintf(stdout, "Tests on RSA (%s) key encryption:", (oaep!=0)?"OAEP":"PKCS V1.5");
+	fprintf(stdout, "Tests on RSA (%s) key encryption:",
+		(oaep != 0) ? "OAEP" : "PKCS V1.5");
 	fflush(stdout);
 
 	memset(data, 0x3, sizeof(data));
@@ -875,7 +905,7 @@ static int rsa_key_encrypt(int cfd, ncr_key_t privkey, ncr_key_t pubkey, int oae
 	}
 	op.oaep_hash_head.nla_len = NLA_HDRLEN + sizeof(op.oaep_hash);
 	op.oaep_hash_head.nla_type = NCR_ATTR_RSA_OAEP_HASH_ALGORITHM;
-	strcpy(op.oaep_hash, SIGNATURE_HASH); /* Ignored if not using OAEP */
+	strcpy(op.oaep_hash, SIGNATURE_HASH);	/* Ignored if not using OAEP */
 	op.input_head.nla_len = NLA_HDRLEN + sizeof(op.input);
 	op.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
 	op.input.data = data;
@@ -911,7 +941,7 @@ static int rsa_key_encrypt(int cfd, ncr_key_t privkey, ncr_key_t pubkey, int oae
 	}
 	op.oaep_hash_head.nla_len = NLA_HDRLEN + sizeof(op.oaep_hash);
 	op.oaep_hash_head.nla_type = NCR_ATTR_RSA_OAEP_HASH_ALGORITHM;
-	strcpy(op.oaep_hash, SIGNATURE_HASH); /* Ignored if not using OAEP */
+	strcpy(op.oaep_hash, SIGNATURE_HASH);	/* Ignored if not using OAEP */
 	op.input_head.nla_len = NLA_HDRLEN + sizeof(op.input);
 	op.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
 	op.input.data = data;
@@ -927,7 +957,7 @@ static int rsa_key_encrypt(int cfd, ncr_key_t privkey, ncr_key_t pubkey, int oae
 		perror("ioctl(NCRIO_SESSION_ONCE)");
 		return 1;
 	}
-	
+
 	if (dec_size != sizeof(vdata)
 	    || memcmp(vdata, data, sizeof(vdata)) != 0) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -943,9 +973,10 @@ static int rsa_key_encrypt(int cfd, ncr_key_t privkey, ncr_key_t pubkey, int oae
 
 #define DATA_TO_SIGN 52
 
-static int rsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey, int pss)
+static int rsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey,
+			       int pss)
 {
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_once f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(ALG_RSA)] ALIGN_NL;
@@ -960,7 +991,7 @@ static int rsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey, int
 		struct nlattr signature_head ALIGN_NL;
 		struct ncr_session_output_buffer signature ALIGN_NL;
 	} ksign;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_once f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(ALG_RSA)] ALIGN_NL;
@@ -980,7 +1011,8 @@ static int rsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey, int
 	size_t sig_size;
 	int ret;
 
-	fprintf(stdout, "Tests on RSA (%s) key signature:", (pss!=0)?"PSS":"PKCS V1.5");
+	fprintf(stdout, "Tests on RSA (%s) key signature:",
+		(pss != 0) ? "PSS" : "PKCS V1.5");
 	fflush(stdout);
 
 	memset(data, 0x3, sizeof(data));
@@ -1065,7 +1097,7 @@ static int rsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey, int
 static int rsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 					   ncr_key_t pubkey, int pss)
 {
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_once f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(NCR_ALG_RSA_TRANSPARENT_HASH)] ALIGN_NL;
@@ -1080,7 +1112,7 @@ static int rsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 		struct nlattr signature_head ALIGN_NL;
 		struct ncr_session_output_buffer signature ALIGN_NL;
 	} ksign;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_once f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(NCR_ALG_RSA_TRANSPARENT_HASH)] ALIGN_NL;
@@ -1184,7 +1216,7 @@ static int rsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 
 static int dsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey)
 {
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_once f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(ALG_DSA)] ALIGN_NL;
@@ -1197,7 +1229,7 @@ static int dsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey)
 		struct nlattr signature_head ALIGN_NL;
 		struct ncr_session_output_buffer signature ALIGN_NL;
 	} ksign;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_once f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(ALG_DSA)] ALIGN_NL;
@@ -1292,7 +1324,7 @@ static int dsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey)
 static int dsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 					   ncr_key_t pubkey)
 {
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_once f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(NCR_ALG_DSA_TRANSPARENT_HASH)] ALIGN_NL;
@@ -1305,7 +1337,7 @@ static int dsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 		struct nlattr signature_head ALIGN_NL;
 		struct ncr_session_output_buffer signature ALIGN_NL;
 	} ksign;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_once f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(NCR_ALG_DSA_TRANSPARENT_HASH)] ALIGN_NL;
@@ -1399,7 +1431,7 @@ static int dsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 static int test_ncr_rsa(int cfd)
 {
 	int ret;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_generate_pair f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(ALG_RSA)] ALIGN_NL;
@@ -1440,7 +1472,9 @@ static int test_ncr_rsa(int cfd)
 	strcpy(kgen.algo, ALG_RSA);
 	kgen.flags_head.nla_len = NLA_HDRLEN + sizeof(kgen.flags);
 	kgen.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kgen.flags = NCR_KEY_FLAG_EXPORTABLE|NCR_KEY_FLAG_WRAPPABLE|NCR_KEY_FLAG_ALLOW_TRANSPARENT_HASH;
+	kgen.flags =
+	    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE |
+	    NCR_KEY_FLAG_ALLOW_TRANSPARENT_HASH;
 	kgen.bits_head.nla_len = NLA_HDRLEN + sizeof(kgen.bits);
 	kgen.bits_head.nla_type = NCR_ATTR_RSA_MODULUS_BITS;
 	kgen.bits = 1024;
@@ -1470,7 +1504,7 @@ static int test_ncr_rsa(int cfd)
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
 		return 1;
 	}
-	
+
 	/* export the public key */
 
 	memset(data, 0, sizeof(data));
@@ -1537,7 +1571,7 @@ static int test_ncr_rsa(int cfd)
 static int test_ncr_dsa(int cfd)
 {
 	int ret;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_generate_pair f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(ALG_DSA)] ALIGN_NL;
@@ -1580,7 +1614,9 @@ static int test_ncr_dsa(int cfd)
 	strcpy(kgen.algo, ALG_DSA);
 	kgen.flags_head.nla_len = NLA_HDRLEN + sizeof(kgen.flags);
 	kgen.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kgen.flags = NCR_KEY_FLAG_EXPORTABLE|NCR_KEY_FLAG_WRAPPABLE|NCR_KEY_FLAG_ALLOW_TRANSPARENT_HASH;
+	kgen.flags =
+	    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE |
+	    NCR_KEY_FLAG_ALLOW_TRANSPARENT_HASH;
 	kgen.q_bits_head.nla_len = NLA_HDRLEN + sizeof(kgen.q_bits);
 	kgen.q_bits_head.nla_type = NCR_ATTR_DSA_Q_BITS;
 	kgen.q_bits = 160;
@@ -1612,7 +1648,7 @@ static int test_ncr_dsa(int cfd)
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
 		return 1;
 	}
-	
+
 	/* export the public key */
 
 	memset(data, 0, sizeof(data));
@@ -1652,9 +1688,7 @@ static int test_ncr_dsa(int cfd)
 
 }
 
-
-int
-main()
+int main()
 {
 	int fd = -1;
 
@@ -1677,7 +1711,7 @@ main()
 
 	if (test_ncr_dsa(fd))
 		return 1;
-		
+
 	if (test_ncr_wrap_key3(fd))
 		return 1;
 
diff --git a/examples/shm/aes.h b/examples/shm/aes.h
index ee13dcb..53e7863 100644
--- a/examples/shm/aes.h
+++ b/examples/shm/aes.h
@@ -31,10 +31,10 @@ extern const uint32_t crypto_fl_tab[4][256];
 extern const uint32_t crypto_it_tab[4][256];
 extern const uint32_t crypto_il_tab[4][256];
 
-int crypto_aes_expand_key(struct crypto_aes_ctx *ctx, const uint8_t *in_key,
-		unsigned int key_len);
+int crypto_aes_expand_key(struct crypto_aes_ctx *ctx, const uint8_t * in_key,
+			  unsigned int key_len);
 
 int crypto_cbc_encrypt(const struct crypto_aes_ctx *ctx,
-	void* src, int nbytes, void* dst, void* iv);
+		       void *src, int nbytes, void *dst, void *iv);
 
 #endif
diff --git a/examples/shm/aes_cbc.c b/examples/shm/aes_cbc.c
index a8d4bfc..dda988e 100644
--- a/examples/shm/aes_cbc.c
+++ b/examples/shm/aes_cbc.c
@@ -60,7 +60,7 @@
 
 static inline __u32 ror32(__u32 word, unsigned int shift)
 {
-        return (word >> shift) | (word << (32 - shift));
+	return (word >> shift) | (word << (32 - shift));
 }
 
 static inline uint8_t byte(const uint32_t x, const unsigned n)
@@ -72,1058 +72,1058 @@ static const uint32_t rco_tab[10] = { 1, 2, 4, 8, 16, 32, 64, 128, 27, 54 };
 
 const uint32_t crypto_ft_tab[4][256] = {
 	{
-		0xa56363c6, 0x847c7cf8, 0x997777ee, 0x8d7b7bf6,
-		0x0df2f2ff, 0xbd6b6bd6, 0xb16f6fde, 0x54c5c591,
-		0x50303060, 0x03010102, 0xa96767ce, 0x7d2b2b56,
-		0x19fefee7, 0x62d7d7b5, 0xe6abab4d, 0x9a7676ec,
-		0x45caca8f, 0x9d82821f, 0x40c9c989, 0x877d7dfa,
-		0x15fafaef, 0xeb5959b2, 0xc947478e, 0x0bf0f0fb,
-		0xecadad41, 0x67d4d4b3, 0xfda2a25f, 0xeaafaf45,
-		0xbf9c9c23, 0xf7a4a453, 0x967272e4, 0x5bc0c09b,
-		0xc2b7b775, 0x1cfdfde1, 0xae93933d, 0x6a26264c,
-		0x5a36366c, 0x413f3f7e, 0x02f7f7f5, 0x4fcccc83,
-		0x5c343468, 0xf4a5a551, 0x34e5e5d1, 0x08f1f1f9,
-		0x937171e2, 0x73d8d8ab, 0x53313162, 0x3f15152a,
-		0x0c040408, 0x52c7c795, 0x65232346, 0x5ec3c39d,
-		0x28181830, 0xa1969637, 0x0f05050a, 0xb59a9a2f,
-		0x0907070e, 0x36121224, 0x9b80801b, 0x3de2e2df,
-		0x26ebebcd, 0x6927274e, 0xcdb2b27f, 0x9f7575ea,
-		0x1b090912, 0x9e83831d, 0x742c2c58, 0x2e1a1a34,
-		0x2d1b1b36, 0xb26e6edc, 0xee5a5ab4, 0xfba0a05b,
-		0xf65252a4, 0x4d3b3b76, 0x61d6d6b7, 0xceb3b37d,
-		0x7b292952, 0x3ee3e3dd, 0x712f2f5e, 0x97848413,
-		0xf55353a6, 0x68d1d1b9, 0x00000000, 0x2cededc1,
-		0x60202040, 0x1ffcfce3, 0xc8b1b179, 0xed5b5bb6,
-		0xbe6a6ad4, 0x46cbcb8d, 0xd9bebe67, 0x4b393972,
-		0xde4a4a94, 0xd44c4c98, 0xe85858b0, 0x4acfcf85,
-		0x6bd0d0bb, 0x2aefefc5, 0xe5aaaa4f, 0x16fbfbed,
-		0xc5434386, 0xd74d4d9a, 0x55333366, 0x94858511,
-		0xcf45458a, 0x10f9f9e9, 0x06020204, 0x817f7ffe,
-		0xf05050a0, 0x443c3c78, 0xba9f9f25, 0xe3a8a84b,
-		0xf35151a2, 0xfea3a35d, 0xc0404080, 0x8a8f8f05,
-		0xad92923f, 0xbc9d9d21, 0x48383870, 0x04f5f5f1,
-		0xdfbcbc63, 0xc1b6b677, 0x75dadaaf, 0x63212142,
-		0x30101020, 0x1affffe5, 0x0ef3f3fd, 0x6dd2d2bf,
-		0x4ccdcd81, 0x140c0c18, 0x35131326, 0x2fececc3,
-		0xe15f5fbe, 0xa2979735, 0xcc444488, 0x3917172e,
-		0x57c4c493, 0xf2a7a755, 0x827e7efc, 0x473d3d7a,
-		0xac6464c8, 0xe75d5dba, 0x2b191932, 0x957373e6,
-		0xa06060c0, 0x98818119, 0xd14f4f9e, 0x7fdcdca3,
-		0x66222244, 0x7e2a2a54, 0xab90903b, 0x8388880b,
-		0xca46468c, 0x29eeeec7, 0xd3b8b86b, 0x3c141428,
-		0x79dedea7, 0xe25e5ebc, 0x1d0b0b16, 0x76dbdbad,
-		0x3be0e0db, 0x56323264, 0x4e3a3a74, 0x1e0a0a14,
-		0xdb494992, 0x0a06060c, 0x6c242448, 0xe45c5cb8,
-		0x5dc2c29f, 0x6ed3d3bd, 0xefacac43, 0xa66262c4,
-		0xa8919139, 0xa4959531, 0x37e4e4d3, 0x8b7979f2,
-		0x32e7e7d5, 0x43c8c88b, 0x5937376e, 0xb76d6dda,
-		0x8c8d8d01, 0x64d5d5b1, 0xd24e4e9c, 0xe0a9a949,
-		0xb46c6cd8, 0xfa5656ac, 0x07f4f4f3, 0x25eaeacf,
-		0xaf6565ca, 0x8e7a7af4, 0xe9aeae47, 0x18080810,
-		0xd5baba6f, 0x887878f0, 0x6f25254a, 0x722e2e5c,
-		0x241c1c38, 0xf1a6a657, 0xc7b4b473, 0x51c6c697,
-		0x23e8e8cb, 0x7cdddda1, 0x9c7474e8, 0x211f1f3e,
-		0xdd4b4b96, 0xdcbdbd61, 0x868b8b0d, 0x858a8a0f,
-		0x907070e0, 0x423e3e7c, 0xc4b5b571, 0xaa6666cc,
-		0xd8484890, 0x05030306, 0x01f6f6f7, 0x120e0e1c,
-		0xa36161c2, 0x5f35356a, 0xf95757ae, 0xd0b9b969,
-		0x91868617, 0x58c1c199, 0x271d1d3a, 0xb99e9e27,
-		0x38e1e1d9, 0x13f8f8eb, 0xb398982b, 0x33111122,
-		0xbb6969d2, 0x70d9d9a9, 0x898e8e07, 0xa7949433,
-		0xb69b9b2d, 0x221e1e3c, 0x92878715, 0x20e9e9c9,
-		0x49cece87, 0xff5555aa, 0x78282850, 0x7adfdfa5,
-		0x8f8c8c03, 0xf8a1a159, 0x80898909, 0x170d0d1a,
-		0xdabfbf65, 0x31e6e6d7, 0xc6424284, 0xb86868d0,
-		0xc3414182, 0xb0999929, 0x772d2d5a, 0x110f0f1e,
-		0xcbb0b07b, 0xfc5454a8, 0xd6bbbb6d, 0x3a16162c,
-	}, {
-		0x6363c6a5, 0x7c7cf884, 0x7777ee99, 0x7b7bf68d,
-		0xf2f2ff0d, 0x6b6bd6bd, 0x6f6fdeb1, 0xc5c59154,
-		0x30306050, 0x01010203, 0x6767cea9, 0x2b2b567d,
-		0xfefee719, 0xd7d7b562, 0xabab4de6, 0x7676ec9a,
-		0xcaca8f45, 0x82821f9d, 0xc9c98940, 0x7d7dfa87,
-		0xfafaef15, 0x5959b2eb, 0x47478ec9, 0xf0f0fb0b,
-		0xadad41ec, 0xd4d4b367, 0xa2a25ffd, 0xafaf45ea,
-		0x9c9c23bf, 0xa4a453f7, 0x7272e496, 0xc0c09b5b,
-		0xb7b775c2, 0xfdfde11c, 0x93933dae, 0x26264c6a,
-		0x36366c5a, 0x3f3f7e41, 0xf7f7f502, 0xcccc834f,
-		0x3434685c, 0xa5a551f4, 0xe5e5d134, 0xf1f1f908,
-		0x7171e293, 0xd8d8ab73, 0x31316253, 0x15152a3f,
-		0x0404080c, 0xc7c79552, 0x23234665, 0xc3c39d5e,
-		0x18183028, 0x969637a1, 0x05050a0f, 0x9a9a2fb5,
-		0x07070e09, 0x12122436, 0x80801b9b, 0xe2e2df3d,
-		0xebebcd26, 0x27274e69, 0xb2b27fcd, 0x7575ea9f,
-		0x0909121b, 0x83831d9e, 0x2c2c5874, 0x1a1a342e,
-		0x1b1b362d, 0x6e6edcb2, 0x5a5ab4ee, 0xa0a05bfb,
-		0x5252a4f6, 0x3b3b764d, 0xd6d6b761, 0xb3b37dce,
-		0x2929527b, 0xe3e3dd3e, 0x2f2f5e71, 0x84841397,
-		0x5353a6f5, 0xd1d1b968, 0x00000000, 0xededc12c,
-		0x20204060, 0xfcfce31f, 0xb1b179c8, 0x5b5bb6ed,
-		0x6a6ad4be, 0xcbcb8d46, 0xbebe67d9, 0x3939724b,
-		0x4a4a94de, 0x4c4c98d4, 0x5858b0e8, 0xcfcf854a,
-		0xd0d0bb6b, 0xefefc52a, 0xaaaa4fe5, 0xfbfbed16,
-		0x434386c5, 0x4d4d9ad7, 0x33336655, 0x85851194,
-		0x45458acf, 0xf9f9e910, 0x02020406, 0x7f7ffe81,
-		0x5050a0f0, 0x3c3c7844, 0x9f9f25ba, 0xa8a84be3,
-		0x5151a2f3, 0xa3a35dfe, 0x404080c0, 0x8f8f058a,
-		0x92923fad, 0x9d9d21bc, 0x38387048, 0xf5f5f104,
-		0xbcbc63df, 0xb6b677c1, 0xdadaaf75, 0x21214263,
-		0x10102030, 0xffffe51a, 0xf3f3fd0e, 0xd2d2bf6d,
-		0xcdcd814c, 0x0c0c1814, 0x13132635, 0xececc32f,
-		0x5f5fbee1, 0x979735a2, 0x444488cc, 0x17172e39,
-		0xc4c49357, 0xa7a755f2, 0x7e7efc82, 0x3d3d7a47,
-		0x6464c8ac, 0x5d5dbae7, 0x1919322b, 0x7373e695,
-		0x6060c0a0, 0x81811998, 0x4f4f9ed1, 0xdcdca37f,
-		0x22224466, 0x2a2a547e, 0x90903bab, 0x88880b83,
-		0x46468cca, 0xeeeec729, 0xb8b86bd3, 0x1414283c,
-		0xdedea779, 0x5e5ebce2, 0x0b0b161d, 0xdbdbad76,
-		0xe0e0db3b, 0x32326456, 0x3a3a744e, 0x0a0a141e,
-		0x494992db, 0x06060c0a, 0x2424486c, 0x5c5cb8e4,
-		0xc2c29f5d, 0xd3d3bd6e, 0xacac43ef, 0x6262c4a6,
-		0x919139a8, 0x959531a4, 0xe4e4d337, 0x7979f28b,
-		0xe7e7d532, 0xc8c88b43, 0x37376e59, 0x6d6ddab7,
-		0x8d8d018c, 0xd5d5b164, 0x4e4e9cd2, 0xa9a949e0,
-		0x6c6cd8b4, 0x5656acfa, 0xf4f4f307, 0xeaeacf25,
-		0x6565caaf, 0x7a7af48e, 0xaeae47e9, 0x08081018,
-		0xbaba6fd5, 0x7878f088, 0x25254a6f, 0x2e2e5c72,
-		0x1c1c3824, 0xa6a657f1, 0xb4b473c7, 0xc6c69751,
-		0xe8e8cb23, 0xdddda17c, 0x7474e89c, 0x1f1f3e21,
-		0x4b4b96dd, 0xbdbd61dc, 0x8b8b0d86, 0x8a8a0f85,
-		0x7070e090, 0x3e3e7c42, 0xb5b571c4, 0x6666ccaa,
-		0x484890d8, 0x03030605, 0xf6f6f701, 0x0e0e1c12,
-		0x6161c2a3, 0x35356a5f, 0x5757aef9, 0xb9b969d0,
-		0x86861791, 0xc1c19958, 0x1d1d3a27, 0x9e9e27b9,
-		0xe1e1d938, 0xf8f8eb13, 0x98982bb3, 0x11112233,
-		0x6969d2bb, 0xd9d9a970, 0x8e8e0789, 0x949433a7,
-		0x9b9b2db6, 0x1e1e3c22, 0x87871592, 0xe9e9c920,
-		0xcece8749, 0x5555aaff, 0x28285078, 0xdfdfa57a,
-		0x8c8c038f, 0xa1a159f8, 0x89890980, 0x0d0d1a17,
-		0xbfbf65da, 0xe6e6d731, 0x424284c6, 0x6868d0b8,
-		0x414182c3, 0x999929b0, 0x2d2d5a77, 0x0f0f1e11,
-		0xb0b07bcb, 0x5454a8fc, 0xbbbb6dd6, 0x16162c3a,
-	}, {
-		0x63c6a563, 0x7cf8847c, 0x77ee9977, 0x7bf68d7b,
-		0xf2ff0df2, 0x6bd6bd6b, 0x6fdeb16f, 0xc59154c5,
-		0x30605030, 0x01020301, 0x67cea967, 0x2b567d2b,
-		0xfee719fe, 0xd7b562d7, 0xab4de6ab, 0x76ec9a76,
-		0xca8f45ca, 0x821f9d82, 0xc98940c9, 0x7dfa877d,
-		0xfaef15fa, 0x59b2eb59, 0x478ec947, 0xf0fb0bf0,
-		0xad41ecad, 0xd4b367d4, 0xa25ffda2, 0xaf45eaaf,
-		0x9c23bf9c, 0xa453f7a4, 0x72e49672, 0xc09b5bc0,
-		0xb775c2b7, 0xfde11cfd, 0x933dae93, 0x264c6a26,
-		0x366c5a36, 0x3f7e413f, 0xf7f502f7, 0xcc834fcc,
-		0x34685c34, 0xa551f4a5, 0xe5d134e5, 0xf1f908f1,
-		0x71e29371, 0xd8ab73d8, 0x31625331, 0x152a3f15,
-		0x04080c04, 0xc79552c7, 0x23466523, 0xc39d5ec3,
-		0x18302818, 0x9637a196, 0x050a0f05, 0x9a2fb59a,
-		0x070e0907, 0x12243612, 0x801b9b80, 0xe2df3de2,
-		0xebcd26eb, 0x274e6927, 0xb27fcdb2, 0x75ea9f75,
-		0x09121b09, 0x831d9e83, 0x2c58742c, 0x1a342e1a,
-		0x1b362d1b, 0x6edcb26e, 0x5ab4ee5a, 0xa05bfba0,
-		0x52a4f652, 0x3b764d3b, 0xd6b761d6, 0xb37dceb3,
-		0x29527b29, 0xe3dd3ee3, 0x2f5e712f, 0x84139784,
-		0x53a6f553, 0xd1b968d1, 0x00000000, 0xedc12ced,
-		0x20406020, 0xfce31ffc, 0xb179c8b1, 0x5bb6ed5b,
-		0x6ad4be6a, 0xcb8d46cb, 0xbe67d9be, 0x39724b39,
-		0x4a94de4a, 0x4c98d44c, 0x58b0e858, 0xcf854acf,
-		0xd0bb6bd0, 0xefc52aef, 0xaa4fe5aa, 0xfbed16fb,
-		0x4386c543, 0x4d9ad74d, 0x33665533, 0x85119485,
-		0x458acf45, 0xf9e910f9, 0x02040602, 0x7ffe817f,
-		0x50a0f050, 0x3c78443c, 0x9f25ba9f, 0xa84be3a8,
-		0x51a2f351, 0xa35dfea3, 0x4080c040, 0x8f058a8f,
-		0x923fad92, 0x9d21bc9d, 0x38704838, 0xf5f104f5,
-		0xbc63dfbc, 0xb677c1b6, 0xdaaf75da, 0x21426321,
-		0x10203010, 0xffe51aff, 0xf3fd0ef3, 0xd2bf6dd2,
-		0xcd814ccd, 0x0c18140c, 0x13263513, 0xecc32fec,
-		0x5fbee15f, 0x9735a297, 0x4488cc44, 0x172e3917,
-		0xc49357c4, 0xa755f2a7, 0x7efc827e, 0x3d7a473d,
-		0x64c8ac64, 0x5dbae75d, 0x19322b19, 0x73e69573,
-		0x60c0a060, 0x81199881, 0x4f9ed14f, 0xdca37fdc,
-		0x22446622, 0x2a547e2a, 0x903bab90, 0x880b8388,
-		0x468cca46, 0xeec729ee, 0xb86bd3b8, 0x14283c14,
-		0xdea779de, 0x5ebce25e, 0x0b161d0b, 0xdbad76db,
-		0xe0db3be0, 0x32645632, 0x3a744e3a, 0x0a141e0a,
-		0x4992db49, 0x060c0a06, 0x24486c24, 0x5cb8e45c,
-		0xc29f5dc2, 0xd3bd6ed3, 0xac43efac, 0x62c4a662,
-		0x9139a891, 0x9531a495, 0xe4d337e4, 0x79f28b79,
-		0xe7d532e7, 0xc88b43c8, 0x376e5937, 0x6ddab76d,
-		0x8d018c8d, 0xd5b164d5, 0x4e9cd24e, 0xa949e0a9,
-		0x6cd8b46c, 0x56acfa56, 0xf4f307f4, 0xeacf25ea,
-		0x65caaf65, 0x7af48e7a, 0xae47e9ae, 0x08101808,
-		0xba6fd5ba, 0x78f08878, 0x254a6f25, 0x2e5c722e,
-		0x1c38241c, 0xa657f1a6, 0xb473c7b4, 0xc69751c6,
-		0xe8cb23e8, 0xdda17cdd, 0x74e89c74, 0x1f3e211f,
-		0x4b96dd4b, 0xbd61dcbd, 0x8b0d868b, 0x8a0f858a,
-		0x70e09070, 0x3e7c423e, 0xb571c4b5, 0x66ccaa66,
-		0x4890d848, 0x03060503, 0xf6f701f6, 0x0e1c120e,
-		0x61c2a361, 0x356a5f35, 0x57aef957, 0xb969d0b9,
-		0x86179186, 0xc19958c1, 0x1d3a271d, 0x9e27b99e,
-		0xe1d938e1, 0xf8eb13f8, 0x982bb398, 0x11223311,
-		0x69d2bb69, 0xd9a970d9, 0x8e07898e, 0x9433a794,
-		0x9b2db69b, 0x1e3c221e, 0x87159287, 0xe9c920e9,
-		0xce8749ce, 0x55aaff55, 0x28507828, 0xdfa57adf,
-		0x8c038f8c, 0xa159f8a1, 0x89098089, 0x0d1a170d,
-		0xbf65dabf, 0xe6d731e6, 0x4284c642, 0x68d0b868,
-		0x4182c341, 0x9929b099, 0x2d5a772d, 0x0f1e110f,
-		0xb07bcbb0, 0x54a8fc54, 0xbb6dd6bb, 0x162c3a16,
-	}, {
-		0xc6a56363, 0xf8847c7c, 0xee997777, 0xf68d7b7b,
-		0xff0df2f2, 0xd6bd6b6b, 0xdeb16f6f, 0x9154c5c5,
-		0x60503030, 0x02030101, 0xcea96767, 0x567d2b2b,
-		0xe719fefe, 0xb562d7d7, 0x4de6abab, 0xec9a7676,
-		0x8f45caca, 0x1f9d8282, 0x8940c9c9, 0xfa877d7d,
-		0xef15fafa, 0xb2eb5959, 0x8ec94747, 0xfb0bf0f0,
-		0x41ecadad, 0xb367d4d4, 0x5ffda2a2, 0x45eaafaf,
-		0x23bf9c9c, 0x53f7a4a4, 0xe4967272, 0x9b5bc0c0,
-		0x75c2b7b7, 0xe11cfdfd, 0x3dae9393, 0x4c6a2626,
-		0x6c5a3636, 0x7e413f3f, 0xf502f7f7, 0x834fcccc,
-		0x685c3434, 0x51f4a5a5, 0xd134e5e5, 0xf908f1f1,
-		0xe2937171, 0xab73d8d8, 0x62533131, 0x2a3f1515,
-		0x080c0404, 0x9552c7c7, 0x46652323, 0x9d5ec3c3,
-		0x30281818, 0x37a19696, 0x0a0f0505, 0x2fb59a9a,
-		0x0e090707, 0x24361212, 0x1b9b8080, 0xdf3de2e2,
-		0xcd26ebeb, 0x4e692727, 0x7fcdb2b2, 0xea9f7575,
-		0x121b0909, 0x1d9e8383, 0x58742c2c, 0x342e1a1a,
-		0x362d1b1b, 0xdcb26e6e, 0xb4ee5a5a, 0x5bfba0a0,
-		0xa4f65252, 0x764d3b3b, 0xb761d6d6, 0x7dceb3b3,
-		0x527b2929, 0xdd3ee3e3, 0x5e712f2f, 0x13978484,
-		0xa6f55353, 0xb968d1d1, 0x00000000, 0xc12ceded,
-		0x40602020, 0xe31ffcfc, 0x79c8b1b1, 0xb6ed5b5b,
-		0xd4be6a6a, 0x8d46cbcb, 0x67d9bebe, 0x724b3939,
-		0x94de4a4a, 0x98d44c4c, 0xb0e85858, 0x854acfcf,
-		0xbb6bd0d0, 0xc52aefef, 0x4fe5aaaa, 0xed16fbfb,
-		0x86c54343, 0x9ad74d4d, 0x66553333, 0x11948585,
-		0x8acf4545, 0xe910f9f9, 0x04060202, 0xfe817f7f,
-		0xa0f05050, 0x78443c3c, 0x25ba9f9f, 0x4be3a8a8,
-		0xa2f35151, 0x5dfea3a3, 0x80c04040, 0x058a8f8f,
-		0x3fad9292, 0x21bc9d9d, 0x70483838, 0xf104f5f5,
-		0x63dfbcbc, 0x77c1b6b6, 0xaf75dada, 0x42632121,
-		0x20301010, 0xe51affff, 0xfd0ef3f3, 0xbf6dd2d2,
-		0x814ccdcd, 0x18140c0c, 0x26351313, 0xc32fecec,
-		0xbee15f5f, 0x35a29797, 0x88cc4444, 0x2e391717,
-		0x9357c4c4, 0x55f2a7a7, 0xfc827e7e, 0x7a473d3d,
-		0xc8ac6464, 0xbae75d5d, 0x322b1919, 0xe6957373,
-		0xc0a06060, 0x19988181, 0x9ed14f4f, 0xa37fdcdc,
-		0x44662222, 0x547e2a2a, 0x3bab9090, 0x0b838888,
-		0x8cca4646, 0xc729eeee, 0x6bd3b8b8, 0x283c1414,
-		0xa779dede, 0xbce25e5e, 0x161d0b0b, 0xad76dbdb,
-		0xdb3be0e0, 0x64563232, 0x744e3a3a, 0x141e0a0a,
-		0x92db4949, 0x0c0a0606, 0x486c2424, 0xb8e45c5c,
-		0x9f5dc2c2, 0xbd6ed3d3, 0x43efacac, 0xc4a66262,
-		0x39a89191, 0x31a49595, 0xd337e4e4, 0xf28b7979,
-		0xd532e7e7, 0x8b43c8c8, 0x6e593737, 0xdab76d6d,
-		0x018c8d8d, 0xb164d5d5, 0x9cd24e4e, 0x49e0a9a9,
-		0xd8b46c6c, 0xacfa5656, 0xf307f4f4, 0xcf25eaea,
-		0xcaaf6565, 0xf48e7a7a, 0x47e9aeae, 0x10180808,
-		0x6fd5baba, 0xf0887878, 0x4a6f2525, 0x5c722e2e,
-		0x38241c1c, 0x57f1a6a6, 0x73c7b4b4, 0x9751c6c6,
-		0xcb23e8e8, 0xa17cdddd, 0xe89c7474, 0x3e211f1f,
-		0x96dd4b4b, 0x61dcbdbd, 0x0d868b8b, 0x0f858a8a,
-		0xe0907070, 0x7c423e3e, 0x71c4b5b5, 0xccaa6666,
-		0x90d84848, 0x06050303, 0xf701f6f6, 0x1c120e0e,
-		0xc2a36161, 0x6a5f3535, 0xaef95757, 0x69d0b9b9,
-		0x17918686, 0x9958c1c1, 0x3a271d1d, 0x27b99e9e,
-		0xd938e1e1, 0xeb13f8f8, 0x2bb39898, 0x22331111,
-		0xd2bb6969, 0xa970d9d9, 0x07898e8e, 0x33a79494,
-		0x2db69b9b, 0x3c221e1e, 0x15928787, 0xc920e9e9,
-		0x8749cece, 0xaaff5555, 0x50782828, 0xa57adfdf,
-		0x038f8c8c, 0x59f8a1a1, 0x09808989, 0x1a170d0d,
-		0x65dabfbf, 0xd731e6e6, 0x84c64242, 0xd0b86868,
-		0x82c34141, 0x29b09999, 0x5a772d2d, 0x1e110f0f,
-		0x7bcbb0b0, 0xa8fc5454, 0x6dd6bbbb, 0x2c3a1616,
-	}
+	 0xa56363c6, 0x847c7cf8, 0x997777ee, 0x8d7b7bf6,
+	 0x0df2f2ff, 0xbd6b6bd6, 0xb16f6fde, 0x54c5c591,
+	 0x50303060, 0x03010102, 0xa96767ce, 0x7d2b2b56,
+	 0x19fefee7, 0x62d7d7b5, 0xe6abab4d, 0x9a7676ec,
+	 0x45caca8f, 0x9d82821f, 0x40c9c989, 0x877d7dfa,
+	 0x15fafaef, 0xeb5959b2, 0xc947478e, 0x0bf0f0fb,
+	 0xecadad41, 0x67d4d4b3, 0xfda2a25f, 0xeaafaf45,
+	 0xbf9c9c23, 0xf7a4a453, 0x967272e4, 0x5bc0c09b,
+	 0xc2b7b775, 0x1cfdfde1, 0xae93933d, 0x6a26264c,
+	 0x5a36366c, 0x413f3f7e, 0x02f7f7f5, 0x4fcccc83,
+	 0x5c343468, 0xf4a5a551, 0x34e5e5d1, 0x08f1f1f9,
+	 0x937171e2, 0x73d8d8ab, 0x53313162, 0x3f15152a,
+	 0x0c040408, 0x52c7c795, 0x65232346, 0x5ec3c39d,
+	 0x28181830, 0xa1969637, 0x0f05050a, 0xb59a9a2f,
+	 0x0907070e, 0x36121224, 0x9b80801b, 0x3de2e2df,
+	 0x26ebebcd, 0x6927274e, 0xcdb2b27f, 0x9f7575ea,
+	 0x1b090912, 0x9e83831d, 0x742c2c58, 0x2e1a1a34,
+	 0x2d1b1b36, 0xb26e6edc, 0xee5a5ab4, 0xfba0a05b,
+	 0xf65252a4, 0x4d3b3b76, 0x61d6d6b7, 0xceb3b37d,
+	 0x7b292952, 0x3ee3e3dd, 0x712f2f5e, 0x97848413,
+	 0xf55353a6, 0x68d1d1b9, 0x00000000, 0x2cededc1,
+	 0x60202040, 0x1ffcfce3, 0xc8b1b179, 0xed5b5bb6,
+	 0xbe6a6ad4, 0x46cbcb8d, 0xd9bebe67, 0x4b393972,
+	 0xde4a4a94, 0xd44c4c98, 0xe85858b0, 0x4acfcf85,
+	 0x6bd0d0bb, 0x2aefefc5, 0xe5aaaa4f, 0x16fbfbed,
+	 0xc5434386, 0xd74d4d9a, 0x55333366, 0x94858511,
+	 0xcf45458a, 0x10f9f9e9, 0x06020204, 0x817f7ffe,
+	 0xf05050a0, 0x443c3c78, 0xba9f9f25, 0xe3a8a84b,
+	 0xf35151a2, 0xfea3a35d, 0xc0404080, 0x8a8f8f05,
+	 0xad92923f, 0xbc9d9d21, 0x48383870, 0x04f5f5f1,
+	 0xdfbcbc63, 0xc1b6b677, 0x75dadaaf, 0x63212142,
+	 0x30101020, 0x1affffe5, 0x0ef3f3fd, 0x6dd2d2bf,
+	 0x4ccdcd81, 0x140c0c18, 0x35131326, 0x2fececc3,
+	 0xe15f5fbe, 0xa2979735, 0xcc444488, 0x3917172e,
+	 0x57c4c493, 0xf2a7a755, 0x827e7efc, 0x473d3d7a,
+	 0xac6464c8, 0xe75d5dba, 0x2b191932, 0x957373e6,
+	 0xa06060c0, 0x98818119, 0xd14f4f9e, 0x7fdcdca3,
+	 0x66222244, 0x7e2a2a54, 0xab90903b, 0x8388880b,
+	 0xca46468c, 0x29eeeec7, 0xd3b8b86b, 0x3c141428,
+	 0x79dedea7, 0xe25e5ebc, 0x1d0b0b16, 0x76dbdbad,
+	 0x3be0e0db, 0x56323264, 0x4e3a3a74, 0x1e0a0a14,
+	 0xdb494992, 0x0a06060c, 0x6c242448, 0xe45c5cb8,
+	 0x5dc2c29f, 0x6ed3d3bd, 0xefacac43, 0xa66262c4,
+	 0xa8919139, 0xa4959531, 0x37e4e4d3, 0x8b7979f2,
+	 0x32e7e7d5, 0x43c8c88b, 0x5937376e, 0xb76d6dda,
+	 0x8c8d8d01, 0x64d5d5b1, 0xd24e4e9c, 0xe0a9a949,
+	 0xb46c6cd8, 0xfa5656ac, 0x07f4f4f3, 0x25eaeacf,
+	 0xaf6565ca, 0x8e7a7af4, 0xe9aeae47, 0x18080810,
+	 0xd5baba6f, 0x887878f0, 0x6f25254a, 0x722e2e5c,
+	 0x241c1c38, 0xf1a6a657, 0xc7b4b473, 0x51c6c697,
+	 0x23e8e8cb, 0x7cdddda1, 0x9c7474e8, 0x211f1f3e,
+	 0xdd4b4b96, 0xdcbdbd61, 0x868b8b0d, 0x858a8a0f,
+	 0x907070e0, 0x423e3e7c, 0xc4b5b571, 0xaa6666cc,
+	 0xd8484890, 0x05030306, 0x01f6f6f7, 0x120e0e1c,
+	 0xa36161c2, 0x5f35356a, 0xf95757ae, 0xd0b9b969,
+	 0x91868617, 0x58c1c199, 0x271d1d3a, 0xb99e9e27,
+	 0x38e1e1d9, 0x13f8f8eb, 0xb398982b, 0x33111122,
+	 0xbb6969d2, 0x70d9d9a9, 0x898e8e07, 0xa7949433,
+	 0xb69b9b2d, 0x221e1e3c, 0x92878715, 0x20e9e9c9,
+	 0x49cece87, 0xff5555aa, 0x78282850, 0x7adfdfa5,
+	 0x8f8c8c03, 0xf8a1a159, 0x80898909, 0x170d0d1a,
+	 0xdabfbf65, 0x31e6e6d7, 0xc6424284, 0xb86868d0,
+	 0xc3414182, 0xb0999929, 0x772d2d5a, 0x110f0f1e,
+	 0xcbb0b07b, 0xfc5454a8, 0xd6bbbb6d, 0x3a16162c,
+	 }, {
+	     0x6363c6a5, 0x7c7cf884, 0x7777ee99, 0x7b7bf68d,
+	     0xf2f2ff0d, 0x6b6bd6bd, 0x6f6fdeb1, 0xc5c59154,
+	     0x30306050, 0x01010203, 0x6767cea9, 0x2b2b567d,
+	     0xfefee719, 0xd7d7b562, 0xabab4de6, 0x7676ec9a,
+	     0xcaca8f45, 0x82821f9d, 0xc9c98940, 0x7d7dfa87,
+	     0xfafaef15, 0x5959b2eb, 0x47478ec9, 0xf0f0fb0b,
+	     0xadad41ec, 0xd4d4b367, 0xa2a25ffd, 0xafaf45ea,
+	     0x9c9c23bf, 0xa4a453f7, 0x7272e496, 0xc0c09b5b,
+	     0xb7b775c2, 0xfdfde11c, 0x93933dae, 0x26264c6a,
+	     0x36366c5a, 0x3f3f7e41, 0xf7f7f502, 0xcccc834f,
+	     0x3434685c, 0xa5a551f4, 0xe5e5d134, 0xf1f1f908,
+	     0x7171e293, 0xd8d8ab73, 0x31316253, 0x15152a3f,
+	     0x0404080c, 0xc7c79552, 0x23234665, 0xc3c39d5e,
+	     0x18183028, 0x969637a1, 0x05050a0f, 0x9a9a2fb5,
+	     0x07070e09, 0x12122436, 0x80801b9b, 0xe2e2df3d,
+	     0xebebcd26, 0x27274e69, 0xb2b27fcd, 0x7575ea9f,
+	     0x0909121b, 0x83831d9e, 0x2c2c5874, 0x1a1a342e,
+	     0x1b1b362d, 0x6e6edcb2, 0x5a5ab4ee, 0xa0a05bfb,
+	     0x5252a4f6, 0x3b3b764d, 0xd6d6b761, 0xb3b37dce,
+	     0x2929527b, 0xe3e3dd3e, 0x2f2f5e71, 0x84841397,
+	     0x5353a6f5, 0xd1d1b968, 0x00000000, 0xededc12c,
+	     0x20204060, 0xfcfce31f, 0xb1b179c8, 0x5b5bb6ed,
+	     0x6a6ad4be, 0xcbcb8d46, 0xbebe67d9, 0x3939724b,
+	     0x4a4a94de, 0x4c4c98d4, 0x5858b0e8, 0xcfcf854a,
+	     0xd0d0bb6b, 0xefefc52a, 0xaaaa4fe5, 0xfbfbed16,
+	     0x434386c5, 0x4d4d9ad7, 0x33336655, 0x85851194,
+	     0x45458acf, 0xf9f9e910, 0x02020406, 0x7f7ffe81,
+	     0x5050a0f0, 0x3c3c7844, 0x9f9f25ba, 0xa8a84be3,
+	     0x5151a2f3, 0xa3a35dfe, 0x404080c0, 0x8f8f058a,
+	     0x92923fad, 0x9d9d21bc, 0x38387048, 0xf5f5f104,
+	     0xbcbc63df, 0xb6b677c1, 0xdadaaf75, 0x21214263,
+	     0x10102030, 0xffffe51a, 0xf3f3fd0e, 0xd2d2bf6d,
+	     0xcdcd814c, 0x0c0c1814, 0x13132635, 0xececc32f,
+	     0x5f5fbee1, 0x979735a2, 0x444488cc, 0x17172e39,
+	     0xc4c49357, 0xa7a755f2, 0x7e7efc82, 0x3d3d7a47,
+	     0x6464c8ac, 0x5d5dbae7, 0x1919322b, 0x7373e695,
+	     0x6060c0a0, 0x81811998, 0x4f4f9ed1, 0xdcdca37f,
+	     0x22224466, 0x2a2a547e, 0x90903bab, 0x88880b83,
+	     0x46468cca, 0xeeeec729, 0xb8b86bd3, 0x1414283c,
+	     0xdedea779, 0x5e5ebce2, 0x0b0b161d, 0xdbdbad76,
+	     0xe0e0db3b, 0x32326456, 0x3a3a744e, 0x0a0a141e,
+	     0x494992db, 0x06060c0a, 0x2424486c, 0x5c5cb8e4,
+	     0xc2c29f5d, 0xd3d3bd6e, 0xacac43ef, 0x6262c4a6,
+	     0x919139a8, 0x959531a4, 0xe4e4d337, 0x7979f28b,
+	     0xe7e7d532, 0xc8c88b43, 0x37376e59, 0x6d6ddab7,
+	     0x8d8d018c, 0xd5d5b164, 0x4e4e9cd2, 0xa9a949e0,
+	     0x6c6cd8b4, 0x5656acfa, 0xf4f4f307, 0xeaeacf25,
+	     0x6565caaf, 0x7a7af48e, 0xaeae47e9, 0x08081018,
+	     0xbaba6fd5, 0x7878f088, 0x25254a6f, 0x2e2e5c72,
+	     0x1c1c3824, 0xa6a657f1, 0xb4b473c7, 0xc6c69751,
+	     0xe8e8cb23, 0xdddda17c, 0x7474e89c, 0x1f1f3e21,
+	     0x4b4b96dd, 0xbdbd61dc, 0x8b8b0d86, 0x8a8a0f85,
+	     0x7070e090, 0x3e3e7c42, 0xb5b571c4, 0x6666ccaa,
+	     0x484890d8, 0x03030605, 0xf6f6f701, 0x0e0e1c12,
+	     0x6161c2a3, 0x35356a5f, 0x5757aef9, 0xb9b969d0,
+	     0x86861791, 0xc1c19958, 0x1d1d3a27, 0x9e9e27b9,
+	     0xe1e1d938, 0xf8f8eb13, 0x98982bb3, 0x11112233,
+	     0x6969d2bb, 0xd9d9a970, 0x8e8e0789, 0x949433a7,
+	     0x9b9b2db6, 0x1e1e3c22, 0x87871592, 0xe9e9c920,
+	     0xcece8749, 0x5555aaff, 0x28285078, 0xdfdfa57a,
+	     0x8c8c038f, 0xa1a159f8, 0x89890980, 0x0d0d1a17,
+	     0xbfbf65da, 0xe6e6d731, 0x424284c6, 0x6868d0b8,
+	     0x414182c3, 0x999929b0, 0x2d2d5a77, 0x0f0f1e11,
+	     0xb0b07bcb, 0x5454a8fc, 0xbbbb6dd6, 0x16162c3a,
+	     }, {
+		 0x63c6a563, 0x7cf8847c, 0x77ee9977, 0x7bf68d7b,
+		 0xf2ff0df2, 0x6bd6bd6b, 0x6fdeb16f, 0xc59154c5,
+		 0x30605030, 0x01020301, 0x67cea967, 0x2b567d2b,
+		 0xfee719fe, 0xd7b562d7, 0xab4de6ab, 0x76ec9a76,
+		 0xca8f45ca, 0x821f9d82, 0xc98940c9, 0x7dfa877d,
+		 0xfaef15fa, 0x59b2eb59, 0x478ec947, 0xf0fb0bf0,
+		 0xad41ecad, 0xd4b367d4, 0xa25ffda2, 0xaf45eaaf,
+		 0x9c23bf9c, 0xa453f7a4, 0x72e49672, 0xc09b5bc0,
+		 0xb775c2b7, 0xfde11cfd, 0x933dae93, 0x264c6a26,
+		 0x366c5a36, 0x3f7e413f, 0xf7f502f7, 0xcc834fcc,
+		 0x34685c34, 0xa551f4a5, 0xe5d134e5, 0xf1f908f1,
+		 0x71e29371, 0xd8ab73d8, 0x31625331, 0x152a3f15,
+		 0x04080c04, 0xc79552c7, 0x23466523, 0xc39d5ec3,
+		 0x18302818, 0x9637a196, 0x050a0f05, 0x9a2fb59a,
+		 0x070e0907, 0x12243612, 0x801b9b80, 0xe2df3de2,
+		 0xebcd26eb, 0x274e6927, 0xb27fcdb2, 0x75ea9f75,
+		 0x09121b09, 0x831d9e83, 0x2c58742c, 0x1a342e1a,
+		 0x1b362d1b, 0x6edcb26e, 0x5ab4ee5a, 0xa05bfba0,
+		 0x52a4f652, 0x3b764d3b, 0xd6b761d6, 0xb37dceb3,
+		 0x29527b29, 0xe3dd3ee3, 0x2f5e712f, 0x84139784,
+		 0x53a6f553, 0xd1b968d1, 0x00000000, 0xedc12ced,
+		 0x20406020, 0xfce31ffc, 0xb179c8b1, 0x5bb6ed5b,
+		 0x6ad4be6a, 0xcb8d46cb, 0xbe67d9be, 0x39724b39,
+		 0x4a94de4a, 0x4c98d44c, 0x58b0e858, 0xcf854acf,
+		 0xd0bb6bd0, 0xefc52aef, 0xaa4fe5aa, 0xfbed16fb,
+		 0x4386c543, 0x4d9ad74d, 0x33665533, 0x85119485,
+		 0x458acf45, 0xf9e910f9, 0x02040602, 0x7ffe817f,
+		 0x50a0f050, 0x3c78443c, 0x9f25ba9f, 0xa84be3a8,
+		 0x51a2f351, 0xa35dfea3, 0x4080c040, 0x8f058a8f,
+		 0x923fad92, 0x9d21bc9d, 0x38704838, 0xf5f104f5,
+		 0xbc63dfbc, 0xb677c1b6, 0xdaaf75da, 0x21426321,
+		 0x10203010, 0xffe51aff, 0xf3fd0ef3, 0xd2bf6dd2,
+		 0xcd814ccd, 0x0c18140c, 0x13263513, 0xecc32fec,
+		 0x5fbee15f, 0x9735a297, 0x4488cc44, 0x172e3917,
+		 0xc49357c4, 0xa755f2a7, 0x7efc827e, 0x3d7a473d,
+		 0x64c8ac64, 0x5dbae75d, 0x19322b19, 0x73e69573,
+		 0x60c0a060, 0x81199881, 0x4f9ed14f, 0xdca37fdc,
+		 0x22446622, 0x2a547e2a, 0x903bab90, 0x880b8388,
+		 0x468cca46, 0xeec729ee, 0xb86bd3b8, 0x14283c14,
+		 0xdea779de, 0x5ebce25e, 0x0b161d0b, 0xdbad76db,
+		 0xe0db3be0, 0x32645632, 0x3a744e3a, 0x0a141e0a,
+		 0x4992db49, 0x060c0a06, 0x24486c24, 0x5cb8e45c,
+		 0xc29f5dc2, 0xd3bd6ed3, 0xac43efac, 0x62c4a662,
+		 0x9139a891, 0x9531a495, 0xe4d337e4, 0x79f28b79,
+		 0xe7d532e7, 0xc88b43c8, 0x376e5937, 0x6ddab76d,
+		 0x8d018c8d, 0xd5b164d5, 0x4e9cd24e, 0xa949e0a9,
+		 0x6cd8b46c, 0x56acfa56, 0xf4f307f4, 0xeacf25ea,
+		 0x65caaf65, 0x7af48e7a, 0xae47e9ae, 0x08101808,
+		 0xba6fd5ba, 0x78f08878, 0x254a6f25, 0x2e5c722e,
+		 0x1c38241c, 0xa657f1a6, 0xb473c7b4, 0xc69751c6,
+		 0xe8cb23e8, 0xdda17cdd, 0x74e89c74, 0x1f3e211f,
+		 0x4b96dd4b, 0xbd61dcbd, 0x8b0d868b, 0x8a0f858a,
+		 0x70e09070, 0x3e7c423e, 0xb571c4b5, 0x66ccaa66,
+		 0x4890d848, 0x03060503, 0xf6f701f6, 0x0e1c120e,
+		 0x61c2a361, 0x356a5f35, 0x57aef957, 0xb969d0b9,
+		 0x86179186, 0xc19958c1, 0x1d3a271d, 0x9e27b99e,
+		 0xe1d938e1, 0xf8eb13f8, 0x982bb398, 0x11223311,
+		 0x69d2bb69, 0xd9a970d9, 0x8e07898e, 0x9433a794,
+		 0x9b2db69b, 0x1e3c221e, 0x87159287, 0xe9c920e9,
+		 0xce8749ce, 0x55aaff55, 0x28507828, 0xdfa57adf,
+		 0x8c038f8c, 0xa159f8a1, 0x89098089, 0x0d1a170d,
+		 0xbf65dabf, 0xe6d731e6, 0x4284c642, 0x68d0b868,
+		 0x4182c341, 0x9929b099, 0x2d5a772d, 0x0f1e110f,
+		 0xb07bcbb0, 0x54a8fc54, 0xbb6dd6bb, 0x162c3a16,
+		 }, {
+		     0xc6a56363, 0xf8847c7c, 0xee997777, 0xf68d7b7b,
+		     0xff0df2f2, 0xd6bd6b6b, 0xdeb16f6f, 0x9154c5c5,
+		     0x60503030, 0x02030101, 0xcea96767, 0x567d2b2b,
+		     0xe719fefe, 0xb562d7d7, 0x4de6abab, 0xec9a7676,
+		     0x8f45caca, 0x1f9d8282, 0x8940c9c9, 0xfa877d7d,
+		     0xef15fafa, 0xb2eb5959, 0x8ec94747, 0xfb0bf0f0,
+		     0x41ecadad, 0xb367d4d4, 0x5ffda2a2, 0x45eaafaf,
+		     0x23bf9c9c, 0x53f7a4a4, 0xe4967272, 0x9b5bc0c0,
+		     0x75c2b7b7, 0xe11cfdfd, 0x3dae9393, 0x4c6a2626,
+		     0x6c5a3636, 0x7e413f3f, 0xf502f7f7, 0x834fcccc,
+		     0x685c3434, 0x51f4a5a5, 0xd134e5e5, 0xf908f1f1,
+		     0xe2937171, 0xab73d8d8, 0x62533131, 0x2a3f1515,
+		     0x080c0404, 0x9552c7c7, 0x46652323, 0x9d5ec3c3,
+		     0x30281818, 0x37a19696, 0x0a0f0505, 0x2fb59a9a,
+		     0x0e090707, 0x24361212, 0x1b9b8080, 0xdf3de2e2,
+		     0xcd26ebeb, 0x4e692727, 0x7fcdb2b2, 0xea9f7575,
+		     0x121b0909, 0x1d9e8383, 0x58742c2c, 0x342e1a1a,
+		     0x362d1b1b, 0xdcb26e6e, 0xb4ee5a5a, 0x5bfba0a0,
+		     0xa4f65252, 0x764d3b3b, 0xb761d6d6, 0x7dceb3b3,
+		     0x527b2929, 0xdd3ee3e3, 0x5e712f2f, 0x13978484,
+		     0xa6f55353, 0xb968d1d1, 0x00000000, 0xc12ceded,
+		     0x40602020, 0xe31ffcfc, 0x79c8b1b1, 0xb6ed5b5b,
+		     0xd4be6a6a, 0x8d46cbcb, 0x67d9bebe, 0x724b3939,
+		     0x94de4a4a, 0x98d44c4c, 0xb0e85858, 0x854acfcf,
+		     0xbb6bd0d0, 0xc52aefef, 0x4fe5aaaa, 0xed16fbfb,
+		     0x86c54343, 0x9ad74d4d, 0x66553333, 0x11948585,
+		     0x8acf4545, 0xe910f9f9, 0x04060202, 0xfe817f7f,
+		     0xa0f05050, 0x78443c3c, 0x25ba9f9f, 0x4be3a8a8,
+		     0xa2f35151, 0x5dfea3a3, 0x80c04040, 0x058a8f8f,
+		     0x3fad9292, 0x21bc9d9d, 0x70483838, 0xf104f5f5,
+		     0x63dfbcbc, 0x77c1b6b6, 0xaf75dada, 0x42632121,
+		     0x20301010, 0xe51affff, 0xfd0ef3f3, 0xbf6dd2d2,
+		     0x814ccdcd, 0x18140c0c, 0x26351313, 0xc32fecec,
+		     0xbee15f5f, 0x35a29797, 0x88cc4444, 0x2e391717,
+		     0x9357c4c4, 0x55f2a7a7, 0xfc827e7e, 0x7a473d3d,
+		     0xc8ac6464, 0xbae75d5d, 0x322b1919, 0xe6957373,
+		     0xc0a06060, 0x19988181, 0x9ed14f4f, 0xa37fdcdc,
+		     0x44662222, 0x547e2a2a, 0x3bab9090, 0x0b838888,
+		     0x8cca4646, 0xc729eeee, 0x6bd3b8b8, 0x283c1414,
+		     0xa779dede, 0xbce25e5e, 0x161d0b0b, 0xad76dbdb,
+		     0xdb3be0e0, 0x64563232, 0x744e3a3a, 0x141e0a0a,
+		     0x92db4949, 0x0c0a0606, 0x486c2424, 0xb8e45c5c,
+		     0x9f5dc2c2, 0xbd6ed3d3, 0x43efacac, 0xc4a66262,
+		     0x39a89191, 0x31a49595, 0xd337e4e4, 0xf28b7979,
+		     0xd532e7e7, 0x8b43c8c8, 0x6e593737, 0xdab76d6d,
+		     0x018c8d8d, 0xb164d5d5, 0x9cd24e4e, 0x49e0a9a9,
+		     0xd8b46c6c, 0xacfa5656, 0xf307f4f4, 0xcf25eaea,
+		     0xcaaf6565, 0xf48e7a7a, 0x47e9aeae, 0x10180808,
+		     0x6fd5baba, 0xf0887878, 0x4a6f2525, 0x5c722e2e,
+		     0x38241c1c, 0x57f1a6a6, 0x73c7b4b4, 0x9751c6c6,
+		     0xcb23e8e8, 0xa17cdddd, 0xe89c7474, 0x3e211f1f,
+		     0x96dd4b4b, 0x61dcbdbd, 0x0d868b8b, 0x0f858a8a,
+		     0xe0907070, 0x7c423e3e, 0x71c4b5b5, 0xccaa6666,
+		     0x90d84848, 0x06050303, 0xf701f6f6, 0x1c120e0e,
+		     0xc2a36161, 0x6a5f3535, 0xaef95757, 0x69d0b9b9,
+		     0x17918686, 0x9958c1c1, 0x3a271d1d, 0x27b99e9e,
+		     0xd938e1e1, 0xeb13f8f8, 0x2bb39898, 0x22331111,
+		     0xd2bb6969, 0xa970d9d9, 0x07898e8e, 0x33a79494,
+		     0x2db69b9b, 0x3c221e1e, 0x15928787, 0xc920e9e9,
+		     0x8749cece, 0xaaff5555, 0x50782828, 0xa57adfdf,
+		     0x038f8c8c, 0x59f8a1a1, 0x09808989, 0x1a170d0d,
+		     0x65dabfbf, 0xd731e6e6, 0x84c64242, 0xd0b86868,
+		     0x82c34141, 0x29b09999, 0x5a772d2d, 0x1e110f0f,
+		     0x7bcbb0b0, 0xa8fc5454, 0x6dd6bbbb, 0x2c3a1616,
+		     }
 };
 
 const uint32_t crypto_fl_tab[4][256] = {
 	{
-		0x00000063, 0x0000007c, 0x00000077, 0x0000007b,
-		0x000000f2, 0x0000006b, 0x0000006f, 0x000000c5,
-		0x00000030, 0x00000001, 0x00000067, 0x0000002b,
-		0x000000fe, 0x000000d7, 0x000000ab, 0x00000076,
-		0x000000ca, 0x00000082, 0x000000c9, 0x0000007d,
-		0x000000fa, 0x00000059, 0x00000047, 0x000000f0,
-		0x000000ad, 0x000000d4, 0x000000a2, 0x000000af,
-		0x0000009c, 0x000000a4, 0x00000072, 0x000000c0,
-		0x000000b7, 0x000000fd, 0x00000093, 0x00000026,
-		0x00000036, 0x0000003f, 0x000000f7, 0x000000cc,
-		0x00000034, 0x000000a5, 0x000000e5, 0x000000f1,
-		0x00000071, 0x000000d8, 0x00000031, 0x00000015,
-		0x00000004, 0x000000c7, 0x00000023, 0x000000c3,
-		0x00000018, 0x00000096, 0x00000005, 0x0000009a,
-		0x00000007, 0x00000012, 0x00000080, 0x000000e2,
-		0x000000eb, 0x00000027, 0x000000b2, 0x00000075,
-		0x00000009, 0x00000083, 0x0000002c, 0x0000001a,
-		0x0000001b, 0x0000006e, 0x0000005a, 0x000000a0,
-		0x00000052, 0x0000003b, 0x000000d6, 0x000000b3,
-		0x00000029, 0x000000e3, 0x0000002f, 0x00000084,
-		0x00000053, 0x000000d1, 0x00000000, 0x000000ed,
-		0x00000020, 0x000000fc, 0x000000b1, 0x0000005b,
-		0x0000006a, 0x000000cb, 0x000000be, 0x00000039,
-		0x0000004a, 0x0000004c, 0x00000058, 0x000000cf,
-		0x000000d0, 0x000000ef, 0x000000aa, 0x000000fb,
-		0x00000043, 0x0000004d, 0x00000033, 0x00000085,
-		0x00000045, 0x000000f9, 0x00000002, 0x0000007f,
-		0x00000050, 0x0000003c, 0x0000009f, 0x000000a8,
-		0x00000051, 0x000000a3, 0x00000040, 0x0000008f,
-		0x00000092, 0x0000009d, 0x00000038, 0x000000f5,
-		0x000000bc, 0x000000b6, 0x000000da, 0x00000021,
-		0x00000010, 0x000000ff, 0x000000f3, 0x000000d2,
-		0x000000cd, 0x0000000c, 0x00000013, 0x000000ec,
-		0x0000005f, 0x00000097, 0x00000044, 0x00000017,
-		0x000000c4, 0x000000a7, 0x0000007e, 0x0000003d,
-		0x00000064, 0x0000005d, 0x00000019, 0x00000073,
-		0x00000060, 0x00000081, 0x0000004f, 0x000000dc,
-		0x00000022, 0x0000002a, 0x00000090, 0x00000088,
-		0x00000046, 0x000000ee, 0x000000b8, 0x00000014,
-		0x000000de, 0x0000005e, 0x0000000b, 0x000000db,
-		0x000000e0, 0x00000032, 0x0000003a, 0x0000000a,
-		0x00000049, 0x00000006, 0x00000024, 0x0000005c,
-		0x000000c2, 0x000000d3, 0x000000ac, 0x00000062,
-		0x00000091, 0x00000095, 0x000000e4, 0x00000079,
-		0x000000e7, 0x000000c8, 0x00000037, 0x0000006d,
-		0x0000008d, 0x000000d5, 0x0000004e, 0x000000a9,
-		0x0000006c, 0x00000056, 0x000000f4, 0x000000ea,
-		0x00000065, 0x0000007a, 0x000000ae, 0x00000008,
-		0x000000ba, 0x00000078, 0x00000025, 0x0000002e,
-		0x0000001c, 0x000000a6, 0x000000b4, 0x000000c6,
-		0x000000e8, 0x000000dd, 0x00000074, 0x0000001f,
-		0x0000004b, 0x000000bd, 0x0000008b, 0x0000008a,
-		0x00000070, 0x0000003e, 0x000000b5, 0x00000066,
-		0x00000048, 0x00000003, 0x000000f6, 0x0000000e,
-		0x00000061, 0x00000035, 0x00000057, 0x000000b9,
-		0x00000086, 0x000000c1, 0x0000001d, 0x0000009e,
-		0x000000e1, 0x000000f8, 0x00000098, 0x00000011,
-		0x00000069, 0x000000d9, 0x0000008e, 0x00000094,
-		0x0000009b, 0x0000001e, 0x00000087, 0x000000e9,
-		0x000000ce, 0x00000055, 0x00000028, 0x000000df,
-		0x0000008c, 0x000000a1, 0x00000089, 0x0000000d,
-		0x000000bf, 0x000000e6, 0x00000042, 0x00000068,
-		0x00000041, 0x00000099, 0x0000002d, 0x0000000f,
-		0x000000b0, 0x00000054, 0x000000bb, 0x00000016,
-	}, {
-		0x00006300, 0x00007c00, 0x00007700, 0x00007b00,
-		0x0000f200, 0x00006b00, 0x00006f00, 0x0000c500,
-		0x00003000, 0x00000100, 0x00006700, 0x00002b00,
-		0x0000fe00, 0x0000d700, 0x0000ab00, 0x00007600,
-		0x0000ca00, 0x00008200, 0x0000c900, 0x00007d00,
-		0x0000fa00, 0x00005900, 0x00004700, 0x0000f000,
-		0x0000ad00, 0x0000d400, 0x0000a200, 0x0000af00,
-		0x00009c00, 0x0000a400, 0x00007200, 0x0000c000,
-		0x0000b700, 0x0000fd00, 0x00009300, 0x00002600,
-		0x00003600, 0x00003f00, 0x0000f700, 0x0000cc00,
-		0x00003400, 0x0000a500, 0x0000e500, 0x0000f100,
-		0x00007100, 0x0000d800, 0x00003100, 0x00001500,
-		0x00000400, 0x0000c700, 0x00002300, 0x0000c300,
-		0x00001800, 0x00009600, 0x00000500, 0x00009a00,
-		0x00000700, 0x00001200, 0x00008000, 0x0000e200,
-		0x0000eb00, 0x00002700, 0x0000b200, 0x00007500,
-		0x00000900, 0x00008300, 0x00002c00, 0x00001a00,
-		0x00001b00, 0x00006e00, 0x00005a00, 0x0000a000,
-		0x00005200, 0x00003b00, 0x0000d600, 0x0000b300,
-		0x00002900, 0x0000e300, 0x00002f00, 0x00008400,
-		0x00005300, 0x0000d100, 0x00000000, 0x0000ed00,
-		0x00002000, 0x0000fc00, 0x0000b100, 0x00005b00,
-		0x00006a00, 0x0000cb00, 0x0000be00, 0x00003900,
-		0x00004a00, 0x00004c00, 0x00005800, 0x0000cf00,
-		0x0000d000, 0x0000ef00, 0x0000aa00, 0x0000fb00,
-		0x00004300, 0x00004d00, 0x00003300, 0x00008500,
-		0x00004500, 0x0000f900, 0x00000200, 0x00007f00,
-		0x00005000, 0x00003c00, 0x00009f00, 0x0000a800,
-		0x00005100, 0x0000a300, 0x00004000, 0x00008f00,
-		0x00009200, 0x00009d00, 0x00003800, 0x0000f500,
-		0x0000bc00, 0x0000b600, 0x0000da00, 0x00002100,
-		0x00001000, 0x0000ff00, 0x0000f300, 0x0000d200,
-		0x0000cd00, 0x00000c00, 0x00001300, 0x0000ec00,
-		0x00005f00, 0x00009700, 0x00004400, 0x00001700,
-		0x0000c400, 0x0000a700, 0x00007e00, 0x00003d00,
-		0x00006400, 0x00005d00, 0x00001900, 0x00007300,
-		0x00006000, 0x00008100, 0x00004f00, 0x0000dc00,
-		0x00002200, 0x00002a00, 0x00009000, 0x00008800,
-		0x00004600, 0x0000ee00, 0x0000b800, 0x00001400,
-		0x0000de00, 0x00005e00, 0x00000b00, 0x0000db00,
-		0x0000e000, 0x00003200, 0x00003a00, 0x00000a00,
-		0x00004900, 0x00000600, 0x00002400, 0x00005c00,
-		0x0000c200, 0x0000d300, 0x0000ac00, 0x00006200,
-		0x00009100, 0x00009500, 0x0000e400, 0x00007900,
-		0x0000e700, 0x0000c800, 0x00003700, 0x00006d00,
-		0x00008d00, 0x0000d500, 0x00004e00, 0x0000a900,
-		0x00006c00, 0x00005600, 0x0000f400, 0x0000ea00,
-		0x00006500, 0x00007a00, 0x0000ae00, 0x00000800,
-		0x0000ba00, 0x00007800, 0x00002500, 0x00002e00,
-		0x00001c00, 0x0000a600, 0x0000b400, 0x0000c600,
-		0x0000e800, 0x0000dd00, 0x00007400, 0x00001f00,
-		0x00004b00, 0x0000bd00, 0x00008b00, 0x00008a00,
-		0x00007000, 0x00003e00, 0x0000b500, 0x00006600,
-		0x00004800, 0x00000300, 0x0000f600, 0x00000e00,
-		0x00006100, 0x00003500, 0x00005700, 0x0000b900,
-		0x00008600, 0x0000c100, 0x00001d00, 0x00009e00,
-		0x0000e100, 0x0000f800, 0x00009800, 0x00001100,
-		0x00006900, 0x0000d900, 0x00008e00, 0x00009400,
-		0x00009b00, 0x00001e00, 0x00008700, 0x0000e900,
-		0x0000ce00, 0x00005500, 0x00002800, 0x0000df00,
-		0x00008c00, 0x0000a100, 0x00008900, 0x00000d00,
-		0x0000bf00, 0x0000e600, 0x00004200, 0x00006800,
-		0x00004100, 0x00009900, 0x00002d00, 0x00000f00,
-		0x0000b000, 0x00005400, 0x0000bb00, 0x00001600,
-	}, {
-		0x00630000, 0x007c0000, 0x00770000, 0x007b0000,
-		0x00f20000, 0x006b0000, 0x006f0000, 0x00c50000,
-		0x00300000, 0x00010000, 0x00670000, 0x002b0000,
-		0x00fe0000, 0x00d70000, 0x00ab0000, 0x00760000,
-		0x00ca0000, 0x00820000, 0x00c90000, 0x007d0000,
-		0x00fa0000, 0x00590000, 0x00470000, 0x00f00000,
-		0x00ad0000, 0x00d40000, 0x00a20000, 0x00af0000,
-		0x009c0000, 0x00a40000, 0x00720000, 0x00c00000,
-		0x00b70000, 0x00fd0000, 0x00930000, 0x00260000,
-		0x00360000, 0x003f0000, 0x00f70000, 0x00cc0000,
-		0x00340000, 0x00a50000, 0x00e50000, 0x00f10000,
-		0x00710000, 0x00d80000, 0x00310000, 0x00150000,
-		0x00040000, 0x00c70000, 0x00230000, 0x00c30000,
-		0x00180000, 0x00960000, 0x00050000, 0x009a0000,
-		0x00070000, 0x00120000, 0x00800000, 0x00e20000,
-		0x00eb0000, 0x00270000, 0x00b20000, 0x00750000,
-		0x00090000, 0x00830000, 0x002c0000, 0x001a0000,
-		0x001b0000, 0x006e0000, 0x005a0000, 0x00a00000,
-		0x00520000, 0x003b0000, 0x00d60000, 0x00b30000,
-		0x00290000, 0x00e30000, 0x002f0000, 0x00840000,
-		0x00530000, 0x00d10000, 0x00000000, 0x00ed0000,
-		0x00200000, 0x00fc0000, 0x00b10000, 0x005b0000,
-		0x006a0000, 0x00cb0000, 0x00be0000, 0x00390000,
-		0x004a0000, 0x004c0000, 0x00580000, 0x00cf0000,
-		0x00d00000, 0x00ef0000, 0x00aa0000, 0x00fb0000,
-		0x00430000, 0x004d0000, 0x00330000, 0x00850000,
-		0x00450000, 0x00f90000, 0x00020000, 0x007f0000,
-		0x00500000, 0x003c0000, 0x009f0000, 0x00a80000,
-		0x00510000, 0x00a30000, 0x00400000, 0x008f0000,
-		0x00920000, 0x009d0000, 0x00380000, 0x00f50000,
-		0x00bc0000, 0x00b60000, 0x00da0000, 0x00210000,
-		0x00100000, 0x00ff0000, 0x00f30000, 0x00d20000,
-		0x00cd0000, 0x000c0000, 0x00130000, 0x00ec0000,
-		0x005f0000, 0x00970000, 0x00440000, 0x00170000,
-		0x00c40000, 0x00a70000, 0x007e0000, 0x003d0000,
-		0x00640000, 0x005d0000, 0x00190000, 0x00730000,
-		0x00600000, 0x00810000, 0x004f0000, 0x00dc0000,
-		0x00220000, 0x002a0000, 0x00900000, 0x00880000,
-		0x00460000, 0x00ee0000, 0x00b80000, 0x00140000,
-		0x00de0000, 0x005e0000, 0x000b0000, 0x00db0000,
-		0x00e00000, 0x00320000, 0x003a0000, 0x000a0000,
-		0x00490000, 0x00060000, 0x00240000, 0x005c0000,
-		0x00c20000, 0x00d30000, 0x00ac0000, 0x00620000,
-		0x00910000, 0x00950000, 0x00e40000, 0x00790000,
-		0x00e70000, 0x00c80000, 0x00370000, 0x006d0000,
-		0x008d0000, 0x00d50000, 0x004e0000, 0x00a90000,
-		0x006c0000, 0x00560000, 0x00f40000, 0x00ea0000,
-		0x00650000, 0x007a0000, 0x00ae0000, 0x00080000,
-		0x00ba0000, 0x00780000, 0x00250000, 0x002e0000,
-		0x001c0000, 0x00a60000, 0x00b40000, 0x00c60000,
-		0x00e80000, 0x00dd0000, 0x00740000, 0x001f0000,
-		0x004b0000, 0x00bd0000, 0x008b0000, 0x008a0000,
-		0x00700000, 0x003e0000, 0x00b50000, 0x00660000,
-		0x00480000, 0x00030000, 0x00f60000, 0x000e0000,
-		0x00610000, 0x00350000, 0x00570000, 0x00b90000,
-		0x00860000, 0x00c10000, 0x001d0000, 0x009e0000,
-		0x00e10000, 0x00f80000, 0x00980000, 0x00110000,
-		0x00690000, 0x00d90000, 0x008e0000, 0x00940000,
-		0x009b0000, 0x001e0000, 0x00870000, 0x00e90000,
-		0x00ce0000, 0x00550000, 0x00280000, 0x00df0000,
-		0x008c0000, 0x00a10000, 0x00890000, 0x000d0000,
-		0x00bf0000, 0x00e60000, 0x00420000, 0x00680000,
-		0x00410000, 0x00990000, 0x002d0000, 0x000f0000,
-		0x00b00000, 0x00540000, 0x00bb0000, 0x00160000,
-	}, {
-		0x63000000, 0x7c000000, 0x77000000, 0x7b000000,
-		0xf2000000, 0x6b000000, 0x6f000000, 0xc5000000,
-		0x30000000, 0x01000000, 0x67000000, 0x2b000000,
-		0xfe000000, 0xd7000000, 0xab000000, 0x76000000,
-		0xca000000, 0x82000000, 0xc9000000, 0x7d000000,
-		0xfa000000, 0x59000000, 0x47000000, 0xf0000000,
-		0xad000000, 0xd4000000, 0xa2000000, 0xaf000000,
-		0x9c000000, 0xa4000000, 0x72000000, 0xc0000000,
-		0xb7000000, 0xfd000000, 0x93000000, 0x26000000,
-		0x36000000, 0x3f000000, 0xf7000000, 0xcc000000,
-		0x34000000, 0xa5000000, 0xe5000000, 0xf1000000,
-		0x71000000, 0xd8000000, 0x31000000, 0x15000000,
-		0x04000000, 0xc7000000, 0x23000000, 0xc3000000,
-		0x18000000, 0x96000000, 0x05000000, 0x9a000000,
-		0x07000000, 0x12000000, 0x80000000, 0xe2000000,
-		0xeb000000, 0x27000000, 0xb2000000, 0x75000000,
-		0x09000000, 0x83000000, 0x2c000000, 0x1a000000,
-		0x1b000000, 0x6e000000, 0x5a000000, 0xa0000000,
-		0x52000000, 0x3b000000, 0xd6000000, 0xb3000000,
-		0x29000000, 0xe3000000, 0x2f000000, 0x84000000,
-		0x53000000, 0xd1000000, 0x00000000, 0xed000000,
-		0x20000000, 0xfc000000, 0xb1000000, 0x5b000000,
-		0x6a000000, 0xcb000000, 0xbe000000, 0x39000000,
-		0x4a000000, 0x4c000000, 0x58000000, 0xcf000000,
-		0xd0000000, 0xef000000, 0xaa000000, 0xfb000000,
-		0x43000000, 0x4d000000, 0x33000000, 0x85000000,
-		0x45000000, 0xf9000000, 0x02000000, 0x7f000000,
-		0x50000000, 0x3c000000, 0x9f000000, 0xa8000000,
-		0x51000000, 0xa3000000, 0x40000000, 0x8f000000,
-		0x92000000, 0x9d000000, 0x38000000, 0xf5000000,
-		0xbc000000, 0xb6000000, 0xda000000, 0x21000000,
-		0x10000000, 0xff000000, 0xf3000000, 0xd2000000,
-		0xcd000000, 0x0c000000, 0x13000000, 0xec000000,
-		0x5f000000, 0x97000000, 0x44000000, 0x17000000,
-		0xc4000000, 0xa7000000, 0x7e000000, 0x3d000000,
-		0x64000000, 0x5d000000, 0x19000000, 0x73000000,
-		0x60000000, 0x81000000, 0x4f000000, 0xdc000000,
-		0x22000000, 0x2a000000, 0x90000000, 0x88000000,
-		0x46000000, 0xee000000, 0xb8000000, 0x14000000,
-		0xde000000, 0x5e000000, 0x0b000000, 0xdb000000,
-		0xe0000000, 0x32000000, 0x3a000000, 0x0a000000,
-		0x49000000, 0x06000000, 0x24000000, 0x5c000000,
-		0xc2000000, 0xd3000000, 0xac000000, 0x62000000,
-		0x91000000, 0x95000000, 0xe4000000, 0x79000000,
-		0xe7000000, 0xc8000000, 0x37000000, 0x6d000000,
-		0x8d000000, 0xd5000000, 0x4e000000, 0xa9000000,
-		0x6c000000, 0x56000000, 0xf4000000, 0xea000000,
-		0x65000000, 0x7a000000, 0xae000000, 0x08000000,
-		0xba000000, 0x78000000, 0x25000000, 0x2e000000,
-		0x1c000000, 0xa6000000, 0xb4000000, 0xc6000000,
-		0xe8000000, 0xdd000000, 0x74000000, 0x1f000000,
-		0x4b000000, 0xbd000000, 0x8b000000, 0x8a000000,
-		0x70000000, 0x3e000000, 0xb5000000, 0x66000000,
-		0x48000000, 0x03000000, 0xf6000000, 0x0e000000,
-		0x61000000, 0x35000000, 0x57000000, 0xb9000000,
-		0x86000000, 0xc1000000, 0x1d000000, 0x9e000000,
-		0xe1000000, 0xf8000000, 0x98000000, 0x11000000,
-		0x69000000, 0xd9000000, 0x8e000000, 0x94000000,
-		0x9b000000, 0x1e000000, 0x87000000, 0xe9000000,
-		0xce000000, 0x55000000, 0x28000000, 0xdf000000,
-		0x8c000000, 0xa1000000, 0x89000000, 0x0d000000,
-		0xbf000000, 0xe6000000, 0x42000000, 0x68000000,
-		0x41000000, 0x99000000, 0x2d000000, 0x0f000000,
-		0xb0000000, 0x54000000, 0xbb000000, 0x16000000,
-	}
+	 0x00000063, 0x0000007c, 0x00000077, 0x0000007b,
+	 0x000000f2, 0x0000006b, 0x0000006f, 0x000000c5,
+	 0x00000030, 0x00000001, 0x00000067, 0x0000002b,
+	 0x000000fe, 0x000000d7, 0x000000ab, 0x00000076,
+	 0x000000ca, 0x00000082, 0x000000c9, 0x0000007d,
+	 0x000000fa, 0x00000059, 0x00000047, 0x000000f0,
+	 0x000000ad, 0x000000d4, 0x000000a2, 0x000000af,
+	 0x0000009c, 0x000000a4, 0x00000072, 0x000000c0,
+	 0x000000b7, 0x000000fd, 0x00000093, 0x00000026,
+	 0x00000036, 0x0000003f, 0x000000f7, 0x000000cc,
+	 0x00000034, 0x000000a5, 0x000000e5, 0x000000f1,
+	 0x00000071, 0x000000d8, 0x00000031, 0x00000015,
+	 0x00000004, 0x000000c7, 0x00000023, 0x000000c3,
+	 0x00000018, 0x00000096, 0x00000005, 0x0000009a,
+	 0x00000007, 0x00000012, 0x00000080, 0x000000e2,
+	 0x000000eb, 0x00000027, 0x000000b2, 0x00000075,
+	 0x00000009, 0x00000083, 0x0000002c, 0x0000001a,
+	 0x0000001b, 0x0000006e, 0x0000005a, 0x000000a0,
+	 0x00000052, 0x0000003b, 0x000000d6, 0x000000b3,
+	 0x00000029, 0x000000e3, 0x0000002f, 0x00000084,
+	 0x00000053, 0x000000d1, 0x00000000, 0x000000ed,
+	 0x00000020, 0x000000fc, 0x000000b1, 0x0000005b,
+	 0x0000006a, 0x000000cb, 0x000000be, 0x00000039,
+	 0x0000004a, 0x0000004c, 0x00000058, 0x000000cf,
+	 0x000000d0, 0x000000ef, 0x000000aa, 0x000000fb,
+	 0x00000043, 0x0000004d, 0x00000033, 0x00000085,
+	 0x00000045, 0x000000f9, 0x00000002, 0x0000007f,
+	 0x00000050, 0x0000003c, 0x0000009f, 0x000000a8,
+	 0x00000051, 0x000000a3, 0x00000040, 0x0000008f,
+	 0x00000092, 0x0000009d, 0x00000038, 0x000000f5,
+	 0x000000bc, 0x000000b6, 0x000000da, 0x00000021,
+	 0x00000010, 0x000000ff, 0x000000f3, 0x000000d2,
+	 0x000000cd, 0x0000000c, 0x00000013, 0x000000ec,
+	 0x0000005f, 0x00000097, 0x00000044, 0x00000017,
+	 0x000000c4, 0x000000a7, 0x0000007e, 0x0000003d,
+	 0x00000064, 0x0000005d, 0x00000019, 0x00000073,
+	 0x00000060, 0x00000081, 0x0000004f, 0x000000dc,
+	 0x00000022, 0x0000002a, 0x00000090, 0x00000088,
+	 0x00000046, 0x000000ee, 0x000000b8, 0x00000014,
+	 0x000000de, 0x0000005e, 0x0000000b, 0x000000db,
+	 0x000000e0, 0x00000032, 0x0000003a, 0x0000000a,
+	 0x00000049, 0x00000006, 0x00000024, 0x0000005c,
+	 0x000000c2, 0x000000d3, 0x000000ac, 0x00000062,
+	 0x00000091, 0x00000095, 0x000000e4, 0x00000079,
+	 0x000000e7, 0x000000c8, 0x00000037, 0x0000006d,
+	 0x0000008d, 0x000000d5, 0x0000004e, 0x000000a9,
+	 0x0000006c, 0x00000056, 0x000000f4, 0x000000ea,
+	 0x00000065, 0x0000007a, 0x000000ae, 0x00000008,
+	 0x000000ba, 0x00000078, 0x00000025, 0x0000002e,
+	 0x0000001c, 0x000000a6, 0x000000b4, 0x000000c6,
+	 0x000000e8, 0x000000dd, 0x00000074, 0x0000001f,
+	 0x0000004b, 0x000000bd, 0x0000008b, 0x0000008a,
+	 0x00000070, 0x0000003e, 0x000000b5, 0x00000066,
+	 0x00000048, 0x00000003, 0x000000f6, 0x0000000e,
+	 0x00000061, 0x00000035, 0x00000057, 0x000000b9,
+	 0x00000086, 0x000000c1, 0x0000001d, 0x0000009e,
+	 0x000000e1, 0x000000f8, 0x00000098, 0x00000011,
+	 0x00000069, 0x000000d9, 0x0000008e, 0x00000094,
+	 0x0000009b, 0x0000001e, 0x00000087, 0x000000e9,
+	 0x000000ce, 0x00000055, 0x00000028, 0x000000df,
+	 0x0000008c, 0x000000a1, 0x00000089, 0x0000000d,
+	 0x000000bf, 0x000000e6, 0x00000042, 0x00000068,
+	 0x00000041, 0x00000099, 0x0000002d, 0x0000000f,
+	 0x000000b0, 0x00000054, 0x000000bb, 0x00000016,
+	 }, {
+	     0x00006300, 0x00007c00, 0x00007700, 0x00007b00,
+	     0x0000f200, 0x00006b00, 0x00006f00, 0x0000c500,
+	     0x00003000, 0x00000100, 0x00006700, 0x00002b00,
+	     0x0000fe00, 0x0000d700, 0x0000ab00, 0x00007600,
+	     0x0000ca00, 0x00008200, 0x0000c900, 0x00007d00,
+	     0x0000fa00, 0x00005900, 0x00004700, 0x0000f000,
+	     0x0000ad00, 0x0000d400, 0x0000a200, 0x0000af00,
+	     0x00009c00, 0x0000a400, 0x00007200, 0x0000c000,
+	     0x0000b700, 0x0000fd00, 0x00009300, 0x00002600,
+	     0x00003600, 0x00003f00, 0x0000f700, 0x0000cc00,
+	     0x00003400, 0x0000a500, 0x0000e500, 0x0000f100,
+	     0x00007100, 0x0000d800, 0x00003100, 0x00001500,
+	     0x00000400, 0x0000c700, 0x00002300, 0x0000c300,
+	     0x00001800, 0x00009600, 0x00000500, 0x00009a00,
+	     0x00000700, 0x00001200, 0x00008000, 0x0000e200,
+	     0x0000eb00, 0x00002700, 0x0000b200, 0x00007500,
+	     0x00000900, 0x00008300, 0x00002c00, 0x00001a00,
+	     0x00001b00, 0x00006e00, 0x00005a00, 0x0000a000,
+	     0x00005200, 0x00003b00, 0x0000d600, 0x0000b300,
+	     0x00002900, 0x0000e300, 0x00002f00, 0x00008400,
+	     0x00005300, 0x0000d100, 0x00000000, 0x0000ed00,
+	     0x00002000, 0x0000fc00, 0x0000b100, 0x00005b00,
+	     0x00006a00, 0x0000cb00, 0x0000be00, 0x00003900,
+	     0x00004a00, 0x00004c00, 0x00005800, 0x0000cf00,
+	     0x0000d000, 0x0000ef00, 0x0000aa00, 0x0000fb00,
+	     0x00004300, 0x00004d00, 0x00003300, 0x00008500,
+	     0x00004500, 0x0000f900, 0x00000200, 0x00007f00,
+	     0x00005000, 0x00003c00, 0x00009f00, 0x0000a800,
+	     0x00005100, 0x0000a300, 0x00004000, 0x00008f00,
+	     0x00009200, 0x00009d00, 0x00003800, 0x0000f500,
+	     0x0000bc00, 0x0000b600, 0x0000da00, 0x00002100,
+	     0x00001000, 0x0000ff00, 0x0000f300, 0x0000d200,
+	     0x0000cd00, 0x00000c00, 0x00001300, 0x0000ec00,
+	     0x00005f00, 0x00009700, 0x00004400, 0x00001700,
+	     0x0000c400, 0x0000a700, 0x00007e00, 0x00003d00,
+	     0x00006400, 0x00005d00, 0x00001900, 0x00007300,
+	     0x00006000, 0x00008100, 0x00004f00, 0x0000dc00,
+	     0x00002200, 0x00002a00, 0x00009000, 0x00008800,
+	     0x00004600, 0x0000ee00, 0x0000b800, 0x00001400,
+	     0x0000de00, 0x00005e00, 0x00000b00, 0x0000db00,
+	     0x0000e000, 0x00003200, 0x00003a00, 0x00000a00,
+	     0x00004900, 0x00000600, 0x00002400, 0x00005c00,
+	     0x0000c200, 0x0000d300, 0x0000ac00, 0x00006200,
+	     0x00009100, 0x00009500, 0x0000e400, 0x00007900,
+	     0x0000e700, 0x0000c800, 0x00003700, 0x00006d00,
+	     0x00008d00, 0x0000d500, 0x00004e00, 0x0000a900,
+	     0x00006c00, 0x00005600, 0x0000f400, 0x0000ea00,
+	     0x00006500, 0x00007a00, 0x0000ae00, 0x00000800,
+	     0x0000ba00, 0x00007800, 0x00002500, 0x00002e00,
+	     0x00001c00, 0x0000a600, 0x0000b400, 0x0000c600,
+	     0x0000e800, 0x0000dd00, 0x00007400, 0x00001f00,
+	     0x00004b00, 0x0000bd00, 0x00008b00, 0x00008a00,
+	     0x00007000, 0x00003e00, 0x0000b500, 0x00006600,
+	     0x00004800, 0x00000300, 0x0000f600, 0x00000e00,
+	     0x00006100, 0x00003500, 0x00005700, 0x0000b900,
+	     0x00008600, 0x0000c100, 0x00001d00, 0x00009e00,
+	     0x0000e100, 0x0000f800, 0x00009800, 0x00001100,
+	     0x00006900, 0x0000d900, 0x00008e00, 0x00009400,
+	     0x00009b00, 0x00001e00, 0x00008700, 0x0000e900,
+	     0x0000ce00, 0x00005500, 0x00002800, 0x0000df00,
+	     0x00008c00, 0x0000a100, 0x00008900, 0x00000d00,
+	     0x0000bf00, 0x0000e600, 0x00004200, 0x00006800,
+	     0x00004100, 0x00009900, 0x00002d00, 0x00000f00,
+	     0x0000b000, 0x00005400, 0x0000bb00, 0x00001600,
+	     }, {
+		 0x00630000, 0x007c0000, 0x00770000, 0x007b0000,
+		 0x00f20000, 0x006b0000, 0x006f0000, 0x00c50000,
+		 0x00300000, 0x00010000, 0x00670000, 0x002b0000,
+		 0x00fe0000, 0x00d70000, 0x00ab0000, 0x00760000,
+		 0x00ca0000, 0x00820000, 0x00c90000, 0x007d0000,
+		 0x00fa0000, 0x00590000, 0x00470000, 0x00f00000,
+		 0x00ad0000, 0x00d40000, 0x00a20000, 0x00af0000,
+		 0x009c0000, 0x00a40000, 0x00720000, 0x00c00000,
+		 0x00b70000, 0x00fd0000, 0x00930000, 0x00260000,
+		 0x00360000, 0x003f0000, 0x00f70000, 0x00cc0000,
+		 0x00340000, 0x00a50000, 0x00e50000, 0x00f10000,
+		 0x00710000, 0x00d80000, 0x00310000, 0x00150000,
+		 0x00040000, 0x00c70000, 0x00230000, 0x00c30000,
+		 0x00180000, 0x00960000, 0x00050000, 0x009a0000,
+		 0x00070000, 0x00120000, 0x00800000, 0x00e20000,
+		 0x00eb0000, 0x00270000, 0x00b20000, 0x00750000,
+		 0x00090000, 0x00830000, 0x002c0000, 0x001a0000,
+		 0x001b0000, 0x006e0000, 0x005a0000, 0x00a00000,
+		 0x00520000, 0x003b0000, 0x00d60000, 0x00b30000,
+		 0x00290000, 0x00e30000, 0x002f0000, 0x00840000,
+		 0x00530000, 0x00d10000, 0x00000000, 0x00ed0000,
+		 0x00200000, 0x00fc0000, 0x00b10000, 0x005b0000,
+		 0x006a0000, 0x00cb0000, 0x00be0000, 0x00390000,
+		 0x004a0000, 0x004c0000, 0x00580000, 0x00cf0000,
+		 0x00d00000, 0x00ef0000, 0x00aa0000, 0x00fb0000,
+		 0x00430000, 0x004d0000, 0x00330000, 0x00850000,
+		 0x00450000, 0x00f90000, 0x00020000, 0x007f0000,
+		 0x00500000, 0x003c0000, 0x009f0000, 0x00a80000,
+		 0x00510000, 0x00a30000, 0x00400000, 0x008f0000,
+		 0x00920000, 0x009d0000, 0x00380000, 0x00f50000,
+		 0x00bc0000, 0x00b60000, 0x00da0000, 0x00210000,
+		 0x00100000, 0x00ff0000, 0x00f30000, 0x00d20000,
+		 0x00cd0000, 0x000c0000, 0x00130000, 0x00ec0000,
+		 0x005f0000, 0x00970000, 0x00440000, 0x00170000,
+		 0x00c40000, 0x00a70000, 0x007e0000, 0x003d0000,
+		 0x00640000, 0x005d0000, 0x00190000, 0x00730000,
+		 0x00600000, 0x00810000, 0x004f0000, 0x00dc0000,
+		 0x00220000, 0x002a0000, 0x00900000, 0x00880000,
+		 0x00460000, 0x00ee0000, 0x00b80000, 0x00140000,
+		 0x00de0000, 0x005e0000, 0x000b0000, 0x00db0000,
+		 0x00e00000, 0x00320000, 0x003a0000, 0x000a0000,
+		 0x00490000, 0x00060000, 0x00240000, 0x005c0000,
+		 0x00c20000, 0x00d30000, 0x00ac0000, 0x00620000,
+		 0x00910000, 0x00950000, 0x00e40000, 0x00790000,
+		 0x00e70000, 0x00c80000, 0x00370000, 0x006d0000,
+		 0x008d0000, 0x00d50000, 0x004e0000, 0x00a90000,
+		 0x006c0000, 0x00560000, 0x00f40000, 0x00ea0000,
+		 0x00650000, 0x007a0000, 0x00ae0000, 0x00080000,
+		 0x00ba0000, 0x00780000, 0x00250000, 0x002e0000,
+		 0x001c0000, 0x00a60000, 0x00b40000, 0x00c60000,
+		 0x00e80000, 0x00dd0000, 0x00740000, 0x001f0000,
+		 0x004b0000, 0x00bd0000, 0x008b0000, 0x008a0000,
+		 0x00700000, 0x003e0000, 0x00b50000, 0x00660000,
+		 0x00480000, 0x00030000, 0x00f60000, 0x000e0000,
+		 0x00610000, 0x00350000, 0x00570000, 0x00b90000,
+		 0x00860000, 0x00c10000, 0x001d0000, 0x009e0000,
+		 0x00e10000, 0x00f80000, 0x00980000, 0x00110000,
+		 0x00690000, 0x00d90000, 0x008e0000, 0x00940000,
+		 0x009b0000, 0x001e0000, 0x00870000, 0x00e90000,
+		 0x00ce0000, 0x00550000, 0x00280000, 0x00df0000,
+		 0x008c0000, 0x00a10000, 0x00890000, 0x000d0000,
+		 0x00bf0000, 0x00e60000, 0x00420000, 0x00680000,
+		 0x00410000, 0x00990000, 0x002d0000, 0x000f0000,
+		 0x00b00000, 0x00540000, 0x00bb0000, 0x00160000,
+		 }, {
+		     0x63000000, 0x7c000000, 0x77000000, 0x7b000000,
+		     0xf2000000, 0x6b000000, 0x6f000000, 0xc5000000,
+		     0x30000000, 0x01000000, 0x67000000, 0x2b000000,
+		     0xfe000000, 0xd7000000, 0xab000000, 0x76000000,
+		     0xca000000, 0x82000000, 0xc9000000, 0x7d000000,
+		     0xfa000000, 0x59000000, 0x47000000, 0xf0000000,
+		     0xad000000, 0xd4000000, 0xa2000000, 0xaf000000,
+		     0x9c000000, 0xa4000000, 0x72000000, 0xc0000000,
+		     0xb7000000, 0xfd000000, 0x93000000, 0x26000000,
+		     0x36000000, 0x3f000000, 0xf7000000, 0xcc000000,
+		     0x34000000, 0xa5000000, 0xe5000000, 0xf1000000,
+		     0x71000000, 0xd8000000, 0x31000000, 0x15000000,
+		     0x04000000, 0xc7000000, 0x23000000, 0xc3000000,
+		     0x18000000, 0x96000000, 0x05000000, 0x9a000000,
+		     0x07000000, 0x12000000, 0x80000000, 0xe2000000,
+		     0xeb000000, 0x27000000, 0xb2000000, 0x75000000,
+		     0x09000000, 0x83000000, 0x2c000000, 0x1a000000,
+		     0x1b000000, 0x6e000000, 0x5a000000, 0xa0000000,
+		     0x52000000, 0x3b000000, 0xd6000000, 0xb3000000,
+		     0x29000000, 0xe3000000, 0x2f000000, 0x84000000,
+		     0x53000000, 0xd1000000, 0x00000000, 0xed000000,
+		     0x20000000, 0xfc000000, 0xb1000000, 0x5b000000,
+		     0x6a000000, 0xcb000000, 0xbe000000, 0x39000000,
+		     0x4a000000, 0x4c000000, 0x58000000, 0xcf000000,
+		     0xd0000000, 0xef000000, 0xaa000000, 0xfb000000,
+		     0x43000000, 0x4d000000, 0x33000000, 0x85000000,
+		     0x45000000, 0xf9000000, 0x02000000, 0x7f000000,
+		     0x50000000, 0x3c000000, 0x9f000000, 0xa8000000,
+		     0x51000000, 0xa3000000, 0x40000000, 0x8f000000,
+		     0x92000000, 0x9d000000, 0x38000000, 0xf5000000,
+		     0xbc000000, 0xb6000000, 0xda000000, 0x21000000,
+		     0x10000000, 0xff000000, 0xf3000000, 0xd2000000,
+		     0xcd000000, 0x0c000000, 0x13000000, 0xec000000,
+		     0x5f000000, 0x97000000, 0x44000000, 0x17000000,
+		     0xc4000000, 0xa7000000, 0x7e000000, 0x3d000000,
+		     0x64000000, 0x5d000000, 0x19000000, 0x73000000,
+		     0x60000000, 0x81000000, 0x4f000000, 0xdc000000,
+		     0x22000000, 0x2a000000, 0x90000000, 0x88000000,
+		     0x46000000, 0xee000000, 0xb8000000, 0x14000000,
+		     0xde000000, 0x5e000000, 0x0b000000, 0xdb000000,
+		     0xe0000000, 0x32000000, 0x3a000000, 0x0a000000,
+		     0x49000000, 0x06000000, 0x24000000, 0x5c000000,
+		     0xc2000000, 0xd3000000, 0xac000000, 0x62000000,
+		     0x91000000, 0x95000000, 0xe4000000, 0x79000000,
+		     0xe7000000, 0xc8000000, 0x37000000, 0x6d000000,
+		     0x8d000000, 0xd5000000, 0x4e000000, 0xa9000000,
+		     0x6c000000, 0x56000000, 0xf4000000, 0xea000000,
+		     0x65000000, 0x7a000000, 0xae000000, 0x08000000,
+		     0xba000000, 0x78000000, 0x25000000, 0x2e000000,
+		     0x1c000000, 0xa6000000, 0xb4000000, 0xc6000000,
+		     0xe8000000, 0xdd000000, 0x74000000, 0x1f000000,
+		     0x4b000000, 0xbd000000, 0x8b000000, 0x8a000000,
+		     0x70000000, 0x3e000000, 0xb5000000, 0x66000000,
+		     0x48000000, 0x03000000, 0xf6000000, 0x0e000000,
+		     0x61000000, 0x35000000, 0x57000000, 0xb9000000,
+		     0x86000000, 0xc1000000, 0x1d000000, 0x9e000000,
+		     0xe1000000, 0xf8000000, 0x98000000, 0x11000000,
+		     0x69000000, 0xd9000000, 0x8e000000, 0x94000000,
+		     0x9b000000, 0x1e000000, 0x87000000, 0xe9000000,
+		     0xce000000, 0x55000000, 0x28000000, 0xdf000000,
+		     0x8c000000, 0xa1000000, 0x89000000, 0x0d000000,
+		     0xbf000000, 0xe6000000, 0x42000000, 0x68000000,
+		     0x41000000, 0x99000000, 0x2d000000, 0x0f000000,
+		     0xb0000000, 0x54000000, 0xbb000000, 0x16000000,
+		     }
 };
 
 const uint32_t crypto_it_tab[4][256] = {
 	{
-		0x50a7f451, 0x5365417e, 0xc3a4171a, 0x965e273a,
-		0xcb6bab3b, 0xf1459d1f, 0xab58faac, 0x9303e34b,
-		0x55fa3020, 0xf66d76ad, 0x9176cc88, 0x254c02f5,
-		0xfcd7e54f, 0xd7cb2ac5, 0x80443526, 0x8fa362b5,
-		0x495ab1de, 0x671bba25, 0x980eea45, 0xe1c0fe5d,
-		0x02752fc3, 0x12f04c81, 0xa397468d, 0xc6f9d36b,
-		0xe75f8f03, 0x959c9215, 0xeb7a6dbf, 0xda595295,
-		0x2d83bed4, 0xd3217458, 0x2969e049, 0x44c8c98e,
-		0x6a89c275, 0x78798ef4, 0x6b3e5899, 0xdd71b927,
-		0xb64fe1be, 0x17ad88f0, 0x66ac20c9, 0xb43ace7d,
-		0x184adf63, 0x82311ae5, 0x60335197, 0x457f5362,
-		0xe07764b1, 0x84ae6bbb, 0x1ca081fe, 0x942b08f9,
-		0x58684870, 0x19fd458f, 0x876cde94, 0xb7f87b52,
-		0x23d373ab, 0xe2024b72, 0x578f1fe3, 0x2aab5566,
-		0x0728ebb2, 0x03c2b52f, 0x9a7bc586, 0xa50837d3,
-		0xf2872830, 0xb2a5bf23, 0xba6a0302, 0x5c8216ed,
-		0x2b1ccf8a, 0x92b479a7, 0xf0f207f3, 0xa1e2694e,
-		0xcdf4da65, 0xd5be0506, 0x1f6234d1, 0x8afea6c4,
-		0x9d532e34, 0xa055f3a2, 0x32e18a05, 0x75ebf6a4,
-		0x39ec830b, 0xaaef6040, 0x069f715e, 0x51106ebd,
-		0xf98a213e, 0x3d06dd96, 0xae053edd, 0x46bde64d,
-		0xb58d5491, 0x055dc471, 0x6fd40604, 0xff155060,
-		0x24fb9819, 0x97e9bdd6, 0xcc434089, 0x779ed967,
-		0xbd42e8b0, 0x888b8907, 0x385b19e7, 0xdbeec879,
-		0x470a7ca1, 0xe90f427c, 0xc91e84f8, 0x00000000,
-		0x83868009, 0x48ed2b32, 0xac70111e, 0x4e725a6c,
-		0xfbff0efd, 0x5638850f, 0x1ed5ae3d, 0x27392d36,
-		0x64d90f0a, 0x21a65c68, 0xd1545b9b, 0x3a2e3624,
-		0xb1670a0c, 0x0fe75793, 0xd296eeb4, 0x9e919b1b,
-		0x4fc5c080, 0xa220dc61, 0x694b775a, 0x161a121c,
-		0x0aba93e2, 0xe52aa0c0, 0x43e0223c, 0x1d171b12,
-		0x0b0d090e, 0xadc78bf2, 0xb9a8b62d, 0xc8a91e14,
-		0x8519f157, 0x4c0775af, 0xbbdd99ee, 0xfd607fa3,
-		0x9f2601f7, 0xbcf5725c, 0xc53b6644, 0x347efb5b,
-		0x7629438b, 0xdcc623cb, 0x68fcedb6, 0x63f1e4b8,
-		0xcadc31d7, 0x10856342, 0x40229713, 0x2011c684,
-		0x7d244a85, 0xf83dbbd2, 0x1132f9ae, 0x6da129c7,
-		0x4b2f9e1d, 0xf330b2dc, 0xec52860d, 0xd0e3c177,
-		0x6c16b32b, 0x99b970a9, 0xfa489411, 0x2264e947,
-		0xc48cfca8, 0x1a3ff0a0, 0xd82c7d56, 0xef903322,
-		0xc74e4987, 0xc1d138d9, 0xfea2ca8c, 0x360bd498,
-		0xcf81f5a6, 0x28de7aa5, 0x268eb7da, 0xa4bfad3f,
-		0xe49d3a2c, 0x0d927850, 0x9bcc5f6a, 0x62467e54,
-		0xc2138df6, 0xe8b8d890, 0x5ef7392e, 0xf5afc382,
-		0xbe805d9f, 0x7c93d069, 0xa92dd56f, 0xb31225cf,
-		0x3b99acc8, 0xa77d1810, 0x6e639ce8, 0x7bbb3bdb,
-		0x097826cd, 0xf418596e, 0x01b79aec, 0xa89a4f83,
-		0x656e95e6, 0x7ee6ffaa, 0x08cfbc21, 0xe6e815ef,
-		0xd99be7ba, 0xce366f4a, 0xd4099fea, 0xd67cb029,
-		0xafb2a431, 0x31233f2a, 0x3094a5c6, 0xc066a235,
-		0x37bc4e74, 0xa6ca82fc, 0xb0d090e0, 0x15d8a733,
-		0x4a9804f1, 0xf7daec41, 0x0e50cd7f, 0x2ff69117,
-		0x8dd64d76, 0x4db0ef43, 0x544daacc, 0xdf0496e4,
-		0xe3b5d19e, 0x1b886a4c, 0xb81f2cc1, 0x7f516546,
-		0x04ea5e9d, 0x5d358c01, 0x737487fa, 0x2e410bfb,
-		0x5a1d67b3, 0x52d2db92, 0x335610e9, 0x1347d66d,
-		0x8c61d79a, 0x7a0ca137, 0x8e14f859, 0x893c13eb,
-		0xee27a9ce, 0x35c961b7, 0xede51ce1, 0x3cb1477a,
-		0x59dfd29c, 0x3f73f255, 0x79ce1418, 0xbf37c773,
-		0xeacdf753, 0x5baafd5f, 0x146f3ddf, 0x86db4478,
-		0x81f3afca, 0x3ec468b9, 0x2c342438, 0x5f40a3c2,
-		0x72c31d16, 0x0c25e2bc, 0x8b493c28, 0x41950dff,
-		0x7101a839, 0xdeb30c08, 0x9ce4b4d8, 0x90c15664,
-		0x6184cb7b, 0x70b632d5, 0x745c6c48, 0x4257b8d0,
-	}, {
-		0xa7f45150, 0x65417e53, 0xa4171ac3, 0x5e273a96,
-		0x6bab3bcb, 0x459d1ff1, 0x58faacab, 0x03e34b93,
-		0xfa302055, 0x6d76adf6, 0x76cc8891, 0x4c02f525,
-		0xd7e54ffc, 0xcb2ac5d7, 0x44352680, 0xa362b58f,
-		0x5ab1de49, 0x1bba2567, 0x0eea4598, 0xc0fe5de1,
-		0x752fc302, 0xf04c8112, 0x97468da3, 0xf9d36bc6,
-		0x5f8f03e7, 0x9c921595, 0x7a6dbfeb, 0x595295da,
-		0x83bed42d, 0x217458d3, 0x69e04929, 0xc8c98e44,
-		0x89c2756a, 0x798ef478, 0x3e58996b, 0x71b927dd,
-		0x4fe1beb6, 0xad88f017, 0xac20c966, 0x3ace7db4,
-		0x4adf6318, 0x311ae582, 0x33519760, 0x7f536245,
-		0x7764b1e0, 0xae6bbb84, 0xa081fe1c, 0x2b08f994,
-		0x68487058, 0xfd458f19, 0x6cde9487, 0xf87b52b7,
-		0xd373ab23, 0x024b72e2, 0x8f1fe357, 0xab55662a,
-		0x28ebb207, 0xc2b52f03, 0x7bc5869a, 0x0837d3a5,
-		0x872830f2, 0xa5bf23b2, 0x6a0302ba, 0x8216ed5c,
-		0x1ccf8a2b, 0xb479a792, 0xf207f3f0, 0xe2694ea1,
-		0xf4da65cd, 0xbe0506d5, 0x6234d11f, 0xfea6c48a,
-		0x532e349d, 0x55f3a2a0, 0xe18a0532, 0xebf6a475,
-		0xec830b39, 0xef6040aa, 0x9f715e06, 0x106ebd51,
-		0x8a213ef9, 0x06dd963d, 0x053eddae, 0xbde64d46,
-		0x8d5491b5, 0x5dc47105, 0xd406046f, 0x155060ff,
-		0xfb981924, 0xe9bdd697, 0x434089cc, 0x9ed96777,
-		0x42e8b0bd, 0x8b890788, 0x5b19e738, 0xeec879db,
-		0x0a7ca147, 0x0f427ce9, 0x1e84f8c9, 0x00000000,
-		0x86800983, 0xed2b3248, 0x70111eac, 0x725a6c4e,
-		0xff0efdfb, 0x38850f56, 0xd5ae3d1e, 0x392d3627,
-		0xd90f0a64, 0xa65c6821, 0x545b9bd1, 0x2e36243a,
-		0x670a0cb1, 0xe757930f, 0x96eeb4d2, 0x919b1b9e,
-		0xc5c0804f, 0x20dc61a2, 0x4b775a69, 0x1a121c16,
-		0xba93e20a, 0x2aa0c0e5, 0xe0223c43, 0x171b121d,
-		0x0d090e0b, 0xc78bf2ad, 0xa8b62db9, 0xa91e14c8,
-		0x19f15785, 0x0775af4c, 0xdd99eebb, 0x607fa3fd,
-		0x2601f79f, 0xf5725cbc, 0x3b6644c5, 0x7efb5b34,
-		0x29438b76, 0xc623cbdc, 0xfcedb668, 0xf1e4b863,
-		0xdc31d7ca, 0x85634210, 0x22971340, 0x11c68420,
-		0x244a857d, 0x3dbbd2f8, 0x32f9ae11, 0xa129c76d,
-		0x2f9e1d4b, 0x30b2dcf3, 0x52860dec, 0xe3c177d0,
-		0x16b32b6c, 0xb970a999, 0x489411fa, 0x64e94722,
-		0x8cfca8c4, 0x3ff0a01a, 0x2c7d56d8, 0x903322ef,
-		0x4e4987c7, 0xd138d9c1, 0xa2ca8cfe, 0x0bd49836,
-		0x81f5a6cf, 0xde7aa528, 0x8eb7da26, 0xbfad3fa4,
-		0x9d3a2ce4, 0x9278500d, 0xcc5f6a9b, 0x467e5462,
-		0x138df6c2, 0xb8d890e8, 0xf7392e5e, 0xafc382f5,
-		0x805d9fbe, 0x93d0697c, 0x2dd56fa9, 0x1225cfb3,
-		0x99acc83b, 0x7d1810a7, 0x639ce86e, 0xbb3bdb7b,
-		0x7826cd09, 0x18596ef4, 0xb79aec01, 0x9a4f83a8,
-		0x6e95e665, 0xe6ffaa7e, 0xcfbc2108, 0xe815efe6,
-		0x9be7bad9, 0x366f4ace, 0x099fead4, 0x7cb029d6,
-		0xb2a431af, 0x233f2a31, 0x94a5c630, 0x66a235c0,
-		0xbc4e7437, 0xca82fca6, 0xd090e0b0, 0xd8a73315,
-		0x9804f14a, 0xdaec41f7, 0x50cd7f0e, 0xf691172f,
-		0xd64d768d, 0xb0ef434d, 0x4daacc54, 0x0496e4df,
-		0xb5d19ee3, 0x886a4c1b, 0x1f2cc1b8, 0x5165467f,
-		0xea5e9d04, 0x358c015d, 0x7487fa73, 0x410bfb2e,
-		0x1d67b35a, 0xd2db9252, 0x5610e933, 0x47d66d13,
-		0x61d79a8c, 0x0ca1377a, 0x14f8598e, 0x3c13eb89,
-		0x27a9ceee, 0xc961b735, 0xe51ce1ed, 0xb1477a3c,
-		0xdfd29c59, 0x73f2553f, 0xce141879, 0x37c773bf,
-		0xcdf753ea, 0xaafd5f5b, 0x6f3ddf14, 0xdb447886,
-		0xf3afca81, 0xc468b93e, 0x3424382c, 0x40a3c25f,
-		0xc31d1672, 0x25e2bc0c, 0x493c288b, 0x950dff41,
-		0x01a83971, 0xb30c08de, 0xe4b4d89c, 0xc1566490,
-		0x84cb7b61, 0xb632d570, 0x5c6c4874, 0x57b8d042,
-	}, {
-		0xf45150a7, 0x417e5365, 0x171ac3a4, 0x273a965e,
-		0xab3bcb6b, 0x9d1ff145, 0xfaacab58, 0xe34b9303,
-		0x302055fa, 0x76adf66d, 0xcc889176, 0x02f5254c,
-		0xe54ffcd7, 0x2ac5d7cb, 0x35268044, 0x62b58fa3,
-		0xb1de495a, 0xba25671b, 0xea45980e, 0xfe5de1c0,
-		0x2fc30275, 0x4c8112f0, 0x468da397, 0xd36bc6f9,
-		0x8f03e75f, 0x9215959c, 0x6dbfeb7a, 0x5295da59,
-		0xbed42d83, 0x7458d321, 0xe0492969, 0xc98e44c8,
-		0xc2756a89, 0x8ef47879, 0x58996b3e, 0xb927dd71,
-		0xe1beb64f, 0x88f017ad, 0x20c966ac, 0xce7db43a,
-		0xdf63184a, 0x1ae58231, 0x51976033, 0x5362457f,
-		0x64b1e077, 0x6bbb84ae, 0x81fe1ca0, 0x08f9942b,
-		0x48705868, 0x458f19fd, 0xde94876c, 0x7b52b7f8,
-		0x73ab23d3, 0x4b72e202, 0x1fe3578f, 0x55662aab,
-		0xebb20728, 0xb52f03c2, 0xc5869a7b, 0x37d3a508,
-		0x2830f287, 0xbf23b2a5, 0x0302ba6a, 0x16ed5c82,
-		0xcf8a2b1c, 0x79a792b4, 0x07f3f0f2, 0x694ea1e2,
-		0xda65cdf4, 0x0506d5be, 0x34d11f62, 0xa6c48afe,
-		0x2e349d53, 0xf3a2a055, 0x8a0532e1, 0xf6a475eb,
-		0x830b39ec, 0x6040aaef, 0x715e069f, 0x6ebd5110,
-		0x213ef98a, 0xdd963d06, 0x3eddae05, 0xe64d46bd,
-		0x5491b58d, 0xc471055d, 0x06046fd4, 0x5060ff15,
-		0x981924fb, 0xbdd697e9, 0x4089cc43, 0xd967779e,
-		0xe8b0bd42, 0x8907888b, 0x19e7385b, 0xc879dbee,
-		0x7ca1470a, 0x427ce90f, 0x84f8c91e, 0x00000000,
-		0x80098386, 0x2b3248ed, 0x111eac70, 0x5a6c4e72,
-		0x0efdfbff, 0x850f5638, 0xae3d1ed5, 0x2d362739,
-		0x0f0a64d9, 0x5c6821a6, 0x5b9bd154, 0x36243a2e,
-		0x0a0cb167, 0x57930fe7, 0xeeb4d296, 0x9b1b9e91,
-		0xc0804fc5, 0xdc61a220, 0x775a694b, 0x121c161a,
-		0x93e20aba, 0xa0c0e52a, 0x223c43e0, 0x1b121d17,
-		0x090e0b0d, 0x8bf2adc7, 0xb62db9a8, 0x1e14c8a9,
-		0xf1578519, 0x75af4c07, 0x99eebbdd, 0x7fa3fd60,
-		0x01f79f26, 0x725cbcf5, 0x6644c53b, 0xfb5b347e,
-		0x438b7629, 0x23cbdcc6, 0xedb668fc, 0xe4b863f1,
-		0x31d7cadc, 0x63421085, 0x97134022, 0xc6842011,
-		0x4a857d24, 0xbbd2f83d, 0xf9ae1132, 0x29c76da1,
-		0x9e1d4b2f, 0xb2dcf330, 0x860dec52, 0xc177d0e3,
-		0xb32b6c16, 0x70a999b9, 0x9411fa48, 0xe9472264,
-		0xfca8c48c, 0xf0a01a3f, 0x7d56d82c, 0x3322ef90,
-		0x4987c74e, 0x38d9c1d1, 0xca8cfea2, 0xd498360b,
-		0xf5a6cf81, 0x7aa528de, 0xb7da268e, 0xad3fa4bf,
-		0x3a2ce49d, 0x78500d92, 0x5f6a9bcc, 0x7e546246,
-		0x8df6c213, 0xd890e8b8, 0x392e5ef7, 0xc382f5af,
-		0x5d9fbe80, 0xd0697c93, 0xd56fa92d, 0x25cfb312,
-		0xacc83b99, 0x1810a77d, 0x9ce86e63, 0x3bdb7bbb,
-		0x26cd0978, 0x596ef418, 0x9aec01b7, 0x4f83a89a,
-		0x95e6656e, 0xffaa7ee6, 0xbc2108cf, 0x15efe6e8,
-		0xe7bad99b, 0x6f4ace36, 0x9fead409, 0xb029d67c,
-		0xa431afb2, 0x3f2a3123, 0xa5c63094, 0xa235c066,
-		0x4e7437bc, 0x82fca6ca, 0x90e0b0d0, 0xa73315d8,
-		0x04f14a98, 0xec41f7da, 0xcd7f0e50, 0x91172ff6,
-		0x4d768dd6, 0xef434db0, 0xaacc544d, 0x96e4df04,
-		0xd19ee3b5, 0x6a4c1b88, 0x2cc1b81f, 0x65467f51,
-		0x5e9d04ea, 0x8c015d35, 0x87fa7374, 0x0bfb2e41,
-		0x67b35a1d, 0xdb9252d2, 0x10e93356, 0xd66d1347,
-		0xd79a8c61, 0xa1377a0c, 0xf8598e14, 0x13eb893c,
-		0xa9ceee27, 0x61b735c9, 0x1ce1ede5, 0x477a3cb1,
-		0xd29c59df, 0xf2553f73, 0x141879ce, 0xc773bf37,
-		0xf753eacd, 0xfd5f5baa, 0x3ddf146f, 0x447886db,
-		0xafca81f3, 0x68b93ec4, 0x24382c34, 0xa3c25f40,
-		0x1d1672c3, 0xe2bc0c25, 0x3c288b49, 0x0dff4195,
-		0xa8397101, 0x0c08deb3, 0xb4d89ce4, 0x566490c1,
-		0xcb7b6184, 0x32d570b6, 0x6c48745c, 0xb8d04257,
-	}, {
-		0x5150a7f4, 0x7e536541, 0x1ac3a417, 0x3a965e27,
-		0x3bcb6bab, 0x1ff1459d, 0xacab58fa, 0x4b9303e3,
-		0x2055fa30, 0xadf66d76, 0x889176cc, 0xf5254c02,
-		0x4ffcd7e5, 0xc5d7cb2a, 0x26804435, 0xb58fa362,
-		0xde495ab1, 0x25671bba, 0x45980eea, 0x5de1c0fe,
-		0xc302752f, 0x8112f04c, 0x8da39746, 0x6bc6f9d3,
-		0x03e75f8f, 0x15959c92, 0xbfeb7a6d, 0x95da5952,
-		0xd42d83be, 0x58d32174, 0x492969e0, 0x8e44c8c9,
-		0x756a89c2, 0xf478798e, 0x996b3e58, 0x27dd71b9,
-		0xbeb64fe1, 0xf017ad88, 0xc966ac20, 0x7db43ace,
-		0x63184adf, 0xe582311a, 0x97603351, 0x62457f53,
-		0xb1e07764, 0xbb84ae6b, 0xfe1ca081, 0xf9942b08,
-		0x70586848, 0x8f19fd45, 0x94876cde, 0x52b7f87b,
-		0xab23d373, 0x72e2024b, 0xe3578f1f, 0x662aab55,
-		0xb20728eb, 0x2f03c2b5, 0x869a7bc5, 0xd3a50837,
-		0x30f28728, 0x23b2a5bf, 0x02ba6a03, 0xed5c8216,
-		0x8a2b1ccf, 0xa792b479, 0xf3f0f207, 0x4ea1e269,
-		0x65cdf4da, 0x06d5be05, 0xd11f6234, 0xc48afea6,
-		0x349d532e, 0xa2a055f3, 0x0532e18a, 0xa475ebf6,
-		0x0b39ec83, 0x40aaef60, 0x5e069f71, 0xbd51106e,
-		0x3ef98a21, 0x963d06dd, 0xddae053e, 0x4d46bde6,
-		0x91b58d54, 0x71055dc4, 0x046fd406, 0x60ff1550,
-		0x1924fb98, 0xd697e9bd, 0x89cc4340, 0x67779ed9,
-		0xb0bd42e8, 0x07888b89, 0xe7385b19, 0x79dbeec8,
-		0xa1470a7c, 0x7ce90f42, 0xf8c91e84, 0x00000000,
-		0x09838680, 0x3248ed2b, 0x1eac7011, 0x6c4e725a,
-		0xfdfbff0e, 0x0f563885, 0x3d1ed5ae, 0x3627392d,
-		0x0a64d90f, 0x6821a65c, 0x9bd1545b, 0x243a2e36,
-		0x0cb1670a, 0x930fe757, 0xb4d296ee, 0x1b9e919b,
-		0x804fc5c0, 0x61a220dc, 0x5a694b77, 0x1c161a12,
-		0xe20aba93, 0xc0e52aa0, 0x3c43e022, 0x121d171b,
-		0x0e0b0d09, 0xf2adc78b, 0x2db9a8b6, 0x14c8a91e,
-		0x578519f1, 0xaf4c0775, 0xeebbdd99, 0xa3fd607f,
-		0xf79f2601, 0x5cbcf572, 0x44c53b66, 0x5b347efb,
-		0x8b762943, 0xcbdcc623, 0xb668fced, 0xb863f1e4,
-		0xd7cadc31, 0x42108563, 0x13402297, 0x842011c6,
-		0x857d244a, 0xd2f83dbb, 0xae1132f9, 0xc76da129,
-		0x1d4b2f9e, 0xdcf330b2, 0x0dec5286, 0x77d0e3c1,
-		0x2b6c16b3, 0xa999b970, 0x11fa4894, 0x472264e9,
-		0xa8c48cfc, 0xa01a3ff0, 0x56d82c7d, 0x22ef9033,
-		0x87c74e49, 0xd9c1d138, 0x8cfea2ca, 0x98360bd4,
-		0xa6cf81f5, 0xa528de7a, 0xda268eb7, 0x3fa4bfad,
-		0x2ce49d3a, 0x500d9278, 0x6a9bcc5f, 0x5462467e,
-		0xf6c2138d, 0x90e8b8d8, 0x2e5ef739, 0x82f5afc3,
-		0x9fbe805d, 0x697c93d0, 0x6fa92dd5, 0xcfb31225,
-		0xc83b99ac, 0x10a77d18, 0xe86e639c, 0xdb7bbb3b,
-		0xcd097826, 0x6ef41859, 0xec01b79a, 0x83a89a4f,
-		0xe6656e95, 0xaa7ee6ff, 0x2108cfbc, 0xefe6e815,
-		0xbad99be7, 0x4ace366f, 0xead4099f, 0x29d67cb0,
-		0x31afb2a4, 0x2a31233f, 0xc63094a5, 0x35c066a2,
-		0x7437bc4e, 0xfca6ca82, 0xe0b0d090, 0x3315d8a7,
-		0xf14a9804, 0x41f7daec, 0x7f0e50cd, 0x172ff691,
-		0x768dd64d, 0x434db0ef, 0xcc544daa, 0xe4df0496,
-		0x9ee3b5d1, 0x4c1b886a, 0xc1b81f2c, 0x467f5165,
-		0x9d04ea5e, 0x015d358c, 0xfa737487, 0xfb2e410b,
-		0xb35a1d67, 0x9252d2db, 0xe9335610, 0x6d1347d6,
-		0x9a8c61d7, 0x377a0ca1, 0x598e14f8, 0xeb893c13,
-		0xceee27a9, 0xb735c961, 0xe1ede51c, 0x7a3cb147,
-		0x9c59dfd2, 0x553f73f2, 0x1879ce14, 0x73bf37c7,
-		0x53eacdf7, 0x5f5baafd, 0xdf146f3d, 0x7886db44,
-		0xca81f3af, 0xb93ec468, 0x382c3424, 0xc25f40a3,
-		0x1672c31d, 0xbc0c25e2, 0x288b493c, 0xff41950d,
-		0x397101a8, 0x08deb30c, 0xd89ce4b4, 0x6490c156,
-		0x7b6184cb, 0xd570b632, 0x48745c6c, 0xd04257b8,
-	}
+	 0x50a7f451, 0x5365417e, 0xc3a4171a, 0x965e273a,
+	 0xcb6bab3b, 0xf1459d1f, 0xab58faac, 0x9303e34b,
+	 0x55fa3020, 0xf66d76ad, 0x9176cc88, 0x254c02f5,
+	 0xfcd7e54f, 0xd7cb2ac5, 0x80443526, 0x8fa362b5,
+	 0x495ab1de, 0x671bba25, 0x980eea45, 0xe1c0fe5d,
+	 0x02752fc3, 0x12f04c81, 0xa397468d, 0xc6f9d36b,
+	 0xe75f8f03, 0x959c9215, 0xeb7a6dbf, 0xda595295,
+	 0x2d83bed4, 0xd3217458, 0x2969e049, 0x44c8c98e,
+	 0x6a89c275, 0x78798ef4, 0x6b3e5899, 0xdd71b927,
+	 0xb64fe1be, 0x17ad88f0, 0x66ac20c9, 0xb43ace7d,
+	 0x184adf63, 0x82311ae5, 0x60335197, 0x457f5362,
+	 0xe07764b1, 0x84ae6bbb, 0x1ca081fe, 0x942b08f9,
+	 0x58684870, 0x19fd458f, 0x876cde94, 0xb7f87b52,
+	 0x23d373ab, 0xe2024b72, 0x578f1fe3, 0x2aab5566,
+	 0x0728ebb2, 0x03c2b52f, 0x9a7bc586, 0xa50837d3,
+	 0xf2872830, 0xb2a5bf23, 0xba6a0302, 0x5c8216ed,
+	 0x2b1ccf8a, 0x92b479a7, 0xf0f207f3, 0xa1e2694e,
+	 0xcdf4da65, 0xd5be0506, 0x1f6234d1, 0x8afea6c4,
+	 0x9d532e34, 0xa055f3a2, 0x32e18a05, 0x75ebf6a4,
+	 0x39ec830b, 0xaaef6040, 0x069f715e, 0x51106ebd,
+	 0xf98a213e, 0x3d06dd96, 0xae053edd, 0x46bde64d,
+	 0xb58d5491, 0x055dc471, 0x6fd40604, 0xff155060,
+	 0x24fb9819, 0x97e9bdd6, 0xcc434089, 0x779ed967,
+	 0xbd42e8b0, 0x888b8907, 0x385b19e7, 0xdbeec879,
+	 0x470a7ca1, 0xe90f427c, 0xc91e84f8, 0x00000000,
+	 0x83868009, 0x48ed2b32, 0xac70111e, 0x4e725a6c,
+	 0xfbff0efd, 0x5638850f, 0x1ed5ae3d, 0x27392d36,
+	 0x64d90f0a, 0x21a65c68, 0xd1545b9b, 0x3a2e3624,
+	 0xb1670a0c, 0x0fe75793, 0xd296eeb4, 0x9e919b1b,
+	 0x4fc5c080, 0xa220dc61, 0x694b775a, 0x161a121c,
+	 0x0aba93e2, 0xe52aa0c0, 0x43e0223c, 0x1d171b12,
+	 0x0b0d090e, 0xadc78bf2, 0xb9a8b62d, 0xc8a91e14,
+	 0x8519f157, 0x4c0775af, 0xbbdd99ee, 0xfd607fa3,
+	 0x9f2601f7, 0xbcf5725c, 0xc53b6644, 0x347efb5b,
+	 0x7629438b, 0xdcc623cb, 0x68fcedb6, 0x63f1e4b8,
+	 0xcadc31d7, 0x10856342, 0x40229713, 0x2011c684,
+	 0x7d244a85, 0xf83dbbd2, 0x1132f9ae, 0x6da129c7,
+	 0x4b2f9e1d, 0xf330b2dc, 0xec52860d, 0xd0e3c177,
+	 0x6c16b32b, 0x99b970a9, 0xfa489411, 0x2264e947,
+	 0xc48cfca8, 0x1a3ff0a0, 0xd82c7d56, 0xef903322,
+	 0xc74e4987, 0xc1d138d9, 0xfea2ca8c, 0x360bd498,
+	 0xcf81f5a6, 0x28de7aa5, 0x268eb7da, 0xa4bfad3f,
+	 0xe49d3a2c, 0x0d927850, 0x9bcc5f6a, 0x62467e54,
+	 0xc2138df6, 0xe8b8d890, 0x5ef7392e, 0xf5afc382,
+	 0xbe805d9f, 0x7c93d069, 0xa92dd56f, 0xb31225cf,
+	 0x3b99acc8, 0xa77d1810, 0x6e639ce8, 0x7bbb3bdb,
+	 0x097826cd, 0xf418596e, 0x01b79aec, 0xa89a4f83,
+	 0x656e95e6, 0x7ee6ffaa, 0x08cfbc21, 0xe6e815ef,
+	 0xd99be7ba, 0xce366f4a, 0xd4099fea, 0xd67cb029,
+	 0xafb2a431, 0x31233f2a, 0x3094a5c6, 0xc066a235,
+	 0x37bc4e74, 0xa6ca82fc, 0xb0d090e0, 0x15d8a733,
+	 0x4a9804f1, 0xf7daec41, 0x0e50cd7f, 0x2ff69117,
+	 0x8dd64d76, 0x4db0ef43, 0x544daacc, 0xdf0496e4,
+	 0xe3b5d19e, 0x1b886a4c, 0xb81f2cc1, 0x7f516546,
+	 0x04ea5e9d, 0x5d358c01, 0x737487fa, 0x2e410bfb,
+	 0x5a1d67b3, 0x52d2db92, 0x335610e9, 0x1347d66d,
+	 0x8c61d79a, 0x7a0ca137, 0x8e14f859, 0x893c13eb,
+	 0xee27a9ce, 0x35c961b7, 0xede51ce1, 0x3cb1477a,
+	 0x59dfd29c, 0x3f73f255, 0x79ce1418, 0xbf37c773,
+	 0xeacdf753, 0x5baafd5f, 0x146f3ddf, 0x86db4478,
+	 0x81f3afca, 0x3ec468b9, 0x2c342438, 0x5f40a3c2,
+	 0x72c31d16, 0x0c25e2bc, 0x8b493c28, 0x41950dff,
+	 0x7101a839, 0xdeb30c08, 0x9ce4b4d8, 0x90c15664,
+	 0x6184cb7b, 0x70b632d5, 0x745c6c48, 0x4257b8d0,
+	 }, {
+	     0xa7f45150, 0x65417e53, 0xa4171ac3, 0x5e273a96,
+	     0x6bab3bcb, 0x459d1ff1, 0x58faacab, 0x03e34b93,
+	     0xfa302055, 0x6d76adf6, 0x76cc8891, 0x4c02f525,
+	     0xd7e54ffc, 0xcb2ac5d7, 0x44352680, 0xa362b58f,
+	     0x5ab1de49, 0x1bba2567, 0x0eea4598, 0xc0fe5de1,
+	     0x752fc302, 0xf04c8112, 0x97468da3, 0xf9d36bc6,
+	     0x5f8f03e7, 0x9c921595, 0x7a6dbfeb, 0x595295da,
+	     0x83bed42d, 0x217458d3, 0x69e04929, 0xc8c98e44,
+	     0x89c2756a, 0x798ef478, 0x3e58996b, 0x71b927dd,
+	     0x4fe1beb6, 0xad88f017, 0xac20c966, 0x3ace7db4,
+	     0x4adf6318, 0x311ae582, 0x33519760, 0x7f536245,
+	     0x7764b1e0, 0xae6bbb84, 0xa081fe1c, 0x2b08f994,
+	     0x68487058, 0xfd458f19, 0x6cde9487, 0xf87b52b7,
+	     0xd373ab23, 0x024b72e2, 0x8f1fe357, 0xab55662a,
+	     0x28ebb207, 0xc2b52f03, 0x7bc5869a, 0x0837d3a5,
+	     0x872830f2, 0xa5bf23b2, 0x6a0302ba, 0x8216ed5c,
+	     0x1ccf8a2b, 0xb479a792, 0xf207f3f0, 0xe2694ea1,
+	     0xf4da65cd, 0xbe0506d5, 0x6234d11f, 0xfea6c48a,
+	     0x532e349d, 0x55f3a2a0, 0xe18a0532, 0xebf6a475,
+	     0xec830b39, 0xef6040aa, 0x9f715e06, 0x106ebd51,
+	     0x8a213ef9, 0x06dd963d, 0x053eddae, 0xbde64d46,
+	     0x8d5491b5, 0x5dc47105, 0xd406046f, 0x155060ff,
+	     0xfb981924, 0xe9bdd697, 0x434089cc, 0x9ed96777,
+	     0x42e8b0bd, 0x8b890788, 0x5b19e738, 0xeec879db,
+	     0x0a7ca147, 0x0f427ce9, 0x1e84f8c9, 0x00000000,
+	     0x86800983, 0xed2b3248, 0x70111eac, 0x725a6c4e,
+	     0xff0efdfb, 0x38850f56, 0xd5ae3d1e, 0x392d3627,
+	     0xd90f0a64, 0xa65c6821, 0x545b9bd1, 0x2e36243a,
+	     0x670a0cb1, 0xe757930f, 0x96eeb4d2, 0x919b1b9e,
+	     0xc5c0804f, 0x20dc61a2, 0x4b775a69, 0x1a121c16,
+	     0xba93e20a, 0x2aa0c0e5, 0xe0223c43, 0x171b121d,
+	     0x0d090e0b, 0xc78bf2ad, 0xa8b62db9, 0xa91e14c8,
+	     0x19f15785, 0x0775af4c, 0xdd99eebb, 0x607fa3fd,
+	     0x2601f79f, 0xf5725cbc, 0x3b6644c5, 0x7efb5b34,
+	     0x29438b76, 0xc623cbdc, 0xfcedb668, 0xf1e4b863,
+	     0xdc31d7ca, 0x85634210, 0x22971340, 0x11c68420,
+	     0x244a857d, 0x3dbbd2f8, 0x32f9ae11, 0xa129c76d,
+	     0x2f9e1d4b, 0x30b2dcf3, 0x52860dec, 0xe3c177d0,
+	     0x16b32b6c, 0xb970a999, 0x489411fa, 0x64e94722,
+	     0x8cfca8c4, 0x3ff0a01a, 0x2c7d56d8, 0x903322ef,
+	     0x4e4987c7, 0xd138d9c1, 0xa2ca8cfe, 0x0bd49836,
+	     0x81f5a6cf, 0xde7aa528, 0x8eb7da26, 0xbfad3fa4,
+	     0x9d3a2ce4, 0x9278500d, 0xcc5f6a9b, 0x467e5462,
+	     0x138df6c2, 0xb8d890e8, 0xf7392e5e, 0xafc382f5,
+	     0x805d9fbe, 0x93d0697c, 0x2dd56fa9, 0x1225cfb3,
+	     0x99acc83b, 0x7d1810a7, 0x639ce86e, 0xbb3bdb7b,
+	     0x7826cd09, 0x18596ef4, 0xb79aec01, 0x9a4f83a8,
+	     0x6e95e665, 0xe6ffaa7e, 0xcfbc2108, 0xe815efe6,
+	     0x9be7bad9, 0x366f4ace, 0x099fead4, 0x7cb029d6,
+	     0xb2a431af, 0x233f2a31, 0x94a5c630, 0x66a235c0,
+	     0xbc4e7437, 0xca82fca6, 0xd090e0b0, 0xd8a73315,
+	     0x9804f14a, 0xdaec41f7, 0x50cd7f0e, 0xf691172f,
+	     0xd64d768d, 0xb0ef434d, 0x4daacc54, 0x0496e4df,
+	     0xb5d19ee3, 0x886a4c1b, 0x1f2cc1b8, 0x5165467f,
+	     0xea5e9d04, 0x358c015d, 0x7487fa73, 0x410bfb2e,
+	     0x1d67b35a, 0xd2db9252, 0x5610e933, 0x47d66d13,
+	     0x61d79a8c, 0x0ca1377a, 0x14f8598e, 0x3c13eb89,
+	     0x27a9ceee, 0xc961b735, 0xe51ce1ed, 0xb1477a3c,
+	     0xdfd29c59, 0x73f2553f, 0xce141879, 0x37c773bf,
+	     0xcdf753ea, 0xaafd5f5b, 0x6f3ddf14, 0xdb447886,
+	     0xf3afca81, 0xc468b93e, 0x3424382c, 0x40a3c25f,
+	     0xc31d1672, 0x25e2bc0c, 0x493c288b, 0x950dff41,
+	     0x01a83971, 0xb30c08de, 0xe4b4d89c, 0xc1566490,
+	     0x84cb7b61, 0xb632d570, 0x5c6c4874, 0x57b8d042,
+	     }, {
+		 0xf45150a7, 0x417e5365, 0x171ac3a4, 0x273a965e,
+		 0xab3bcb6b, 0x9d1ff145, 0xfaacab58, 0xe34b9303,
+		 0x302055fa, 0x76adf66d, 0xcc889176, 0x02f5254c,
+		 0xe54ffcd7, 0x2ac5d7cb, 0x35268044, 0x62b58fa3,
+		 0xb1de495a, 0xba25671b, 0xea45980e, 0xfe5de1c0,
+		 0x2fc30275, 0x4c8112f0, 0x468da397, 0xd36bc6f9,
+		 0x8f03e75f, 0x9215959c, 0x6dbfeb7a, 0x5295da59,
+		 0xbed42d83, 0x7458d321, 0xe0492969, 0xc98e44c8,
+		 0xc2756a89, 0x8ef47879, 0x58996b3e, 0xb927dd71,
+		 0xe1beb64f, 0x88f017ad, 0x20c966ac, 0xce7db43a,
+		 0xdf63184a, 0x1ae58231, 0x51976033, 0x5362457f,
+		 0x64b1e077, 0x6bbb84ae, 0x81fe1ca0, 0x08f9942b,
+		 0x48705868, 0x458f19fd, 0xde94876c, 0x7b52b7f8,
+		 0x73ab23d3, 0x4b72e202, 0x1fe3578f, 0x55662aab,
+		 0xebb20728, 0xb52f03c2, 0xc5869a7b, 0x37d3a508,
+		 0x2830f287, 0xbf23b2a5, 0x0302ba6a, 0x16ed5c82,
+		 0xcf8a2b1c, 0x79a792b4, 0x07f3f0f2, 0x694ea1e2,
+		 0xda65cdf4, 0x0506d5be, 0x34d11f62, 0xa6c48afe,
+		 0x2e349d53, 0xf3a2a055, 0x8a0532e1, 0xf6a475eb,
+		 0x830b39ec, 0x6040aaef, 0x715e069f, 0x6ebd5110,
+		 0x213ef98a, 0xdd963d06, 0x3eddae05, 0xe64d46bd,
+		 0x5491b58d, 0xc471055d, 0x06046fd4, 0x5060ff15,
+		 0x981924fb, 0xbdd697e9, 0x4089cc43, 0xd967779e,
+		 0xe8b0bd42, 0x8907888b, 0x19e7385b, 0xc879dbee,
+		 0x7ca1470a, 0x427ce90f, 0x84f8c91e, 0x00000000,
+		 0x80098386, 0x2b3248ed, 0x111eac70, 0x5a6c4e72,
+		 0x0efdfbff, 0x850f5638, 0xae3d1ed5, 0x2d362739,
+		 0x0f0a64d9, 0x5c6821a6, 0x5b9bd154, 0x36243a2e,
+		 0x0a0cb167, 0x57930fe7, 0xeeb4d296, 0x9b1b9e91,
+		 0xc0804fc5, 0xdc61a220, 0x775a694b, 0x121c161a,
+		 0x93e20aba, 0xa0c0e52a, 0x223c43e0, 0x1b121d17,
+		 0x090e0b0d, 0x8bf2adc7, 0xb62db9a8, 0x1e14c8a9,
+		 0xf1578519, 0x75af4c07, 0x99eebbdd, 0x7fa3fd60,
+		 0x01f79f26, 0x725cbcf5, 0x6644c53b, 0xfb5b347e,
+		 0x438b7629, 0x23cbdcc6, 0xedb668fc, 0xe4b863f1,
+		 0x31d7cadc, 0x63421085, 0x97134022, 0xc6842011,
+		 0x4a857d24, 0xbbd2f83d, 0xf9ae1132, 0x29c76da1,
+		 0x9e1d4b2f, 0xb2dcf330, 0x860dec52, 0xc177d0e3,
+		 0xb32b6c16, 0x70a999b9, 0x9411fa48, 0xe9472264,
+		 0xfca8c48c, 0xf0a01a3f, 0x7d56d82c, 0x3322ef90,
+		 0x4987c74e, 0x38d9c1d1, 0xca8cfea2, 0xd498360b,
+		 0xf5a6cf81, 0x7aa528de, 0xb7da268e, 0xad3fa4bf,
+		 0x3a2ce49d, 0x78500d92, 0x5f6a9bcc, 0x7e546246,
+		 0x8df6c213, 0xd890e8b8, 0x392e5ef7, 0xc382f5af,
+		 0x5d9fbe80, 0xd0697c93, 0xd56fa92d, 0x25cfb312,
+		 0xacc83b99, 0x1810a77d, 0x9ce86e63, 0x3bdb7bbb,
+		 0x26cd0978, 0x596ef418, 0x9aec01b7, 0x4f83a89a,
+		 0x95e6656e, 0xffaa7ee6, 0xbc2108cf, 0x15efe6e8,
+		 0xe7bad99b, 0x6f4ace36, 0x9fead409, 0xb029d67c,
+		 0xa431afb2, 0x3f2a3123, 0xa5c63094, 0xa235c066,
+		 0x4e7437bc, 0x82fca6ca, 0x90e0b0d0, 0xa73315d8,
+		 0x04f14a98, 0xec41f7da, 0xcd7f0e50, 0x91172ff6,
+		 0x4d768dd6, 0xef434db0, 0xaacc544d, 0x96e4df04,
+		 0xd19ee3b5, 0x6a4c1b88, 0x2cc1b81f, 0x65467f51,
+		 0x5e9d04ea, 0x8c015d35, 0x87fa7374, 0x0bfb2e41,
+		 0x67b35a1d, 0xdb9252d2, 0x10e93356, 0xd66d1347,
+		 0xd79a8c61, 0xa1377a0c, 0xf8598e14, 0x13eb893c,
+		 0xa9ceee27, 0x61b735c9, 0x1ce1ede5, 0x477a3cb1,
+		 0xd29c59df, 0xf2553f73, 0x141879ce, 0xc773bf37,
+		 0xf753eacd, 0xfd5f5baa, 0x3ddf146f, 0x447886db,
+		 0xafca81f3, 0x68b93ec4, 0x24382c34, 0xa3c25f40,
+		 0x1d1672c3, 0xe2bc0c25, 0x3c288b49, 0x0dff4195,
+		 0xa8397101, 0x0c08deb3, 0xb4d89ce4, 0x566490c1,
+		 0xcb7b6184, 0x32d570b6, 0x6c48745c, 0xb8d04257,
+		 }, {
+		     0x5150a7f4, 0x7e536541, 0x1ac3a417, 0x3a965e27,
+		     0x3bcb6bab, 0x1ff1459d, 0xacab58fa, 0x4b9303e3,
+		     0x2055fa30, 0xadf66d76, 0x889176cc, 0xf5254c02,
+		     0x4ffcd7e5, 0xc5d7cb2a, 0x26804435, 0xb58fa362,
+		     0xde495ab1, 0x25671bba, 0x45980eea, 0x5de1c0fe,
+		     0xc302752f, 0x8112f04c, 0x8da39746, 0x6bc6f9d3,
+		     0x03e75f8f, 0x15959c92, 0xbfeb7a6d, 0x95da5952,
+		     0xd42d83be, 0x58d32174, 0x492969e0, 0x8e44c8c9,
+		     0x756a89c2, 0xf478798e, 0x996b3e58, 0x27dd71b9,
+		     0xbeb64fe1, 0xf017ad88, 0xc966ac20, 0x7db43ace,
+		     0x63184adf, 0xe582311a, 0x97603351, 0x62457f53,
+		     0xb1e07764, 0xbb84ae6b, 0xfe1ca081, 0xf9942b08,
+		     0x70586848, 0x8f19fd45, 0x94876cde, 0x52b7f87b,
+		     0xab23d373, 0x72e2024b, 0xe3578f1f, 0x662aab55,
+		     0xb20728eb, 0x2f03c2b5, 0x869a7bc5, 0xd3a50837,
+		     0x30f28728, 0x23b2a5bf, 0x02ba6a03, 0xed5c8216,
+		     0x8a2b1ccf, 0xa792b479, 0xf3f0f207, 0x4ea1e269,
+		     0x65cdf4da, 0x06d5be05, 0xd11f6234, 0xc48afea6,
+		     0x349d532e, 0xa2a055f3, 0x0532e18a, 0xa475ebf6,
+		     0x0b39ec83, 0x40aaef60, 0x5e069f71, 0xbd51106e,
+		     0x3ef98a21, 0x963d06dd, 0xddae053e, 0x4d46bde6,
+		     0x91b58d54, 0x71055dc4, 0x046fd406, 0x60ff1550,
+		     0x1924fb98, 0xd697e9bd, 0x89cc4340, 0x67779ed9,
+		     0xb0bd42e8, 0x07888b89, 0xe7385b19, 0x79dbeec8,
+		     0xa1470a7c, 0x7ce90f42, 0xf8c91e84, 0x00000000,
+		     0x09838680, 0x3248ed2b, 0x1eac7011, 0x6c4e725a,
+		     0xfdfbff0e, 0x0f563885, 0x3d1ed5ae, 0x3627392d,
+		     0x0a64d90f, 0x6821a65c, 0x9bd1545b, 0x243a2e36,
+		     0x0cb1670a, 0x930fe757, 0xb4d296ee, 0x1b9e919b,
+		     0x804fc5c0, 0x61a220dc, 0x5a694b77, 0x1c161a12,
+		     0xe20aba93, 0xc0e52aa0, 0x3c43e022, 0x121d171b,
+		     0x0e0b0d09, 0xf2adc78b, 0x2db9a8b6, 0x14c8a91e,
+		     0x578519f1, 0xaf4c0775, 0xeebbdd99, 0xa3fd607f,
+		     0xf79f2601, 0x5cbcf572, 0x44c53b66, 0x5b347efb,
+		     0x8b762943, 0xcbdcc623, 0xb668fced, 0xb863f1e4,
+		     0xd7cadc31, 0x42108563, 0x13402297, 0x842011c6,
+		     0x857d244a, 0xd2f83dbb, 0xae1132f9, 0xc76da129,
+		     0x1d4b2f9e, 0xdcf330b2, 0x0dec5286, 0x77d0e3c1,
+		     0x2b6c16b3, 0xa999b970, 0x11fa4894, 0x472264e9,
+		     0xa8c48cfc, 0xa01a3ff0, 0x56d82c7d, 0x22ef9033,
+		     0x87c74e49, 0xd9c1d138, 0x8cfea2ca, 0x98360bd4,
+		     0xa6cf81f5, 0xa528de7a, 0xda268eb7, 0x3fa4bfad,
+		     0x2ce49d3a, 0x500d9278, 0x6a9bcc5f, 0x5462467e,
+		     0xf6c2138d, 0x90e8b8d8, 0x2e5ef739, 0x82f5afc3,
+		     0x9fbe805d, 0x697c93d0, 0x6fa92dd5, 0xcfb31225,
+		     0xc83b99ac, 0x10a77d18, 0xe86e639c, 0xdb7bbb3b,
+		     0xcd097826, 0x6ef41859, 0xec01b79a, 0x83a89a4f,
+		     0xe6656e95, 0xaa7ee6ff, 0x2108cfbc, 0xefe6e815,
+		     0xbad99be7, 0x4ace366f, 0xead4099f, 0x29d67cb0,
+		     0x31afb2a4, 0x2a31233f, 0xc63094a5, 0x35c066a2,
+		     0x7437bc4e, 0xfca6ca82, 0xe0b0d090, 0x3315d8a7,
+		     0xf14a9804, 0x41f7daec, 0x7f0e50cd, 0x172ff691,
+		     0x768dd64d, 0x434db0ef, 0xcc544daa, 0xe4df0496,
+		     0x9ee3b5d1, 0x4c1b886a, 0xc1b81f2c, 0x467f5165,
+		     0x9d04ea5e, 0x015d358c, 0xfa737487, 0xfb2e410b,
+		     0xb35a1d67, 0x9252d2db, 0xe9335610, 0x6d1347d6,
+		     0x9a8c61d7, 0x377a0ca1, 0x598e14f8, 0xeb893c13,
+		     0xceee27a9, 0xb735c961, 0xe1ede51c, 0x7a3cb147,
+		     0x9c59dfd2, 0x553f73f2, 0x1879ce14, 0x73bf37c7,
+		     0x53eacdf7, 0x5f5baafd, 0xdf146f3d, 0x7886db44,
+		     0xca81f3af, 0xb93ec468, 0x382c3424, 0xc25f40a3,
+		     0x1672c31d, 0xbc0c25e2, 0x288b493c, 0xff41950d,
+		     0x397101a8, 0x08deb30c, 0xd89ce4b4, 0x6490c156,
+		     0x7b6184cb, 0xd570b632, 0x48745c6c, 0xd04257b8,
+		     }
 };
 
 const uint32_t crypto_il_tab[4][256] = {
 	{
-		0x00000052, 0x00000009, 0x0000006a, 0x000000d5,
-		0x00000030, 0x00000036, 0x000000a5, 0x00000038,
-		0x000000bf, 0x00000040, 0x000000a3, 0x0000009e,
-		0x00000081, 0x000000f3, 0x000000d7, 0x000000fb,
-		0x0000007c, 0x000000e3, 0x00000039, 0x00000082,
-		0x0000009b, 0x0000002f, 0x000000ff, 0x00000087,
-		0x00000034, 0x0000008e, 0x00000043, 0x00000044,
-		0x000000c4, 0x000000de, 0x000000e9, 0x000000cb,
-		0x00000054, 0x0000007b, 0x00000094, 0x00000032,
-		0x000000a6, 0x000000c2, 0x00000023, 0x0000003d,
-		0x000000ee, 0x0000004c, 0x00000095, 0x0000000b,
-		0x00000042, 0x000000fa, 0x000000c3, 0x0000004e,
-		0x00000008, 0x0000002e, 0x000000a1, 0x00000066,
-		0x00000028, 0x000000d9, 0x00000024, 0x000000b2,
-		0x00000076, 0x0000005b, 0x000000a2, 0x00000049,
-		0x0000006d, 0x0000008b, 0x000000d1, 0x00000025,
-		0x00000072, 0x000000f8, 0x000000f6, 0x00000064,
-		0x00000086, 0x00000068, 0x00000098, 0x00000016,
-		0x000000d4, 0x000000a4, 0x0000005c, 0x000000cc,
-		0x0000005d, 0x00000065, 0x000000b6, 0x00000092,
-		0x0000006c, 0x00000070, 0x00000048, 0x00000050,
-		0x000000fd, 0x000000ed, 0x000000b9, 0x000000da,
-		0x0000005e, 0x00000015, 0x00000046, 0x00000057,
-		0x000000a7, 0x0000008d, 0x0000009d, 0x00000084,
-		0x00000090, 0x000000d8, 0x000000ab, 0x00000000,
-		0x0000008c, 0x000000bc, 0x000000d3, 0x0000000a,
-		0x000000f7, 0x000000e4, 0x00000058, 0x00000005,
-		0x000000b8, 0x000000b3, 0x00000045, 0x00000006,
-		0x000000d0, 0x0000002c, 0x0000001e, 0x0000008f,
-		0x000000ca, 0x0000003f, 0x0000000f, 0x00000002,
-		0x000000c1, 0x000000af, 0x000000bd, 0x00000003,
-		0x00000001, 0x00000013, 0x0000008a, 0x0000006b,
-		0x0000003a, 0x00000091, 0x00000011, 0x00000041,
-		0x0000004f, 0x00000067, 0x000000dc, 0x000000ea,
-		0x00000097, 0x000000f2, 0x000000cf, 0x000000ce,
-		0x000000f0, 0x000000b4, 0x000000e6, 0x00000073,
-		0x00000096, 0x000000ac, 0x00000074, 0x00000022,
-		0x000000e7, 0x000000ad, 0x00000035, 0x00000085,
-		0x000000e2, 0x000000f9, 0x00000037, 0x000000e8,
-		0x0000001c, 0x00000075, 0x000000df, 0x0000006e,
-		0x00000047, 0x000000f1, 0x0000001a, 0x00000071,
-		0x0000001d, 0x00000029, 0x000000c5, 0x00000089,
-		0x0000006f, 0x000000b7, 0x00000062, 0x0000000e,
-		0x000000aa, 0x00000018, 0x000000be, 0x0000001b,
-		0x000000fc, 0x00000056, 0x0000003e, 0x0000004b,
-		0x000000c6, 0x000000d2, 0x00000079, 0x00000020,
-		0x0000009a, 0x000000db, 0x000000c0, 0x000000fe,
-		0x00000078, 0x000000cd, 0x0000005a, 0x000000f4,
-		0x0000001f, 0x000000dd, 0x000000a8, 0x00000033,
-		0x00000088, 0x00000007, 0x000000c7, 0x00000031,
-		0x000000b1, 0x00000012, 0x00000010, 0x00000059,
-		0x00000027, 0x00000080, 0x000000ec, 0x0000005f,
-		0x00000060, 0x00000051, 0x0000007f, 0x000000a9,
-		0x00000019, 0x000000b5, 0x0000004a, 0x0000000d,
-		0x0000002d, 0x000000e5, 0x0000007a, 0x0000009f,
-		0x00000093, 0x000000c9, 0x0000009c, 0x000000ef,
-		0x000000a0, 0x000000e0, 0x0000003b, 0x0000004d,
-		0x000000ae, 0x0000002a, 0x000000f5, 0x000000b0,
-		0x000000c8, 0x000000eb, 0x000000bb, 0x0000003c,
-		0x00000083, 0x00000053, 0x00000099, 0x00000061,
-		0x00000017, 0x0000002b, 0x00000004, 0x0000007e,
-		0x000000ba, 0x00000077, 0x000000d6, 0x00000026,
-		0x000000e1, 0x00000069, 0x00000014, 0x00000063,
-		0x00000055, 0x00000021, 0x0000000c, 0x0000007d,
-	}, {
-		0x00005200, 0x00000900, 0x00006a00, 0x0000d500,
-		0x00003000, 0x00003600, 0x0000a500, 0x00003800,
-		0x0000bf00, 0x00004000, 0x0000a300, 0x00009e00,
-		0x00008100, 0x0000f300, 0x0000d700, 0x0000fb00,
-		0x00007c00, 0x0000e300, 0x00003900, 0x00008200,
-		0x00009b00, 0x00002f00, 0x0000ff00, 0x00008700,
-		0x00003400, 0x00008e00, 0x00004300, 0x00004400,
-		0x0000c400, 0x0000de00, 0x0000e900, 0x0000cb00,
-		0x00005400, 0x00007b00, 0x00009400, 0x00003200,
-		0x0000a600, 0x0000c200, 0x00002300, 0x00003d00,
-		0x0000ee00, 0x00004c00, 0x00009500, 0x00000b00,
-		0x00004200, 0x0000fa00, 0x0000c300, 0x00004e00,
-		0x00000800, 0x00002e00, 0x0000a100, 0x00006600,
-		0x00002800, 0x0000d900, 0x00002400, 0x0000b200,
-		0x00007600, 0x00005b00, 0x0000a200, 0x00004900,
-		0x00006d00, 0x00008b00, 0x0000d100, 0x00002500,
-		0x00007200, 0x0000f800, 0x0000f600, 0x00006400,
-		0x00008600, 0x00006800, 0x00009800, 0x00001600,
-		0x0000d400, 0x0000a400, 0x00005c00, 0x0000cc00,
-		0x00005d00, 0x00006500, 0x0000b600, 0x00009200,
-		0x00006c00, 0x00007000, 0x00004800, 0x00005000,
-		0x0000fd00, 0x0000ed00, 0x0000b900, 0x0000da00,
-		0x00005e00, 0x00001500, 0x00004600, 0x00005700,
-		0x0000a700, 0x00008d00, 0x00009d00, 0x00008400,
-		0x00009000, 0x0000d800, 0x0000ab00, 0x00000000,
-		0x00008c00, 0x0000bc00, 0x0000d300, 0x00000a00,
-		0x0000f700, 0x0000e400, 0x00005800, 0x00000500,
-		0x0000b800, 0x0000b300, 0x00004500, 0x00000600,
-		0x0000d000, 0x00002c00, 0x00001e00, 0x00008f00,
-		0x0000ca00, 0x00003f00, 0x00000f00, 0x00000200,
-		0x0000c100, 0x0000af00, 0x0000bd00, 0x00000300,
-		0x00000100, 0x00001300, 0x00008a00, 0x00006b00,
-		0x00003a00, 0x00009100, 0x00001100, 0x00004100,
-		0x00004f00, 0x00006700, 0x0000dc00, 0x0000ea00,
-		0x00009700, 0x0000f200, 0x0000cf00, 0x0000ce00,
-		0x0000f000, 0x0000b400, 0x0000e600, 0x00007300,
-		0x00009600, 0x0000ac00, 0x00007400, 0x00002200,
-		0x0000e700, 0x0000ad00, 0x00003500, 0x00008500,
-		0x0000e200, 0x0000f900, 0x00003700, 0x0000e800,
-		0x00001c00, 0x00007500, 0x0000df00, 0x00006e00,
-		0x00004700, 0x0000f100, 0x00001a00, 0x00007100,
-		0x00001d00, 0x00002900, 0x0000c500, 0x00008900,
-		0x00006f00, 0x0000b700, 0x00006200, 0x00000e00,
-		0x0000aa00, 0x00001800, 0x0000be00, 0x00001b00,
-		0x0000fc00, 0x00005600, 0x00003e00, 0x00004b00,
-		0x0000c600, 0x0000d200, 0x00007900, 0x00002000,
-		0x00009a00, 0x0000db00, 0x0000c000, 0x0000fe00,
-		0x00007800, 0x0000cd00, 0x00005a00, 0x0000f400,
-		0x00001f00, 0x0000dd00, 0x0000a800, 0x00003300,
-		0x00008800, 0x00000700, 0x0000c700, 0x00003100,
-		0x0000b100, 0x00001200, 0x00001000, 0x00005900,
-		0x00002700, 0x00008000, 0x0000ec00, 0x00005f00,
-		0x00006000, 0x00005100, 0x00007f00, 0x0000a900,
-		0x00001900, 0x0000b500, 0x00004a00, 0x00000d00,
-		0x00002d00, 0x0000e500, 0x00007a00, 0x00009f00,
-		0x00009300, 0x0000c900, 0x00009c00, 0x0000ef00,
-		0x0000a000, 0x0000e000, 0x00003b00, 0x00004d00,
-		0x0000ae00, 0x00002a00, 0x0000f500, 0x0000b000,
-		0x0000c800, 0x0000eb00, 0x0000bb00, 0x00003c00,
-		0x00008300, 0x00005300, 0x00009900, 0x00006100,
-		0x00001700, 0x00002b00, 0x00000400, 0x00007e00,
-		0x0000ba00, 0x00007700, 0x0000d600, 0x00002600,
-		0x0000e100, 0x00006900, 0x00001400, 0x00006300,
-		0x00005500, 0x00002100, 0x00000c00, 0x00007d00,
-	}, {
-		0x00520000, 0x00090000, 0x006a0000, 0x00d50000,
-		0x00300000, 0x00360000, 0x00a50000, 0x00380000,
-		0x00bf0000, 0x00400000, 0x00a30000, 0x009e0000,
-		0x00810000, 0x00f30000, 0x00d70000, 0x00fb0000,
-		0x007c0000, 0x00e30000, 0x00390000, 0x00820000,
-		0x009b0000, 0x002f0000, 0x00ff0000, 0x00870000,
-		0x00340000, 0x008e0000, 0x00430000, 0x00440000,
-		0x00c40000, 0x00de0000, 0x00e90000, 0x00cb0000,
-		0x00540000, 0x007b0000, 0x00940000, 0x00320000,
-		0x00a60000, 0x00c20000, 0x00230000, 0x003d0000,
-		0x00ee0000, 0x004c0000, 0x00950000, 0x000b0000,
-		0x00420000, 0x00fa0000, 0x00c30000, 0x004e0000,
-		0x00080000, 0x002e0000, 0x00a10000, 0x00660000,
-		0x00280000, 0x00d90000, 0x00240000, 0x00b20000,
-		0x00760000, 0x005b0000, 0x00a20000, 0x00490000,
-		0x006d0000, 0x008b0000, 0x00d10000, 0x00250000,
-		0x00720000, 0x00f80000, 0x00f60000, 0x00640000,
-		0x00860000, 0x00680000, 0x00980000, 0x00160000,
-		0x00d40000, 0x00a40000, 0x005c0000, 0x00cc0000,
-		0x005d0000, 0x00650000, 0x00b60000, 0x00920000,
-		0x006c0000, 0x00700000, 0x00480000, 0x00500000,
-		0x00fd0000, 0x00ed0000, 0x00b90000, 0x00da0000,
-		0x005e0000, 0x00150000, 0x00460000, 0x00570000,
-		0x00a70000, 0x008d0000, 0x009d0000, 0x00840000,
-		0x00900000, 0x00d80000, 0x00ab0000, 0x00000000,
-		0x008c0000, 0x00bc0000, 0x00d30000, 0x000a0000,
-		0x00f70000, 0x00e40000, 0x00580000, 0x00050000,
-		0x00b80000, 0x00b30000, 0x00450000, 0x00060000,
-		0x00d00000, 0x002c0000, 0x001e0000, 0x008f0000,
-		0x00ca0000, 0x003f0000, 0x000f0000, 0x00020000,
-		0x00c10000, 0x00af0000, 0x00bd0000, 0x00030000,
-		0x00010000, 0x00130000, 0x008a0000, 0x006b0000,
-		0x003a0000, 0x00910000, 0x00110000, 0x00410000,
-		0x004f0000, 0x00670000, 0x00dc0000, 0x00ea0000,
-		0x00970000, 0x00f20000, 0x00cf0000, 0x00ce0000,
-		0x00f00000, 0x00b40000, 0x00e60000, 0x00730000,
-		0x00960000, 0x00ac0000, 0x00740000, 0x00220000,
-		0x00e70000, 0x00ad0000, 0x00350000, 0x00850000,
-		0x00e20000, 0x00f90000, 0x00370000, 0x00e80000,
-		0x001c0000, 0x00750000, 0x00df0000, 0x006e0000,
-		0x00470000, 0x00f10000, 0x001a0000, 0x00710000,
-		0x001d0000, 0x00290000, 0x00c50000, 0x00890000,
-		0x006f0000, 0x00b70000, 0x00620000, 0x000e0000,
-		0x00aa0000, 0x00180000, 0x00be0000, 0x001b0000,
-		0x00fc0000, 0x00560000, 0x003e0000, 0x004b0000,
-		0x00c60000, 0x00d20000, 0x00790000, 0x00200000,
-		0x009a0000, 0x00db0000, 0x00c00000, 0x00fe0000,
-		0x00780000, 0x00cd0000, 0x005a0000, 0x00f40000,
-		0x001f0000, 0x00dd0000, 0x00a80000, 0x00330000,
-		0x00880000, 0x00070000, 0x00c70000, 0x00310000,
-		0x00b10000, 0x00120000, 0x00100000, 0x00590000,
-		0x00270000, 0x00800000, 0x00ec0000, 0x005f0000,
-		0x00600000, 0x00510000, 0x007f0000, 0x00a90000,
-		0x00190000, 0x00b50000, 0x004a0000, 0x000d0000,
-		0x002d0000, 0x00e50000, 0x007a0000, 0x009f0000,
-		0x00930000, 0x00c90000, 0x009c0000, 0x00ef0000,
-		0x00a00000, 0x00e00000, 0x003b0000, 0x004d0000,
-		0x00ae0000, 0x002a0000, 0x00f50000, 0x00b00000,
-		0x00c80000, 0x00eb0000, 0x00bb0000, 0x003c0000,
-		0x00830000, 0x00530000, 0x00990000, 0x00610000,
-		0x00170000, 0x002b0000, 0x00040000, 0x007e0000,
-		0x00ba0000, 0x00770000, 0x00d60000, 0x00260000,
-		0x00e10000, 0x00690000, 0x00140000, 0x00630000,
-		0x00550000, 0x00210000, 0x000c0000, 0x007d0000,
-	}, {
-		0x52000000, 0x09000000, 0x6a000000, 0xd5000000,
-		0x30000000, 0x36000000, 0xa5000000, 0x38000000,
-		0xbf000000, 0x40000000, 0xa3000000, 0x9e000000,
-		0x81000000, 0xf3000000, 0xd7000000, 0xfb000000,
-		0x7c000000, 0xe3000000, 0x39000000, 0x82000000,
-		0x9b000000, 0x2f000000, 0xff000000, 0x87000000,
-		0x34000000, 0x8e000000, 0x43000000, 0x44000000,
-		0xc4000000, 0xde000000, 0xe9000000, 0xcb000000,
-		0x54000000, 0x7b000000, 0x94000000, 0x32000000,
-		0xa6000000, 0xc2000000, 0x23000000, 0x3d000000,
-		0xee000000, 0x4c000000, 0x95000000, 0x0b000000,
-		0x42000000, 0xfa000000, 0xc3000000, 0x4e000000,
-		0x08000000, 0x2e000000, 0xa1000000, 0x66000000,
-		0x28000000, 0xd9000000, 0x24000000, 0xb2000000,
-		0x76000000, 0x5b000000, 0xa2000000, 0x49000000,
-		0x6d000000, 0x8b000000, 0xd1000000, 0x25000000,
-		0x72000000, 0xf8000000, 0xf6000000, 0x64000000,
-		0x86000000, 0x68000000, 0x98000000, 0x16000000,
-		0xd4000000, 0xa4000000, 0x5c000000, 0xcc000000,
-		0x5d000000, 0x65000000, 0xb6000000, 0x92000000,
-		0x6c000000, 0x70000000, 0x48000000, 0x50000000,
-		0xfd000000, 0xed000000, 0xb9000000, 0xda000000,
-		0x5e000000, 0x15000000, 0x46000000, 0x57000000,
-		0xa7000000, 0x8d000000, 0x9d000000, 0x84000000,
-		0x90000000, 0xd8000000, 0xab000000, 0x00000000,
-		0x8c000000, 0xbc000000, 0xd3000000, 0x0a000000,
-		0xf7000000, 0xe4000000, 0x58000000, 0x05000000,
-		0xb8000000, 0xb3000000, 0x45000000, 0x06000000,
-		0xd0000000, 0x2c000000, 0x1e000000, 0x8f000000,
-		0xca000000, 0x3f000000, 0x0f000000, 0x02000000,
-		0xc1000000, 0xaf000000, 0xbd000000, 0x03000000,
-		0x01000000, 0x13000000, 0x8a000000, 0x6b000000,
-		0x3a000000, 0x91000000, 0x11000000, 0x41000000,
-		0x4f000000, 0x67000000, 0xdc000000, 0xea000000,
-		0x97000000, 0xf2000000, 0xcf000000, 0xce000000,
-		0xf0000000, 0xb4000000, 0xe6000000, 0x73000000,
-		0x96000000, 0xac000000, 0x74000000, 0x22000000,
-		0xe7000000, 0xad000000, 0x35000000, 0x85000000,
-		0xe2000000, 0xf9000000, 0x37000000, 0xe8000000,
-		0x1c000000, 0x75000000, 0xdf000000, 0x6e000000,
-		0x47000000, 0xf1000000, 0x1a000000, 0x71000000,
-		0x1d000000, 0x29000000, 0xc5000000, 0x89000000,
-		0x6f000000, 0xb7000000, 0x62000000, 0x0e000000,
-		0xaa000000, 0x18000000, 0xbe000000, 0x1b000000,
-		0xfc000000, 0x56000000, 0x3e000000, 0x4b000000,
-		0xc6000000, 0xd2000000, 0x79000000, 0x20000000,
-		0x9a000000, 0xdb000000, 0xc0000000, 0xfe000000,
-		0x78000000, 0xcd000000, 0x5a000000, 0xf4000000,
-		0x1f000000, 0xdd000000, 0xa8000000, 0x33000000,
-		0x88000000, 0x07000000, 0xc7000000, 0x31000000,
-		0xb1000000, 0x12000000, 0x10000000, 0x59000000,
-		0x27000000, 0x80000000, 0xec000000, 0x5f000000,
-		0x60000000, 0x51000000, 0x7f000000, 0xa9000000,
-		0x19000000, 0xb5000000, 0x4a000000, 0x0d000000,
-		0x2d000000, 0xe5000000, 0x7a000000, 0x9f000000,
-		0x93000000, 0xc9000000, 0x9c000000, 0xef000000,
-		0xa0000000, 0xe0000000, 0x3b000000, 0x4d000000,
-		0xae000000, 0x2a000000, 0xf5000000, 0xb0000000,
-		0xc8000000, 0xeb000000, 0xbb000000, 0x3c000000,
-		0x83000000, 0x53000000, 0x99000000, 0x61000000,
-		0x17000000, 0x2b000000, 0x04000000, 0x7e000000,
-		0xba000000, 0x77000000, 0xd6000000, 0x26000000,
-		0xe1000000, 0x69000000, 0x14000000, 0x63000000,
-		0x55000000, 0x21000000, 0x0c000000, 0x7d000000,
-	}
+	 0x00000052, 0x00000009, 0x0000006a, 0x000000d5,
+	 0x00000030, 0x00000036, 0x000000a5, 0x00000038,
+	 0x000000bf, 0x00000040, 0x000000a3, 0x0000009e,
+	 0x00000081, 0x000000f3, 0x000000d7, 0x000000fb,
+	 0x0000007c, 0x000000e3, 0x00000039, 0x00000082,
+	 0x0000009b, 0x0000002f, 0x000000ff, 0x00000087,
+	 0x00000034, 0x0000008e, 0x00000043, 0x00000044,
+	 0x000000c4, 0x000000de, 0x000000e9, 0x000000cb,
+	 0x00000054, 0x0000007b, 0x00000094, 0x00000032,
+	 0x000000a6, 0x000000c2, 0x00000023, 0x0000003d,
+	 0x000000ee, 0x0000004c, 0x00000095, 0x0000000b,
+	 0x00000042, 0x000000fa, 0x000000c3, 0x0000004e,
+	 0x00000008, 0x0000002e, 0x000000a1, 0x00000066,
+	 0x00000028, 0x000000d9, 0x00000024, 0x000000b2,
+	 0x00000076, 0x0000005b, 0x000000a2, 0x00000049,
+	 0x0000006d, 0x0000008b, 0x000000d1, 0x00000025,
+	 0x00000072, 0x000000f8, 0x000000f6, 0x00000064,
+	 0x00000086, 0x00000068, 0x00000098, 0x00000016,
+	 0x000000d4, 0x000000a4, 0x0000005c, 0x000000cc,
+	 0x0000005d, 0x00000065, 0x000000b6, 0x00000092,
+	 0x0000006c, 0x00000070, 0x00000048, 0x00000050,
+	 0x000000fd, 0x000000ed, 0x000000b9, 0x000000da,
+	 0x0000005e, 0x00000015, 0x00000046, 0x00000057,
+	 0x000000a7, 0x0000008d, 0x0000009d, 0x00000084,
+	 0x00000090, 0x000000d8, 0x000000ab, 0x00000000,
+	 0x0000008c, 0x000000bc, 0x000000d3, 0x0000000a,
+	 0x000000f7, 0x000000e4, 0x00000058, 0x00000005,
+	 0x000000b8, 0x000000b3, 0x00000045, 0x00000006,
+	 0x000000d0, 0x0000002c, 0x0000001e, 0x0000008f,
+	 0x000000ca, 0x0000003f, 0x0000000f, 0x00000002,
+	 0x000000c1, 0x000000af, 0x000000bd, 0x00000003,
+	 0x00000001, 0x00000013, 0x0000008a, 0x0000006b,
+	 0x0000003a, 0x00000091, 0x00000011, 0x00000041,
+	 0x0000004f, 0x00000067, 0x000000dc, 0x000000ea,
+	 0x00000097, 0x000000f2, 0x000000cf, 0x000000ce,
+	 0x000000f0, 0x000000b4, 0x000000e6, 0x00000073,
+	 0x00000096, 0x000000ac, 0x00000074, 0x00000022,
+	 0x000000e7, 0x000000ad, 0x00000035, 0x00000085,
+	 0x000000e2, 0x000000f9, 0x00000037, 0x000000e8,
+	 0x0000001c, 0x00000075, 0x000000df, 0x0000006e,
+	 0x00000047, 0x000000f1, 0x0000001a, 0x00000071,
+	 0x0000001d, 0x00000029, 0x000000c5, 0x00000089,
+	 0x0000006f, 0x000000b7, 0x00000062, 0x0000000e,
+	 0x000000aa, 0x00000018, 0x000000be, 0x0000001b,
+	 0x000000fc, 0x00000056, 0x0000003e, 0x0000004b,
+	 0x000000c6, 0x000000d2, 0x00000079, 0x00000020,
+	 0x0000009a, 0x000000db, 0x000000c0, 0x000000fe,
+	 0x00000078, 0x000000cd, 0x0000005a, 0x000000f4,
+	 0x0000001f, 0x000000dd, 0x000000a8, 0x00000033,
+	 0x00000088, 0x00000007, 0x000000c7, 0x00000031,
+	 0x000000b1, 0x00000012, 0x00000010, 0x00000059,
+	 0x00000027, 0x00000080, 0x000000ec, 0x0000005f,
+	 0x00000060, 0x00000051, 0x0000007f, 0x000000a9,
+	 0x00000019, 0x000000b5, 0x0000004a, 0x0000000d,
+	 0x0000002d, 0x000000e5, 0x0000007a, 0x0000009f,
+	 0x00000093, 0x000000c9, 0x0000009c, 0x000000ef,
+	 0x000000a0, 0x000000e0, 0x0000003b, 0x0000004d,
+	 0x000000ae, 0x0000002a, 0x000000f5, 0x000000b0,
+	 0x000000c8, 0x000000eb, 0x000000bb, 0x0000003c,
+	 0x00000083, 0x00000053, 0x00000099, 0x00000061,
+	 0x00000017, 0x0000002b, 0x00000004, 0x0000007e,
+	 0x000000ba, 0x00000077, 0x000000d6, 0x00000026,
+	 0x000000e1, 0x00000069, 0x00000014, 0x00000063,
+	 0x00000055, 0x00000021, 0x0000000c, 0x0000007d,
+	 }, {
+	     0x00005200, 0x00000900, 0x00006a00, 0x0000d500,
+	     0x00003000, 0x00003600, 0x0000a500, 0x00003800,
+	     0x0000bf00, 0x00004000, 0x0000a300, 0x00009e00,
+	     0x00008100, 0x0000f300, 0x0000d700, 0x0000fb00,
+	     0x00007c00, 0x0000e300, 0x00003900, 0x00008200,
+	     0x00009b00, 0x00002f00, 0x0000ff00, 0x00008700,
+	     0x00003400, 0x00008e00, 0x00004300, 0x00004400,
+	     0x0000c400, 0x0000de00, 0x0000e900, 0x0000cb00,
+	     0x00005400, 0x00007b00, 0x00009400, 0x00003200,
+	     0x0000a600, 0x0000c200, 0x00002300, 0x00003d00,
+	     0x0000ee00, 0x00004c00, 0x00009500, 0x00000b00,
+	     0x00004200, 0x0000fa00, 0x0000c300, 0x00004e00,
+	     0x00000800, 0x00002e00, 0x0000a100, 0x00006600,
+	     0x00002800, 0x0000d900, 0x00002400, 0x0000b200,
+	     0x00007600, 0x00005b00, 0x0000a200, 0x00004900,
+	     0x00006d00, 0x00008b00, 0x0000d100, 0x00002500,
+	     0x00007200, 0x0000f800, 0x0000f600, 0x00006400,
+	     0x00008600, 0x00006800, 0x00009800, 0x00001600,
+	     0x0000d400, 0x0000a400, 0x00005c00, 0x0000cc00,
+	     0x00005d00, 0x00006500, 0x0000b600, 0x00009200,
+	     0x00006c00, 0x00007000, 0x00004800, 0x00005000,
+	     0x0000fd00, 0x0000ed00, 0x0000b900, 0x0000da00,
+	     0x00005e00, 0x00001500, 0x00004600, 0x00005700,
+	     0x0000a700, 0x00008d00, 0x00009d00, 0x00008400,
+	     0x00009000, 0x0000d800, 0x0000ab00, 0x00000000,
+	     0x00008c00, 0x0000bc00, 0x0000d300, 0x00000a00,
+	     0x0000f700, 0x0000e400, 0x00005800, 0x00000500,
+	     0x0000b800, 0x0000b300, 0x00004500, 0x00000600,
+	     0x0000d000, 0x00002c00, 0x00001e00, 0x00008f00,
+	     0x0000ca00, 0x00003f00, 0x00000f00, 0x00000200,
+	     0x0000c100, 0x0000af00, 0x0000bd00, 0x00000300,
+	     0x00000100, 0x00001300, 0x00008a00, 0x00006b00,
+	     0x00003a00, 0x00009100, 0x00001100, 0x00004100,
+	     0x00004f00, 0x00006700, 0x0000dc00, 0x0000ea00,
+	     0x00009700, 0x0000f200, 0x0000cf00, 0x0000ce00,
+	     0x0000f000, 0x0000b400, 0x0000e600, 0x00007300,
+	     0x00009600, 0x0000ac00, 0x00007400, 0x00002200,
+	     0x0000e700, 0x0000ad00, 0x00003500, 0x00008500,
+	     0x0000e200, 0x0000f900, 0x00003700, 0x0000e800,
+	     0x00001c00, 0x00007500, 0x0000df00, 0x00006e00,
+	     0x00004700, 0x0000f100, 0x00001a00, 0x00007100,
+	     0x00001d00, 0x00002900, 0x0000c500, 0x00008900,
+	     0x00006f00, 0x0000b700, 0x00006200, 0x00000e00,
+	     0x0000aa00, 0x00001800, 0x0000be00, 0x00001b00,
+	     0x0000fc00, 0x00005600, 0x00003e00, 0x00004b00,
+	     0x0000c600, 0x0000d200, 0x00007900, 0x00002000,
+	     0x00009a00, 0x0000db00, 0x0000c000, 0x0000fe00,
+	     0x00007800, 0x0000cd00, 0x00005a00, 0x0000f400,
+	     0x00001f00, 0x0000dd00, 0x0000a800, 0x00003300,
+	     0x00008800, 0x00000700, 0x0000c700, 0x00003100,
+	     0x0000b100, 0x00001200, 0x00001000, 0x00005900,
+	     0x00002700, 0x00008000, 0x0000ec00, 0x00005f00,
+	     0x00006000, 0x00005100, 0x00007f00, 0x0000a900,
+	     0x00001900, 0x0000b500, 0x00004a00, 0x00000d00,
+	     0x00002d00, 0x0000e500, 0x00007a00, 0x00009f00,
+	     0x00009300, 0x0000c900, 0x00009c00, 0x0000ef00,
+	     0x0000a000, 0x0000e000, 0x00003b00, 0x00004d00,
+	     0x0000ae00, 0x00002a00, 0x0000f500, 0x0000b000,
+	     0x0000c800, 0x0000eb00, 0x0000bb00, 0x00003c00,
+	     0x00008300, 0x00005300, 0x00009900, 0x00006100,
+	     0x00001700, 0x00002b00, 0x00000400, 0x00007e00,
+	     0x0000ba00, 0x00007700, 0x0000d600, 0x00002600,
+	     0x0000e100, 0x00006900, 0x00001400, 0x00006300,
+	     0x00005500, 0x00002100, 0x00000c00, 0x00007d00,
+	     }, {
+		 0x00520000, 0x00090000, 0x006a0000, 0x00d50000,
+		 0x00300000, 0x00360000, 0x00a50000, 0x00380000,
+		 0x00bf0000, 0x00400000, 0x00a30000, 0x009e0000,
+		 0x00810000, 0x00f30000, 0x00d70000, 0x00fb0000,
+		 0x007c0000, 0x00e30000, 0x00390000, 0x00820000,
+		 0x009b0000, 0x002f0000, 0x00ff0000, 0x00870000,
+		 0x00340000, 0x008e0000, 0x00430000, 0x00440000,
+		 0x00c40000, 0x00de0000, 0x00e90000, 0x00cb0000,
+		 0x00540000, 0x007b0000, 0x00940000, 0x00320000,
+		 0x00a60000, 0x00c20000, 0x00230000, 0x003d0000,
+		 0x00ee0000, 0x004c0000, 0x00950000, 0x000b0000,
+		 0x00420000, 0x00fa0000, 0x00c30000, 0x004e0000,
+		 0x00080000, 0x002e0000, 0x00a10000, 0x00660000,
+		 0x00280000, 0x00d90000, 0x00240000, 0x00b20000,
+		 0x00760000, 0x005b0000, 0x00a20000, 0x00490000,
+		 0x006d0000, 0x008b0000, 0x00d10000, 0x00250000,
+		 0x00720000, 0x00f80000, 0x00f60000, 0x00640000,
+		 0x00860000, 0x00680000, 0x00980000, 0x00160000,
+		 0x00d40000, 0x00a40000, 0x005c0000, 0x00cc0000,
+		 0x005d0000, 0x00650000, 0x00b60000, 0x00920000,
+		 0x006c0000, 0x00700000, 0x00480000, 0x00500000,
+		 0x00fd0000, 0x00ed0000, 0x00b90000, 0x00da0000,
+		 0x005e0000, 0x00150000, 0x00460000, 0x00570000,
+		 0x00a70000, 0x008d0000, 0x009d0000, 0x00840000,
+		 0x00900000, 0x00d80000, 0x00ab0000, 0x00000000,
+		 0x008c0000, 0x00bc0000, 0x00d30000, 0x000a0000,
+		 0x00f70000, 0x00e40000, 0x00580000, 0x00050000,
+		 0x00b80000, 0x00b30000, 0x00450000, 0x00060000,
+		 0x00d00000, 0x002c0000, 0x001e0000, 0x008f0000,
+		 0x00ca0000, 0x003f0000, 0x000f0000, 0x00020000,
+		 0x00c10000, 0x00af0000, 0x00bd0000, 0x00030000,
+		 0x00010000, 0x00130000, 0x008a0000, 0x006b0000,
+		 0x003a0000, 0x00910000, 0x00110000, 0x00410000,
+		 0x004f0000, 0x00670000, 0x00dc0000, 0x00ea0000,
+		 0x00970000, 0x00f20000, 0x00cf0000, 0x00ce0000,
+		 0x00f00000, 0x00b40000, 0x00e60000, 0x00730000,
+		 0x00960000, 0x00ac0000, 0x00740000, 0x00220000,
+		 0x00e70000, 0x00ad0000, 0x00350000, 0x00850000,
+		 0x00e20000, 0x00f90000, 0x00370000, 0x00e80000,
+		 0x001c0000, 0x00750000, 0x00df0000, 0x006e0000,
+		 0x00470000, 0x00f10000, 0x001a0000, 0x00710000,
+		 0x001d0000, 0x00290000, 0x00c50000, 0x00890000,
+		 0x006f0000, 0x00b70000, 0x00620000, 0x000e0000,
+		 0x00aa0000, 0x00180000, 0x00be0000, 0x001b0000,
+		 0x00fc0000, 0x00560000, 0x003e0000, 0x004b0000,
+		 0x00c60000, 0x00d20000, 0x00790000, 0x00200000,
+		 0x009a0000, 0x00db0000, 0x00c00000, 0x00fe0000,
+		 0x00780000, 0x00cd0000, 0x005a0000, 0x00f40000,
+		 0x001f0000, 0x00dd0000, 0x00a80000, 0x00330000,
+		 0x00880000, 0x00070000, 0x00c70000, 0x00310000,
+		 0x00b10000, 0x00120000, 0x00100000, 0x00590000,
+		 0x00270000, 0x00800000, 0x00ec0000, 0x005f0000,
+		 0x00600000, 0x00510000, 0x007f0000, 0x00a90000,
+		 0x00190000, 0x00b50000, 0x004a0000, 0x000d0000,
+		 0x002d0000, 0x00e50000, 0x007a0000, 0x009f0000,
+		 0x00930000, 0x00c90000, 0x009c0000, 0x00ef0000,
+		 0x00a00000, 0x00e00000, 0x003b0000, 0x004d0000,
+		 0x00ae0000, 0x002a0000, 0x00f50000, 0x00b00000,
+		 0x00c80000, 0x00eb0000, 0x00bb0000, 0x003c0000,
+		 0x00830000, 0x00530000, 0x00990000, 0x00610000,
+		 0x00170000, 0x002b0000, 0x00040000, 0x007e0000,
+		 0x00ba0000, 0x00770000, 0x00d60000, 0x00260000,
+		 0x00e10000, 0x00690000, 0x00140000, 0x00630000,
+		 0x00550000, 0x00210000, 0x000c0000, 0x007d0000,
+		 }, {
+		     0x52000000, 0x09000000, 0x6a000000, 0xd5000000,
+		     0x30000000, 0x36000000, 0xa5000000, 0x38000000,
+		     0xbf000000, 0x40000000, 0xa3000000, 0x9e000000,
+		     0x81000000, 0xf3000000, 0xd7000000, 0xfb000000,
+		     0x7c000000, 0xe3000000, 0x39000000, 0x82000000,
+		     0x9b000000, 0x2f000000, 0xff000000, 0x87000000,
+		     0x34000000, 0x8e000000, 0x43000000, 0x44000000,
+		     0xc4000000, 0xde000000, 0xe9000000, 0xcb000000,
+		     0x54000000, 0x7b000000, 0x94000000, 0x32000000,
+		     0xa6000000, 0xc2000000, 0x23000000, 0x3d000000,
+		     0xee000000, 0x4c000000, 0x95000000, 0x0b000000,
+		     0x42000000, 0xfa000000, 0xc3000000, 0x4e000000,
+		     0x08000000, 0x2e000000, 0xa1000000, 0x66000000,
+		     0x28000000, 0xd9000000, 0x24000000, 0xb2000000,
+		     0x76000000, 0x5b000000, 0xa2000000, 0x49000000,
+		     0x6d000000, 0x8b000000, 0xd1000000, 0x25000000,
+		     0x72000000, 0xf8000000, 0xf6000000, 0x64000000,
+		     0x86000000, 0x68000000, 0x98000000, 0x16000000,
+		     0xd4000000, 0xa4000000, 0x5c000000, 0xcc000000,
+		     0x5d000000, 0x65000000, 0xb6000000, 0x92000000,
+		     0x6c000000, 0x70000000, 0x48000000, 0x50000000,
+		     0xfd000000, 0xed000000, 0xb9000000, 0xda000000,
+		     0x5e000000, 0x15000000, 0x46000000, 0x57000000,
+		     0xa7000000, 0x8d000000, 0x9d000000, 0x84000000,
+		     0x90000000, 0xd8000000, 0xab000000, 0x00000000,
+		     0x8c000000, 0xbc000000, 0xd3000000, 0x0a000000,
+		     0xf7000000, 0xe4000000, 0x58000000, 0x05000000,
+		     0xb8000000, 0xb3000000, 0x45000000, 0x06000000,
+		     0xd0000000, 0x2c000000, 0x1e000000, 0x8f000000,
+		     0xca000000, 0x3f000000, 0x0f000000, 0x02000000,
+		     0xc1000000, 0xaf000000, 0xbd000000, 0x03000000,
+		     0x01000000, 0x13000000, 0x8a000000, 0x6b000000,
+		     0x3a000000, 0x91000000, 0x11000000, 0x41000000,
+		     0x4f000000, 0x67000000, 0xdc000000, 0xea000000,
+		     0x97000000, 0xf2000000, 0xcf000000, 0xce000000,
+		     0xf0000000, 0xb4000000, 0xe6000000, 0x73000000,
+		     0x96000000, 0xac000000, 0x74000000, 0x22000000,
+		     0xe7000000, 0xad000000, 0x35000000, 0x85000000,
+		     0xe2000000, 0xf9000000, 0x37000000, 0xe8000000,
+		     0x1c000000, 0x75000000, 0xdf000000, 0x6e000000,
+		     0x47000000, 0xf1000000, 0x1a000000, 0x71000000,
+		     0x1d000000, 0x29000000, 0xc5000000, 0x89000000,
+		     0x6f000000, 0xb7000000, 0x62000000, 0x0e000000,
+		     0xaa000000, 0x18000000, 0xbe000000, 0x1b000000,
+		     0xfc000000, 0x56000000, 0x3e000000, 0x4b000000,
+		     0xc6000000, 0xd2000000, 0x79000000, 0x20000000,
+		     0x9a000000, 0xdb000000, 0xc0000000, 0xfe000000,
+		     0x78000000, 0xcd000000, 0x5a000000, 0xf4000000,
+		     0x1f000000, 0xdd000000, 0xa8000000, 0x33000000,
+		     0x88000000, 0x07000000, 0xc7000000, 0x31000000,
+		     0xb1000000, 0x12000000, 0x10000000, 0x59000000,
+		     0x27000000, 0x80000000, 0xec000000, 0x5f000000,
+		     0x60000000, 0x51000000, 0x7f000000, 0xa9000000,
+		     0x19000000, 0xb5000000, 0x4a000000, 0x0d000000,
+		     0x2d000000, 0xe5000000, 0x7a000000, 0x9f000000,
+		     0x93000000, 0xc9000000, 0x9c000000, 0xef000000,
+		     0xa0000000, 0xe0000000, 0x3b000000, 0x4d000000,
+		     0xae000000, 0x2a000000, 0xf5000000, 0xb0000000,
+		     0xc8000000, 0xeb000000, 0xbb000000, 0x3c000000,
+		     0x83000000, 0x53000000, 0x99000000, 0x61000000,
+		     0x17000000, 0x2b000000, 0x04000000, 0x7e000000,
+		     0xba000000, 0x77000000, 0xd6000000, 0x26000000,
+		     0xe1000000, 0x69000000, 0x14000000, 0x63000000,
+		     0x55000000, 0x21000000, 0x0c000000, 0x7d000000,
+		     }
 };
 
 /* initialise the key schedule from the user supplied key */
@@ -1212,14 +1212,14 @@ const uint32_t crypto_il_tab[4][256] = {
  * described in FIPS-197. The first slot (16 bytes) of each key (enc or dec) is
  * for the initial combination, the second slot for the first round and so on.
  */
-int crypto_aes_expand_key(struct crypto_aes_ctx *ctx, const uint8_t *in_key,
-		unsigned int key_len)
+int crypto_aes_expand_key(struct crypto_aes_ctx *ctx, const uint8_t * in_key,
+			  unsigned int key_len)
 {
 	const uint32_t *key = (const uint32_t *)in_key;
 	uint32_t i, t, u, v, w, j;
 
 	if (key_len != AES_KEYSIZE_128 && key_len != AES_KEYSIZE_192 &&
-			key_len != AES_KEYSIZE_256)
+	    key_len != AES_KEYSIZE_256)
 		return -1;
 
 	ctx->key_length = key_len;
@@ -1296,10 +1296,11 @@ int crypto_aes_expand_key(struct crypto_aes_ctx *ctx, const uint8_t *in_key,
 	f_rl(bo, bi, 3, k);	\
 } while (0)
 
-static void aes_encrypt(const struct crypto_aes_ctx *ctx, uint8_t *out, const uint8_t *in)
+static void aes_encrypt(const struct crypto_aes_ctx *ctx, uint8_t * out,
+			const uint8_t * in)
 {
 	const uint32_t *src = (const uint32_t *)in;
-	uint32_t *dst = (uint32_t *)out;
+	uint32_t *dst = (uint32_t *) out;
 	uint32_t b0[4], b1[4];
 	const uint32_t *kp = ctx->key_enc + 4;
 	const int key_len = ctx->key_length;
@@ -1367,25 +1368,26 @@ static void aes_encrypt(const struct crypto_aes_ctx *ctx, uint8_t *out, const ui
 	i_rl(bo, bi, 3, k);	\
 } while (0)
 
-static inline void crypto_xor_byte(uint8_t *a, const uint8_t *b, unsigned int size)
+static inline void crypto_xor_byte(uint8_t * a, const uint8_t * b,
+				   unsigned int size)
 {
 	for (; size; size--)
 		*a++ ^= *b++;
 }
 
-void crypto_xor(uint8_t *dst, const uint8_t *src, unsigned int size)
+void crypto_xor(uint8_t * dst, const uint8_t * src, unsigned int size)
 {
-	uint32_t *a = (uint32_t *)dst;
-	uint32_t *b = (uint32_t *)src;
+	uint32_t *a = (uint32_t *) dst;
+	uint32_t *b = (uint32_t *) src;
 
 	for (; size >= 4; size -= 4)
 		*a++ ^= *b++;
 
-	crypto_xor_byte((uint8_t *)a, (uint8_t *)b, size);
+	crypto_xor_byte((uint8_t *) a, (uint8_t *) b, size);
 }
 
 int crypto_cbc_encrypt(const struct crypto_aes_ctx *ctx,
-	void* src, int nbytes, void* dst, void* iv)
+		       void *src, int nbytes, void *dst, void *iv)
 {
 	int bsize = 16;
 
diff --git a/examples/shm/shm.c b/examples/shm/shm.c
index 2469115..fd2c2ce 100644
--- a/examples/shm/shm.c
+++ b/examples/shm/shm.c
@@ -12,7 +12,7 @@ sem_t *enc_sem, *get_sem;
 
 #define SHM_SIZE 64*1024
 
-void child(pid_t parent, void* mem)
+void child(pid_t parent, void *mem)
 {
 	char key[16];
 	char iv[16];
@@ -24,9 +24,9 @@ void child(pid_t parent, void* mem)
 		memset(iv, 0x3, sizeof(iv));
 
 		sem_wait(enc_sem);
-		
-		crypto_aes_expand_key(&ctx, (void*)key, sizeof(key));
-		
+
+		crypto_aes_expand_key(&ctx, (void *)key, sizeof(key));
+
 		memcpy(&mem_size, mem, sizeof(mem_size));
 
 		crypto_cbc_encrypt(&ctx, mem, mem_size, mem, iv);
@@ -39,47 +39,48 @@ static int must_finish = 0;
 
 static void alarm_handler(int signo)
 {
-        must_finish = 1;
+	must_finish = 1;
 }
 
 static double udifftimeval(struct timeval start, struct timeval end)
 {
-        return (double)(end.tv_usec - start.tv_usec) +
-               (double)(end.tv_sec - start.tv_sec) * 1000 * 1000;
+	return (double)(end.tv_usec - start.tv_usec) +
+	    (double)(end.tv_sec - start.tv_sec) * 1000 * 1000;
 }
 
-static void value2human(double bytes, double time, double* data, double* speed,char* metric)
+static void value2human(double bytes, double time, double *data, double *speed,
+			char *metric)
 {
-        if (bytes > 1000 && bytes < 1000*1000) {
-                *data = ((double)bytes)/1000;
-                *speed = *data/time;
-                strcpy(metric, "Kb");
-                return;
-        } else if (bytes >= 1000*1000 && bytes < 1000*1000*1000) {
-                *data = ((double)bytes)/(1000*1000);
-                *speed = *data/time;
-                strcpy(metric, "Mb");
-                return;
-        } else if (bytes >= 1000*1000*1000) {
-                *data = ((double)bytes)/(1000*1000*1000);
-                *speed = *data/time;
-                strcpy(metric, "Gb");
-                return;
-        } else {
-                *data = (double)bytes;
-                *speed = *data/time;
-                strcpy(metric, "bytes");
-                return;
-        }
+	if (bytes > 1000 && bytes < 1000 * 1000) {
+		*data = ((double)bytes) / 1000;
+		*speed = *data / time;
+		strcpy(metric, "Kb");
+		return;
+	} else if (bytes >= 1000 * 1000 && bytes < 1000 * 1000 * 1000) {
+		*data = ((double)bytes) / (1000 * 1000);
+		*speed = *data / time;
+		strcpy(metric, "Mb");
+		return;
+	} else if (bytes >= 1000 * 1000 * 1000) {
+		*data = ((double)bytes) / (1000 * 1000 * 1000);
+		*speed = *data / time;
+		strcpy(metric, "Gb");
+		return;
+	} else {
+		*data = (double)bytes;
+		*speed = *data / time;
+		strcpy(metric, "bytes");
+		return;
+	}
 }
 
-void parent(pid_t child, void* mem)
+void parent(pid_t child, void *mem)
 {
-struct timeval start, end;
-uint32_t chunksize;
-double total = 0;
-double secs, ddata, dspeed;
-char metric[16];
+	struct timeval start, end;
+	uint32_t chunksize;
+	double total = 0;
+	double secs, ddata, dspeed;
+	char metric[16];
 
 	signal(SIGALRM, alarm_handler);
 
@@ -90,27 +91,27 @@ char metric[16];
 
 		printf("\tEncrypting in chunks of %d bytes: ", chunksize);
 		fflush(stdout);
-		
+
 		total = 0;
 		must_finish = 0;
 		alarm(5);
 		gettimeofday(&start, NULL);
-		
+
 		do {
 			memcpy(mem, &chunksize, sizeof(chunksize));
 
 			sem_post(enc_sem);
 
 			sem_wait(get_sem);
-			total+=chunksize;
-		} while(must_finish == 0);
-		
+			total += chunksize;
+		} while (must_finish == 0);
+
 		gettimeofday(&end, NULL);
-		
-		secs = udifftimeval(start, end)/ 1000000.0;
+
+		secs = udifftimeval(start, end) / 1000000.0;
 		value2human(total, secs, &ddata, &dspeed, metric);
-		printf ("done. %.2f %s in %.2f secs: ", ddata, metric, secs);
-		printf ("%.2f %s/sec\n", dspeed, metric);
+		printf("done. %.2f %s in %.2f secs: ", ddata, metric, secs);
+		printf("%.2f %s/sec\n", dspeed, metric);
 	}
 
 }
@@ -120,36 +121,37 @@ int main()
 	int shmid, shmid2;
 	char c, *shm, *s, *semmem;
 	pid_t pid;
-	
+
 	signal(SIGUSR1, SIG_IGN);
 	signal(SIGUSR2, SIG_IGN);
-	
+
 	if ((shmid = shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT | 0660)) < 0) {
 		perror("shmget fail");
 		return 1;
 	}
 
-	if ((shm = (char *) shmat(shmid, 0, 0)) == (char *) -1) {
+	if ((shm = (char *)shmat(shmid, 0, 0)) == (char *)-1) {
 		perror("shmat : parent");
 		return 2;
 	}
 
-	if ((shmid2 = shmget(IPC_PRIVATE, 2*sizeof(sem_t), IPC_CREAT | 0660)) < 0) {
+	if ((shmid2 =
+	     shmget(IPC_PRIVATE, 2 * sizeof(sem_t), IPC_CREAT | 0660)) < 0) {
 		perror("shmget fail");
 		return 1;
 	}
 
-	if ((semmem = (char *) shmat(shmid2, 0, 0)) == (char *) -1) {
+	if ((semmem = (char *)shmat(shmid2, 0, 0)) == (char *)-1) {
 		perror("shmat : parent");
 		return 2;
 	}
-	
-	enc_sem = (void*)semmem;
-	get_sem = (void*)semmem + sizeof(sem_t);
-	
+
+	enc_sem = (void *)semmem;
+	get_sem = (void *)semmem + sizeof(sem_t);
+
 	sem_init(enc_sem, 1, 0);
 	sem_init(get_sem, 1, 0);
-	
+
 	printf("Addresses in parent\n");
 	printf("shared mem: %p\n", shm);
 
@@ -158,7 +160,7 @@ int main()
 		*s++ = c;
 	*s = '\0';		// terminate the sequence
 
-	switch (pid=fork()) {
+	switch (pid = fork()) {
 	case -1:
 		perror("fork");
 		return 3;
@@ -167,7 +169,7 @@ int main()
 		kill(pid, SIGTERM);
 		wait(0);	// let the child finish
 		shmdt(shm);
-		shmctl(shmid, IPC_RMID, (struct shmid_ds *) 0);
+		shmctl(shmid, IPC_RMID, (struct shmid_ds *)0);
 		break;
 	case 0:
 		child(getppid(), shm);
diff --git a/examples/speed.c b/examples/speed.c
index 70a2ed8..8d3563a 100644
--- a/examples/speed.c
+++ b/examples/speed.c
@@ -37,42 +37,42 @@
 static double udifftimeval(struct timeval start, struct timeval end)
 {
 	return (double)(end.tv_usec - start.tv_usec) +
-	       (double)(end.tv_sec - start.tv_sec) * 1000 * 1000;
+	    (double)(end.tv_sec - start.tv_sec) * 1000 * 1000;
 }
 
 static int must_finish = 0;
 
 static void alarm_handler(int signo)
 {
-        must_finish = 1;
+	must_finish = 1;
 }
 
-static void value2human(double bytes, double time, double* data, double* speed,char* metric)
+static void value2human(double bytes, double time, double *data, double *speed,
+			char *metric)
 {
-        if (bytes > 1000 && bytes < 1000*1000) {
-                *data = ((double)bytes)/1000;
-                *speed = *data/time;
-                strcpy(metric, "Kb");
-                return;
-        } else if (bytes >= 1000*1000 && bytes < 1000*1000*1000) {
-                *data = ((double)bytes)/(1000*1000);
-                *speed = *data/time;
-                strcpy(metric, "Mb");
-                return;
-        } else if (bytes >= 1000*1000*1000) {
-                *data = ((double)bytes)/(1000*1000*1000);
-                *speed = *data/time;
-                strcpy(metric, "Gb");
-                return;
-        } else {
-                *data = (double)bytes;
-                *speed = *data/time;
-                strcpy(metric, "bytes");
-                return;
-        }
+	if (bytes > 1000 && bytes < 1000 * 1000) {
+		*data = ((double)bytes) / 1000;
+		*speed = *data / time;
+		strcpy(metric, "Kb");
+		return;
+	} else if (bytes >= 1000 * 1000 && bytes < 1000 * 1000 * 1000) {
+		*data = ((double)bytes) / (1000 * 1000);
+		*speed = *data / time;
+		strcpy(metric, "Mb");
+		return;
+	} else if (bytes >= 1000 * 1000 * 1000) {
+		*data = ((double)bytes) / (1000 * 1000 * 1000);
+		*speed = *data / time;
+		strcpy(metric, "Gb");
+		return;
+	} else {
+		*data = (double)bytes;
+		*speed = *data / time;
+		strcpy(metric, "bytes");
+		return;
+	}
 }
 
-
 int encrypt_data_ncr_direct(int cfd, const char *algo, int chunksize)
 {
 	char *buffer, iv[32];
@@ -82,14 +82,14 @@ int encrypt_data_ncr_direct(int cfd, const char *algo, int chunksize)
 	double secs, ddata, dspeed;
 	char metric[16];
 	ncr_key_t key;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_key_generate f;
 		struct nlattr algo_head ALIGN_NL;
 		char algo[sizeof(ALG_AES_CBC)] ALIGN_NL;
 		struct nlattr bits_head ALIGN_NL;
 		uint32_t bits ALIGN_NL;
 	} kgen;
-	struct __attribute__((packed)) {
+	struct __attribute__ ((packed)) {
 		struct ncr_session_once f;
 		struct nlattr key_head ALIGN_NL;
 		uint32_t key ALIGN_NL;
@@ -119,7 +119,7 @@ int encrypt_data_ncr_direct(int cfd, const char *algo, int chunksize)
 	strcpy(kgen.algo, ALG_AES_CBC);
 	kgen.bits_head.nla_len = NLA_HDRLEN + sizeof(kgen.bits);
 	kgen.bits_head.nla_type = NCR_ATTR_SECRET_KEY_BITS;
-	kgen.bits = 128; /* 16 bytes */
+	kgen.bits = 128;	/* 16 bytes */
 
 	if (ioctl(cfd, NCRIO_KEY_GENERATE, &kgen)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -127,7 +127,6 @@ int encrypt_data_ncr_direct(int cfd, const char *algo, int chunksize)
 		return 1;
 	}
 
-
 	buffer = malloc(chunksize);
 	memset(iv, 0x23, 32);
 
@@ -170,15 +169,15 @@ int encrypt_data_ncr_direct(int cfd, const char *algo, int chunksize)
 			return 1;
 		}
 
-		total+=chunksize;
-	} while(must_finish==0);
+		total += chunksize;
+	} while (must_finish == 0);
 	gettimeofday(&end, NULL);
 
-	secs = udifftimeval(start, end)/ 1000000.0;
-	
+	secs = udifftimeval(start, end) / 1000000.0;
+
 	value2human(total, secs, &ddata, &dspeed, metric);
-	printf ("done. %.2f %s in %.2f secs: ", ddata, metric, secs);
-	printf ("%.2f %s/sec\n", dspeed, metric);
+	printf("done. %.2f %s in %.2f secs: ", ddata, metric, secs);
+	printf("%.2f %s/sec\n", dspeed, metric);
 
 	return 0;
 }
@@ -200,7 +199,6 @@ int main(void)
 			break;
 	}
 
-
 	fprintf(stderr, "\nTesting NCR-DIRECT with AES-128-CBC cipher: \n");
 	for (i = 256; i <= (64 * 1024); i *= 2) {
 		if (encrypt_data_ncr_direct(fd, "cbc(aes)", i))
diff --git a/ncr-dh.c b/ncr-dh.c
index 501eaa3..733c9d7 100644
--- a/ncr-dh.c
+++ b/ncr-dh.c
@@ -52,7 +52,7 @@ int dh_import_params(dh_key * key, uint8_t * p, size_t p_size, uint8_t * g,
 	}
 
 	if ((err =
-	     mp_read_unsigned_bin(&key->p, (unsigned char *) p,
+	     mp_read_unsigned_bin(&key->p, (unsigned char *)p,
 				  p_size)) != CRYPT_OK) {
 		err();
 		ret = _ncr_tomerr(err);
@@ -60,7 +60,7 @@ int dh_import_params(dh_key * key, uint8_t * p, size_t p_size, uint8_t * g,
 	}
 
 	if ((err =
-	     mp_read_unsigned_bin(&key->g, (unsigned char *) g,
+	     mp_read_unsigned_bin(&key->g, (unsigned char *)g,
 				  g_size)) != CRYPT_OK) {
 		err();
 		ret = _ncr_tomerr(err);
@@ -68,7 +68,7 @@ int dh_import_params(dh_key * key, uint8_t * p, size_t p_size, uint8_t * g,
 	}
 
 	return 0;
-      fail:
+fail:
 	mp_clear_multi(&key->p, &key->g, &key->x, &key->y, NULL);
 
 	return ret;
@@ -95,7 +95,8 @@ int dh_generate_key(dh_key * key)
 	do {
 		get_random_bytes(buf, size);
 
-		if ((err = mp_read_unsigned_bin(&key->x, buf, size)) != CRYPT_OK) {
+		if ((err =
+		     mp_read_unsigned_bin(&key->x, buf, size)) != CRYPT_OK) {
 			err();
 			ret = _ncr_tomerr(err);
 			goto fail;
@@ -107,12 +108,13 @@ int dh_generate_key(dh_key * key)
 			ret = _ncr_tomerr(err);
 			goto fail;
 		}
-	} while(mp_cmp_d(&key->x, 0) == MP_EQ || mp_cmp_d(&key->x, 1) == MP_EQ);
+	} while (mp_cmp_d(&key->x, 0) == MP_EQ
+		 || mp_cmp_d(&key->x, 1) == MP_EQ);
 
 	key->type = PK_PRIVATE;
 
 	ret = 0;
-      fail:
+fail:
 	kfree(buf);
 
 	return ret;
@@ -123,8 +125,7 @@ int dh_generate_public(dh_key * public, dh_key * private)
 {
 	int err, ret;
 
-	err =
-	    mp_exptmod(&private->g, &private->x, &private->p, &public->y);
+	err = mp_exptmod(&private->g, &private->x, &private->p, &public->y);
 	if (err != CRYPT_OK) {
 		err();
 		ret = _ncr_tomerr(err);
@@ -134,12 +135,12 @@ int dh_generate_public(dh_key * public, dh_key * private)
 	public->type = PK_PUBLIC;
 
 	ret = 0;
-      fail:
+fail:
 
 	return ret;
 }
 
-int dh_export(uint8_t * out, unsigned long * outlen, int type, dh_key * key)
+int dh_export(uint8_t * out, unsigned long *outlen, int type, dh_key * key)
 {
 	unsigned long zero = 0;
 	int err;
@@ -164,28 +165,29 @@ int dh_export(uint8_t * out, unsigned long * outlen, int type, dh_key * key)
 	 */
 	if (type == PK_PRIVATE) {
 		err = der_encode_sequence_multi(out, outlen,
-					LTC_ASN1_SHORT_INTEGER, 1UL, &zero, 
-					LTC_ASN1_INTEGER, 1UL, &key->p, 
-					LTC_ASN1_INTEGER, 1UL, &key->g,
-					LTC_ASN1_INTEGER, 1UL, &key->x, 
-					LTC_ASN1_EOL, 0UL, NULL);
+						LTC_ASN1_SHORT_INTEGER, 1UL,
+						&zero, LTC_ASN1_INTEGER, 1UL,
+						&key->p, LTC_ASN1_INTEGER, 1UL,
+						&key->g, LTC_ASN1_INTEGER, 1UL,
+						&key->x, LTC_ASN1_EOL, 0UL,
+						NULL);
 	} else {
 		err = mp_unsigned_bin_size(&key->y);
 		if (err > *outlen) {
 			err();
 			return -EOVERFLOW;
 		}
-		
+
 		*outlen = err;
 
 		err = mp_to_unsigned_bin(&key->y, out);
 	}
-	
+
 	if (err != CRYPT_OK) {
 		err();
 		return _ncr_tomerr(err);
 	}
-	
+
 	return 0;
 }
 
@@ -200,18 +202,18 @@ int dh_import(const uint8_t * in, size_t inlen, dh_key * key)
 	}
 
 	/* init key */
-	if (mp_init_multi
-	    (&key->p, &key->g, &key->x, &key->y, NULL) != CRYPT_OK) {
+	if (mp_init_multi(&key->p, &key->g, &key->x, &key->y, NULL) != CRYPT_OK) {
 		return -ENOMEM;
 	}
 
 	/* get key type */
 	if ((err = der_decode_sequence_multi(in, inlen,
-				LTC_ASN1_SHORT_INTEGER, 1UL, &zero, 
-				LTC_ASN1_INTEGER, 1UL, &key->p, 
-				LTC_ASN1_INTEGER, 1UL, &key->g,
-				LTC_ASN1_INTEGER, 1UL, &key->x,
-				LTC_ASN1_EOL, 0UL, NULL)) == CRYPT_OK) {
+					     LTC_ASN1_SHORT_INTEGER, 1UL, &zero,
+					     LTC_ASN1_INTEGER, 1UL, &key->p,
+					     LTC_ASN1_INTEGER, 1UL, &key->g,
+					     LTC_ASN1_INTEGER, 1UL, &key->x,
+					     LTC_ASN1_EOL, 0UL,
+					     NULL)) == CRYPT_OK) {
 		key->type = PK_PRIVATE;
 	} else {		/* public */
 		err = mp_read_unsigned_bin(&key->y, in, inlen);
@@ -224,41 +226,41 @@ int dh_import(const uint8_t * in, size_t inlen, dh_key * key)
 
 	return 0;
 
-      LBL_ERR:
+LBL_ERR:
 	mp_clear_multi(&key->p, &key->g, &key->x, &key->y, NULL);
 	return _ncr_tomerr(err);
 }
 
-int dh_derive_gxy(struct key_item_st* newkey, dh_key * key,
-	void* pk, size_t pk_size)
+int dh_derive_gxy(struct key_item_st *newkey, dh_key * key,
+		  void *pk, size_t pk_size)
 {
-int ret, err;
-mp_int y, gxy;
+	int ret, err;
+	mp_int y, gxy;
 	/* newkey will be a secret key with value of g^{xy}
 	 */
-	
+
 	if (mp_init_multi(&y, &gxy, NULL) != CRYPT_OK) {
 		err();
 		return -ENOMEM;
 	}
-	
+
 	if (key->type != PK_PRIVATE) {
 		err();
 		return -EINVAL;
 	}
 
-	if ((err=mp_read_unsigned_bin(&y, pk, pk_size)) != CRYPT_OK) {
+	if ((err = mp_read_unsigned_bin(&y, pk, pk_size)) != CRYPT_OK) {
 		err();
 		ret = _ncr_tomerr(err);
 		goto fail;
 	}
-	
-	if ((err=mp_exptmod(&y, &key->x, &key->p, &gxy))!= CRYPT_OK) {
+
+	if ((err = mp_exptmod(&y, &key->x, &key->p, &gxy)) != CRYPT_OK) {
 		err();
 		ret = _ncr_tomerr(err);
 		goto fail;
 	}
-	
+
 	err = mp_unsigned_bin_size(&gxy);
 	if (err > NCR_CIPHER_MAX_KEY_LEN) {
 		err();
@@ -279,18 +281,18 @@ mp_int y, gxy;
 	ret = 0;
 fail:
 	mp_clear_multi(&y, &gxy, NULL);
-	
+
 	return ret;
-}	
+}
 
-int ncr_pk_get_dh_size( dh_key* key)
+int ncr_pk_get_dh_size(dh_key * key)
 {
-int ret;
+	int ret;
 	ret = mp_count_bits(&key->p);
 	if (ret <= 0) {
 		err();
 		return -EINVAL;
 	}
-	
+
 	return ret;
 }
diff --git a/ncr-dh.h b/ncr-dh.h
index 183f790..a185871 100644
--- a/ncr-dh.h
+++ b/ncr-dh.h
@@ -4,24 +4,25 @@
 #include <tomcrypt.h>
 
 typedef struct {
-	int type; /* PK_PRIVATE or PK_PUBLIC */
+	int type;		/* PK_PRIVATE or PK_PUBLIC */
 	mp_int p;
 	mp_int g;
-	mp_int x; /* private */
-	mp_int y; /* public: y=g^x */
+	mp_int x;		/* private */
+	mp_int y;		/* public: y=g^x */
 } dh_key;
 
 int dh_generate_key(dh_key * key);
-int dh_import_params(dh_key * key, uint8_t* p, size_t p_size, uint8_t* g, size_t g_size);
+int dh_import_params(dh_key * key, uint8_t * p, size_t p_size, uint8_t * g,
+		     size_t g_size);
 void dh_free(dh_key * key);
-int dh_generate_public(dh_key * public, dh_key* private);
+int dh_generate_public(dh_key * public, dh_key * private);
 
-int dh_export(uint8_t *out, unsigned long *outlen, int type, dh_key *key);
-int dh_import(const uint8_t *in, size_t inlen, dh_key *key);
+int dh_export(uint8_t * out, unsigned long *outlen, int type, dh_key * key);
+int dh_import(const uint8_t * in, size_t inlen, dh_key * key);
 
-int dh_derive_gxy(struct key_item_st* newkey, dh_key * key,
-	void* pk, size_t pk_size);
+int dh_derive_gxy(struct key_item_st *newkey, dh_key * key,
+		  void *pk, size_t pk_size);
 
-int ncr_pk_get_dh_size( dh_key* key);
+int ncr_pk_get_dh_size(dh_key * key);
 
 #endif
diff --git a/ncr-int.h b/ncr-int.h
index 400cf7e..e09eb5c 100644
--- a/ncr-int.h
+++ b/ncr-int.h
@@ -26,7 +26,7 @@ typedef enum {
 
 	NCR_ALG_3DES_CBC,
 	NCR_ALG_3DES_ECB,
-	
+
 	NCR_ALG_AES_ECB,
 	NCR_ALG_AES_CBC,
 	NCR_ALG_AES_CTR,
@@ -34,15 +34,15 @@ typedef enum {
 	NCR_ALG_CAMELIA_ECB,
 	NCR_ALG_CAMELIA_CBC,
 	NCR_ALG_CAMELIA_CTR,
-	
-	NCR_ALG_MD5=200,
+
+	NCR_ALG_MD5 = 200,
 	NCR_ALG_SHA1,
 	NCR_ALG_SHA2_224,
 	NCR_ALG_SHA2_256,
 	NCR_ALG_SHA2_384,
 	NCR_ALG_SHA2_512,
 
-	NCR_ALG_RSA=600,
+	NCR_ALG_RSA = 600,
 	NCR_ALG_DSA,
 	NCR_ALG_DH,
 } ncr_algorithm_t;
@@ -61,7 +61,7 @@ struct algo_properties_st {
 	unsigned can_sign:1;
 	unsigned can_digest:1;
 	unsigned can_encrypt:1;
-	unsigned can_kx:1; /* key exchange */
+	unsigned can_kx:1;	/* key exchange */
 	unsigned is_symmetric:1;
 	unsigned is_pk:1;
 	unsigned has_transparent_hash:1;
@@ -78,7 +78,7 @@ struct key_item_st {
 	 */
 	ncr_key_type_t type;
 	unsigned int flags;
-	const struct algo_properties_st *algorithm; /* non-NULL for public/private keys */
+	const struct algo_properties_st *algorithm;	/* non-NULL for public/private keys */
 	uint8_t key_id[MAX_KEY_ID_SIZE];
 	size_t key_id_size;
 
@@ -116,7 +116,7 @@ struct ncr_lists {
 	struct idr session_idr;
 };
 
-void* ncr_init_lists(void);
+void *ncr_init_lists(void);
 void ncr_deinit_lists(struct ncr_lists *lst);
 
 long ncr_ioctl(struct ncr_lists *lst, unsigned int cmd, unsigned long arg);
@@ -127,7 +127,7 @@ long ncr_compat_ioctl(struct ncr_lists *lst, unsigned int cmd,
 int ncr_key_derive(struct ncr_lists *lst, const struct ncr_key_derive *data,
 		   struct nlattr *tb[]);
 
-void ncr_key_clear(struct key_item_st* item);
+void ncr_key_clear(struct key_item_st *item);
 int ncr_key_update_flags(struct key_item_st *item, const struct nlattr *nla);
 
 /* key handling */
@@ -146,14 +146,14 @@ int ncr_key_get_info(struct ncr_lists *lst, struct ncr_out *out,
 int ncr_key_generate_pair(struct ncr_lists *lst,
 			  const struct ncr_key_generate_pair *gen,
 			  struct nlattr *tb[]);
-int ncr_key_get_public(struct ncr_lists *lst, void __user* arg);
+int ncr_key_get_public(struct ncr_lists *lst, void __user * arg);
 
-int ncr_key_item_get_read(struct key_item_st**st, struct ncr_lists *lst,
-	ncr_key_t desc);
+int ncr_key_item_get_read(struct key_item_st **st, struct ncr_lists *lst,
+			  ncr_key_t desc);
 /* get key item for writing */
-int ncr_key_item_get_write( struct key_item_st** st,
-	struct ncr_lists *lst, ncr_key_t desc);
-void _ncr_key_item_put( struct key_item_st* item);
+int ncr_key_item_get_write(struct key_item_st **st,
+			   struct ncr_lists *lst, ncr_key_t desc);
+void _ncr_key_item_put(struct key_item_st *item);
 
 typedef enum {
 	LIMIT_TYPE_KEY,
@@ -181,7 +181,7 @@ void ncr_sessions_list_deinit(struct ncr_lists *lst);
 
 int ncr_session_init(struct ncr_lists *lists,
 		     const struct ncr_session_init *session,
-		    struct nlattr *tb[]);
+		     struct nlattr *tb[]);
 int ncr_session_update(struct ncr_lists *lists,
 		       const struct ncr_session_update *op, struct nlattr *tb[],
 		       int compat);
@@ -198,17 +198,20 @@ extern struct key_item_st master_key;
 void ncr_master_key_reset(void);
 
 /* storage */
-int key_from_storage_data(struct key_item_st* key, const void* data, size_t data_size);
-int key_to_storage_data( uint8_t** data, size_t * data_size, const struct key_item_st *key);
-
+int key_from_storage_data(struct key_item_st *key, const void *data,
+			  size_t data_size);
+int key_to_storage_data(uint8_t ** data, size_t * data_size,
+			const struct key_item_st *key);
 
 /* misc helper macros */
 
 const struct algo_properties_st *_ncr_algo_to_properties(ncr_algorithm_t algo);
-const struct algo_properties_st *_ncr_nla_to_properties(const struct nlattr *nla);
-int _ncr_key_get_sec_level(struct key_item_st* item);
-const struct algo_properties_st *_ncr_oid_to_properties(oid_st* oid);
-const oid_st* _ncr_properties_to_oid(const struct algo_properties_st * prop, int key_size);
+const struct algo_properties_st *_ncr_nla_to_properties(const struct nlattr
+							*nla);
+int _ncr_key_get_sec_level(struct key_item_st *item);
+const struct algo_properties_st *_ncr_oid_to_properties(oid_st * oid);
+const oid_st *_ncr_properties_to_oid(const struct algo_properties_st *prop,
+				     int key_size);
 
 /* CONFIG_COMPAT handling */
 
@@ -231,7 +234,7 @@ int ncr_session_input_data_from_nla(struct ncr_session_input_data *dest,
 int ncr_session_output_buffer_from_nla(struct ncr_session_output_buffer *dest,
 				       const struct nlattr *nla, int compat);
 
-int ncr_session_output_buffer_set_size(const struct ncr_session_output_buffer *dest,
-				       size_t size, int compat);
+int ncr_session_output_buffer_set_size(const struct ncr_session_output_buffer
+				       *dest, size_t size, int compat);
 
 #endif
diff --git a/ncr-key-storage.c b/ncr-key-storage.c
index 921134a..59ed915 100644
--- a/ncr-key-storage.c
+++ b/ncr-key-storage.c
@@ -41,13 +41,14 @@ struct packed_key {
 
 	uint8_t raw[KEY_DATA_MAX_SIZE];
 	uint32_t raw_size;
-} __attribute__((__packed__));
+} __attribute__ ((__packed__));
 
 #define THIS_VERSION 2
 
-int key_to_storage_data( uint8_t** sdata, size_t * sdata_size, const struct key_item_st *key)
+int key_to_storage_data(uint8_t ** sdata, size_t * sdata_size,
+			const struct key_item_st *key)
 {
-	struct packed_key * pkey;
+	struct packed_key *pkey;
 	int ret;
 
 	pkey = kmalloc(sizeof(*pkey), GFP_KERNEL);
@@ -69,9 +70,10 @@ int key_to_storage_data( uint8_t** sdata, size_t * sdata_size, const struct key_
 		pkey->raw_size = key->key.secret.size;
 		memcpy(pkey->raw, key->key.secret.data, pkey->raw_size);
 #ifdef CONFIG_ASSYMETRIC
-	} else if (key->type == NCR_KEY_TYPE_PRIVATE || key->type == NCR_KEY_TYPE_PUBLIC) {
+	} else if (key->type == NCR_KEY_TYPE_PRIVATE
+		   || key->type == NCR_KEY_TYPE_PUBLIC) {
 		pkey->raw_size = sizeof(pkey->raw);
-		ret = ncr_pk_pack( key, pkey->raw, &pkey->raw_size);
+		ret = ncr_pk_pack(key, pkey->raw, &pkey->raw_size);
 		if (ret < 0) {
 			err();
 			goto fail;
@@ -83,7 +85,7 @@ int key_to_storage_data( uint8_t** sdata, size_t * sdata_size, const struct key_
 		goto fail;
 	}
 
-	*sdata = (void*)pkey;
+	*sdata = (void *)pkey;
 	*sdata_size = sizeof(*pkey);
 
 	return 0;
@@ -93,9 +95,10 @@ fail:
 	return ret;
 }
 
-int key_from_storage_data(struct key_item_st* key, const void* data, size_t data_size)
+int key_from_storage_data(struct key_item_st *key, const void *data,
+			  size_t data_size)
 {
-	const struct packed_key * pkey = data;
+	const struct packed_key *pkey = data;
 
 	if (data_size != sizeof(*pkey) || pkey->version != THIS_VERSION
 	    || pkey->key_id_size > MAX_KEY_ID_SIZE) {
@@ -122,11 +125,11 @@ int key_from_storage_data(struct key_item_st* key, const void* data, size_t data
 		key->key.secret.size = pkey->raw_size;
 		memcpy(key->key.secret.data, pkey->raw, pkey->raw_size);
 #ifdef CONFIG_ASSYMETRIC
-	} else if (key->type == NCR_KEY_TYPE_PUBLIC 
-		|| key->type == NCR_KEY_TYPE_PRIVATE) {
+	} else if (key->type == NCR_KEY_TYPE_PUBLIC
+		   || key->type == NCR_KEY_TYPE_PRIVATE) {
 		int ret;
 
-		ret = ncr_pk_unpack( key, pkey->raw, pkey->raw_size);
+		ret = ncr_pk_unpack(key, pkey->raw, pkey->raw_size);
 		if (ret < 0) {
 			err();
 			return ret;
diff --git a/ncr-key-wrap.c b/ncr-key-wrap.c
index d3ff07e..de0be7e 100644
--- a/ncr-key-wrap.c
+++ b/ncr-key-wrap.c
@@ -46,12 +46,12 @@ typedef uint8_t val64_t[8];
 
 static const val64_t initA = "\xA6\xA6\xA6\xA6\xA6\xA6\xA6\xA6";
 
-static int key_to_packed_data( uint8_t** sdata, size_t * sdata_size, const struct key_item_st *key);
-static int key_from_packed_data(struct nlattr *tb[], struct key_item_st* key,
-				const void* data, size_t data_size);
-
+static int key_to_packed_data(uint8_t ** sdata, size_t * sdata_size,
+			      const struct key_item_st *key);
+static int key_from_packed_data(struct nlattr *tb[], struct key_item_st *key,
+				const void *data, size_t data_size);
 
-static void val64_xor( val64_t val, uint32_t x)
+static void val64_xor(val64_t val, uint32_t x)
 {
 	val[7] ^= x & 0xff;
 	val[6] ^= (x >> 8) & 0xff;
@@ -59,65 +59,67 @@ static void val64_xor( val64_t val, uint32_t x)
 	val[4] ^= (x >> 24) & 0xff;
 }
 
-static int rfc3394_wrap(val64_t *R, unsigned int n, struct cipher_data* ctx,
-	uint8_t* output, size_t *output_size, const uint8_t iv[8])
+static int rfc3394_wrap(val64_t * R, unsigned int n, struct cipher_data *ctx,
+			uint8_t * output, size_t * output_size,
+			const uint8_t iv[8])
 {
-val64_t A;
-uint8_t aes_block[16];
-int i,j;
+	val64_t A;
+	uint8_t aes_block[16];
+	int i, j;
 
-	if (*output_size < (n+1)*8) {
+	if (*output_size < (n + 1) * 8) {
 		err();
 		return -ERANGE;
 	}
 
 	memcpy(A, iv, 8);
 
-	for (i=0;i<6*n;i++) {
+	for (i = 0; i < 6 * n; i++) {
 		memcpy(aes_block, A, 8);
 		memcpy(&aes_block[8], R[0], 8);
 
 		_cryptodev_cipher_encrypt(ctx, aes_block, sizeof(aes_block),
-			aes_block, sizeof(aes_block));
+					  aes_block, sizeof(aes_block));
 
-		memcpy(A, aes_block, 8); /* A = MSB64(AES(A^{t-1}|R_{1}^{t-1})) */
-		val64_xor(A, i+1); /* A ^= t */
+		memcpy(A, aes_block, 8);	/* A = MSB64(AES(A^{t-1}|R_{1}^{t-1})) */
+		val64_xor(A, i + 1);	/* A ^= t */
 
-		for (j=0;j<n-1;j++)
-			memcpy(R[j], R[j+1], sizeof(R[j]));
-		memcpy(R[n-1], &aes_block[8], 8); /* R[n-1] = LSB64(AES(A^{t-1}|R_{1}^{t-1})) */
+		for (j = 0; j < n - 1; j++)
+			memcpy(R[j], R[j + 1], sizeof(R[j]));
+		memcpy(R[n - 1], &aes_block[8], 8);	/* R[n-1] = LSB64(AES(A^{t-1}|R_{1}^{t-1})) */
 	}
 
 	memcpy(output, A, sizeof(A));
-	for (j=0;j<n;j++)
-		memcpy(&output[(j+1)*8], R[j], 8);
-	*output_size = (n+1)*8;
+	for (j = 0; j < n; j++)
+		memcpy(&output[(j + 1) * 8], R[j], 8);
+	*output_size = (n + 1) * 8;
 
 	return 0;
 }
 
-static int rfc3394_unwrap(const uint8_t *wrapped_key, val64_t R[], unsigned int n, val64_t A, struct cipher_data *ctx)
+static int rfc3394_unwrap(const uint8_t * wrapped_key, val64_t R[],
+			  unsigned int n, val64_t A, struct cipher_data *ctx)
 {
 	int i, j;
 	uint8_t aes_block[16];
 
-	memcpy(A, wrapped_key, 8); /* A = C[0] */
-	for (i=0;i<n;i++)
-		memcpy(R[i], &wrapped_key[(i+1)*8], 8);
+	memcpy(A, wrapped_key, 8);	/* A = C[0] */
+	for (i = 0; i < n; i++)
+		memcpy(R[i], &wrapped_key[(i + 1) * 8], 8);
 
-	for (i=(6*n)-1;i>=0;i--) {
-		val64_xor(A, i+1);
+	for (i = (6 * n) - 1; i >= 0; i--) {
+		val64_xor(A, i + 1);
 
 		memcpy(aes_block, A, 8);
-		memcpy(&aes_block[8], R[n-1], 8);
+		memcpy(&aes_block[8], R[n - 1], 8);
 
 		_cryptodev_cipher_decrypt(ctx, aes_block, sizeof(aes_block),
-			aes_block, sizeof(aes_block));
+					  aes_block, sizeof(aes_block));
 
 		memcpy(A, aes_block, 8);
 
-		for (j=n-1;j>=1;j--)
-			memcpy(R[j], R[j-1], sizeof(R[j]));
+		for (j = n - 1; j >= 1; j--)
+			memcpy(R[j], R[j - 1], sizeof(R[j]));
 
 		memcpy(R[0], &aes_block[8], 8);
 	}
@@ -126,14 +128,16 @@ static int rfc3394_unwrap(const uint8_t *wrapped_key, val64_t R[], unsigned int
 }
 
 #define RFC5649_IV "\xA6\x59\x59\xA6"
-static int _wrap_aes_rfc5649(void* kdata, size_t kdata_size, struct key_item_st* kek,
-	void* output, size_t* output_size, const void* _iv, size_t iv_size)
+static int _wrap_aes_rfc5649(void *kdata, size_t kdata_size,
+			     struct key_item_st *kek, void *output,
+			     size_t * output_size, const void *_iv,
+			     size_t iv_size)
 {
-size_t n;
-int i, ret;
-struct cipher_data ctx;
-uint8_t iv[8];
-val64_t *R = NULL;
+	size_t n;
+	int i, ret;
+	struct cipher_data ctx;
+	uint8_t iv[8];
+	val64_t *R = NULL;
 
 	if (iv_size != 4) {
 		memcpy(iv, RFC5649_IV, 4);
@@ -146,19 +150,21 @@ val64_t *R = NULL;
 	iv[6] = (kdata_size >> 8) & 0xff;
 	iv[7] = (kdata_size) & 0xff;
 
-	n = (kdata_size+7)/8;
-	if (n==1) { /* unimplemented */
+	n = (kdata_size + 7) / 8;
+	if (n == 1) {		/* unimplemented */
 		err();
 		return -EINVAL;
 	}
 
-	ret = cryptodev_cipher_init(&ctx, "ecb(aes)", kek->key.secret.data, kek->key.secret.size);
+	ret =
+	    cryptodev_cipher_init(&ctx, "ecb(aes)", kek->key.secret.data,
+				  kek->key.secret.size);
 	if (ret < 0) {
 		err();
 		return ret;
 	}
 
-	R = kmalloc(n * sizeof (*R), GFP_KERNEL);
+	R = kmalloc(n * sizeof(*R), GFP_KERNEL);
 	if (R == NULL) {
 		err();
 		ret = -ENOMEM;
@@ -166,15 +172,15 @@ val64_t *R = NULL;
 	}
 
 	/* R = P */
-	for (i=0;i<kdata_size;i++) {
-		R[i/8][i%8] = ((uint8_t*)kdata)[i];
+	for (i = 0; i < kdata_size; i++) {
+		R[i / 8][i % 8] = ((uint8_t *) kdata)[i];
 	}
 
-	for (;i<n*8;i++) {
-		R[i/8][i%8] = 0;
+	for (; i < n * 8; i++) {
+		R[i / 8][i % 8] = 0;
 	}
 
-	ret = rfc3394_wrap( R, n, &ctx, output, output_size, iv);
+	ret = rfc3394_wrap(R, n, &ctx, output, output_size, iv);
 	if (ret < 0) {
 		err();
 		goto cleanup;
@@ -189,15 +195,17 @@ cleanup:
 	return ret;
 }
 
-static int _unwrap_aes_rfc5649(void* kdata, size_t *kdata_size, struct key_item_st* kek,
-	const void *wrapped_key, size_t wrapped_key_size, const void* _iv, size_t iv_size)
+static int _unwrap_aes_rfc5649(void *kdata, size_t * kdata_size,
+			       struct key_item_st *kek, const void *wrapped_key,
+			       size_t wrapped_key_size, const void *_iv,
+			       size_t iv_size)
 {
-size_t n;
-int i, ret;
-struct cipher_data ctx;
-uint8_t iv[4];
-size_t size;
-val64_t *R = NULL, A;
+	size_t n;
+	int i, ret;
+	struct cipher_data ctx;
+	uint8_t iv[4];
+	size_t size;
+	val64_t *R = NULL, A;
 
 	if (iv_size != 4) {
 		memcpy(iv, RFC5649_IV, 4);
@@ -206,7 +214,9 @@ val64_t *R = NULL, A;
 	}
 	iv_size = 4;
 
-	ret = cryptodev_cipher_init(&ctx, "ecb(aes)", kek->key.secret.data, kek->key.secret.size);
+	ret =
+	    cryptodev_cipher_init(&ctx, "ecb(aes)", kek->key.secret.data,
+				  kek->key.secret.size);
 	if (ret < 0) {
 		err();
 		return ret;
@@ -218,15 +228,15 @@ val64_t *R = NULL, A;
 		goto cleanup;
 	}
 
-	n = wrapped_key_size/8 - 1;
+	n = wrapped_key_size / 8 - 1;
 
-	if (*kdata_size < (n-1)*8) {
+	if (*kdata_size < (n - 1) * 8) {
 		err();
 		ret = -EINVAL;
 		goto cleanup;
 	}
 
-	R = kmalloc(n * sizeof (*R), GFP_KERNEL);
+	R = kmalloc(n * sizeof(*R), GFP_KERNEL);
 	if (R == NULL) {
 		err();
 		ret = -ENOMEM;
@@ -239,14 +249,14 @@ val64_t *R = NULL, A;
 		goto cleanup;
 	}
 
-	if (memcmp(A, iv, 4)!= 0) {
+	if (memcmp(A, iv, 4) != 0) {
 		err();
 		ret = -EINVAL;
 		goto cleanup;
 	}
 
 	size = (A[4] << 24) | (A[5] << 16) | (A[6] << 8) | A[7];
-	if (size > n*8 || size < (n-1)*8 || *kdata_size < size) {
+	if (size > n * 8 || size < (n - 1) * 8 || *kdata_size < size) {
 		err();
 		ret = -EINVAL;
 		goto cleanup;
@@ -254,8 +264,8 @@ val64_t *R = NULL, A;
 
 	memset(kdata, 0, size);
 	*kdata_size = size;
-	for (i=0;i<size;i++) {
-		((uint8_t*)kdata)[i] = R[i/8][i%8];
+	for (i = 0; i < size; i++) {
+		((uint8_t *) kdata)[i] = R[i / 8][i % 8];
 	}
 
 	ret = 0;
@@ -267,13 +277,14 @@ cleanup:
 	return ret;
 }
 
-
-static int wrap_aes_rfc5649(struct key_item_st* tobewrapped, struct key_item_st *kek,
-	void* output, size_t* output_size, const void* iv, size_t iv_size)
+static int wrap_aes_rfc5649(struct key_item_st *tobewrapped,
+			    struct key_item_st *kek, void *output,
+			    size_t * output_size, const void *iv,
+			    size_t iv_size)
 {
-int ret;
-uint8_t* sdata = NULL;
-size_t sdata_size = 0;
+	int ret;
+	uint8_t *sdata = NULL;
+	size_t sdata_size = 0;
 
 	ret = key_to_packed_data(&sdata, &sdata_size, tobewrapped);
 	if (ret < 0) {
@@ -282,24 +293,25 @@ size_t sdata_size = 0;
 	}
 
 	ret = _wrap_aes_rfc5649(sdata, sdata_size,
-		kek, output, output_size, iv, iv_size);
+				kek, output, output_size, iv, iv_size);
 
 	kfree(sdata);
-	
+
 	return ret;
 }
 
-static int unwrap_aes_rfc5649(struct key_item_st* output, struct key_item_st *kek,
-	void *wrapped, size_t wrapped_size, struct nlattr *tb[])
+static int unwrap_aes_rfc5649(struct key_item_st *output,
+			      struct key_item_st *kek, void *wrapped,
+			      size_t wrapped_size, struct nlattr *tb[])
 {
-const struct nlattr *nla;
-int ret, iv_size;
-void * sdata;
-size_t sdata_size = KEY_DATA_MAX_SIZE;
-const uint8_t *iv;
+	const struct nlattr *nla;
+	int ret, iv_size;
+	void *sdata;
+	size_t sdata_size = KEY_DATA_MAX_SIZE;
+	const uint8_t *iv;
 
 	sdata = kmalloc(sdata_size, GFP_KERNEL);
-	if (sdata == NULL) { 
+	if (sdata == NULL) {
 		err();
 		return -ENOMEM;
 	}
@@ -313,7 +325,7 @@ const uint8_t *iv;
 		iv_size = 0;
 	}
 
-	ret = _unwrap_aes_rfc5649(sdata, &sdata_size, kek, 
+	ret = _unwrap_aes_rfc5649(sdata, &sdata_size, kek,
 				  wrapped, wrapped_size, iv, iv_size);
 	if (ret < 0) {
 		err();
@@ -325,38 +337,41 @@ const uint8_t *iv;
 		err();
 		goto fail;
 	}
-	
+
 	ret = 0;
-	
+
 fail:
 	kfree(sdata);
 	return ret;
 
 }
-		
 
 /* Wraps using the RFC3394 way.
  */
-static int wrap_aes_rfc3394(struct key_item_st* tobewrapped, struct key_item_st *kek,
-	void* output, size_t *output_size, const void* iv, size_t iv_size)
+static int wrap_aes_rfc3394(struct key_item_st *tobewrapped,
+			    struct key_item_st *kek, void *output,
+			    size_t * output_size, const void *iv,
+			    size_t iv_size)
 {
-size_t key_size, n;
-uint8_t *raw_key;
-int i, ret;
-struct cipher_data ctx;
-val64_t *R = NULL;
+	size_t key_size, n;
+	uint8_t *raw_key;
+	int i, ret;
+	struct cipher_data ctx;
+	val64_t *R = NULL;
 
 	if (tobewrapped->type != NCR_KEY_TYPE_SECRET) {
 		err();
 		return -EINVAL;
 	}
-	
+
 	if (iv_size < sizeof(initA)) {
 		iv_size = sizeof(initA);
 		iv = initA;
 	}
 
-	ret = cryptodev_cipher_init(&ctx, "ecb(aes)", kek->key.secret.data, kek->key.secret.size);
+	ret =
+	    cryptodev_cipher_init(&ctx, "ecb(aes)", kek->key.secret.data,
+				  kek->key.secret.size);
 	if (ret < 0) {
 		err();
 		return ret;
@@ -371,10 +386,9 @@ val64_t *R = NULL;
 		goto cleanup;
 	}
 
-	n = key_size/8;
-
+	n = key_size / 8;
 
-	R = kmalloc(sizeof(*R)*n, GFP_KERNEL);
+	R = kmalloc(sizeof(*R) * n, GFP_KERNEL);
 	if (R == NULL) {
 		err();
 		ret = -ENOMEM;
@@ -382,11 +396,11 @@ val64_t *R = NULL;
 	}
 
 	/* R = P */
-	for (i=0;i<n;i++) {
-		memcpy(R[i], &raw_key[i*8], 8);
+	for (i = 0; i < n; i++) {
+		memcpy(R[i], &raw_key[i * 8], 8);
 	}
 
-	ret = rfc3394_wrap( R, n, &ctx, output, output_size, iv);
+	ret = rfc3394_wrap(R, n, &ctx, output, output_size, iv);
 	if (ret < 0) {
 		err();
 		goto cleanup;
@@ -403,29 +417,29 @@ cleanup:
 
 #if 0
 /* for debugging */
-void print_val64(char* str, val64_t val)
+void print_val64(char *str, val64_t val)
 {
 	int i;
-	printk("%s: ",str);
-	for (i=0;i<8;i++)
-	  printk("%.2x", val[i]);
+	printk("%s: ", str);
+	for (i = 0; i < 8; i++)
+		printk("%.2x", val[i]);
 	printk("\n");
-	
+
 }
 #endif
 
-static int unwrap_aes_rfc3394(struct key_item_st* output, struct key_item_st *kek,
-			      void* wrapped_key, size_t wrapped_key_size,
-			      struct nlattr *tb[])
+static int unwrap_aes_rfc3394(struct key_item_st *output,
+			      struct key_item_st *kek, void *wrapped_key,
+			      size_t wrapped_key_size, struct nlattr *tb[])
 {
-const struct nlattr *nla;
-size_t n;
-val64_t A;
-int i, ret;
-struct cipher_data ctx;
-val64_t * R = NULL;
-int iv_size;
-const uint8_t *iv;
+	const struct nlattr *nla;
+	size_t n;
+	val64_t A;
+	int i, ret;
+	struct cipher_data ctx;
+	val64_t *R = NULL;
+	int iv_size;
+	const uint8_t *iv;
 
 	nla = tb[NCR_ATTR_IV];
 	if (nla != NULL) {
@@ -438,7 +452,9 @@ const uint8_t *iv;
 		iv = initA;
 	}
 
-	ret = cryptodev_cipher_init(&ctx, "ecb(aes)", kek->key.secret.data, kek->key.secret.size);
+	ret =
+	    cryptodev_cipher_init(&ctx, "ecb(aes)", kek->key.secret.data,
+				  kek->key.secret.size);
 	if (ret < 0) {
 		err();
 		return ret;
@@ -452,15 +468,15 @@ const uint8_t *iv;
 		goto cleanup;
 	}
 
-	n = wrapped_key_size/8 - 1;
+	n = wrapped_key_size / 8 - 1;
 
-	if (NCR_CIPHER_MAX_KEY_LEN < (n-1)*8) {
+	if (NCR_CIPHER_MAX_KEY_LEN < (n - 1) * 8) {
 		err();
 		ret = -EINVAL;
 		goto cleanup;
 	}
 
-	R = kmalloc(sizeof(*R)*n, GFP_KERNEL);
+	R = kmalloc(sizeof(*R) * n, GFP_KERNEL);
 	if (R == NULL) {
 		err();
 		ret = -ENOMEM;
@@ -473,7 +489,7 @@ const uint8_t *iv;
 		goto cleanup;
 	}
 
-	if (memcmp(A, iv, 8)!= 0) {
+	if (memcmp(A, iv, 8) != 0) {
 		err();
 		ret = -EINVAL;
 		goto cleanup;
@@ -486,10 +502,10 @@ const uint8_t *iv;
 	}
 
 	memset(&output->key, 0, sizeof(output->key));
-	for (i=0;i<n;i++) {
-		memcpy(&output->key.secret.data[i*8], R[i], sizeof(R[i]));
+	for (i = 0; i < n; i++) {
+		memcpy(&output->key.secret.data[i * 8], R[i], sizeof(R[i]));
 	}
-	output->key.secret.size = n*8;
+	output->key.secret.size = n * 8;
 	output->type = NCR_KEY_TYPE_SECRET;
 
 	ret = 0;
@@ -504,9 +520,9 @@ cleanup:
 /* will check if the kek is of equal or higher security level than
  * wkey. To prevent encrypting a 256 bit key with an 128 bit one.
  */
-static int check_key_level(struct key_item_st* kek, struct key_item_st* wkey)
+static int check_key_level(struct key_item_st *kek, struct key_item_st *wkey)
 {
-int kek_level, wkey_level;
+	int kek_level, wkey_level;
 
 	/* allow wrapping of public keys with any key */
 	if (wkey->type == NCR_KEY_TYPE_PUBLIC)
@@ -523,12 +539,12 @@ int kek_level, wkey_level;
 		err();
 		return wkey_level;
 	}
-	
+
 	if (wkey_level > kek_level) {
 		err();
 		return -EPERM;
 	}
-	
+
 	return 0;
 }
 
@@ -536,13 +552,13 @@ int ncr_key_wrap(struct ncr_lists *lst, const struct ncr_key_wrap *wrap,
 		 struct nlattr *tb[])
 {
 #ifdef CONFIG_ASSYMETRIC
-const struct nlattr *nla;
-struct key_item_st* wkey = NULL;
-struct key_item_st* key = NULL;
-void* data = NULL;
-const void *iv;
-size_t data_size, iv_size;
-int ret;
+	const struct nlattr *nla;
+	struct key_item_st *wkey = NULL;
+	struct key_item_st *key = NULL;
+	void *data = NULL;
+	const void *iv;
+	size_t data_size, iv_size;
+	int ret;
 
 #ifdef KEY_WRAP_IS_PRIVILEGED
 	if (current_euid() != 0) {
@@ -579,7 +595,7 @@ int ret;
 		ret = -EPERM;
 		goto fail;
 	}
-	
+
 	ret = check_key_level(key, wkey);
 	if (ret < 0) {
 		err();
@@ -593,7 +609,7 @@ int ret;
 		ret = -ENOMEM;
 		goto fail;
 	}
-	
+
 	nla = tb[NCR_ATTR_IV];
 	if (nla != NULL) {
 		iv = nla_data(nla);
@@ -619,7 +635,7 @@ int ret;
 		err();
 		ret = -EINVAL;
 	}
-	
+
 	if (ret < 0) {
 		err();
 		goto fail;
@@ -634,8 +650,10 @@ int ret;
 	ret = data_size;
 
 fail:
-	if (wkey != NULL) _ncr_key_item_put(wkey);
-	if (key != NULL) _ncr_key_item_put(key);
+	if (wkey != NULL)
+		_ncr_key_item_put(wkey);
+	if (key != NULL)
+		_ncr_key_item_put(key);
 	kfree(data);
 
 	return ret;
@@ -651,12 +669,12 @@ int ncr_key_unwrap(struct ncr_lists *lst, const struct ncr_key_unwrap *wrap,
 		   struct nlattr *tb[])
 {
 #ifdef CONFIG_ASSYMETRIC
-const struct nlattr *nla;
-struct key_item_st* wkey = NULL;
-struct key_item_st* key = NULL;
-void* data = NULL;
-size_t data_size;
-int ret;
+	const struct nlattr *nla;
+	struct key_item_st *wkey = NULL;
+	struct key_item_st *key = NULL;
+	void *data = NULL;
+	size_t data_size;
+	int ret;
 
 #ifdef KEY_WRAP_IS_PRIVILEGED
 	if (current_euid() != 0) {
@@ -696,7 +714,7 @@ int ret;
 		ret = -EFAULT;
 		goto fail;
 	}
-	
+
 	ncr_key_clear(wkey);
 
 	nla = tb[NCR_ATTR_WRAPPING_ALGORITHM];
@@ -713,11 +731,14 @@ int ret;
 		err();
 		ret = -EINVAL;
 	}
-	
+
 fail:
-	if (wkey != NULL) _ncr_key_item_put(wkey);
-	if (key != NULL) _ncr_key_item_put(key);
-	if (data != NULL) kfree(data);
+	if (wkey != NULL)
+		_ncr_key_item_put(wkey);
+	if (key != NULL)
+		_ncr_key_item_put(key);
+	if (data != NULL)
+		kfree(data);
 
 	return ret;
 #else
@@ -729,12 +750,12 @@ int ncr_key_storage_wrap(struct ncr_lists *lst,
 			 const struct ncr_key_storage_wrap *wrap,
 			 struct nlattr *tb[])
 {
-struct key_item_st* wkey = NULL;
-void* data = NULL;
-size_t data_size;
-uint8_t * sdata = NULL;
-size_t sdata_size = 0;
-int ret;
+	struct key_item_st *wkey = NULL;
+	void *data = NULL;
+	size_t data_size;
+	uint8_t *sdata = NULL;
+	size_t sdata_size = 0;
+	int ret;
 
 	if (master_key.type != NCR_KEY_TYPE_SECRET) {
 		err();
@@ -759,14 +780,16 @@ int ret;
 		ret = -ENOMEM;
 		goto fail;
 	}
-	
+
 	ret = key_to_storage_data(&sdata, &sdata_size, wkey);
 	if (ret < 0) {
 		err();
 		goto fail;
 	}
 
-	ret = _wrap_aes_rfc5649(sdata, sdata_size, &master_key, data, &data_size, NULL, 0);
+	ret =
+	    _wrap_aes_rfc5649(sdata, sdata_size, &master_key, data, &data_size,
+			      NULL, 0);
 	if (ret < 0) {
 		err();
 		goto fail;
@@ -781,9 +804,12 @@ int ret;
 	ret = data_size;
 
 fail:
-	if (wkey != NULL) _ncr_key_item_put(wkey);
-	if (data != NULL) kfree(data);
-	if (sdata != NULL) kfree(sdata);
+	if (wkey != NULL)
+		_ncr_key_item_put(wkey);
+	if (data != NULL)
+		kfree(data);
+	if (sdata != NULL)
+		kfree(sdata);
 
 	return ret;
 }
@@ -792,11 +818,11 @@ int ncr_key_storage_unwrap(struct ncr_lists *lst,
 			   const struct ncr_key_storage_unwrap *wrap,
 			   struct nlattr *tb[])
 {
-struct key_item_st* wkey = NULL;
-void* data = NULL;
-uint8_t * sdata = NULL;
-size_t sdata_size = 0, data_size;
-int ret;
+	struct key_item_st *wkey = NULL;
+	void *data = NULL;
+	uint8_t *sdata = NULL;
+	size_t sdata_size = 0, data_size;
+	int ret;
 
 	if (master_key.type != NCR_KEY_TYPE_SECRET) {
 		err();
@@ -831,7 +857,9 @@ int ret;
 		goto fail;
 	}
 
-	ret = _unwrap_aes_rfc5649(sdata, &sdata_size, &master_key, data, data_size, NULL, 0);
+	ret =
+	    _unwrap_aes_rfc5649(sdata, &sdata_size, &master_key, data,
+				data_size, NULL, 0);
 	if (ret < 0) {
 		err();
 		goto fail;
@@ -844,12 +872,14 @@ int ret;
 		err();
 		goto fail;
 	}
-	
 
 fail:
-	if (wkey != NULL) _ncr_key_item_put(wkey);
-	if (data != NULL) kfree(data);
-	if (sdata != NULL) kfree(sdata);
+	if (wkey != NULL)
+		_ncr_key_item_put(wkey);
+	if (data != NULL)
+		kfree(data);
+	if (sdata != NULL)
+		kfree(sdata);
 
 	return ret;
 }
@@ -866,17 +896,18 @@ fail:
  * 
  * This allows distinguishing types of wrapped keys.
  */
-static int key_to_packed_data( uint8_t** sdata, size_t * sdata_size, const struct key_item_st *key)
+static int key_to_packed_data(uint8_t ** sdata, size_t * sdata_size,
+			      const struct key_item_st *key)
 {
-	uint8_t * pkey = NULL;
-	uint8_t * derkey = NULL;
+	uint8_t *pkey = NULL;
+	uint8_t *derkey = NULL;
 	uint32_t pkey_size;
 	int ret, err;
 	unsigned long version = KEY_WRAP_VERSION;
 	unsigned long type;
 	unsigned long derlen;
-	const oid_st* oid;
-	
+	const oid_st *oid;
+
 	*sdata_size = KEY_DATA_MAX_SIZE;
 	pkey = kmalloc(*sdata_size, GFP_KERNEL);
 	if (pkey == NULL) {
@@ -894,25 +925,27 @@ static int key_to_packed_data( uint8_t** sdata, size_t * sdata_size, const struc
 	if (key->type == NCR_KEY_TYPE_SECRET) {
 		memcpy(pkey, key->key.secret.data, key->key.secret.size);
 		pkey_size = key->key.secret.size;
-		
+
 		type = 0;
-	} else if (key->type == NCR_KEY_TYPE_PRIVATE || key->type == NCR_KEY_TYPE_PUBLIC) {
+	} else if (key->type == NCR_KEY_TYPE_PRIVATE
+		   || key->type == NCR_KEY_TYPE_PUBLIC) {
 		pkey_size = *sdata_size;
-		ret = ncr_pk_pack( key, pkey, &pkey_size);
+		ret = ncr_pk_pack(key, pkey, &pkey_size);
 		if (ret < 0) {
 			err();
 			goto fail;
 		}
-		
+
 		if (key->type == NCR_KEY_TYPE_PUBLIC)
 			type = 1;
-		else type = 2;
+		else
+			type = 2;
 	} else {
 		err();
 		ret = -EINVAL;
 		goto fail;
 	}
-	
+
 	oid = _ncr_properties_to_oid(key->algorithm, pkey_size);
 	if (oid == NULL) {
 		err();
@@ -921,21 +954,22 @@ static int key_to_packed_data( uint8_t** sdata, size_t * sdata_size, const struc
 	}
 
 	err = der_encode_sequence_multi(derkey, &derlen,
-				LTC_ASN1_SHORT_INTEGER, 1UL, &version, 
-				LTC_ASN1_OBJECT_IDENTIFIER, oid->OIDlen, oid->OID,
-				LTC_ASN1_SHORT_INTEGER, 1UL, &type, 
-				LTC_ASN1_OCTET_STRING, (unsigned long)pkey_size, pkey, 
-				LTC_ASN1_EOL, 0UL, NULL);
-				
+					LTC_ASN1_SHORT_INTEGER, 1UL, &version,
+					LTC_ASN1_OBJECT_IDENTIFIER, oid->OIDlen,
+					oid->OID, LTC_ASN1_SHORT_INTEGER, 1UL,
+					&type, LTC_ASN1_OCTET_STRING,
+					(unsigned long)pkey_size, pkey,
+					LTC_ASN1_EOL, 0UL, NULL);
+
 	kfree(pkey);
-	
+
 	if (err != CRYPT_OK) {
 		err();
 		ret = _ncr_tomerr(err);
 		goto fail;
 	}
-	
-	*sdata = (void*)derkey;
+
+	*sdata = (void *)derkey;
 	*sdata_size = derlen;
 
 	return 0;
@@ -946,27 +980,26 @@ fail:
 	return ret;
 }
 
-inline static int packed_type_to_key_type(unsigned long type, struct key_item_st* key)
+inline static int packed_type_to_key_type(unsigned long type,
+					  struct key_item_st *key)
 {
-	switch(type) {
-		case 0:
-			key->type = NCR_KEY_TYPE_SECRET;
-			break;
-		case 1:
-			key->type = NCR_KEY_TYPE_PUBLIC;
-			break;
-		case 2:
-			key->type = NCR_KEY_TYPE_PRIVATE;
-			break;
-		default:
-			err();
-			return -EINVAL;
+	switch (type) {
+	case 0:
+		key->type = NCR_KEY_TYPE_SECRET;
+		break;
+	case 1:
+		key->type = NCR_KEY_TYPE_PUBLIC;
+		break;
+	case 2:
+		key->type = NCR_KEY_TYPE_PRIVATE;
+		break;
+	default:
+		err();
+		return -EINVAL;
 	}
 	return 0;
 }
 
-
-
 /* Unpack, or better decode the DER data
  */
 static int key_from_packed_data(struct nlattr *tb[], struct key_item_st *key,
@@ -975,7 +1008,7 @@ static int key_from_packed_data(struct nlattr *tb[], struct key_item_st *key,
 	ltc_asn1_list list[6];
 	int ret, i, pkey_size, err;
 	unsigned long version, type;
-	uint8_t * pkey = NULL;
+	uint8_t *pkey = NULL;
 	oid_st oid;
 
 	if (data_size > DER_KEY_MAX_SIZE) {
@@ -992,20 +1025,20 @@ static int key_from_packed_data(struct nlattr *tb[], struct key_item_st *key,
 
 	i = 0;
 
-	list[i].type   = LTC_ASN1_SHORT_INTEGER;
-	list[i].size   = 1;
+	list[i].type = LTC_ASN1_SHORT_INTEGER;
+	list[i].size = 1;
 	list[i++].data = &version;
 
-	list[i].type   = LTC_ASN1_OBJECT_IDENTIFIER;
-	list[i].size   = sizeof(oid.OID)/sizeof(oid.OID[0]);
+	list[i].type = LTC_ASN1_OBJECT_IDENTIFIER;
+	list[i].size = sizeof(oid.OID) / sizeof(oid.OID[0]);
 	list[i++].data = oid.OID;
 
-	list[i].type   = LTC_ASN1_SHORT_INTEGER;
-	list[i].size   = 1;
+	list[i].type = LTC_ASN1_SHORT_INTEGER;
+	list[i].size = 1;
 	list[i++].data = &type;
 
-	list[i].type   = LTC_ASN1_OCTET_STRING;
-	list[i].size   = pkey_size;
+	list[i].type = LTC_ASN1_OCTET_STRING;
+	list[i].size = pkey_size;
 	list[i++].data = pkey;
 
 	err = der_decode_sequence(data, data_size, list, i);
@@ -1042,7 +1075,6 @@ static int key_from_packed_data(struct nlattr *tb[], struct key_item_st *key,
 		err();
 		return ret;
 	}
-	
 
 #ifndef KEY_WRAP_IS_PRIVILEGED
 	/* Do not allow key unwrapping to result to exportable keys
@@ -1059,10 +1091,10 @@ static int key_from_packed_data(struct nlattr *tb[], struct key_item_st *key,
 		key->key.secret.size = pkey_size;
 		memcpy(key->key.secret.data, pkey, pkey_size);
 #ifdef CONFIG_ASSYMETRIC
-	} else if (key->type == NCR_KEY_TYPE_PUBLIC 
-		|| key->type == NCR_KEY_TYPE_PRIVATE) {
+	} else if (key->type == NCR_KEY_TYPE_PUBLIC
+		   || key->type == NCR_KEY_TYPE_PRIVATE) {
 
-		ret = ncr_pk_unpack( key, pkey, pkey_size);
+		ret = ncr_pk_unpack(key, pkey, pkey_size);
 		if (ret < 0) {
 			err();
 			return ret;
@@ -1077,6 +1109,6 @@ static int key_from_packed_data(struct nlattr *tb[], struct key_item_st *key,
 
 fail:
 	kfree(pkey);
-	
+
 	return ret;
 }
diff --git a/ncr-key.c b/ncr-key.c
index 94b6f80..baf879f 100644
--- a/ncr-key.c
+++ b/ncr-key.c
@@ -52,14 +52,14 @@ void ncr_key_list_deinit(struct ncr_lists *lst)
 }
 
 /* returns the data item corresponding to desc */
-int ncr_key_item_get_read(struct key_item_st**st, struct ncr_lists *lst,
-	ncr_key_t desc)
+int ncr_key_item_get_read(struct key_item_st **st, struct ncr_lists *lst,
+			  ncr_key_t desc)
 {
-struct key_item_st* item;
-int ret;
-	
+	struct key_item_st *item;
+	int ret;
+
 	*st = NULL;
-	
+
 	mutex_lock(&lst->key_idr_mutex);
 	item = idr_find(&lst->key_idr, desc);
 	if (item == NULL) {
@@ -87,11 +87,11 @@ exit:
 /* as above but will never return anything that
  * is in use.
  */
-int ncr_key_item_get_write( struct key_item_st** st, 
-	struct ncr_lists *lst, ncr_key_t desc)
+int ncr_key_item_get_write(struct key_item_st **st,
+			   struct ncr_lists *lst, ncr_key_t desc)
 {
-struct key_item_st* item;
-int ret;
+	struct key_item_st *item;
+	int ret;
 
 	*st = NULL;
 
@@ -104,13 +104,13 @@ int ret;
 	}
 	/* do not return items that are in use already */
 
-	if (atomic_add_unless(&item->writer, 1, 1)==0) {
+	if (atomic_add_unless(&item->writer, 1, 1) == 0) {
 		/* another writer so busy */
 		ret = -EBUSY;
 		goto exit;
 	}
 
-	if (atomic_add_unless(&item->refcnt, 1, 2)==0) {
+	if (atomic_add_unless(&item->refcnt, 1, 2) == 0) {
 		/* some reader is active so busy */
 		atomic_dec(&item->writer);
 		ret = -EBUSY;
@@ -125,25 +125,25 @@ exit:
 	return ret;
 }
 
-void _ncr_key_item_put( struct key_item_st* item)
+void _ncr_key_item_put(struct key_item_st *item)
 {
 	if (atomic_read(&item->writer) > 0)
 		atomic_dec(&item->writer);
 	if (atomic_dec_and_test(&item->refcnt)) {
-			ncr_limits_remove(item->uid, item->pid, LIMIT_TYPE_KEY);
-			ncr_key_clear(item);
-			kfree(item);
+		ncr_limits_remove(item->uid, item->pid, LIMIT_TYPE_KEY);
+		ncr_key_clear(item);
+		kfree(item);
 	}
 }
 
 static void _ncr_key_remove(struct ncr_lists *lst, ncr_key_t desc)
 {
-	struct key_item_st * item;
+	struct key_item_st *item;
 
 	mutex_lock(&lst->key_idr_mutex);
 	item = idr_find(&lst->key_idr, desc);
 	if (item != NULL)
-		idr_remove(&lst->key_idr, desc); /* Steal the reference */
+		idr_remove(&lst->key_idr, desc);	/* Steal the reference */
 	mutex_unlock(&lst->key_idr_mutex);
 
 	if (item != NULL)
@@ -153,10 +153,12 @@ static void _ncr_key_remove(struct ncr_lists *lst, ncr_key_t desc)
 int ncr_key_init(struct ncr_lists *lst)
 {
 	ncr_key_t desc;
-	struct key_item_st* key;
+	struct key_item_st *key;
 	int ret;
 
-	ret = ncr_limits_add_and_check(current_euid(), task_pid_nr(current), LIMIT_TYPE_KEY);
+	ret =
+	    ncr_limits_add_and_check(current_euid(), task_pid_nr(current),
+				     LIMIT_TYPE_KEY);
 	if (ret < 0) {
 		err();
 		return ret;
@@ -205,10 +207,10 @@ int ncr_key_deinit(struct ncr_lists *lst, ncr_key_t desc)
 int ncr_key_export(struct ncr_lists *lst, const struct ncr_key_export *data,
 		   struct nlattr *tb[])
 {
-struct key_item_st* item = NULL;
-void* tmp = NULL;
-uint32_t tmp_size;
-int ret;
+	struct key_item_st *item = NULL;
+	void *tmp = NULL;
+	uint32_t tmp_size;
+	int ret;
 
 	if (data->buffer_size < 0) {
 		err();
@@ -228,57 +230,59 @@ int ret;
 	}
 
 	switch (item->type) {
-		case NCR_KEY_TYPE_SECRET:
-			if (item->key.secret.size > data->buffer_size) {
+	case NCR_KEY_TYPE_SECRET:
+		if (item->key.secret.size > data->buffer_size) {
+			err();
+			ret = -ERANGE;
+			goto fail;
+		}
+
+		/* found */
+		if (item->key.secret.size > 0) {
+			ret =
+			    copy_to_user(data->buffer, item->key.secret.data,
+					 item->key.secret.size);
+			if (unlikely(ret)) {
 				err();
-				ret = -ERANGE;
+				ret = -EFAULT;
 				goto fail;
 			}
+		}
 
-			/* found */
-			if (item->key.secret.size > 0) {
-				ret = copy_to_user(data->buffer, item->key.secret.data, item->key.secret.size);
-				if (unlikely(ret)) {
-					err();
-					ret = -EFAULT;
-					goto fail;
-				}
-			}
-
-			ret = item->key.secret.size;
-			break;
+		ret = item->key.secret.size;
+		break;
 #ifdef CONFIG_ASSYMETRIC
-		case NCR_KEY_TYPE_PUBLIC:
-		case NCR_KEY_TYPE_PRIVATE:
-			tmp_size = data->buffer_size;
-			
-			tmp = kmalloc(tmp_size, GFP_KERNEL);
-			if (tmp == NULL) {
-				err();
-				ret = -ENOMEM;
-				goto fail;
-			}
+	case NCR_KEY_TYPE_PUBLIC:
+	case NCR_KEY_TYPE_PRIVATE:
+		tmp_size = data->buffer_size;
 
-			ret = ncr_pk_pack(item, tmp, &tmp_size);
-			if (ret < 0) {
-				err();
-				goto fail;
-			}
+		tmp = kmalloc(tmp_size, GFP_KERNEL);
+		if (tmp == NULL) {
+			err();
+			ret = -ENOMEM;
+			goto fail;
+		}
 
-			ret = copy_to_user(data->buffer, tmp, tmp_size);
-			if (unlikely(ret)) {
-				err();
-				ret = -EFAULT;
-				goto fail;
-			}
-			
-			ret = tmp_size;
-			break;
-#endif
-		default:
+		ret = ncr_pk_pack(item, tmp, &tmp_size);
+		if (ret < 0) {
 			err();
-			ret = -EINVAL;
 			goto fail;
+		}
+
+		ret = copy_to_user(data->buffer, tmp, tmp_size);
+		if (unlikely(ret)) {
+			err();
+			ret = -EFAULT;
+			goto fail;
+		}
+
+		ret = tmp_size;
+		break;
+#endif
+	default:
+		err();
+		ret = -EINVAL;
+		goto fail;
 	}
 
 fail:
@@ -286,10 +290,10 @@ fail:
 	if (item)
 		_ncr_key_item_put(item);
 	return ret;
-	
+
 }
 
-int ncr_key_update_flags(struct key_item_st* item, const struct nlattr *nla)
+int ncr_key_update_flags(struct key_item_st *item, const struct nlattr *nla)
 {
 	uint32_t flags;
 
@@ -306,13 +310,13 @@ int ncr_key_update_flags(struct key_item_st* item, const struct nlattr *nla)
 int ncr_key_import(struct ncr_lists *lst, const struct ncr_key_import *data,
 		   struct nlattr *tb[])
 {
-const struct nlattr *nla;
-struct key_item_st* item = NULL;
-int ret;
-void* tmp = NULL;
-size_t tmp_size;
+	const struct nlattr *nla;
+	struct key_item_st *item = NULL;
+	int ret;
+	void *tmp = NULL;
+	size_t tmp_size;
 
-	ret = ncr_key_item_get_write( &item, lst, data->key);
+	ret = ncr_key_item_get_write(&item, lst, data->key);
 	if (ret < 0) {
 		err();
 		return ret;
@@ -326,7 +330,7 @@ size_t tmp_size;
 		ret = -ENOMEM;
 		goto fail;
 	}
-	
+
 	if (unlikely(copy_from_user(tmp, data->data, data->data_size))) {
 		err();
 		ret = -EFAULT;
@@ -367,31 +371,31 @@ size_t tmp_size;
 		memcpy(item->key_id, nla_data(nla), item->key_id_size);
 	}
 
-	switch(item->type) {
-		case NCR_KEY_TYPE_SECRET:
-			if (tmp_size > NCR_CIPHER_MAX_KEY_LEN) {
-				err();
-				ret = -EINVAL;
-				goto fail;
-			}
-			
-			memcpy(item->key.secret.data, tmp, tmp_size);
-			item->key.secret.size = tmp_size;
-			break;
-#ifdef CONFIG_ASSYMETRIC
-		case NCR_KEY_TYPE_PRIVATE:
-		case NCR_KEY_TYPE_PUBLIC:
-			ret = ncr_pk_unpack( item, tmp, tmp_size);
-			if (ret < 0) {
-				err();
-				goto fail;
-			}
-			break;
-#endif
-		default:
+	switch (item->type) {
+	case NCR_KEY_TYPE_SECRET:
+		if (tmp_size > NCR_CIPHER_MAX_KEY_LEN) {
 			err();
 			ret = -EINVAL;
 			goto fail;
+		}
+
+		memcpy(item->key.secret.data, tmp, tmp_size);
+		item->key.secret.size = tmp_size;
+		break;
+#ifdef CONFIG_ASSYMETRIC
+	case NCR_KEY_TYPE_PRIVATE:
+	case NCR_KEY_TYPE_PUBLIC:
+		ret = ncr_pk_unpack(item, tmp, tmp_size);
+		if (ret < 0) {
+			err();
+			goto fail;
+		}
+		break;
+#endif
+	default:
+		err();
+		ret = -EINVAL;
+		goto fail;
 	}
 
 	ret = 0;
@@ -404,13 +408,13 @@ fail:
 	return ret;
 }
 
-void ncr_key_clear(struct key_item_st* item)
+void ncr_key_clear(struct key_item_st *item)
 {
 	/* clears any previously allocated parameters */
 #ifdef CONFIG_ASSYMETRIC
 	if (item->type == NCR_KEY_TYPE_PRIVATE ||
-		item->type == NCR_KEY_TYPE_PUBLIC) {
-		
+	    item->type == NCR_KEY_TYPE_PUBLIC) {
+
 		ncr_pk_clear(item);
 	}
 #endif
@@ -418,7 +422,7 @@ void ncr_key_clear(struct key_item_st* item)
 	memset(item->key_id, 0, sizeof(item->key_id));
 	item->key_id_size = 0;
 	item->flags = 0;
-	
+
 	return;
 }
 
@@ -427,11 +431,11 @@ void ncr_key_clear(struct key_item_st* item)
 int ncr_key_generate(struct ncr_lists *lst, const struct ncr_key_generate *gen,
 		     struct nlattr *tb[])
 {
-const struct nlattr *nla;
-struct key_item_st* item = NULL;
-const struct algo_properties_st *algo;
-int ret;
-size_t size;
+	const struct nlattr *nla;
+	struct key_item_st *item = NULL;
+	const struct algo_properties_st *algo;
+	int ret;
+	size_t size;
 
 	ret = ncr_key_item_get_write(&item, lst, gen->key);
 	if (ret < 0) {
@@ -485,12 +489,13 @@ size_t size;
 		ret = -EINVAL;
 		goto fail;
 	}
-	
+
 	ret = 0;
 
 fail:
 	if (item) {
-		if (ret < 0) item->type = NCR_KEY_TYPE_INVALID;
+		if (ret < 0)
+			item->type = NCR_KEY_TYPE_INVALID;
 		_ncr_key_item_put(item);
 	}
 	return ret;
@@ -503,56 +508,57 @@ fail:
  * symmetric ones. Should be kept up to date.
  */
 static const struct {
-	unsigned int bits; /* sec level */
+	unsigned int bits;	/* sec level */
 	unsigned int rsa_bits;
 	unsigned int dlog_bits;
 } ecrypt_vals[] = {
-	{64, 816, 816},
-	{80, 1248, 1248},
-	{112, 2432, 2432},
-	{128, 3248, 3248},
-	{160, 5312, 5312},
-	{192, 7936, 7936},
-	{256, 15424, 15424},
-	{0,0,0}
+	{
+	64, 816, 816}, {
+	80, 1248, 1248}, {
+	112, 2432, 2432}, {
+	128, 3248, 3248}, {
+	160, 5312, 5312}, {
+	192, 7936, 7936}, {
+	256, 15424, 15424}, {
+	0, 0, 0}
 };
 
 static unsigned int rsa_to_bits(unsigned int rsa_bits)
 {
-int i = 1;
+	int i = 1;
 
 	if (rsa_bits <= ecrypt_vals[0].rsa_bits)
 		return ecrypt_vals[0].rsa_bits;
 
 	do {
-		if (rsa_bits <= ecrypt_vals[i].rsa_bits && 
-			rsa_bits > ecrypt_vals[i-1].rsa_bits) {
+		if (rsa_bits <= ecrypt_vals[i].rsa_bits &&
+		    rsa_bits > ecrypt_vals[i - 1].rsa_bits) {
 
 			return ecrypt_vals[i].bits;
 		}
-	} while(ecrypt_vals[++i].bits != 0);
-	
+	} while (ecrypt_vals[++i].bits != 0);
+
 	/* return the highest found so far */
-	return ecrypt_vals[i-1].bits;
+	return ecrypt_vals[i - 1].bits;
 }
 
 static unsigned int dlog_to_bits(unsigned int dlog_bits)
 {
-int i = 1;
+	int i = 1;
 
 	if (dlog_bits <= ecrypt_vals[0].dlog_bits)
 		return ecrypt_vals[0].dlog_bits;
 
 	do {
-		if (dlog_bits <= ecrypt_vals[i].dlog_bits && 
-			dlog_bits > ecrypt_vals[i-1].dlog_bits) {
+		if (dlog_bits <= ecrypt_vals[i].dlog_bits &&
+		    dlog_bits > ecrypt_vals[i - 1].dlog_bits) {
 
 			return ecrypt_vals[i].bits;
 		}
-	} while(ecrypt_vals[++i].bits != 0);
-	
+	} while (ecrypt_vals[++i].bits != 0);
+
 	/* return the highest found so far */
-	return ecrypt_vals[i-1].bits;
+	return ecrypt_vals[i - 1].bits;
 }
 
 #endif
@@ -560,46 +566,47 @@ int i = 1;
 /* returns the security level of the key in bits. Private/Public keys
  * are mapped to symmetric key bits using the ECRYPT II 2010 recommendation.
  */
-int _ncr_key_get_sec_level(struct key_item_st* item)
+int _ncr_key_get_sec_level(struct key_item_st *item)
 {
 	/* FIXME: should we move everything here into algorithm properties? 
 	 */
 	if (item->type == NCR_KEY_TYPE_SECRET) {
-		if (item->algorithm->algo == NCR_ALG_3DES_CBC || item->algorithm->algo == NCR_ALG_3DES_ECB)
+		if (item->algorithm->algo == NCR_ALG_3DES_CBC
+		    || item->algorithm->algo == NCR_ALG_3DES_ECB)
 			return 112;
 
-		return item->key.secret.size*8;
+		return item->key.secret.size * 8;
 #ifdef CONFIG_ASSYMETRIC
 	} else if (item->type == NCR_KEY_TYPE_PRIVATE) {
 		int bits;
 
-		switch(item->algorithm->algo) {
-			case NCR_ALG_RSA:
-				bits = ncr_pk_get_rsa_size(&item->key.pk.rsa);
-				if (bits < 0) {
-					err();
-					return bits;
-				}
-				
-				return rsa_to_bits(bits);
-			case NCR_ALG_DSA:
-				bits = ncr_pk_get_dsa_size(&item->key.pk.dsa);
-				if (bits < 0) {
-					err();
-					return bits;
-				}
-				
-				return dlog_to_bits(bits);
-			case NCR_ALG_DH:
-				bits = ncr_pk_get_dh_size(&item->key.pk.dh);
-				if (bits < 0) {
-					err();
-					return bits;
-				}
-				
-				return dlog_to_bits(bits);
-			default:
-				return -EINVAL;
+		switch (item->algorithm->algo) {
+		case NCR_ALG_RSA:
+			bits = ncr_pk_get_rsa_size(&item->key.pk.rsa);
+			if (bits < 0) {
+				err();
+				return bits;
+			}
+
+			return rsa_to_bits(bits);
+		case NCR_ALG_DSA:
+			bits = ncr_pk_get_dsa_size(&item->key.pk.dsa);
+			if (bits < 0) {
+				err();
+				return bits;
+			}
+
+			return dlog_to_bits(bits);
+		case NCR_ALG_DH:
+			bits = ncr_pk_get_dh_size(&item->key.pk.dh);
+			if (bits < 0) {
+				err();
+				return bits;
+			}
+
+			return dlog_to_bits(bits);
+		default:
+			return -EINVAL;
 		}
 #endif
 	} else {
@@ -610,17 +617,17 @@ int _ncr_key_get_sec_level(struct key_item_st* item)
 int ncr_key_get_info(struct ncr_lists *lst, struct ncr_out *out,
 		     const struct ncr_key_get_info *info, struct nlattr *tb[])
 {
-const struct nlattr *nla;
-const u16 *attr, *attr_end;
-struct key_item_st* item = NULL;
-int ret;
+	const struct nlattr *nla;
+	const u16 *attr, *attr_end;
+	struct key_item_st *item = NULL;
+	int ret;
 
 	ret = ncr_key_item_get_read(&item, lst, info->key);
 	if (ret < 0) {
 		err();
 		return ret;
 	}
-	
+
 	if (item->type == NCR_KEY_TYPE_INVALID) {
 		err();
 		ret = -EINVAL;
@@ -648,7 +655,7 @@ int ret;
 						 item->algorithm->kstr);
 			break;
 		default:
-			break; /* Silently ignore */
+			break;	/* Silently ignore */
 		}
 		if (ret != 0) {
 			err();
@@ -664,7 +671,7 @@ int ret;
 	}
 
 fail:
-	_ncr_key_item_put( item);
+	_ncr_key_item_put(item);
 
 	return ret;
 }
@@ -674,9 +681,9 @@ int ncr_key_generate_pair(struct ncr_lists *lst,
 			  struct nlattr *tb[])
 {
 #ifdef CONFIG_ASSYMETRIC
-struct key_item_st* private = NULL;
-struct key_item_st* public = NULL;
-int ret;
+	struct key_item_st *private = NULL;
+	struct key_item_st *public = NULL;
+	int ret;
 
 	ret = ncr_key_item_get_write(&private, lst, gen->private_key);
 	if (ret < 0) {
@@ -695,7 +702,7 @@ int ret;
 
 	/* we generate only secret keys */
 	private->algorithm = public->algorithm
-		= _ncr_nla_to_properties(tb[NCR_ATTR_ALGORITHM]);
+	    = _ncr_nla_to_properties(tb[NCR_ATTR_ALGORITHM]);
 	if (private->algorithm == NULL) {
 		err();
 		ret = -EINVAL;
@@ -714,8 +721,8 @@ int ret;
 		goto fail;
 	}
 
-	public->flags |= (NCR_KEY_FLAG_EXPORTABLE|NCR_KEY_FLAG_WRAPPABLE);
-	
+	public->flags |= (NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE);
+
 	if (public->type == NCR_KEY_TYPE_PUBLIC) {
 		ret = ncr_pk_generate(public->algorithm, tb, private, public);
 		if (ret < 0) {
@@ -727,15 +734,17 @@ int ret;
 		ret = -EINVAL;
 		goto fail;
 	}
-	
+
 	ret = 0;
 fail:
 	if (public) {
-		if (ret < 0) public->type = NCR_KEY_TYPE_INVALID;
+		if (ret < 0)
+			public->type = NCR_KEY_TYPE_INVALID;
 		_ncr_key_item_put(public);
 	}
 	if (private) {
-		if (ret < 0) private->type = NCR_KEY_TYPE_INVALID;
+		if (ret < 0)
+			private->type = NCR_KEY_TYPE_INVALID;
 		_ncr_key_item_put(private);
 	}
 	return ret;
@@ -747,19 +756,20 @@ fail:
 int ncr_key_derive(struct ncr_lists *lst, const struct ncr_key_derive *data,
 		   struct nlattr *tb[])
 {
-int ret;
-struct key_item_st* key = NULL;
-struct key_item_st* newkey = NULL;
+	int ret;
+	struct key_item_st *key = NULL;
+	struct key_item_st *newkey = NULL;
 
 	ret = ncr_key_item_get_read(&key, lst, data->input_key);
 	if (ret < 0) {
 		err();
 		return ret;
 	}
-	
+
 	/* wrapping keys cannot be used for anything except wrapping.
 	 */
-	if (key->flags & NCR_KEY_FLAG_WRAPPING || key->flags & NCR_KEY_FLAG_UNWRAPPING) {
+	if (key->flags & NCR_KEY_FLAG_WRAPPING
+	    || key->flags & NCR_KEY_FLAG_UNWRAPPING) {
 		err();
 		ret = -EINVAL;
 		goto fail;
@@ -781,19 +791,19 @@ struct key_item_st* newkey = NULL;
 
 	switch (key->type) {
 #ifdef CONFIG_ASSYMETRIC
-		case NCR_KEY_TYPE_PUBLIC:
-		case NCR_KEY_TYPE_PRIVATE:
-			ret = ncr_pk_derive(newkey, key, tb);
-			if (ret < 0) {
-				err();
-				goto fail;
-			}
-			break;
-#endif
-		default:
+	case NCR_KEY_TYPE_PUBLIC:
+	case NCR_KEY_TYPE_PRIVATE:
+		ret = ncr_pk_derive(newkey, key, tb);
+		if (ret < 0) {
 			err();
-			ret = -EINVAL;
 			goto fail;
+		}
+		break;
+#endif
+	default:
+		err();
+		ret = -EINVAL;
+		goto fail;
 	}
 
 fail:
@@ -802,6 +812,5 @@ fail:
 	if (newkey)
 		_ncr_key_item_put(newkey);
 	return ret;
-	
-}
 
+}
diff --git a/ncr-limits.c b/ncr-limits.c
index 0c12824..cd2a420 100644
--- a/ncr-limits.c
+++ b/ncr-limits.c
@@ -92,10 +92,10 @@ void ncr_limits_init(void)
 
 void ncr_limits_deinit(void)
 {
-struct limit_process_item_st* pitem;
-struct limit_user_item_st* uitem;
-struct hlist_node *pos, *tmp;
-size_t i;
+	struct limit_process_item_st *pitem;
+	struct limit_user_item_st *uitem;
+	struct hlist_node *pos, *tmp;
+	size_t i;
 
 	mutex_lock(&user_limit_mutex);
 	for (i = 0; i < USER_LIMIT_TABLE_SIZE; i++) {
@@ -106,7 +106,7 @@ size_t i;
 		}
 	}
 	mutex_unlock(&user_limit_mutex);
-	
+
 	mutex_lock(&process_limit_mutex);
 	for (i = 0; i < PROCESS_LIMIT_TABLE_SIZE; i++) {
 		hlist_for_each_entry_safe(pitem, pos, tmp,
@@ -121,12 +121,12 @@ size_t i;
 
 int ncr_limits_add_and_check(uid_t uid, pid_t pid, limits_type_t type)
 {
-struct limit_process_item_st* pitem;
-struct limit_user_item_st* uitem;
-struct hlist_head *user_head, *process_head;
-struct hlist_node *pos;
-int add = 1;
-int ret;
+	struct limit_process_item_st *pitem;
+	struct limit_user_item_st *uitem;
+	struct hlist_head *user_head, *process_head;
+	struct hlist_node *pos;
+	int add = 1;
+	int ret;
 	BUG_ON(type >= NUM_LIMIT_TYPES);
 
 	user_head = user_limit_hash(uid);
@@ -135,7 +135,8 @@ int ret;
 		if (uitem->uid == uid) {
 			add = 0;
 
-			if (atomic_add_unless(&uitem->cnt[type], 1, max_per_user[type])==0) {
+			if (atomic_add_unless
+			    (&uitem->cnt[type], 1, max_per_user[type]) == 0) {
 				err();
 				mutex_unlock(&user_limit_mutex);
 				return -EPERM;
@@ -147,7 +148,7 @@ int ret;
 	if (add) {
 		size_t i;
 
-		uitem = kmalloc( sizeof(*uitem), GFP_KERNEL);
+		uitem = kmalloc(sizeof(*uitem), GFP_KERNEL);
 		if (uitem == NULL) {
 			err();
 			mutex_unlock(&user_limit_mutex);
@@ -169,7 +170,9 @@ int ret;
 	hlist_for_each_entry(pitem, pos, process_head, hlist) {
 		if (pitem->pid == pid) {
 			add = 0;
-			if (atomic_add_unless(&pitem->cnt[type], 1, max_per_process[type])==0) {
+			if (atomic_add_unless
+			    (&pitem->cnt[type], 1,
+			     max_per_process[type]) == 0) {
 				err();
 				mutex_unlock(&process_limit_mutex);
 
@@ -179,7 +182,6 @@ int ret;
 			break;
 		}
 	}
-	
 
 	if (add) {
 		size_t i;
@@ -216,10 +218,10 @@ restore_user:
 
 void ncr_limits_remove(uid_t uid, pid_t pid, limits_type_t type)
 {
-struct limit_process_item_st* pitem;
-struct limit_user_item_st* uitem;
-struct hlist_head *hhead;
-struct hlist_node *pos;
+	struct limit_process_item_st *pitem;
+	struct limit_user_item_st *uitem;
+	struct hlist_head *hhead;
+	struct hlist_node *pos;
 
 	BUG_ON(type >= NUM_LIMIT_TYPES);
 	hhead = user_limit_hash(uid);
diff --git a/ncr-pk.c b/ncr-pk.c
index 6de044b..19237c7 100644
--- a/ncr-pk.c
+++ b/ncr-pk.c
@@ -38,37 +38,38 @@
 int _ncr_tomerr(int err)
 {
 	switch (err) {
-		case CRYPT_BUFFER_OVERFLOW:
-			return -ERANGE;
-		case CRYPT_MEM:
-			return -ENOMEM;
-		default:
-			return -EINVAL;
+	case CRYPT_BUFFER_OVERFLOW:
+		return -ERANGE;
+	case CRYPT_MEM:
+		return -ENOMEM;
+	default:
+		return -EINVAL;
 	}
 }
 
-void ncr_pk_clear(struct key_item_st* key)
+void ncr_pk_clear(struct key_item_st *key)
 {
 	if (key->algorithm == NULL)
 		return;
-	switch(key->algorithm->algo) {
-		case NCR_ALG_RSA:
-			rsa_free(&key->key.pk.rsa);
-			break;
-		case NCR_ALG_DSA:
-			dsa_free(&key->key.pk.dsa);
-			break;
-		case NCR_ALG_DH:
-			dh_free(&key->key.pk.dh);
-			break;
-		default:
-			return;
+	switch (key->algorithm->algo) {
+	case NCR_ALG_RSA:
+		rsa_free(&key->key.pk.rsa);
+		break;
+	case NCR_ALG_DSA:
+		dsa_free(&key->key.pk.dsa);
+		break;
+	case NCR_ALG_DH:
+		dh_free(&key->key.pk.dh);
+		break;
+	default:
+		return;
 	}
 }
 
-static int ncr_pk_make_public_and_id( struct key_item_st * private, struct key_item_st * public)
+static int ncr_pk_make_public_and_id(struct key_item_st *private,
+				     struct key_item_st *public)
 {
-	uint8_t * tmp;
+	uint8_t *tmp;
 	unsigned long max_size;
 	int ret, cret;
 	unsigned long key_id_size;
@@ -80,48 +81,51 @@ static int ncr_pk_make_public_and_id( struct key_item_st * private, struct key_i
 		return -ENOMEM;
 	}
 
-	switch(private->algorithm->algo) {
-		case NCR_ALG_RSA:
-			cret = rsa_export(tmp, &max_size, PK_PUBLIC, &private->key.pk.rsa);
-			if (cret != CRYPT_OK) {
-				err();
-				ret = _ncr_tomerr(cret);
-				goto fail;
-			}
+	switch (private->algorithm->algo) {
+	case NCR_ALG_RSA:
+		cret =
+		    rsa_export(tmp, &max_size, PK_PUBLIC, &private->key.pk.rsa);
+		if (cret != CRYPT_OK) {
+			err();
+			ret = _ncr_tomerr(cret);
+			goto fail;
+		}
 
-			cret = rsa_import(tmp, max_size, &public->key.pk.rsa);
-			if (cret != CRYPT_OK) {
-				err();
-				ret = _ncr_tomerr(cret);
-				goto fail;
-			}
-			break;
-		case NCR_ALG_DSA:
-			cret = dsa_export(tmp, &max_size, PK_PUBLIC, &private->key.pk.dsa);
-			if (cret != CRYPT_OK) {
-				err();
-				ret = _ncr_tomerr(cret);
-				goto fail;
-			}
+		cret = rsa_import(tmp, max_size, &public->key.pk.rsa);
+		if (cret != CRYPT_OK) {
+			err();
+			ret = _ncr_tomerr(cret);
+			goto fail;
+		}
+		break;
+	case NCR_ALG_DSA:
+		cret =
+		    dsa_export(tmp, &max_size, PK_PUBLIC, &private->key.pk.dsa);
+		if (cret != CRYPT_OK) {
+			err();
+			ret = _ncr_tomerr(cret);
+			goto fail;
+		}
 
-			cret = dsa_import(tmp, max_size, &public->key.pk.dsa);
-			if (cret != CRYPT_OK) {
-				err();
-				ret = _ncr_tomerr(cret);
-				goto fail;
-			}
-			break;
-		case NCR_ALG_DH:
-			ret = dh_generate_public(&public->key.pk.dh, &private->key.pk.dh);
-			if (ret < 0) {
-				err();
-				goto fail;
-			}
-			break;
-		default:
+		cret = dsa_import(tmp, max_size, &public->key.pk.dsa);
+		if (cret != CRYPT_OK) {
 			err();
-			ret = -EINVAL;
+			ret = _ncr_tomerr(cret);
 			goto fail;
+		}
+		break;
+	case NCR_ALG_DH:
+		ret =
+		    dh_generate_public(&public->key.pk.dh, &private->key.pk.dh);
+		if (ret < 0) {
+			err();
+			goto fail;
+		}
+		break;
+	default:
+		err();
+		ret = -EINVAL;
+		goto fail;
 	}
 
 	key_id_size = MAX_KEY_ID_SIZE;
@@ -133,16 +137,17 @@ static int ncr_pk_make_public_and_id( struct key_item_st * private, struct key_i
 		goto fail;
 	}
 	private->key_id_size = public->key_id_size = key_id_size;
-	memcpy(public->key_id, private->key_id, key_id_size);			
+	memcpy(public->key_id, private->key_id, key_id_size);
 
 	ret = 0;
-fail:	
+fail:
 	kfree(tmp);
-	
+
 	return ret;
 }
 
-int ncr_pk_pack( const struct key_item_st * key, uint8_t * packed, uint32_t * packed_size)
+int ncr_pk_pack(const struct key_item_st *key, uint8_t * packed,
+		uint32_t * packed_size)
 {
 	unsigned long max_size = *packed_size;
 	int cret, ret;
@@ -152,42 +157,49 @@ int ncr_pk_pack( const struct key_item_st * key, uint8_t * packed, uint32_t * pa
 		return -EINVAL;
 	}
 
-	switch(key->algorithm->algo) {
-		case NCR_ALG_RSA:
-			cret = rsa_export(packed, &max_size, key->key.pk.rsa.type, (void*)&key->key.pk.rsa);
-			if (cret != CRYPT_OK) {
-				*packed_size = max_size;
-				err();
-				return _ncr_tomerr(cret);
-			}
-			break;
-		case NCR_ALG_DSA:
-			cret = dsa_export(packed, &max_size, key->key.pk.dsa.type, (void*)&key->key.pk.dsa);
-			if (cret != CRYPT_OK) {
-				*packed_size = max_size;
-				err();
-				return _ncr_tomerr(cret);
-			}
-			break;
-		case NCR_ALG_DH:
-			ret = dh_export(packed, &max_size, key->key.pk.dh.type, (void*)&key->key.pk.dh);
-			if (ret < 0) {
-				*packed_size = max_size;
-				err();
-				return ret;
-			}
-			break;
-		default:
+	switch (key->algorithm->algo) {
+	case NCR_ALG_RSA:
+		cret =
+		    rsa_export(packed, &max_size, key->key.pk.rsa.type,
+			       (void *)&key->key.pk.rsa);
+		if (cret != CRYPT_OK) {
+			*packed_size = max_size;
 			err();
-			return -EINVAL;
+			return _ncr_tomerr(cret);
+		}
+		break;
+	case NCR_ALG_DSA:
+		cret =
+		    dsa_export(packed, &max_size, key->key.pk.dsa.type,
+			       (void *)&key->key.pk.dsa);
+		if (cret != CRYPT_OK) {
+			*packed_size = max_size;
+			err();
+			return _ncr_tomerr(cret);
+		}
+		break;
+	case NCR_ALG_DH:
+		ret =
+		    dh_export(packed, &max_size, key->key.pk.dh.type,
+			      (void *)&key->key.pk.dh);
+		if (ret < 0) {
+			*packed_size = max_size;
+			err();
+			return ret;
+		}
+		break;
+	default:
+		err();
+		return -EINVAL;
 	}
-	
+
 	*packed_size = max_size;
 
 	return 0;
 }
 
-int ncr_pk_unpack( struct key_item_st * key, const void * packed, size_t packed_size)
+int ncr_pk_unpack(struct key_item_st *key, const void *packed,
+		  size_t packed_size)
 {
 	int cret, ret;
 
@@ -196,31 +208,33 @@ int ncr_pk_unpack( struct key_item_st * key, const void * packed, size_t packed_
 		return -EINVAL;
 	}
 
-	switch(key->algorithm->algo) {
-		case NCR_ALG_RSA:
-			cret = rsa_import(packed, packed_size, (void*)&key->key.pk.rsa);
-			if (cret != CRYPT_OK) {
-				err();
-				return _ncr_tomerr(cret);
-			}
-			break;
-		case NCR_ALG_DSA:
-			cret = dsa_import(packed, packed_size, (void*)&key->key.pk.dsa);
-			if (cret != CRYPT_OK) {
-				err();
-				return _ncr_tomerr(cret);
-			}
-			break;
-		case NCR_ALG_DH:
-			ret = dh_import(packed, packed_size, (void*)&key->key.pk.dh);
-			if (ret < 0) {
-				err();
-				return ret;
-			}
-			break;
-		default:
+	switch (key->algorithm->algo) {
+	case NCR_ALG_RSA:
+		cret =
+		    rsa_import(packed, packed_size, (void *)&key->key.pk.rsa);
+		if (cret != CRYPT_OK) {
 			err();
-			return -EINVAL;
+			return _ncr_tomerr(cret);
+		}
+		break;
+	case NCR_ALG_DSA:
+		cret =
+		    dsa_import(packed, packed_size, (void *)&key->key.pk.dsa);
+		if (cret != CRYPT_OK) {
+			err();
+			return _ncr_tomerr(cret);
+		}
+		break;
+	case NCR_ALG_DH:
+		ret = dh_import(packed, packed_size, (void *)&key->key.pk.dh);
+		if (ret < 0) {
+			err();
+			return ret;
+		}
+		break;
+	default:
+		err();
+		return -EINVAL;
 	}
 
 	return 0;
@@ -244,7 +258,7 @@ static int binary_to_ulong(unsigned long *dest, const struct nlattr *nla)
 }
 
 int ncr_pk_generate(const struct algo_properties_st *algo, struct nlattr *tb[],
-	struct key_item_st* private, struct key_item_st* public) 
+		    struct key_item_st *private, struct key_item_st *public)
 {
 	const struct nlattr *nla;
 	unsigned long e;
@@ -253,28 +267,29 @@ int ncr_pk_generate(const struct algo_properties_st *algo, struct nlattr *tb[],
 	private->algorithm = public->algorithm = algo;
 
 	ret = 0;
-	switch(algo->algo) {
-		case NCR_ALG_RSA:
-			nla = tb[NCR_ATTR_RSA_E];
-			if (nla != NULL) {
-				ret = binary_to_ulong(&e, nla);
-				if (ret != 0)
-					break;
-			} else
-				e = 65537;
-
-			nla = tb[NCR_ATTR_RSA_MODULUS_BITS];
-			if (nla == NULL) {
-				ret = -EINVAL;
+	switch (algo->algo) {
+	case NCR_ALG_RSA:
+		nla = tb[NCR_ATTR_RSA_E];
+		if (nla != NULL) {
+			ret = binary_to_ulong(&e, nla);
+			if (ret != 0)
 				break;
-			}
-			cret = rsa_make_key(nla_get_u32(nla) / 8, e, &private->key.pk.rsa);
-			if (cret != CRYPT_OK) {
-				err();
-				return _ncr_tomerr(cret);
-			}
+		} else
+			e = 65537;
+
+		nla = tb[NCR_ATTR_RSA_MODULUS_BITS];
+		if (nla == NULL) {
+			ret = -EINVAL;
 			break;
-		case NCR_ALG_DSA: {
+		}
+		cret =
+		    rsa_make_key(nla_get_u32(nla) / 8, e, &private->key.pk.rsa);
+		if (cret != CRYPT_OK) {
+			err();
+			return _ncr_tomerr(cret);
+		}
+		break;
+	case NCR_ALG_DSA:{
 			u32 q_bits, p_bits;
 
 			nla = tb[NCR_ATTR_DSA_Q_BITS];
@@ -295,7 +310,7 @@ int ncr_pk_generate(const struct algo_properties_st *algo, struct nlattr *tb[],
 			}
 			break;
 		}
-		case NCR_ALG_DH: {
+	case NCR_ALG_DH:{
 			const struct nlattr *p, *g;
 
 			p = tb[NCR_ATTR_DH_PRIME];
@@ -320,9 +335,9 @@ int ncr_pk_generate(const struct algo_properties_st *algo, struct nlattr *tb[],
 			}
 			break;
 		}
-		default:
-			err();
-			return -EINVAL;
+	default:
+		err();
+		return -EINVAL;
 	}
 
 fail:
@@ -336,14 +351,14 @@ fail:
 		err();
 		return ret;
 	}
-	
+
 	return 0;
 }
 
 /* Encryption/Decryption
  */
 
-void ncr_pk_cipher_deinit(struct ncr_pk_ctx* ctx)
+void ncr_pk_cipher_deinit(struct ncr_pk_ctx *ctx)
 {
 	if (ctx->init) {
 		ctx->init = 0;
@@ -352,14 +367,14 @@ void ncr_pk_cipher_deinit(struct ncr_pk_ctx* ctx)
 }
 
 int ncr_pk_cipher_init(const struct algo_properties_st *algo,
-		       struct ncr_pk_ctx* ctx, struct nlattr *tb[],
+		       struct ncr_pk_ctx *ctx, struct nlattr *tb[],
 		       struct key_item_st *key,
 		       const struct algo_properties_st *sign_hash)
 {
 	const struct nlattr *nla;
 
 	memset(ctx, 0, sizeof(*ctx));
-	
+
 	/* Allow using the same key for transparent and non-transparent
 	   hashing. */
 	if (key->algorithm->algo != algo->algo) {
@@ -372,57 +387,58 @@ int ncr_pk_cipher_init(const struct algo_properties_st *algo,
 	ctx->sign_hash = sign_hash;
 	ctx->salt_len = 0;
 
-	switch(algo->algo) {
-		case NCR_ALG_RSA:
-			nla = tb[NCR_ATTR_RSA_ENCODING_METHOD];
-			if (nla == NULL) {
-				err();
-				return -EINVAL;
-			}
-			switch (nla_get_u32(nla)) {
-			case RSA_PKCS1_V1_5:
-				ctx->type = LTC_LTC_PKCS_1_V1_5;
-				break;
-			case RSA_PKCS1_OAEP:
-				ctx->type = LTC_LTC_PKCS_1_OAEP;
-				nla = tb[NCR_ATTR_RSA_OAEP_HASH_ALGORITHM];
-				ctx->oaep_hash = _ncr_nla_to_properties(nla);
-				if (ctx->oaep_hash == NULL) {
-				  err();
-				  return -EINVAL;
-				}
-				break;
-			case RSA_PKCS1_PSS:
-				ctx->type = LTC_LTC_PKCS_1_PSS;
-				nla = tb[NCR_ATTR_RSA_PSS_SALT_LENGTH];
-				if (nla != NULL)
-					ctx->salt_len = nla_get_u32(nla);
-				break;
-			default:
+	switch (algo->algo) {
+	case NCR_ALG_RSA:
+		nla = tb[NCR_ATTR_RSA_ENCODING_METHOD];
+		if (nla == NULL) {
+			err();
+			return -EINVAL;
+		}
+		switch (nla_get_u32(nla)) {
+		case RSA_PKCS1_V1_5:
+			ctx->type = LTC_LTC_PKCS_1_V1_5;
+			break;
+		case RSA_PKCS1_OAEP:
+			ctx->type = LTC_LTC_PKCS_1_OAEP;
+			nla = tb[NCR_ATTR_RSA_OAEP_HASH_ALGORITHM];
+			ctx->oaep_hash = _ncr_nla_to_properties(nla);
+			if (ctx->oaep_hash == NULL) {
 				err();
 				return -EINVAL;
 			}
 			break;
-		case NCR_ALG_DSA:
+		case RSA_PKCS1_PSS:
+			ctx->type = LTC_LTC_PKCS_1_PSS;
+			nla = tb[NCR_ATTR_RSA_PSS_SALT_LENGTH];
+			if (nla != NULL)
+				ctx->salt_len = nla_get_u32(nla);
 			break;
 		default:
 			err();
 			return -EINVAL;
+		}
+		break;
+	case NCR_ALG_DSA:
+		break;
+	default:
+		err();
+		return -EINVAL;
 	}
-	
+
 	ctx->init = 1;
 
 	return 0;
 }
 
-int ncr_pk_cipher_encrypt(const struct ncr_pk_ctx* ctx, 
-	const struct scatterlist* isg, unsigned int isg_cnt, size_t isg_size,
-	struct scatterlist *osg, unsigned int osg_cnt, size_t* osg_size)
+int ncr_pk_cipher_encrypt(const struct ncr_pk_ctx *ctx,
+			  const struct scatterlist *isg, unsigned int isg_cnt,
+			  size_t isg_size, struct scatterlist *osg,
+			  unsigned int osg_cnt, size_t * osg_size)
 {
-int cret, ret;
-unsigned long osize = *osg_size;
-uint8_t* tmp;
-void * input, *output;
+	int cret, ret;
+	unsigned long osize = *osg_size;
+	uint8_t *tmp;
+	void *input, *output;
 
 	tmp = kmalloc(isg_size + *osg_size, GFP_KERNEL);
 	if (tmp == NULL) {
@@ -430,7 +446,9 @@ void * input, *output;
 		return -ENOMEM;
 	}
 
-	ret = sg_copy_to_buffer((struct scatterlist*)isg, isg_cnt, tmp, isg_size);
+	ret =
+	    sg_copy_to_buffer((struct scatterlist *)isg, isg_cnt, tmp,
+			      isg_size);
 	if (ret != isg_size) {
 		err();
 		ret = -EINVAL;
@@ -440,27 +458,27 @@ void * input, *output;
 	input = tmp;
 	output = &tmp[isg_size];
 
+	switch (ctx->algorithm->algo) {
+	case NCR_ALG_RSA:
+		cret = rsa_encrypt_key_ex(input, isg_size, output, &osize,
+					  NULL, 0, ctx->oaep_hash, ctx->type,
+					  &ctx->key->key.pk.rsa);
 
-	switch(ctx->algorithm->algo) {
-		case NCR_ALG_RSA:
-			cret = rsa_encrypt_key_ex( input, isg_size, output, &osize, 
-				NULL, 0, ctx->oaep_hash, ctx->type, &ctx->key->key.pk.rsa);
-
-			if (cret != CRYPT_OK) {
-				err();
-				ret = _ncr_tomerr(cret);
-				goto fail;
-			}
-			*osg_size = osize;
-
-			break;
-		case NCR_ALG_DSA:
-			ret = -EINVAL;
-			goto fail;
-		default:
+		if (cret != CRYPT_OK) {
 			err();
-			ret = -EINVAL;
+			ret = _ncr_tomerr(cret);
 			goto fail;
+		}
+		*osg_size = osize;
+
+		break;
+	case NCR_ALG_DSA:
+		ret = -EINVAL;
+		goto fail;
+	default:
+		err();
+		ret = -EINVAL;
+		goto fail;
 	}
 
 	ret = sg_copy_from_buffer(osg, osg_cnt, output, *osg_size);
@@ -468,7 +486,7 @@ void * input, *output;
 		err();
 		ret = -EINVAL;
 		goto fail;
-	}	
+	}
 
 	ret = 0;
 
@@ -477,15 +495,16 @@ fail:
 	return ret;
 }
 
-int ncr_pk_cipher_decrypt(const struct ncr_pk_ctx* ctx, 
-	const struct scatterlist* isg, unsigned int isg_cnt, size_t isg_size,
-	struct scatterlist *osg, unsigned int osg_cnt, size_t* osg_size)
+int ncr_pk_cipher_decrypt(const struct ncr_pk_ctx *ctx,
+			  const struct scatterlist *isg, unsigned int isg_cnt,
+			  size_t isg_size, struct scatterlist *osg,
+			  unsigned int osg_cnt, size_t * osg_size)
 {
-int cret, ret;
-int stat;
-unsigned long osize = *osg_size;
-uint8_t* tmp;
-void * input, *output;
+	int cret, ret;
+	int stat;
+	unsigned long osize = *osg_size;
+	uint8_t *tmp;
+	void *input, *output;
 
 	tmp = kmalloc(isg_size + *osg_size, GFP_KERNEL);
 	if (tmp == NULL) {
@@ -496,38 +515,41 @@ void * input, *output;
 	input = tmp;
 	output = &tmp[isg_size];
 
-	ret = sg_copy_to_buffer((struct scatterlist*)isg, isg_cnt, input, isg_size);
+	ret =
+	    sg_copy_to_buffer((struct scatterlist *)isg, isg_cnt, input,
+			      isg_size);
 	if (ret != isg_size) {
 		err();
 		ret = -EINVAL;
 		goto fail;
 	}
 
-	switch(ctx->algorithm->algo) {
-		case NCR_ALG_RSA:
-			cret = rsa_decrypt_key_ex( input, isg_size, output, &osize, 
-				NULL, 0, ctx->oaep_hash, ctx->type, &stat, &ctx->key->key.pk.rsa);
+	switch (ctx->algorithm->algo) {
+	case NCR_ALG_RSA:
+		cret = rsa_decrypt_key_ex(input, isg_size, output, &osize,
+					  NULL, 0, ctx->oaep_hash, ctx->type,
+					  &stat, &ctx->key->key.pk.rsa);
 
-			if (cret != CRYPT_OK) {
-				err();
-				ret = _ncr_tomerr(cret);
-				goto fail;
-			}
-
-			if (stat==0) {
-				err();
-				ret = -EINVAL;
-				goto fail;
-			}
-			*osg_size = osize;
-			break;
-		case NCR_ALG_DSA:
-			ret = -EINVAL;
+		if (cret != CRYPT_OK) {
+			err();
+			ret = _ncr_tomerr(cret);
 			goto fail;
-		default:
+		}
+
+		if (stat == 0) {
 			err();
 			ret = -EINVAL;
 			goto fail;
+		}
+		*osg_size = osize;
+		break;
+	case NCR_ALG_DSA:
+		ret = -EINVAL;
+		goto fail;
+	default:
+		err();
+		ret = -EINVAL;
+		goto fail;
 	}
 
 	ret = sg_copy_from_buffer(osg, osg_cnt, output, *osg_size);
@@ -535,101 +557,102 @@ void * input, *output;
 		err();
 		ret = -EINVAL;
 		goto fail;
-	}	
+	}
 
 	ret = 0;
 fail:
 	kfree(tmp);
-	
+
 	return ret;
 }
 
 int ncr_pk_cipher_sign(const struct ncr_pk_ctx *ctx, const void *hash,
-		       size_t hash_size, void *sig, size_t *sig_size)
+		       size_t hash_size, void *sig, size_t * sig_size)
 {
 	int cret;
 	unsigned long osize = *sig_size;
 
-	switch(ctx->algorithm->algo) {
-		case NCR_ALG_RSA:
-			if (ctx->sign_hash == NULL) {
-				err();
-				return -EINVAL;
-			}
-			cret = rsa_sign_hash_ex(hash, hash_size, sig, &osize,
-				ctx->type, ctx->sign_hash, ctx->salt_len, &ctx->key->key.pk.rsa);
-			if (cret != CRYPT_OK) {
-				err();
-				return _ncr_tomerr(cret);
-			}
-			*sig_size = osize;
-			break;
-		case NCR_ALG_DSA:
-			cret = dsa_sign_hash(hash, hash_size, sig, &osize,
-				&ctx->key->key.pk.dsa);
-
-			if (cret != CRYPT_OK) {
-				err();
-				return _ncr_tomerr(cret);
-			}
-			*sig_size = osize;
-			break;
-		default:
+	switch (ctx->algorithm->algo) {
+	case NCR_ALG_RSA:
+		if (ctx->sign_hash == NULL) {
 			err();
 			return -EINVAL;
+		}
+		cret = rsa_sign_hash_ex(hash, hash_size, sig, &osize,
+					ctx->type, ctx->sign_hash,
+					ctx->salt_len, &ctx->key->key.pk.rsa);
+		if (cret != CRYPT_OK) {
+			err();
+			return _ncr_tomerr(cret);
+		}
+		*sig_size = osize;
+		break;
+	case NCR_ALG_DSA:
+		cret = dsa_sign_hash(hash, hash_size, sig, &osize,
+				     &ctx->key->key.pk.dsa);
+
+		if (cret != CRYPT_OK) {
+			err();
+			return _ncr_tomerr(cret);
+		}
+		*sig_size = osize;
+		break;
+	default:
+		err();
+		return -EINVAL;
 	}
 	return 0;
 }
 
-int ncr_pk_cipher_verify(const struct ncr_pk_ctx* ctx, const void *sig,
+int ncr_pk_cipher_verify(const struct ncr_pk_ctx *ctx, const void *sig,
 			 size_t sig_size, const void *hash, size_t hash_size)
 {
 	int cret, ret, stat;
 
-	switch(ctx->algorithm->algo) {
-		case NCR_ALG_RSA:
-			if (ctx->sign_hash == NULL) {
-				err();
-				return -EINVAL;
-			}
-			cret = rsa_verify_hash_ex(sig, sig_size, hash,
-						  hash_size, ctx->type,
-						  ctx->sign_hash, ctx->salt_len,
-						  &stat, &ctx->key->key.pk.rsa);
-			if (cret != CRYPT_OK) {
-				err();
-				ret = _ncr_tomerr(cret);
-				goto fail;
-			}
-
-			ret = (stat == 1);
-			break;
-		case NCR_ALG_DSA:
-			cret = dsa_verify_hash(sig, sig_size, hash, hash_size,
-					       &stat, &ctx->key->key.pk.dsa);
-			if (cret != CRYPT_OK) {
-				err();
-				ret = _ncr_tomerr(cret);
-				goto fail;
-			}
+	switch (ctx->algorithm->algo) {
+	case NCR_ALG_RSA:
+		if (ctx->sign_hash == NULL) {
+			err();
+			return -EINVAL;
+		}
+		cret = rsa_verify_hash_ex(sig, sig_size, hash,
+					  hash_size, ctx->type,
+					  ctx->sign_hash, ctx->salt_len,
+					  &stat, &ctx->key->key.pk.rsa);
+		if (cret != CRYPT_OK) {
+			err();
+			ret = _ncr_tomerr(cret);
+			goto fail;
+		}
 
-			ret = (stat == 1);
-			break;
-		default:
+		ret = (stat == 1);
+		break;
+	case NCR_ALG_DSA:
+		cret = dsa_verify_hash(sig, sig_size, hash, hash_size,
+				       &stat, &ctx->key->key.pk.dsa);
+		if (cret != CRYPT_OK) {
 			err();
-			ret = -EINVAL;
+			ret = _ncr_tomerr(cret);
 			goto fail;
+		}
+
+		ret = (stat == 1);
+		break;
+	default:
+		err();
+		ret = -EINVAL;
+		goto fail;
 	}
 
 fail:
 	return ret;
 }
 
-int ncr_pk_derive(struct key_item_st* newkey, struct key_item_st* oldkey,
+int ncr_pk_derive(struct key_item_st *newkey, struct key_item_st *oldkey,
 		  struct nlattr *tb[])
 {
-const struct nlattr *nla;
-int ret;
+	const struct nlattr *nla;
+	int ret;
 
 	nla = tb[NCR_ATTR_DERIVATION_ALGORITHM];
 	if (nla == NULL) {
@@ -662,27 +685,27 @@ int ret;
 	return 0;
 }
 
-int ncr_pk_get_rsa_size( rsa_key* key)
+int ncr_pk_get_rsa_size(rsa_key * key)
 {
-int ret;
+	int ret;
 	ret = mp_count_bits(&key->N);
 	if (ret <= 0) {
 		err();
 		return -EINVAL;
 	}
-	
+
 	return ret;
 }
 
-int ncr_pk_get_dsa_size( dsa_key* key)
+int ncr_pk_get_dsa_size(dsa_key * key)
 {
-int ret;
+	int ret;
 	ret = mp_count_bits(&key->p);
 	if (ret <= 0) {
 		err();
 		return -EINVAL;
 	}
-	
+
 	return ret;
 }
 
diff --git a/ncr-pk.h b/ncr-pk.h
index fb9aba5..c8d61cb 100644
--- a/ncr-pk.h
+++ b/ncr-pk.h
@@ -6,54 +6,57 @@
 struct nlattr;
 
 struct ncr_pk_ctx {
-	const struct algo_properties_st *algorithm; /* algorithm */
-	
-	const struct algo_properties_st *sign_hash; /* for verification */
-	
+	const struct algo_properties_st *algorithm;	/* algorithm */
+
+	const struct algo_properties_st *sign_hash;	/* for verification */
+
 	const struct algo_properties_st *oaep_hash;
-	int salt_len; /* for RSA-PSS signatures */
-	
-	int type; /* libtomcrypt type */
-	int init; /* non zero if initialized */
-	
-	struct key_item_st * key;
+	int salt_len;		/* for RSA-PSS signatures */
+
+	int type;		/* libtomcrypt type */
+	int init;		/* non zero if initialized */
+
+	struct key_item_st *key;
 };
 
 /* PK */
-void ncr_pk_clear(struct key_item_st* key);
+void ncr_pk_clear(struct key_item_st *key);
 int ncr_pk_generate(const struct algo_properties_st *algo, struct nlattr *tb[],
-	struct key_item_st* private, struct key_item_st* public);
-int ncr_pk_pack( const struct key_item_st * key, uint8_t * packed, uint32_t * packed_size);
-int ncr_pk_unpack( struct key_item_st * key, const void * packed, size_t packed_size);
+		    struct key_item_st *private, struct key_item_st *public);
+int ncr_pk_pack(const struct key_item_st *key, uint8_t * packed,
+		uint32_t * packed_size);
+int ncr_pk_unpack(struct key_item_st *key, const void *packed,
+		  size_t packed_size);
 
 /* encryption/decryption */
 int ncr_pk_cipher_init(const struct algo_properties_st *algo,
-		       struct ncr_pk_ctx* ctx, struct nlattr *tb[],
+		       struct ncr_pk_ctx *ctx, struct nlattr *tb[],
 		       struct key_item_st *key,
 		       const struct algo_properties_st *sign_hash);
-void ncr_pk_cipher_deinit(struct ncr_pk_ctx* ctx);
+void ncr_pk_cipher_deinit(struct ncr_pk_ctx *ctx);
 
-int ncr_pk_cipher_encrypt(const struct ncr_pk_ctx* ctx, 
-	const struct scatterlist* isg, unsigned int isg_cnt, size_t isg_size,
-	struct scatterlist *osg, unsigned int osg_cnt, size_t* osg_size);
+int ncr_pk_cipher_encrypt(const struct ncr_pk_ctx *ctx,
+			  const struct scatterlist *isg, unsigned int isg_cnt,
+			  size_t isg_size, struct scatterlist *osg,
+			  unsigned int osg_cnt, size_t * osg_size);
 
-int ncr_pk_cipher_decrypt(const struct ncr_pk_ctx* ctx,
- 	const struct scatterlist* isg, unsigned int isg_cnt, size_t isg_size,
-	struct scatterlist *osg, unsigned int osg_cnt, size_t* osg_size);
+int ncr_pk_cipher_decrypt(const struct ncr_pk_ctx *ctx,
+			  const struct scatterlist *isg, unsigned int isg_cnt,
+			  size_t isg_size, struct scatterlist *osg,
+			  unsigned int osg_cnt, size_t * osg_size);
 
 int ncr_pk_cipher_sign(const struct ncr_pk_ctx *ctx, const void *hash,
-		       size_t hash_size, void *sig, size_t *sig_size);
-	
-int ncr_pk_cipher_verify(const struct ncr_pk_ctx* ctx, const void *sig,
+		       size_t hash_size, void *sig, size_t * sig_size);
+
+int ncr_pk_cipher_verify(const struct ncr_pk_ctx *ctx, const void *sig,
 			 size_t sig_size, const void *hash, size_t hash_size);
 
 int _ncr_tomerr(int err);
 
-int ncr_pk_derive(struct key_item_st* newkey, struct key_item_st* oldkey,
+int ncr_pk_derive(struct key_item_st *newkey, struct key_item_st *oldkey,
 		  struct nlattr *tb[]);
 
-int ncr_pk_get_rsa_size( rsa_key* key);
-int ncr_pk_get_dsa_size( dsa_key* key);
-
+int ncr_pk_get_rsa_size(rsa_key * key);
+int ncr_pk_get_dsa_size(dsa_key * key);
 
 #endif
diff --git a/ncr-sessions.c b/ncr-sessions.c
index 3f39d6d..a716670 100644
--- a/ncr-sessions.c
+++ b/ncr-sessions.c
@@ -133,7 +133,7 @@ static void session_publish_ref(struct ncr_lists *lst,
 static struct session_item_st *session_get_ref(struct ncr_lists *lst,
 					       ncr_session_t desc)
 {
-struct session_item_st* item;
+	struct session_item_st *item;
 
 	mutex_lock(&lst->session_idr_mutex);
 	/* item may be NULL for pre-allocated session IDs. */
@@ -185,7 +185,7 @@ static void _ncr_sessions_item_put(struct session_item_st *item)
 
 static struct session_item_st *ncr_session_new(ncr_session_t desc)
 {
-	struct session_item_st* sess;
+	struct session_item_st *sess;
 
 	sess = kzalloc(sizeof(*sess), GFP_KERNEL);
 	if (sess == NULL) {
@@ -195,9 +195,9 @@ static struct session_item_st *ncr_session_new(ncr_session_t desc)
 
 	sess->array_size = DEFAULT_PREALLOC_PAGES;
 	sess->pages = kzalloc(sess->array_size *
-			sizeof(struct page *), GFP_KERNEL);
+			      sizeof(struct page *), GFP_KERNEL);
 	sess->sg = kzalloc(sess->array_size *
-			sizeof(struct scatterlist), GFP_KERNEL);
+			   sizeof(struct scatterlist), GFP_KERNEL);
 	if (sess->sg == NULL || sess->pages == NULL) {
 		err();
 		goto err_sess;
@@ -216,84 +216,85 @@ err_sess:
 	return NULL;
 }
 
-const oid_st* _ncr_properties_to_oid(const struct algo_properties_st * prop, int key_size)
+const oid_st *_ncr_properties_to_oid(const struct algo_properties_st *prop,
+				     int key_size)
 {
-int i = 0;
+	int i = 0;
 
 	if (prop->oids == NULL)
 		return NULL;
-		
+
 	do {
 		if (key_size == prop->oids[i].key_size ||
-			prop->oids[i].key_size == -1 /* catch all */) {
-			
+		    prop->oids[i].key_size == -1 /* catch all */ ) {
+
 			return &prop->oids[i].oid;
 		}
-	} while(prop->oids[++i].key_size != 0);
+	} while (prop->oids[++i].key_size != 0);
 
 	return NULL;
 }
 
 const static struct algo_oid_st aes_cbc_oids[] = {
-	{.key_size=16, 
-	.oid = {{2,16,840,1,101,3,4,1,2}, 9}},
-	{.key_size=24, 
-	.oid = {{2,16,840,1,101,3,4,1,22}, 9}},
-	{.key_size=32, 
-	.oid = {{2,16,840,1,101,3,4,1,42}, 9}},
-	{.key_size=0 }
+	{.key_size = 16,
+	 .oid = {{2, 16, 840, 1, 101, 3, 4, 1, 2}, 9}},
+	{.key_size = 24,
+	 .oid = {{2, 16, 840, 1, 101, 3, 4, 1, 22}, 9}},
+	{.key_size = 32,
+	 .oid = {{2, 16, 840, 1, 101, 3, 4, 1, 42}, 9}},
+	{.key_size = 0}
 };
 
 const static struct algo_oid_st aes_ecb_oids[] = {
-	{.key_size=16, 
-	.oid = {{2,16,840,1,101,3,4,1,1}, 9}},
-	{.key_size=24, 
-	.oid = {{2,16,840,1,101,3,4,1,21}, 9}},
-	{.key_size=32, 
-	.oid = {{2,16,840,1,101,3,4,1,41}, 9}},
-	{.key_size=0 }
+	{.key_size = 16,
+	 .oid = {{2, 16, 840, 1, 101, 3, 4, 1, 1}, 9}},
+	{.key_size = 24,
+	 .oid = {{2, 16, 840, 1, 101, 3, 4, 1, 21}, 9}},
+	{.key_size = 32,
+	 .oid = {{2, 16, 840, 1, 101, 3, 4, 1, 41}, 9}},
+	{.key_size = 0}
 };
 
 const static struct algo_oid_st des3_cbc_oids[] = {
-	{.key_size=-1, 
-	.oid = {{1,2,840,113549,3,7}, 6}},
-	{.key_size=0 }
+	{.key_size = -1,
+	 .oid = {{1, 2, 840, 113549, 3, 7}, 6}},
+	{.key_size = 0}
 };
 
 /* http://www.oid-info.com/get/1.3.6.1.4.1.4929.1.7 
  */
 const static struct algo_oid_st des3_ecb_oids[] = {
-	{.key_size=-1, 
-	.oid = {{1,3,6,1,4,1,4929,1,7}, 9}},
-	{.key_size=0 }
+	{.key_size = -1,
+	 .oid = {{1, 3, 6, 1, 4, 1, 4929, 1, 7}, 9}},
+	{.key_size = 0}
 };
 
 const static struct algo_oid_st camelia_cbc_oids[] = {
-	{.key_size=16, 
-	.oid = {{1,2,392,200011,61,1,1,1,2}, 9}},
-	{.key_size=24, 
-	.oid = {{1,2,392,200011,61,1,1,1,3}, 9}},
-	{.key_size=32, 
-	.oid = {{1,2,392,200011,61,1,1,1,4}, 9}},
-	{.key_size=0 }
+	{.key_size = 16,
+	 .oid = {{1, 2, 392, 200011, 61, 1, 1, 1, 2}, 9}},
+	{.key_size = 24,
+	 .oid = {{1, 2, 392, 200011, 61, 1, 1, 1, 3}, 9}},
+	{.key_size = 32,
+	 .oid = {{1, 2, 392, 200011, 61, 1, 1, 1, 4}, 9}},
+	{.key_size = 0}
 };
 
 const static struct algo_oid_st rsa_oid[] = {
-	{.key_size=-1, 
-	.oid = {{1,2,840,113549,1,1,1}, 7}},
-	{.key_size=0 }
+	{.key_size = -1,
+	 .oid = {{1, 2, 840, 113549, 1, 1, 1}, 7}},
+	{.key_size = 0}
 };
 
 const static struct algo_oid_st dsa_oid[] = {
-	{.key_size=-1, 
-	.oid = {{1,2,840,10040,4,1}, 6}},
-	{.key_size=0 }
+	{.key_size = -1,
+	 .oid = {{1, 2, 840, 10040, 4, 1}, 6}},
+	{.key_size = 0}
 };
 
 const static struct algo_oid_st dh_oid[] = {
-	{.key_size=-1, 
-	.oid = {{1,2,840,10046,2,1}, 6}},
-	{.key_size=0 }
+	{.key_size = -1,
+	 .oid = {{1, 2, 840, 10046, 2, 1}, 6}},
+	{.key_size = 0}
 };
 
 /* OIDs are used in cipher algorithms to distinguish keys on key wrapping.
@@ -301,87 +302,87 @@ const static struct algo_oid_st dh_oid[] = {
 
 static const struct algo_properties_st algo_properties[] = {
 #define KSTR(x) .kstr = x, .kstr_len = sizeof(x) - 1
-	{ .algo = NCR_ALG_NULL, KSTR("ecb(cipher_null)"),
-		.needs_iv = 0, .is_symmetric=1, .can_encrypt=1,
-		.key_type = NCR_KEY_TYPE_INVALID },
-	{ .algo = NCR_ALG_3DES_CBC, KSTR("cbc(des3_ede)"),
-		.needs_iv = 1, .is_symmetric=1, .can_encrypt=1,
-		.key_type = NCR_KEY_TYPE_SECRET, .oids = des3_cbc_oids },
-	{ .algo = NCR_ALG_3DES_ECB, KSTR("ecb(des3_ede)"),
-		.needs_iv = 0, .is_symmetric=1, .can_encrypt=1,
-		.key_type = NCR_KEY_TYPE_SECRET, .oids = des3_ecb_oids },
-	{ .algo = NCR_ALG_AES_CBC, KSTR("cbc(aes)"),
-		.needs_iv = 1, .is_symmetric=1, .can_encrypt=1,
-		.key_type = NCR_KEY_TYPE_SECRET, .oids = aes_cbc_oids },
-	{ .algo = NCR_ALG_CAMELIA_CBC, KSTR("cbc(camelia)"),
-		.needs_iv = 1, .is_symmetric=1, .can_encrypt=1,
-		.key_type = NCR_KEY_TYPE_SECRET, .oids = camelia_cbc_oids },
-	{ .algo = NCR_ALG_AES_CTR, KSTR("ctr(aes)"),
-		.needs_iv = 1, .is_symmetric=1, .can_encrypt=1,
-		.key_type = NCR_KEY_TYPE_SECRET, /* FIXME: no OIDs */ },
-	{ .algo = NCR_ALG_CAMELIA_CTR, KSTR("ctr(camelia)"),
-		.needs_iv = 1, .is_symmetric=1, .can_encrypt=1,
-		.key_type = NCR_KEY_TYPE_SECRET, /* FIXME: no OIDs */ },
-	{ .algo = NCR_ALG_AES_ECB, KSTR("ecb(aes)"),
-		.needs_iv = 0, .is_symmetric=1, .can_encrypt=1,
-		.key_type = NCR_KEY_TYPE_SECRET, .oids = aes_ecb_oids },
-	{ .algo = NCR_ALG_CAMELIA_ECB, KSTR("ecb(camelia)"),
-		.needs_iv = 0, .is_symmetric=1, .can_encrypt=1,
-		.key_type = NCR_KEY_TYPE_SECRET, /* FIXME: no OIDs */ },
-	{ .algo = NCR_ALG_SHA1, KSTR("sha1"),
-		.digest_size = 20, .can_digest=1,
-		.key_type = NCR_KEY_TYPE_INVALID },
-	{ .algo = NCR_ALG_MD5, KSTR("md5"),
-		.digest_size = 16, .can_digest=1,
-		.key_type = NCR_KEY_TYPE_INVALID },
-	{ .algo = NCR_ALG_SHA2_224, KSTR("sha224"),
-		.digest_size = 28, .can_digest=1,
-		.key_type = NCR_KEY_TYPE_INVALID },
-	{ .algo = NCR_ALG_SHA2_256, KSTR("sha256"),
-		.digest_size = 32, .can_digest=1,
-		.key_type = NCR_KEY_TYPE_INVALID },
-	{ .algo = NCR_ALG_SHA2_384, KSTR("sha384"),
-		.digest_size = 48, .can_digest=1,
-		.key_type = NCR_KEY_TYPE_INVALID },
-	{ .algo = NCR_ALG_SHA2_512, KSTR("sha512"),
-		.digest_size = 64, .can_digest=1,
-		.key_type = NCR_KEY_TYPE_INVALID },
-	{ .is_hmac = 1, KSTR("hmac(sha1)"),
-		.digest_size = 20, .can_sign=1,
-		.key_type = NCR_KEY_TYPE_SECRET },
-	{ .is_hmac = 1, KSTR("hmac(md5)"),
-		.digest_size = 16, .can_sign=1,
-		.key_type = NCR_KEY_TYPE_SECRET },
-	{ .is_hmac = 1, KSTR("hmac(sha224)"),
-		.digest_size = 28, .can_sign=1,
-		.key_type = NCR_KEY_TYPE_SECRET },
-	{ .is_hmac = 1, KSTR("hmac(sha256)"),
-		.digest_size = 32, .can_sign=1,
-		.key_type = NCR_KEY_TYPE_SECRET },
-	{ .is_hmac = 1, KSTR("hmac(sha384)"),
-		.digest_size = 48, .can_sign=1,
-		.key_type = NCR_KEY_TYPE_SECRET },
-	{ .is_hmac = 1, KSTR("hmac(sha512)"),
-		.digest_size = 64, .can_sign=1,
-		.key_type = NCR_KEY_TYPE_SECRET },
+	{.algo = NCR_ALG_NULL, KSTR("ecb(cipher_null)"),
+	 .needs_iv = 0,.is_symmetric = 1,.can_encrypt = 1,
+	 .key_type = NCR_KEY_TYPE_INVALID},
+	{.algo = NCR_ALG_3DES_CBC, KSTR("cbc(des3_ede)"),
+	 .needs_iv = 1,.is_symmetric = 1,.can_encrypt = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET,.oids = des3_cbc_oids},
+	{.algo = NCR_ALG_3DES_ECB, KSTR("ecb(des3_ede)"),
+	 .needs_iv = 0,.is_symmetric = 1,.can_encrypt = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET,.oids = des3_ecb_oids},
+	{.algo = NCR_ALG_AES_CBC, KSTR("cbc(aes)"),
+	 .needs_iv = 1,.is_symmetric = 1,.can_encrypt = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET,.oids = aes_cbc_oids},
+	{.algo = NCR_ALG_CAMELIA_CBC, KSTR("cbc(camelia)"),
+	 .needs_iv = 1,.is_symmetric = 1,.can_encrypt = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET,.oids = camelia_cbc_oids},
+	{.algo = NCR_ALG_AES_CTR, KSTR("ctr(aes)"),
+	 .needs_iv = 1,.is_symmetric = 1,.can_encrypt = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET, /* FIXME: no OIDs */ },
+	{.algo = NCR_ALG_CAMELIA_CTR, KSTR("ctr(camelia)"),
+	 .needs_iv = 1,.is_symmetric = 1,.can_encrypt = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET, /* FIXME: no OIDs */ },
+	{.algo = NCR_ALG_AES_ECB, KSTR("ecb(aes)"),
+	 .needs_iv = 0,.is_symmetric = 1,.can_encrypt = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET,.oids = aes_ecb_oids},
+	{.algo = NCR_ALG_CAMELIA_ECB, KSTR("ecb(camelia)"),
+	 .needs_iv = 0,.is_symmetric = 1,.can_encrypt = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET, /* FIXME: no OIDs */ },
+	{.algo = NCR_ALG_SHA1, KSTR("sha1"),
+	 .digest_size = 20,.can_digest = 1,
+	 .key_type = NCR_KEY_TYPE_INVALID},
+	{.algo = NCR_ALG_MD5, KSTR("md5"),
+	 .digest_size = 16,.can_digest = 1,
+	 .key_type = NCR_KEY_TYPE_INVALID},
+	{.algo = NCR_ALG_SHA2_224, KSTR("sha224"),
+	 .digest_size = 28,.can_digest = 1,
+	 .key_type = NCR_KEY_TYPE_INVALID},
+	{.algo = NCR_ALG_SHA2_256, KSTR("sha256"),
+	 .digest_size = 32,.can_digest = 1,
+	 .key_type = NCR_KEY_TYPE_INVALID},
+	{.algo = NCR_ALG_SHA2_384, KSTR("sha384"),
+	 .digest_size = 48,.can_digest = 1,
+	 .key_type = NCR_KEY_TYPE_INVALID},
+	{.algo = NCR_ALG_SHA2_512, KSTR("sha512"),
+	 .digest_size = 64,.can_digest = 1,
+	 .key_type = NCR_KEY_TYPE_INVALID},
+	{.is_hmac = 1, KSTR("hmac(sha1)"),
+	 .digest_size = 20,.can_sign = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET},
+	{.is_hmac = 1, KSTR("hmac(md5)"),
+	 .digest_size = 16,.can_sign = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET},
+	{.is_hmac = 1, KSTR("hmac(sha224)"),
+	 .digest_size = 28,.can_sign = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET},
+	{.is_hmac = 1, KSTR("hmac(sha256)"),
+	 .digest_size = 32,.can_sign = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET},
+	{.is_hmac = 1, KSTR("hmac(sha384)"),
+	 .digest_size = 48,.can_sign = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET},
+	{.is_hmac = 1, KSTR("hmac(sha512)"),
+	 .digest_size = 64,.can_sign = 1,
+	 .key_type = NCR_KEY_TYPE_SECRET},
 	/* NOTE: These algorithm names are not available through the kernel API
 	   (yet). */
-	{ .algo = NCR_ALG_RSA, KSTR("rsa"), .is_pk = 1,
-		.can_encrypt=1, .can_sign=1, .key_type = NCR_KEY_TYPE_PUBLIC,
-		.oids = rsa_oid },
-	{ .algo = NCR_ALG_DSA, KSTR("dsa"), .is_pk = 1,
-		.can_sign=1, .key_type = NCR_KEY_TYPE_PUBLIC,
-		.oids = dsa_oid },
-	{ .algo = NCR_ALG_DH, KSTR("dh"), .is_pk = 1,
-		.can_kx=1, .key_type = NCR_KEY_TYPE_PUBLIC,
-		.oids = dh_oid },
-
-	{ .algo = NCR_ALG_DSA, KSTR(NCR_ALG_DSA_TRANSPARENT_HASH), .is_pk = 1,
-	  .can_sign=1, .has_transparent_hash = 1,
-	  .key_type = NCR_KEY_TYPE_PUBLIC, .oids = rsa_oid },
-	{ .algo = NCR_ALG_RSA, KSTR(NCR_ALG_RSA_TRANSPARENT_HASH), .is_pk = 1,
-	  .can_encrypt=1, .can_sign=1, .has_transparent_hash = 1,
-	  .key_type = NCR_KEY_TYPE_PUBLIC, .oids = dsa_oid },
+	{.algo = NCR_ALG_RSA, KSTR("rsa"),.is_pk = 1,
+	 .can_encrypt = 1,.can_sign = 1,.key_type = NCR_KEY_TYPE_PUBLIC,
+	 .oids = rsa_oid},
+	{.algo = NCR_ALG_DSA, KSTR("dsa"),.is_pk = 1,
+	 .can_sign = 1,.key_type = NCR_KEY_TYPE_PUBLIC,
+	 .oids = dsa_oid},
+	{.algo = NCR_ALG_DH, KSTR("dh"),.is_pk = 1,
+	 .can_kx = 1,.key_type = NCR_KEY_TYPE_PUBLIC,
+	 .oids = dh_oid},
+
+	{.algo = NCR_ALG_DSA, KSTR(NCR_ALG_DSA_TRANSPARENT_HASH),.is_pk = 1,
+	 .can_sign = 1,.has_transparent_hash = 1,
+	 .key_type = NCR_KEY_TYPE_PUBLIC,.oids = rsa_oid},
+	{.algo = NCR_ALG_RSA, KSTR(NCR_ALG_RSA_TRANSPARENT_HASH),.is_pk = 1,
+	 .can_encrypt = 1,.can_sign = 1,.has_transparent_hash = 1,
+	 .key_type = NCR_KEY_TYPE_PUBLIC,.oids = dsa_oid},
 
 #undef KSTR
 };
@@ -401,21 +402,21 @@ const struct algo_properties_st *_ncr_algo_to_properties(ncr_algorithm_t algo)
 	return NULL;
 }
 
-static void print_oid(oid_st* oid)
+static void print_oid(oid_st * oid)
 {
-char txt[128]="";
-char tmp[64];
-int i;
+	char txt[128] = "";
+	char tmp[64];
+	int i;
 
-	for (i=0;i<oid->OIDlen;i++) {
+	for (i = 0; i < oid->OIDlen; i++) {
 		sprintf(tmp, "%d.", (int)oid->OID[i]);
 		strcat(txt, tmp);
 	}
-	
+
 	dprintk(1, KERN_DEBUG, "unknown oid: %s\n", txt);
 }
 
-const struct algo_properties_st *_ncr_oid_to_properties(oid_st* oid)
+const struct algo_properties_st *_ncr_oid_to_properties(oid_st * oid)
 {
 	const struct algo_properties_st *a;
 	int i;
@@ -423,22 +424,25 @@ const struct algo_properties_st *_ncr_oid_to_properties(oid_st* oid)
 	for (a = algo_properties;
 	     a < algo_properties + ARRAY_SIZE(algo_properties); a++) {
 
-		i=0;
-		
-		if (a->oids == NULL) continue;
-		
+		i = 0;
+
+		if (a->oids == NULL)
+			continue;
+
 		do {
-			if (a->oids[i].oid.OIDlen == oid->OIDlen && 
-				memcmp(oid->OID, a->oids[i].oid.OID, oid->OIDlen*sizeof(oid->OID[0]))==0)
+			if (a->oids[i].oid.OIDlen == oid->OIDlen &&
+			    memcmp(oid->OID, a->oids[i].oid.OID,
+				   oid->OIDlen * sizeof(oid->OID[0])) == 0)
 				return a;
-		} while(a->oids[++i].key_size != 0);
+		} while (a->oids[++i].key_size != 0);
 	}
 
 	print_oid(oid);
 	return NULL;
 }
 
-const struct algo_properties_st *_ncr_nla_to_properties(const struct nlattr *nla)
+const struct algo_properties_st *_ncr_nla_to_properties(const struct nlattr
+							*nla)
 {
 	const struct algo_properties_st *a;
 	size_t name_len;
@@ -543,228 +547,251 @@ static struct session_item_st *_ncr_session_init(struct ncr_lists *lists,
 		}
 	} else
 		ns->algorithm = old_session->algorithm;
-	
-	switch(op) {
-		case NCR_OP_ENCRYPT:
-		case NCR_OP_DECRYPT:
-			if (!ns->algorithm->can_encrypt) {
+
+	switch (op) {
+	case NCR_OP_ENCRYPT:
+	case NCR_OP_DECRYPT:
+		if (!ns->algorithm->can_encrypt) {
+			err();
+			ret = -EINVAL;
+			goto fail;
+		}
+
+		if (old_session != NULL) {
+			err();
+			ret = -EOPNOTSUPP;
+			goto fail;
+		}
+
+		/* read key */
+		ret = key_item_get_nla_read(&ns->key, lists, tb[NCR_ATTR_KEY]);
+		if (ret < 0) {
+			err();
+			goto fail;
+		}
+
+		/* wrapping keys cannot be used for encryption or decryption
+		 */
+		if (ns->key->flags & NCR_KEY_FLAG_WRAPPING
+		    || ns->key->flags & NCR_KEY_FLAG_UNWRAPPING) {
+			err();
+			ret = -EINVAL;
+			goto fail;
+		}
+
+		if (ns->key->type == NCR_KEY_TYPE_SECRET) {
+			int keysize = ns->key->key.secret.size;
+
+			if (ns->algorithm->algo == NCR_ALG_NULL)
+				keysize = 0;
+
+			if (ns->algorithm->is_pk) {
 				err();
 				ret = -EINVAL;
 				goto fail;
 			}
 
-			if (old_session != NULL) {
+			ret =
+			    cryptodev_cipher_init(&ns->cipher,
+						  ns->algorithm->kstr,
+						  ns->key->key.secret.data,
+						  keysize);
+			if (ret < 0) {
 				err();
-				ret = -EOPNOTSUPP;
 				goto fail;
 			}
 
-			/* read key */
-			ret = key_item_get_nla_read(&ns->key, lists,
-						    tb[NCR_ATTR_KEY]);
+			if (ns->algorithm->needs_iv) {
+				nla = tb[NCR_ATTR_IV];
+				if (nla == NULL) {
+					err();
+					ret = -EINVAL;
+					goto fail;
+				}
+				cryptodev_cipher_set_iv(&ns->cipher,
+							nla_data(nla),
+							nla_len(nla));
+			}
+#ifdef CONFIG_ASSYMETRIC
+		} else if (ns->key->type == NCR_KEY_TYPE_PRIVATE
+			   || ns->key->type == NCR_KEY_TYPE_PUBLIC) {
+			ret =
+			    ncr_pk_cipher_init(ns->algorithm, &ns->pk, tb,
+					       ns->key, NULL);
 			if (ret < 0) {
 				err();
 				goto fail;
 			}
-			
-			/* wrapping keys cannot be used for encryption or decryption
-			 */
-			if (ns->key->flags & NCR_KEY_FLAG_WRAPPING || ns->key->flags & NCR_KEY_FLAG_UNWRAPPING) {
+#endif
+		} else {
+			err();
+			ret = -EINVAL;
+			goto fail;
+		}
+		break;
+
+	case NCR_OP_SIGN:
+	case NCR_OP_VERIFY:
+		if (!ns->algorithm->can_sign && !ns->algorithm->can_digest) {
+			err();
+			ret = -EINVAL;
+			goto fail;
+		}
+
+		if (ns->algorithm->can_digest) {
+			if (ns->algorithm->is_pk) {
 				err();
 				ret = -EINVAL;
 				goto fail;
 			}
 
-			if (ns->key->type == NCR_KEY_TYPE_SECRET) {
-				int keysize = ns->key->key.secret.size;
-				
-				if (ns->algorithm->algo == NCR_ALG_NULL)
-				  keysize = 0;
-				
-				if (ns->algorithm->is_pk) {
-					err();
-					ret = -EINVAL;
-					goto fail;
-				}
-
-				ret = cryptodev_cipher_init(&ns->cipher, ns->algorithm->kstr,
-					ns->key->key.secret.data, keysize);
-				if (ret < 0) {
-					err();
-					goto fail;
-				}
+			ret = init_or_clone_hash(ns, old_session,
+						 ns->algorithm, NULL, 0);
+			if (ret < 0) {
+				err();
+				goto fail;
+			}
 
-				if (ns->algorithm->needs_iv) {
-					nla = tb[NCR_ATTR_IV];
-					if (nla == NULL) {
-						err();
-						ret = -EINVAL;
-						goto fail;
-					}
-					cryptodev_cipher_set_iv(&ns->cipher,
-								nla_data(nla),
-								nla_len(nla));
-				}
-#ifdef CONFIG_ASSYMETRIC
-			} else if (ns->key->type == NCR_KEY_TYPE_PRIVATE || ns->key->type == NCR_KEY_TYPE_PUBLIC) {
-				ret = ncr_pk_cipher_init(ns->algorithm, &ns->pk, 
-							 tb, ns->key, NULL);
+		} else {
+			/* Get key */
+			if (old_session == NULL) {
+				ret = key_item_get_nla_read(&ns->key,
+							    lists,
+							    tb[NCR_ATTR_KEY]);
 				if (ret < 0) {
 					err();
 					goto fail;
 				}
-#endif
 			} else {
+				atomic_inc(&old_session->key->refcnt);
+				ns->key = old_session->key;
+			}
+
+			/* wrapping keys cannot be used for anything except wrapping.
+			 */
+			if (ns->key->flags & NCR_KEY_FLAG_WRAPPING
+			    || ns->key->flags & NCR_KEY_FLAG_UNWRAPPING) {
 				err();
 				ret = -EINVAL;
 				goto fail;
 			}
-			break;
 
-		case NCR_OP_SIGN:
-		case NCR_OP_VERIFY:
-			if (!ns->algorithm->can_sign && !ns->algorithm->can_digest) {
+			/* wrapping keys cannot be used for anything except wrapping.
+			 */
+			if (ns->key->flags & NCR_KEY_FLAG_WRAPPING) {
 				err();
 				ret = -EINVAL;
 				goto fail;
 			}
 
-			if (ns->algorithm->can_digest) {
+			if (ns->algorithm->is_hmac
+			    && ns->key->type == NCR_KEY_TYPE_SECRET) {
 				if (ns->algorithm->is_pk) {
 					err();
 					ret = -EINVAL;
 					goto fail;
 				}
 
-				ret = init_or_clone_hash(ns, old_session,
-							 ns->algorithm, NULL,
-							 0);
+				ret =
+				    init_or_clone_hash(ns, old_session,
+						       ns->algorithm,
+						       ns->key->key.secret.data,
+						       ns->key->key.secret.
+						       size);
 				if (ret < 0) {
 					err();
 					goto fail;
 				}
-			
-			} else {
-				/* Get key */
-				if (old_session == NULL) {
-					ret = key_item_get_nla_read(&ns->key,
-								    lists,
-								    tb[NCR_ATTR_KEY]);
-					if (ret < 0) {
-						err();
-						goto fail;
-					}
-				} else {
-					atomic_inc(&old_session->key->refcnt);
-					ns->key = old_session->key;
+#ifdef CONFIG_ASSYMETRIC
+			} else if (ns->algorithm->is_pk
+				   && (ns->key->type == NCR_KEY_TYPE_PRIVATE
+				       || ns->key->type ==
+				       NCR_KEY_TYPE_PUBLIC)) {
+				const struct algo_properties_st *sign_hash;
+
+				if (old_session != NULL) {
+					err();
+					ret = -EOPNOTSUPP;
+					goto fail;
 				}
 
-				/* wrapping keys cannot be used for anything except wrapping.
-				 */
-				if (ns->key->flags & NCR_KEY_FLAG_WRAPPING || ns->key->flags & NCR_KEY_FLAG_UNWRAPPING) {
+				nla = tb[NCR_ATTR_SIGNATURE_HASH_ALGORITHM];
+				sign_hash = _ncr_nla_to_properties(nla);
+				if (sign_hash == NULL) {
 					err();
 					ret = -EINVAL;
 					goto fail;
 				}
 
-				/* wrapping keys cannot be used for anything except wrapping.
-				 */
-				if (ns->key->flags & NCR_KEY_FLAG_WRAPPING) {
+				if (!sign_hash->can_digest) {
 					err();
 					ret = -EINVAL;
 					goto fail;
 				}
 
-				if (ns->algorithm->is_hmac && ns->key->type == NCR_KEY_TYPE_SECRET) {
-					if (ns->algorithm->is_pk) {
-						err();
-						ret = -EINVAL;
-						goto fail;
-					}
-
-					ret = init_or_clone_hash(ns, old_session, ns->algorithm,
-						ns->key->key.secret.data, ns->key->key.secret.size);
-					if (ret < 0) {
-						err();
-						goto fail;
-					}
-#ifdef CONFIG_ASSYMETRIC
-				} else if (ns->algorithm->is_pk && (ns->key->type == NCR_KEY_TYPE_PRIVATE || ns->key->type == NCR_KEY_TYPE_PUBLIC)) {
-				        const struct algo_properties_st *sign_hash;
-
-					if (old_session != NULL) {
-						err();
-						ret = -EOPNOTSUPP;
-						goto fail;
-					}
-
-					nla = tb[NCR_ATTR_SIGNATURE_HASH_ALGORITHM];
-					sign_hash = _ncr_nla_to_properties(nla);
-					if (sign_hash == NULL) {
-						err();
-						ret = -EINVAL;
-						goto fail;
-					}
+				if (sign_hash->is_pk) {
+					err();
+					ret = -EINVAL;
+					goto fail;
+				}
 
-					if (!sign_hash->can_digest) {
-						err();
-						ret = -EINVAL;
-						goto fail;
-					}
+				ret = ncr_pk_cipher_init(ns->algorithm, &ns->pk,
+							 tb, ns->key,
+							 sign_hash);
+				if (ret < 0) {
+					err();
+					goto fail;
+				}
 
-					if (sign_hash->is_pk) {
-						err();
-						ret = -EINVAL;
-						goto fail;
-					}
+				ret =
+				    cryptodev_hash_init(&ns->hash,
+							sign_hash->kstr, NULL,
+							0);
+				if (ret < 0) {
+					err();
+					goto fail;
+				}
 
-					ret = ncr_pk_cipher_init(ns->algorithm, &ns->pk, 
-						tb, ns->key, sign_hash);
-					if (ret < 0) {
+				if (ns->algorithm->has_transparent_hash) {
+					/* transparent hash has to be allowed by the key
+					 */
+					if (!
+					    (ns->key->
+					     flags &
+					     NCR_KEY_FLAG_ALLOW_TRANSPARENT_HASH))
+					{
 						err();
+						ret = -EPERM;
 						goto fail;
 					}
 
-					ret = cryptodev_hash_init(&ns->hash, sign_hash->kstr, NULL, 0);
-					if (ret < 0) {
+					ns->transparent_hash =
+					    kzalloc(ns->hash.digestsize,
+						    GFP_KERNEL);
+					if (ns->transparent_hash == NULL) {
 						err();
+						ret = -ENOMEM;
 						goto fail;
 					}
-
-					if (ns->algorithm->has_transparent_hash) {
-						/* transparent hash has to be allowed by the key
-						 */
-						if (!(ns->key->flags & NCR_KEY_FLAG_ALLOW_TRANSPARENT_HASH)) {
-							err();
-							ret = -EPERM;
-							goto fail;
-						}
-
-						ns->transparent_hash = kzalloc(ns->hash.digestsize, GFP_KERNEL);
-						if (ns->transparent_hash == NULL) {
-							err();
-							ret = -ENOMEM;
-							goto fail;
-						}
-					}
-#endif
-				} else {
-					err();
-					ret = -EINVAL;
-					goto fail;
 				}
+#endif
+			} else {
+				err();
+				ret = -EINVAL;
+				goto fail;
 			}
+		}
 
-			break;
-		default:
-			err();
-			ret = -EINVAL;
-			goto fail;
+		break;
+	default:
+		err();
+		ret = -EINVAL;
+		goto fail;
 	}
 
 	if (old_session != NULL)
 		_ncr_sessions_item_put(old_session);
-	
+
 	return ns;
 
 fail:
@@ -801,26 +828,31 @@ int ncr_session_init(struct ncr_lists *lists,
 }
 
 /* The caller is responsible for locking of the session. */
-static int _ncr_session_encrypt(struct session_item_st* sess, const struct scatterlist* input, unsigned input_cnt,
-	size_t input_size, void *output, unsigned output_cnt, size_t *output_size)
+static int _ncr_session_encrypt(struct session_item_st *sess,
+				const struct scatterlist *input,
+				unsigned input_cnt, size_t input_size,
+				void *output, unsigned output_cnt,
+				size_t * output_size)
 {
-int ret;
+	int ret;
 
 	if (sess->algorithm->is_symmetric) {
 		/* read key */
-		ret = cryptodev_cipher_encrypt(&sess->cipher, input, 
-			output, input_size);
+		ret = cryptodev_cipher_encrypt(&sess->cipher, input,
+					       output, input_size);
 		if (ret < 0) {
 			err();
 			return ret;
 		}
 		/* FIXME: handle ciphers that do not require that */
 		*output_size = input_size;
-	} else { /* public key */
+	} else {		/* public key */
 #ifdef CONFIG_ASSYMETRIC
-		ret = ncr_pk_cipher_encrypt(&sess->pk, input, input_cnt, input_size,
-			output, output_cnt, output_size);
-		
+		ret =
+		    ncr_pk_cipher_encrypt(&sess->pk, input, input_cnt,
+					  input_size, output, output_cnt,
+					  output_size);
+
 		if (ret < 0) {
 			err();
 			return ret;
@@ -830,32 +862,36 @@ int ret;
 #endif
 
 	}
-	
+
 	return 0;
 }
 
 /* The caller is responsible for locking of the session. */
-static int _ncr_session_decrypt(struct session_item_st* sess, const struct scatterlist* input, 
-	unsigned input_cnt, size_t input_size,
-	struct scatterlist *output, unsigned output_cnt, size_t *output_size)
+static int _ncr_session_decrypt(struct session_item_st *sess,
+				const struct scatterlist *input,
+				unsigned input_cnt, size_t input_size,
+				struct scatterlist *output, unsigned output_cnt,
+				size_t * output_size)
 {
-int ret;
+	int ret;
 
 	if (sess->algorithm->is_symmetric) {
 		/* read key */
-		ret = cryptodev_cipher_decrypt(&sess->cipher, input, 
-			output, input_size);
+		ret = cryptodev_cipher_decrypt(&sess->cipher, input,
+					       output, input_size);
 		if (ret < 0) {
 			err();
 			return ret;
 		}
 		/* FIXME: handle ciphers that do not require equality */
 		*output_size = input_size;
-	} else { /* public key */
+	} else {		/* public key */
 #ifdef CONFIG_ASSYMETRIC
-		ret = ncr_pk_cipher_decrypt(&sess->pk, input, input_cnt, input_size,
-			output, output_cnt, output_size);
-		
+		ret =
+		    ncr_pk_cipher_decrypt(&sess->pk, input, input_cnt,
+					  input_size, output, output_cnt,
+					  output_size);
+
 		if (ret < 0) {
 			err();
 			return ret;
@@ -865,7 +901,7 @@ int ret;
 #endif
 
 	}
-	
+
 	return 0;
 }
 
@@ -880,8 +916,7 @@ static int _ncr_session_grow_pages(struct session_item_st *ses, int pagecount)
 		return 0;
 
 	for (array_size = ses->array_size; array_size < pagecount;
-	     array_size *= 2)
-		;
+	     array_size *= 2) ;
 
 	dprintk(2, KERN_DEBUG, "%s: reallocating to %d elements\n",
 		__func__, array_size);
@@ -905,7 +940,8 @@ static int _ncr_session_grow_pages(struct session_item_st *ses, int pagecount)
    The caller is responsible for locking of the session. */
 static int get_userbuf2(struct session_item_st *ses, struct nlattr *tb[],
 			struct scatterlist **src_sg, unsigned *src_cnt,
-			size_t *src_size, struct ncr_session_output_buffer *dst,
+			size_t * src_size,
+			struct ncr_session_output_buffer *dst,
 			struct scatterlist **dst_sg, unsigned *dst_cnt,
 			int compat)
 {
@@ -986,7 +1022,7 @@ static int get_userbuf2(struct session_item_st *ses, struct nlattr *tb[],
 			*dst_sg = NULL;
 		}
 	}
-	
+
 	ses->available_pages = pagecount;
 
 	return 0;
@@ -1001,7 +1037,7 @@ static int _ncr_session_update(struct session_item_st *sess,
 	int ret;
 	struct scatterlist *isg = NULL;
 	struct scatterlist *osg = NULL;
-	unsigned osg_cnt=0, isg_cnt=0;
+	unsigned osg_cnt = 0, isg_cnt = 0;
 	size_t isg_size = 0, osg_size;
 	struct ncr_session_output_buffer out;
 
@@ -1012,111 +1048,108 @@ static int _ncr_session_update(struct session_item_st *sess,
 		return ret;
 	}
 
-	switch(sess->op) {
-		case NCR_OP_ENCRYPT:
-			if (osg == NULL) {
-				err();
-				ret = -EINVAL;
-				goto fail;
-			}
+	switch (sess->op) {
+	case NCR_OP_ENCRYPT:
+		if (osg == NULL) {
+			err();
+			ret = -EINVAL;
+			goto fail;
+		}
 
-			osg_size = out.buffer_size;
-			if (osg_size < isg_size) {
-				err();
-				ret = -EINVAL;
-				goto fail;
-			}
+		osg_size = out.buffer_size;
+		if (osg_size < isg_size) {
+			err();
+			ret = -EINVAL;
+			goto fail;
+		}
 
-			if (sess->algorithm->is_symmetric
-			    && sess->algorithm->needs_iv) {
-				nla = tb[NCR_ATTR_IV];
-				if (nla != NULL)
-					cryptodev_cipher_set_iv(&sess->cipher,
-								nla_data(nla),
-								nla_len(nla));
-			}
+		if (sess->algorithm->is_symmetric && sess->algorithm->needs_iv) {
+			nla = tb[NCR_ATTR_IV];
+			if (nla != NULL)
+				cryptodev_cipher_set_iv(&sess->cipher,
+							nla_data(nla),
+							nla_len(nla));
+		}
 
-			ret = _ncr_session_encrypt(sess, isg, isg_cnt, isg_size, 
-				osg, osg_cnt, &osg_size);
-			if (ret < 0) {
-				err();
-				goto fail;
-			}
+		ret = _ncr_session_encrypt(sess, isg, isg_cnt, isg_size,
+					   osg, osg_cnt, &osg_size);
+		if (ret < 0) {
+			err();
+			goto fail;
+		}
 
-			ret = ncr_session_output_buffer_set_size(&out, osg_size,
-								 compat);
-			if (ret != 0) {
-				err();
-				goto fail;
-			}
-			break;
-		case NCR_OP_DECRYPT:
-			if (osg == NULL) {
+		ret = ncr_session_output_buffer_set_size(&out, osg_size,
+							 compat);
+		if (ret != 0) {
+			err();
+			goto fail;
+		}
+		break;
+	case NCR_OP_DECRYPT:
+		if (osg == NULL) {
+			err();
+			ret = -EINVAL;
+			goto fail;
+		}
+
+		osg_size = out.buffer_size;
+		if (osg_size < isg_size) {
+			err();
+			ret = -EINVAL;
+			goto fail;
+		}
+
+		if (sess->algorithm->is_symmetric && sess->algorithm->needs_iv) {
+			nla = tb[NCR_ATTR_IV];
+			if (nla != NULL)
+				cryptodev_cipher_set_iv(&sess->cipher,
+							nla_data(nla),
+							nla_len(nla));
+		}
+
+		ret = _ncr_session_decrypt(sess, isg, isg_cnt, isg_size,
+					   osg, osg_cnt, &osg_size);
+		if (ret < 0) {
+			err();
+			goto fail;
+		}
+
+		ret = ncr_session_output_buffer_set_size(&out, osg_size,
+							 compat);
+		if (ret != 0) {
+			err();
+			goto fail;
+		}
+		break;
+
+	case NCR_OP_SIGN:
+	case NCR_OP_VERIFY:
+		if (sess->algorithm->has_transparent_hash) {
+			if (isg_size != sess->hash.digestsize) {
 				err();
 				ret = -EINVAL;
 				goto fail;
 			}
-
-			osg_size = out.buffer_size;
-			if (osg_size < isg_size) {
+			ret = sg_copy_to_buffer(isg, isg_cnt,
+						sess->transparent_hash,
+						isg_size);
+			if (ret != isg_size) {
 				err();
 				ret = -EINVAL;
 				goto fail;
 			}
-
-			if (sess->algorithm->is_symmetric
-			    && sess->algorithm->needs_iv) {
-				nla = tb[NCR_ATTR_IV];
-				if (nla != NULL)
-					cryptodev_cipher_set_iv(&sess->cipher,
-								nla_data(nla),
-								nla_len(nla));
-			}
-
-			ret = _ncr_session_decrypt(sess, isg, isg_cnt, isg_size, 
-				osg, osg_cnt, &osg_size);
+		} else {
+			ret = cryptodev_hash_update(&sess->hash, isg, isg_size);
 			if (ret < 0) {
 				err();
 				goto fail;
 			}
-
-			ret = ncr_session_output_buffer_set_size(&out, osg_size,
-								 compat);
-			if (ret != 0) {
-				err();
-				goto fail;
-			}
-			break;
-
-		case NCR_OP_SIGN:
-		case NCR_OP_VERIFY:
-			if (sess->algorithm->has_transparent_hash) {
-				if (isg_size != sess->hash.digestsize) {
-					err();
-					ret = -EINVAL;
-					goto fail;
-				}
-				ret = sg_copy_to_buffer(isg, isg_cnt,
-							sess->transparent_hash,
-							isg_size);
-				if (ret != isg_size) {
-					err();
-					ret = -EINVAL;
-					goto fail;
-				}
-			} else {
-				ret = cryptodev_hash_update(&sess->hash, isg,
-							    isg_size);
-				if (ret < 0) {
-					err();
-					goto fail;
-				}
-			}
-			break;
-		default:
-			err();
-			ret = -EINVAL;
-			goto fail;
+		}
+		break;
+	default:
+		err();
+		ret = -EINVAL;
+		goto fail;
 	}
 
 	ret = 0;
@@ -1162,146 +1195,157 @@ static int _ncr_session_final(struct ncr_lists *lists,
 		return ret;
 	}
 
-	switch(sess->op) {
+	switch (sess->op) {
 	case NCR_OP_ENCRYPT:
 	case NCR_OP_DECRYPT:
 		break;
-	case NCR_OP_VERIFY: {
-		struct ncr_session_input_data src;
+	case NCR_OP_VERIFY:{
+			struct ncr_session_input_data src;
 
-		nla = tb[NCR_ATTR_FINAL_INPUT_DATA];
-		ret = ncr_session_input_data_from_nla(&src, nla, compat);
-		if (unlikely(ret != 0)) {
-			err();
-			goto fail;
-		}
-
-		buffer = kmalloc(src.data_size, GFP_KERNEL);
-		if (buffer == NULL) {
-			err();
-			ret = -ENOMEM;
-			goto fail;
-		}
-		if (unlikely(copy_from_user(buffer, src.data, src.data_size))) {
-			err();
-			ret = -EFAULT;
-			goto fail;
-		}
-
-		digest_size = sess->hash.digestsize;
-		if (digest_size == 0 || sizeof(digest) < digest_size) {
-			err();
-			ret = -EINVAL;
-			goto fail;
-		}
-		if (sess->algorithm->has_transparent_hash)
-			memcpy(digest, sess->transparent_hash, digest_size);
-		else {
-			ret = cryptodev_hash_final(&sess->hash, digest);
-			if (ret < 0) {
+			nla = tb[NCR_ATTR_FINAL_INPUT_DATA];
+			ret =
+			    ncr_session_input_data_from_nla(&src, nla, compat);
+			if (unlikely(ret != 0)) {
 				err();
 				goto fail;
 			}
-		}
 
-		if (!sess->algorithm->is_pk)
-			ret = (digest_size == src.data_size
-			       && memcmp(buffer, digest, digest_size) == 0);
-		else {
-#ifdef CONFIG_ASSYMETRIC
-			ret = ncr_pk_cipher_verify(&sess->pk, buffer,
-						   src.data_size, digest,
-						   digest_size);
-			if (ret < 0) {
+			buffer = kmalloc(src.data_size, GFP_KERNEL);
+			if (buffer == NULL) {
 				err();
+				ret = -ENOMEM;
 				goto fail;
 			}
-#else
-			ret = -EOPNOTSUPP;
-			goto fail;
-#endif
-		}
-		break;
-	}
-
-	case NCR_OP_SIGN: {
-		struct ncr_session_output_buffer dst;
-		size_t output_size;
-
-		nla = tb[NCR_ATTR_FINAL_OUTPUT_BUFFER];
-		ret = ncr_session_output_buffer_from_nla(&dst, nla, compat);
-		if (unlikely(ret != 0)) {
-			err();
-			goto fail;
-		}
-
-		digest_size = sess->hash.digestsize;
-		if (digest_size == 0) {
-			err();
-			ret = -EINVAL;
-			goto fail;
-		}
-
-		if (sess->algorithm->has_transparent_hash)
-			memcpy(digest, sess->transparent_hash, digest_size);
-		else {
-			ret = cryptodev_hash_final(&sess->hash, digest);
-			if (ret < 0) {
+			if (unlikely
+			    (copy_from_user(buffer, src.data, src.data_size))) {
 				err();
+				ret = -EFAULT;
 				goto fail;
 			}
-		}
-
-		cryptodev_hash_deinit(&sess->hash);
 
-		if (!sess->algorithm->is_pk) {
-			if (dst.buffer_size < digest_size) {
+			digest_size = sess->hash.digestsize;
+			if (digest_size == 0 || sizeof(digest) < digest_size) {
 				err();
-				ret = -ERANGE;
+				ret = -EINVAL;
 				goto fail;
 			}
-			if (unlikely(copy_to_user(dst.buffer, digest,
-						  digest_size))) {
-				err();
-				ret = -EFAULT;
-				goto fail;
+			if (sess->algorithm->has_transparent_hash)
+				memcpy(digest, sess->transparent_hash,
+				       digest_size);
+			else {
+				ret = cryptodev_hash_final(&sess->hash, digest);
+				if (ret < 0) {
+					err();
+					goto fail;
+				}
 			}
-			output_size = digest_size;
-		} else {
+
+			if (!sess->algorithm->is_pk)
+				ret = (digest_size == src.data_size
+				       && memcmp(buffer, digest,
+						 digest_size) == 0);
+			else {
 #ifdef CONFIG_ASSYMETRIC
-			output_size = dst.buffer_size;
-			buffer = kmalloc(output_size, GFP_KERNEL);
-			if (buffer == NULL) {
-				err();
-				ret = -ENOMEM;
+				ret = ncr_pk_cipher_verify(&sess->pk, buffer,
+							   src.data_size,
+							   digest, digest_size);
+				if (ret < 0) {
+					err();
+					goto fail;
+				}
+#else
+				ret = -EOPNOTSUPP;
 				goto fail;
+#endif
 			}
-			ret = ncr_pk_cipher_sign(&sess->pk, digest, digest_size,
-						 buffer, &output_size);
-			if (ret < 0) {
+			break;
+		}
+
+	case NCR_OP_SIGN:{
+			struct ncr_session_output_buffer dst;
+			size_t output_size;
+
+			nla = tb[NCR_ATTR_FINAL_OUTPUT_BUFFER];
+			ret =
+			    ncr_session_output_buffer_from_nla(&dst, nla,
+							       compat);
+			if (unlikely(ret != 0)) {
 				err();
 				goto fail;
 			}
-			if (unlikely(copy_to_user(dst.buffer, buffer,
-						  output_size))) {
+
+			digest_size = sess->hash.digestsize;
+			if (digest_size == 0) {
 				err();
-				ret = -EFAULT;
+				ret = -EINVAL;
 				goto fail;
 			}
+
+			if (sess->algorithm->has_transparent_hash)
+				memcpy(digest, sess->transparent_hash,
+				       digest_size);
+			else {
+				ret = cryptodev_hash_final(&sess->hash, digest);
+				if (ret < 0) {
+					err();
+					goto fail;
+				}
+			}
+
+			cryptodev_hash_deinit(&sess->hash);
+
+			if (!sess->algorithm->is_pk) {
+				if (dst.buffer_size < digest_size) {
+					err();
+					ret = -ERANGE;
+					goto fail;
+				}
+				if (unlikely(copy_to_user(dst.buffer, digest,
+							  digest_size))) {
+					err();
+					ret = -EFAULT;
+					goto fail;
+				}
+				output_size = digest_size;
+			} else {
+#ifdef CONFIG_ASSYMETRIC
+				output_size = dst.buffer_size;
+				buffer = kmalloc(output_size, GFP_KERNEL);
+				if (buffer == NULL) {
+					err();
+					ret = -ENOMEM;
+					goto fail;
+				}
+				ret =
+				    ncr_pk_cipher_sign(&sess->pk, digest,
+						       digest_size, buffer,
+						       &output_size);
+				if (ret < 0) {
+					err();
+					goto fail;
+				}
+				if (unlikely(copy_to_user(dst.buffer, buffer,
+							  output_size))) {
+					err();
+					ret = -EFAULT;
+					goto fail;
+				}
 #else
-			ret = -EOPNOTSUPP;
-			goto fail;
+				ret = -EOPNOTSUPP;
+				goto fail;
 #endif
-		}
+			}
 
-		ret = ncr_session_output_buffer_set_size(&dst, output_size,
-							 compat);
-		if (ret != 0) {
-			err();
-			goto fail;
+			ret =
+			    ncr_session_output_buffer_set_size(&dst,
+							       output_size,
+							       compat);
+			if (ret != 0) {
+				err();
+				goto fail;
+			}
+			break;
 		}
-		break;
-	}
 	default:
 		err();
 		ret = -EINVAL;
@@ -1317,11 +1361,11 @@ fail:
 /* Direct with key: Allows to hash a key.
    The caller is responsible for locking of the session. */
 static int _ncr_session_update_key(struct ncr_lists *lists,
-				   struct session_item_st* sess,
+				   struct session_item_st *sess,
 				   struct nlattr *tb[])
 {
 	int ret;
-	struct key_item_st* key = NULL;
+	struct key_item_st *key = NULL;
 
 	/* read key */
 	ret = key_item_get_nla_read(&key, lists,
@@ -1330,43 +1374,44 @@ static int _ncr_session_update_key(struct ncr_lists *lists,
 		err();
 		return ret;
 	}
-	
+
 	if (key->type != NCR_KEY_TYPE_SECRET) {
 		err();
 		ret = -EINVAL;
 		goto fail;
 	}
-	
+
 	if (!(key->flags & NCR_KEY_FLAG_HASHABLE)) {
 		err();
 		ret = -EPERM;
 		goto fail;
 	}
 
-	switch(sess->op) {
-		case NCR_OP_ENCRYPT:
-		case NCR_OP_DECRYPT:
+	switch (sess->op) {
+	case NCR_OP_ENCRYPT:
+	case NCR_OP_DECRYPT:
+		err();
+		ret = -EINVAL;
+		goto fail;
+	case NCR_OP_SIGN:
+	case NCR_OP_VERIFY:
+		if (sess->algorithm->has_transparent_hash) {
 			err();
 			ret = -EINVAL;
 			goto fail;
-		case NCR_OP_SIGN:
-		case NCR_OP_VERIFY:
-			if (sess->algorithm->has_transparent_hash) {
-				err();
-				ret = -EINVAL;
-				goto fail;
-			}
-			ret = _cryptodev_hash_update(&sess->hash, 
-				key->key.secret.data, key->key.secret.size);
-			if (ret < 0) {
-				err();
-				goto fail;
-			}
-			break;
-		default:
+		}
+		ret = _cryptodev_hash_update(&sess->hash,
+					     key->key.secret.data,
+					     key->key.secret.size);
+		if (ret < 0) {
 			err();
-			ret = -EINVAL;
 			goto fail;
+		}
+		break;
+	default:
+		err();
+		ret = -EINVAL;
+		goto fail;
 	}
 
 	ret = 0;
diff --git a/ncr.c b/ncr.c
index 55b40ef..6e7154c 100644
--- a/ncr.c
+++ b/ncr.c
@@ -30,7 +30,7 @@
 #include <linux/random.h>
 #include <linux/uaccess.h>
 #include <linux/scatterlist.h>
-#include <linux/cred.h>  
+#include <linux/cred.h>
 #include <linux/capability.h>
 #include <net/netlink.h>
 #include "ncr.h"
@@ -42,12 +42,12 @@
  */
 struct key_item_st master_key;
 
-void* ncr_init_lists(void)
+void *ncr_init_lists(void)
 {
 	struct ncr_lists *lst;
 
 	lst = kmalloc(sizeof(*lst), GFP_KERNEL);
-	if(!lst) {
+	if (!lst) {
 		err();
 		return NULL;
 	}
@@ -65,7 +65,7 @@ void* ncr_init_lists(void)
 
 void ncr_deinit_lists(struct ncr_lists *lst)
 {
-	if(lst) {
+	if (lst) {
 		ncr_key_list_deinit(lst);
 		ncr_sessions_list_deinit(lst);
 		kfree(lst);
@@ -91,12 +91,14 @@ static int ncr_master_key_set(const struct ncr_master_key_set *st,
 	}
 
 	if (st->key_size != 16 && st->key_size != 24 && st->key_size != 32) {
-		dprintk(0, KERN_DEBUG, "Master key size must be 16,24 or 32.\n");
+		dprintk(0, KERN_DEBUG,
+			"Master key size must be 16,24 or 32.\n");
 		return -EINVAL;
 	}
 
 	if (master_key.type != NCR_KEY_TYPE_INVALID) {
-		dprintk(0, KERN_DEBUG, "Master key was previously initialized.\n");
+		dprintk(0, KERN_DEBUG,
+			"Master key was previously initialized.\n");
 	}
 
 	if (unlikely(copy_from_user(master_key.key.secret.data, st->key,
@@ -113,8 +115,7 @@ static int ncr_master_key_set(const struct ncr_master_key_set *st,
 	return 0;
 }
 
-long
-ncr_ioctl(struct ncr_lists *lst, unsigned int cmd, unsigned long arg_)
+long ncr_ioctl(struct ncr_lists *lst, unsigned int cmd, unsigned long arg_)
 {
 	void __user *arg = (void __user *)arg_;
 	struct nlattr *tb[NCR_ATTR_MAX + 1];
@@ -144,55 +145,61 @@ ncr_ioctl(struct ncr_lists *lst, unsigned int cmd, unsigned long arg_)
 
 	case NCRIO_KEY_INIT:
 		return ncr_key_init(lst);
-	CASE_NO_OUTPUT(NCRIO_KEY_GENERATE, ncr_key_generate, ncr_key_generate);
-	CASE_NO_OUTPUT(NCRIO_KEY_GENERATE_PAIR, ncr_key_generate_pair,
-		       ncr_key_generate_pair);
-	CASE_NO_OUTPUT(NCRIO_KEY_DERIVE, ncr_key_derive, ncr_key_derive);
-	case NCRIO_KEY_GET_INFO: {
-		struct ncr_key_get_info data;
-		struct ncr_out out;
-
-		attr_buf = NCR_GET_INPUT_ARGS(&data, tb, arg);
-		if (IS_ERR(attr_buf)) {
-			err();
-			return PTR_ERR(attr_buf);
-		}
-		ret = NCR_OUT_INIT(&out, &data, arg);
-		if (ret != 0) {
-			err();
+		CASE_NO_OUTPUT(NCRIO_KEY_GENERATE, ncr_key_generate,
+			       ncr_key_generate);
+		CASE_NO_OUTPUT(NCRIO_KEY_GENERATE_PAIR, ncr_key_generate_pair,
+			       ncr_key_generate_pair);
+		CASE_NO_OUTPUT(NCRIO_KEY_DERIVE, ncr_key_derive,
+			       ncr_key_derive);
+	case NCRIO_KEY_GET_INFO:{
+			struct ncr_key_get_info data;
+			struct ncr_out out;
+
+			attr_buf = NCR_GET_INPUT_ARGS(&data, tb, arg);
+			if (IS_ERR(attr_buf)) {
+				err();
+				return PTR_ERR(attr_buf);
+			}
+			ret = NCR_OUT_INIT(&out, &data, arg);
+			if (ret != 0) {
+				err();
+				break;
+			}
+			ret = ncr_key_get_info(lst, &out, &data, tb);
+			ncr_out_free(&out);
 			break;
 		}
-		ret = ncr_key_get_info(lst, &out, &data, tb);
-		ncr_out_free(&out);
-		break;
-	}
-	CASE_NO_OUTPUT(NCRIO_KEY_EXPORT, ncr_key_export, ncr_key_export);
-	CASE_NO_OUTPUT(NCRIO_KEY_IMPORT, ncr_key_import, ncr_key_import);
-	case NCRIO_KEY_DEINIT: {
-		ncr_key_t key;
-
-		ret = get_user(key, (const ncr_key_t __user *)arg);
-		if (unlikely(ret)) {
-			err();
-			return ret;
+		CASE_NO_OUTPUT(NCRIO_KEY_EXPORT, ncr_key_export,
+			       ncr_key_export);
+		CASE_NO_OUTPUT(NCRIO_KEY_IMPORT, ncr_key_import,
+			       ncr_key_import);
+	case NCRIO_KEY_DEINIT:{
+			ncr_key_t key;
+
+			ret = get_user(key, (const ncr_key_t __user *)arg);
+			if (unlikely(ret)) {
+				err();
+				return ret;
+			}
+			return ncr_key_deinit(lst, key);
 		}
-		return ncr_key_deinit(lst, key);
-	}
-	CASE_NO_OUTPUT(NCRIO_KEY_WRAP, ncr_key_wrap, ncr_key_wrap);
-	CASE_NO_OUTPUT(NCRIO_KEY_UNWRAP, ncr_key_unwrap, ncr_key_unwrap);
-	CASE_NO_OUTPUT(NCRIO_KEY_STORAGE_WRAP, ncr_key_storage_wrap,
-		       ncr_key_storage_wrap);
-	CASE_NO_OUTPUT(NCRIO_KEY_STORAGE_UNWRAP, ncr_key_storage_unwrap,
-		       ncr_key_storage_unwrap);
-	CASE_NO_OUTPUT(NCRIO_SESSION_INIT, ncr_session_init, ncr_session_init);
-	CASE_NO_OUTPUT_COMPAT(NCRIO_SESSION_UPDATE, ncr_session_update,
-			      ncr_session_update);
-	CASE_NO_OUTPUT_COMPAT(NCRIO_SESSION_FINAL, ncr_session_final,
-			      ncr_session_final);
-	CASE_NO_OUTPUT_COMPAT(NCRIO_SESSION_ONCE, ncr_session_once,
-			      ncr_session_once);
-	CASE_(NCRIO_MASTER_KEY_SET, ncr_master_key_set, ncr_master_key_set,
-	      (&data, tb));
+		CASE_NO_OUTPUT(NCRIO_KEY_WRAP, ncr_key_wrap, ncr_key_wrap);
+		CASE_NO_OUTPUT(NCRIO_KEY_UNWRAP, ncr_key_unwrap,
+			       ncr_key_unwrap);
+		CASE_NO_OUTPUT(NCRIO_KEY_STORAGE_WRAP, ncr_key_storage_wrap,
+			       ncr_key_storage_wrap);
+		CASE_NO_OUTPUT(NCRIO_KEY_STORAGE_UNWRAP, ncr_key_storage_unwrap,
+			       ncr_key_storage_unwrap);
+		CASE_NO_OUTPUT(NCRIO_SESSION_INIT, ncr_session_init,
+			       ncr_session_init);
+		CASE_NO_OUTPUT_COMPAT(NCRIO_SESSION_UPDATE, ncr_session_update,
+				      ncr_session_update);
+		CASE_NO_OUTPUT_COMPAT(NCRIO_SESSION_FINAL, ncr_session_final,
+				      ncr_session_final);
+		CASE_NO_OUTPUT_COMPAT(NCRIO_SESSION_ONCE, ncr_session_once,
+				      ncr_session_once);
+		CASE_(NCRIO_MASTER_KEY_SET, ncr_master_key_set,
+		      ncr_master_key_set, (&data, tb));
 	default:
 		return -EINVAL;
 #undef CASE_
@@ -209,7 +216,7 @@ struct compat_ncr_key_export {
 	ncr_key_t key;
 	compat_uptr_t buffer;
 	compat_int_t buffer_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 #define COMPAT_NCRIO_KEY_EXPORT _IOWR('c', 209, struct compat_ncr_key_export)
 
@@ -226,7 +233,7 @@ struct compat_ncr_key_import {
 	ncr_key_t key;
 	compat_uptr_t data;
 	__u32 data_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 #define COMPAT_NCRIO_KEY_IMPORT _IOWR('c', 210, struct compat_ncr_key_import)
 
@@ -244,7 +251,7 @@ struct compat_ncr_key_wrap {
 	ncr_key_t source_key;
 	compat_uptr_t buffer;
 	compat_int_t buffer_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 #define COMPAT_NCRIO_KEY_WRAP _IOWR('c', 250, struct compat_ncr_key_wrap)
 
@@ -263,7 +270,7 @@ struct compat_ncr_key_unwrap {
 	ncr_key_t dest_key;
 	compat_uptr_t data;
 	__u32 data_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 #define COMPAT_NCRIO_KEY_UNWRAP _IOWR('c', 251, struct compat_ncr_key_unwrap)
 
@@ -281,13 +288,14 @@ struct compat_ncr_key_storage_wrap {
 	ncr_key_t key;
 	compat_uptr_t buffer;
 	compat_int_t buffer_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 #define COMPAT_NCRIO_KEY_STORAGE_WRAP				\
 	_IOWR('c', 261, struct compat_ncr_key_storage_wrap)
 
 static void convert_ncr_key_storage_wrap(struct ncr_key_storage_wrap *new,
-					 const struct compat_ncr_key_storage_wrap *old)
+					 const struct
+					 compat_ncr_key_storage_wrap *old)
 {
 	new->key = old->key;
 	new->buffer = compat_ptr(old->buffer);
@@ -299,13 +307,14 @@ struct compat_ncr_key_storage_unwrap {
 	ncr_key_t key;
 	compat_uptr_t data;
 	__u32 data_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 #define COMPAT_NCRIO_KEY_STORAGE_UNWRAP				\
 	_IOWR('c', 262, struct compat_ncr_key_storage_wrap)
 
 static void convert_ncr_key_storage_unwrap(struct ncr_key_storage_unwrap *new,
-					   const struct compat_ncr_key_storage_unwrap *old)
+					   const struct
+					   compat_ncr_key_storage_unwrap *old)
 {
 	new->key = old->key;
 	new->data = compat_ptr(old->data);
@@ -316,13 +325,14 @@ struct compat_ncr_master_key_set {
 	__u32 input_size, output_size;
 	compat_uptr_t key;
 	__u32 key_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 #define COMPAT_NCRIO_MASTER_KEY_SET				\
 	_IOWR('c', 260, struct compat_ncr_master_key_set)
 
 static void convert_ncr_master_key_set(struct ncr_master_key_set *new,
-				       const struct compat_ncr_master_key_set *old)
+				       const struct compat_ncr_master_key_set
+				       *old)
 {
 	new->key = compat_ptr(old->key);
 	new->key_size = old->key_size;
@@ -379,22 +389,26 @@ ncr_compat_ioctl(struct ncr_lists *lst, unsigned int cmd, unsigned long arg_)
 		break;							\
 	}
 
-	CASE_NO_OUTPUT(COMPAT_NCRIO_KEY_EXPORT, ncr_key_export, ncr_key_export);
-	CASE_NO_OUTPUT(COMPAT_NCRIO_KEY_IMPORT, ncr_key_import, ncr_key_import);
-	CASE_NO_OUTPUT(COMPAT_NCRIO_KEY_WRAP, ncr_key_wrap, ncr_key_wrap);
-	CASE_NO_OUTPUT(COMPAT_NCRIO_KEY_UNWRAP, ncr_key_unwrap, ncr_key_unwrap);
-	CASE_NO_OUTPUT(COMPAT_NCRIO_KEY_STORAGE_WRAP, ncr_key_storage_wrap,
-		       ncr_key_storage_wrap);
-	CASE_NO_OUTPUT(COMPAT_NCRIO_KEY_STORAGE_UNWRAP, ncr_key_storage_unwrap,
-		       ncr_key_storage_unwrap);
-	CASE_COMPAT_ONLY(NCRIO_SESSION_UPDATE, ncr_session_update,
-			 ncr_session_update);
-	CASE_COMPAT_ONLY(NCRIO_SESSION_FINAL, ncr_session_final,
-			 ncr_session_final);
-	CASE_COMPAT_ONLY(NCRIO_SESSION_ONCE, ncr_session_once,
-			 ncr_session_once);
-	CASE_(COMPAT_NCRIO_MASTER_KEY_SET, ncr_master_key_set,
-	      ncr_master_key_set, (&new, tb));
+		CASE_NO_OUTPUT(COMPAT_NCRIO_KEY_EXPORT, ncr_key_export,
+			       ncr_key_export);
+		CASE_NO_OUTPUT(COMPAT_NCRIO_KEY_IMPORT, ncr_key_import,
+			       ncr_key_import);
+		CASE_NO_OUTPUT(COMPAT_NCRIO_KEY_WRAP, ncr_key_wrap,
+			       ncr_key_wrap);
+		CASE_NO_OUTPUT(COMPAT_NCRIO_KEY_UNWRAP, ncr_key_unwrap,
+			       ncr_key_unwrap);
+		CASE_NO_OUTPUT(COMPAT_NCRIO_KEY_STORAGE_WRAP,
+			       ncr_key_storage_wrap, ncr_key_storage_wrap);
+		CASE_NO_OUTPUT(COMPAT_NCRIO_KEY_STORAGE_UNWRAP,
+			       ncr_key_storage_unwrap, ncr_key_storage_unwrap);
+		CASE_COMPAT_ONLY(NCRIO_SESSION_UPDATE, ncr_session_update,
+				 ncr_session_update);
+		CASE_COMPAT_ONLY(NCRIO_SESSION_FINAL, ncr_session_final,
+				 ncr_session_final);
+		CASE_COMPAT_ONLY(NCRIO_SESSION_ONCE, ncr_session_once,
+				 ncr_session_once);
+		CASE_(COMPAT_NCRIO_MASTER_KEY_SET, ncr_master_key_set,
+		      ncr_master_key_set, (&new, tb));
 	default:
 		return -EINVAL;
 #undef CASE_
@@ -415,7 +429,7 @@ int ncr_session_input_data_from_nla(struct ncr_session_input_data *dest,
 	if (!compat) {
 #endif
 		if (unlikely(nla_len(nla) < sizeof(dest)))
-			return -ERANGE; /* nla_validate would return -ERANGE. */
+			return -ERANGE;	/* nla_validate would return -ERANGE. */
 		memcpy(dest, nla_data(nla), sizeof(*dest));
 #ifdef CONFIG_COMPAT
 	} else {
@@ -440,7 +454,7 @@ int ncr_session_output_buffer_from_nla(struct ncr_session_output_buffer *dest,
 	if (!compat) {
 #endif
 		if (unlikely(nla_len(nla) < sizeof(dest)))
-			return -ERANGE; /* nla_validate would return -ERANGE. */
+			return -ERANGE;	/* nla_validate would return -ERANGE. */
 		memcpy(dest, nla_data(nla), sizeof(*dest));
 #ifdef CONFIG_COMPAT
 	} else {
@@ -457,9 +471,8 @@ int ncr_session_output_buffer_from_nla(struct ncr_session_output_buffer *dest,
 	return 0;
 }
 
-
-int ncr_session_output_buffer_set_size(const struct ncr_session_output_buffer *dest,
-				       size_t size, int compat)
+int ncr_session_output_buffer_set_size(const struct ncr_session_output_buffer
+				       *dest, size_t size, int compat)
 {
 #ifdef CONFIG_COMPAT
 	if (!compat)
@@ -471,7 +484,7 @@ int ncr_session_output_buffer_set_size(const struct ncr_session_output_buffer *d
 
 		old = size;
 		return put_user(old,
-				(compat_size_t __user *)dest->result_size_ptr);
+				(compat_size_t __user *) dest->result_size_ptr);
 	}
 #endif
 }
diff --git a/ncr.h b/ncr.h
index e4500b9..a144c03 100644
--- a/ncr.h
+++ b/ncr.h
@@ -29,36 +29,36 @@
 /* FIXME: Split key generation/derivation attributes to decrease the number
    of attributes used for the frequent operations? */
 enum {
-	NCR_ATTR_UNSPEC,	      /* 0 is special in lib/nlattr.c. */
-	NCR_ATTR_ALGORITHM,	      /* NLA_NUL_STRING */
-	NCR_ATTR_DERIVATION_ALGORITHM, /* NLA_NUL_STRING - NCR_DERIVE_* */
-	NCR_ATTR_SIGNATURE_HASH_ALGORITHM, /* NLA_NUL_STRING */
-	NCR_ATTR_WRAPPING_ALGORITHM,  /* NLA_NUL_STRING - NCR_WALG_* */
-	NCR_ATTR_UPDATE_INPUT_DATA,   /* NLA_BINARY - ncr_session_input_data */
+	NCR_ATTR_UNSPEC,	/* 0 is special in lib/nlattr.c. */
+	NCR_ATTR_ALGORITHM,	/* NLA_NUL_STRING */
+	NCR_ATTR_DERIVATION_ALGORITHM,	/* NLA_NUL_STRING - NCR_DERIVE_* */
+	NCR_ATTR_SIGNATURE_HASH_ALGORITHM,	/* NLA_NUL_STRING */
+	NCR_ATTR_WRAPPING_ALGORITHM,	/* NLA_NUL_STRING - NCR_WALG_* */
+	NCR_ATTR_UPDATE_INPUT_DATA,	/* NLA_BINARY - ncr_session_input_data */
 	/* NLA_BINARY - ncr_session_output_buffer */
 	NCR_ATTR_UPDATE_OUTPUT_BUFFER,
-	NCR_ATTR_UPDATE_INPUT_KEY_AS_DATA, /* NLA_U32 - ncr_key_t */
-	NCR_ATTR_FINAL_INPUT_DATA,    /* NLA_BINARY - ncr_session_input_data */
+	NCR_ATTR_UPDATE_INPUT_KEY_AS_DATA,	/* NLA_U32 - ncr_key_t */
+	NCR_ATTR_FINAL_INPUT_DATA,	/* NLA_BINARY - ncr_session_input_data */
 	/* NLA_BINARY - ncr_session_output_buffer */
 	NCR_ATTR_FINAL_OUTPUT_BUFFER,
-	NCR_ATTR_KEY,	              /* NLA_U32 - ncr_key_t */
-	NCR_ATTR_KEY_FLAGS,	      /* NLA_U32 - NCR_KEY_FLAG_* */
-	NCR_ATTR_KEY_ID,	      /* NLA_BINARY */
-	NCR_ATTR_KEY_TYPE,	      /* NLA_U32 - ncr_key_type_t */
-	NCR_ATTR_IV,		      /* NLA_BINARY */
-	NCR_ATTR_SECRET_KEY_BITS,     /* NLA_U32 */
-	NCR_ATTR_RSA_MODULUS_BITS,    /* NLA_U32 */
-	NCR_ATTR_RSA_E,		      /* NLA_BINARY */
-	NCR_ATTR_RSA_ENCODING_METHOD, /* NLA_U32 - ncr_rsa_type_t */
-	NCR_ATTR_RSA_OAEP_HASH_ALGORITHM, /* NLA_NUL_STRING */
-	NCR_ATTR_RSA_PSS_SALT_LENGTH, /* NLA_U32 */
-	NCR_ATTR_DSA_P_BITS,	      /* NLA_U32 */
-	NCR_ATTR_DSA_Q_BITS,	      /* NLA_U32 */
-	NCR_ATTR_DH_PRIME,	      /* NLA_BINARY */
-	NCR_ATTR_DH_BASE,	      /* NLA_BINARY */
-	NCR_ATTR_DH_PUBLIC,	      /* NLA_BINARY */
-	NCR_ATTR_WANTED_ATTRS,	      /* NLA_BINARY - array of u16 IDs */
-	NCR_ATTR_SESSION_CLONE_FROM,  /* NLA_U32 - ncr_session_t */
+	NCR_ATTR_KEY,		/* NLA_U32 - ncr_key_t */
+	NCR_ATTR_KEY_FLAGS,	/* NLA_U32 - NCR_KEY_FLAG_* */
+	NCR_ATTR_KEY_ID,	/* NLA_BINARY */
+	NCR_ATTR_KEY_TYPE,	/* NLA_U32 - ncr_key_type_t */
+	NCR_ATTR_IV,		/* NLA_BINARY */
+	NCR_ATTR_SECRET_KEY_BITS,	/* NLA_U32 */
+	NCR_ATTR_RSA_MODULUS_BITS,	/* NLA_U32 */
+	NCR_ATTR_RSA_E,		/* NLA_BINARY */
+	NCR_ATTR_RSA_ENCODING_METHOD,	/* NLA_U32 - ncr_rsa_type_t */
+	NCR_ATTR_RSA_OAEP_HASH_ALGORITHM,	/* NLA_NUL_STRING */
+	NCR_ATTR_RSA_PSS_SALT_LENGTH,	/* NLA_U32 */
+	NCR_ATTR_DSA_P_BITS,	/* NLA_U32 */
+	NCR_ATTR_DSA_Q_BITS,	/* NLA_U32 */
+	NCR_ATTR_DH_PRIME,	/* NLA_BINARY */
+	NCR_ATTR_DH_BASE,	/* NLA_BINARY */
+	NCR_ATTR_DH_PUBLIC,	/* NLA_BINARY */
+	NCR_ATTR_WANTED_ATTRS,	/* NLA_BINARY - array of u16 IDs */
+	NCR_ATTR_SESSION_CLONE_FROM,	/* NLA_U32 - ncr_session_t */
 
 	/* Add new attributes here */
 
@@ -73,14 +73,14 @@ enum {
 #define NCR_ALG_DSA_TRANSPARENT_HASH "__dsa_transparent_hash"
 #define NCR_ALG_RSA_TRANSPARENT_HASH "__rsa_transparent_hash"
 
-#define NCR_WALG_AES_RFC3394 "walg-aes-rfc3394" /* for secret keys only */
-#define NCR_WALG_AES_RFC5649 "walg-aes-rfc5649" /* can wrap arbitrary key */
+#define NCR_WALG_AES_RFC3394 "walg-aes-rfc3394"	/* for secret keys only */
+#define NCR_WALG_AES_RFC5649 "walg-aes-rfc5649"	/* can wrap arbitrary key */
 
 typedef enum {
 	NCR_KEY_TYPE_INVALID,
-	NCR_KEY_TYPE_SECRET=1,
-	NCR_KEY_TYPE_PUBLIC=2,
-	NCR_KEY_TYPE_PRIVATE=3,
+	NCR_KEY_TYPE_SECRET = 1,
+	NCR_KEY_TYPE_PUBLIC = 2,
+	NCR_KEY_TYPE_PRIVATE = 3,
 } ncr_key_type_t;
 
 /* Key handling
@@ -112,30 +112,29 @@ typedef __s32 ncr_key_t;
 struct ncr_key_generate {
 	__u32 input_size, output_size;
 	ncr_key_t key;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 struct ncr_key_generate_pair {
 	__u32 input_size, output_size;
 	ncr_key_t private_key;
 	ncr_key_t public_key;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 typedef enum {
-	RSA_PKCS1_V1_5, /* both signatures and encryption */
-	RSA_PKCS1_OAEP, /* for encryption only */
-	RSA_PKCS1_PSS, /* for signatures only */
+	RSA_PKCS1_V1_5,		/* both signatures and encryption */
+	RSA_PKCS1_OAEP,		/* for encryption only */
+	RSA_PKCS1_PSS,		/* for signatures only */
 } ncr_rsa_type_t;
 
 #define NCR_DERIVE_DH "dh"
 
-
 struct ncr_key_derive {
 	__u32 input_size, output_size;
 	ncr_key_t input_key;
 	ncr_key_t new_key;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 #define MAX_KEY_ID_SIZE 20
@@ -143,7 +142,7 @@ struct ncr_key_derive {
 struct ncr_key_get_info {
 	__u32 input_size, output_size;
 	ncr_key_t key;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 struct ncr_key_import {
@@ -151,7 +150,7 @@ struct ncr_key_import {
 	ncr_key_t key;
 	const void __user *data;
 	__u32 data_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 struct ncr_key_export {
@@ -159,7 +158,7 @@ struct ncr_key_export {
 	ncr_key_t key;
 	void __user *buffer;
 	int buffer_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 #define NCRIO_KEY_INIT _IO('c', 0xC0)
@@ -186,7 +185,7 @@ struct ncr_key_wrap {
 	ncr_key_t source_key;
 	void __user *buffer;
 	int buffer_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 struct ncr_key_unwrap {
@@ -195,7 +194,7 @@ struct ncr_key_unwrap {
 	ncr_key_t dest_key;
 	const void __user *data;
 	__u32 data_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 #define NCRIO_KEY_WRAP _IOWR('c', 0xC8, struct ncr_key_wrap)
@@ -206,7 +205,7 @@ struct ncr_master_key_set {
 	__u32 input_size, output_size;
 	const void __user *key;
 	__u32 key_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 #define NCRIO_MASTER_KEY_SET _IOWR('c', 0xCA, struct ncr_master_key_set)
@@ -218,7 +217,7 @@ struct ncr_key_storage_wrap {
 	ncr_key_t key;
 	void __user *buffer;
 	int buffer_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 struct ncr_key_storage_unwrap {
@@ -226,7 +225,7 @@ struct ncr_key_storage_unwrap {
 	ncr_key_t key;
 	const void __user *data;
 	__u32 data_size;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 #define NCRIO_KEY_STORAGE_WRAP _IOWR('c', 0xCB, struct ncr_key_storage_wrap)
@@ -236,7 +235,7 @@ struct ncr_key_storage_unwrap {
  */
 
 typedef enum {
-	NCR_OP_ENCRYPT=1,
+	NCR_OP_ENCRYPT = 1,
 	NCR_OP_DECRYPT,
 	NCR_OP_SIGN,
 	NCR_OP_VERIFY,
@@ -259,25 +258,25 @@ struct ncr_session_output_buffer {
 struct ncr_session_init {
 	__u32 input_size, output_size;
 	__u32 op;		/* ncr_crypto_op_t */
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 struct ncr_session_update {
 	__u32 input_size, output_size;
 	ncr_session_t ses;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 struct ncr_session_final {
 	__u32 input_size, output_size;
 	ncr_session_t ses;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 struct ncr_session_once {
 	__u32 input_size, output_size;
 	ncr_crypto_op_t op;
-	__NL_ATTRIBUTES;
+	 __NL_ATTRIBUTES;
 };
 
 #define NCRIO_SESSION_INIT _IOWR('c', 0xD0, struct ncr_session_init)
diff --git a/utils.c b/utils.c
index a427833..245f949 100644
--- a/utils.c
+++ b/utils.c
@@ -48,45 +48,44 @@
 #endif /* !CONFIG_COMPAT */
 
 static const struct nla_policy ncr_attr_policy[NCR_ATTR_MAX + 1] = {
-	[NCR_ATTR_ALGORITHM] = { NLA_NUL_STRING, 0 },
-	[NCR_ATTR_DERIVATION_ALGORITHM] = { NLA_NUL_STRING, 0 },
-	[NCR_ATTR_SIGNATURE_HASH_ALGORITHM] = { NLA_NUL_STRING, 0 },
-	[NCR_ATTR_WRAPPING_ALGORITHM] = { NLA_NUL_STRING, 0 },
+	[NCR_ATTR_ALGORITHM] = {NLA_NUL_STRING, 0},
+	[NCR_ATTR_DERIVATION_ALGORITHM] = {NLA_NUL_STRING, 0},
+	[NCR_ATTR_SIGNATURE_HASH_ALGORITHM] = {NLA_NUL_STRING, 0},
+	[NCR_ATTR_WRAPPING_ALGORITHM] = {NLA_NUL_STRING, 0},
 	[NCR_ATTR_UPDATE_INPUT_DATA] = {
-		NLA_BINARY, MAX_SESSION_INPUT_DATA_SIZE
-	},
+					NLA_BINARY,
+					MAX_SESSION_INPUT_DATA_SIZE},
 	[NCR_ATTR_UPDATE_OUTPUT_BUFFER] = {
-		NLA_BINARY, MAX_SESSION_OUTPUT_BUFFER_SIZE
-	},
-	[NCR_ATTR_UPDATE_INPUT_KEY_AS_DATA] = { NLA_U32, 0 },
+					   NLA_BINARY,
+					   MAX_SESSION_OUTPUT_BUFFER_SIZE},
+	[NCR_ATTR_UPDATE_INPUT_KEY_AS_DATA] = {NLA_U32, 0},
 	[NCR_ATTR_FINAL_INPUT_DATA] = {
-		NLA_BINARY, MAX_SESSION_INPUT_DATA_SIZE
-	},
+				       NLA_BINARY, MAX_SESSION_INPUT_DATA_SIZE},
 	[NCR_ATTR_FINAL_OUTPUT_BUFFER] = {
-		NLA_BINARY, MAX_SESSION_OUTPUT_BUFFER_SIZE
-	},
-	[NCR_ATTR_KEY] = { NLA_U32, 0 },
-	[NCR_ATTR_KEY_FLAGS] = { NLA_U32, 0 },
-	[NCR_ATTR_KEY_ID] = { NLA_BINARY, 0 },
-	[NCR_ATTR_KEY_TYPE] = { NLA_U32, 0 },
-	[NCR_ATTR_IV] = { NLA_BINARY, 0 },
-	[NCR_ATTR_SECRET_KEY_BITS] = { NLA_U32, 0 },
-	[NCR_ATTR_RSA_MODULUS_BITS] = { NLA_U32, 0 },
-	[NCR_ATTR_RSA_E] = { NLA_BINARY, 0 },
-	[NCR_ATTR_RSA_ENCODING_METHOD] = { NLA_U32, 0 },
-	[NCR_ATTR_RSA_OAEP_HASH_ALGORITHM] = { NLA_NUL_STRING, 0 },
-	[NCR_ATTR_RSA_PSS_SALT_LENGTH] = { NLA_U32, 0 },
-	[NCR_ATTR_DSA_P_BITS] = { NLA_U32, 0 },
-	[NCR_ATTR_DSA_Q_BITS] = { NLA_U32, 0 },
-	[NCR_ATTR_DH_PRIME] = { NLA_BINARY, 0 },
-	[NCR_ATTR_DH_BASE] = { NLA_BINARY, 0 },
-	[NCR_ATTR_DH_PUBLIC] = { NLA_BINARY, 0 },
-	[NCR_ATTR_WANTED_ATTRS] = { NLA_BINARY, 0 },
-	[NCR_ATTR_SESSION_CLONE_FROM] = { NLA_U32, 0 },
+					  NLA_BINARY,
+					  MAX_SESSION_OUTPUT_BUFFER_SIZE},
+	[NCR_ATTR_KEY] = {NLA_U32, 0},
+	[NCR_ATTR_KEY_FLAGS] = {NLA_U32, 0},
+	[NCR_ATTR_KEY_ID] = {NLA_BINARY, 0},
+	[NCR_ATTR_KEY_TYPE] = {NLA_U32, 0},
+	[NCR_ATTR_IV] = {NLA_BINARY, 0},
+	[NCR_ATTR_SECRET_KEY_BITS] = {NLA_U32, 0},
+	[NCR_ATTR_RSA_MODULUS_BITS] = {NLA_U32, 0},
+	[NCR_ATTR_RSA_E] = {NLA_BINARY, 0},
+	[NCR_ATTR_RSA_ENCODING_METHOD] = {NLA_U32, 0},
+	[NCR_ATTR_RSA_OAEP_HASH_ALGORITHM] = {NLA_NUL_STRING, 0},
+	[NCR_ATTR_RSA_PSS_SALT_LENGTH] = {NLA_U32, 0},
+	[NCR_ATTR_DSA_P_BITS] = {NLA_U32, 0},
+	[NCR_ATTR_DSA_Q_BITS] = {NLA_U32, 0},
+	[NCR_ATTR_DH_PRIME] = {NLA_BINARY, 0},
+	[NCR_ATTR_DH_BASE] = {NLA_BINARY, 0},
+	[NCR_ATTR_DH_PUBLIC] = {NLA_BINARY, 0},
+	[NCR_ATTR_WANTED_ATTRS] = {NLA_BINARY, 0},
+	[NCR_ATTR_SESSION_CLONE_FROM] = {NLA_U32, 0},
 };
 
 void *__ncr_get_input_args(void *fixed, struct nlattr *tb[], size_t fixed_size,
-			   u32 *input_size_ptr, const void __user *arg)
+			   u32 * input_size_ptr, const void __user * arg)
 {
 	size_t input_size, buf_size;
 	void *buf;
@@ -143,22 +142,22 @@ err_buf:
 	return ERR_PTR(ret);
 }
 
-static int update_output_size(void __user *arg, size_t output_size_offset,
+static int update_output_size(void __user * arg, size_t output_size_offset,
 			      u32 old_value, u32 new_value)
 {
 	if (old_value != 0 && old_value != new_value) {
 		u32 __user *dest;
 
-		dest = (u32 __user *)((char __user *)arg + output_size_offset);
+		dest = (u32 __user *) ((char __user *)arg + output_size_offset);
 		return put_user(new_value, dest);
 	}
 	return 0;
 }
 
 void *__ncr_get_input_args_no_output(void *fixed, struct nlattr *tb[],
-				     size_t fixed_size, u32 *input_size_ptr,
+				     size_t fixed_size, u32 * input_size_ptr,
 				     size_t output_size_offset,
-				     void __user *arg)
+				     void __user * arg)
 {
 	void *attr_buf;
 	u32 output_size;
@@ -180,7 +179,7 @@ void *__ncr_get_input_args_no_output(void *fixed, struct nlattr *tb[],
 }
 
 int __ncr_out_init(struct ncr_out *out, const void *fixed, size_t fixed_size,
-		   size_t output_size_offset, void __user *arg)
+		   size_t output_size_offset, void __user * arg)
 {
 	u32 output_size;
 
@@ -248,7 +247,8 @@ struct nlattr *ncr_out_reserve(struct ncr_out *out, int attrtype, int attrlen)
 	return nla;
 }
 
-int ncr_out_put(struct ncr_out *out, int attrtype, int attrlen, const void *data)
+int ncr_out_put(struct ncr_out *out, int attrtype, int attrlen,
+		const void *data)
 {
 	struct nlattr *nla;
 
diff --git a/utils.h b/utils.h
index 2802afa..c1b6ebc 100644
--- a/utils.h
+++ b/utils.h
@@ -25,7 +25,6 @@ extern u32 __ncr_u32_type_check;
 	((void)(&(fixed)->output_size == &__ncr_u32_type_check),	\
 	 (char *)&(fixed)->output_size - (char *)(fixed))
 
-
 /**
  * Load *@fixed and a sequence of netlink-like attributes from @arg.  @fixed
  * contains "input_size", which is an u32 filled with total input size,
@@ -37,7 +36,7 @@ extern u32 __ncr_u32_type_check;
 	 __ncr_get_input_args(fixed, tb, sizeof(*(fixed)),	\
 			      &(fixed)->input_size, arg))
 void *__ncr_get_input_args(void *fixed, struct nlattr *tb[], size_t fixed_size,
-			   u32 *input_size_ptr, const void __user *arg);
+			   u32 * input_size_ptr, const void __user * arg);
 
 /**
  * Load *@fixed and a sequence of netlink-like attributes from @arg.  @fixed
@@ -53,9 +52,9 @@ void *__ncr_get_input_args(void *fixed, struct nlattr *tb[], size_t fixed_size,
 					&(fixed)->input_size,		\
 					__OUT_SIZE_OFF(fixed), arg))
 void *__ncr_get_input_args_no_output(void *fixed, struct nlattr *tb[],
-				     size_t fixed_size, u32 *input_size_ptr,
+				     size_t fixed_size, u32 * input_size_ptr,
 				     size_t output_size_offset,
-				     void __user *arg);
+				     void __user * arg);
 
 /**
  * Return a new output attribute context for attributes of *@fixed.  @fixed
@@ -67,7 +66,7 @@ void *__ncr_get_input_args_no_output(void *fixed, struct nlattr *tb[],
 	 __ncr_out_init((out), (fixed), sizeof(*(fixed)),	\
 			__OUT_SIZE_OFF(fixed), (arg)))
 int __ncr_out_init(struct ncr_out *out, const void *fixed, size_t fixed_size,
-		   size_t output_size_offset, void __user *arg);
+		   size_t output_size_offset, void __user * arg);
 
 /**
  * Write attributes from @out to user space and update user-space output_size.