diff -urpN jumbo-bleed1/doc/DYNAMIC jumbo-bleed0/doc/DYNAMIC
--- jumbo-bleed1/doc/DYNAMIC	2012-07-02 21:59:23.078125000 +0000
+++ jumbo-bleed0/doc/DYNAMIC	2012-07-02 18:44:20.656250000 +0000
@@ -802,12 +802,34 @@ examples (this whole list is also found
 #
 ####################################################################
 #
+#   SaltLenX86=# line   (Optional, but required IF the format needs it)
+#
+#################
+#
+#  This is almost never needed.  But if needed to have a different
+#  salt size on non-MMX/SSE builds, then this is how to do it.
+#
+####################################################################
+#
 #   MaxInputLen=# line   (Optional, but required IF the format needs it)
 #
 #################
 #
 #  If a format has a 'max' length of password (such as Cisco PIX has
-#  a max length of 16 byte PW), then this must be set.
+#  a max length of 16 byte PW), then this must be set.  If this is
+#  not set, then the format will have a max password allowed to be
+#  55-abs(saltlen)  (80-abs(saltlen) if not an SSE/MMX build)
+#
+####################################################################
+#
+#   MaxInputLenX86=# line   (Optional, but required IF the format needs it)
+#
+#################
+#
+#  Similar to the SaltLenX86, in that it allows a different password 
+#  length to be force set in non-SSE builds.  So if a format should
+#  ONLY have 16 byte passwords, and no salt, then you would need
+#  to set MaxInputLen=16  and have a MaxInputLenX86=16 set also.
 #
 ####################################################################
 #
diff -urpN jumbo-bleed1/run/dynamic.conf jumbo-bleed0/run/dynamic.conf
--- jumbo-bleed1/run/dynamic.conf	2012-07-02 21:59:29.843750000 +0000
+++ jumbo-bleed0/run/dynamic.conf	2012-07-02 19:52:09.593750000 +0000
@@ -177,24 +177,16 @@ Test=$dynamic_1006$e9d38522b5eeec753332e
 Expression=md5(md5($p).$s) (vBulletin)
 # Flag needed here, is Salt.  There is no 'fixed' saltlen.
 Flag=MGF_SALTED
-Flag=MGF_ColonNOTValid
 Flag=MGF_KEYS_BASE16_IN1
 # vBulletin has a 'fixed' 3 byte salt, so list the fixed size
 SaltLen=3
-ColonChar=;
 # here is the optimized 'script' to perform vBulletin hash
 Func=DynamicFunc__set_input_len_32
 Func=DynamicFunc__append_salt
 Func=DynamicFunc__crypt_md5
-# NOTE, vBulletin is setup to 'override' the ':'.  USUALLY, it is good to use something
-# outside of the ASCII values from 0x20 to 0x7F.  0x1F is a 'good' choice, but it will
-# cause john.conf to have a 'non-normal' ASCII char.  Thus for this 'simple' example, I
-# have used the ';' character.  NOTE this would have the same 'problems' as the ':' character
-# if used for real, since ; is also a valid character within the salt of vBulletin.
-# NOTE to run, you MUST use the command line switch:   -field-separator-char=;
-Test=$dynamic_1007$daa61d77e218e42060c2fa198ac1feaf$SXB;test1
-Test=$dynamic_1007$de56b00bb15d6db79204bd44383469bc$T &;thatsworking
-Test=$dynamic_1007$fb685c6f469f6e549c85e4c1fb5a65a6$\\H:;test3
+Test=$dynamic_1007$daa61d77e218e42060c2fa198ac1feaf$SXB:test1
+Test=$dynamic_1007$de56b00bb15d6db79204bd44383469bc$T &:thatsworking
+Test=$dynamic_1007$fb685c6f469f6e549c85e4c1fb5a65a6$HEX$5C483A:test3
 
 ####################################################################
 # Dynamic type for algorithm used in RADIUS User-Password attrinute md5($p.$s)
@@ -222,6 +214,7 @@ Test=$dynamic_1008$658bbf9f04538d6bede09
 [List.Generic:dynamic_1009]
 Expression=md5($s.$p) (RADIUS Responses)
 Flag=MGF_SALTED
+Saltlen=-16
 Func=DynamicFunc__clean_input
 Func=DynamicFunc__append_salt
 Func=DynamicFunc__append_keys
diff -urpN jumbo-bleed1/src/dynamic.h jumbo-bleed0/src/dynamic.h
--- jumbo-bleed1/src/dynamic.h	2012-07-02 21:59:38.687500000 +0000
+++ jumbo-bleed0/src/dynamic.h	2012-07-02 19:06:59.640625000 +0000
@@ -100,12 +100,15 @@ typedef struct DYNAMIC_Setup_t
 	DYNAMIC_Constants *pConstants;
 	unsigned flags;
 	unsigned startFlags;
-	int SaltLen;
-	int MaxInputLen;
+	int SaltLen;			// these are SSE lengths
+	int MaxInputLen;		// SSE length.  If 0, then set to 55-abs(SaltLen)
+	int MaxInputLenX86;		// if zero, then use PW len set to 80-abs(SaltLen) (or 80-abs(SaltLenX86), if it is not 0)
+	int SaltLenX86;			// if zero, then use salt len of SSE
 } DYNAMIC_Setup;
 
 int dynamic_SETUP(DYNAMIC_Setup *, struct fmt_main *pFmt);
 int dynamic_IS_VALID(int i);
+int dynamic_real_salt_length(struct fmt_main *pFmt);
 void dynamic_RESET(struct fmt_main *);
 void dynamic_DISPLAY_ALL_FORMATS();
 
diff -urpN jumbo-bleed1/src/dynamic_fmt.c jumbo-bleed0/src/dynamic_fmt.c
--- jumbo-bleed1/src/dynamic_fmt.c	2012-07-02 21:59:38.718750000 +0000
+++ jumbo-bleed0/src/dynamic_fmt.c	2012-07-02 19:13:38.640625000 +0000
@@ -833,7 +833,7 @@ static void init(struct fmt_main *pFmt)
 	if (curdat.input2_set_len32) {
 		for (i = 0; i < MAX_KEYS_PER_CRYPT_X86; ++i)
 			total_len2_X86[i] = 32;
-#ifdef MMX_COEF
+#ifdef MMX_COEF 
 		for (i = 0; i < BLOCK_LOOPS; ++i) {
 			input_buf2[i][GETPOS(32,0)] = 0x80;
 			input_buf2[i][GETPOS(57,0)] = 0x1;
@@ -7161,14 +7161,20 @@ int dynamic_SETUP(DYNAMIC_Setup *Setup,
 		}
 	}
 
-#ifdef MMX_COEF
-		pFmt->params.plaintext_length = PLAINTEXT_LENGTH;
-#else
-		pFmt->params.plaintext_length = PLAINTEXT_LENGTH_X86;
-#endif
-
 	if (Setup->MaxInputLen)
 		pFmt->params.plaintext_length = Setup->MaxInputLen;
+	else
+		pFmt->params.plaintext_length = 55 - abs(Setup->SaltLen);
+#ifndef MMX_COEF
+	if (Setup->MaxInputLenX86) {
+		pFmt->params.plaintext_length = Setup->MaxInputLenX86;
+	} else {
+		if (Setup->SaltLenX86)
+			pFmt->params.plaintext_length = 80 - abs(Setup->SaltLenX86);
+		else
+			pFmt->params.plaintext_length = 80 - abs(Setup->SaltLen);
+	}
+#endif
 
 	curdat.store_keys_in_input = !!(Setup->startFlags&MGF_KEYS_INPUT );
 	curdat.input2_set_len32 = !!(Setup->startFlags&MGF_SET_INP2LEN32);
@@ -7497,6 +7503,9 @@ static int LoadOneFormat(int idx, struct
 	memcpy(pFmt, &fmt_Dynamic, sizeof(struct fmt_main));
 	dynamic_RESET(pFmt);
 
+	// Ok we need to list this as a dynamic format (even for the 'thin' formats)
+	pFmt->params.flags |= FMT_DYNAMIC;
+
 	if (idx < 1000) {
 		if (dynamic_RESERVED_PRELOAD_SETUP(idx, pFmt) != 1)
 			return 0;
@@ -7539,7 +7548,7 @@ static int LoadOneFormat(int idx, struct
 
 	if (strncmp(curdat.dynamic_WHICH_TYPE_SIG, pFmt->params.tests[0].ciphertext, strlen(curdat.dynamic_WHICH_TYPE_SIG)))
 	{
-		fprintf(stderr, "ERROR, when loading dynamic formats, the wrong curdat item was linked to this type:\nTYPE_SIG=%s\nTest_Dat=%s\n",
+		fprintf(stderr, "ERROR, when loading dynamic formats, the wrong curdat item was linked to this type:\nTYPE_SIG=%s\nTest_Dat=%s\n", 
 				curdat.dynamic_WHICH_TYPE_SIG, pFmt->params.tests[0].ciphertext);
 	}
 	return 1;
@@ -7746,3 +7755,14 @@ static char *HandleCase(char *cp, int ca
 	}
 	return (char*)dest;
 }
+
+int dynamic_real_salt_length(struct fmt_main *pFmt) {
+	if (pFmt->params.flags & FMT_DYNAMIC) {
+		private_subformat_data *pPriv = pFmt->private.data;
+		if (pPriv == NULL || pPriv->pSetup == NULL)
+			return -1;  // not a dynamic format, or called before we have loaded them!!
+		return abs(pPriv->pSetup->SaltLen);
+	}
+	// NOT a dynamic format
+	return -1;
+}
diff -urpN jumbo-bleed1/src/dynamic_parser.c jumbo-bleed0/src/dynamic_parser.c
--- jumbo-bleed1/src/dynamic_parser.c	2012-07-02 21:59:38.734375000 +0000
+++ jumbo-bleed0/src/dynamic_parser.c	2012-07-02 20:36:58.031250000 +0000
@@ -522,12 +522,24 @@ int dynamic_LOAD_PARSER_FUNCTIONS_LoadLI
 			return 1;
 		return !fprintf(stderr, "Error, Invalid SaltLen= line:  %s  \n", Line);
 	}
+	if (c == 's' && !strncasecmp(Line, "SaltLenX86=", 11))
+	{
+		if (sscanf(&Line[10], "=%d", &pSetup->SaltLenX86) == 1)
+			return 1;
+		return !fprintf(stderr, "Error, Invalid SaltLenX86= line:  %s  \n", Line);
+	}
 	if (c == 'm' && !strncasecmp(Line, "MaxInputLen=", 12))
 	{
 		if (sscanf(&Line[11], "=%d", &pSetup->MaxInputLen) == 1)
 			return 1;
 		return !fprintf(stderr, "Error, Invalid MaxInputLen= line:  %s  \n", Line);
 	}
+	if (c == 'm' && !strncasecmp(Line, "MaxInputLenX86=", 15))
+	{
+		if (sscanf(&Line[14], "=%d", &pSetup->MaxInputLenX86) == 1)
+			return 1;
+		return !fprintf(stderr, "Error, Invalid MaxInputLenX86= line:  %s  \n", Line);
+	}
 	if (c == 'e' && !strncasecmp(Line, "Expression=", 11))
 	{
 		char tmp[256];
@@ -626,7 +638,7 @@ int dynamic_LOAD_PARSER_FUNCTIONS(int wh
 	nPreloadCnt = 0;
 	nFuncCnt = 0;
 
-	pSetup = mem_alloc_tiny(sizeof(DYNAMIC_Setup), MEM_ALIGN_NONE);
+	pSetup = mem_calloc_tiny(sizeof(DYNAMIC_Setup), MEM_ALIGN_NONE);
 
 	if (!dynamic_LOAD_PARSER_SIGNATURE(which))
 	{
diff -urpN jumbo-bleed1/src/dynamic_preloads.c jumbo-bleed0/src/dynamic_preloads.c
--- jumbo-bleed1/src/dynamic_preloads.c	2012-07-02 21:59:38.734375000 +0000
+++ jumbo-bleed0/src/dynamic_preloads.c	2012-07-02 20:34:00.140625000 +0000
@@ -46,7 +46,7 @@
 //dynamic_4 --> md5($s.$p)  (osCommerce MD5 2 byte salt)
 //dynamic_5 --> md5($s.$p.$s)
 //dynamic_6 --> md5(md5($p).$s)
-//dynamic_7 --> md5(md5($p).$s) vBulletin  (fixed 3 byte salt, colon not valid as field sep, since all chars from 0x20 to 0x7E are in the salt)
+   // DEPRICATED  //dynamic_7 --> md5(md5($p).$s) vBulletin  (fixed 3 byte salt, colon not valid as field sep, since all chars from 0x20 to 0x7E are in the salt)
 //dynamic_8 --> md5(md5($s).$p)
 //dynamic_9 --> md5($s.md5($p))
 //dynamic_10 --> md5($s.md5($s.$p))
@@ -214,6 +214,7 @@ static struct fmt_tests _Preloads_6[] =
 	{NULL}
 };
 
+#if 0
 //dynamic_7 --> md5(md5($p).$s) vBulletin  (forced 3 byte salt, valid chars from 0x20 to 0x7E)
 static DYNAMIC_primitive_funcp _Funcs_7[] =
 {
@@ -238,6 +239,7 @@ static struct fmt_tests _Preloads_7[] =
 	{"$dynamic_7$fb685c6f469f6e549c85e4c1fb5a65a6$\\H:","test3"},
 	{NULL}
 };
+#endif
 
 //dynamic_8 --> md5(md5($s).$p)
 static DYNAMIC_primitive_funcp _Funcs_8[] =
@@ -866,72 +868,51 @@ static DYNAMIC_Constants _ConstDefault[]
 static DYNAMIC_Setup Setups[] =
 {
 	{ "dynamic_0: md5($p) (raw-md5)",           _Funcs_0, _Preloads_0, _ConstDefault, MGF_NO_FLAG, MGF_KEYS_INPUT|MGF_GET_SOURCE },
-#if defined (MMX_COEF)
-	{ "dynamic_1: md5($p.$s) (joomla)",         _Funcs_1, _Preloads_1, _ConstDefault, MGF_SALTED, MGF_NO_FLAG, -32, 23 },
-#else
-	{ "dynamic_1: md5($p.$s) (joomla)",         _Funcs_1, _Preloads_1, _ConstDefault, MGF_SALTED },
-#endif
+	{ "dynamic_1: md5($p.$s) (joomla)",         _Funcs_1, _Preloads_1, _ConstDefault, MGF_SALTED, MGF_NO_FLAG, -32 },
 	{ "dynamic_2: md5(md5($p)) (e107)",         _Funcs_2, _Preloads_2, _ConstDefault, MGF_NO_FLAG, MGF_KEYS_INPUT|MGF_SET_INP2LEN32 },
-	{ "dynamic_3: md5(md5(md5($p)))",            _Funcs_3, _Preloads_3, _ConstDefault, MGF_NO_FLAG, MGF_KEYS_INPUT|MGF_SET_INP2LEN32 },
-#if defined (MMX_COEF)
-	{ "dynamic_4: md5($s.$p) (OSC)",            _Funcs_4, _Preloads_4, _ConstDefault, MGF_SALTED, MGF_NO_FLAG, -24, 31  },
-	{ "dynamic_5: md5($s.$p.$s)",                _Funcs_5, _Preloads_5, _ConstDefault, MGF_SALTED, MGF_NO_FLAG, -12, 31  },
-	{ "dynamic_6: md5(md5($p).$s)",              _Funcs_6, _Preloads_6, _ConstDefault, MGF_SALTED, MGF_KEYS_BASE16_IN1, -23 },
-#else
-	{ "dynamic_4: md5($s.$p) (OSC)",            _Funcs_4, _Preloads_4, _ConstDefault, MGF_SALTED },
-	{ "dynamic_5: md5($s.$p.$s)",                _Funcs_5, _Preloads_5, _ConstDefault, MGF_SALTED },
-	{ "dynamic_6: md5(md5($p).$s)",              _Funcs_6, _Preloads_6, _ConstDefault, MGF_SALTED, MGF_KEYS_BASE16_IN1 },
-#endif
-	{ "dynamic_7: md5(md5($p).$s) (vBulletin)", _Funcs_7, _Preloads_7, _ConstDefault, MGF_SALTED|MGF_ColonNOTValid, MGF_KEYS_BASE16_IN1, 3 },
-	{ "dynamic_8: md5(md5($s).$p)",              _Funcs_8, _Preloads_8, _ConstDefault, MGF_SALTED|MGF_SALT_AS_HEX, MGF_NO_FLAG, -1,  23},
-#if defined (MMX_COEF)
-	{ "dynamic_9: md5($s.md5($p))",              _Funcs_9, _Preloads_9, _ConstDefault, MGF_SALTED, MGF_KEYS_BASE16_IN1, -23 },
-	{ "dynamic_10: md5($s.md5($s.$p))",          _Funcs_10,_Preloads_10,_ConstDefault, MGF_SALTED, MGF_NO_FLAG, -24, 31 },
-	{ "dynamic_11: md5($s.md5($p.$s))",          _Funcs_11,_Preloads_11,_ConstDefault, MGF_SALTED, MGF_NO_FLAG, -24, 31 },
-#else
-	{ "dynamic_9: md5($s.md5($p))",              _Funcs_9, _Preloads_9, _ConstDefault, MGF_SALTED, MGF_KEYS_BASE16_IN1 },
-	{ "dynamic_10: md5($s.md5($s.$p))",          _Funcs_10,_Preloads_10,_ConstDefault, MGF_SALTED },
-	{ "dynamic_11: md5($s.md5($p.$s))",          _Funcs_11,_Preloads_11,_ConstDefault, MGF_SALTED },
-#endif
-	{ "dynamic_12: md5(md5($s).md5($p)) (IPB)", _Funcs_12,_Preloads_12,_ConstDefault, MGF_SALTED|MGF_SALT_AS_HEX, MGF_KEYS_BASE16_X86_IN1_Offset32 },
-	{ "dynamic_13: md5(md5($p).md5($s))",        _Funcs_13,_Preloads_13,_ConstDefault, MGF_SALTED|MGF_SALT_AS_HEX, MGF_KEYS_BASE16_X86_IN1 },
+	{ "dynamic_3: md5(md5(md5($p)))",           _Funcs_3, _Preloads_3, _ConstDefault, MGF_NO_FLAG, MGF_KEYS_INPUT|MGF_SET_INP2LEN32 },
+	{ "dynamic_4: md5($s.$p) (OSC)",            _Funcs_4, _Preloads_4, _ConstDefault, MGF_SALTED, MGF_NO_FLAG, -24  },
+	{ "dynamic_5: md5($s.$p.$s)",               _Funcs_5, _Preloads_5, _ConstDefault, MGF_SALTED, MGF_NO_FLAG, -12, 31, 56  },
+	{ "dynamic_6: md5(md5($p).$s)",             _Funcs_6, _Preloads_6, _ConstDefault, MGF_SALTED, MGF_KEYS_BASE16_IN1, -23, 55, 80 },
+#if 0
+	// this format is deprecated. If someone WANTS it to work, then it can be uncommented.
+	// however it is MUCH better to use dyanamic_6, and if there are any bad characters in
+	// the salts (like ':'), then use %HEX$ for that candidate's salt value.
+	{ "dynamic_7: md5(md5($p).$s) (vBulletin)", _Funcs_7, _Preloads_7, _ConstDefault, MGF_SALTED|MGF_ColonNOTValid, MGF_KEYS_BASE16_IN1, 3, 52 },
+#endif
+	{ "dynamic_8: md5(md5($s).$p)",             _Funcs_8, _Preloads_8, _ConstDefault, MGF_SALTED|MGF_SALT_AS_HEX, MGF_NO_FLAG, -32,  23},
+	{ "dynamic_9: md5($s.md5($p))",             _Funcs_9, _Preloads_9, _ConstDefault, MGF_SALTED, MGF_KEYS_BASE16_IN1, -23, 55, 80 },
+	{ "dynamic_10: md5($s.md5($s.$p))",         _Funcs_10,_Preloads_10,_ConstDefault, MGF_SALTED, MGF_NO_FLAG, -23 },
+	{ "dynamic_11: md5($s.md5($p.$s))",         _Funcs_11,_Preloads_11,_ConstDefault, MGF_SALTED, MGF_NO_FLAG, -23 },
+	{ "dynamic_12: md5(md5($s).md5($p)) (IPB)", _Funcs_12,_Preloads_12,_ConstDefault, MGF_SALTED|MGF_SALT_AS_HEX, MGF_KEYS_BASE16_X86_IN1_Offset32, -32, 55, 80 },
+	{ "dynamic_13: md5(md5($p).md5($s))",       _Funcs_13,_Preloads_13,_ConstDefault, MGF_SALTED|MGF_SALT_AS_HEX, MGF_KEYS_BASE16_X86_IN1, -32, 55, 80 },
 #if defined (MMX_COEF)
-	{ "dynamic_14: md5($s.md5($p).$s)",          _Funcs_14,_Preloads_14,_ConstDefault, MGF_SALTED,MGF_KEYS_CRYPT_IN2, -12 },
+	{ "dynamic_14: md5($s.md5($p).$s)",         _Funcs_14,_Preloads_14,_ConstDefault, MGF_SALTED,MGF_KEYS_CRYPT_IN2, -11, 55, 80, -24 },
 #else
-	{ "dynamic_14: md5($s.md5($p).$s)",          _Funcs_14,_Preloads_14,_ConstDefault, MGF_SALTED, MGF_KEYS_BASE16_IN1 },
+	{ "dynamic_14: md5($s.md5($p).$s)",          _Funcs_14,_Preloads_14,_ConstDefault, MGF_SALTED, MGF_KEYS_BASE16_IN1, -11, 55, 80, -24},
 #endif
-	{ "dynamic_15: md5($u.md5($p).$s)",          _Funcs_15,_Preloads_15,_ConstDefault, MGF_SALTED|MGF_USERNAME|MGF_NOTSSE2Safe|MGF_FULL_CLEAN_REQUIRED, MGF_KEYS_CRYPT_IN2, -26, 32 }, // 26 is 12+12+2 so 24+52 'fits
-	{ "dynamic_16: md5(md5(md5($p).$s).$s2)",    _Funcs_16,_Preloads_16,_ConstDefault, MGF_SALTED|MGF_SALTED2|MGF_NOTSSE2Safe, MGF_KEYS_BASE16_IN1, -26, 32 },
-	{ "dynamic_17: phpass ($P$ or $H$)",         _Funcs_17,_Preloads_17,_ConstDefault, MGF_SALTED|MGF_INPBASE64, MGF_PHPassSetup, 9, 38 },
+	{ "dynamic_15: md5($u.md5($p).$s)",         _Funcs_15,_Preloads_15,_ConstDefault, MGF_SALTED|MGF_USERNAME|MGF_NOTSSE2Safe|MGF_FULL_CLEAN_REQUIRED, MGF_KEYS_CRYPT_IN2, -12, 55, 80 }, // 26 is 12+12+2 so 24+52 'fits
+	{ "dynamic_16: md5(md5(md5($p).$s).$s2)",   _Funcs_16,_Preloads_16,_ConstDefault, MGF_SALTED|MGF_SALTED2|MGF_NOTSSE2Safe, MGF_KEYS_BASE16_IN1, -23, 55, 80 },
+	{ "dynamic_17: phpass ($P$ or $H$)",        _Funcs_17,_Preloads_17,_ConstDefault, MGF_SALTED|MGF_INPBASE64, MGF_PHPassSetup, 9, 38 },
 	{ "dynamic_18: md5($s.Y.$p.0xF7.$s)(Post.Office MD5)",  _Funcs_18,_Preloads_18,_Const_18,     MGF_SALTED|MGF_NOTSSE2Safe, MGF_POSetup, 32, 32 },
-	{ "dynamic_19: Cisco PIX (MD5)",              _Funcs_19,_Preloads_19,_ConstDefault, MGF_INPBASE64_4x6, MGF_NO_FLAG, 0, 16 },
-	{ "dynamic_20: Cisco PIX (MD5 salted)",       _Funcs_20,_Preloads_20,_ConstDefault, MGF_INPBASE64_4x6|MGF_SALTED, MGF_NO_FLAG, 4, 12 },
-	{ "dynamic_21: HTTP Digest Access Auth",      _Funcs_21,_Preloads_21,_Const_21,     MGF_HDAA_SALT|MGF_FLD2|MGF_FLD3|MGF_SALTED, MGF_NO_FLAG, 0, 26 },
-	{ "dynamic_22: md5(sha1($p))",                _Funcs_22,_Preloads_22,_ConstDefault, MGF_StartInX86Mode, MGF_KEYS_INPUT_BE_SAFE },
-	{ "dynamic_23: sha1(md5($p))",                _Funcs_23,_Preloads_23,_ConstDefault, MGF_SHA1_40_BYTE_FINISH, MGF_KEYS_INPUT },
-	{ "dynamic_24: sha1($p.$s)",                  _Funcs_24,_Preloads_24,_ConstDefault, MGF_SALTED|MGF_SHA1_40_BYTE_FINISH, MGF_NO_FLAG, -24, 31 },
-	{ "dynamic_25: sha1($s.$p)",                  _Funcs_25,_Preloads_25,_ConstDefault, MGF_SALTED|MGF_SHA1_40_BYTE_FINISH, MGF_NO_FLAG, -24, 31 },
-	{ "dynamic_26: sha1($p) raw-sha1",            _Funcs_26,_Preloads_26,_ConstDefault, MGF_SHA1_40_BYTE_FINISH, MGF_RAW_SHA1_INPUT },
+	{ "dynamic_19: Cisco PIX (MD5)",            _Funcs_19,_Preloads_19,_ConstDefault, MGF_INPBASE64_4x6, MGF_NO_FLAG, 0, 16, 16 },
+	{ "dynamic_20: Cisco PIX (MD5 salted)",     _Funcs_20,_Preloads_20,_ConstDefault, MGF_INPBASE64_4x6|MGF_SALTED, MGF_NO_FLAG, 4, 12, 12 },
+	{ "dynamic_21: HTTP Digest Access Auth",    _Funcs_21,_Preloads_21,_Const_21,     MGF_HDAA_SALT|MGF_FLD2|MGF_FLD3|MGF_SALTED, MGF_NO_FLAG, 0, 26, 26 },
+	{ "dynamic_22: md5(sha1($p))",              _Funcs_22,_Preloads_22,_ConstDefault, MGF_StartInX86Mode, MGF_KEYS_INPUT_BE_SAFE },
+	{ "dynamic_23: sha1(md5($p))",              _Funcs_23,_Preloads_23,_ConstDefault, MGF_SHA1_40_BYTE_FINISH, MGF_KEYS_INPUT, },
+	{ "dynamic_24: sha1($p.$s)",                _Funcs_24,_Preloads_24,_ConstDefault, MGF_SALTED|MGF_SHA1_40_BYTE_FINISH, MGF_NO_FLAG, -24 },
+	{ "dynamic_25: sha1($s.$p)",                _Funcs_25,_Preloads_25,_ConstDefault, MGF_SALTED|MGF_SHA1_40_BYTE_FINISH, MGF_NO_FLAG, -24 },
+	{ "dynamic_26: sha1($p) raw-sha1",          _Funcs_26,_Preloads_26,_ConstDefault, MGF_SHA1_40_BYTE_FINISH, MGF_RAW_SHA1_INPUT },
 #if ARCH_LITTLE_ENDIAN
-	{ "dynamic_27: FreeBSD MD5",                  _Funcs_27,_Preloads_27,_Const_27,     MGF_SALTED|MGF_INPBASE64a|MGF_StartInX86Mode, MGF_FreeBSDMD5Setup, 0, 15 },
-	{ "dynamic_28: Apache MD5",                   _Funcs_28,_Preloads_28,_Const_28,     MGF_SALTED|MGF_INPBASE64a|MGF_StartInX86Mode, MGF_FreeBSDMD5Setup, 0, 15 },
-#endif
-#if defined (MMX_COEF)
-	{ "dynamic_29: md5(unicode($p))",             _Funcs_29,_Preloads_29,_ConstDefault, MGF_UTF8, MGF_NO_FLAG, 0, 27 }, // if we are in utf8 mode, we triple this in the init() call
-#else
-	{ "dynamic_29: md5(unicode($p))",             _Funcs_29,_Preloads_29,_ConstDefault, MGF_UTF8, MGF_NO_FLAG, 0, 40 }, // if we are in utf8 mode, we triple this in the init() call
+	{ "dynamic_27: FreeBSD MD5",                _Funcs_27,_Preloads_27,_Const_27,     MGF_SALTED|MGF_INPBASE64a|MGF_StartInX86Mode, MGF_FreeBSDMD5Setup, -8, 15, 32 },
+	{ "dynamic_28: Apache MD5",                 _Funcs_28,_Preloads_28,_Const_28,     MGF_SALTED|MGF_INPBASE64a|MGF_StartInX86Mode, MGF_FreeBSDMD5Setup, -8, 15, 32 },
 #endif
+	{ "dynamic_29: md5(unicode($p))",           _Funcs_29,_Preloads_29,_ConstDefault, MGF_UTF8, MGF_NO_FLAG, 0, 27, 40 }, // if we are in utf8 mode, we triple this in the init() call
 	{ "dynamic_30: md4($p) (raw-md4)",          _Funcs_30,_Preloads_30,_ConstDefault, MGF_NO_FLAG, MGF_KEYS_INPUT },
-#if defined (MMX_COEF)
-	{ "dynamic_31: md4($s.$p)",                   _Funcs_31,_Preloads_31,_ConstDefault, MGF_SALTED, MGF_NO_FLAG, -24, 31 },
-	{ "dynamic_32: md4($p.$s)",                   _Funcs_32,_Preloads_32,_ConstDefault, MGF_SALTED, MGF_NO_FLAG, -24, 31 },
-	{ "dynamic_33: md4(unicode($p))",             _Funcs_33,_Preloads_33,_ConstDefault, MGF_UTF8, MGF_NO_FLAG, 0, 27 }, // if we are in utf8 mode, we triple this in the init() call
-#else
-	{ "dynamic_31: md4($s.$p)",                   _Funcs_31,_Preloads_31,_ConstDefault, MGF_SALTED },
-	{ "dynamic_32: md4($p.$s)",                   _Funcs_32,_Preloads_32,_ConstDefault, MGF_SALTED },
-	{ "dynamic_33: md4(unicode($p))",             _Funcs_33,_Preloads_33,_ConstDefault, MGF_UTF8, MGF_NO_FLAG, 0, 40 }, // if we are in utf8 mode, we triple this in the init() call
-#endif
-	{ "dynamic_34: md5(md4($p))",                 _Funcs_34,_Preloads_34,_ConstDefault, MGF_NO_FLAG, MGF_KEYS_INPUT|MGF_SET_INP2LEN32 },
+	{ "dynamic_31: md4($s.$p)",                 _Funcs_31,_Preloads_31,_ConstDefault, MGF_SALTED, MGF_NO_FLAG, -24 },
+	{ "dynamic_32: md4($p.$s)",                 _Funcs_32,_Preloads_32,_ConstDefault, MGF_SALTED, MGF_NO_FLAG, -24 },
+	{ "dynamic_33: md4(unicode($p))",           _Funcs_33,_Preloads_33,_ConstDefault, MGF_UTF8, MGF_NO_FLAG, 0, 27, 40 }, // if we are in utf8 mode, we triple this in the init() call
+	{ "dynamic_34: md5(md4($p))",               _Funcs_34,_Preloads_34,_ConstDefault, MGF_NO_FLAG, MGF_KEYS_INPUT|MGF_SET_INP2LEN32 },
 };
 
 char *dynamic_PRELOAD_SIGNATURE(int cnt)
diff -urpN jumbo-bleed1/src/formats.h jumbo-bleed0/src/formats.h
--- jumbo-bleed1/src/formats.h	2012-07-02 21:59:38.968750000 +0000
+++ jumbo-bleed0/src/formats.h	2012-07-02 18:57:31.296875000 +0000
@@ -38,6 +38,8 @@ struct db_password;
 #define FMT_BS				0x00010000
 /* The split() method unifies the case of characters in hash encodings */
 #define FMT_SPLIT_UNIFIES_CASE		0x00020000
+/* Is this format a dynamic_x format (or a 'thin' format using dynamic code) ? */
+#define FMT_DYNAMIC				0x00100000
 /* Parallelized with OpenMP */
 #ifdef _OPENMP
 #define FMT_OMP				0x01000000
diff -urpN jumbo-bleed1/src/john.c jumbo-bleed0/src/john.c
--- jumbo-bleed1/src/john.c	2012-07-02 21:59:39.906250000 +0000
+++ jumbo-bleed0/src/john.c	2012-07-02 22:05:31.750000000 +0000
@@ -786,6 +786,7 @@ static void john_init(char *name, int ar
 			printf(" False positives possible       \t%s\n", (format->params.flags & FMT_NOT_EXACT) ? "yes" : "no");
 			printf(" Uses a bitslice implementation \t%s\n", (format->params.flags & FMT_BS) ? "yes" : "no");
 			printf(" The split() method unifies case\t%s\n", (format->params.flags & FMT_SPLIT_UNIFIES_CASE) ? "yes" : "no");
+			printf(" A $dynamic$ format             \t%s\n", (format->params.flags & FMT_DYNAMIC) ? "yes" : "no");
 #ifdef _OPENMP
 			printf(" Parallelized with OpenMP       \t%s\n", (format->params.flags & FMT_OMP) ? "yes" : "no");
 #endif
@@ -795,7 +796,12 @@ static void john_init(char *name, int ar
 			printf("Benchmark comment               \t%s\n", format->params.benchmark_comment);
 			printf("Benchmark length                \t%d\n", format->params.benchmark_length);
 			printf("Binary size                     \t%d\n", format->params.binary_size);
-			printf("Salt size                       \t%d\n", format->params.salt_size);
+			if ( (format->params.flags & FMT_DYNAMIC) && format->params.salt_size) {
+				// salts are handled internally within the format. We want to know the 'real' salt size/
+				// dynamic will alway set params.salt_size to 0 or sizeof a pointer.
+				printf("Salt size                       \t%d\n", dynamic_real_salt_length(format));
+			} else
+				printf("Salt size                       \t%d\n", format->params.salt_size);
 			printf("\n");
 		} while ((format = format->next));
 		exit(0);
@@ -808,7 +814,7 @@ static void john_init(char *name, int ar
 			int ShowIt = 1, i;
 			if (options.listconf[14] == '=' || options.listconf[14] == ':') {
 				ShowIt = 0;
-				if (!strcasecmp(&options.listconf[15], "set_key")   ||
+				if (!strcasecmp(&options.listconf[15], "set_key")   || 
 					!strcasecmp(&options.listconf[15], "get_key")   ||
 					!strcasecmp(&options.listconf[15], "crypt_all") ||
 					!strcasecmp(&options.listconf[15], "cmp_all")   ||