1 files changed, 303 insertions, 0 deletions
diff --git a/src/others/irrlicht-1.8.1/source/Irrlicht/aesGladman/aescrypt.cpp b/src/others/irrlicht-1.8.1/source/Irrlicht/aesGladman/aescrypt.cpp
new file mode 100644
index 0000000..8d1feee
--- /dev/null
+++ b/src/others/irrlicht-1.8.1/source/Irrlicht/aesGladman/aescrypt.cpp
@@ -0,0 +1,303 @@
+/*
+ ---------------------------------------------------------------------------
+ Copyright (c) 2003, Dr Brian Gladman <                 >, Worcester, UK.
+ All rights reserved.
+ LICENSE TERMS
+ The free distribution and use of this software in both source and binary
+ form is allowed (with or without changes) provided that:
+   1. distributions of this source code include the above copyright
+      notice, this list of conditions and the following disclaimer;
+   2. distributions in binary form include the above copyright
+      notice, this list of conditions and the following disclaimer
+      in the documentation and/or other associated materials;
+   3. the copyright holder's name is not used to endorse products
+      built using this software without specific written permission.
+ ALTERNATIVELY, provided that this notice is retained in full, this product
+ may be distributed under the terms of the GNU General Public License (GPL),
+ in which case the provisions of the GPL apply INSTEAD OF those given above.
+ DISCLAIMER
+ This software is provided 'as is' with no explicit or implied warranties
+ in respect of its properties, including, but not limited to, correctness
+ and/or fitness for purpose.
+ ---------------------------------------------------------------------------
+ Issue Date: 26/08/2003
+ This file contains the code for implementing encryption and decryption
+ for AES (Rijndael) for block and key sizes of 16, 24 and 32 bytes. It
+ can optionally be replaced by code written in assembler using NASM. For
+ further details see the file aesopt.h
+*/
+#include "aesopt.h"
+#define si(y,x,k,c) (s(y,c) = word_in(x, c) ^ (k)[c])
+#define so(y,x,c)   word_out(y, c, s(x,c))
+#if defined(ARRAYS)
+#define locals(y,x)     x[4],y[4]
+#else
+#define locals(y,x)     x##0,x##1,x##2,x##3,y##0,y##1,y##2,y##3
+#endif
+#define l_copy(y, x)    s(y,0) = s(x,0); s(y,1) = s(x,1); \
+                        s(y,2) = s(x,2); s(y,3) = s(x,3);
+#define state_in(y,x,k) si(y,x,k,0); si(y,x,k,1); si(y,x,k,2); si(y,x,k,3)
+#define state_out(y,x)  so(y,x,0); so(y,x,1); so(y,x,2); so(y,x,3)
+#define round(rm,y,x,k) rm(y,x,k,0); rm(y,x,k,1); rm(y,x,k,2); rm(y,x,k,3)
+#if defined(ENCRYPTION) && !defined(AES_ASM)
+/* Visual C++ .Net v7.1 provides the fastest encryption code when using
+   Pentium optimization with small code but this is poor for decryption
+   so we need to control this with the following VC++ pragmas
+*/
+#if defined(_MSC_VER)
+#pragma optimize( "s", on )
+#endif
+/* Given the column (c) of the output state variable, the following
+   macros give the input state variables which are needed in its
+   computation for each row (r) of the state. All the alternative
+   macros give the same end values but expand into different ways
+   of calculating these values.  In particular the complex macro
+   used for dynamically variable block sizes is designed to expand
+   to a compile time constant whenever possible but will expand to
+   conditional clauses on some branches (I am grateful to Frank
+   Yellin for this construction)
+*/
+#define fwd_var(x,r,c)\
+ ( r == 0 ? ( c == 0 ? s(x,0) : c == 1 ? s(x,1) : c == 2 ? s(x,2) : s(x,3))\
+ : r == 1 ? ( c == 0 ? s(x,1) : c == 1 ? s(x,2) : c == 2 ? s(x,3) : s(x,0))\
+ : r == 2 ? ( c == 0 ? s(x,2) : c == 1 ? s(x,3) : c == 2 ? s(x,0) : s(x,1))\
+ :          ( c == 0 ? s(x,3) : c == 1 ? s(x,0) : c == 2 ? s(x,1) : s(x,2)))
+#if defined(FT4_SET)
+#undef  dec_fmvars
+#define fwd_rnd(y,x,k,c)    (s(y,c) = (k)[c] ^ four_tables(x,t_use(f,n),fwd_var,rf1,c))
+#elif defined(FT1_SET)
+#undef  dec_fmvars
+#define fwd_rnd(y,x,k,c)    (s(y,c) = (k)[c] ^ one_table(x,upr,t_use(f,n),fwd_var,rf1,c))
+#else
+#define fwd_rnd(y,x,k,c)    (s(y,c) = (k)[c] ^ fwd_mcol(no_table(x,t_use(s,box),fwd_var,rf1,c)))
+#endif
+#if defined(FL4_SET)
+#define fwd_lrnd(y,x,k,c)   (s(y,c) = (k)[c] ^ four_tables(x,t_use(f,l),fwd_var,rf1,c))
+#elif defined(FL1_SET)
+#define fwd_lrnd(y,x,k,c)   (s(y,c) = (k)[c] ^ one_table(x,ups,t_use(f,l),fwd_var,rf1,c))
+#else
+#define fwd_lrnd(y,x,k,c)   (s(y,c) = (k)[c] ^ no_table(x,t_use(s,box),fwd_var,rf1,c))
+#endif
+aes_rval aes_encrypt(const void *in_blk, void *out_blk, const aes_encrypt_ctx cx[1])
+{   aes_32t         locals(b0, b1);
+    const aes_32t   *kp = cx->ks;
+#ifdef dec_fmvars
+    dec_fmvars; /* declare variables for fwd_mcol() if needed */
+#endif
+    aes_32t nr = (kp[45] ^ kp[52] ^ kp[53] ? kp[52] : 14);
+#ifdef AES_ERR_CHK
+    if(   (nr != 10 || !(kp[0] | kp[3] | kp[4])) 
+       && (nr != 12 || !(kp[0] | kp[5] | kp[6]))
+       && (nr != 14 || !(kp[0] | kp[7] | kp[8])) )
+        return aes_error;
+#endif
+    state_in(b0, in_blk, kp);
+#if (ENC_UNROLL == FULL)
+    switch(nr)
+    {
+    case 14:
+        round(fwd_rnd,  b1, b0, kp + 1 * N_COLS);
+        round(fwd_rnd,  b0, b1, kp + 2 * N_COLS);
+        kp += 2 * N_COLS;
+    case 12:
+        round(fwd_rnd,  b1, b0, kp + 1 * N_COLS);
+        round(fwd_rnd,  b0, b1, kp + 2 * N_COLS);
+        kp += 2 * N_COLS;
+    case 10:
+        round(fwd_rnd,  b1, b0, kp + 1 * N_COLS);
+        round(fwd_rnd,  b0, b1, kp + 2 * N_COLS);
+        round(fwd_rnd,  b1, b0, kp + 3 * N_COLS);
+        round(fwd_rnd,  b0, b1, kp + 4 * N_COLS);
+        round(fwd_rnd,  b1, b0, kp + 5 * N_COLS);
+        round(fwd_rnd,  b0, b1, kp + 6 * N_COLS);
+        round(fwd_rnd,  b1, b0, kp + 7 * N_COLS);
+        round(fwd_rnd,  b0, b1, kp + 8 * N_COLS);
+        round(fwd_rnd,  b1, b0, kp + 9 * N_COLS);
+        round(fwd_lrnd, b0, b1, kp +10 * N_COLS);
+    }
+#else
+#if (ENC_UNROLL == PARTIAL)
+    {   aes_32t    rnd;
+        for(rnd = 0; rnd < (nr >> 1) - 1; ++rnd)
+        {
+            kp += N_COLS;
+            round(fwd_rnd, b1, b0, kp);
+            kp += N_COLS;
+            round(fwd_rnd, b0, b1, kp);
+        }
+        kp += N_COLS;
+        round(fwd_rnd,  b1, b0, kp);
+#else
+    {   aes_32t    rnd;
+        for(rnd = 0; rnd < nr - 1; ++rnd)
+        {
+            kp += N_COLS;
+            round(fwd_rnd, b1, b0, kp);
+            l_copy(b0, b1);
+        }
+#endif
+        kp += N_COLS;
+        round(fwd_lrnd, b0, b1, kp);
+    }
+#endif
+    state_out(out_blk, b0);
+#ifdef AES_ERR_CHK
+    return aes_good;
+#endif
+}
+#endif
+#if defined(DECRYPTION) && !defined(AES_ASM)
+/* Visual C++ .Net v7.1 provides the fastest encryption code when using
+   Pentium optimization with small code but this is poor for decryption
+   so we need to control this with the following VC++ pragmas
+*/
+#if defined(_MSC_VER)
+#pragma optimize( "t", on )
+#endif
+/* Given the column (c) of the output state variable, the following
+   macros give the input state variables which are needed in its
+   computation for each row (r) of the state. All the alternative
+   macros give the same end values but expand into different ways
+   of calculating these values.  In particular the complex macro
+   used for dynamically variable block sizes is designed to expand
+   to a compile time constant whenever possible but will expand to
+   conditional clauses on some branches (I am grateful to Frank
+   Yellin for this construction)
+*/
+#define inv_var(x,r,c)\
+ ( r == 0 ? ( c == 0 ? s(x,0) : c == 1 ? s(x,1) : c == 2 ? s(x,2) : s(x,3))\
+ : r == 1 ? ( c == 0 ? s(x,3) : c == 1 ? s(x,0) : c == 2 ? s(x,1) : s(x,2))\
+ : r == 2 ? ( c == 0 ? s(x,2) : c == 1 ? s(x,3) : c == 2 ? s(x,0) : s(x,1))\
+ :          ( c == 0 ? s(x,1) : c == 1 ? s(x,2) : c == 2 ? s(x,3) : s(x,0)))
+#if defined(IT4_SET)
+#undef  dec_imvars
+#define inv_rnd(y,x,k,c)    (s(y,c) = (k)[c] ^ four_tables(x,t_use(i,n),inv_var,rf1,c))
+#elif defined(IT1_SET)
+#undef  dec_imvars
+#define inv_rnd(y,x,k,c)    (s(y,c) = (k)[c] ^ one_table(x,upr,t_use(i,n),inv_var,rf1,c))
+#else
+#define inv_rnd(y,x,k,c)    (s(y,c) = inv_mcol((k)[c] ^ no_table(x,t_use(i,box),inv_var,rf1,c)))
+#endif
+#if defined(IL4_SET)
+#define inv_lrnd(y,x,k,c)   (s(y,c) = (k)[c] ^ four_tables(x,t_use(i,l),inv_var,rf1,c))
+#elif defined(IL1_SET)
+#define inv_lrnd(y,x,k,c)   (s(y,c) = (k)[c] ^ one_table(x,ups,t_use(i,l),inv_var,rf1,c))
+#else
+#define inv_lrnd(y,x,k,c)   (s(y,c) = (k)[c] ^ no_table(x,t_use(i,box),inv_var,rf1,c))
+#endif
+aes_rval aes_decrypt(const void *in_blk, void *out_blk, const aes_decrypt_ctx cx[1])
+{   aes_32t        locals(b0, b1);
+#ifdef dec_imvars
+    dec_imvars; /* declare variables for inv_mcol() if needed */
+#endif
+    aes_32t nr = (cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] ? cx->ks[52] : 14);
+    const aes_32t *kp = cx->ks + nr * N_COLS;
+#ifdef AES_ERR_CHK
+    if(   (nr != 10 || !(cx->ks[0] | cx->ks[3] | cx->ks[4])) 
+       && (nr != 12 || !(cx->ks[0] | cx->ks[5] | cx->ks[6]))
+       && (nr != 14 || !(cx->ks[0] | cx->ks[7] | cx->ks[8])) )
+        return aes_error;
+#endif
+    state_in(b0, in_blk, kp);
+#if (DEC_UNROLL == FULL)
+    switch(nr)
+    {
+    case 14:
+        round(inv_rnd,  b1, b0, kp -  1 * N_COLS);
+        round(inv_rnd,  b0, b1, kp -  2 * N_COLS);
+        kp -= 2 * N_COLS;
+    case 12:
+        round(inv_rnd,  b1, b0, kp -  1 * N_COLS);
+        round(inv_rnd,  b0, b1, kp -  2 * N_COLS);
+        kp -= 2 * N_COLS;
+    case 10:
+        round(inv_rnd,  b1, b0, kp -  1 * N_COLS);
+        round(inv_rnd,  b0, b1, kp -  2 * N_COLS);
+        round(inv_rnd,  b1, b0, kp -  3 * N_COLS);
+        round(inv_rnd,  b0, b1, kp -  4 * N_COLS);
+        round(inv_rnd,  b1, b0, kp -  5 * N_COLS);
+        round(inv_rnd,  b0, b1, kp -  6 * N_COLS);
+        round(inv_rnd,  b1, b0, kp -  7 * N_COLS);
+        round(inv_rnd,  b0, b1, kp -  8 * N_COLS);
+        round(inv_rnd,  b1, b0, kp -  9 * N_COLS);
+        round(inv_lrnd, b0, b1, kp - 10 * N_COLS);
+    }
+#else
+#if (DEC_UNROLL == PARTIAL)
+    {   aes_32t    rnd;
+        for(rnd = 0; rnd < (nr >> 1) - 1; ++rnd)
+        {
+            kp -= N_COLS;
+            round(inv_rnd, b1, b0, kp);
+            kp -= N_COLS;
+            round(inv_rnd, b0, b1, kp);
+        }
+        kp -= N_COLS;
+        round(inv_rnd, b1, b0, kp);
+#else
+    {   aes_32t    rnd;
+        for(rnd = 0; rnd < nr - 1; ++rnd)
+        {
+            kp -= N_COLS;
+            round(inv_rnd, b1, b0, kp);
+            l_copy(b0, b1);
+        }
+#endif
+        kp -= N_COLS;
+        round(inv_lrnd, b0, b1, kp);
+    }
+#endif
+    state_out(out_blk, b0);
+#ifdef AES_ERR_CHK
+    return aes_good;
+#endif
+}
+#endif

diff --git a/src/others/irrlicht-1.8.1/source/Irrlicht/aesGladman/aescrypt.cpp b/src/others/irrlicht-1.8.1/source/Irrlicht/aesGladman/aescrypt.cpp new file mode 100644 index 0000000..8d1feee --- /dev/null +++ b/src/others/irrlicht-1.8.1/source/Irrlicht/aesGladman/aescrypt.cpp
@@ -0,0 +1,303 @@
	1	/*
	2	---------------------------------------------------------------------------
	3	Copyright (c) 2003, Dr Brian Gladman < >, Worcester, UK.
	4	All rights reserved.
	5
	6	LICENSE TERMS
	7
	8	The free distribution and use of this software in both source and binary
	9	form is allowed (with or without changes) provided that:
	10
	11	1. distributions of this source code include the above copyright
	12	notice, this list of conditions and the following disclaimer;
	13
	14	2. distributions in binary form include the above copyright
	15	notice, this list of conditions and the following disclaimer
	16	in the documentation and/or other associated materials;
	17
	18	3. the copyright holder's name is not used to endorse products
	19	built using this software without specific written permission.
	20
	21	ALTERNATIVELY, provided that this notice is retained in full, this product
	22	may be distributed under the terms of the GNU General Public License (GPL),
	23	in which case the provisions of the GPL apply INSTEAD OF those given above.
	24
	25	DISCLAIMER
	26
	27	This software is provided 'as is' with no explicit or implied warranties
	28	in respect of its properties, including, but not limited to, correctness
	29	and/or fitness for purpose.
	30	---------------------------------------------------------------------------
	31	Issue Date: 26/08/2003
	32
	33	This file contains the code for implementing encryption and decryption
	34	for AES (Rijndael) for block and key sizes of 16, 24 and 32 bytes. It
	35	can optionally be replaced by code written in assembler using NASM. For
	36	further details see the file aesopt.h
	37	*/
	38
	39	#include "aesopt.h"
	40
	41	#define si(y,x,k,c) (s(y,c) = word_in(x, c) ^ (k)[c])
	42	#define so(y,x,c) word_out(y, c, s(x,c))
	43
	44	#if defined(ARRAYS)
	45	#define locals(y,x) x[4],y[4]
	46	#else
	47	#define locals(y,x) x##0,x##1,x##2,x##3,y##0,y##1,y##2,y##3
	48	#endif
	49
	50	#define l_copy(y, x) s(y,0) = s(x,0); s(y,1) = s(x,1); \
	51	s(y,2) = s(x,2); s(y,3) = s(x,3);
	52	#define state_in(y,x,k) si(y,x,k,0); si(y,x,k,1); si(y,x,k,2); si(y,x,k,3)
	53	#define state_out(y,x) so(y,x,0); so(y,x,1); so(y,x,2); so(y,x,3)
	54	#define round(rm,y,x,k) rm(y,x,k,0); rm(y,x,k,1); rm(y,x,k,2); rm(y,x,k,3)
	55
	56	#if defined(ENCRYPTION) && !defined(AES_ASM)
	57
	58	/* Visual C++ .Net v7.1 provides the fastest encryption code when using
	59	Pentium optimization with small code but this is poor for decryption
	60	so we need to control this with the following VC++ pragmas
	61	*/
	62
	63	#if defined(_MSC_VER)
	64	#pragma optimize( "s", on )
	65	#endif
	66
	67	/* Given the column (c) of the output state variable, the following
	68	macros give the input state variables which are needed in its
	69	computation for each row (r) of the state. All the alternative
	70	macros give the same end values but expand into different ways
	71	of calculating these values. In particular the complex macro
	72	used for dynamically variable block sizes is designed to expand
	73	to a compile time constant whenever possible but will expand to
	74	conditional clauses on some branches (I am grateful to Frank
	75	Yellin for this construction)
	76	*/
	77
	78	#define fwd_var(x,r,c)\
	79	( r == 0 ? ( c == 0 ? s(x,0) : c == 1 ? s(x,1) : c == 2 ? s(x,2) : s(x,3))\
	80	: r == 1 ? ( c == 0 ? s(x,1) : c == 1 ? s(x,2) : c == 2 ? s(x,3) : s(x,0))\
	81	: r == 2 ? ( c == 0 ? s(x,2) : c == 1 ? s(x,3) : c == 2 ? s(x,0) : s(x,1))\
	82	: ( c == 0 ? s(x,3) : c == 1 ? s(x,0) : c == 2 ? s(x,1) : s(x,2)))
	83
	84	#if defined(FT4_SET)
	85	#undef dec_fmvars
	86	#define fwd_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(f,n),fwd_var,rf1,c))
	87	#elif defined(FT1_SET)
	88	#undef dec_fmvars
	89	#define fwd_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ one_table(x,upr,t_use(f,n),fwd_var,rf1,c))
	90	#else
	91	#define fwd_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ fwd_mcol(no_table(x,t_use(s,box),fwd_var,rf1,c)))
	92	#endif
	93
	94	#if defined(FL4_SET)
	95	#define fwd_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(f,l),fwd_var,rf1,c))
	96	#elif defined(FL1_SET)
	97	#define fwd_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ one_table(x,ups,t_use(f,l),fwd_var,rf1,c))
	98	#else
	99	#define fwd_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ no_table(x,t_use(s,box),fwd_var,rf1,c))
	100	#endif
	101
	102	aes_rval aes_encrypt(const void in_blk, void out_blk, const aes_encrypt_ctx cx[1])
	103	{ aes_32t locals(b0, b1);
	104	const aes_32t *kp = cx->ks;
	105	#ifdef dec_fmvars
	106	dec_fmvars; /* declare variables for fwd_mcol() if needed */
	107	#endif
	108
	109	aes_32t nr = (kp[45] ^ kp[52] ^ kp[53] ? kp[52] : 14);
	110
	111	#ifdef AES_ERR_CHK
	112	if( (nr != 10 \|\| !(kp[0] \| kp[3] \| kp[4]))
	113	&& (nr != 12 \|\| !(kp[0] \| kp[5] \| kp[6]))
	114	&& (nr != 14 \|\| !(kp[0] \| kp[7] \| kp[8])) )
	115	return aes_error;
	116	#endif
	117
	118	state_in(b0, in_blk, kp);
	119
	120	#if (ENC_UNROLL == FULL)
	121
	122	switch(nr)
	123	{
	124	case 14:
	125	round(fwd_rnd, b1, b0, kp + 1 * N_COLS);
	126	round(fwd_rnd, b0, b1, kp + 2 * N_COLS);
	127	kp += 2 * N_COLS;
	128	case 12:
	129	round(fwd_rnd, b1, b0, kp + 1 * N_COLS);
	130	round(fwd_rnd, b0, b1, kp + 2 * N_COLS);
	131	kp += 2 * N_COLS;
	132	case 10:
	133	round(fwd_rnd, b1, b0, kp + 1 * N_COLS);
	134	round(fwd_rnd, b0, b1, kp + 2 * N_COLS);
	135	round(fwd_rnd, b1, b0, kp + 3 * N_COLS);
	136	round(fwd_rnd, b0, b1, kp + 4 * N_COLS);
	137	round(fwd_rnd, b1, b0, kp + 5 * N_COLS);
	138	round(fwd_rnd, b0, b1, kp + 6 * N_COLS);
	139	round(fwd_rnd, b1, b0, kp + 7 * N_COLS);
	140	round(fwd_rnd, b0, b1, kp + 8 * N_COLS);
	141	round(fwd_rnd, b1, b0, kp + 9 * N_COLS);
	142	round(fwd_lrnd, b0, b1, kp +10 * N_COLS);
	143	}
	144
	145	#else
	146
	147	#if (ENC_UNROLL == PARTIAL)
	148	{ aes_32t rnd;
	149	for(rnd = 0; rnd < (nr >> 1) - 1; ++rnd)
	150	{
	151	kp += N_COLS;
	152	round(fwd_rnd, b1, b0, kp);
	153	kp += N_COLS;
	154	round(fwd_rnd, b0, b1, kp);
	155	}
	156	kp += N_COLS;
	157	round(fwd_rnd, b1, b0, kp);
	158	#else
	159	{ aes_32t rnd;
	160	for(rnd = 0; rnd < nr - 1; ++rnd)
	161	{
	162	kp += N_COLS;
	163	round(fwd_rnd, b1, b0, kp);
	164	l_copy(b0, b1);
	165	}
	166	#endif
	167	kp += N_COLS;
	168	round(fwd_lrnd, b0, b1, kp);
	169	}
	170	#endif
	171
	172	state_out(out_blk, b0);
	173	#ifdef AES_ERR_CHK
	174	return aes_good;
	175	#endif
	176	}
	177
	178	#endif
	179
	180	#if defined(DECRYPTION) && !defined(AES_ASM)
	181
	182	/* Visual C++ .Net v7.1 provides the fastest encryption code when using
	183	Pentium optimization with small code but this is poor for decryption
	184	so we need to control this with the following VC++ pragmas
	185	*/
	186
	187	#if defined(_MSC_VER)
	188	#pragma optimize( "t", on )
	189	#endif
	190
	191	/* Given the column (c) of the output state variable, the following
	192	macros give the input state variables which are needed in its
	193	computation for each row (r) of the state. All the alternative
	194	macros give the same end values but expand into different ways
	195	of calculating these values. In particular the complex macro
	196	used for dynamically variable block sizes is designed to expand
	197	to a compile time constant whenever possible but will expand to
	198	conditional clauses on some branches (I am grateful to Frank
	199	Yellin for this construction)
	200	*/
	201
	202	#define inv_var(x,r,c)\
	203	( r == 0 ? ( c == 0 ? s(x,0) : c == 1 ? s(x,1) : c == 2 ? s(x,2) : s(x,3))\
	204	: r == 1 ? ( c == 0 ? s(x,3) : c == 1 ? s(x,0) : c == 2 ? s(x,1) : s(x,2))\
	205	: r == 2 ? ( c == 0 ? s(x,2) : c == 1 ? s(x,3) : c == 2 ? s(x,0) : s(x,1))\
	206	: ( c == 0 ? s(x,1) : c == 1 ? s(x,2) : c == 2 ? s(x,3) : s(x,0)))
	207
	208	#if defined(IT4_SET)
	209	#undef dec_imvars
	210	#define inv_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(i,n),inv_var,rf1,c))
	211	#elif defined(IT1_SET)
	212	#undef dec_imvars
	213	#define inv_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ one_table(x,upr,t_use(i,n),inv_var,rf1,c))
	214	#else
	215	#define inv_rnd(y,x,k,c) (s(y,c) = inv_mcol((k)[c] ^ no_table(x,t_use(i,box),inv_var,rf1,c)))
	216	#endif
	217
	218	#if defined(IL4_SET)
	219	#define inv_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(i,l),inv_var,rf1,c))
	220	#elif defined(IL1_SET)
	221	#define inv_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ one_table(x,ups,t_use(i,l),inv_var,rf1,c))
	222	#else
	223	#define inv_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ no_table(x,t_use(i,box),inv_var,rf1,c))
	224	#endif
	225
	226	aes_rval aes_decrypt(const void in_blk, void out_blk, const aes_decrypt_ctx cx[1])
	227	{ aes_32t locals(b0, b1);
	228	#ifdef dec_imvars
	229	dec_imvars; /* declare variables for inv_mcol() if needed */
	230	#endif
	231
	232	aes_32t nr = (cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] ? cx->ks[52] : 14);
	233	const aes_32t kp = cx->ks + nr N_COLS;
	234
	235	#ifdef AES_ERR_CHK
	236	if( (nr != 10 \|\| !(cx->ks[0] \| cx->ks[3] \| cx->ks[4]))
	237	&& (nr != 12 \|\| !(cx->ks[0] \| cx->ks[5] \| cx->ks[6]))
	238	&& (nr != 14 \|\| !(cx->ks[0] \| cx->ks[7] \| cx->ks[8])) )
	239	return aes_error;
	240	#endif
	241
	242	state_in(b0, in_blk, kp);
	243
	244	#if (DEC_UNROLL == FULL)
	245
	246	switch(nr)
	247	{
	248	case 14:
	249	round(inv_rnd, b1, b0, kp - 1 * N_COLS);
	250	round(inv_rnd, b0, b1, kp - 2 * N_COLS);
	251	kp -= 2 * N_COLS;
	252	case 12:
	253	round(inv_rnd, b1, b0, kp - 1 * N_COLS);
	254	round(inv_rnd, b0, b1, kp - 2 * N_COLS);
	255	kp -= 2 * N_COLS;
	256	case 10:
	257	round(inv_rnd, b1, b0, kp - 1 * N_COLS);
	258	round(inv_rnd, b0, b1, kp - 2 * N_COLS);
	259	round(inv_rnd, b1, b0, kp - 3 * N_COLS);
	260	round(inv_rnd, b0, b1, kp - 4 * N_COLS);
	261	round(inv_rnd, b1, b0, kp - 5 * N_COLS);
	262	round(inv_rnd, b0, b1, kp - 6 * N_COLS);
	263	round(inv_rnd, b1, b0, kp - 7 * N_COLS);
	264	round(inv_rnd, b0, b1, kp - 8 * N_COLS);
	265	round(inv_rnd, b1, b0, kp - 9 * N_COLS);
	266	round(inv_lrnd, b0, b1, kp - 10 * N_COLS);
	267	}
	268
	269	#else
	270
	271	#if (DEC_UNROLL == PARTIAL)
	272	{ aes_32t rnd;
	273	for(rnd = 0; rnd < (nr >> 1) - 1; ++rnd)
	274	{
	275	kp -= N_COLS;
	276	round(inv_rnd, b1, b0, kp);
	277	kp -= N_COLS;
	278	round(inv_rnd, b0, b1, kp);
	279	}
	280	kp -= N_COLS;
	281	round(inv_rnd, b1, b0, kp);
	282	#else
	283	{ aes_32t rnd;
	284	for(rnd = 0; rnd < nr - 1; ++rnd)
	285	{
	286	kp -= N_COLS;
	287	round(inv_rnd, b1, b0, kp);
	288	l_copy(b0, b1);
	289	}
	290	#endif
	291	kp -= N_COLS;
	292	round(inv_lrnd, b0, b1, kp);
	293	}
	294	#endif
	295
	296	state_out(out_blk, b0);
	297	#ifdef AES_ERR_CHK
	298	return aes_good;
	299	#endif
	300	}
	301
	302	#endif
	303