diff -ur ldmud-3.3.714.orig/src/autoconf/configure.in ldmud-3.3.714.mod/src/autoconf/configure.in
--- ldmud-3.3.714.orig/src/autoconf/configure.in	2006-07-10 04:44:05.000000000 +0200
+++ ldmud-3.3.714.mod/src/autoconf/configure.in	2007-09-23 17:26:08.000000000 +0200
@@ -371,6 +371,7 @@
 AC_CDEF_FROM_ENABLE(malloc_sbrk_trace)
 AC_CDEF_FROM_ENABLE(dynamic_costs)
 AC_CDEF_FROM_ENABLE(trace_code)
+AC_CDEF_FROM_ENABLE(use_dwhash)
 
 AC_CDEF_FROM_ENABLE(rxcache_table)
 AC_CDEF_FROM_ENABLE(synchronous_heart_beat)
@@ -2657,6 +2658,7 @@
 AC_SUBST(cdef_malloc_lpc_trace)
 AC_SUBST(cdef_malloc_sbrk_trace)
 AC_SUBST(cdef_dynamic_costs)
+AC_SUBST(cdef_use_dwhash)
 
 AC_SUBST(cdef_rxcache_table)
 AC_SUBST(cdef_wizlist_file)
diff -ur ldmud-3.3.714.orig/src/config.h.in ldmud-3.3.714.mod/src/config.h.in
--- ldmud-3.3.714.orig/src/config.h.in	2006-07-10 04:44:06.000000000 +0200
+++ ldmud-3.3.714.mod/src/config.h.in	2007-09-23 19:45:58.000000000 +0200
@@ -486,6 +486,7 @@
  */
 @cdef_rxcache_table@ RXCACHE_TABLE            @val_rxcache_table@
 
+
 /* --- Current Developments ---
  * These options can be used to disable developments-in-progress if their
  * code turns out to be interrrupting.
@@ -500,6 +501,11 @@
  */
 @cdef_use_new_inlines@ USE_NEW_INLINES
 
+/* Use larger string hashes (double-words, 32 bit) and D.J. Bernsteins
+ * Hash function?
+ */
+@cdef_use_dwhash@ USE_DWHASH
+
 
 /* --- Profiling ---
  * For profiling of the VM instruction implementations, refer to the Makefile
diff -ur ldmud-3.3.714.orig/src/hash.c ldmud-3.3.714.mod/src/hash.c
--- ldmud-3.3.714.orig/src/hash.c	2006-07-10 04:42:06.000000000 +0200
+++ ldmud-3.3.714.mod/src/hash.c	2007-09-23 19:33:54.000000000 +0200
@@ -161,5 +161,52 @@
     return h;
 } /* chashstr() */
 
-/***************************************************************************/
+/*-------------------------------------------------------------------------*/
+
+/* The following functions basically implement Dan J. Bernsteins Hash 
+ * function, also used in his CDB */
+dwhash_t
+dwhashmem2 (const char *s, size_t len, int maxn, dwhash_t initial)
+
+/* Hash the first min(<len>,<maxn>) characters of string <s> into an 
+ * unsigned long integer (p_uint, double word) and return this hashed value.
+ * The hash value is initialized with <initial>, so that this function
+ * can be used to hash a series of strings into one result.
+ * Aliased to dwhashmem()
+ */
+{
+    register dwhash_t hash = initial;
+    register size_t i = maxn;
+    
+    if (i > len)
+        i = len;
+    
+    while(i--) {
+        hash += (hash << 5);
+        hash = hash ^ *(s++);
+    }
+    return (hash);
+}
+
+/*-------------------------------------------------------------------------*/
 
+dwhash_t
+dwhashstr (const char *s, int maxn)
+
+/* Hash the first min(<len>,<maxn>) characters of string <s> (or until \0,
+ * whatever comes first) into an unsigned long integer (p_uint, double word) 
+ * and return this hashed value.
+ */
+{
+    register dwhash_t hash = INITIAL_DWHASH;
+    register size_t i = maxn;
+    register unsigned char c;
+    
+    while(i-- && (c = *s++) != '\0') {
+        hash += (hash << 5);
+        hash = hash ^ c;
+    }
+    return (hash);
+}
+
+/***************************************************************************/
diff -ur ldmud-3.3.714.orig/src/hash.h ldmud-3.3.714.mod/src/hash.h
--- ldmud-3.3.714.orig/src/hash.h	2006-07-10 04:42:06.000000000 +0200
+++ ldmud-3.3.714.mod/src/hash.h	2007-09-23 19:29:21.000000000 +0200
@@ -3,16 +3,25 @@
 
 #include <stdlib.h>
 #include <limits.h>
+#include "driver.h"
 
 typedef unsigned short whash_t;
 typedef unsigned char  chash_t;
+typedef p_uint         dwhash_t;
 
-#define MAX_WHASH (USHRT_MAX)
-#define MAX_CHASH (UCHAR_MAX)
+#define MAX_WHASH  (USHRT_MAX)
+#define MAX_CHASH  (UCHAR_MAX)
+#define MAX_DWHASH (PUINT_MAX)
+
+#define INITIAL_DWHASH 5381
 
 extern whash_t whashmem (const char *s, size_t len, int maxn);
 extern whash_t whashmem2 (const char *s, size_t len, int maxn, whash_t initial);
 extern whash_t whashstr (const char *s, int maxn);
 extern chash_t chashstr (const char *s, int maxn);
+extern dwhash_t dwhashmem2 (const char *s, size_t len, int maxn, dwhash_t initial);
+extern dwhash_t dwhashstr (const char *s, int maxn);
+
+#define dwhashmem(pTxt,len,maxn)   dwhashmem2(pTxt, len, maxn, INITIAL_DWHASH)
 
 #endif /* HASH_H__ */
diff -ur ldmud-3.3.714.orig/src/lex.c ldmud-3.3.714.mod/src/lex.c
--- ldmud-3.3.714.orig/src/lex.c	2006-07-10 04:43:48.000000000 +0200
+++ ldmud-3.3.714.mod/src/lex.c	2007-09-23 18:05:54.000000000 +0200
@@ -367,7 +367,11 @@
 #if ITABLE_SIZE == 256
 #    define identhash(s) chashstr((s), 12)
 #else
-#    define identhash(s) (whashstr((s), 12) % ITABLE_SIZE)
+#    ifndef USE_DWHASH
+#        define identhash(s) (whashstr((s), 12) % ITABLE_SIZE)
+#    else
+#        define identhash(s) (dwhashstr((s), 12) % ITABLE_SIZE)
+#    endif
 #endif
   /* Hash an identifier name (c-string) into a table index.
    */
diff -ur ldmud-3.3.714.orig/src/mstrings.c ldmud-3.3.714.mod/src/mstrings.c
--- ldmud-3.3.714.orig/src/mstrings.c	2006-07-10 04:43:25.000000000 +0200
+++ ldmud-3.3.714.mod/src/mstrings.c	2007-09-23 17:02:47.000000000 +0200
@@ -179,7 +179,11 @@
 #endif /* EXT_STRING_STATS */
 
 /*-------------------------------------------------------------------------*/
+#ifndef USE_DWHASH
 static INLINE whash_t
+#else
+static INLINE dwhash_t
+#endif
 hash_string (const char * const s, size_t size)
 
 /* Compute the hash for string <s> of length <size> and return it.
@@ -187,16 +191,22 @@
  */
 
 {
-    whash_t hash;
-
-    hash = whashmem(s, size, MSTRING_HASH_LENGTH);
+#ifndef USE_DWHASH
+    whash_t hash = whashmem(s, size, MSTRING_HASH_LENGTH);
+#else
+    dwhash_t hash = dwhashmem(s, size, MSTRING_HASH_LENGTH);
+#endif
     if (!hash)
         hash = 1 << (sizeof (hash) * CHAR_BIT - 1);
     return hash;
 } /* hash_string() */
 
 /*-------------------------------------------------------------------------*/
+#ifndef USE_DWHASH
 static INLINE whash_t
+#else
+static INLINE dwhash_t
+#endif
 get_hash (string_t * pStr)
 
 /* Return the hash of string <pStr>, computing it if necessary.
@@ -210,7 +220,11 @@
 } /* get_hash() */
 
 /*-------------------------------------------------------------------------*/
+#ifndef USE_DWHASH
 whash_t
+#else
+dwhash_t
+#endif
 mstring_get_hash (string_t * pStr)
 
 /* Aliased to: mstr_get_hash()
@@ -224,8 +238,11 @@
 
 /*-------------------------------------------------------------------------*/
 static INLINE string_t *
+#ifndef USE_DWHASH
 find_and_move (const char * const s, size_t size, whash_t hash)
-
+#else
+find_and_move (const char * const s, size_t size, dwhash_t hash)
+#endif
 /* If <s> is a tabled string of length <size> and <hash> in the related
  * stringtable chain: find it, move it to the head of the chain and return its
  * string_t*.
@@ -314,8 +331,11 @@
 
 /*-------------------------------------------------------------------------*/
 static INLINE string_t *
+#ifndef USE_DWHASH
 make_new_tabled (const char * const pTxt, size_t size, whash_t hash MTRACE_DECL)
-
+#else
+make_new_tabled (const char * const pTxt, size_t size, dwhash_t hash MTRACE_DECL)
+#endif
 /* Helper function for mstring_new_tabled() and mstring_new_n_tabled().
  *
  * Create a new tabled string by copying the data string <pTxt> of length
@@ -481,7 +501,11 @@
  */
 
 {
+#ifndef USE_DWHASH
     whash_t    hash;
+#else
+    dwhash_t   hash;
+#endif
     size_t     size;
     string_t * string;
 
@@ -513,7 +537,11 @@
  */
 
 {
+#ifndef USE_DWHASH
     whash_t    hash;
+#else
+    dwhash_t   hash;
+#endif
     string_t * string;
 
     hash = hash_string(pTxt, size);
@@ -546,7 +574,11 @@
 
 {
     string_t *string;
+#ifndef USE_DWHASH
     whash_t    hash;
+#else
+    dwhash_t   hash;
+#endif
     int        idx;
     size_t     size;
     size_t     msize;
@@ -749,7 +781,11 @@
  */
 
 {
-    whash_t hash;
+#ifndef USE_DWHASH
+    whash_t    hash;
+#else
+    dwhash_t   hash;
+#endif
     size_t  size;
 
 #ifdef EXT_STRING_STATS
@@ -790,7 +826,11 @@
  */
 
 {
-    whash_t hash;
+#ifndef USE_DWHASH
+    whash_t    hash;
+#else
+    dwhash_t   hash;
+#endif
 
     hash = hash_string(pTxt, size);
 
@@ -1019,8 +1059,13 @@
 
     /* Strings with a smaller hash also count as 'less'. */
     {
+#ifndef USE_DWHASH
         whash_t hash1 = get_hash(pStr1);
         whash_t hash2 = get_hash(pStr2);
+#else
+        dwhash_t hash1 = get_hash(pStr1);
+        dwhash_t hash2 = get_hash(pStr2);
+#endif
         if (hash1 != hash2)
             return  hash1 < hash2 ? -1 : 1;
     }
diff -ur ldmud-3.3.714.orig/src/mstrings.h ldmud-3.3.714.mod/src/mstrings.h
--- ldmud-3.3.714.orig/src/mstrings.h	2006-07-10 04:43:26.000000000 +0200
+++ ldmud-3.3.714.mod/src/mstrings.h	2007-09-23 16:54:35.000000000 +0200
@@ -47,7 +47,11 @@
     } info;
     string_t * next;    /* Linkpointer in string table. */
     size_t     size;    /* Length of the string */
+#ifndef USE_DWHASH
     whash_t    hash;    /* 0, or the hash of the string */
+#else
+    dwhash_t   hash;    /* 0, or the hash of the string */
+#endif
     char       txt[1];  /* In fact .size characters plus one '\0' */
       /* The string text follows here */
 };
@@ -65,7 +69,11 @@
 /* --- Prototypes --- */
 
 extern void mstring_init (void);
+#ifndef USE_DWHASH
 extern whash_t    mstring_get_hash (string_t * pStr);
+#else
+extern dwhash_t   mstring_get_hash (string_t * pStr);
+#endif
 extern string_t * mstring_alloc_string (size_t iSize MTRACE_DECL);
 extern string_t * mstring_new_string (const char * const pTxt MTRACE_DECL);
 extern string_t * mstring_new_n_string (const char * const pTxt, size_t len MTRACE_DECL);
diff -ur ldmud-3.3.714.orig/src/otable.c ldmud-3.3.714.mod/src/otable.c
--- ldmud-3.3.714.orig/src/otable.c	2006-07-10 04:42:56.000000000 +0200
+++ ldmud-3.3.714.mod/src/otable.c	2007-09-23 17:47:34.000000000 +0200
@@ -48,13 +48,20 @@
 /*=========================================================================*/
 /*                           OBJECT TABLE                                  */
 /*-------------------------------------------------------------------------*/
-
 #if !( (OTABLE_SIZE) & (OTABLE_SIZE)-1 )
-#    define ObjHash(s)        (mstr_get_hash(s) & ((OTABLE_SIZE)-1) )
+#  define ObjHash(s)        (mstr_get_hash(s) & ((OTABLE_SIZE)-1) )
+#  ifndef USE_DWHASH
 #    define ObjHashStr(s,len) (whashmem(s, len, MSTRING_HASH_LENGTH) & ((OTABLE_SIZE)-1) )
+#  else
+#    define ObjHashStr(s,len) (dwhashmem(s, len, MSTRING_HASH_LENGTH) & ((OTABLE_SIZE)-1) )
+#  endif
 #else
-#    define ObjHash(s)        (mstr_get_hash(s) % OTABLE_SIZE)
+#  define ObjHash(s)        (mstr_get_hash(s) % OTABLE_SIZE)
+#  ifndef USE_DWHASH
 #    define ObjHashStr(s,len) (whashmem(s, len, MSTRING_HASH_LENGTH) % OTABLE_SIZE)
+#  else
+#    define ObjHashStr(s,len) (dwhashmem(s, len, MSTRING_HASH_LENGTH) % OTABLE_SIZE)
+#  endif
 #endif
 /* Hash the string <s> and compute the appropriate table index
  */