Binary files memdbg2/.git/index and memdbg1/.git/index differ
diff -urpN memdbg2/.git/logs/HEAD memdbg1/.git/logs/HEAD
--- memdbg2/.git/logs/HEAD	2013-05-15 04:30:32.921875000 -0500
+++ memdbg1/.git/logs/HEAD	2013-05-11 08:14:36.312500000 -0500
@@ -1 +1 @@
-0000000000000000000000000000000000000000 011462b2d5872480c3162aa7bd244c250dd8fd81 JimF <jfoug@cox.net> 1368610232 -0500	clone: from git://github.com/magnumripper/JohnTheRipper
+0000000000000000000000000000000000000000 994b39c5b55851b3cc7b57f0b3914b22983c8e9a JimF <jfoug@cox.net> 1368278076 -0500	clone: from git://github.com/magnumripper/JohnTheRipper
diff -urpN memdbg2/.git/logs/refs/heads/memdbg memdbg1/.git/logs/refs/heads/memdbg
--- memdbg2/.git/logs/refs/heads/memdbg	2013-05-15 04:30:32.921875000 -0500
+++ memdbg1/.git/logs/refs/heads/memdbg	2013-05-11 08:14:36.296875000 -0500
@@ -1 +1 @@
-0000000000000000000000000000000000000000 011462b2d5872480c3162aa7bd244c250dd8fd81 JimF <jfoug@cox.net> 1368610232 -0500	clone: from git://github.com/magnumripper/JohnTheRipper
+0000000000000000000000000000000000000000 994b39c5b55851b3cc7b57f0b3914b22983c8e9a JimF <jfoug@cox.net> 1368278076 -0500	clone: from git://github.com/magnumripper/JohnTheRipper
Binary files memdbg2/.git/objects/pack/pack-684533148debec357c174f6add8b28f9b1dcbe2a.idx and memdbg1/.git/objects/pack/pack-684533148debec357c174f6add8b28f9b1dcbe2a.idx differ
Binary files memdbg2/.git/objects/pack/pack-684533148debec357c174f6add8b28f9b1dcbe2a.pack and memdbg1/.git/objects/pack/pack-684533148debec357c174f6add8b28f9b1dcbe2a.pack differ
Binary files memdbg2/.git/objects/pack/pack-f3295db3f9c225f869242a3a247bf036253ee062.idx and memdbg1/.git/objects/pack/pack-f3295db3f9c225f869242a3a247bf036253ee062.idx differ
Binary files memdbg2/.git/objects/pack/pack-f3295db3f9c225f869242a3a247bf036253ee062.pack and memdbg1/.git/objects/pack/pack-f3295db3f9c225f869242a3a247bf036253ee062.pack differ
diff -urpN memdbg2/.git/packed-refs memdbg1/.git/packed-refs
--- memdbg2/.git/packed-refs	2013-05-15 04:30:32.718750000 -0500
+++ memdbg1/.git/packed-refs	2013-05-11 08:14:36.250000000 -0500
@@ -1,10 +1,12 @@
 # pack-refs with: peeled 
 0ef286ee95d3e6df3246a19a3172a5ce7500fb56 refs/remotes/origin/1.7.9-jumbo-7
 4d507bfeb720d788fd0293d7a5dbeb02c7c15867 refs/remotes/origin/bartavelle
-d4189d888c20cf51c0216c98a9bb56950c3e5f28 refs/remotes/origin/bleeding-jumbo
-4a1fd882c15020cf51ad3e943c661c11ee770f1b refs/remotes/origin/master
-011462b2d5872480c3162aa7bd244c250dd8fd81 refs/remotes/origin/memdbg
-a1ab62b3a978f56f59f7c5201793e30c3e6bc82e refs/remotes/origin/unstable-jumbo
+1c43dd4fea74e58a453b317521bef2fb0ed040b6 refs/remotes/origin/bleeding-jumbo
+dfef98e27b360bddd2e2c4d4c0a19eba62073055 refs/remotes/origin/master
+9a3bd13dd9d8cf3014e27f1b410dc4e2bdea7ca9 refs/remotes/origin/master+patches
+994b39c5b55851b3cc7b57f0b3914b22983c8e9a refs/remotes/origin/memdbg
+404c2fcaace13184efe9107de704e5ba531e3b7e refs/remotes/origin/mschapv2-bs
+60b3b3d173f31f3fcadb4b47f05ab5ba4bf57b3b refs/remotes/origin/unstable-jumbo
 7894cc8e3052793020db34f4648182a890d8ba7e refs/tags/1.7.9
 cad3b0ec43b6b9af0eb478bed0e84e1461d7e412 refs/tags/1.7.9-jumbo-3
 57a0e272bbba7187b3240c9c605281100b97515f refs/tags/1.7.9-jumbo-4
diff -urpN memdbg2/.git/refs/heads/memdbg memdbg1/.git/refs/heads/memdbg
--- memdbg2/.git/refs/heads/memdbg	2013-05-15 04:30:32.812500000 -0500
+++ memdbg1/.git/refs/heads/memdbg	2013-05-11 08:14:36.296875000 -0500
@@ -1 +1 @@
-011462b2d5872480c3162aa7bd244c250dd8fd81
+994b39c5b55851b3cc7b57f0b3914b22983c8e9a
diff -urpN memdbg2/doc/DYNAMIC memdbg1/doc/DYNAMIC
--- memdbg2/doc/DYNAMIC	2013-05-15 04:30:33.156250000 -0500
+++ memdbg1/doc/DYNAMIC	2013-05-15 06:51:22.984375000 -0500
@@ -166,6 +166,7 @@ dynamic_54  | sha224(sha224_raw($p))  |
 dynamic_55  | sha224(sha224($p).$s)   | Yes   |
 dynamic_56  | sha224($s.sha224($p))   | Yes   |
 dynamic_57  | sha224(sha224($s).sha224($p)) | Yes   |
+dynamic_58  | sha224(sha224($p).sha224($p)) | No    |
 dynamic_60  | sha256($p)              | No    |
 dynamic_61  | sha256($s.$p)           | Yes   |
 dynamic_62  | sha256($p.$s)           | Yes   |
@@ -174,6 +175,7 @@ dynamic_64  | sha256(sha256_raw($p))  |
 dynamic_65  | sha256(sha256($p).$s)   | Yes   |
 dynamic_66  | sha256($s.sha256($p))   | Yes   |
 dynamic_67  | sha256(sha256($s).sha256($p)) | Yes   |
+dynamic_68  | sha256(sha256($p).sha256($p)) | No    |
 dynamic_70  | sha384($p)              | No    |
 dynamic_71  | sha384($s.$p)           | Yes   |
 dynamic_72  | sha384($p.$s)           | Yes   |
@@ -182,6 +184,7 @@ dynamic_74  | sha384(sha384_raw($p))  |
 dynamic_75  | sha384(sha384($p).$s)   | Yes   |
 dynamic_76  | sha384($s.sha384($p))   | Yes   |
 dynamic_77  | sha384(sha384($s).sha384($p)) | Yes   |
+dynamic_78  | sha384(sha384($p).sha384($p)) | No    |
 dynamic_80  | sha512($p)              | No    |
 dynamic_81  | sha512($s.$p)           | Yes   |
 dynamic_82  | sha512($p.$s)           | Yes   |
@@ -190,6 +193,7 @@ dynamic_84  | sha512(sha512_raw($p))  |
 dynamic_85  | sha512(sha512($p).$s)   | Yes   |
 dynamic_86  | sha512($s.sha512($p))   | Yes   |
 dynamic_87  | sha512(sha512($s).sha512($p)) | Yes   |
+dynamic_88  | sha512(sha512($p).sha512($p)) | No    |
 dynamic_90  | GOST($p)                | No    |
 dynamic_91  | GOST($s.$p)             | Yes   |
 dynamic_92  | GOST($p.$s)             | Yes   |
@@ -198,6 +202,7 @@ dynamic_94  | GOST(GOST_raw($p))      |
 dynamic_95  | GOST(GOST($p).$s)       | Yes   |
 dynamic_96  | GOST($s.GOST($p))       | Yes   |
 dynamic_97  | GOST(GOST($s).GOST($p)) | Yes   |
+dynamic_98  | GOST(GOST($p).GOST($p)) | No    |
 dynamic_100 | WHIRLPOOL($p)           | No    |
 dynamic_101 | WHIRLPOOL($s.$p)        | Yes   |
 dynamic_102 | WHIRLPOOL($p.$s)        | Yes   |
@@ -206,6 +211,7 @@ dynamic_104 | WHIRLPOOL(WHIRLPOOL_raw($p
 dynamic_105 | WHIRLPOOL(WHIRLPOOL($p).$s)  | Yes   |
 dynamic_106 | WHIRLPOOL($s.WHIRLPOOL($p))  | Yes   |
 dynamic_107 | WHIRLPOOL(WHIRLPOOL($s).WHIRLPOOL($p)) | Yes   |
+dynamic_108 | WHIRLPOOL(WHIRLPOOL($p).WHIRLPOOL($p)) | No    |
 dynamic_110 | Tiger($p)                | No   |
 dynamic_111 | Tiger($s.$p)             | Yes  |
 dynamic_112 | Tiger($p.$s)             | Yes  |
@@ -214,6 +220,7 @@ dynamic_114 | Tiger(Tiger_raw($p))     |
 dynamic_115 | Tiger(Tiger($p).$s)      | Yes  |
 dynamic_116 | Tiger($s.Tiger($p))      | Yes  |
 dynamic_117 | Tiger(Tiger($s).Tiger($p)) | Yes  |
+dynamic_118 | Tiger(Tiger($p).Tiger($p)) | No   |
 dynamic_120 | RIPEMD128($p)                | No   |
 dynamic_121 | RIPEMD128($s.$p)             | Yes  |
 dynamic_122 | RIPEMD128($p.$s)             | Yes  |
@@ -222,6 +229,7 @@ dynamic_124 | RIPEMD128(RIPEMD128_raw($p
 dynamic_125 | RIPEMD128(RIPEMD128($p).$s)      | Yes  |
 dynamic_126 | RIPEMD128($s.RIPEMD128($p))      | Yes  |
 dynamic_127 | RIPEMD128(RIPEMD128($s).RIPEMD128($p)) | Yes  |
+dynamic_128 | RIPEMD128(RIPEMD128($p).RIPEMD128($p)) | No   |
 dynamic_130 | RIPEMD160($p)                | No   |
 dynamic_131 | RIPEMD160($s.$p)             | Yes  |
 dynamic_132 | RIPEMD160($p.$s)             | Yes  |
@@ -230,6 +238,7 @@ dynamic_134 | RIPEMD160(RIPEMD160_raw($p
 dynamic_135 | RIPEMD160(RIPEMD160($p).$s)      | Yes  |
 dynamic_136 | RIPEMD160($s.RIPEMD160($p))      | Yes  |
 dynamic_137 | RIPEMD160(RIPEMD160($s).RIPEMD160($p)) | Yes  |
+dynamic_138 | RIPEMD160(RIPEMD160($p).RIPEMD160($p)) | No   |
 dynamic_140 | RIPEMD256($p)                | No   |
 dynamic_141 | RIPEMD256($s.$p)             | Yes  |
 dynamic_142 | RIPEMD256($p.$s)             | Yes  |
@@ -238,6 +247,7 @@ dynamic_144 | RIPEMD256(RIPEMD256_raw($p
 dynamic_145 | RIPEMD256(RIPEMD256($p).$s)      | Yes  |
 dynamic_146 | RIPEMD256($s.RIPEMD256($p))      | Yes  |
 dynamic_147 | RIPEMD256(RIPEMD256($s).RIPEMD256($p)) | Yes  |
+dynamic_148 | RIPEMD256(RIPEMD256($p).RIPEMD256($p)) | No   |
 dynamic_150 | RIPEMD320($p)                | No   |
 dynamic_151 | RIPEMD320($s.$p)             | Yes  |
 dynamic_152 | RIPEMD320($p.$s)             | Yes  |
@@ -246,6 +256,7 @@ dynamic_154 | RIPEMD320(RIPEMD320_raw($p
 dynamic_155 | RIPEMD320(RIPEMD320($p).$s)      | Yes  |
 dynamic_156 | RIPEMD320($s.RIPEMD320($p))      | Yes  |
 dynamic_157 | RIPEMD320(RIPEMD320($s).RIPEMD320($p)) | Yes  |
+dynamic_158 | RIPEMD320(RIPEMD320($p).RIPEMD320($p)) | No   |
 
 
 ........    | RESERVED                | UNK   |
@@ -653,6 +664,12 @@ examples (this whole list is also found
 #  DynamicFunc__append_input2_from_input
 #     Appends input1 to input2   input2 += input
 #
+#  DynamicFunc__append_input_from_input
+#     Appends input1 to input1   input1 += input2
+#
+#  DynamicFunc__append_input2_from_input2
+#     Appends input2 to input2   input2 += input2
+#
 #  DynamicFunc__append_from_last_output2_as_raw
 #     Appends the 'raw' output data from output2 to input1.  Length of input1 grows by 16 bytes.
 #
diff -urpN memdbg2/run/pass_gen.pl memdbg1/run/pass_gen.pl
--- memdbg2/run/pass_gen.pl	2013-05-15 04:30:34.406250000 -0500
+++ memdbg1/run/pass_gen.pl	2013-05-15 06:44:26.500000000 -0500
@@ -1756,6 +1756,7 @@ sub dynamic_compile {
 			$dynamic_args==55 && do {$fmt='sha224(sha224($p).$s),saltlen=6';            last SWITCH; };
 			$dynamic_args==56 && do {$fmt='sha224($s.sha224($p)),saltlen=6';            last SWITCH; };
 			$dynamic_args==57 && do {$fmt='sha224(sha224($s).sha224($p)),saltlen=6';	last SWITCH; };
+			$dynamic_args==58 && do {$fmt='sha224(sha224($p).sha224($p))';				last SWITCH; };
 			$dynamic_args==60 && do {$fmt='sha256($p)';					last SWITCH; };
 			$dynamic_args==61 && do {$fmt='sha256($s.$p),saltlen=6';	last SWITCH; };
 			$dynamic_args==62 && do {$fmt='sha256($p.$s)';				last SWITCH; };
@@ -1764,6 +1765,7 @@ sub dynamic_compile {
 			$dynamic_args==65 && do {$fmt='sha256(sha256($p).$s),saltlen=6';            last SWITCH; };
 			$dynamic_args==66 && do {$fmt='sha256($s.sha256($p)),saltlen=6';            last SWITCH; };
 			$dynamic_args==67 && do {$fmt='sha256(sha256($s).sha256($p)),saltlen=6';	last SWITCH; };
+			$dynamic_args==68 && do {$fmt='sha256(sha256($p).sha256($p))';				last SWITCH; };
 			$dynamic_args==70 && do {$fmt='sha384($p)';					last SWITCH; };
 			$dynamic_args==71 && do {$fmt='sha384($s.$p),saltlen=6';	last SWITCH; };
 			$dynamic_args==72 && do {$fmt='sha384($p.$s)';				last SWITCH; };
@@ -1772,6 +1774,7 @@ sub dynamic_compile {
 			$dynamic_args==75 && do {$fmt='sha384(sha384($p).$s),saltlen=6';            last SWITCH; };
 			$dynamic_args==76 && do {$fmt='sha384($s.sha384($p)),saltlen=6';            last SWITCH; };
 			$dynamic_args==77 && do {$fmt='sha384(sha384($s).sha384($p)),saltlen=6';	last SWITCH; };
+			$dynamic_args==78 && do {$fmt='sha384(sha384($p).sha384($p))';				last SWITCH; };
 			$dynamic_args==80 && do {$fmt='sha512($p)';					last SWITCH; };
 			$dynamic_args==81 && do {$fmt='sha512($s.$p),saltlen=6';	last SWITCH; };
 			$dynamic_args==82 && do {$fmt='sha512($p.$s)';				last SWITCH; };
@@ -1780,6 +1783,7 @@ sub dynamic_compile {
 			$dynamic_args==85 && do {$fmt='sha512(sha512($p).$s),saltlen=6';            last SWITCH; };
 			$dynamic_args==86 && do {$fmt='sha512($s.sha512($p)),saltlen=6';            last SWITCH; };
 			$dynamic_args==87 && do {$fmt='sha512(sha512($s).sha512($p)),saltlen=6';	last SWITCH; };
+			$dynamic_args==88 && do {$fmt='sha512(sha512($p).sha512($p))';				last SWITCH; };
 			$dynamic_args==90 && do {$fmt='gost($p)';					last SWITCH; };
 			$dynamic_args==91 && do {$fmt='gost($s.$p),saltlen=6';		last SWITCH; };
 			$dynamic_args==92 && do {$fmt='gost($p.$s)';				last SWITCH; };
@@ -1788,6 +1792,7 @@ sub dynamic_compile {
 			$dynamic_args==95 && do {$fmt='gost(gost($p).$s),saltlen=6';        last SWITCH; };
 			$dynamic_args==96 && do {$fmt='gost($s.gost($p)),saltlen=6';        last SWITCH; };
 			$dynamic_args==97 && do {$fmt='gost(gost($s).gost($p)),saltlen=6';	last SWITCH; };
+			$dynamic_args==98 && do {$fmt='gost(gost($p).gost($p))';			last SWITCH; };
 			$dynamic_args==100 && do {$fmt='whirlpool($p)';					last SWITCH; };
 			$dynamic_args==101 && do {$fmt='whirlpool($s.$p),saltlen=6';	last SWITCH; };
 			$dynamic_args==102 && do {$fmt='whirlpool($p.$s)';				last SWITCH; };
@@ -1796,6 +1801,7 @@ sub dynamic_compile {
 			$dynamic_args==105 && do {$fmt='whirlpool(whirlpool($p).$s),saltlen=6';				last SWITCH; };
 			$dynamic_args==106 && do {$fmt='whirlpool($s.whirlpool($p)),saltlen=6';				last SWITCH; };
 			$dynamic_args==107 && do {$fmt='whirlpool(whirlpool($s).whirlpool($p)),saltlen=6';	last SWITCH; };
+			$dynamic_args==108 && do {$fmt='whirlpool(whirlpool($p).whirlpool($p))';			last SWITCH; };
 			$dynamic_args==110 && do {$fmt='tiger($p)';					last SWITCH; };
 			$dynamic_args==111 && do {$fmt='tiger($s.$p),saltlen=6';	last SWITCH; };
 			$dynamic_args==112 && do {$fmt='tiger($p.$s)';				last SWITCH; };
@@ -1804,6 +1810,7 @@ sub dynamic_compile {
 			$dynamic_args==115 && do {$fmt='tiger(tiger($p).$s),saltlen=6';				last SWITCH; };
 			$dynamic_args==116 && do {$fmt='tiger($s.tiger($p)),saltlen=6';				last SWITCH; };
 			$dynamic_args==117 && do {$fmt='tiger(tiger($s).tiger($p)),saltlen=6';	last SWITCH; };
+			$dynamic_args==118 && do {$fmt='tiger(tiger($p).tiger($p))';			last SWITCH; };
 			$dynamic_args==120 && do {$fmt='ripemd128($p)';					last SWITCH; };
 			$dynamic_args==121 && do {$fmt='ripemd128($s.$p),saltlen=6';	last SWITCH; };
 			$dynamic_args==122 && do {$fmt='ripemd128($p.$s)';				last SWITCH; };
@@ -1812,6 +1819,7 @@ sub dynamic_compile {
 			$dynamic_args==125 && do {$fmt='ripemd128(ripemd128($p).$s),saltlen=6';				last SWITCH; };
 			$dynamic_args==126 && do {$fmt='ripemd128($s.ripemd128($p)),saltlen=6';				last SWITCH; };
 			$dynamic_args==127 && do {$fmt='ripemd128(ripemd128($s).ripemd128($p)),saltlen=6';	last SWITCH; };
+			$dynamic_args==128 && do {$fmt='ripemd128(ripemd128($p).ripemd128($p))';			last SWITCH; };
 			$dynamic_args==130 && do {$fmt='ripemd160($p)';					last SWITCH; };
 			$dynamic_args==131 && do {$fmt='ripemd160($s.$p),saltlen=6';	last SWITCH; };
 			$dynamic_args==132 && do {$fmt='ripemd160($p.$s)';				last SWITCH; };
@@ -1820,6 +1828,7 @@ sub dynamic_compile {
 			$dynamic_args==135 && do {$fmt='ripemd160(ripemd160($p).$s),saltlen=6';				last SWITCH; };
 			$dynamic_args==136 && do {$fmt='ripemd160($s.ripemd160($p)),saltlen=6';				last SWITCH; };
 			$dynamic_args==137 && do {$fmt='ripemd160(ripemd160($s).ripemd160($p)),saltlen=6';	last SWITCH; };
+			$dynamic_args==138 && do {$fmt='ripemd160(ripemd160($p).ripemd160($p))';			last SWITCH; };
 			$dynamic_args==140 && do {$fmt='ripemd256($p)';					last SWITCH; };
 			$dynamic_args==141 && do {$fmt='ripemd256($s.$p),saltlen=6';	last SWITCH; };
 			$dynamic_args==142 && do {$fmt='ripemd256($p.$s)';				last SWITCH; };
@@ -1828,6 +1837,7 @@ sub dynamic_compile {
 			$dynamic_args==145 && do {$fmt='ripemd256(ripemd256($p).$s),saltlen=6';				last SWITCH; };
 			$dynamic_args==146 && do {$fmt='ripemd256($s.ripemd256($p)),saltlen=6';				last SWITCH; };
 			$dynamic_args==147 && do {$fmt='ripemd256(ripemd256($s).ripemd256($p)),saltlen=6';	last SWITCH; };
+			$dynamic_args==148 && do {$fmt='ripemd256(ripemd256($p).ripemd256($p))';			last SWITCH; };
 			$dynamic_args==150 && do {$fmt='ripemd320($p)';			last SWITCH; };
 			$dynamic_args==151 && do {$fmt='ripemd320($s.$p),saltlen=6';	last SWITCH; };
 			$dynamic_args==152 && do {$fmt='ripemd320($p.$s)';				last SWITCH; };
@@ -1836,6 +1846,7 @@ sub dynamic_compile {
 			$dynamic_args==155 && do {$fmt='ripemd320(ripemd320($p).$s),saltlen=6';				last SWITCH; };
 			$dynamic_args==156 && do {$fmt='ripemd320($s.ripemd320($p)),saltlen=6';				last SWITCH; };
 			$dynamic_args==157 && do {$fmt='ripemd320(ripemd320($s).ripemd320($p)),saltlen=6';	last SWITCH; };
+			$dynamic_args==158 && do {$fmt='ripemd320(ripemd320($p).ripemd320($p))';			last SWITCH; };
 
 			# 7, 17, 19, 20, 21, 27, 28 are still handled by 'special' functions.
 
diff -urpN memdbg2/src/dynamic.h memdbg1/src/dynamic.h
--- memdbg2/src/dynamic.h	2013-05-15 04:30:35.968750000 -0500
+++ memdbg1/src/dynamic.h	2013-05-15 05:32:31.640625000 -0500
@@ -80,6 +80,8 @@ typedef struct DYNAMIC_Constants_t
 #define MGF_PASSWORD_UPCASE          0x08000000
 #define MGF_PASSWORD_LOCASE          0x10000000
 #define MGF_FULL_CLEAN_REQUIRED      0x20000000
+// open                              0x40000000
+// open                              0x80000000
 
 // These are special loader flags.  They specify that keys loads are 'special', and
 // do MORE than simply load keys into the keys[] array.  They may preload the keys
@@ -101,13 +103,24 @@ typedef struct DYNAMIC_Constants_t
 // the unicode_b4_crypt does a unicode convert, prior to crypt_in2, base16-in1, etc.  It can NOT be used with KEYS_INPUT.
 #define MGF_KEYS_UNICODE_B4_CRYPT        0x00001000
 #define MGF_SOURCE                       0x00002000
-#define MGF_INPUT_20_BYTE                0x00004000
-#define MGF_INPUT_24_BYTE                0x00008000
-#define MGF_INPUT_28_BYTE                0x00010000
-#define MGF_INPUT_32_BYTE                0x00020000
-#define MGF_INPUT_40_BYTE                0x00040000
-#define MGF_INPUT_48_BYTE                0x00080000
-#define MGF_INPUT_64_BYTE                0x00100000
+// open                                  0x00004000
+// open                                  0x00008000
+// open                                  0x00010000
+// open                                  0x00020000
+// open                                  0x00040000
+// open                                  0x00080000
+#define MGF_INPUT_20_BYTE                0x00100000
+#define MGF_INPUT_24_BYTE                0x00200000
+#define MGF_INPUT_28_BYTE                0x00400000
+#define MGF_INPUT_32_BYTE                0x00800000
+#define MGF_INPUT_40_BYTE                0x01000000
+#define MGF_INPUT_48_BYTE                0x02000000
+#define MGF_INPUT_64_BYTE                0x04000000
+// open                                  0x08000000
+// open                                  0x10000000
+// open                                  0x20000000
+// open                                  0x40000000
+// open                                  0x80000000
 
 typedef struct DYNAMIC_Setup_t
 {
@@ -211,6 +224,14 @@ extern void DynamicFunc__overwrite_salt_
 extern void DynamicFunc__append_input_from_input2(DYNA_OMP_PARAMS);
 extern void DynamicFunc__append_input2_from_input(DYNA_OMP_PARAMS);
 
+// NOTE, these are input=input+input and input2=input2+input2
+// (must be careful to not use strcat type stuff).  Added for types like
+// sha256(sha256($p).sha256($p)) so that we can still keep keys in input1,
+// and simply double the output of input2, without having to double compute
+// sha256($p)
+extern void DynamicFunc__append_input_from_input(DYNA_OMP_PARAMS);
+extern void DynamicFunc__append_input2_from_input2(DYNA_OMP_PARAMS);
+
 extern void DynamicFunc__append_2nd_salt(DYNA_OMP_PARAMS);
 extern void DynamicFunc__append_2nd_salt2(DYNA_OMP_PARAMS);
 extern void DynamicFunc__append_userid(DYNA_OMP_PARAMS);
diff -urpN memdbg2/src/dynamic_big_crypt.c memdbg1/src/dynamic_big_crypt.c
--- memdbg2/src/dynamic_big_crypt.c	2013-05-15 04:30:35.968750000 -0500
+++ memdbg1/src/dynamic_big_crypt.c	2013-05-14 23:29:09.015625000 -0500
@@ -2360,9 +2360,11 @@ void DynamicFunc__RIPEMD128_crypt_input2
 		total_len_X86[i] = large_hash_output_no_null(crypt_out, cpo, 16, tid);
 	}
 }
+// since this hash is only 128 bits also, the output 'fits' properly into
+// the crypt_key array, without using an intermediate buffer.
 void DynamicFunc__RIPEMD128_crypt_input1_to_output1_FINAL(DYNA_OMP_PARAMS) {
-	union xx { unsigned char u[16]; ARCH_WORD a[16/sizeof(ARCH_WORD)]; } u;
-	unsigned char *crypt_out=u.u;
+//	union xx { unsigned char u[16]; ARCH_WORD a[16/sizeof(ARCH_WORD)]; } u;
+//	unsigned char *crypt_out=u.u;
 	int i, til;
 	sph_ripemd128_context ctx;
 
@@ -2381,19 +2383,23 @@ void DynamicFunc__RIPEMD128_crypt_input1
 		else
 #endif
 			sph_ripemd128(&ctx, input_buf_X86[i>>MD5_X2].x1.B, total_len_X86[i]);
-		sph_ripemd128_close(&ctx, crypt_out);
+//		sph_ripemd128_close(&ctx, crypt_out);
 
 #if (MD5_X2)
 		if (i & 1)
-			memcpy(crypt_key_X86[i>>MD5_X2].x2.B2, crypt_out, 16);
+//			memcpy(crypt_key_X86[i>>MD5_X2].x2.B2, crypt_out, 16);
+			sph_ripemd128_close(&ctx, crypt_key_X86[i>>MD5_X2].x2.B2);
 		else
 #endif
-			memcpy(crypt_key_X86[i>>MD5_X2].x1.B, crypt_out, 16);
+//			memcpy(crypt_key_X86[i>>MD5_X2].x1.B, crypt_out, 16);
+			sph_ripemd128_close(&ctx, crypt_key_X86[i>>MD5_X2].x1.B);
 	}
 }
+// since this hash is only 128 bits also, the output 'fits' properly into
+// the crypt_key array, without using an intermediate buffer.
 void DynamicFunc__RIPEMD128_crypt_input2_to_output1_FINAL(DYNA_OMP_PARAMS) {
-	union xx { unsigned char u[16]; ARCH_WORD a[16/sizeof(ARCH_WORD)]; } u;
-	unsigned char *crypt_out=u.u;
+//	union xx { unsigned char u[16]; ARCH_WORD a[16/sizeof(ARCH_WORD)]; } u;
+//	unsigned char *crypt_out=u.u;
 	int i, til;
 	sph_ripemd128_context ctx;
 
@@ -2412,14 +2418,16 @@ void DynamicFunc__RIPEMD128_crypt_input2
 		else
 #endif
 			sph_ripemd128(&ctx, input_buf2_X86[i>>MD5_X2].x1.B, total_len2_X86[i]);
-		sph_ripemd128_close(&ctx, crypt_out);
+//		sph_ripemd128_close(&ctx, crypt_out);
 
 #if (MD5_X2)
 		if (i & 1)
-			memcpy(crypt_key_X86[i>>MD5_X2].x2.B2, crypt_out, 16);
+//			memcpy(crypt_key_X86[i>>MD5_X2].x2.B2, crypt_out, 16);
+		sph_ripemd128_close(&ctx, crypt_key_X86[i>>MD5_X2].x2.B2);
 		else
 #endif
-			memcpy(crypt_key_X86[i>>MD5_X2].x1.B, crypt_out, 16);
+			//memcpy(crypt_key_X86[i>>MD5_X2].x1.B, crypt_out, 16);
+			sph_ripemd128_close(&ctx, crypt_key_X86[i>>MD5_X2].x1.B);
 	}
 }
 
diff -urpN memdbg2/src/dynamic_fmt.c memdbg1/src/dynamic_fmt.c
--- memdbg2/src/dynamic_fmt.c	2013-05-15 04:30:35.984375000 -0500
+++ memdbg1/src/dynamic_fmt.c	2013-05-15 05:33:39.234375000 -0500
@@ -30,7 +30,6 @@
  *      from the end. This would allow crypt($s.$p) and crypt($p.s) to be optimized
  *      in the way of string loading, and many fewer buffer copies.  So dyna_1 could
  *      be optimized to something like:
-
  // dynamic_1  Joomla md5($p.$s)
 static DYNAMIC_primitive_funcp _Funcs_1[] =
 {
@@ -40,14 +39,24 @@ static DYNAMIC_primitive_funcp _Funcs_1[
 	DynamicFunc__crypt_md5,
 	NULL
 };
-
-WELL, the fixed size salt, it 'may' not be key for the MGF_PASS_BEFORE_FIXEDSALT, I think I can
-make that 'work' for variable sized salts.  But for the MGF_PASS_AFTER_FIXEDSALT, i.e. crypt($s.$p)
-the fixed size salt IS key.  I would like to store all PW's at salt_len offset in the buffer, and
-simply overwrite the first part of each buffer with the salt, never moving the password after the
-first time it is written. THEN it is very important this ONLY be allowed when we KNOW the salt length
-ahead of time.
-
+ *      WELL, the fixed size salt, it 'may' not be key for the MGF_PASS_BEFORE_FIXEDSALT,
+ *      I think I can make that 'work' for variable sized salts.  But for the
+ *      MGF_PASS_AFTER_FIXEDSALT, i.e. crypt($s.$p) the fixed size salt IS key.  I would
+ *      like to store all PW's at salt_len offset in the buffer, and simply overwrite the
+ *      first part of each buffer with the salt, never moving the password after the first
+ *      time it is written. THEN it is very important this ONLY be allowed when we KNOW
+ *      the salt length ahead of time.
+ *
+ *   2. The flat buffer length is getting 'tight'.  Right now the buffer length is
+ *      PLAINTEXT_LENGTH_X86+EX_BUF_LEN which is 124+136 == 260.  We currently have 
+ *      a couple of hashes that are 256 bytes long (sha512(sha512($p).sha512($p)) and
+ *      the same for whirlpool. This does not give much room for growth.  But these buffers
+ *      should not be made to be 'too' much larger than needed.  This is an issue that needs
+ *      to be looked into.
+ *
+ *   3. sha512(sha512($p).sha512($p) does tripple crypts when it should only do 2 of them.
+ *      need to create an append_input2_input2 and use it, I think.
+ *
  */
 
 #include <string.h>
@@ -456,8 +465,10 @@ static int valid(char *ciphertext, struc
 
 	if (cp[cipherTextLen] && cp[cipherTextLen] != '$')
 		return 0;
+// NOTE if looking at this in the future, this was not my fix.
 	if (strlen(&cp[cipherTextLen]) > SALT_SIZE)
 		return 0;
+// end NOTE.
 	if (pPriv->dynamic_FIXED_SALT_SIZE && ciphertext[pPriv->dynamic_SALT_OFFSET-1] != '$')
 		return 0;
 	if (pPriv->dynamic_FIXED_SALT_SIZE > 0 && strlen(&ciphertext[pPriv->dynamic_SALT_OFFSET]) != pPriv->dynamic_FIXED_SALT_SIZE) {
@@ -4151,6 +4162,87 @@ unsigned i, til;
 	}
 }
 
+void DynamicFunc__append_input_from_input(DYNA_OMP_PARAMS)
+{
+unsigned i, til;
+#ifdef _OPENMP
+	til = last;
+	i = first;
+#else
+	i = 0;
+	til = m_count;
+#endif
+#ifdef MMX_COEF
+	if (dynamic_use_sse==1) {
+		unsigned j, k;
+		til = (til+MMX_COEF-1)/MMX_COEF;
+		i /= MMX_COEF;
+		for (; i < til; ++i)
+		{
+			for (j = 0; j < MMX_COEF; ++j)
+			{
+				unsigned start_len = (total_len[i] >> ((32/MMX_COEF)*j)) & 0xFF;
+				for (k = 0; k < start_len; ++k)
+					input_buf[i].c[GETPOS((k+start_len), j)] = input_buf[i].c[GETPOS(k,j)];
+				input_buf[i].c[GETPOS((start_len+start_len), j)] = 0x80;
+				total_len[i] += ( start_len << ( ( (32/MMX_COEF) * j ) ));
+			}
+		}
+		return;
+	}
+#endif
+	for (; i < til; ++i)
+	{
+#if MD5_X2
+		if (i&1)
+			memcpy(&(input_buf_X86[i>>MD5_X2].x2.b2[total_len_X86[i]]), input_buf_X86[i>>MD5_X2].x2.b2, total_len_X86[i]);
+		else
+#endif
+		memcpy(&(input_buf_X86[i>>MD5_X2].x1.b[total_len_X86[i]]), input_buf_X86[i>>MD5_X2].x1.b, total_len_X86[i]);
+		total_len_X86[i] <<= 1;
+	}
+}
+void DynamicFunc__append_input2_from_input2(DYNA_OMP_PARAMS)
+{
+unsigned i, til;
+#ifdef _OPENMP
+	til = last;
+	i = first;
+#else
+	i = 0;
+	til = m_count;
+#endif
+#ifdef MMX_COEF
+	if (dynamic_use_sse==1) {
+		unsigned j, k;
+		til = (til+MMX_COEF-1)/MMX_COEF;
+		i /= MMX_COEF;
+		for (; i < til; ++i)
+		{
+			for (j = 0; j < MMX_COEF; ++j)
+			{
+				unsigned start_len = (total_len2[i] >> ((32/MMX_COEF)*j)) & 0xFF;
+				for (k = 0; k < start_len; ++k)
+					input_buf2[i].c[GETPOS((k+start_len), j)] = input_buf2[i].c[GETPOS(k,j)];
+				input_buf2[i].c[GETPOS((start_len+start_len), j)] = 0x80;
+				total_len2[i] += ( start_len << ( ( (32/MMX_COEF) * j ) ));
+			}
+		}
+		return;
+	}
+#endif
+	for (; i < til; ++i)
+	{
+#if MD5_X2
+		if (i&1)
+			memcpy(&(input_buf2_X86[i>>MD5_X2].x2.b2[total_len2_X86[i]]), input_buf2_X86[i>>MD5_X2].x2.b2, total_len2_X86[i]);
+		else
+#endif
+		memcpy(&(input_buf2_X86[i>>MD5_X2].x1.b[total_len2_X86[i]]), input_buf2_X86[i>>MD5_X2].x1.b, total_len2_X86[i]);
+		total_len2_X86[i] <<= 1;
+	}
+}
+
 #ifdef MD5_SSE_PARA
 static void SSE_Intrinsics_LoadLens(int side, int i)
 {
diff -urpN memdbg2/src/dynamic_parser.c memdbg1/src/dynamic_parser.c
--- memdbg2/src/dynamic_parser.c	2013-05-15 04:30:36.765625000 -0500
+++ memdbg1/src/dynamic_parser.c	2013-05-15 05:32:31.593750000 -0500
@@ -118,6 +118,8 @@ static Dynamic_Predicate_t Dynamic_Predi
 	{ "DynamicFunc__append_salt2", DynamicFunc__append_salt2 },
 	{ "DynamicFunc__append_input_from_input2", DynamicFunc__append_input_from_input2 },
 	{ "DynamicFunc__append_input2_from_input", DynamicFunc__append_input2_from_input },
+	{ "DynamicFunc__append_input_from_input", DynamicFunc__append_input_from_input },
+	{ "DynamicFunc__append_input2_from_input2", DynamicFunc__append_input2_from_input2 },
 	{ "DynamicFunc__append_2nd_salt", DynamicFunc__append_2nd_salt },
 	{ "DynamicFunc__append_2nd_salt2", DynamicFunc__append_2nd_salt2 },
 	{ "DynamicFunc__append_userid", DynamicFunc__append_userid },
diff -urpN memdbg2/src/dynamic_preloads.c memdbg1/src/dynamic_preloads.c
--- memdbg2/src/dynamic_preloads.c	2013-05-15 04:30:36.796875000 -0500
+++ memdbg1/src/dynamic_preloads.c	2013-05-15 06:45:21.640625000 -0500
@@ -92,6 +92,7 @@
 //dynamic_55 -->sha224(sha224($p).$s)
 //dynamic_56 -->sha224($s.sha224($p))
 //dynamic_57 -->sha224(sha224($s).sha224($p))
+//dynamic_58 -->sha224(sha224($p).sha224($p))
 	// Try to group sha256 here (from dyna-60 to dyna-69)
 //dynamic_60 -->sha256($p)
 //dynamic_61 -->sha256($s.$p)
@@ -101,6 +102,7 @@
 //dynamic_65 -->sha256(sha256($p).$s)
 //dynamic_66 -->sha256($s.sha256($p))
 //dynamic_67 -->sha256(sha256($s).sha256($p))
+//dynamic_68 -->sha256(sha256($p).sha256($p))
 	// Try to group sha384 here (from dyna-70 to dyna-79)
 //dynamic_70 -->sha384($p)
 //dynamic_71 -->sha384($s.$p)
@@ -110,6 +112,7 @@
 //dynamic_75 -->sha384(sha384($p).$s)
 //dynamic_76 -->sha384($s.sha384($p))
 //dynamic_77 -->sha384(sha384($s).sha384($p))
+//dynamic_78 -->sha384(sha384($p).sha384($p))
 	// Try to group sha512 here (from dyna-80 to dyna-89)
 //dynamic_80 -->sha512($p)
 //dynamic_81 -->sha512($s.$p)
@@ -119,6 +122,7 @@
 //dynamic_85 -->sha512(sha512($p).$s)
 //dynamic_86 -->sha512($s.sha512($p))
 //dynamic_87 -->sha512(sha512($s).sha512($p))
+//dynamic_88 -->sha512(sha512($p).sha512($p))
 	// Try to group GOST here (from dyna-90 to dyna-99)
 //dynamic_90 -->GOST($p)
 //dynamic_91 -->GOST($s.$p)
@@ -128,6 +132,7 @@
 //dynamic_95 -->GOST(GOST($p).$s)
 //dynamic_96 -->GOST($s.GOST($p))
 //dynamic_97 -->GOST(GOST($s).GOST($p))
+//dynamic_98 -->GOST(GOST($p).GOST($p))
 	// Try to group WHIRLPOOL here (from dyna-100 to dyna-109)
 //dynamic_100 -->WHIRLPOOL($p)
 //dynamic_101 -->WHIRLPOOL($s.$p)
@@ -137,6 +142,7 @@
 //dynamic_105 -->WHIRLPOOL(WHIRLPOOL($p).$s)
 //dynamic_106 -->WHIRLPOOL($s.WHIRLPOOL($p))
 //dynamic_107 -->WHIRLPOOL(WHIRLPOOL($s).WHIRLPOOL($p))
+//dynamic_108 -->WHIRLPOOL(WHIRLPOOL($p).WHIRLPOOL($p))
 	// Try to group Tiger here (from dyna-110 to dyna-119)
 //dynamic_110 -->Tiger($p)
 //dynamic_111 -->Tiger($s.$p)
@@ -146,6 +152,48 @@
 //dynamic_115 -->Tiger(Tiger($p).$s)
 //dynamic_116 -->Tiger($s.Tiger($p))
 //dynamic_117 -->Tiger(Tiger($s).Tiger($p))
+//dynamic_118 -->Tiger(Tiger($p).Tiger($p))
+	// Try to group RIPEMD128 here (from dyna-120 to dyna-129)
+//dynamic_120 -->RIPEMD128($p)
+//dynamic_121 -->RIPEMD128($s.$p)
+//dynamic_122 -->RIPEMD128($p.$s)
+//dynamic_123 -->RIPEMD128(RIPEMD128($p))
+//dynamic_124 -->RIPEMD128(RIPEMD128_raw($p))
+//dynamic_125 -->RIPEMD128(RIPEMD128($p).$s)
+//dynamic_126 -->RIPEMD128($s.RIPEMD128($p))
+//dynamic_127 -->RIPEMD128(RIPEMD128($s).RIPEMD128($p))
+//dynamic_128 -->RIPEMD128(RIPEMD128($p).RIPEMD128($p))
+	// Try to group RIPEMD160 here (from dyna-130 to dyna-139)
+//dynamic_130 -->RIPEMD160($p)
+//dynamic_131 -->RIPEMD160($s.$p)
+//dynamic_132 -->RIPEMD160($p.$s)
+//dynamic_133 -->RIPEMD160(RIPEMD160($p))
+//dynamic_134 -->RIPEMD160(RIPEMD160_raw($p))
+//dynamic_135 -->RIPEMD160(RIPEMD160($p).$s)
+//dynamic_136 -->RIPEMD160($s.RIPEMD160($p))
+//dynamic_137 -->RIPEMD160(RIPEMD160($s).RIPEMD160($p))
+//dynamic_138 -->RIPEMD160(RIPEMD160($p).RIPEMD160($p))
+	// Try to group RIPEMD256 here (from dyna-140 to dyna-149)
+//dynamic_140 -->RIPEMD256($p)
+//dynamic_141 -->RIPEMD256($s.$p)
+//dynamic_142 -->RIPEMD256($p.$s)
+//dynamic_143 -->RIPEMD256(RIPEMD256($p))
+//dynamic_144 -->RIPEMD256(RIPEMD256_raw($p))
+//dynamic_145 -->RIPEMD256(RIPEMD256($p).$s)
+//dynamic_146 -->RIPEMD256($s.RIPEMD256($p))
+//dynamic_147 -->RIPEMD256(RIPEMD256($s).RIPEMD256($p))
+//dynamic_148 -->RIPEMD256(RIPEMD256($p).RIPEMD256($p))
+	// Try to group RIPEMD320 here (from dyna-150 to dyna-159)
+//dynamic_150 -->RIPEMD320($p)
+//dynamic_151 -->RIPEMD320($s.$p)
+//dynamic_152 -->RIPEMD320($p.$s)
+//dynamic_153 -->RIPEMD320(RIPEMD320($p))
+//dynamic_154 -->RIPEMD320(RIPEMD320_raw($p))
+//dynamic_155 -->RIPEMD320(RIPEMD320($p).$s)
+//dynamic_156 -->RIPEMD320($s.RIPEMD320($p))
+//dynamic_157 -->RIPEMD320(RIPEMD320($s).RIPEMD320($p))
+//dynamic_158 -->RIPEMD320(RIPEMD320($p).RIPEMD320($p))
+
 
 static DYNAMIC_primitive_funcp _Funcs_0[] =
 {
@@ -1098,10 +1146,9 @@ static struct fmt_tests _Preloads_38[] =
 //	dynamic_50: sha224($p)
 static DYNAMIC_primitive_funcp _Funcs_50[] =
 {
+	//MGF_KEYS_INPUT
 	//MGF_INPUT_28_BYTE
 	//MGF_NOTSSE2Safe
-	DynamicFunc__clean_input,
-	DynamicFunc__append_keys,
 	DynamicFunc__SHA224_crypt_input1_to_output1_FINAL,
 	NULL
 };
@@ -1257,13 +1304,32 @@ static struct fmt_tests _Preloads_57[] =
 	{NULL}
 };
 
+//	dynamic_58: sha224(sha224($p).sha224($p))
+static DYNAMIC_primitive_funcp _Funcs_58[] =
+{
+	//MGF_INPUT_28_BYTE
+	//MGF_NOTSSE2Safe
+	//MGF_KEYS_IN_INPUT
+	DynamicFunc__clean_input2_kwik,
+	DynamicFunc__SHA224_crypt_input1_append_input2,
+	DynamicFunc__append_input2_from_input2,
+	DynamicFunc__SHA224_crypt_input2_to_output1_FINAL,
+	NULL
+};
+static struct fmt_tests _Preloads_58[] =
+{
+	{"$dynamic_58$960f782c001ed315755b7f42a6e36166b7cb580006633ef4bd6fcd10","test1"},
+	{"$dynamic_58$1f0ef052ea6496a941c9d28f502cd943de8dc42222ab105d6e5584bb","thatsworking"},
+	{"$dynamic_58$52fd68900d7f5e5388a0b94b6c3c68edddb98f6f4e9a9353babbf9d9","test3"},
+	{NULL}
+};
+
 //	dynamic_60: sha256($p)
 static DYNAMIC_primitive_funcp _Funcs_60[] =
 {
+	//MGF_KEYS_INPUT
 	//MGF_INPUT_32_BYTE
 	//MGF_NOTSSE2Safe
-	DynamicFunc__clean_input,
-	DynamicFunc__append_keys,
 	DynamicFunc__SHA256_crypt_input1_to_output1_FINAL,
 	NULL
 };
@@ -1418,14 +1484,32 @@ static struct fmt_tests _Preloads_67[] =
 	{NULL}
 };
 
+//	dynamic_68: sha256(sha256($p).sha256($p))
+static DYNAMIC_primitive_funcp _Funcs_68[] =
+{
+	//MGF_INPUT_32_BYTE
+	//MGF_NOTSSE2Safe
+	//MGF_KEYS_IN_INPUT
+	DynamicFunc__clean_input2_kwik,
+	DynamicFunc__SHA256_crypt_input1_append_input2,
+	DynamicFunc__append_input2_from_input2,
+	DynamicFunc__SHA256_crypt_input2_to_output1_FINAL,
+	NULL
+};
+static struct fmt_tests _Preloads_68[] =
+{
+	{"$dynamic_68$98866d999ba299056e0e79ba9137709a181fbccd230d6d3a6cc004da6e7bce83","test1"},
+	{"$dynamic_68$5ca7061b1da740429d107d42333214248a5ffa9fac9f506c3b20648c8b428c51","thatsworking"},
+	{"$dynamic_68$000b7a5fc83fa7fb1e405b836daf3488d00ac42cb7fc5a917840e91ddc651661","test3"},
+	{NULL}
+};
 
 //	dynamic_70: sha384($p)
 static DYNAMIC_primitive_funcp _Funcs_70[] =
 {
+	//MGF_KEYS_INPUT
 	//MGF_INPUT_48_BYTE
 	//MGF_NOTSSE2Safe
-	DynamicFunc__clean_input,
-	DynamicFunc__append_keys,
 	DynamicFunc__SHA384_crypt_input1_to_output1_FINAL,
 	NULL
 };
@@ -1580,14 +1664,32 @@ static struct fmt_tests _Preloads_77[] =
 	{NULL}
 };
 
+//	dynamic_78: sha384(sha384($p).sha384($p))
+static DYNAMIC_primitive_funcp _Funcs_78[] =
+{
+	//MGF_INPUT_48_BYTE
+	//MGF_NOTSSE2Safe
+	//MGF_KEYS_IN_INPUT
+	DynamicFunc__clean_input2_kwik,
+	DynamicFunc__SHA384_crypt_input1_append_input2,
+	DynamicFunc__append_input2_from_input2,
+	DynamicFunc__SHA384_crypt_input2_to_output1_FINAL,
+	NULL
+};
+static struct fmt_tests _Preloads_78[] =
+{
+	{"$dynamic_78$bcc4c9d333738be9668acee9859c53e137fd513185167df88eecf5cf91060a62164ea3570940a4ef4381300fcf232eba","test1"},
+	{"$dynamic_78$43afcdb29a6d23492573c8f3669e0f5d88d6ca5716448cd742b3622cb020af946c273d430818831d82f1c1e89516f1f7","thatsworking"},
+	{"$dynamic_78$5bf8faa92ad87edb31619442306c7652a7d1777fc1321a0cd40d91ffd7956a25be6321b606a824a3ce66dcf6de990698","test3"},
+	{NULL}
+};
 
 //	dynamic_80: sha512($p)
 static DYNAMIC_primitive_funcp _Funcs_80[] =
 {
+	//MGF_KEYS_INPUT
 	//MGF_INPUT_64_BYTE
 	//MGF_NOTSSE2Safe
-	DynamicFunc__clean_input,
-	DynamicFunc__append_keys,
 	DynamicFunc__SHA512_crypt_input1_to_output1_FINAL,
 	NULL
 };
@@ -1742,14 +1844,32 @@ static struct fmt_tests _Preloads_87[] =
 	{NULL}
 };
 
+//	dynamic_88: sha512(sha512($p).sha512($p))
+static DYNAMIC_primitive_funcp _Funcs_88[] =
+{
+	//MGF_INPUT_64_BYTE
+	//MGF_NOTSSE2Safe
+	//MGF_KEYS_IN_INPUT
+	DynamicFunc__clean_input2_kwik,
+	DynamicFunc__SHA512_crypt_input1_append_input2,
+	DynamicFunc__append_input2_from_input2,
+	DynamicFunc__SHA512_crypt_input2_to_output1_FINAL,
+	NULL
+};
+static struct fmt_tests _Preloads_88[] =
+{
+	{"$dynamic_88$e43a5ceccd814df1669b9f07f7f422932d5f9778cda0abbb5a169d0d5beda06744dd97b3947f288329f5f9c2db394dc2eae8c1f71e8b290c98c7e8545458aff3","test1"},
+	{"$dynamic_88$82bd38d8a52db824fedd8b7506b9e36ed4854aa2d71094771c9c9c32294d080fa488b67bac5c77ca10790f058199fe324e80f73ba61ca0877df9dcdfd1c66ba8","thatsworking"},
+	{"$dynamic_88$769412e26aff2ca3005ce84628d98a6681448909ced9980a0bea57ba6a1cbaa0403ac6bb213d267eeaefafad3103b0d1486e700c9521800f9d548f87046470f0","test3"},
+	{NULL}
+};
 
 //	dynamic_90: GOST($p)
 static DYNAMIC_primitive_funcp _Funcs_90[] =
 {
+	//MGF_KEYS_INPUT
 	//MGF_INPUT_32_BYTE
 	//MGF_NOTSSE2Safe
-	DynamicFunc__clean_input,
-	DynamicFunc__append_keys,
 	DynamicFunc__GOST_crypt_input1_to_output1_FINAL,
 	NULL
 };
@@ -1904,13 +2024,32 @@ static struct fmt_tests _Preloads_97[] =
 	{NULL}
 };
 
+//	dynamic_98: GOST(GOST($p).GOST($p))
+static DYNAMIC_primitive_funcp _Funcs_98[] =
+{
+	//MGF_INPUT_32_BYTE
+	//MGF_NOTSSE2Safe
+	//MGF_KEYS_IN_INPUT
+	DynamicFunc__clean_input2_kwik,
+	DynamicFunc__GOST_crypt_input1_append_input2,
+	DynamicFunc__append_input2_from_input2,
+	DynamicFunc__GOST_crypt_input2_to_output1_FINAL,
+	NULL
+};
+static struct fmt_tests _Preloads_98[] =
+{
+	{"$dynamic_98$6d7aa908db4df2e99abbb19d646c0d8b540152b8499fee0cd73f42f7dbee800c","test1"},
+	{"$dynamic_98$49571dcdde0820ac0115de5521f33e91f3fefda82bcf3a05bcc028596cfc531f","thatsworking"},
+	{"$dynamic_98$9a2eb6ae6fa23ab615f1014bbcb8119be20d474495ecc2ab18d51e08852629cc","test3"},
+	{NULL}
+};
+
 //	dynamic_100: WHIRLPOOL($p)
 static DYNAMIC_primitive_funcp _Funcs_100[] =
 {
+	//MGF_KEYS_INPUT
 	//MGF_INPUT_64_BYTE
 	//MGF_NOTSSE2Safe
-	DynamicFunc__clean_input,
-	DynamicFunc__append_keys,
 	DynamicFunc__WHIRLPOOL_crypt_input1_to_output1_FINAL,
 	NULL
 };
@@ -2066,13 +2205,32 @@ static struct fmt_tests _Preloads_107[]
 	{NULL}
 };
 
+//	dynamic_108: WHIRLPOOL(WHIRLPOOL($p).WHIRLPOOL($p))
+static DYNAMIC_primitive_funcp _Funcs_108[] =
+{
+	//MGF_INPUT_64_BYTE
+	//MGF_NOTSSE2Safe
+	//MGF_KEYS_IN_INPUT
+	DynamicFunc__clean_input2_kwik,
+	DynamicFunc__WHIRLPOOL_crypt_input1_append_input2,
+	DynamicFunc__append_input2_from_input2,
+	DynamicFunc__WHIRLPOOL_crypt_input2_to_output1_FINAL,
+	NULL
+};
+static struct fmt_tests _Preloads_108[] =
+{
+	{"$dynamic_108$b1d42b3a7a285847b5d8a9124a795a9c5309ae242ead410ab7aa2de0e5f1d954cf8bdc2650aa74a28761cd4e11af44a4e97532051569c3d00dfa261483ed409b","test1"},
+	{"$dynamic_108$1e61a931e292da1cf5fe665010eea990649fe19cbae9e12fb03751d0c0519ce23d154152f414df5a0a9d569e4aeca4c5bbc2f99705dd18cea22b79e4078e19ec","thatsworking"},
+	{"$dynamic_108$a7d50bf71a0d5b0d2797531156fd3acae63425ef55cd461c2cf4556518dcc102f5562d24794bc200e4c91434e40179df73b9cd7334056818d2af3f0ea90bfc36","test3"},
+	{NULL}
+};
+
 //	dynamic_110: Tiger($p)
 static DYNAMIC_primitive_funcp _Funcs_110[] =
 {
+	//MGF_KEYS_INPUT
 	//MGF_INPUT_24_BYTE
 	//MGF_NOTSSE2Safe
-	DynamicFunc__clean_input,
-	DynamicFunc__append_keys,
 	DynamicFunc__Tiger_crypt_input1_to_output1_FINAL,
 	NULL
 };
@@ -2228,12 +2386,31 @@ static struct fmt_tests _Preloads_117[]
 	{NULL}
 };
 
+//	dynamic_118: Tiger(Tiger($p).Tiger($p))
+static DYNAMIC_primitive_funcp _Funcs_118[] =
+{
+	//MGF_INPUT_24_BYTE
+	//MGF_NOTSSE2Safe
+	//MGF_KEYS_IN_INPUT
+	DynamicFunc__clean_input2_kwik,
+	DynamicFunc__Tiger_crypt_input1_append_input2,
+	DynamicFunc__append_input2_from_input2,
+	DynamicFunc__Tiger_crypt_input2_to_output1_FINAL,
+	NULL
+};
+static struct fmt_tests _Preloads_118[] =
+{
+	{"$dynamic_118$c4d8ae7ed634de780059f93dad2676fca5c83c2257c5bfbf","test1"},
+	{"$dynamic_118$3ae1b52c145a3899c099ae8c45b159ac65f8ca54a312af84","thatsworking"},
+	{"$dynamic_118$64d847ba02fb89902b9557a89a3c8c3e3474982001dc93f4","test3"},
+	{NULL}
+};
+
 //	dynamic_120: RIPEMD128($p)
 static DYNAMIC_primitive_funcp _Funcs_120[] =
 {
+	//MGF_KEYS_INPUT
 	//MGF_NOTSSE2Safe
-	DynamicFunc__clean_input,
-	DynamicFunc__append_keys,
 	DynamicFunc__RIPEMD128_crypt_input1_to_output1_FINAL,
 	NULL
 };
@@ -2382,13 +2559,31 @@ static struct fmt_tests _Preloads_127[]
 	{NULL}
 };
 
+//	dynamic_128: RIPEMD128(RIPEMD128($p).RIPEMD128($p))
+static DYNAMIC_primitive_funcp _Funcs_128[] =
+{
+	//MGF_NOTSSE2Safe
+	//MGF_KEYS_IN_INPUT
+	DynamicFunc__clean_input2_kwik,
+	DynamicFunc__RIPEMD128_crypt_input1_append_input2,
+	DynamicFunc__append_input2_from_input2,
+	DynamicFunc__RIPEMD128_crypt_input2_to_output1_FINAL,
+	NULL
+};
+static struct fmt_tests _Preloads_128[] =
+{
+	{"$dynamic_128$9fb0be59a61be9e674cf9e53de01f45a","test1"},
+	{"$dynamic_128$33572aa87db2991d504f0d5b3470fabb","thatsworking"},
+	{"$dynamic_128$b2a315b546b04a485f7ff925f8944494","test3"},
+	{NULL}
+};
+
 //	dynamic_130: RIPEMD160($p)
 static DYNAMIC_primitive_funcp _Funcs_130[] =
 {
+	//MGF_KEYS_INPUT
 	//MGF_INPUT_20_BYTE
 	//MGF_NOTSSE2Safe
-	DynamicFunc__clean_input,
-	DynamicFunc__append_keys,
 	DynamicFunc__RIPEMD160_crypt_input1_to_output1_FINAL,
 	NULL
 };
@@ -2544,14 +2739,32 @@ static struct fmt_tests _Preloads_137[]
 	{NULL}
 };
 
+//	dynamic_138: RIPEMD160(RIPEMD160($p).RIPEMD160($p))
+static DYNAMIC_primitive_funcp _Funcs_138[] =
+{
+	//MGF_INPUT_20_BYTE
+	//MGF_NOTSSE2Safe
+	//MGF_KEYS_IN_INPUT
+	DynamicFunc__clean_input2_kwik,
+	DynamicFunc__RIPEMD160_crypt_input1_append_input2,
+	DynamicFunc__append_input2_from_input2,
+	DynamicFunc__RIPEMD160_crypt_input2_to_output1_FINAL,
+	NULL
+};
+static struct fmt_tests _Preloads_138[] =
+{
+	{"$dynamic_138$d6a76d520f9f74aeca1fee22e961d74c916df334","test1"},
+	{"$dynamic_138$6d9543280c7f70bc612143d3980ff99367258d63","thatsworking"},
+	{"$dynamic_138$12fbe8a67372ea76ed786dc08f32a17f778ee695","test3"},
+	{NULL}
+};
 
 //	dynamic_140: RIPEMD256($p)
 static DYNAMIC_primitive_funcp _Funcs_140[] =
 {
+	//MGF_KEYS_INPUT
 	//MGF_INPUT_32_BYTE
 	//MGF_NOTSSE2Safe
-	DynamicFunc__clean_input,
-	DynamicFunc__append_keys,
 	DynamicFunc__RIPEMD256_crypt_input1_to_output1_FINAL,
 	NULL
 };
@@ -2703,13 +2916,32 @@ static struct fmt_tests _Preloads_147[]
 	{NULL}
 };
 
+//	dynamic_148: RIPEMD256(RIPEMD256($p).RIPEMD256($p))
+static DYNAMIC_primitive_funcp _Funcs_148[] =
+{
+	//MGF_INPUT_32_BYTE
+	//MGF_NOTSSE2Safe
+	//MGF_KEYS_IN_INPUT
+	DynamicFunc__clean_input2_kwik,
+	DynamicFunc__RIPEMD256_crypt_input1_append_input2,
+	DynamicFunc__append_input2_from_input2,
+	DynamicFunc__RIPEMD256_crypt_input2_to_output1_FINAL,
+	NULL
+};
+static struct fmt_tests _Preloads_148[] =
+{
+	{"$dynamic_148$2ba00db7b3f6acdc55ac34fe847907d68b730c48cbfcbcb1306592653b450133","test1"},
+	{"$dynamic_148$9c821fad9361d7c09df4a1191cbe22f451e1b2ebe03aa5a81c4bcc95471f484e","thatsworking"},
+	{"$dynamic_148$fc25f51bbc2edd52e8a16632053de02d13066a327fe951418c5ad91b936ff4c0","test3"},
+	{NULL}
+};
+
 //	dynamic_150: RIPEMD320($p)
 static DYNAMIC_primitive_funcp _Funcs_150[] =
 {
+	//MGF_KEYS_INPUT
 	//MGF_INPUT_40_BYTE
 	//MGF_NOTSSE2Safe
-	DynamicFunc__clean_input,
-	DynamicFunc__append_keys,
 	DynamicFunc__RIPEMD320_crypt_input1_to_output1_FINAL,
 	NULL
 };
@@ -2721,6 +2953,7 @@ static struct fmt_tests _Preloads_150[]
 	{NULL}
 };
 
+
 //	dynamic_151: RIPEMD320($s.$p)
 static DYNAMIC_primitive_funcp _Funcs_151[] =
 {
@@ -2866,6 +3099,26 @@ static struct fmt_tests _Preloads_157[]
 	{NULL}
 };
 
+//	dynamic_158: RIPEMD320(RIPEMD320($p).RIPEMD320($p))
+static DYNAMIC_primitive_funcp _Funcs_158[] =
+{
+	//MGF_INPUT_40_BYTE
+	//MGF_NOTSSE2Safe
+	//MGF_KEYS_IN_INPUT
+	DynamicFunc__clean_input2_kwik,
+	DynamicFunc__RIPEMD320_crypt_input1_append_input2,
+	DynamicFunc__append_input2_from_input2,
+	DynamicFunc__RIPEMD320_crypt_input2_to_output1_FINAL,
+	NULL
+};
+static struct fmt_tests _Preloads_158[] =
+{
+	{"$dynamic_158$083b9aed550cc2788fffbd07bd9a02b10b40edcb9357692942e2f6689c0c800005d09855d5a5a150","test1"},
+	{"$dynamic_158$e1d2e0183c05d0094a9986d9dcb0add0344fd401eb255b23cf84bb6d5321cb70669eb3ef7562972b","thatsworking"},
+	{"$dynamic_158$824aaade4d6e6441f8da3e8dd7549b70ece96c2d08035ed4cb71f1d5d5e2ba17db46f699bdff8b1e","test3"},
+	{NULL}
+};
+
 // Here is a 'dummy' constant array. This will be 'linked' to any dynamic format that does not have any constants.
 static DYNAMIC_Constants _ConstDefault[] =
 {
@@ -2941,104 +3194,115 @@ static DYNAMIC_Setup Setups[] =
 	{ "dynamic_37: sha1(lc($u).$p) (SMF)",      _Funcs_37,_Preloads_37,_ConstDefault, MGF_USERNAME, MGF_INPUT_20_BYTE, -23, 32 },
 	{ "dynamic_38: sha1($s.sha1($s.sha1($p))) (Wolt3BB)",  _Funcs_38,_Preloads_38,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_20_BYTE|MGF_NO_FLAG, -23, 40 },
 	// Try to group sha224 here (from dyna-50 to dyna-59)
-	{ "dynamic_50: sha224($p)",                  _Funcs_50,_Preloads_50,_ConstDefault, MGF_NOTSSE2Safe, MGF_INPUT_28_BYTE },
+	{ "dynamic_50: sha224($p)",                  _Funcs_50,_Preloads_50,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_28_BYTE },
 	{ "dynamic_51: sha224($s.$p)",               _Funcs_51,_Preloads_51,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_28_BYTE, -20, 35 },
 	{ "dynamic_52: sha224($p.$s)",               _Funcs_52,_Preloads_52,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_28_BYTE, -20, 35 },
-	{ "dynamic_53: sha224(sha224($p))",          _Funcs_53,_Preloads_53,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_28_BYTE, },
-	{ "dynamic_54: sha224(sha224_raw($p))",      _Funcs_54,_Preloads_54,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_28_BYTE, },
+	{ "dynamic_53: sha224(sha224($p))",          _Funcs_53,_Preloads_53,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_28_BYTE },
+	{ "dynamic_54: sha224(sha224_raw($p))",      _Funcs_54,_Preloads_54,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_28_BYTE },
 	{ "dynamic_55: sha224(sha224($p).$s)",       _Funcs_55,_Preloads_55,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_28_BYTE, -20, 35 },
 	{ "dynamic_56: sha224($s.sha224($p))",       _Funcs_56,_Preloads_56,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_28_BYTE, -20, 35 },
 	{ "dynamic_57: sha224(sha224($s).sha224($p))",_Funcs_57,_Preloads_57,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_28_BYTE, -20, 35 },
+	{ "dynamic_58: sha224(sha224($p).sha224($p))",_Funcs_58,_Preloads_58,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_28_BYTE },
 	// Try to group sha256 here (from dyna-60 to dyna-69)
-	{ "dynamic_60: sha256($p)",                  _Funcs_60,_Preloads_60,_ConstDefault, MGF_NOTSSE2Safe, MGF_INPUT_32_BYTE },
+	{ "dynamic_60: sha256($p)",                  _Funcs_60,_Preloads_60,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE },
 	{ "dynamic_61: sha256($s.$p)",               _Funcs_61,_Preloads_61,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_32_BYTE, -20, 35 },
 	{ "dynamic_62: sha256($p.$s)",               _Funcs_62,_Preloads_62,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_32_BYTE, -20, 35 },
-	{ "dynamic_63: sha256(sha256($p))",          _Funcs_63,_Preloads_63,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, },
-	{ "dynamic_64: sha256(sha256_raw($p))",      _Funcs_64,_Preloads_64,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, },
+	{ "dynamic_63: sha256(sha256($p))",          _Funcs_63,_Preloads_63,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE },
+	{ "dynamic_64: sha256(sha256_raw($p))",      _Funcs_64,_Preloads_64,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE },
 	{ "dynamic_65: sha256(sha256($p).$s)",       _Funcs_65,_Preloads_65,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, -20, 35 },
 	{ "dynamic_66: sha256($s.sha256($p))",       _Funcs_66,_Preloads_66,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, -20, 35 },
 	{ "dynamic_67: sha256(sha256($s).sha256($p))",_Funcs_67,_Preloads_67,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, -20, 35 },
+	{ "dynamic_68: sha256(sha256($p).sha256($p))",_Funcs_68,_Preloads_68,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE },
 	// Try to group sha384 here (from dyna-70 to dyna-79)
-	{ "dynamic_70: sha384($p)",                  _Funcs_70,_Preloads_70,_ConstDefault, MGF_NOTSSE2Safe, MGF_INPUT_48_BYTE },
+	{ "dynamic_70: sha384($p)",                  _Funcs_70,_Preloads_70,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_48_BYTE },
 	{ "dynamic_71: sha384($s.$p)",               _Funcs_71,_Preloads_71,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_48_BYTE, -20, 35 },
 	{ "dynamic_72: sha384($p.$s)",               _Funcs_72,_Preloads_72,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_48_BYTE, -20, 35 },
-	{ "dynamic_73: sha384(sha384($p))",          _Funcs_73,_Preloads_73,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_48_BYTE, },
-	{ "dynamic_74: sha384(sha384_raw($p))",      _Funcs_74,_Preloads_74,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_48_BYTE, },
+	{ "dynamic_73: sha384(sha384($p))",          _Funcs_73,_Preloads_73,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_48_BYTE },
+	{ "dynamic_74: sha384(sha384_raw($p))",      _Funcs_74,_Preloads_74,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_48_BYTE },
 	{ "dynamic_75: sha384(sha384($p).$s)",       _Funcs_75,_Preloads_75,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_48_BYTE, -20, 35 },
 	{ "dynamic_76: sha384($s.sha384($p))",       _Funcs_76,_Preloads_76,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_48_BYTE, -20, 35 },
 	{ "dynamic_77: sha384(sha384($s).sha384($p))",_Funcs_77,_Preloads_77,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_48_BYTE, -20, 35 },
+	{ "dynamic_78: sha384(sha384($p).sha384($p))",_Funcs_78,_Preloads_78,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_48_BYTE },
 	// Try to group sha512 here (from dyna-80 to dyna-89)
-	{ "dynamic_80: sha512($p)",                  _Funcs_80,_Preloads_80,_ConstDefault, MGF_NOTSSE2Safe, MGF_INPUT_64_BYTE },
+	{ "dynamic_80: sha512($p)",                  _Funcs_80,_Preloads_80,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE },
 	{ "dynamic_81: sha512($s.$p)",               _Funcs_81,_Preloads_81,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_64_BYTE, -20, 35 },
 	{ "dynamic_82: sha512($p.$s)",               _Funcs_82,_Preloads_82,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_64_BYTE, -20, 35 },
-	{ "dynamic_83: sha512(sha512($p))",          _Funcs_83,_Preloads_83,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE, },
-	{ "dynamic_84: sha512(sha512_raw($p))",      _Funcs_84,_Preloads_84,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE, },
+	{ "dynamic_83: sha512(sha512($p))",          _Funcs_83,_Preloads_83,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE },
+	{ "dynamic_84: sha512(sha512_raw($p))",      _Funcs_84,_Preloads_84,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE },
 	{ "dynamic_85: sha512(sha512($p).$s)",       _Funcs_85,_Preloads_85,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE, -20, 35 },
 	{ "dynamic_86: sha512($s.sha512($p))",       _Funcs_86,_Preloads_86,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE, -20, 35 },
 	{ "dynamic_87: sha512(sha512($s).sha512($p))",_Funcs_87,_Preloads_87,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE, -20, 35 },
+	{ "dynamic_88: sha512(sha512($p).sha512($p))",_Funcs_88,_Preloads_88,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE },
 	// Try to group GOST here (from dyna-90 to dyna-99)
-	{ "dynamic_90: GOST($p)",                    _Funcs_90,_Preloads_90,_ConstDefault, MGF_NOTSSE2Safe, MGF_INPUT_32_BYTE },
+	{ "dynamic_90: GOST($p)",                    _Funcs_90,_Preloads_90,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE },
 	{ "dynamic_91: GOST($s.$p)",                 _Funcs_91,_Preloads_91,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_32_BYTE, -20, 35 },
 	{ "dynamic_92: GOST($p.$s)",                 _Funcs_92,_Preloads_92,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_32_BYTE, -20, 35 },
-	{ "dynamic_93: GOST(GOST($p))",              _Funcs_93,_Preloads_93,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, },
-	{ "dynamic_94: GOST(GOST_raw($p))",          _Funcs_94,_Preloads_94,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, },
+	{ "dynamic_93: GOST(GOST($p))",              _Funcs_93,_Preloads_93,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE },
+	{ "dynamic_94: GOST(GOST_raw($p))",          _Funcs_94,_Preloads_94,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE },
 	{ "dynamic_95: GOST(GOST($p).$s)",           _Funcs_95,_Preloads_95,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, -20, 35 },
 	{ "dynamic_96: GOST($s.GOST($p))",           _Funcs_96,_Preloads_96,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, -20, 35 },
 	{ "dynamic_97: GOST(GOST($s).GOST($p))",     _Funcs_97,_Preloads_97,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, -20, 35 },
+	{ "dynamic_98: GOST(GOST($p).GOST($p))",     _Funcs_98,_Preloads_98,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE },
 	// Try to group WHIRLPOOL here (from dyna-100 to dyna-109)
-	{ "dynamic_100: WHIRLPOOL($p)",              _Funcs_100,_Preloads_100,_ConstDefault, MGF_NOTSSE2Safe, MGF_INPUT_64_BYTE },
+	{ "dynamic_100: WHIRLPOOL($p)",              _Funcs_100,_Preloads_100,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE },
 	{ "dynamic_101: WHIRLPOOL($s.$p)",           _Funcs_101,_Preloads_101,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_64_BYTE, -20, 35 },
 	{ "dynamic_102: WHIRLPOOL($p.$s)",           _Funcs_102,_Preloads_102,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_64_BYTE, -20, 35 },
-	{ "dynamic_103: WHIRLPOOL(WHIRLPOOL($p))",   _Funcs_103,_Preloads_103,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE, },
-	{ "dynamic_104: WHIRLPOOL(WHIRLPOOL_raw($p))",_Funcs_104,_Preloads_104,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE, },
+	{ "dynamic_103: WHIRLPOOL(WHIRLPOOL($p))",   _Funcs_103,_Preloads_103,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE },
+	{ "dynamic_104: WHIRLPOOL(WHIRLPOOL_raw($p))",_Funcs_104,_Preloads_104,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE },
 	{ "dynamic_105: WHIRLPOOL(WHIRLPOOL($p).$s)",_Funcs_105,_Preloads_105,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE, -20, 35 },
 	{ "dynamic_106: WHIRLPOOL($s.WHIRLPOOL($p))",_Funcs_106,_Preloads_106,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE, -20, 35 },
 	{ "dynamic_107: WHIRLPOOL(WHIRLPOOL($s).WHIRLPOOL($p))",_Funcs_107,_Preloads_107,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE, -20, 35 },
+	{ "dynamic_108: WHIRLPOOL(WHIRLPOOL($p).WHIRLPOOL($p))",_Funcs_108,_Preloads_108,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_64_BYTE },
 	// Try to group Tiger here (from dyna-110 to dyna-119)
-	{ "dynamic_110: Tiger($p)",                  _Funcs_110,_Preloads_110,_ConstDefault, MGF_NOTSSE2Safe, MGF_INPUT_24_BYTE },
+	{ "dynamic_110: Tiger($p)",                  _Funcs_110,_Preloads_110,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_24_BYTE },
 	{ "dynamic_111: Tiger($s.$p)",               _Funcs_111,_Preloads_111,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_24_BYTE, -20, 35 },
 	{ "dynamic_112: Tiger($p.$s)",               _Funcs_112,_Preloads_112,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_24_BYTE, -20, 35 },
-	{ "dynamic_113: Tiger(Tiger($p))",           _Funcs_113,_Preloads_113,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_24_BYTE, },
-	{ "dynamic_114: Tiger(Tiger_raw($p))",       _Funcs_114,_Preloads_114,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_24_BYTE, },
+	{ "dynamic_113: Tiger(Tiger($p))",           _Funcs_113,_Preloads_113,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_24_BYTE },
+	{ "dynamic_114: Tiger(Tiger_raw($p))",       _Funcs_114,_Preloads_114,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_24_BYTE },
 	{ "dynamic_115: Tiger(Tiger($p).$s)",        _Funcs_115,_Preloads_115,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_24_BYTE, -20, 35 },
 	{ "dynamic_116: Tiger($s.Tiger($p))",        _Funcs_116,_Preloads_116,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_24_BYTE, -20, 35 },
 	{ "dynamic_117: Tiger(Tiger($s).Tiger($p))", _Funcs_117,_Preloads_117,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_24_BYTE, -20, 35 },
+	{ "dynamic_118: Tiger(Tiger($p).Tiger($p))", _Funcs_118,_Preloads_118,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_24_BYTE },
 	// Try to group RIPEMD128 here (from dyna-120 to dyna-129)
-	{ "dynamic_120: RIPEMD128($p)",                  _Funcs_120,_Preloads_120,_ConstDefault, MGF_NOTSSE2Safe, MGF_NO_FLAG },
+	{ "dynamic_120: RIPEMD128($p)",                  _Funcs_120,_Preloads_120,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT },
 	{ "dynamic_121: RIPEMD128($s.$p)",               _Funcs_121,_Preloads_121,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_NO_FLAG, -20, 35 },
 	{ "dynamic_122: RIPEMD128($p.$s)",               _Funcs_122,_Preloads_122,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_NO_FLAG, -20, 35 },
-	{ "dynamic_123: RIPEMD128(RIPEMD128($p))",           _Funcs_123,_Preloads_123,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_NO_FLAG, },
-	{ "dynamic_124: RIPEMD128(RIPEMD128_raw($p))",       _Funcs_124,_Preloads_124,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_NO_FLAG, },
+	{ "dynamic_123: RIPEMD128(RIPEMD128($p))",           _Funcs_123,_Preloads_123,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_NO_FLAG },
+	{ "dynamic_124: RIPEMD128(RIPEMD128_raw($p))",       _Funcs_124,_Preloads_124,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_NO_FLAG },
 	{ "dynamic_125: RIPEMD128(RIPEMD128($p).$s)",        _Funcs_125,_Preloads_125,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_NO_FLAG, -20, 35 },
 	{ "dynamic_126: RIPEMD128($s.RIPEMD128($p))",        _Funcs_126,_Preloads_126,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_NO_FLAG, -20, 35 },
 	{ "dynamic_127: RIPEMD128(RIPEMD128($s).RIPEMD128($p))", _Funcs_127,_Preloads_127,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_NO_FLAG, -20, 35 },
+	{ "dynamic_128: RIPEMD128(RIPEMD128($p).RIPEMD128($p))", _Funcs_128,_Preloads_128,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_NO_FLAG },
 	// Try to group RIPEMD160 here (from dyna-130 to dyna-139)
-	{ "dynamic_130: RIPEMD160($p)",                  _Funcs_130,_Preloads_130,_ConstDefault, MGF_NOTSSE2Safe, MGF_INPUT_20_BYTE },
+	{ "dynamic_130: RIPEMD160($p)",                  _Funcs_130,_Preloads_130,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_20_BYTE },
 	{ "dynamic_131: RIPEMD160($s.$p)",               _Funcs_131,_Preloads_131,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_20_BYTE, -20, 35 },
 	{ "dynamic_132: RIPEMD160($p.$s)",               _Funcs_132,_Preloads_132,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_20_BYTE, -20, 35 },
-	{ "dynamic_133: RIPEMD160(RIPEMD160($p))",           _Funcs_133,_Preloads_133,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_20_BYTE, },
-	{ "dynamic_134: RIPEMD160(RIPEMD160_raw($p))",       _Funcs_134,_Preloads_134,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_20_BYTE, },
+	{ "dynamic_133: RIPEMD160(RIPEMD160($p))",           _Funcs_133,_Preloads_133,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_20_BYTE },
+	{ "dynamic_134: RIPEMD160(RIPEMD160_raw($p))",       _Funcs_134,_Preloads_134,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_20_BYTE },
 	{ "dynamic_135: RIPEMD160(RIPEMD160($p).$s)",        _Funcs_135,_Preloads_135,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_20_BYTE, -20, 35 },
 	{ "dynamic_136: RIPEMD160($s.RIPEMD160($p))",        _Funcs_136,_Preloads_136,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_20_BYTE, -20, 35 },
 	{ "dynamic_137: RIPEMD160(RIPEMD160($s).RIPEMD160($p))", _Funcs_137,_Preloads_137,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_20_BYTE, -20, 35 },
+	{ "dynamic_138: RIPEMD160(RIPEMD160($p).RIPEMD160($p))", _Funcs_138,_Preloads_138,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_20_BYTE },
 	// Try to group RIPEMD256 here (from dyna-140 to dyna-149)
-	{ "dynamic_140: RIPEMD256($p)",                  _Funcs_140,_Preloads_140,_ConstDefault, MGF_NOTSSE2Safe, MGF_INPUT_32_BYTE },
+	{ "dynamic_140: RIPEMD256($p)",                  _Funcs_140,_Preloads_140,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE },
 	{ "dynamic_141: RIPEMD256($s.$p)",               _Funcs_141,_Preloads_141,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_32_BYTE, -20, 35 },
 	{ "dynamic_142: RIPEMD256($p.$s)",               _Funcs_142,_Preloads_142,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_32_BYTE, -20, 35 },
-	{ "dynamic_143: RIPEMD256(RIPEMD256($p))",           _Funcs_143,_Preloads_143,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, },
-	{ "dynamic_144: RIPEMD256(RIPEMD256_raw($p))",       _Funcs_144,_Preloads_144,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, },
+	{ "dynamic_143: RIPEMD256(RIPEMD256($p))",           _Funcs_143,_Preloads_143,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE },
+	{ "dynamic_144: RIPEMD256(RIPEMD256_raw($p))",       _Funcs_144,_Preloads_144,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE },
 	{ "dynamic_145: RIPEMD256(RIPEMD256($p).$s)",        _Funcs_145,_Preloads_145,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, -20, 35 },
 	{ "dynamic_146: RIPEMD256($s.RIPEMD256($p))",        _Funcs_146,_Preloads_146,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, -20, 35 },
 	{ "dynamic_147: RIPEMD256(RIPEMD256($s).RIPEMD256($p))", _Funcs_147,_Preloads_147,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE, -20, 35 },
+	{ "dynamic_148: RIPEMD256(RIPEMD256($p).RIPEMD256($p))", _Funcs_148,_Preloads_148,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_32_BYTE },
 	// Try to group RIPEMD320 here (from dyna-150 to dyna-159)
-	{ "dynamic_150: RIPEMD320($p)",                  _Funcs_150,_Preloads_150,_ConstDefault, MGF_NOTSSE2Safe, MGF_INPUT_40_BYTE },
+	{ "dynamic_150: RIPEMD320($p)",                  _Funcs_150,_Preloads_150,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_40_BYTE },
 	{ "dynamic_151: RIPEMD320($s.$p)",               _Funcs_151,_Preloads_151,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_40_BYTE, -20, 35 },
 	{ "dynamic_152: RIPEMD320($p.$s)",               _Funcs_152,_Preloads_152,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_INPUT_40_BYTE, -20, 35 },
-	{ "dynamic_153: RIPEMD320(RIPEMD320($p))",           _Funcs_153,_Preloads_153,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_40_BYTE, },
-	{ "dynamic_154: RIPEMD320(RIPEMD320_raw($p))",       _Funcs_154,_Preloads_154,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_40_BYTE, },
+	{ "dynamic_153: RIPEMD320(RIPEMD320($p))",           _Funcs_153,_Preloads_153,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_40_BYTE },
+	{ "dynamic_154: RIPEMD320(RIPEMD320_raw($p))",       _Funcs_154,_Preloads_154,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_40_BYTE },
 	{ "dynamic_155: RIPEMD320(RIPEMD320($p).$s)",        _Funcs_155,_Preloads_155,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_40_BYTE, -20, 35 },
 	{ "dynamic_156: RIPEMD320($s.RIPEMD320($p))",        _Funcs_156,_Preloads_156,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_40_BYTE, -20, 35 },
 	{ "dynamic_157: RIPEMD320(RIPEMD320($s).RIPEMD320($p))", _Funcs_157,_Preloads_157,_ConstDefault, MGF_SALTED|MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_40_BYTE, -20, 35 },
+	{ "dynamic_158: RIPEMD320(RIPEMD320($p).RIPEMD320($p))", _Funcs_158,_Preloads_158,_ConstDefault, MGF_NOTSSE2Safe, MGF_KEYS_INPUT|MGF_INPUT_40_BYTE },
 };
 
 char *dynamic_PRELOAD_SIGNATURE(int cnt)
diff -urpN memdbg2/src/dynamic_types.h memdbg1/src/dynamic_types.h
--- memdbg2/src/dynamic_types.h	2013-05-15 04:30:36.828125000 -0500
+++ memdbg1/src/dynamic_types.h	2013-05-15 06:54:14.359375000 -0500
@@ -35,6 +35,10 @@ typedef ARCH_WORD_32 MD5_word;
 // NOTE, this was flushed out by the max password sized stuff in format self test code, but
 // this IS the size needed to avoid overflows.  126 'would' be large enough. We go a bit over
 // this.  NOTE, if we are using md5_go any more, we would need to expand this even more.
+// Right now, we have type dynamic_107: WHIRLPOOL(WHIRLPOOL($s).WHIRLPOOL($p)) and
+// dynamic_87: sha512(sha512($s).sha512($p)) which both require a 257 byte buffer.  We
+// have only a 260 byte buffer, so it is barely large enough for those. This would be
+// nowhere near large enough to use for md5_go code any more.
 #define EX_BUF_LEN 136
 
 
@@ -54,12 +58,6 @@ typedef struct {
 	}x2;
 #endif
 } MD5_OUT;
-typedef union {
-	double dummy;
-	MD5_word w[5];
-	char b[20];
-	unsigned char B[16];
-} SHA1_OUT;
 
 typedef struct {
 	union {
diff -urpN memdbg2/src/ripemd_plug.c memdbg1/src/ripemd_plug.c
--- memdbg2/src/ripemd_plug.c	2013-05-15 04:30:39.375000000 -0500
+++ memdbg1/src/ripemd_plug.c	2013-05-14 23:12:03.265625000 -0500
@@ -287,7 +287,7 @@ void
 sph_ripemd_close(void *cc, void *dst)
 {
 	ripemd_close(cc, dst, 4);
-	sph_ripemd_init(cc);
+	//sph_ripemd_init(cc);
 }
 
 /* see sph_ripemd.h */
@@ -611,7 +611,7 @@ void
 sph_ripemd128_close(void *cc, void *dst)
 {
 	ripemd128_close(cc, dst, 4);
-	sph_ripemd128_init(cc);
+	//sph_ripemd128_init(cc);
 }
 
 /* see sph_ripemd.h */
@@ -638,7 +638,7 @@ void
 sph_ripemd256_close(void *cc, void *dst)
 {
 	ripemd256_close(cc, dst, 8);
-	sph_ripemd256_init(cc);
+	//sph_ripemd256_init(cc);
 }
 
 /* see sph_ripemd.h */
@@ -896,8 +896,8 @@ sph_ripemd256_comp(const sph_u32 msg[16]
 		ROUND2(C, D, E, A, B, F1, 11, in( 9),  5); \
 		ROUND2(B, C, D, E, A, F1, 11, in(11),  5); \
  \
-		if (_320) { \
-		tmp = E1; E1 = E2; E2 = tmp; \
+		/* we do not swap here, but swap in the next block*/ /*if (_320)*/ { \
+		/*tmp = E1; E1 = E2; E2 = tmp;*/ \
 		} \
  \
 		if (_320) { \
@@ -905,12 +905,12 @@ sph_ripemd256_comp(const sph_u32 msg[16]
 		(h)[1] = SPH_T32((h)[1] + B1); \
 		(h)[2] = SPH_T32((h)[2] + C1); \
 		(h)[3] = SPH_T32((h)[3] + D1); \
-		(h)[4] = SPH_T32((h)[4] + E1); \
+		(h)[4] = SPH_T32((h)[4] + E2); /*Swapped with E1*/ \
 		(h)[5] = SPH_T32((h)[5] + A2); \
 		(h)[6] = SPH_T32((h)[6] + B2); \
 		(h)[7] = SPH_T32((h)[7] + C2); \
 		(h)[8] = SPH_T32((h)[8] + D2); \
-		(h)[9] = SPH_T32((h)[9] + E2); \
+		(h)[9] = SPH_T32((h)[9] + E1); /*Swapped with E2*/\
 		} else { \
 		tmp = SPH_T32((h)[1] + C1 + D2); \
 		(h)[1] = SPH_T32((h)[2] + D1 + E2); \
@@ -973,7 +973,7 @@ void
 sph_ripemd160_close(void *cc, void *dst)
 {
 	ripemd160_close(cc, dst, 5);
-	sph_ripemd160_init(cc);
+	//sph_ripemd160_init(cc);
 }
 
 void
@@ -1037,7 +1037,7 @@ void
 sph_ripemd320_close(void *cc, void *dst)
 {
 	ripemd320_close(cc, dst, 10);
-	sph_ripemd320_init(cc);
+	//sph_ripemd320_init(cc);
 }
 
 void