Bug 1586867 - Upgrade Firefox 71 to use NSPR 4.23. r=jcj NSPR_4_23_BETA1 UPGRADE_NSPR_RELEASE
authorKai Engert <kaie@kuix.de>
Mon, 07 Oct 2019 22:07:04 +0000
changeset 496698 679ba7a64a774209a7cc8444ef6d548ac5add9f1
parent 496697 1194b12661808eda93082bb8c4545390184c81ef
child 496699 7a8b337580fb7c519eef65149fbfc94903e8f854
push id36665
push userapavel@mozilla.com
push dateTue, 08 Oct 2019 09:34:20 +0000
treeherdermozilla-central@035f52aed442 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjcj
bugs1586867
milestone71.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1586867 - Upgrade Firefox 71 to use NSPR 4.23. r=jcj NSPR_4_23_BETA1 UPGRADE_NSPR_RELEASE Differential Revision: https://phabricator.services.mozilla.com/D48414
nsprpub/TAG-INFO
nsprpub/config/libc_r.h
nsprpub/config/nsinstall.c
nsprpub/config/prdepend.h
nsprpub/configure
nsprpub/configure.in
nsprpub/lib/ds/plarena.c
nsprpub/lib/ds/plhash.c
nsprpub/lib/ds/plvrsion.c
nsprpub/lib/libc/include/plbase64.h
nsprpub/lib/libc/include/plgetopt.h
nsprpub/lib/libc/include/plstr.h
nsprpub/lib/libc/src/base64.c
nsprpub/lib/libc/src/plerror.c
nsprpub/lib/libc/src/plgetopt.c
nsprpub/lib/libc/src/plvrsion.c
nsprpub/lib/libc/src/strcase.c
nsprpub/lib/libc/src/strcat.c
nsprpub/lib/libc/src/strchr.c
nsprpub/lib/libc/src/strcmp.c
nsprpub/lib/libc/src/strcpy.c
nsprpub/lib/libc/src/strdup.c
nsprpub/lib/libc/src/strlen.c
nsprpub/lib/libc/src/strpbrk.c
nsprpub/lib/libc/src/strstr.c
nsprpub/lib/libc/src/strtok.c
nsprpub/lib/prstreams/plvrsion.c
nsprpub/lib/prstreams/prstrms.cpp
nsprpub/lib/prstreams/prstrms.h
nsprpub/lib/prstreams/tests/testprstrm/testprstrm.cpp
nsprpub/lib/tests/arena.c
nsprpub/lib/tests/base64t.c
nsprpub/lib/tests/getopt.c
nsprpub/lib/tests/string.c
nsprpub/pr/include/gencfg.c
nsprpub/pr/include/md/_aix.h
nsprpub/pr/include/md/_bsdi.h
nsprpub/pr/include/md/_darwin.h
nsprpub/pr/include/md/_freebsd.h
nsprpub/pr/include/md/_hpux.h
nsprpub/pr/include/md/_linux.h
nsprpub/pr/include/md/_netbsd.h
nsprpub/pr/include/md/_nspr_pthread.h
nsprpub/pr/include/md/_nto.h
nsprpub/pr/include/md/_openbsd.h
nsprpub/pr/include/md/_os2.h
nsprpub/pr/include/md/_os2_errors.h
nsprpub/pr/include/md/_pcos.h
nsprpub/pr/include/md/_pth.h
nsprpub/pr/include/md/_qnx.h
nsprpub/pr/include/md/_riscos.h
nsprpub/pr/include/md/_scoos.h
nsprpub/pr/include/md/_solaris.h
nsprpub/pr/include/md/_unix_errors.h
nsprpub/pr/include/md/_unixos.h
nsprpub/pr/include/md/_unixware.h
nsprpub/pr/include/md/_win32_errors.h
nsprpub/pr/include/md/_win95.h
nsprpub/pr/include/md/_winnt.h
nsprpub/pr/include/obsolete/pralarm.h
nsprpub/pr/include/obsolete/probslet.h
nsprpub/pr/include/obsolete/protypes.h
nsprpub/pr/include/obsolete/prsem.h
nsprpub/pr/include/pratom.h
nsprpub/pr/include/prbit.h
nsprpub/pr/include/prclist.h
nsprpub/pr/include/prcountr.h
nsprpub/pr/include/prcvar.h
nsprpub/pr/include/prdtoa.h
nsprpub/pr/include/prenv.h
nsprpub/pr/include/prerror.h
nsprpub/pr/include/prinet.h
nsprpub/pr/include/prinit.h
nsprpub/pr/include/prinrval.h
nsprpub/pr/include/prio.h
nsprpub/pr/include/private/pprio.h
nsprpub/pr/include/private/pprthred.h
nsprpub/pr/include/private/primpl.h
nsprpub/pr/include/prlink.h
nsprpub/pr/include/prlock.h
nsprpub/pr/include/prlog.h
nsprpub/pr/include/prlong.h
nsprpub/pr/include/prmem.h
nsprpub/pr/include/prmwait.h
nsprpub/pr/include/prnetdb.h
nsprpub/pr/include/prolock.h
nsprpub/pr/include/prpdce.h
nsprpub/pr/include/prprf.h
nsprpub/pr/include/prproces.h
nsprpub/pr/include/prrng.h
nsprpub/pr/include/prrwlock.h
nsprpub/pr/include/prshm.h
nsprpub/pr/include/prshma.h
nsprpub/pr/include/prsystem.h
nsprpub/pr/include/prthread.h
nsprpub/pr/include/prtime.h
nsprpub/pr/include/prtpool.h
nsprpub/pr/include/prtrace.h
nsprpub/pr/include/prtypes.h
nsprpub/pr/include/prvrsion.h
nsprpub/pr/include/prwin16.h
nsprpub/pr/src/cplus/rcascii.h
nsprpub/pr/src/cplus/rcbase.cpp
nsprpub/pr/src/cplus/rcbase.h
nsprpub/pr/src/cplus/rccv.cpp
nsprpub/pr/src/cplus/rccv.h
nsprpub/pr/src/cplus/rcfileio.cpp
nsprpub/pr/src/cplus/rcfileio.h
nsprpub/pr/src/cplus/rcinrval.cpp
nsprpub/pr/src/cplus/rcinrval.h
nsprpub/pr/src/cplus/rcio.h
nsprpub/pr/src/cplus/rclock.cpp
nsprpub/pr/src/cplus/rclock.h
nsprpub/pr/src/cplus/rcnetdb.cpp
nsprpub/pr/src/cplus/rcnetdb.h
nsprpub/pr/src/cplus/rcnetio.cpp
nsprpub/pr/src/cplus/rcnetio.h
nsprpub/pr/src/cplus/rcthread.cpp
nsprpub/pr/src/cplus/rcthread.h
nsprpub/pr/src/cplus/rctime.cpp
nsprpub/pr/src/cplus/rctime.h
nsprpub/pr/src/cplus/tests/ranfile.cpp
nsprpub/pr/src/cplus/tests/switch.cpp
nsprpub/pr/src/cplus/tests/thread.cpp
nsprpub/pr/src/cplus/tests/tpd.cpp
nsprpub/pr/src/io/prdir.c
nsprpub/pr/src/io/prfdcach.c
nsprpub/pr/src/io/prfile.c
nsprpub/pr/src/io/prio.c
nsprpub/pr/src/io/priometh.c
nsprpub/pr/src/io/pripv6.c
nsprpub/pr/src/io/prlayer.c
nsprpub/pr/src/io/prlog.c
nsprpub/pr/src/io/prmapopt.c
nsprpub/pr/src/io/prmmap.c
nsprpub/pr/src/io/prmwait.c
nsprpub/pr/src/io/prpolevt.c
nsprpub/pr/src/io/prprf.c
nsprpub/pr/src/io/prscanf.c
nsprpub/pr/src/io/prsocket.c
nsprpub/pr/src/linking/prlink.c
nsprpub/pr/src/malloc/prmalloc.c
nsprpub/pr/src/malloc/prmem.c
nsprpub/pr/src/md/os2/os2_errors.c
nsprpub/pr/src/md/os2/os2cv.c
nsprpub/pr/src/md/os2/os2gc.c
nsprpub/pr/src/md/os2/os2inrval.c
nsprpub/pr/src/md/os2/os2io.c
nsprpub/pr/src/md/os2/os2misc.c
nsprpub/pr/src/md/os2/os2poll.c
nsprpub/pr/src/md/os2/os2rng.c
nsprpub/pr/src/md/os2/os2sem.c
nsprpub/pr/src/md/os2/os2sock.c
nsprpub/pr/src/md/os2/os2thred.c
nsprpub/pr/src/md/prosdep.c
nsprpub/pr/src/md/unix/aix.c
nsprpub/pr/src/md/unix/aixwrap.c
nsprpub/pr/src/md/unix/bsdi.c
nsprpub/pr/src/md/unix/darwin.c
nsprpub/pr/src/md/unix/freebsd.c
nsprpub/pr/src/md/unix/hpux.c
nsprpub/pr/src/md/unix/linux.c
nsprpub/pr/src/md/unix/nto.c
nsprpub/pr/src/md/unix/pthreads_user.c
nsprpub/pr/src/md/unix/qnx.c
nsprpub/pr/src/md/unix/riscos.c
nsprpub/pr/src/md/unix/scoos.c
nsprpub/pr/src/md/unix/solaris.c
nsprpub/pr/src/md/unix/unix.c
nsprpub/pr/src/md/unix/unix_errors.c
nsprpub/pr/src/md/unix/unixware.c
nsprpub/pr/src/md/unix/uxpoll.c
nsprpub/pr/src/md/unix/uxproces.c
nsprpub/pr/src/md/unix/uxrng.c
nsprpub/pr/src/md/unix/uxshm.c
nsprpub/pr/src/md/unix/uxwrap.c
nsprpub/pr/src/md/windows/ntdllmn.c
nsprpub/pr/src/md/windows/ntgc.c
nsprpub/pr/src/md/windows/ntinrval.c
nsprpub/pr/src/md/windows/ntio.c
nsprpub/pr/src/md/windows/ntmisc.c
nsprpub/pr/src/md/windows/ntsec.c
nsprpub/pr/src/md/windows/ntsem.c
nsprpub/pr/src/md/windows/ntthread.c
nsprpub/pr/src/md/windows/w32ipcsem.c
nsprpub/pr/src/md/windows/w32poll.c
nsprpub/pr/src/md/windows/w32rng.c
nsprpub/pr/src/md/windows/w32shm.c
nsprpub/pr/src/md/windows/w95cv.c
nsprpub/pr/src/md/windows/w95dllmain.c
nsprpub/pr/src/md/windows/w95io.c
nsprpub/pr/src/md/windows/w95sock.c
nsprpub/pr/src/md/windows/w95thred.c
nsprpub/pr/src/md/windows/win32_errors.c
nsprpub/pr/src/memory/prseg.c
nsprpub/pr/src/memory/prshm.c
nsprpub/pr/src/memory/prshma.c
nsprpub/pr/src/misc/dtoa.c
nsprpub/pr/src/misc/pralarm.c
nsprpub/pr/src/misc/pratom.c
nsprpub/pr/src/misc/praton.c
nsprpub/pr/src/misc/prcountr.c
nsprpub/pr/src/misc/prdtoa.c
nsprpub/pr/src/misc/prenv.c
nsprpub/pr/src/misc/prerr.c
nsprpub/pr/src/misc/prerror.c
nsprpub/pr/src/misc/prerrortable.c
nsprpub/pr/src/misc/prinit.c
nsprpub/pr/src/misc/prinrval.c
nsprpub/pr/src/misc/pripcsem.c
nsprpub/pr/src/misc/prlong.c
nsprpub/pr/src/misc/prnetdb.c
nsprpub/pr/src/misc/prolock.c
nsprpub/pr/src/misc/prrng.c
nsprpub/pr/src/misc/prsystem.c
nsprpub/pr/src/misc/prthinfo.c
nsprpub/pr/src/misc/prtime.c
nsprpub/pr/src/misc/prtpool.c
nsprpub/pr/src/misc/prtrace.c
nsprpub/pr/src/prvrsion.c
nsprpub/pr/src/pthreads/ptio.c
nsprpub/pr/src/pthreads/ptmisc.c
nsprpub/pr/src/pthreads/ptsynch.c
nsprpub/pr/src/pthreads/ptthread.c
nsprpub/pr/src/threads/combined/prucpu.c
nsprpub/pr/src/threads/combined/prucv.c
nsprpub/pr/src/threads/combined/prulock.c
nsprpub/pr/src/threads/combined/prustack.c
nsprpub/pr/src/threads/combined/pruthr.c
nsprpub/pr/src/threads/prcmon.c
nsprpub/pr/src/threads/prcthr.c
nsprpub/pr/src/threads/prdump.c
nsprpub/pr/src/threads/prmon.c
nsprpub/pr/src/threads/prrwlock.c
nsprpub/pr/src/threads/prsem.c
nsprpub/pr/src/threads/prtpd.c
nsprpub/pr/tests/abstract.c
nsprpub/pr/tests/accept.c
nsprpub/pr/tests/acceptread.c
nsprpub/pr/tests/acceptreademu.c
nsprpub/pr/tests/addrstr.c
nsprpub/pr/tests/affinity.c
nsprpub/pr/tests/alarm.c
nsprpub/pr/tests/anonfm.c
nsprpub/pr/tests/append.c
nsprpub/pr/tests/atomic.c
nsprpub/pr/tests/attach.c
nsprpub/pr/tests/bigfile.c
nsprpub/pr/tests/bigfile2.c
nsprpub/pr/tests/bigfile3.c
nsprpub/pr/tests/bug1test.c
nsprpub/pr/tests/cleanup.c
nsprpub/pr/tests/cltsrv.c
nsprpub/pr/tests/concur.c
nsprpub/pr/tests/cvar.c
nsprpub/pr/tests/cvar2.c
nsprpub/pr/tests/dbmalloc.c
nsprpub/pr/tests/dbmalloc1.c
nsprpub/pr/tests/dceemu.c
nsprpub/pr/tests/depend.c
nsprpub/pr/tests/dll/mygetval.c
nsprpub/pr/tests/dlltest.c
nsprpub/pr/tests/dtoa.c
nsprpub/pr/tests/env.c
nsprpub/pr/tests/errcodes.c
nsprpub/pr/tests/errset.c
nsprpub/pr/tests/exit.c
nsprpub/pr/tests/fdcach.c
nsprpub/pr/tests/fileio.c
nsprpub/pr/tests/foreign.c
nsprpub/pr/tests/forktest.c
nsprpub/pr/tests/formattm.c
nsprpub/pr/tests/freeif.c
nsprpub/pr/tests/fsync.c
nsprpub/pr/tests/getai.c
nsprpub/pr/tests/gethost.c
nsprpub/pr/tests/getproto.c
nsprpub/pr/tests/i2l.c
nsprpub/pr/tests/initclk.c
nsprpub/pr/tests/inrval.c
nsprpub/pr/tests/instrumt.c
nsprpub/pr/tests/intrio.c
nsprpub/pr/tests/intrupt.c
nsprpub/pr/tests/io_timeout.c
nsprpub/pr/tests/io_timeoutk.c
nsprpub/pr/tests/io_timeoutu.c
nsprpub/pr/tests/ioconthr.c
nsprpub/pr/tests/ipv6.c
nsprpub/pr/tests/join.c
nsprpub/pr/tests/joinkk.c
nsprpub/pr/tests/joinku.c
nsprpub/pr/tests/joinuk.c
nsprpub/pr/tests/joinuu.c
nsprpub/pr/tests/layer.c
nsprpub/pr/tests/lazyinit.c
nsprpub/pr/tests/libfilename.c
nsprpub/pr/tests/lltest.c
nsprpub/pr/tests/lock.c
nsprpub/pr/tests/lockfile.c
nsprpub/pr/tests/logger.c
nsprpub/pr/tests/many_cv.c
nsprpub/pr/tests/mbcs.c
nsprpub/pr/tests/multiacc.c
nsprpub/pr/tests/multiwait.c
nsprpub/pr/tests/nameshm1.c
nsprpub/pr/tests/nbconn.c
nsprpub/pr/tests/nblayer.c
nsprpub/pr/tests/nonblock.c
nsprpub/pr/tests/ntioto.c
nsprpub/pr/tests/ntoh.c
nsprpub/pr/tests/obsints.c
nsprpub/pr/tests/op_2long.c
nsprpub/pr/tests/op_excl.c
nsprpub/pr/tests/op_filnf.c
nsprpub/pr/tests/op_filok.c
nsprpub/pr/tests/op_nofil.c
nsprpub/pr/tests/openfile.c
nsprpub/pr/tests/parent.c
nsprpub/pr/tests/parsetm.c
nsprpub/pr/tests/peek.c
nsprpub/pr/tests/perf.c
nsprpub/pr/tests/pipeself.c
nsprpub/pr/tests/poll_er.c
nsprpub/pr/tests/poll_nm.c
nsprpub/pr/tests/poll_to.c
nsprpub/pr/tests/pollable.c
nsprpub/pr/tests/prftest.c
nsprpub/pr/tests/prftest1.c
nsprpub/pr/tests/prftest2.c
nsprpub/pr/tests/primblok.c
nsprpub/pr/tests/priotest.c
nsprpub/pr/tests/provider.c
nsprpub/pr/tests/prpoll.c
nsprpub/pr/tests/prpollml.c
nsprpub/pr/tests/prselect.c
nsprpub/pr/tests/randseed.c
nsprpub/pr/tests/ranfile.c
nsprpub/pr/tests/rmdir.c
nsprpub/pr/tests/rwlockrank.c
nsprpub/pr/tests/rwlocktest.c
nsprpub/pr/tests/sel_spd.c
nsprpub/pr/tests/selct_er.c
nsprpub/pr/tests/selct_nm.c
nsprpub/pr/tests/selct_to.c
nsprpub/pr/tests/select2.c
nsprpub/pr/tests/sem.c
nsprpub/pr/tests/sema.c
nsprpub/pr/tests/semaerr.c
nsprpub/pr/tests/semaerr1.c
nsprpub/pr/tests/semaping.c
nsprpub/pr/tests/semapong.c
nsprpub/pr/tests/sendzlf.c
nsprpub/pr/tests/server_test.c
nsprpub/pr/tests/servr_kk.c
nsprpub/pr/tests/servr_ku.c
nsprpub/pr/tests/servr_uk.c
nsprpub/pr/tests/servr_uu.c
nsprpub/pr/tests/short_thread.c
nsprpub/pr/tests/sigpipe.c
nsprpub/pr/tests/sleep.c
nsprpub/pr/tests/socket.c
nsprpub/pr/tests/sockopt.c
nsprpub/pr/tests/sprintf.c
nsprpub/pr/tests/stack.c
nsprpub/pr/tests/stat.c
nsprpub/pr/tests/stdio.c
nsprpub/pr/tests/strod.c
nsprpub/pr/tests/suspend.c
nsprpub/pr/tests/switch.c
nsprpub/pr/tests/system.c
nsprpub/pr/tests/testbit.c
nsprpub/pr/tests/testfile.c
nsprpub/pr/tests/threads.c
nsprpub/pr/tests/thrpool_client.c
nsprpub/pr/tests/thrpool_server.c
nsprpub/pr/tests/thruput.c
nsprpub/pr/tests/time.c
nsprpub/pr/tests/timemac.c
nsprpub/pr/tests/timetest.c
nsprpub/pr/tests/tmoacc.c
nsprpub/pr/tests/tmocon.c
nsprpub/pr/tests/tpd.c
nsprpub/pr/tests/udpsrv.c
nsprpub/pr/tests/vercheck.c
nsprpub/pr/tests/version.c
nsprpub/pr/tests/writev.c
nsprpub/pr/tests/xnotify.c
nsprpub/pr/tests/y2k.c
nsprpub/pr/tests/y2ktmo.c
nsprpub/pr/tests/yield.c
nsprpub/pr/tests/zerolen.c
nsprpub/tools/httpget.c
nsprpub/tools/tail.c
--- a/nsprpub/TAG-INFO
+++ b/nsprpub/TAG-INFO
@@ -1,1 +1,1 @@
-NSPR_4_22_RTM
+NSPR_4_23_BETA1
\ No newline at end of file
--- a/nsprpub/config/libc_r.h
+++ b/nsprpub/config/libc_r.h
@@ -20,17 +20,17 @@
 #define _LIBC_R_H
 
 /************/
 /*  strtok  */
 /************/
 #define R_STRTOK_INIT_R() \
     char *r_strtok_r=NULL
 
-#define R_STRTOK_R(return,source,delim) \     
+#define R_STRTOK_R(return,source,delim) \
     return=strtok_r(source,delim,&r_strtok_r)
 
 #define R_STRTOK_NORET_R(source,delim) \
     strtok_r(source,delim,&r_strtok_r)
 
 /**************/
 /*  strerror  */
 /**************/
@@ -63,24 +63,24 @@
 #define R_GMTIME_R(time) \
     gmtime_r(time,&r_gmtime_r)
 
 #define R_LOCALTIME_INIT_R() \
    struct tm r_localtime_r
 
 #define R_LOCALTIME_R(val) \
    localtime_r(val,&r_localtime_r)
-    
+
 /***********/
 /*  crypt  */
 /***********/
 #include <crypt.h>
 #define R_CRYPT_INIT_R() \
     CRYPTD r_cryptd_r; \
-    bzero(&r_cryptd_r,sizeof(CRYPTD)) 
+    bzero(&r_cryptd_r,sizeof(CRYPTD))
 
 #define R_CRYPT_R(pass,salt) \
     crypt_r(pass,salt,&r_cryptd_r)
 
 /**************/
 /*  pw stuff  */
 /**************/
 #define R_MAX_PW_LEN_R 1024
--- a/nsprpub/config/nsinstall.c
+++ b/nsprpub/config/nsinstall.c
@@ -34,95 +34,102 @@
 /*
  * Does getcwd() take NULL as the first argument and malloc
  * the result buffer?
  */
 #if !defined(DARWIN)
 #define GETCWD_CAN_MALLOC
 #endif
 
-#if defined(LINUX) || defined(__GNU__) || defined(__GLIBC__) 
+#if defined(LINUX) || defined(__GNU__) || defined(__GLIBC__)
 #include <getopt.h>
 #endif
 
 #if defined(SCO) || defined(UNIXWARE)
 #if !defined(S_ISLNK) && defined(S_IFLNK)
-#define S_ISLNK(a)	(((a) & S_IFMT) == S_IFLNK)
+#define S_ISLNK(a)  (((a) & S_IFMT) == S_IFLNK)
 #endif
 #endif
 
 #ifdef QNX
 #define d_ino d_stat.st_ino
 #endif
 
 static void
 usage(void)
 {
     fprintf(stderr,
-	"usage: %s [-C cwd] [-L linkprefix] [-m mode] [-o owner] [-g group]\n"
-	"       %*s [-DdltR] file [file ...] directory\n",
-	program, (int)strlen(program), "");
+            "usage: %s [-C cwd] [-L linkprefix] [-m mode] [-o owner] [-g group]\n"
+            "       %*s [-DdltR] file [file ...] directory\n",
+            program, (int)strlen(program), "");
     exit(2);
 }
 
 static int
 mkdirs(char *path, mode_t mode)
 {
     char *cp;
     struct stat sb;
     int res;
-    
-    while (*path == '/' && path[1] == '/')
-	path++;
+
+    while (*path == '/' && path[1] == '/') {
+        path++;
+    }
     for (cp = strrchr(path, '/'); cp && cp != path && cp[-1] == '/'; cp--)
-	;
+        ;
     if (cp && cp != path) {
-	*cp = '\0';
-	if ((stat(path, &sb) < 0 || !S_ISDIR(sb.st_mode)) &&
-	    mkdirs(path, mode) < 0) {
-	    return -1;
-	}
-	*cp = '/';
+        *cp = '\0';
+        if ((stat(path, &sb) < 0 || !S_ISDIR(sb.st_mode)) &&
+            mkdirs(path, mode) < 0) {
+            return -1;
+        }
+        *cp = '/';
     }
     res = mkdir(path, mode);
-    if ((res != 0) && (errno == EEXIST))
-	return 0;
-     else
-	return res;
+    if ((res != 0) && (errno == EEXIST)) {
+        return 0;
+    }
+    else {
+        return res;
+    }
 }
 
 static uid_t
 touid(char *owner)
 {
     struct passwd *pw;
     uid_t uid;
     char *cp;
 
     pw = getpwnam(owner);
-    if (pw)
-	return pw->pw_uid;
+    if (pw) {
+        return pw->pw_uid;
+    }
     uid = strtol(owner, &cp, 0);
-    if (uid == 0 && cp == owner)
-	fail("cannot find uid for %s", owner);
+    if (uid == 0 && cp == owner) {
+        fail("cannot find uid for %s", owner);
+    }
     return uid;
 }
 
 static gid_t
 togid(char *group)
 {
     struct group *gr;
     gid_t gid;
     char *cp;
 
     gr = getgrnam(group);
-    if (gr)
-	return gr->gr_gid;
+    if (gr) {
+        return gr->gr_gid;
+    }
     gid = strtol(group, &cp, 0);
-    if (gid == 0 && cp == group)
-	fail("cannot find gid for %s", group);
+    if (gid == 0 && cp == group) {
+        fail("cannot find gid for %s", group);
+    }
     return gid;
 }
 
 int
 main(int argc, char **argv)
 {
     int onlydir, dodir, dolink, dorelsymlink, dotimes, opt, len, lplen, tdlen, bnlen, exists, fromfd, tofd, cc, wc;
     mode_t mode = 0755;
@@ -132,205 +139,222 @@ main(int argc, char **argv)
     struct stat sb, tosb;
     struct utimbuf utb;
 
     program = argv[0];
     cwd = linkname = linkprefix = owner = group = 0;
     onlydir = dodir = dolink = dorelsymlink = dotimes = lplen = 0;
 
     while ((opt = getopt(argc, argv, "C:DdlL:Rm:o:g:t")) != EOF) {
-	switch (opt) {
-	  case 'C':
-	    cwd = optarg;
-	    break;
-	  case 'D':
-	    onlydir = 1;
-	    break;
-	  case 'd':
-	    dodir = 1;
-	    break;
-	  case 'l':
-	    dolink = 1;
-	    break;
-	  case 'L':
-	    linkprefix = optarg;
-	    lplen = strlen(linkprefix);
-	    dolink = 1;
-	    break;
-	  case 'R':
-	    dolink = dorelsymlink = 1;
-	    break;
-	  case 'm':
-	    mode = strtoul(optarg, &cp, 8);
-	    if (mode == 0 && cp == optarg)
-		usage();
-	    break;
-	  case 'o':
-	    owner = optarg;
-	    break;
-	  case 'g':
-	    group = optarg;
-	    break;
-	  case 't':
-	    dotimes = 1;
-	    break;
-	  default:
-	    usage();
-	}
+        switch (opt) {
+            case 'C':
+                cwd = optarg;
+                break;
+            case 'D':
+                onlydir = 1;
+                break;
+            case 'd':
+                dodir = 1;
+                break;
+            case 'l':
+                dolink = 1;
+                break;
+            case 'L':
+                linkprefix = optarg;
+                lplen = strlen(linkprefix);
+                dolink = 1;
+                break;
+            case 'R':
+                dolink = dorelsymlink = 1;
+                break;
+            case 'm':
+                mode = strtoul(optarg, &cp, 8);
+                if (mode == 0 && cp == optarg) {
+                    usage();
+                }
+                break;
+            case 'o':
+                owner = optarg;
+                break;
+            case 'g':
+                group = optarg;
+                break;
+            case 't':
+                dotimes = 1;
+                break;
+            default:
+                usage();
+        }
     }
 
     argc -= optind;
     argv += optind;
-    if (argc < 2 - onlydir)
-	usage();
+    if (argc < 2 - onlydir) {
+        usage();
+    }
 
     todir = argv[argc-1];
     if ((stat(todir, &sb) < 0 || !S_ISDIR(sb.st_mode)) &&
-	mkdirs(todir, 0777) < 0) {
-	fail("cannot make directory %s", todir);
+        mkdirs(todir, 0777) < 0) {
+        fail("cannot make directory %s", todir);
     }
-    if (onlydir)
-	return 0;
+    if (onlydir) {
+        return 0;
+    }
 
     if (!cwd) {
 #ifdef GETCWD_CAN_MALLOC
-	cwd = getcwd(0, PATH_MAX);
+        cwd = getcwd(0, PATH_MAX);
 #else
-	cwd = malloc(PATH_MAX + 1);
-	cwd = getcwd(cwd, PATH_MAX);
+        cwd = malloc(PATH_MAX + 1);
+        cwd = getcwd(cwd, PATH_MAX);
 #endif
     }
     xchdir(todir);
 #ifdef GETCWD_CAN_MALLOC
     todir = getcwd(0, PATH_MAX);
 #else
     todir = malloc(PATH_MAX + 1);
     todir = getcwd(todir, PATH_MAX);
 #endif
     xchdir(cwd);
     tdlen = strlen(todir);
 
     uid = owner ? touid(owner) : -1;
     gid = group ? togid(group) : -1;
 
     while (--argc > 0) {
-	name = *argv++;
-	len = strlen(name);
-	base = xbasename(name);
-	bnlen = strlen(base);
-	toname = (char*)xmalloc(tdlen + 1 + bnlen + 1);
-	sprintf(toname, "%s/%s", todir, base);
-	exists = (lstat(toname, &tosb) == 0);
+        name = *argv++;
+        len = strlen(name);
+        base = xbasename(name);
+        bnlen = strlen(base);
+        toname = (char*)xmalloc(tdlen + 1 + bnlen + 1);
+        sprintf(toname, "%s/%s", todir, base);
+        exists = (lstat(toname, &tosb) == 0);
 
-	if (dodir) {
-	    /* -d means create a directory, always */
-	    if (exists && !S_ISDIR(tosb.st_mode)) {
-		(void) unlink(toname);
-		exists = 0;
-	    }
-	    if (!exists && mkdir(toname, mode) < 0)
-		fail("cannot make directory %s", toname);
-	    if ((owner || group) && chown(toname, uid, gid) < 0)
-		fail("cannot change owner of %s", toname);
-	} else if (dolink) {
-	    if (*name == '/') {
-		/* source is absolute pathname, link to it directly */
-		linkname = 0;
-	    } else {
-		if (linkprefix) {
-		    /* -L implies -l and prefixes names with a $cwd arg. */
-		    len += lplen + 1;
-		    linkname = (char*)xmalloc(len + 1);
-		    sprintf(linkname, "%s/%s", linkprefix, name);
-		} else if (dorelsymlink) {
-		    /* Symlink the relative path from todir to source name. */
-		    linkname = (char*)xmalloc(PATH_MAX);
+        if (dodir) {
+            /* -d means create a directory, always */
+            if (exists && !S_ISDIR(tosb.st_mode)) {
+                (void) unlink(toname);
+                exists = 0;
+            }
+            if (!exists && mkdir(toname, mode) < 0) {
+                fail("cannot make directory %s", toname);
+            }
+            if ((owner || group) && chown(toname, uid, gid) < 0) {
+                fail("cannot change owner of %s", toname);
+            }
+        } else if (dolink) {
+            if (*name == '/') {
+                /* source is absolute pathname, link to it directly */
+                linkname = 0;
+            } else {
+                if (linkprefix) {
+                    /* -L implies -l and prefixes names with a $cwd arg. */
+                    len += lplen + 1;
+                    linkname = (char*)xmalloc(len + 1);
+                    sprintf(linkname, "%s/%s", linkprefix, name);
+                } else if (dorelsymlink) {
+                    /* Symlink the relative path from todir to source name. */
+                    linkname = (char*)xmalloc(PATH_MAX);
 
-		    if (*todir == '/') {
-			/* todir is absolute: skip over common prefix. */
-			lplen = relatepaths(todir, cwd, linkname);
-			strcpy(linkname + lplen, name);
-		    } else {
-			/* todir is named by a relative path: reverse it. */
-			reversepath(todir, name, len, linkname);
-			xchdir(cwd);
-		    }
+                    if (*todir == '/') {
+                        /* todir is absolute: skip over common prefix. */
+                        lplen = relatepaths(todir, cwd, linkname);
+                        strcpy(linkname + lplen, name);
+                    } else {
+                        /* todir is named by a relative path: reverse it. */
+                        reversepath(todir, name, len, linkname);
+                        xchdir(cwd);
+                    }
+
+                    len = strlen(linkname);
+                }
+                name = linkname;
+            }
 
-		    len = strlen(linkname);
-		}
-		name = linkname;
-	    }
-
-	    /* Check for a pre-existing symlink with identical content. */
-	    if (exists &&
-		(!S_ISLNK(tosb.st_mode) ||
-		 readlink(toname, buf, sizeof buf) != len ||
-		 strncmp(buf, name, len) != 0)) {
-		(void) (S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
-		exists = 0;
-	    }
-	    if (!exists && symlink(name, toname) < 0)
-		fail("cannot make symbolic link %s", toname);
+            /* Check for a pre-existing symlink with identical content. */
+            if (exists &&
+                (!S_ISLNK(tosb.st_mode) ||
+                 readlink(toname, buf, sizeof buf) != len ||
+                 strncmp(buf, name, len) != 0)) {
+                (void) (S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
+                exists = 0;
+            }
+            if (!exists && symlink(name, toname) < 0) {
+                fail("cannot make symbolic link %s", toname);
+            }
 #ifdef HAVE_LCHOWN
-	    if ((owner || group) && lchown(toname, uid, gid) < 0)
-		fail("cannot change owner of %s", toname);
+            if ((owner || group) && lchown(toname, uid, gid) < 0) {
+                fail("cannot change owner of %s", toname);
+            }
 #endif
 
-	    if (linkname) {
-		free(linkname);
-		linkname = 0;
-	    }
-	} else {
-	    /* Copy from name to toname, which might be the same file. */
-	    fromfd = open(name, O_RDONLY);
-	    if (fromfd < 0 || fstat(fromfd, &sb) < 0)
-		fail("cannot access %s", name);
-	    if (exists && (!S_ISREG(tosb.st_mode) || access(toname, W_OK) < 0))
-		(void) (S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
-	    tofd = open(toname, O_CREAT | O_WRONLY, 0666);
-	    if (tofd < 0)
-		fail("cannot create %s", toname);
+            if (linkname) {
+                free(linkname);
+                linkname = 0;
+            }
+        } else {
+            /* Copy from name to toname, which might be the same file. */
+            fromfd = open(name, O_RDONLY);
+            if (fromfd < 0 || fstat(fromfd, &sb) < 0) {
+                fail("cannot access %s", name);
+            }
+            if (exists && (!S_ISREG(tosb.st_mode) || access(toname, W_OK) < 0)) {
+                (void) (S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
+            }
+            tofd = open(toname, O_CREAT | O_WRONLY, 0666);
+            if (tofd < 0) {
+                fail("cannot create %s", toname);
+            }
 
-	    bp = buf;
-	    while ((cc = read(fromfd, bp, sizeof buf)) > 0) {
-		while ((wc = write(tofd, bp, cc)) > 0) {
-		    if ((cc -= wc) == 0)
-			break;
-		    bp += wc;
-		}
-		if (wc < 0)
-		    fail("cannot write to %s", toname);
-	    }
-	    if (cc < 0)
-		fail("cannot read from %s", name);
+            bp = buf;
+            while ((cc = read(fromfd, bp, sizeof buf)) > 0) {
+                while ((wc = write(tofd, bp, cc)) > 0) {
+                    if ((cc -= wc) == 0) {
+                        break;
+                    }
+                    bp += wc;
+                }
+                if (wc < 0) {
+                    fail("cannot write to %s", toname);
+                }
+            }
+            if (cc < 0) {
+                fail("cannot read from %s", name);
+            }
 
-	    if (ftruncate(tofd, sb.st_size) < 0)
-		fail("cannot truncate %s", toname);
-	    if (dotimes) {
-		utb.actime = sb.st_atime;
-		utb.modtime = sb.st_mtime;
-		if (utime(toname, &utb) < 0)
-		    fail("cannot set times of %s", toname);
-	    }
+            if (ftruncate(tofd, sb.st_size) < 0) {
+                fail("cannot truncate %s", toname);
+            }
+            if (dotimes) {
+                utb.actime = sb.st_atime;
+                utb.modtime = sb.st_mtime;
+                if (utime(toname, &utb) < 0) {
+                    fail("cannot set times of %s", toname);
+                }
+            }
 #ifdef HAVE_FCHMOD
-	    if (fchmod(tofd, mode) < 0)
+            if (fchmod(tofd, mode) < 0)
 #else
-	    if (chmod(toname, mode) < 0)
+            if (chmod(toname, mode) < 0)
 #endif
-		fail("cannot change mode of %s", toname);
-	    if ((owner || group) && fchown(tofd, uid, gid) < 0)
-		fail("cannot change owner of %s", toname);
+                fail("cannot change mode of %s", toname);
+            if ((owner || group) && fchown(tofd, uid, gid) < 0) {
+                fail("cannot change owner of %s", toname);
+            }
 
-	    /* Must check for delayed (NFS) write errors on close. */
-	    if (close(tofd) < 0)
-		fail("cannot write to %s", toname);
-	    close(fromfd);
-	}
+            /* Must check for delayed (NFS) write errors on close. */
+            if (close(tofd) < 0) {
+                fail("cannot write to %s", toname);
+            }
+            close(fromfd);
+        }
 
-	free(toname);
+        free(toname);
     }
 
     free(cwd);
     free(todir);
     return 0;
 }
 
 /*
@@ -354,169 +378,183 @@ fail(char *format, ...)
     error = errno;
     fprintf(stderr, "%s: ", program);
     va_start(ap, format);
     vfprintf(stderr, format, ap);
     va_end(ap);
     if (error)
 
 #ifdef USE_REENTRANT_LIBC
-    R_STRERROR_R(errno);
-	fprintf(stderr, ": %s", r_strerror_r);
+        R_STRERROR_R(errno);
+    fprintf(stderr, ": %s", r_strerror_r);
 #else
-	fprintf(stderr, ": %s", strerror(errno));
+        fprintf(stderr, ": %s", strerror(errno));
 #endif
 
     putc('\n', stderr);
     exit(1);
 }
 
 char *
 getcomponent(char *path, char *name)
 {
-    if (*path == '\0')
-	return 0;
+    if (*path == '\0') {
+        return 0;
+    }
     if (*path == '/') {
-	*name++ = '/';
+        *name++ = '/';
     } else {
-	do {
-	    *name++ = *path++;
-	} while (*path != '/' && *path != '\0');
+        do {
+            *name++ = *path++;
+        } while (*path != '/' && *path != '\0');
     }
     *name = '\0';
-    while (*path == '/')
-	path++;
+    while (*path == '/') {
+        path++;
+    }
     return path;
 }
 
 #ifdef UNIXWARE_READDIR_BUFFER_TOO_SMALL
 /* Sigh.  The static buffer in Unixware's readdir is too small. */
 struct dirent * readdir(DIR *d)
 {
-        static struct dirent *buf = NULL;
+    static struct dirent *buf = NULL;
 #define MAX_PATH_LEN 1024
 
 
-        if(buf == NULL)
-                buf = (struct dirent *) malloc(sizeof(struct dirent) + MAX_PATH_LEN)
-;
-        return(readdir_r(d, buf));
+    if(buf == NULL)
+        buf = (struct dirent *) malloc(sizeof(struct dirent) + MAX_PATH_LEN)
+              ;
+    return(readdir_r(d, buf));
 }
 #endif
 
 char *
 ino2name(ino_t ino, char *dir)
 {
     DIR *dp;
     struct dirent *ep;
     char *name;
 
     dp = opendir("..");
-    if (!dp)
-	fail("cannot read parent directory");
+    if (!dp) {
+        fail("cannot read parent directory");
+    }
     for (;;) {
-	if (!(ep = readdir(dp)))
-	    fail("cannot find current directory");
-	if (ep->d_ino == ino)
-	    break;
+        if (!(ep = readdir(dp))) {
+            fail("cannot find current directory");
+        }
+        if (ep->d_ino == ino) {
+            break;
+        }
     }
     name = xstrdup(ep->d_name);
     closedir(dp);
     return name;
 }
 
 void *
 xmalloc(size_t size)
 {
     void *p = malloc(size);
-    if (!p)
-	fail("cannot allocate %u bytes", size);
+    if (!p) {
+        fail("cannot allocate %u bytes", size);
+    }
     return p;
 }
 
 char *
 xstrdup(char *s)
 {
     return strcpy((char*)xmalloc(strlen(s) + 1), s);
 }
 
 char *
 xbasename(char *path)
 {
     char *cp;
 
-    while ((cp = strrchr(path, '/')) && cp[1] == '\0')
-	*cp = '\0';
-    if (!cp) return path;
+    while ((cp = strrchr(path, '/')) && cp[1] == '\0') {
+        *cp = '\0';
+    }
+    if (!cp) {
+        return path;
+    }
     return cp + 1;
 }
 
 void
 xchdir(char *dir)
 {
-    if (chdir(dir) < 0)
-	fail("cannot change directory to %s", dir);
+    if (chdir(dir) < 0) {
+        fail("cannot change directory to %s", dir);
+    }
 }
 
 int
 relatepaths(char *from, char *to, char *outpath)
 {
     char *cp, *cp2;
     int len;
     char buf[NAME_MAX];
 
     assert(*from == '/' && *to == '/');
     for (cp = to, cp2 = from; *cp == *cp2; cp++, cp2++)
-	if (*cp == '\0')
-	    break;
-    while (cp[-1] != '/')
-	cp--, cp2--;
+        if (*cp == '\0') {
+            break;
+        }
+    while (cp[-1] != '/') {
+        cp--, cp2--;
+    }
     if (cp - 1 == to) {
-	/* closest common ancestor is /, so use full pathname */
-	len = strlen(strcpy(outpath, to));
-	if (outpath[len] != '/') {
-	    outpath[len++] = '/';
-	    outpath[len] = '\0';
-	}
+        /* closest common ancestor is /, so use full pathname */
+        len = strlen(strcpy(outpath, to));
+        if (outpath[len] != '/') {
+            outpath[len++] = '/';
+            outpath[len] = '\0';
+        }
     } else {
-	len = 0;
-	while ((cp2 = getcomponent(cp2, buf)) != 0) {
-	    strcpy(outpath + len, "../");
-	    len += 3;
-	}
-	while ((cp = getcomponent(cp, buf)) != 0) {
-	    sprintf(outpath + len, "%s/", buf);
-	    len += strlen(outpath + len);
-	}
+        len = 0;
+        while ((cp2 = getcomponent(cp2, buf)) != 0) {
+            strcpy(outpath + len, "../");
+            len += 3;
+        }
+        while ((cp = getcomponent(cp, buf)) != 0) {
+            sprintf(outpath + len, "%s/", buf);
+            len += strlen(outpath + len);
+        }
     }
     return len;
 }
 
 void
 reversepath(char *inpath, char *name, int len, char *outpath)
 {
     char *cp, *cp2;
     char buf[NAME_MAX];
     struct stat sb;
 
     cp = strcpy(outpath + PATH_MAX - (len + 1), name);
     cp2 = inpath;
     while ((cp2 = getcomponent(cp2, buf)) != 0) {
-	if (strcmp(buf, ".") == 0)
-	    continue;
-	if (strcmp(buf, "..") == 0) {
-	    if (stat(".", &sb) < 0)
-		fail("cannot stat current directory");
-	    name = ino2name(sb.st_ino, "..");
-	    len = strlen(name);
-	    cp -= len + 1;
-	    strcpy(cp, name);
-	    cp[len] = '/';
-	    free(name);
-	    xchdir("..");
-	} else {
-	    cp -= 3;
-	    memcpy(cp, "../", 3);
-	    xchdir(buf);
-	}
+        if (strcmp(buf, ".") == 0) {
+            continue;
+        }
+        if (strcmp(buf, "..") == 0) {
+            if (stat(".", &sb) < 0) {
+                fail("cannot stat current directory");
+            }
+            name = ino2name(sb.st_ino, "..");
+            len = strlen(name);
+            cp -= len + 1;
+            strcpy(cp, name);
+            cp[len] = '/';
+            free(name);
+            xchdir("..");
+        } else {
+            cp -= 3;
+            memcpy(cp, "../", 3);
+            xchdir(buf);
+        }
     }
     strcpy(outpath, cp);
 }
--- a/nsprpub/config/prdepend.h
+++ b/nsprpub/config/prdepend.h
@@ -5,9 +5,8 @@
 
 /*
  * A dummy header file that is a dependency for all the object files.
  * Used to force a full recompilation of NSPR in Mozilla's Tinderbox
  * depend builds.  See comments in rules.mk.
  */
 
 #error "Do not include this header file."
-
--- a/nsprpub/configure
+++ b/nsprpub/configure
@@ -2481,17 +2481,17 @@ case $target_os in *\ *) target_os=`echo
 # The aliases save the names the user supplied, while $host etc.
 # will get canonicalized.
 test -n "$target_alias" &&
   test "$program_prefix$program_suffix$program_transform_name" = \
     NONENONEs,x,x, &&
   program_prefix=${target_alias}-
 
 MOD_MAJOR_VERSION=4
-MOD_MINOR_VERSION=22
+MOD_MINOR_VERSION=23
 MOD_PATCH_VERSION=0
 NSPR_MODNAME=nspr20
 _HAVE_PTHREADS=
 USE_PTHREADS=
 USE_USER_PTHREADS=
 USE_NSPR_THREADS=
 USE_N32=
 USE_X32=
--- a/nsprpub/configure.in
+++ b/nsprpub/configure.in
@@ -10,17 +10,17 @@ AC_CONFIG_SRCDIR([pr/include/nspr.h])
 
 AC_CONFIG_AUX_DIR(${srcdir}/build/autoconf)
 AC_CANONICAL_TARGET
 
 dnl ========================================================
 dnl = Defaults
 dnl ========================================================
 MOD_MAJOR_VERSION=4
-MOD_MINOR_VERSION=22
+MOD_MINOR_VERSION=23
 MOD_PATCH_VERSION=0
 NSPR_MODNAME=nspr20
 _HAVE_PTHREADS=
 USE_PTHREADS=
 USE_USER_PTHREADS=
 USE_NSPR_THREADS=
 USE_N32=
 USE_X32=
--- a/nsprpub/lib/ds/plarena.c
+++ b/nsprpub/lib/ds/plarena.c
@@ -30,141 +30,151 @@ static PLArenaStats *arena_stats_list;
 PR_IMPLEMENT(void) PL_InitArenaPool(
     PLArenaPool *pool, const char *name, PRUint32 size, PRUint32 align)
 {
     /*
      * Look-up table of PR_BITMASK(PR_CeilingLog2(align)) values for
      * align = 1 to 32.
      */
     static const PRUint8 pmasks[33] = {
-         0,                                               /*  not used */
-         0, 1, 3, 3, 7, 7, 7, 7,15,15,15,15,15,15,15,15,  /*  1 ... 16 */
-        31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31}; /* 17 ... 32 */
+        0,                                               /*  not used */
+        0, 1, 3, 3, 7, 7, 7, 7,15,15,15,15,15,15,15,15,  /*  1 ... 16 */
+        31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31   /* 17 ... 32 */
+    };
 
-    if (align == 0)
+    if (align == 0) {
         align = PL_ARENA_DEFAULT_ALIGN;
+    }
 
-    if (align < sizeof(pmasks)/sizeof(pmasks[0]))
+    if (align < sizeof(pmasks)/sizeof(pmasks[0])) {
         pool->mask = pmasks[align];
-    else
+    }
+    else {
         pool->mask = PR_BITMASK(PR_CeilingLog2(align));
+    }
 
     pool->first.next = NULL;
     /* Set all three addresses in pool->first to the same dummy value.
      * These addresses are only compared with each other, but never
      * dereferenced. */
     pool->first.base = pool->first.avail = pool->first.limit =
-        (PRUword)PL_ARENA_ALIGN(pool, &pool->first + 1);
+            (PRUword)PL_ARENA_ALIGN(pool, &pool->first + 1);
     pool->current = &pool->first;
     /*
      * Compute the net size so that each arena's gross size is |size|.
      * sizeof(PLArena) + pool->mask is the header and alignment slop
      * that PL_ArenaAllocate adds to the net size.
      */
-    if (size > sizeof(PLArena) + pool->mask)
+    if (size > sizeof(PLArena) + pool->mask) {
         pool->arenasize = size - (sizeof(PLArena) + pool->mask);
-    else
+    }
+    else {
         pool->arenasize = size;
+    }
 #ifdef PL_ARENAMETER
     memset(&pool->stats, 0, sizeof pool->stats);
     pool->stats.name = strdup(name);
     pool->stats.next = arena_stats_list;
     arena_stats_list = &pool->stats;
 #endif
 }
 
 
 /*
 ** PL_ArenaAllocate() -- allocate space from an arena pool
-** 
+**
 ** Description: PL_ArenaAllocate() allocates space from an arena
-** pool. 
+** pool.
 **
 ** First, try to satisfy the request from arenas starting at
 ** pool->current. Then try to allocate a new arena from the heap.
 **
 ** Returns: pointer to allocated space or NULL
-** 
+**
 ** Notes: The original implementation had some difficult to
 ** solve bugs; the code was difficult to read. Sometimes it's
 ** just easier to rewrite it. I did that. larryh.
 **
 ** See also: bugzilla: 45343.
 **
 */
 
 PR_IMPLEMENT(void *) PL_ArenaAllocate(PLArenaPool *pool, PRUint32 nb)
 {
-    PLArena *a;   
+    PLArena *a;
     char *rp;     /* returned pointer */
     PRUint32 nbOld;
 
     PR_ASSERT((nb & pool->mask) == 0);
-    
+
     nbOld = nb;
     nb = (PRUword)PL_ARENA_ALIGN(pool, nb); /* force alignment */
-    if (nb < nbOld)
+    if (nb < nbOld) {
         return NULL;
+    }
 
     /* attempt to allocate from arenas at pool->current */
     {
         a = pool->current;
         do {
             if ( nb <= a->limit - a->avail )  {
                 pool->current = a;
                 rp = (char *)a->avail;
                 a->avail += nb;
                 return rp;
             }
         } while( NULL != (a = a->next) );
     }
 
-    /* attempt to allocate from the heap */ 
-    {  
+    /* attempt to allocate from the heap */
+    {
         PRUint32 sz = PR_MAX(pool->arenasize, nb);
         if (PR_UINT32_MAX - sz < sizeof *a + pool->mask) {
             a = NULL;
         } else {
             sz += sizeof *a + pool->mask;  /* header and alignment slop */
             a = (PLArena*)PR_MALLOC(sz);
         }
         if ( NULL != a )  {
             a->limit = (PRUword)a + sz;
             a->base = a->avail = (PRUword)PL_ARENA_ALIGN(pool, a + 1);
             PL_MAKE_MEM_NOACCESS((void*)a->avail, a->limit - a->avail);
             rp = (char *)a->avail;
             a->avail += nb;
             PR_ASSERT(a->avail <= a->limit);
-            /* the newly allocated arena is linked after pool->current 
+            /* the newly allocated arena is linked after pool->current
             *  and becomes pool->current */
             a->next = pool->current->next;
             pool->current->next = a;
             pool->current = a;
-            if ( NULL == pool->first.next )
+            if ( NULL == pool->first.next ) {
                 pool->first.next = a;
+            }
             PL_COUNT_ARENA(pool,++);
             COUNT(pool, nmallocs);
             return(rp);
         }
     }
 
     /* we got to here, and there's no memory to allocate */
     return(NULL);
 } /* --- end PL_ArenaAllocate() --- */
 
 PR_IMPLEMENT(void *) PL_ArenaGrow(
     PLArenaPool *pool, void *p, PRUint32 size, PRUint32 incr)
 {
     void *newp;
 
-    if (PR_UINT32_MAX - size < incr)
+    if (PR_UINT32_MAX - size < incr) {
         return NULL;
+    }
     PL_ARENA_ALLOCATE(newp, pool, size + incr);
-    if (newp)
+    if (newp) {
         memcpy(newp, p, size);
+    }
     return newp;
 }
 
 PR_IMPLEMENT(void) PL_ClearArenaPool(PLArenaPool *pool, PRInt32 pattern)
 {
     PLArena *a;
 
     for (a = pool->first.next; a; a = a->next) {
@@ -177,18 +187,19 @@ PR_IMPLEMENT(void) PL_ClearArenaPool(PLA
 
 /*
  * Free tail arenas linked after head, which may not be the true list head.
  * Reset pool->current to point to head in case it pointed at a tail arena.
  */
 static void FreeArenaList(PLArenaPool *pool, PLArena *head)
 {
     PLArena *a = head->next;
-    if (!a)
+    if (!a) {
         return;
+    }
 
     head->next = NULL;
 
     do {
         PLArena *tmp = a;
         a = a->next;
         PL_CLEAR_ARENA(tmp);
         PL_COUNT_ARENA(pool,--);
@@ -219,18 +230,19 @@ PR_IMPLEMENT(void) PL_FreeArenaPool(PLAr
 
 PR_IMPLEMENT(void) PL_FinishArenaPool(PLArenaPool *pool)
 {
     FreeArenaList(pool, &pool->first);
 #ifdef PL_ARENAMETER
     {
         PLArenaStats *stats, **statsp;
 
-        if (pool->stats.name)
+        if (pool->stats.name) {
             PR_DELETE(pool->stats.name);
+        }
         for (statsp = &arena_stats_list; (stats = *statsp) != 0;
              statsp = &stats->next) {
             if (stats == &pool->stats) {
                 *statsp = stats->next;
                 return;
             }
         }
     }
@@ -261,36 +273,38 @@ PR_IMPLEMENT(size_t) PL_SizeOfArenaPoolE
     return size;
 }
 
 #ifdef PL_ARENAMETER
 PR_IMPLEMENT(void) PL_ArenaCountAllocation(PLArenaPool *pool, PRUint32 nb)
 {
     pool->stats.nallocs++;
     pool->stats.nbytes += nb;
-    if (nb > pool->stats.maxalloc)
+    if (nb > pool->stats.maxalloc) {
         pool->stats.maxalloc = nb;
+    }
     pool->stats.variance += nb * nb;
 }
 
 PR_IMPLEMENT(void) PL_ArenaCountInplaceGrowth(
     PLArenaPool *pool, PRUint32 size, PRUint32 incr)
 {
     pool->stats.ninplace++;
 }
 
 PR_IMPLEMENT(void) PL_ArenaCountGrowth(
     PLArenaPool *pool, PRUint32 size, PRUint32 incr)
 {
     pool->stats.ngrows++;
     pool->stats.nbytes += incr;
     pool->stats.variance -= size * size;
     size += incr;
-    if (size > pool->stats.maxalloc)
+    if (size > pool->stats.maxalloc) {
         pool->stats.maxalloc = size;
+    }
     pool->stats.variance += size * size;
 }
 
 PR_IMPLEMENT(void) PL_ArenaCountRelease(PLArenaPool *pool, char *mark)
 {
     pool->stats.nreleases++;
 }
 
--- a/nsprpub/lib/ds/plhash.c
+++ b/nsprpub/lib/ds/plhash.c
@@ -46,18 +46,19 @@ static PLHashEntry * PR_CALLBACK
 DefaultAllocEntry(void *pool, const void *key)
 {
     return PR_NEW(PLHashEntry);
 }
 
 static void PR_CALLBACK
 DefaultFreeEntry(void *pool, PLHashEntry *he, PRUintn flag)
 {
-    if (flag == HT_FREE_ENTRY)
+    if (flag == HT_FREE_ENTRY) {
         PR_Free(he);
+    }
 }
 
 static PLHashAllocOps defaultHashAllocOps = {
     DefaultAllocTable, DefaultFreeTable,
     DefaultAllocEntry, DefaultFreeEntry
 };
 
 PR_IMPLEMENT(PLHashTable *)
@@ -67,25 +68,29 @@ PL_NewHashTable(PRUint32 n, PLHashFuncti
 {
     PLHashTable *ht;
     PRSize nb;
 
     if (n <= MINBUCKETS) {
         n = MINBUCKETSLOG2;
     } else {
         n = PR_CeilingLog2(n);
-        if ((PRInt32)n < 0)
+        if ((PRInt32)n < 0) {
             return 0;
+        }
     }
 
-    if (!allocOps) allocOps = &defaultHashAllocOps;
+    if (!allocOps) {
+        allocOps = &defaultHashAllocOps;
+    }
 
     ht = (PLHashTable*)((*allocOps->allocTable)(allocPriv, sizeof *ht));
-    if (!ht)
-	return 0;
+    if (!ht) {
+        return 0;
+    }
     memset(ht, 0, sizeof *ht);
     ht->shift = PL_HASH_BITS - n;
     n = 1 << n;
     nb = n * sizeof(PLHashEntry *);
     ht->buckets = (PLHashEntry**)((*allocOps->allocTable)(allocPriv, nb));
     if (!ht->buckets) {
         (*allocOps->freeTable)(allocPriv, ht);
         return 0;
@@ -197,17 +202,17 @@ PL_HashTableRawAdd(PLHashTable *ht, PLHa
     PRSize nb;
 
     /* Grow the table if it is overloaded */
     n = NBUCKETS(ht);
     if (ht->nentries >= OVERLOADED(n)) {
         oldbuckets = ht->buckets;
         nb = 2 * n * sizeof(PLHashEntry *);
         ht->buckets = (PLHashEntry**)
-            ((*ht->allocOps->allocTable)(ht->allocPriv, nb));
+                      ((*ht->allocOps->allocTable)(ht->allocPriv, nb));
         if (!ht->buckets) {
             ht->buckets = oldbuckets;
             return 0;
         }
         memset(ht->buckets, 0, nb);
 #ifdef HASHMETER
         ht->ngrows++;
 #endif
@@ -226,18 +231,19 @@ PL_HashTableRawAdd(PLHashTable *ht, PLHa
         memset(oldbuckets, 0xDB, n * sizeof oldbuckets[0]);
 #endif
         (*ht->allocOps->freeTable)(ht->allocPriv, oldbuckets);
         hep = PL_HashTableRawLookup(ht, keyHash, key);
     }
 
     /* Make a new key value entry */
     he = (*ht->allocOps->allocEntry)(ht->allocPriv, key);
-    if (!he)
-	return 0;
+    if (!he) {
+        return 0;
+    }
     he->keyHash = keyHash;
     he->key = key;
     he->value = value;
     he->next = *hep;
     *hep = he;
     ht->nentries++;
     return he;
 }
@@ -251,18 +257,19 @@ PL_HashTableAdd(PLHashTable *ht, const v
     keyHash = (*ht->keyHash)(key);
     hep = PL_HashTableRawLookup(ht, keyHash, key);
     if ((he = *hep) != 0) {
         /* Hit; see if values match */
         if ((*ht->valueCompare)(he->value, value)) {
             /* key,value pair is already present in table */
             return he;
         }
-        if (he->value)
+        if (he->value) {
             (*ht->allocOps->freeEntry)(ht->allocPriv, he, HT_FREE_VALUE);
+        }
         he->value = value;
         return he;
     }
     return PL_HashTableRawAdd(ht, hep, keyHash, key, value);
 }
 
 PR_IMPLEMENT(void)
 PL_HashTableRawRemove(PLHashTable *ht, PLHashEntry **hep, PLHashEntry *he)
@@ -275,17 +282,17 @@ PL_HashTableRawRemove(PLHashTable *ht, P
     (*ht->allocOps->freeEntry)(ht->allocPriv, he, HT_FREE_ENTRY);
 
     /* Shrink table if it's underloaded */
     n = NBUCKETS(ht);
     if (--ht->nentries < UNDERLOADED(n)) {
         oldbuckets = ht->buckets;
         nb = n * sizeof(PLHashEntry*) / 2;
         ht->buckets = (PLHashEntry**)(
-            (*ht->allocOps->allocTable)(ht->allocPriv, nb));
+                          (*ht->allocOps->allocTable)(ht->allocPriv, nb));
         if (!ht->buckets) {
             ht->buckets = oldbuckets;
             return;
         }
         memset(ht->buckets, 0, nb);
 #ifdef HASHMETER
         ht->nshrinks++;
 #endif
@@ -310,18 +317,19 @@ PL_HashTableRawRemove(PLHashTable *ht, P
 PR_IMPLEMENT(PRBool)
 PL_HashTableRemove(PLHashTable *ht, const void *key)
 {
     PLHashNumber keyHash;
     PLHashEntry *he, **hep;
 
     keyHash = (*ht->keyHash)(key);
     hep = PL_HashTableRawLookup(ht, keyHash, key);
-    if ((he = *hep) == 0)
+    if ((he = *hep) == 0) {
         return PR_FALSE;
+    }
 
     /* Hit; remove element */
     PL_HashTableRawRemove(ht, hep, he);
     return PR_TRUE;
 }
 
 PR_IMPLEMENT(void *)
 PL_HashTableLookup(PLHashTable *ht, const void *key)
@@ -409,45 +417,48 @@ PL_HashTableDumpMeter(PLHashTable *ht, P
     PLHashEntry *he;
 
     variance = 0;
     nchains = 0;
     maxChainLen = 0;
     nbuckets = NBUCKETS(ht);
     for (i = 0; i < nbuckets; i++) {
         he = ht->buckets[i];
-        if (!he)
+        if (!he) {
             continue;
+        }
         nchains++;
-        for (n = 0; he; he = he->next)
+        for (n = 0; he; he = he->next) {
             n++;
+        }
         variance += n * n;
         if (n > maxChainLen) {
             maxChainLen = n;
             maxChain = i;
         }
     }
     mean = (double)ht->nentries / nchains;
     variance = fabs(variance / nchains - mean * mean);
 
     fprintf(fp, "\nHash table statistics:\n");
     fprintf(fp, "     number of lookups: %u\n", ht->nlookups);
     fprintf(fp, "     number of entries: %u\n", ht->nentries);
     fprintf(fp, "       number of grows: %u\n", ht->ngrows);
     fprintf(fp, "     number of shrinks: %u\n", ht->nshrinks);
     fprintf(fp, "   mean steps per hash: %g\n", (double)ht->nsteps
-                                                / ht->nlookups);
+            / ht->nlookups);
     fprintf(fp, "mean hash chain length: %g\n", mean);
     fprintf(fp, "    standard deviation: %g\n", sqrt(variance));
     fprintf(fp, " max hash chain length: %u\n", maxChainLen);
     fprintf(fp, "        max hash chain: [%u]\n", maxChain);
 
     for (he = ht->buckets[maxChain], i = 0; he; he = he->next, i++)
-        if ((*dump)(he, i, fp) != HT_ENUMERATE_NEXT)
+        if ((*dump)(he, i, fp) != HT_ENUMERATE_NEXT) {
             break;
+        }
 }
 #endif /* HASHMETER */
 
 PR_IMPLEMENT(int)
 PL_HashTableDump(PLHashTable *ht, PLHashEnumerator dump, FILE *fp)
 {
     int count;
 
@@ -460,18 +471,19 @@ PL_HashTableDump(PLHashTable *ht, PLHash
 
 PR_IMPLEMENT(PLHashNumber)
 PL_HashString(const void *key)
 {
     PLHashNumber h;
     const PRUint8 *s;
 
     h = 0;
-    for (s = (const PRUint8*)key; *s; s++)
+    for (s = (const PRUint8*)key; *s; s++) {
         h = PR_ROTATE_LEFT32(h, 4) ^ *s;
+    }
     return h;
 }
 
 PR_IMPLEMENT(int)
 PL_CompareStrings(const void *v1, const void *v2)
 {
     return strcmp((const char*)v1, (const char*)v2) == 0;
 }
--- a/nsprpub/lib/ds/plvrsion.c
+++ b/nsprpub/lib/ds/plvrsion.c
@@ -63,35 +63,35 @@ PRVersionDescription VERSION_DESC_NAME =
 
 /*
  * Version information for the 'ident' and 'what commands
  *
  * NOTE: the first component of the concatenated rcsid string
  * must not end in a '$' to prevent rcs keyword substitution.
  */
 static char rcsid[] = "$Header: NSPR " PR_VERSION _DEBUG_STRING
-        "  " _BUILD_STRING " $";
+                      "  " _BUILD_STRING " $";
 static char sccsid[] = "@(#)NSPR " PR_VERSION _DEBUG_STRING
-        "  " _BUILD_STRING;
+                       "  " _BUILD_STRING;
 
 #endif /* XP_UNIX */
 
 #ifdef _PR_HAS_PRAGMA_DIAGNOSTIC
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
 #endif
 PR_IMPLEMENT(const PRVersionDescription*) libVersionPoint()
 {
 #ifdef XP_UNIX
     /*
      * Add dummy references to rcsid and sccsid to prevent them
      * from being optimized away as unused variables.
      */
     const char *dummy;
-    
+
     dummy = rcsid;
     dummy = sccsid;
 #endif
     return &VERSION_DESC_NAME;
 }  /* versionEntryPointType */
 #ifdef _PR_HAS_PRAGMA_DIAGNOSTIC
 #pragma GCC diagnostic pop
 #endif
--- a/nsprpub/lib/libc/include/plbase64.h
+++ b/nsprpub/lib/libc/include/plbase64.h
@@ -14,21 +14,21 @@ PR_BEGIN_EXTERN_C
  * PL_Base64Encode
  *
  * This routine encodes the data pointed to by the "src" parameter using the
  * base64 algorithm, and returns a pointer to the result.  If the "srclen"
  * parameter is not zero, it specifies the length of the source data.  If it
  * is zero, the source data is assumed to be null-terminated, and PL_strlen
  * is used to determine the source length.  If the "dest" parameter is not
  * null, it is assumed to point to a buffer of sufficient size (which may be
- * calculated: ((srclen + 2)/3)*4) into which the encoded data is placed 
+ * calculated: ((srclen + 2)/3)*4) into which the encoded data is placed
  * (without any termination).  If the "dest" parameter is null, a buffer is
  * allocated from the heap to hold the encoded data, and the result *will*
- * be terminated with an extra null character.  It is the caller's 
- * responsibility to free the result when it is allocated.  A null is returned 
+ * be terminated with an extra null character.  It is the caller's
+ * responsibility to free the result when it is allocated.  A null is returned
  * if the allocation fails.
  *
  * NOTE: when calculating ((srclen + 2)/3)*4), first ensure that
  *     srclen <= (PR_UINT32_MAX/4) * 3
  * to avoid PRUint32 overflow.
  */
 
 PR_EXTERN(char *)
@@ -51,17 +51,17 @@ PL_Base64Encode
  * a buffer of sufficient size (which may be calculated: (srclen * 3)/4
  * when srclen includes the '=' characters) into which the decoded data
  * is placed (without any termination).  If the "dest" parameter is null,
  * a buffer is allocated from the heap to hold the decoded data, and the
  * result *will* be terminated with an extra null character.  It is the
  * caller's responsibility to free the result when it is allocated.  A null
  * is retuned if the allocation fails, or if the source is not well-coded.
  *
- * NOTE: when calculating (srclen * 3)/4, first ensure that 
+ * NOTE: when calculating (srclen * 3)/4, first ensure that
  *     srclen <= PR_UINT32_MAX/3
  * to avoid PRUint32 overflow.  Alternatively, calculate
  *     (srclen/4) * 3 + ((srclen%4) * 3)/4
  * which is equivalent but doesn't overflow for any value of srclen.
  */
 
 PR_EXTERN(char *)
 PL_Base64Decode
--- a/nsprpub/lib/libc/include/plgetopt.h
+++ b/nsprpub/lib/libc/include/plgetopt.h
@@ -11,112 +11,112 @@
 #if defined(PLGETOPT_H_)
 #else
 #define PLGETOPT_H_
 
 #include "prtypes.h"
 
 PR_BEGIN_EXTERN_C
 
-typedef struct PLOptionInternal PLOptionInternal; 
+typedef struct PLOptionInternal PLOptionInternal;
 
 typedef enum
 {
-        PL_OPT_OK,              /* all's well with the option */
-        PL_OPT_EOL,             /* end of options list */
-        PL_OPT_BAD              /* invalid option (and value) */
+    PL_OPT_OK,              /* all's well with the option */
+    PL_OPT_EOL,             /* end of options list */
+    PL_OPT_BAD              /* invalid option (and value) */
 } PLOptStatus;
 
 typedef struct PLLongOpt
 {
     const char * longOptName;   /* long option name string                  */
     PRIntn       longOption;    /* value put in PLOptState for this option. */
     PRBool       valueRequired; /* If option name not followed by '=',      */
-                                /* value is the next argument from argv.    */
+    /* value is the next argument from argv.    */
 } PLLongOpt;
 
 typedef struct PLOptState
 {
     char option;                /* the name of the option */
     const char *value;          /* the value of that option | NULL */
 
     PLOptionInternal *internal; /* private processing state */
 
     PRIntn   longOption;        /* value from PLLongOpt put here */
     PRIntn   longOptIndex;      /* index into caller's array of PLLongOpts */
 } PLOptState;
 
 /*
  * PL_CreateOptState
  *
- * The argument "options" points to a string of single-character option 
- * names.  Option names that may have an option argument value must be 
- * followed immediately by a ':' character.  
+ * The argument "options" points to a string of single-character option
+ * names.  Option names that may have an option argument value must be
+ * followed immediately by a ':' character.
  */
 PR_EXTERN(PLOptState*) PL_CreateOptState(
-        PRIntn argc, char **argv, const char *options);
+    PRIntn argc, char **argv, const char *options);
 
-/* 
+/*
  * PL_CreateLongOptState
  *
- * Alternative to PL_CreateOptState.  
- * Allows caller to specify BOTH a string of single-character option names, 
- * AND an array of structures describing "long" (keyword) option names.  
- * The array is terminated by a structure in which longOptName is NULL.  
+ * Alternative to PL_CreateOptState.
+ * Allows caller to specify BOTH a string of single-character option names,
+ * AND an array of structures describing "long" (keyword) option names.
+ * The array is terminated by a structure in which longOptName is NULL.
  * Long option values (arguments) may always be given as "--name=value".
- * If PLLongOpt.valueRequired is not PR_FALSE, and the option name was not 
- * followed by '=' then the next argument from argv is taken as the value.  
+ * If PLLongOpt.valueRequired is not PR_FALSE, and the option name was not
+ * followed by '=' then the next argument from argv is taken as the value.
  */
 PR_EXTERN(PLOptState*) PL_CreateLongOptState(
-        PRIntn argc, char **argv, const char *options, 
-        const PLLongOpt *longOpts);
+    PRIntn argc, char **argv, const char *options,
+    const PLLongOpt *longOpts);
 /*
  * PL_DestroyOptState
  *
  * Call this to destroy the PLOptState returned from PL_CreateOptState or
  * PL_CreateLongOptState.
  */
 PR_EXTERN(void) PL_DestroyOptState(PLOptState *opt);
 
 /*
  * PL_GetNextOpt
  *
- * When this function returns PL_OPT_OK, 
- * - opt->option will hold the single-character option name that was parsed, 
- *   or zero.  
- * When opt->option is zero, the token parsed was either a "long" (keyword) 
- *   option or a positional parameter.  
- * For a positional parameter, 
+ * When this function returns PL_OPT_OK,
+ * - opt->option will hold the single-character option name that was parsed,
+ *   or zero.
+ * When opt->option is zero, the token parsed was either a "long" (keyword)
+ *   option or a positional parameter.
+ * For a positional parameter,
  * - opt->longOptIndex will contain -1, and
  * - opt->value will point to the positional parameter string.
- * For a long option name, 
- * - opt->longOptIndex will contain the non-negative index of the 
- *   PLLongOpt structure in the caller's array of PLLongOpt structures 
- *   corresponding to the long option name, and 
- * For a single-character or long option, 
+ * For a long option name,
+ * - opt->longOptIndex will contain the non-negative index of the
+ *   PLLongOpt structure in the caller's array of PLLongOpt structures
+ *   corresponding to the long option name, and
+ * For a single-character or long option,
  * - opt->longOption will contain the value of the single-character option
  *   name, or the value of the longOption from the PLLongOpt structure
  *   for that long option.  See notes below.
  * - opt->value will point to the argument option string, or will
  *   be NULL if option does not require argument.  If option requires
  *   argument but it is not provided, PL_OPT_BAD is returned.
- * When opt->option is non-zero, 
+ * When opt->option is non-zero,
  * - opt->longOptIndex will be -1
  * When this function returns PL_OPT_EOL, or PL_OPT_BAD, the contents of
  *   opt are undefined.
  *
- * Notes: It is possible to ignore opt->option, and always look at 
+ * Notes: It is possible to ignore opt->option, and always look at
  *   opt->longOption instead.  opt->longOption will contain the same value
  *   as opt->option for single-character option names, and will contain the
  *   value of longOption from the PLLongOpt structure for long option names.
- * This means that it is possible to equivalence long option names to 
+ * This means that it is possible to equivalence long option names to
  *   single character names by giving the longOption in the PLLongOpt struct
- *   the same value as the single-character option name.  
+ *   the same value as the single-character option name.
  * For long options that are NOT intended to be equivalent to any single-
- *   character option, the longOption value should be chosen to not match 
+ *   character option, the longOption value should be chosen to not match
  *   any possible single character name.  It might be advisable to choose
  *   longOption values greater than 0xff for such long options.
  */
 PR_EXTERN(PLOptStatus) PL_GetNextOpt(PLOptState *opt);
 
 PR_END_EXTERN_C
 
 #endif /* defined(PLGETOPT_H_) */
--- a/nsprpub/lib/libc/include/plstr.h
+++ b/nsprpub/lib/libc/include/plstr.h
@@ -5,23 +5,23 @@
 
 #ifndef _plstr_h
 #define _plstr_h
 
 /*
  * plstr.h
  *
  * This header file exports the API to the NSPR portable library or string-
- * handling functions.  
- * 
- * This API was not designed as an "optimal" or "ideal" string library; it 
+ * handling functions.
+ *
+ * This API was not designed as an "optimal" or "ideal" string library; it
  * was based on the good ol' unix string.3 functions, and was written to
  *
- *  1) replace the libc functions, for cross-platform consistency, 
- *  2) complete the API on platforms lacking common functions (e.g., 
+ *  1) replace the libc functions, for cross-platform consistency,
+ *  2) complete the API on platforms lacking common functions (e.g.,
  *     strcase*), and
  *  3) to implement some obvious "closure" functions that I've seen
  *     people hacking around in our code.
  *
  * Point number three largely means that most functions have an "strn"
  * limited-length version, and all comparison routines have a non-case-
  * sensitive version available.
  */
@@ -71,23 +71,23 @@ PL_strcpy(char *dest, const char *src);
  */
 
 PR_EXTERN(char *)
 PL_strncpy(char *dest, const char *src, PRUint32 max);
 
 /*
  * PL_strncpyz
  *
- * Copies the source string into the destination buffer, up to and including 
- * the trailing '\0' or up but not including the max'th character, whichever 
+ * Copies the source string into the destination buffer, up to and including
+ * the trailing '\0' or up but not including the max'th character, whichever
  * comes first.  It does not (can not) verify that the destination buffer is
  * large enough.  The destination string is always terminated with a '\0',
  * unlike the traditional libc implementation.  It returns the "dest" argument.
  *
- * NOTE: If you call this with a source "abcdefg" and a max of 5, the 
+ * NOTE: If you call this with a source "abcdefg" and a max of 5, the
  * destination will end up with "abcd\0" (i.e., its strlen length will be 4)!
  *
  * This means you can do this:
  *
  *     char buffer[ SOME_SIZE ];
  *     PL_strncpyz(buffer, src, sizeof(buffer));
  *
  * and the result will be properly terminated.
@@ -147,17 +147,17 @@ PR_EXTERN(char *)
 PL_strcat(char *dst, const char *src);
 
 /*
  * PL_strncat
  *
  * Appends a copy of the string pointed to by the second argument, up to
  * the maximum size specified, to the end of the string pointed to by the
  * first.  The destination buffer is not (can not be) checked for sufficient
- * size.  A null destination argument returns null; otherwise, the first 
+ * size.  A null destination argument returns null; otherwise, the first
  * argument is returned.  If the maximum size limits the copy, then the
  * result will *not* be null-terminated (JLRU).  A null destination
  * returns null; otherwise, the destination argument is returned.
  */
 
 PR_EXTERN(char *)
 PL_strncat(char *dst, const char *src, PRUint32 max);
 
@@ -184,46 +184,46 @@ PL_strcatn(char *dst, PRUint32 max, cons
  * NSPR implementation is not i18n.
  */
 
 PR_EXTERN(PRIntn)
 PL_strcmp(const char *a, const char *b);
 
 /*
  * PL_strncmp
- * 
+ *
  * Returns an integer, the sign of which -- positive, zero, or negative --
  * reflects the lexical sorting order of the two strings indicated, up to
- * the maximum specified.  The result is positive if the first string comes 
+ * the maximum specified.  The result is positive if the first string comes
  * after the second.  The NSPR implementation is not i18n.  If the maximum
  * is zero, only the existance or non-existance (pointer is null) of the
  * strings is compared.
  */
 
 PR_EXTERN(PRIntn)
 PL_strncmp(const char *a, const char *b, PRUint32 max);
 
 /*
  * PL_strcasecmp
  *
  * Returns an integer, the sign of which -- positive, zero or negative --
  * reflects the case-insensitive lexical sorting order of the two strings
- * indicated.  The result is positive if the first string comes after the 
+ * indicated.  The result is positive if the first string comes after the
  * second.  The NSPR implementation is not i18n.
  */
 
 PR_EXTERN(PRIntn)
 PL_strcasecmp(const char *a, const char *b);
 
 /*
  * PL_strncasecmp
  *
  * Returns an integer, the sign of which -- positive, zero or negative --
  * reflects the case-insensitive lexical sorting order of the first n characters
- * of the two strings indicated.  The result is positive if the first string comes 
+ * of the two strings indicated.  The result is positive if the first string comes
  * after the second.  The NSPR implementation is not i18n.
  */
 
 PR_EXTERN(PRIntn)
 PL_strncasecmp(const char *a, const char *b, PRUint32 max);
 
 /*
  * PL_strchr
@@ -244,17 +244,17 @@ PL_strchr(const char *s, char c);
  * provided string is null.  The character may be the null character.
  */
 
 PR_EXTERN(char *)
 PL_strrchr(const char *s, char c);
 
 /*
  * PL_strnchr
- * 
+ *
  * Returns a pointer to the first instance of the specified character within the
  * first n characters of the provided string.  It returns null if the character
  * is not found, or if the provided string is null.  The character may be the
  * null character.
  */
 
 PR_EXTERN(char *)
 PL_strnchr(const char *s, char c, PRUint32 n);
@@ -381,17 +381,17 @@ PL_strcasestr(const char *big, const cha
 
 PR_EXTERN(char *)
 PL_strcaserstr(const char *big, const char *little);
 
 /*
  * PL_strncasestr
  *
  * Returns a pointer to the first instance of the little string within the first
- * n characters of the big one, ignoring case.  It returns null if either string is 
+ * n characters of the big one, ignoring case.  It returns null if either string is
  * null.  It returns null if the length of the little string is greater than n.
  */
 
 PR_EXTERN(char *)
 PL_strncasestr(const char *big, const char *little, PRUint32 max);
 
 /*
  * PL_strncaserstr
--- a/nsprpub/lib/libc/src/base64.c
+++ b/nsprpub/lib/libc/src/base64.c
@@ -95,18 +95,18 @@ encode
     }
 
     return;
 }
 
 /*
  * PL_Base64Encode
  *
- * If the destination argument is NULL, a return buffer is 
- * allocated, and the data therein will be null-terminated.  
+ * If the destination argument is NULL, a return buffer is
+ * allocated, and the data therein will be null-terminated.
  * If the destination argument is not NULL, it is assumed to
  * be of sufficient size, and the contents will not be null-
  * terminated by this routine.
  *
  * Returns null if the allocation fails.
  */
 
 PR_IMPLEMENT(char *)
@@ -336,18 +336,18 @@ decode
 /*
  * PL_Base64Decode
  *
  * If the destination argument is NULL, a return buffer is
  * allocated and the data therein will be null-terminated.
  * If the destination argument is not null, it is assumed
  * to be of sufficient size, and the data will not be null-
  * terminated by this routine.
- * 
- * Returns null if the allocation fails, or if the source string is 
+ *
+ * Returns null if the allocation fails, or if the source string is
  * not well-formed.
  */
 
 PR_IMPLEMENT(char *)
 PL_Base64Decode
 (
     const char *src,
     PRUint32    srclen,
--- a/nsprpub/lib/libc/src/plerror.c
+++ b/nsprpub/lib/libc/src/plerror.c
@@ -11,30 +11,34 @@
 
 #include "plerror.h"
 
 #include "prprf.h"
 #include "prerror.h"
 
 PR_IMPLEMENT(void) PL_FPrintError(PRFileDesc *fd, const char *msg)
 {
-PRErrorCode error = PR_GetError();
-PRInt32 oserror = PR_GetOSError();
-const char *name = PR_ErrorToName(error);
+    PRErrorCode error = PR_GetError();
+    PRInt32 oserror = PR_GetOSError();
+    const char *name = PR_ErrorToName(error);
 
-	if (NULL != msg) PR_fprintf(fd, "%s: ", msg);
+    if (NULL != msg) {
+        PR_fprintf(fd, "%s: ", msg);
+    }
     if (NULL == name)
         PR_fprintf(
-			fd, " (%d)OUT OF RANGE, oserror = %d\n", error, oserror);
+            fd, " (%d)OUT OF RANGE, oserror = %d\n", error, oserror);
     else
         PR_fprintf(
             fd, "%s(%d), oserror = %d\n",
             name, error, oserror);
 }  /* PL_FPrintError */
 
 PR_IMPLEMENT(void) PL_PrintError(const char *msg)
 {
-	static PRFileDesc *fd = NULL;
-	if (NULL == fd) fd = PR_GetSpecialFD(PR_StandardError);
-	PL_FPrintError(fd, msg);
+    static PRFileDesc *fd = NULL;
+    if (NULL == fd) {
+        fd = PR_GetSpecialFD(PR_StandardError);
+    }
+    PL_FPrintError(fd, msg);
 }  /* PL_PrintError */
 
 /* plerror.c */
--- a/nsprpub/lib/libc/src/plgetopt.c
+++ b/nsprpub/lib/libc/src/plgetopt.c
@@ -40,30 +40,30 @@ struct PLOptionInternal
 */
 PR_IMPLEMENT(PLOptState*) PL_CreateOptState(
     PRIntn argc, char **argv, const char *options)
 {
     return PL_CreateLongOptState( argc, argv, options, NULL);
 }  /* PL_CreateOptState */
 
 PR_IMPLEMENT(PLOptState*) PL_CreateLongOptState(
-    PRIntn argc, char **argv, const char *options, 
+    PRIntn argc, char **argv, const char *options,
     const PLLongOpt *longOpts)
 {
     PLOptState *opt = NULL;
     PLOptionInternal *internal;
 
-    if (NULL == options) 
+    if (NULL == options)
     {
         PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
         return opt;
     }
 
     opt = PR_NEWZAP(PLOptState);
-    if (NULL == opt) 
+    if (NULL == opt)
     {
         PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
         return opt;
     }
 
     internal = PR_NEW(PLOptionInternal);
     if (NULL == internal)
     {
@@ -119,61 +119,63 @@ PR_IMPLEMENT(PLOptStatus) PL_GetNextOpt(
         if (internal->xargc >= internal->argc)
         {
             opt->option = 0;
             opt->value = NULL;
             return PL_OPT_EOL;
         }
         internal->xargv = internal->argv[internal->xargc];
         internal->minus = 0;
-        if (!internal->endOfOpts && ('-' == *internal->xargv)) 
+        if (!internal->endOfOpts && ('-' == *internal->xargv))
         {
             internal->minus++;
             internal->xargv++;  /* and consume */
-            if ('-' == *internal->xargv && internal->longOpts) 
+            if ('-' == *internal->xargv && internal->longOpts)
             {
                 internal->minus++;
                 internal->xargv++;
-                if (0 == *internal->xargv) 
+                if (0 == *internal->xargv)
                 {
                     internal->endOfOpts = PR_TRUE;
                 }
             }
         }
     }
 
     /*
     ** If we already have a '-' or '--' in hand, xargv points to the next
     ** option. See if we can find a match in the list of possible
     ** options supplied.
     */
-    if (internal->minus == 2) 
+    if (internal->minus == 2)
     {
         char * foundEqual = strchr(internal->xargv,'=');
         PRIntn optNameLen = foundEqual ? (foundEqual - internal->xargv) :
                             strlen(internal->xargv);
         const PLLongOpt *longOpt = internal->longOpts;
         PLOptStatus result = PL_OPT_BAD;
 
         opt->option = 0;
         opt->value  = NULL;
 
-        for (; longOpt->longOptName; ++longOpt) 
+        for (; longOpt->longOptName; ++longOpt)
         {
-            if (strncmp(longOpt->longOptName, internal->xargv, optNameLen))
-                continue;  /* not a possible match */
-            if (strlen(longOpt->longOptName) != optNameLen)
-                continue;  /* not a match */
+            if (strncmp(longOpt->longOptName, internal->xargv, optNameLen)) {
+                continue;    /* not a possible match */
+            }
+            if (strlen(longOpt->longOptName) != optNameLen) {
+                continue;    /* not a match */
+            }
             /* option name match */
             opt->longOptIndex = longOpt - internal->longOpts;
             opt->longOption   = longOpt->longOption;
             /* value is part of the current argv[] element if = was found */
             /* note: this sets value even for long options that do not
              * require option if specified as --long=value */
-            if (foundEqual) 
+            if (foundEqual)
             {
                 opt->value = foundEqual + 1;
             }
             else if (longOpt->valueRequired)
             {
                 /* value is the next argv[] element, if any */
                 if (internal->xargc + 1 < internal->argc)
                 {
@@ -222,18 +224,19 @@ PR_IMPLEMENT(PLOptStatus) PL_GetNextOpt(
                     else
                     {
                         return PL_OPT_BAD;
                     }
 
                     internal->xargv = &static_Nul;
                     internal->minus = 0;
                 }
-                else 
-                    opt->value = NULL; 
+                else {
+                    opt->value = NULL;
+                }
                 return PL_OPT_OK;
             }
         }
         internal->xargv += 1;  /* consume that option */
         return PL_OPT_BAD;
     }
 
     /*
--- a/nsprpub/lib/libc/src/plvrsion.c
+++ b/nsprpub/lib/libc/src/plvrsion.c
@@ -63,35 +63,35 @@ PRVersionDescription VERSION_DESC_NAME =
 
 /*
  * Version information for the 'ident' and 'what commands
  *
  * NOTE: the first component of the concatenated rcsid string
  * must not end in a '$' to prevent rcs keyword substitution.
  */
 static char rcsid[] = "$Header: NSPR " PR_VERSION _DEBUG_STRING
-        "  " _BUILD_STRING " $";
+                      "  " _BUILD_STRING " $";
 static char sccsid[] = "@(#)NSPR " PR_VERSION _DEBUG_STRING
-        "  " _BUILD_STRING;
+                       "  " _BUILD_STRING;
 
 #endif /* XP_UNIX */
 
 #ifdef _PR_HAS_PRAGMA_DIAGNOSTIC
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
 #endif
 PR_IMPLEMENT(const PRVersionDescription*) libVersionPoint()
 {
 #ifdef XP_UNIX
     /*
      * Add dummy references to rcsid and sccsid to prevent them
      * from being optimized away as unused variables.
      */
     const char *dummy;
-    
+
     dummy = rcsid;
     dummy = sccsid;
 #endif
     return &VERSION_DESC_NAME;
 }  /* versionEntryPointType */
 #ifdef _PR_HAS_PRAGMA_DIAGNOSTIC
 #pragma GCC diagnostic pop
 #endif
--- a/nsprpub/lib/libc/src/strcase.c
+++ b/nsprpub/lib/libc/src/strcase.c
@@ -43,20 +43,22 @@ static const unsigned char uc[] =
 };
 
 PR_IMPLEMENT(PRIntn)
 PL_strcasecmp(const char *a, const char *b)
 {
     const unsigned char *ua = (const unsigned char *)a;
     const unsigned char *ub = (const unsigned char *)b;
 
-    if( (const char *)0 == a )
+    if( (const char *)0 == a ) {
         return ((const char *)0 == b) ? 0 : -1;
-    if( (const char *)0 == b )
+    }
+    if( (const char *)0 == b ) {
         return 1;
+    }
 
     while( (uc[*ua] == uc[*ub]) && ('\0' != *a) )
     {
         a++;
         ua++;
         ub++;
     }
 
@@ -64,111 +66,141 @@ PL_strcasecmp(const char *a, const char 
 }
 
 PR_IMPLEMENT(PRIntn)
 PL_strncasecmp(const char *a, const char *b, PRUint32 max)
 {
     const unsigned char *ua = (const unsigned char *)a;
     const unsigned char *ub = (const unsigned char *)b;
 
-    if( (const char *)0 == a )
+    if( (const char *)0 == a ) {
         return ((const char *)0 == b) ? 0 : -1;
-    if( (const char *)0 == b )
+    }
+    if( (const char *)0 == b ) {
         return 1;
+    }
 
     while( max && (uc[*ua] == uc[*ub]) && ('\0' != *a) )
     {
         a++;
         ua++;
         ub++;
         max--;
     }
 
-    if( 0 == max ) return (PRIntn)0;
+    if( 0 == max ) {
+        return (PRIntn)0;
+    }
 
     return (PRIntn)(uc[*ua] - uc[*ub]);
 }
 
 PR_IMPLEMENT(char *)
 PL_strcasestr(const char *big, const char *little)
 {
     PRUint32 ll;
 
-    if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
-    if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
+    if( ((const char *)0 == big) || ((const char *)0 == little) ) {
+        return (char *)0;
+    }
+    if( ((char)0 == *big) || ((char)0 == *little) ) {
+        return (char *)0;
+    }
 
     ll = strlen(little);
 
     for( ; *big; big++ )
         /* obvious improvement available here */
-            if( 0 == PL_strncasecmp(big, little, ll) )
-                return (char *)big;
+        if( 0 == PL_strncasecmp(big, little, ll) ) {
+            return (char *)big;
+        }
 
     return (char *)0;
 }
 
 PR_IMPLEMENT(char *)
 PL_strcaserstr(const char *big, const char *little)
 {
     const char *p;
     PRUint32 bl, ll;
 
-    if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
-    if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
+    if( ((const char *)0 == big) || ((const char *)0 == little) ) {
+        return (char *)0;
+    }
+    if( ((char)0 == *big) || ((char)0 == *little) ) {
+        return (char *)0;
+    }
 
     bl = strlen(big);
     ll = strlen(little);
-    if( bl < ll ) return (char *)0;
+    if( bl < ll ) {
+        return (char *)0;
+    }
     p = &big[ bl - ll ];
 
     for( ; p >= big; p-- )
         /* obvious improvement available here */
-            if( 0 == PL_strncasecmp(p, little, ll) )
-                return (char *)p;
+        if( 0 == PL_strncasecmp(p, little, ll) ) {
+            return (char *)p;
+        }
 
     return (char *)0;
 }
 
 PR_IMPLEMENT(char *)
 PL_strncasestr(const char *big, const char *little, PRUint32 max)
 {
     PRUint32 ll;
 
-    if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
-    if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
+    if( ((const char *)0 == big) || ((const char *)0 == little) ) {
+        return (char *)0;
+    }
+    if( ((char)0 == *big) || ((char)0 == *little) ) {
+        return (char *)0;
+    }
 
     ll = strlen(little);
-    if( ll > max ) return (char *)0;
+    if( ll > max ) {
+        return (char *)0;
+    }
     max -= ll;
     max++;
 
     for( ; max && *big; big++, max-- )
         /* obvious improvement available here */
-            if( 0 == PL_strncasecmp(big, little, ll) )
-                return (char *)big;
+        if( 0 == PL_strncasecmp(big, little, ll) ) {
+            return (char *)big;
+        }
 
     return (char *)0;
 }
 
 PR_IMPLEMENT(char *)
 PL_strncaserstr(const char *big, const char *little, PRUint32 max)
 {
     const char *p;
     PRUint32 ll;
 
-    if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
-    if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
+    if( ((const char *)0 == big) || ((const char *)0 == little) ) {
+        return (char *)0;
+    }
+    if( ((char)0 == *big) || ((char)0 == *little) ) {
+        return (char *)0;
+    }
 
     ll = strlen(little);
 
     for( p = big; max && *p; p++, max-- )
         ;
 
     p -= ll;
-    if( p < big ) return (char *)0;
+    if( p < big ) {
+        return (char *)0;
+    }
 
     for( ; p >= big; p-- )
         /* obvious improvement available here */
-            if( 0 == PL_strncasecmp(p, little, ll) )
-                return (char *)p;
+        if( 0 == PL_strncasecmp(p, little, ll) ) {
+            return (char *)p;
+        }
 
     return (char *)0;
 }
--- a/nsprpub/lib/libc/src/strcat.c
+++ b/nsprpub/lib/libc/src/strcat.c
@@ -4,46 +4,51 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "plstr.h"
 #include <string.h>
 
 PR_IMPLEMENT(char *)
 PL_strcat(char *dest, const char *src)
 {
-    if( ((char *)0 == dest) || ((const char *)0 == src) )
+    if( ((char *)0 == dest) || ((const char *)0 == src) ) {
         return dest;
+    }
 
     return strcat(dest, src);
 }
 
 PR_IMPLEMENT(char *)
 PL_strncat(char *dest, const char *src, PRUint32 max)
 {
     char *rv;
 
-    if( ((char *)0 == dest) || ((const char *)0 == src) || (0 == max) )
+    if( ((char *)0 == dest) || ((const char *)0 == src) || (0 == max) ) {
         return dest;
+    }
 
     for( rv = dest; *dest; dest++ )
         ;
 
     (void)PL_strncpy(dest, src, max);
     return rv;
 }
 
 PR_IMPLEMENT(char *)
 PL_strcatn(char *dest, PRUint32 max, const char *src)
 {
     char *rv;
     PRUint32 dl;
 
-    if( ((char *)0 == dest) || ((const char *)0 == src) )
+    if( ((char *)0 == dest) || ((const char *)0 == src) ) {
         return dest;
+    }
 
     for( rv = dest, dl = 0; *dest; dest++, dl++ )
         ;
 
-    if( max <= dl ) return rv;
+    if( max <= dl ) {
+        return rv;
+    }
     (void)PL_strncpyz(dest, src, max-dl);
 
     return rv;
 }
--- a/nsprpub/lib/libc/src/strchr.c
+++ b/nsprpub/lib/libc/src/strchr.c
@@ -4,53 +4,67 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "plstr.h"
 #include <string.h>
 
 PR_IMPLEMENT(char *)
 PL_strchr(const char *s, char c)
 {
-    if( (const char *)0 == s ) return (char *)0;
+    if( (const char *)0 == s ) {
+        return (char *)0;
+    }
 
     return strchr(s, c);
 }
 
 PR_IMPLEMENT(char *)
 PL_strrchr(const char *s, char c)
 {
-    if( (const char *)0 == s ) return (char *)0;
+    if( (const char *)0 == s ) {
+        return (char *)0;
+    }
 
     return strrchr(s, c);
 }
 
 PR_IMPLEMENT(char *)
 PL_strnchr(const char *s, char c, PRUint32 n)
 {
-    if( (const char *)0 == s ) return (char *)0;
+    if( (const char *)0 == s ) {
+        return (char *)0;
+    }
 
     for( ; n && *s; s++, n-- )
-        if( *s == c )
+        if( *s == c ) {
             return (char *)s;
+        }
 
-    if( ((char)0 == c) && (n > 0) && ((char)0 == *s) ) return (char *)s;
+    if( ((char)0 == c) && (n > 0) && ((char)0 == *s) ) {
+        return (char *)s;
+    }
 
     return (char *)0;
 }
 
 PR_IMPLEMENT(char *)
 PL_strnrchr(const char *s, char c, PRUint32 n)
 {
     const char *p;
 
-    if( (const char *)0 == s ) return (char *)0;
+    if( (const char *)0 == s ) {
+        return (char *)0;
+    }
 
     for( p = s; n && *p; p++, n-- )
         ;
 
-    if( ((char)0 == c) && (n > 0) && ((char)0 == *p) ) return (char *)p;
+    if( ((char)0 == c) && (n > 0) && ((char)0 == *p) ) {
+        return (char *)p;
+    }
 
     for( p--; p >= s; p-- )
-        if( *p == c )
+        if( *p == c ) {
             return (char *)p;
+        }
 
     return (char *)0;
 }
--- a/nsprpub/lib/libc/src/strcmp.c
+++ b/nsprpub/lib/libc/src/strcmp.c
@@ -4,26 +4,30 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "plstr.h"
 #include <string.h>
 
 PR_IMPLEMENT(PRIntn)
 PL_strcmp(const char *a, const char *b)
 {
-    if( (const char *)0 == a )
+    if( (const char *)0 == a ) {
         return ((const char *)0 == b) ? 0 : -1;
-    if( (const char *)0 == b )
+    }
+    if( (const char *)0 == b ) {
         return 1;
+    }
 
     return (PRIntn)strcmp(a, b);
 }
 
 PR_IMPLEMENT(PRIntn)
 PL_strncmp(const char *a, const char *b, PRUint32 max)
 {
-    if( (const char *)0 == a )
+    if( (const char *)0 == a ) {
         return ((const char *)0 == b) ? 0 : -1;
-    if( (const char *)0 == b )
+    }
+    if( (const char *)0 == b ) {
         return 1;
+    }
 
     return (PRIntn)strncmp(a, b, (size_t)max);
 }
--- a/nsprpub/lib/libc/src/strcpy.c
+++ b/nsprpub/lib/libc/src/strcpy.c
@@ -4,49 +4,62 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "plstr.h"
 #include <string.h>
 
 PR_IMPLEMENT(char *)
 PL_strcpy(char *dest, const char *src)
 {
-    if( ((char *)0 == dest) || ((const char *)0 == src) ) return (char *)0;
+    if( ((char *)0 == dest) || ((const char *)0 == src) ) {
+        return (char *)0;
+    }
 
     return strcpy(dest, src);
 }
 
 PR_IMPLEMENT(char *)
 PL_strncpy(char *dest, const char *src, PRUint32 max)
 {
     char *rv;
-    
-    if( (char *)0 == dest ) return (char *)0;
-    if( (const char *)0 == src ) return (char *)0;
+
+    if( (char *)0 == dest ) {
+        return (char *)0;
+    }
+    if( (const char *)0 == src ) {
+        return (char *)0;
+    }
 
     for( rv = dest; max && ((*dest = *src) != 0); dest++, src++, max-- )
         ;
 
 #ifdef JLRU
     /* XXX I (wtc) think the -- and ++ operators should be postfix. */
-    while( --max )
+    while( --max ) {
         *++dest = '\0';
+    }
 #endif /* JLRU */
 
     return rv;
 }
 
 PR_IMPLEMENT(char *)
 PL_strncpyz(char *dest, const char *src, PRUint32 max)
 {
     char *rv;
-    
-    if( (char *)0 == dest ) return (char *)0;
-    if( (const char *)0 == src ) return (char *)0;
-    if( 0 == max ) return (char *)0;
+
+    if( (char *)0 == dest ) {
+        return (char *)0;
+    }
+    if( (const char *)0 == src ) {
+        return (char *)0;
+    }
+    if( 0 == max ) {
+        return (char *)0;
+    }
 
     for( rv = dest, max--; max && ((*dest = *src) != 0); dest++, src++, max-- )
         ;
 
     *dest = '\0';
 
     return rv;
 }
--- a/nsprpub/lib/libc/src/strdup.c
+++ b/nsprpub/lib/libc/src/strdup.c
@@ -8,23 +8,26 @@
 #include <string.h>
 
 PR_IMPLEMENT(char *)
 PL_strdup(const char *s)
 {
     char *rv;
     size_t n;
 
-    if( (const char *)0 == s )
+    if( (const char *)0 == s ) {
         s = "";
+    }
 
     n = strlen(s) + 1;
 
     rv = (char *)malloc(n);
-    if( (char *)0 == rv ) return rv;
+    if( (char *)0 == rv ) {
+        return rv;
+    }
 
     (void)memcpy(rv, s, n);
 
     return rv;
 }
 
 PR_IMPLEMENT(void)
 PL_strfree(char *s)
@@ -33,21 +36,24 @@ PL_strfree(char *s)
 }
 
 PR_IMPLEMENT(char *)
 PL_strndup(const char *s, PRUint32 max)
 {
     char *rv;
     size_t l;
 
-    if( (const char *)0 == s )
+    if( (const char *)0 == s ) {
         s = "";
+    }
 
     l = PL_strnlen(s, max);
 
     rv = (char *)malloc(l+1);
-    if( (char *)0 == rv ) return rv;
+    if( (char *)0 == rv ) {
+        return rv;
+    }
 
     (void)memcpy(rv, s, l);
     rv[l] = '\0';
 
     return rv;
 }
--- a/nsprpub/lib/libc/src/strlen.c
+++ b/nsprpub/lib/libc/src/strlen.c
@@ -8,35 +8,40 @@
 #include "prlog.h"
 #include <string.h>
 
 PR_IMPLEMENT(PRUint32)
 PL_strlen(const char *str)
 {
     size_t l;
 
-    if( (const char *)0 == str ) return 0;
+    if( (const char *)0 == str ) {
+        return 0;
+    }
 
     l = strlen(str);
 
     /* error checking in case we have a 64-bit platform -- make sure
      * we don't have ultra long strings that overflow an int32
-     */ 
+     */
     if( sizeof(PRUint32) < sizeof(size_t) )
     {
-        if( l > PR_INT32_MAX )
+        if( l > PR_INT32_MAX ) {
             PR_Assert("l <= PR_INT32_MAX", __FILE__, __LINE__);
+        }
     }
 
     return (PRUint32)l;
 }
 
 PR_IMPLEMENT(PRUint32)
 PL_strnlen(const char *str, PRUint32 max)
 {
     register const char *s;
 
-    if( (const char *)0 == str ) return 0;
+    if( (const char *)0 == str ) {
+        return 0;
+    }
     for( s = str; max && *s; s++, max-- )
         ;
 
     return (PRUint32)(s - str);
 }
--- a/nsprpub/lib/libc/src/strpbrk.c
+++ b/nsprpub/lib/libc/src/strpbrk.c
@@ -4,65 +4,76 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "plstr.h"
 #include <string.h>
 
 PR_IMPLEMENT(char *)
 PL_strpbrk(const char *s, const char *list)
 {
-    if( ((const char *)0 == s) || ((const char *)0 == list) ) return (char *)0;
+    if( ((const char *)0 == s) || ((const char *)0 == list) ) {
+        return (char *)0;
+    }
 
     return strpbrk(s, list);
 }
 
 PR_IMPLEMENT(char *)
 PL_strprbrk(const char *s, const char *list)
 {
     const char *p;
     const char *r;
 
-    if( ((const char *)0 == s) || ((const char *)0 == list) ) return (char *)0;
+    if( ((const char *)0 == s) || ((const char *)0 == list) ) {
+        return (char *)0;
+    }
 
     for( r = s; *r; r++ )
         ;
 
     for( r--; r >= s; r-- )
         for( p = list; *p; p++ )
-            if( *r == *p )
+            if( *r == *p ) {
                 return (char *)r;
+            }
 
     return (char *)0;
 }
 
 PR_IMPLEMENT(char *)
 PL_strnpbrk(const char *s, const char *list, PRUint32 max)
 {
     const char *p;
 
-    if( ((const char *)0 == s) || ((const char *)0 == list) ) return (char *)0;
+    if( ((const char *)0 == s) || ((const char *)0 == list) ) {
+        return (char *)0;
+    }
 
     for( ; max && *s; s++, max-- )
         for( p = list; *p; p++ )
-            if( *s == *p )
+            if( *s == *p ) {
                 return (char *)s;
+            }
 
     return (char *)0;
 }
 
 PR_IMPLEMENT(char *)
 PL_strnprbrk(const char *s, const char *list, PRUint32 max)
 {
     const char *p;
     const char *r;
 
-    if( ((const char *)0 == s) || ((const char *)0 == list) ) return (char *)0;
+    if( ((const char *)0 == s) || ((const char *)0 == list) ) {
+        return (char *)0;
+    }
 
     for( r = s; max && *r; r++, max-- )
         ;
 
     for( r--; r >= s; r-- )
         for( p = list; *p; p++ )
-            if( *r == *p )
+            if( *r == *p ) {
                 return (char *)r;
+            }
 
     return (char *)0;
 }
--- a/nsprpub/lib/libc/src/strstr.c
+++ b/nsprpub/lib/libc/src/strstr.c
@@ -4,82 +4,107 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "plstr.h"
 #include <string.h>
 
 PR_IMPLEMENT(char *)
 PL_strstr(const char *big, const char *little)
 {
-    if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
-    if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
+    if( ((const char *)0 == big) || ((const char *)0 == little) ) {
+        return (char *)0;
+    }
+    if( ((char)0 == *big) || ((char)0 == *little) ) {
+        return (char *)0;
+    }
 
     return strstr(big, little);
 }
 
 PR_IMPLEMENT(char *)
 PL_strrstr(const char *big, const char *little)
 {
     const char *p;
     size_t ll;
     size_t bl;
 
-    if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
-    if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
+    if( ((const char *)0 == big) || ((const char *)0 == little) ) {
+        return (char *)0;
+    }
+    if( ((char)0 == *big) || ((char)0 == *little) ) {
+        return (char *)0;
+    }
 
     ll = strlen(little);
     bl = strlen(big);
-    if( bl < ll ) return (char *)0;
+    if( bl < ll ) {
+        return (char *)0;
+    }
     p = &big[ bl - ll ];
 
     for( ; p >= big; p-- )
         if( *little == *p )
-            if( 0 == strncmp(p, little, ll) )
+            if( 0 == strncmp(p, little, ll) ) {
                 return (char *)p;
+            }
 
     return (char *)0;
 }
 
 PR_IMPLEMENT(char *)
 PL_strnstr(const char *big, const char *little, PRUint32 max)
 {
     size_t ll;
 
-    if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
-    if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
+    if( ((const char *)0 == big) || ((const char *)0 == little) ) {
+        return (char *)0;
+    }
+    if( ((char)0 == *big) || ((char)0 == *little) ) {
+        return (char *)0;
+    }
 
     ll = strlen(little);
-    if( ll > (size_t)max ) return (char *)0;
+    if( ll > (size_t)max ) {
+        return (char *)0;
+    }
     max -= (PRUint32)ll;
     max++;
 
     for( ; max && *big; big++, max-- )
         if( *little == *big )
-            if( 0 == strncmp(big, little, ll) )
+            if( 0 == strncmp(big, little, ll) ) {
                 return (char *)big;
+            }
 
     return (char *)0;
 }
 
 PR_IMPLEMENT(char *)
 PL_strnrstr(const char *big, const char *little, PRUint32 max)
 {
     const char *p;
     size_t ll;
 
-    if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
-    if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
+    if( ((const char *)0 == big) || ((const char *)0 == little) ) {
+        return (char *)0;
+    }
+    if( ((char)0 == *big) || ((char)0 == *little) ) {
+        return (char *)0;
+    }
 
     ll = strlen(little);
 
     for( p = big; max && *p; p++, max-- )
         ;
 
     p -= ll;
-    if( p < big ) return (char *)0;
+    if( p < big ) {
+        return (char *)0;
+    }
 
     for( ; p >= big; p-- )
         if( *little == *p )
-            if( 0 == strncmp(p, little, ll) )
+            if( 0 == strncmp(p, little, ll) ) {
                 return (char *)p;
+            }
 
     return (char *)0;
 }
--- a/nsprpub/lib/libc/src/strtok.c
+++ b/nsprpub/lib/libc/src/strtok.c
@@ -9,39 +9,42 @@ PR_IMPLEMENT(char *)
 PL_strtok_r(char *s1, const char *s2, char **lasts)
 {
     const char *sepp;
     int         c, sc;
     char       *tok;
 
     if( s1 == NULL )
     {
-        if( *lasts == NULL )
+        if( *lasts == NULL ) {
             return NULL;
+        }
 
         s1 = *lasts;
     }
-  
+
     for( ; (c = *s1) != 0; s1++ )
     {
         for( sepp = s2 ; (sc = *sepp) != 0 ; sepp++ )
         {
-            if( c == sc )
+            if( c == sc ) {
                 break;
+            }
         }
-        if( sc == 0 )
-            break; 
+        if( sc == 0 ) {
+            break;
+        }
     }
 
     if( c == 0 )
     {
         *lasts = NULL;
         return NULL;
     }
-  
+
     tok = s1++;
 
     for( ; (c = *s1) != 0; s1++ )
     {
         for( sepp = s2; (sc = *sepp) != 0; sepp++ )
         {
             if( c == sc )
             {
--- a/nsprpub/lib/prstreams/plvrsion.c
+++ b/nsprpub/lib/prstreams/plvrsion.c
@@ -63,35 +63,35 @@ PRVersionDescription VERSION_DESC_NAME =
 
 /*
  * Version information for the 'ident' and 'what commands
  *
  * NOTE: the first component of the concatenated rcsid string
  * must not end in a '$' to prevent rcs keyword substitution.
  */
 static char rcsid[] = "$Header: NSPR " PR_VERSION _DEBUG_STRING
-        "  " _BUILD_STRING " $";
+                      "  " _BUILD_STRING " $";
 static char sccsid[] = "@(#)NSPR " PR_VERSION _DEBUG_STRING
-        "  " _BUILD_STRING;
+                       "  " _BUILD_STRING;
 
 #endif /* XP_UNIX */
 
 #ifdef _PR_HAS_PRAGMA_DIAGNOSTIC
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
 #endif
 PR_IMPLEMENT(const PRVersionDescription*) libVersionPoint()
 {
 #ifdef XP_UNIX
     /*
      * Add dummy references to rcsid and sccsid to prevent them
      * from being optimized away as unused variables.
      */
     const char *dummy;
-    
+
     dummy = rcsid;
     dummy = sccsid;
 #endif
     return &VERSION_DESC_NAME;
 }  /* versionEntryPointType */
 #ifdef _PR_HAS_PRAGMA_DIAGNOSTIC
 #pragma GCC diagnostic pop
 #endif
--- a/nsprpub/lib/prstreams/prstrms.cpp
+++ b/nsprpub/lib/prstreams/prstrms.cpp
@@ -110,17 +110,17 @@ PRfilebuf *PRfilebuf::open(
 
     if ((_fd = PR_Open(name, prflags, mode)) == NULL) {
         return NULL;
     }
 
     _opened = true;
 
     if (ate &&
-            seekoff(0, ios_base::end, flags) == pos_type(traits_type::eof())) {
+        seekoff(0, ios_base::end, flags) == pos_type(traits_type::eof())) {
         close();
         return NULL;
     }
 
     return this;
 }
 
 
@@ -133,23 +133,24 @@ PRfilebuf *PRfilebuf::attach(PRFileDesc 
     _opened = false;
     _fd = fd;
     return this;
 }
 
 
 PRfilebuf *PRfilebuf::close()
 {
-    if (_fd == NULL)
+    if (_fd == NULL) {
         return NULL;
+    }
 
     int status = sync();
 
     if (PR_Close(_fd) == PR_FAILURE ||
-            traits_type::eq_int_type(status, traits_type::eof())) {
+        traits_type::eq_int_type(status, traits_type::eof())) {
         return NULL;
     }
 
     _fd = NULL;
     return this;
 }
 
 
--- a/nsprpub/lib/prstreams/prstrms.h
+++ b/nsprpub/lib/prstreams/prstrms.h
@@ -29,34 +29,36 @@ class PR_IMPLEMENT(std::ios_base);
 class PR_IMPLEMENT(PRfilebuf): public std::streambuf
 {
 public:
     PRfilebuf();
     PRfilebuf(PRFileDesc *fd);
     PRfilebuf(PRFileDesc *fd, char_type *ptr, std::streamsize len);
     virtual ~PRfilebuf();
 
-    bool is_open() const { return _fd != NULL; }
+    bool is_open() const {
+        return _fd != NULL;
+    }
 
     PRfilebuf *open(
-                  const char *name,
-                  std::ios_base::openmode flags,
-                  PRIntn mode);
+        const char *name,
+        std::ios_base::openmode flags,
+        PRIntn mode);
     PRfilebuf *attach(PRFileDesc *fd);
     PRfilebuf *close();
 
 protected:
     virtual std::streambuf *setbuf(char_type *ptr, std::streamsize len);
     virtual pos_type seekoff(
-                         off_type offset,
-                         std::ios_base::seekdir dir,
-                         std::ios_base::openmode flags);
+        off_type offset,
+        std::ios_base::seekdir dir,
+        std::ios_base::openmode flags);
     virtual pos_type seekpos(
-                         pos_type pos,
-                         std::ios_base::openmode flags) {
+        pos_type pos,
+        std::ios_base::openmode flags) {
         return seekoff(pos, std::ios_base::beg, flags);
     }
     virtual int sync();
     virtual int_type underflow();
     virtual int_type overflow(int_type c = traits_type::eof());
 
     // TODO: Override pbackfail(), showmanyc(), uflow(), xsgetn(), and xsputn().
 
@@ -78,18 +80,22 @@ class PR_IMPLEMENT(PRifstream): public s
 {
 public:
     PRifstream();
     PRifstream(PRFileDesc *fd);
     PRifstream(PRFileDesc *fd, char_type *ptr, std::streamsize len);
     PRifstream(const char *name, openmode flags = in, PRIntn mode = 0);
     virtual ~PRifstream();
 
-    PRfilebuf *rdbuf() const { return &_filebuf; }
-    bool is_open() const { return _filebuf.is_open(); }
+    PRfilebuf *rdbuf() const {
+        return &_filebuf;
+    }
+    bool is_open() const {
+        return _filebuf.is_open();
+    }
 
     void open(const char *name, openmode flags = in, PRIntn mode = 0);
     void attach(PRFileDesc *fd);
     void close();
 
 private:
     mutable PRfilebuf _filebuf;
 };
@@ -99,18 +105,22 @@ class PR_IMPLEMENT(PRofstream): public s
 {
 public:
     PRofstream();
     PRofstream(PRFileDesc *fd);
     PRofstream(PRFileDesc *fd, char_type *ptr, std::streamsize len);
     PRofstream(const char *name, openmode flags = out, PRIntn mode = 0);
     virtual ~PRofstream();
 
-    PRfilebuf *rdbuf() const { return &_filebuf; }
-    bool is_open() const { return _filebuf.is_open(); }
+    PRfilebuf *rdbuf() const {
+        return &_filebuf;
+    }
+    bool is_open() const {
+        return _filebuf.is_open();
+    }
 
     void open(const char *name, openmode flags = out, PRIntn mode = 0);
     void attach(PRFileDesc *fd);
     void close();
 
 private:
     mutable PRfilebuf _filebuf;
 };
@@ -120,18 +130,22 @@ class PR_IMPLEMENT(PRfstream): public st
 {
 public:
     PRfstream();
     PRfstream(PRFileDesc *fd);
     PRfstream(PRFileDesc *fd, char_type *ptr, std::streamsize len);
     PRfstream(const char *name, openmode flags = in | out, PRIntn mode = 0);
     virtual ~PRfstream();
 
-    PRfilebuf *rdbuf() const { return &_filebuf; }
-    bool is_open() const { return _filebuf.is_open(); }
+    PRfilebuf *rdbuf() const {
+        return &_filebuf;
+    }
+    bool is_open() const {
+        return _filebuf.is_open();
+    }
 
     void open(const char *name, openmode flags = in | out, PRIntn mode = 0);
     void attach(PRFileDesc *fd);
     void close();
 
 private:
     mutable PRfilebuf _filebuf;
 };
--- a/nsprpub/lib/prstreams/tests/testprstrm/testprstrm.cpp
+++ b/nsprpub/lib/prstreams/tests/testprstrm/testprstrm.cpp
@@ -23,149 +23,150 @@ using std::ios;
 const unsigned int MaxCnt = 1;
 
 typedef struct threadarg {
     const char *mytag;
 } threadarg;
 
 void threadwork(threadarg *arg);
 
-void 
+void
 threadmain(void *mytag)
 {
     threadarg arg;
 
     arg.mytag = static_cast<const char *>(mytag);
 
     threadwork(&arg);
 }
 
 void
 threadwork(threadarg *arg)
 {
-	unsigned int i;
+    unsigned int i;
 
-	char fname1[256];
-	char fname2[256];
+    char fname1[256];
+    char fname2[256];
 
-	strcpy(fname1, arg->mytag);
-	strcpy(fname2, arg->mytag);
-	strcat(fname2, "2");
-	PR_Delete(fname1);
-	PR_Delete(fname2);
+    strcpy(fname1, arg->mytag);
+    strcpy(fname2, arg->mytag);
+    strcat(fname2, "2");
+    PR_Delete(fname1);
+    PR_Delete(fname2);
 
-	PRfilebuf *fb[MaxCnt];
-	PRifstream *ifs[MaxCnt];
-	PRofstream *ofs[MaxCnt];
-	int mode = 0;
+    PRfilebuf *fb[MaxCnt];
+    PRifstream *ifs[MaxCnt];
+    PRofstream *ofs[MaxCnt];
+    int mode = 0;
 #ifdef XP_UNIX
-	mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH;
+    mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH;
 #endif
 
-	//
-	// Allocate a bunch
-	cout << "Testing unused filebufs ----------------" << endl;
-	for (i=0; i < MaxCnt; i++){
-		fb[i] = new PRfilebuf;
-	}
-	// Delete them
-	for (i=0; i < MaxCnt; i++){
-		delete fb[i];
-	}
-	cout << "Unused filebufs complete ---------------" << endl;
+    //
+    // Allocate a bunch
+    cout << "Testing unused filebufs ----------------" << endl;
+    for (i=0; i < MaxCnt; i++) {
+        fb[i] = new PRfilebuf;
+    }
+    // Delete them
+    for (i=0; i < MaxCnt; i++) {
+        delete fb[i];
+    }
+    cout << "Unused filebufs complete ---------------" << endl;
 
-	//
-	// Allocate a bunch
-	cout << "Testing unused ifstream -----------------" << endl;
-	for (i=0; i < MaxCnt; i++){
-	  ifs[i] = new PRifstream;
-	}
-	//
-	// Delete them
-	for (i=0; i < MaxCnt; i++){
-	  delete ifs[i];
-	}
-	cout << "Unused ifstream complete ----------------" << endl;
-	//
-	// Allocate a bunch
-	cout << "Testing unused ofstream -----------------" << endl;
-	for (i=0; i < MaxCnt; i++){
-		ofs[i] = new PRofstream;
-	}
-	for (i=0; i < MaxCnt; i++){
-	  *(ofs[i]) << "A"; // Write a bit
-	  delete ofs[i]; // Delete it.
-	}
-	cout << "Unused ofstream complete ----------------" << endl;
+    //
+    // Allocate a bunch
+    cout << "Testing unused ifstream -----------------" << endl;
+    for (i=0; i < MaxCnt; i++) {
+        ifs[i] = new PRifstream;
+    }
+    //
+    // Delete them
+    for (i=0; i < MaxCnt; i++) {
+        delete ifs[i];
+    }
+    cout << "Unused ifstream complete ----------------" << endl;
+    //
+    // Allocate a bunch
+    cout << "Testing unused ofstream -----------------" << endl;
+    for (i=0; i < MaxCnt; i++) {
+        ofs[i] = new PRofstream;
+    }
+    for (i=0; i < MaxCnt; i++) {
+        *(ofs[i]) << "A"; // Write a bit
+        delete ofs[i]; // Delete it.
+    }
+    cout << "Unused ofstream complete ----------------" << endl;
 
-	cout << "Testing use of ofstream 1 (extra filebuf allocated) ---------" << endl;
-	PRofstream *aos = new PRofstream(fname1, ios::out|ios::ate, mode);
-	for (i=0; i < MaxCnt; i++){
-	  for (int j=0; j < 8192; j++)
-		*aos << "AaBbCcDdEeFfGg" << endl;
-		fb[i] = new PRfilebuf; // Allocate as we go to hack at the heap
-	}
-	//
-	// Delete the extra foo we allocated
-	for (i=0; i < MaxCnt; i++){
-	  delete fb[i];
-	}
-	aos->flush(); // Explicit flush
-	delete aos;
-	cout << "Testing use of ofstream 1 complete (extra filebuf deleted) --" << endl;
-	cout << "Testing use of ofstream 2 (extra filebuf allocated) ---------" << endl;
-	PRofstream *aos2 = new PRofstream(fname2, ios::out, mode);
+    cout << "Testing use of ofstream 1 (extra filebuf allocated) ---------" << endl;
+    PRofstream *aos = new PRofstream(fname1, ios::out|ios::ate, mode);
+    for (i=0; i < MaxCnt; i++) {
+        for (int j=0; j < 8192; j++) {
+            *aos << "AaBbCcDdEeFfGg" << endl;
+        }
+        fb[i] = new PRfilebuf; // Allocate as we go to hack at the heap
+    }
+    //
+    // Delete the extra foo we allocated
+    for (i=0; i < MaxCnt; i++) {
+        delete fb[i];
+    }
+    aos->flush(); // Explicit flush
+    delete aos;
+    cout << "Testing use of ofstream 1 complete (extra filebuf deleted) --" << endl;
+    cout << "Testing use of ofstream 2 (extra filebuf allocated) ---------" << endl;
+    PRofstream *aos2 = new PRofstream(fname2, ios::out, mode);
 
-	for (i=0; i < MaxCnt; i++){
-	    *aos2 << "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz";
-	}
-	// Force flushing in the dtor
-	delete aos2;
-	cout << "Testing use of ofstream 2 complete (extra filebuf deleted) --" << endl;
-	char line[1024];
-	cout << "Testing use of ifstream 1 (stack allocation) -------------" << endl;
-	PRifstream ais(fname1);
-	for (i=0; i < MaxCnt; i++){
-		ais >> line;
-	}
-	cout << "Testing use of ifstream 1 complete -----------------------" << endl;
-	cout << "Testing use of ifstream 2 ----------------------" << endl;
-	PRifstream *ais2 = new PRifstream(fname2);
-	char achar;
-	for (i=0; i < MaxCnt*10; i++){
-		*ais2 >> achar;
-	}
-	delete ais2;
-	cout << "Testing use of ifstream 2 complete -------------" << endl;
+    for (i=0; i < MaxCnt; i++) {
+        *aos2 << "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz";
+    }
+    // Force flushing in the dtor
+    delete aos2;
+    cout << "Testing use of ofstream 2 complete (extra filebuf deleted) --" << endl;
+    char line[1024];
+    cout << "Testing use of ifstream 1 (stack allocation) -------------" << endl;
+    PRifstream ais(fname1);
+    for (i=0; i < MaxCnt; i++) {
+        ais >> line;
+    }
+    cout << "Testing use of ifstream 1 complete -----------------------" << endl;
+    cout << "Testing use of ifstream 2 ----------------------" << endl;
+    PRifstream *ais2 = new PRifstream(fname2);
+    char achar;
+    for (i=0; i < MaxCnt*10; i++) {
+        *ais2 >> achar;
+    }
+    delete ais2;
+    cout << "Testing use of ifstream 2 complete -------------" << endl;
 }
 
 #define STACKSIZE 1024*1024
 int
 main()
 {
-	PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 256);
-	threadmain(const_cast<char *>("TestFile"));
-	PRThread *thr1 = PR_CreateThread(PR_SYSTEM_THREAD, 
-					 threadmain, 
-					 const_cast<char *>("TestFile1"),
-					 PR_PRIORITY_NORMAL,
-					 PR_GLOBAL_THREAD,
-					 PR_JOINABLE_THREAD,
-					 STACKSIZE);
-	PRThread *thr2 = PR_CreateThread(PR_SYSTEM_THREAD, 
-					 threadmain, 
-					 const_cast<char *>("TestFile2"),
-					 PR_PRIORITY_NORMAL,
-					 PR_GLOBAL_THREAD,
-					 PR_JOINABLE_THREAD,
-					 STACKSIZE);
-	PRThread *thr3 = PR_CreateThread(PR_SYSTEM_THREAD, 
-					 threadmain, 
-					 const_cast<char *>("TestFile3"),
-					 PR_PRIORITY_NORMAL,
-					 PR_GLOBAL_THREAD,
-					 PR_JOINABLE_THREAD,
-					 STACKSIZE);
-	PR_JoinThread(thr1);
-	PR_JoinThread(thr2);
-	PR_JoinThread(thr3);
-	return 0;
+    PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 256);
+    threadmain(const_cast<char *>("TestFile"));
+    PRThread *thr1 = PR_CreateThread(PR_SYSTEM_THREAD,
+                                     threadmain,
+                                     const_cast<char *>("TestFile1"),
+                                     PR_PRIORITY_NORMAL,
+                                     PR_GLOBAL_THREAD,
+                                     PR_JOINABLE_THREAD,
+                                     STACKSIZE);
+    PRThread *thr2 = PR_CreateThread(PR_SYSTEM_THREAD,
+                                     threadmain,
+                                     const_cast<char *>("TestFile2"),
+                                     PR_PRIORITY_NORMAL,
+                                     PR_GLOBAL_THREAD,
+                                     PR_JOINABLE_THREAD,
+                                     STACKSIZE);
+    PRThread *thr3 = PR_CreateThread(PR_SYSTEM_THREAD,
+                                     threadmain,
+                                     const_cast<char *>("TestFile3"),
+                                     PR_PRIORITY_NORMAL,
+                                     PR_GLOBAL_THREAD,
+                                     PR_JOINABLE_THREAD,
+                                     STACKSIZE);
+    PR_JoinThread(thr1);
+    PR_JoinThread(thr2);
+    PR_JoinThread(thr3);
+    return 0;
 }
--- a/nsprpub/lib/tests/arena.c
+++ b/nsprpub/lib/tests/arena.c
@@ -28,75 +28,75 @@ PRIntn  poolMax = (100 * 4096);
 PRIntn  arenaMin = 40;
 PRIntn  arenaMax = (100 * 40);
 PRIntn  stressIterations = 15;
 PRIntn  maxAlloc = (1024 * 1024);
 PRIntn  stressThreads = 4;
 
 void DumpAll( void )
 {
-	return;
+    return;
 }
 
 /*
 ** Test Arena allocation.
 */
 static void ArenaAllocate( void )
 {
     PLArenaPool ap;
     void    *ptr;
-	PRInt32	i;
+    PRInt32 i;
 
     PL_InitArenaPool( &ap, "AllocArena", 2048, sizeof(double));
-    PR_LOG( tLM, PR_LOG_DEBUG, ("AA, InitPool -- Pool: %p. first: %p, current: %p, size: %d", 
-        &ap, ap.first, ap.current, ap.arenasize  ));
+    PR_LOG( tLM, PR_LOG_DEBUG, ("AA, InitPool -- Pool: %p. first: %p, current: %p, size: %d",
+                                &ap, ap.first, ap.current, ap.arenasize  ));
 
-	for( i = 0; i < 150; i++ )
-	{
-		PL_ARENA_ALLOCATE( ptr, &ap, 512 );
-        PR_LOG( tLM, PR_LOG_DEBUG,("AA, after alloc -- Pool: %p. first: %p, current: %p, size: %d", 
-               &ap, ap.first, ap.current, ap.arenasize  ));
-		PR_LOG( tLM, PR_LOG_DEBUG,(
-		    "AA -- Pool: %p. alloc: %p ", &ap, ptr ));
-	}
+    for( i = 0; i < 150; i++ )
+    {
+        PL_ARENA_ALLOCATE( ptr, &ap, 512 );
+        PR_LOG( tLM, PR_LOG_DEBUG,("AA, after alloc -- Pool: %p. first: %p, current: %p, size: %d",
+                                   &ap, ap.first, ap.current, ap.arenasize  ));
+        PR_LOG( tLM, PR_LOG_DEBUG,(
+                    "AA -- Pool: %p. alloc: %p ", &ap, ptr ));
+    }
 
     PL_FreeArenaPool( &ap );
 
-	for( i = 0; i < 221; i++ )
-	{
-		PL_ARENA_ALLOCATE( ptr, &ap, 512 );
-        PR_LOG( tLM, PR_LOG_DEBUG,("AA, after alloc -- Pool: %p. first: %p, current: %p, size: %d", 
-               &ap, ap.first, ap.current, ap.arenasize  ));
-		PR_LOG( tLM, PR_LOG_DEBUG,(
-		    "AA -- Pool: %p. alloc: %p ", &ap, ptr ));
-	}
+    for( i = 0; i < 221; i++ )
+    {
+        PL_ARENA_ALLOCATE( ptr, &ap, 512 );
+        PR_LOG( tLM, PR_LOG_DEBUG,("AA, after alloc -- Pool: %p. first: %p, current: %p, size: %d",
+                                   &ap, ap.first, ap.current, ap.arenasize  ));
+        PR_LOG( tLM, PR_LOG_DEBUG,(
+                    "AA -- Pool: %p. alloc: %p ", &ap, ptr ));
+    }
 
     PL_FreeArenaPool( &ap );
-    
+
     return;
 } /* end ArenaGrow() */
 /*
 ** Test Arena grow.
 */
 static void ArenaGrow( void )
 {
     PLArenaPool ap;
     void    *ptr;
-	PRInt32	i;
+    PRInt32 i;
 
     PL_InitArenaPool( &ap, "TheArena", 4096, sizeof(double));
     PL_ARENA_ALLOCATE( ptr, &ap, 512 );
 
-	PR_LOG( tLM, PR_LOG_DEBUG, ("Before growth -- Pool: %p. alloc: %p ", &ap, ptr ));
+    PR_LOG( tLM, PR_LOG_DEBUG, ("Before growth -- Pool: %p. alloc: %p ", &ap, ptr ));
 
-	for( i = 0; i < 10; i++ )
-	{
-		PL_ARENA_GROW( ptr, &ap, 512, 7000 );
-		PR_LOG( tLM, PR_LOG_DEBUG, ("After growth -- Pool: %p. alloc: %p ", &ap, ptr ));
-	}
+    for( i = 0; i < 10; i++ )
+    {
+        PL_ARENA_GROW( ptr, &ap, 512, 7000 );
+        PR_LOG( tLM, PR_LOG_DEBUG, ("After growth -- Pool: %p. alloc: %p ", &ap, ptr ));
+    }
 
 
     return;
 } /* end ArenaGrow() */
 
 
 /*
 ** Test arena Mark and Release.
@@ -106,79 +106,79 @@ static void MarkAndRelease( void )
     PLArenaPool ap;
     void    *ptr = NULL;
     void    *mark0, *mark1;
     PRIntn  i;
 
     PL_InitArenaPool( &ap, "TheArena", 4096, sizeof(double));
     mark0 = PL_ARENA_MARK( &ap );
     PR_LOG( tLM, PR_LOG_DEBUG,
-        ("mark0. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p, m0: %p", 
-            &ap, ap.first.next, ap.current, ap.arenasize, ptr, mark0 ));
+            ("mark0. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p, m0: %p",
+             &ap, ap.first.next, ap.current, ap.arenasize, ptr, mark0 ));
 
-	for( i = 0; i < 201; i++ )
-	{
-		PL_ARENA_ALLOCATE( ptr, &ap, 512 );
+    for( i = 0; i < 201; i++ )
+    {
+        PL_ARENA_ALLOCATE( ptr, &ap, 512 );
         PR_LOG( tLM, PR_LOG_DEBUG,
-            ("mr. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p", 
-                &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
-	}
+                ("mr. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p",
+                 &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
+    }
 
     mark1 = PL_ARENA_MARK( &ap );
     PR_LOG( tLM, PR_LOG_DEBUG,
-        ("mark1. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p, m1: %p", 
-            &ap, ap.first.next, ap.current, ap.arenasize, ptr, mark1 ));
+            ("mark1. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p, m1: %p",
+             &ap, ap.first.next, ap.current, ap.arenasize, ptr, mark1 ));
 
 
-	for( i = 0; i < 225; i++ )
-	{
-		PL_ARENA_ALLOCATE( ptr, &ap, 512 );
+    for( i = 0; i < 225; i++ )
+    {
+        PL_ARENA_ALLOCATE( ptr, &ap, 512 );
         PR_LOG( tLM, PR_LOG_DEBUG,
-            ("mr. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p", 
-                &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
-	}
+                ("mr. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p",
+                 &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
+    }
 
     PL_ARENA_RELEASE( &ap, mark1 );
     PR_LOG( tLM, PR_LOG_DEBUG,
-        ("Release-1: %p -- Pool: %p. first: %p, current: %p, size: %d", 
-               mark1, &ap, ap.first, ap.current, ap.arenasize  ));
+            ("Release-1: %p -- Pool: %p. first: %p, current: %p, size: %d",
+             mark1, &ap, ap.first, ap.current, ap.arenasize  ));
 
-	for( i = 0; i < 20; i++ )
-	{
-		PL_ARENA_ALLOCATE( ptr, &ap, 512 );
+    for( i = 0; i < 20; i++ )
+    {
+        PL_ARENA_ALLOCATE( ptr, &ap, 512 );
         PR_LOG( tLM, PR_LOG_DEBUG,
-            ("mr. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p", 
-                &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
-	}
+                ("mr. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p",
+                 &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
+    }
 
     PL_ARENA_RELEASE( &ap, mark1 );
     PR_LOG( tLM, PR_LOG_DEBUG,
-        ("Release-1. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p", 
-            &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
+            ("Release-1. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p",
+             &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
 
     PL_ARENA_RELEASE( &ap, mark0 );
     PR_LOG( tLM, PR_LOG_DEBUG,
-        ("Release-0. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p", 
-            &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
+            ("Release-0. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p",
+             &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
 
     PL_FreeArenaPool( &ap );
     PR_LOG( tLM, PR_LOG_DEBUG,
-        ("Free. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p", 
-            &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
-    
+            ("Free. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p",
+             &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
+
     PL_FinishArenaPool( &ap );
     PR_LOG( tLM, PR_LOG_DEBUG,
-        ("Finish. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p", 
-            &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
+            ("Finish. ap: %p, ap.f: %p, ap.c: %p, ap.siz: %d, alloc: %p",
+             &ap, ap.first.next, ap.current, ap.arenasize, ptr ));
 
     return;
 } /* end MarkAndRelease() */
 
 /*
-** RandSize() returns a random number in the range 
+** RandSize() returns a random number in the range
 ** min..max, rounded to the next doubleword
 **
 */
 static PRIntn RandSize( PRIntn min, PRIntn max )
 {
     PRIntn  sz = (rand() % (max -min)) + min + sizeof(double);
 
     sz &= ~sizeof(double)-1;
@@ -225,55 +225,55 @@ static void PR_CALLBACK StressThread( vo
     PR_LOG( tLM, PR_LOG_DEBUG, ("Stress thread %p finished all iteration\n", tp));
     PL_FinishArenaPool( &ap );
     PR_LOG( tLM, PR_LOG_DEBUG, ("Stress thread %p after FinishArenaPool()\n", tp));
 
     /* That's all folks! let's quit */
     PR_EnterMonitor(tMon);
     threadCount--;
     PR_Notify(tMon);
-    PR_ExitMonitor(tMon);    
+    PR_ExitMonitor(tMon);
     return;
-}    
+}
 
 /*
 ** Stress()
 ** Flog the hell out of arenas multi-threaded.
 ** Do NOT pass an individual arena to another thread.
-** 
+**
 */
 static void Stress( void )
 {
     PRThread    *tt;
     PRIntn      i;
 
     tMon = PR_NewMonitor();
 
     for ( i = 0 ; i < stressThreads ; i++ )
     {
         PR_EnterMonitor(tMon);
         tt = PR_CreateThread(PR_USER_THREAD,
-               StressThread,
-               NULL,
-               PR_PRIORITY_NORMAL,
-               PR_GLOBAL_THREAD,
-               PR_UNJOINABLE_THREAD,
-               0);
+                             StressThread,
+                             NULL,
+                             PR_PRIORITY_NORMAL,
+                             PR_GLOBAL_THREAD,
+                             PR_UNJOINABLE_THREAD,
+                             0);
         threadCount++;
         PR_ExitMonitor(tMon);
     }
 
     /* Wait for all threads to exit */
     PR_EnterMonitor(tMon);
-    while ( threadCount != 0 ) 
+    while ( threadCount != 0 )
     {
         PR_Wait(tMon, PR_INTERVAL_NO_TIMEOUT);
     }
     PR_ExitMonitor(tMon);
-	PR_DestroyMonitor(tMon);
+    PR_DestroyMonitor(tMon);
 
     return;
 } /* end Stress() */
 
 /*
 ** EvaluateResults()
 ** uses failed_already to display results and set program
 ** exit code.
@@ -281,17 +281,17 @@ static void Stress( void )
 static PRIntn  EvaluateResults(void)
 {
     PRIntn rc = 0;
 
     if ( failed_already == PR_TRUE )
     {
         PR_LOG( tLM, PR_LOG_DEBUG, ("FAIL\n"));
         rc =1;
-    } 
+    }
     else
     {
         PR_LOG( tLM, PR_LOG_DEBUG, ("PASS\n"));
     }
     return(rc);
 } /* EvaluateResults() */
 
 void Help( void )
@@ -303,65 +303,67 @@ void Help( void )
     printf("-a <n>   minimum size of an arena allocation. Default(%d)\n", arenaMin);
     printf("-A <n>   maximum size of an arena allocation. Default(%d)\n", arenaMax);
     printf("-i <n>   number of iterations in a stress thread. Default(%d)\n", stressIterations);
     printf("-s <n>   maximum allocation for a single stress thread. Default(%d)\n", maxAlloc);
     printf("-t <n>   number of stress threads. Default(%d)\n", stressThreads );
     printf("-d       enable debug mode\n");
     printf("\n");
     exit(1);
-}    
+}
 
 PRIntn main(PRIntn argc, char *argv[])
 {
     PLOptStatus os;
-	PLOptState *opt = PL_CreateOptState(argc, argv, "dhp:P:a:A:i:s:t:");
-	while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
+    PLOptState *opt = PL_CreateOptState(argc, argv, "dhp:P:a:A:i:s:t:");
+    while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
     {
-		if (PL_OPT_BAD == os) continue;
+        if (PL_OPT_BAD == os) {
+            continue;
+        }
         switch (opt->option)
         {
-        case 'a':  /* arena Min size */
-            arenaMin = atol( opt->value );
-            break;
-        case 'A':  /* arena Max size  */
-            arenaMax = atol( opt->value );
-            break;
-        case 'p':  /* pool Min size */
-            poolMin = atol( opt->value );
-            break;
-        case 'P':  /* pool Max size */
-            poolMax = atol( opt->value );
-            break;
-        case 'i':  /* Iterations in stress tests */
-            stressIterations = atol( opt->value );
-            break;
-        case 's':  /* storage to get per iteration */
-            maxAlloc = atol( opt->value );
-            break;
-        case 't':  /* Number of stress threads to create */
-            stressThreads = atol( opt->value );
-            break;
-        case 'd':  /* debug mode */
-			debug_mode = 1;
-            break;
-        case 'h':  /* help */
-        default:
-            Help();
+            case 'a':  /* arena Min size */
+                arenaMin = atol( opt->value );
+                break;
+            case 'A':  /* arena Max size  */
+                arenaMax = atol( opt->value );
+                break;
+            case 'p':  /* pool Min size */
+                poolMin = atol( opt->value );
+                break;
+            case 'P':  /* pool Max size */
+                poolMax = atol( opt->value );
+                break;
+            case 'i':  /* Iterations in stress tests */
+                stressIterations = atol( opt->value );
+                break;
+            case 's':  /* storage to get per iteration */
+                maxAlloc = atol( opt->value );
+                break;
+            case 't':  /* Number of stress threads to create */
+                stressThreads = atol( opt->value );
+                break;
+            case 'd':  /* debug mode */
+                debug_mode = 1;
+                break;
+            case 'h':  /* help */
+            default:
+                Help();
         } /* end switch() */
     } /* end while() */
-	PL_DestroyOptState(opt);
+    PL_DestroyOptState(opt);
 
     srand( (unsigned)time( NULL ) ); /* seed random number generator */
     tLM = PR_NewLogModule("testcase");
 
 
 #if 0
-	ArenaAllocate();
-	ArenaGrow();
+    ArenaAllocate();
+    ArenaGrow();
 #endif
 
     MarkAndRelease();
 
     Stress();
 
     return(EvaluateResults());
 } /* end main() */
--- a/nsprpub/lib/tests/base64t.c
+++ b/nsprpub/lib/tests/base64t.c
@@ -158,1638 +158,2013 @@ PRBool test_003(void)
             }
         }
     }
 
     printf("PASS\n");
     return PR_TRUE;
 }
 
-    static struct
-    {
-        const char *plaintext;
-        const char *cyphertext;
-    } array[] =
-      {
-          /* Cyphertexts generated with uuenview 0.5.13 */
-          { " ", "IA==" },
-          { ".", "Lg==" },
-          { "/", "Lw==" },
-          { "C", "Qw==" },
-          { "H", "SA==" },
-          { "S", "Uw==" },
-          { "^", "Xg==" },
-          { "a", "YQ==" },
-          { "o", "bw==" },
-          { "t", "dA==" },
+static struct
+{
+    const char *plaintext;
+    const char *cyphertext;
+} array[] =
+{
+    /* Cyphertexts generated with uuenview 0.5.13 */
+    { " ", "IA==" },
+    { ".", "Lg==" },
+    { "/", "Lw==" },
+    { "C", "Qw==" },
+    { "H", "SA==" },
+    { "S", "Uw==" },
+    { "^", "Xg==" },
+    { "a", "YQ==" },
+    { "o", "bw==" },
+    { "t", "dA==" },
 
-          { "AB", "QUI=" },
-          { "AH", "QUg=" },
-          { "AQ", "QVE=" },
-          { "BD", "QkQ=" },
-          { "CR", "Q1I=" },
-          { "CS", "Q1M=" },
-          { "DB", "REI=" },
-          { "DC", "REM=" },
-          { "EK", "RUs=" },
-          { "ET", "RVQ=" },
-          { "IM", "SU0=" },
-          { "JR", "SlI=" },
-          { "LO", "TE8=" },
-          { "LW", "TFc=" },
-          { "ML", "TUw=" },
-          { "SB", "U0I=" },
-          { "TO", "VE8=" },
-          { "VS", "VlM=" },
-          { "WP", "V1A=" },
-          /* legitimate two-letter words */
-          { "ad", "YWQ=" },
-          { "ah", "YWg=" },
-          { "am", "YW0=" },
-          { "an", "YW4=" },
-          { "as", "YXM=" },
-          { "at", "YXQ=" },
-          { "ax", "YXg=" },
-          { "be", "YmU=" },
-          { "by", "Ynk=" },
-          { "do", "ZG8=" },
-          { "go", "Z28=" },
-          { "he", "aGU=" },
-          { "hi", "aGk=" },
-          { "if", "aWY=" },
-          { "in", "aW4=" },
-          { "is", "aXM=" },
-          { "it", "aXQ=" },
-          { "me", "bWU=" },
-          { "my", "bXk=" },
-          { "no", "bm8=" },
-          { "of", "b2Y=" },
-          { "on", "b24=" },
-          { "or", "b3I=" },
-          { "ox", "b3g=" },
-          { "so", "c28=" },
-          { "to", "dG8=" },
-          { "up", "dXA=" },
-          { "us", "dXM=" },
-          { "we", "d2U=" },
-          /* all three-letter entries in /usr/dict/words */
-          { "1st", "MXN0" },
-          { "2nd", "Mm5k" },
-          { "3rd", "M3Jk" },
-          { "4th", "NHRo" },
-          { "5th", "NXRo" },
-          { "6th", "NnRo" },
-          { "7th", "N3Ro" },
-          { "8th", "OHRo" },
-          { "9th", "OXRo" },
-          { "AAA", "QUFB" },
-          { "AAU", "QUFV" },
-          { "ABA", "QUJB" },
-          { "abc", "YWJj" },
-          { "Abe", "QWJl" },
-          { "Abo", "QWJv" },
-          { "ace", "YWNl" },
-          { "ACM", "QUNN" },
-          { "ACS", "QUNT" },
-          { "act", "YWN0" },
-          { "Ada", "QWRh" },
-          { "add", "YWRk" },
-          { "ado", "YWRv" },
-          { "aft", "YWZ0" },
-          { "age", "YWdl" },
-          { "ago", "YWdv" },
-          { "aid", "YWlk" },
-          { "ail", "YWls" },
-          { "aim", "YWlt" },
-          { "air", "YWly" },
-          { "ala", "YWxh" },
-          { "alb", "YWxi" },
-          { "ale", "YWxl" },
-          { "Ali", "QWxp" },
-          { "all", "YWxs" },
-          { "alp", "YWxw" },
-          { "A&M", "QSZN" },
-          { "AMA", "QU1B" },
-          { "ami", "YW1p" },
-          { "amp", "YW1w" },
-          { "Amy", "QW15" },
-          { "amy", "YW15" },
-          { "ana", "YW5h" },
-          { "and", "YW5k" },
-          { "ani", "YW5p" },
-          { "Ann", "QW5u" },
-          { "ant", "YW50" },
-          { "any", "YW55" },
-          { "A&P", "QSZQ" },
-          { "ape", "YXBl" },
-          { "Apr", "QXBy" },
-          { "APS", "QVBT" },
-          { "apt", "YXB0" },
-          { "arc", "YXJj" },
-          { "are", "YXJl" },
-          { "ark", "YXJr" },
-          { "arm", "YXJt" },
-          { "art", "YXJ0" },
-          { "a's", "YSdz" },
-          { "ash", "YXNo" },
-          { "ask", "YXNr" },
-          { "ass", "YXNz" },
-          { "ate", "YXRl" },
-          { "Aug", "QXVn" },
-          { "auk", "YXVr" },
-          { "Ave", "QXZl" },
-          { "awe", "YXdl" },
-          { "awl", "YXds" },
-          { "awn", "YXdu" },
-          { "axe", "YXhl" },
-          { "aye", "YXll" },
-          { "bad", "YmFk" },
-          { "bag", "YmFn" },
-          { "bah", "YmFo" },
-          { "bam", "YmFt" },
-          { "ban", "YmFu" },
-          { "bar", "YmFy" },
-          { "bat", "YmF0" },
-          { "bay", "YmF5" },
-          { "bed", "YmVk" },
-          { "bee", "YmVl" },
-          { "beg", "YmVn" },
-          { "bel", "YmVs" },
-          { "Ben", "QmVu" },
-          { "bet", "YmV0" },
-          { "bey", "YmV5" },
-          { "bib", "Ymli" },
-          { "bid", "Ymlk" },
-          { "big", "Ymln" },
-          { "bin", "Ymlu" },
-          { "bit", "Yml0" },
-          { "biz", "Yml6" },
-          { "BMW", "Qk1X" },
-          { "boa", "Ym9h" },
-          { "bob", "Ym9i" },
-          { "bog", "Ym9n" },
-          { "bon", "Ym9u" },
-          { "boo", "Ym9v" },
-          { "bop", "Ym9w" },
-          { "bow", "Ym93" },
-          { "box", "Ym94" },
-          { "boy", "Ym95" },
-          { "b's", "Yidz" },
-          { "BTL", "QlRM" },
-          { "BTU", "QlRV" },
-          { "bub", "YnVi" },
-          { "bud", "YnVk" },
-          { "bug", "YnVn" },
-          { "bum", "YnVt" },
-          { "bun", "YnVu" },
-          { "bus", "YnVz" },
-          { "but", "YnV0" },
-          { "buy", "YnV5" },
-          { "bye", "Ynll" },
-          { "cab", "Y2Fi" },
-          { "Cal", "Q2Fs" },
-          { "cam", "Y2Ft" },
-          { "can", "Y2Fu" },
-          { "cap", "Y2Fw" },
-          { "car", "Y2Fy" },
-          { "cat", "Y2F0" },
-          { "caw", "Y2F3" },
-          { "CBS", "Q0JT" },
-          { "CDC", "Q0RD" },
-          { "CEQ", "Q0VR" },
-          { "chi", "Y2hp" },
-          { "CIA", "Q0lB" },
-          { "cit", "Y2l0" },
-          { "cod", "Y29k" },
-          { "cog", "Y29n" },
-          { "col", "Y29s" },
-          { "con", "Y29u" },
-          { "coo", "Y29v" },
-          { "cop", "Y29w" },
-          { "cos", "Y29z" },
-          { "cot", "Y290" },
-          { "cow", "Y293" },
-          { "cox", "Y294" },
-          { "coy", "Y295" },
-          { "CPA", "Q1BB" },
-          { "cpu", "Y3B1" },
-          { "CRT", "Q1JU" },
-          { "cry", "Y3J5" },
-          { "c's", "Yydz" },
-          { "cub", "Y3Vi" },
-          { "cud", "Y3Vk" },
-          { "cue", "Y3Vl" },
-          { "cup", "Y3Vw" },
-          { "cur", "Y3Vy" },
-          { "cut", "Y3V0" },
-          { "dab", "ZGFi" },
-          { "dad", "ZGFk" },
-          { "dam", "ZGFt" },
-          { "Dan", "RGFu" },
-          { "Dar", "RGFy" },
-          { "day", "ZGF5" },
-          { "Dec", "RGVj" },
-          { "Dee", "RGVl" },
-          { "Del", "RGVs" },
-          { "den", "ZGVu" },
-          { "Des", "RGVz" },
-          { "dew", "ZGV3" },
-          { "dey", "ZGV5" },
-          { "did", "ZGlk" },
-          { "die", "ZGll" },
-          { "dig", "ZGln" },
-          { "dim", "ZGlt" },
-          { "din", "ZGlu" },
-          { "dip", "ZGlw" },
-          { "Dis", "RGlz" },
-          { "DNA", "RE5B" },
-          { "DOD", "RE9E" },
-          { "doe", "ZG9l" },
-          { "dog", "ZG9n" },
-          { "don", "ZG9u" },
-          { "dot", "ZG90" },
-          { "Dow", "RG93" },
-          { "dry", "ZHJ5" },
-          { "d's", "ZCdz" },
-          { "dub", "ZHVi" },
-          { "dud", "ZHVk" },
-          { "due", "ZHVl" },
-          { "dug", "ZHVn" },
-          { "dun", "ZHVu" },
-          { "dye", "ZHll" },
-          { "ear", "ZWFy" },
-          { "eat", "ZWF0" },
-          { "ebb", "ZWJi" },
-          { "EDT", "RURU" },
-          { "eel", "ZWVs" },
-          { "eft", "ZWZ0" },
-          { "e.g", "ZS5n" },
-          { "egg", "ZWdn" },
-          { "ego", "ZWdv" },
-          { "eke", "ZWtl" },
-          { "Eli", "RWxp" },
-          { "elk", "ZWxr" },
-          { "ell", "ZWxs" },
-          { "elm", "ZWxt" },
-          { "Ely", "RWx5" },
-          { "end", "ZW5k" },
-          { "Eng", "RW5n" },
-          { "EPA", "RVBB" },
-          { "era", "ZXJh" },
-          { "ere", "ZXJl" },
-          { "erg", "ZXJn" },
-          { "err", "ZXJy" },
-          { "e's", "ZSdz" },
-          { "EST", "RVNU" },
-          { "eta", "ZXRh" },
-          { "etc", "ZXRj" },
-          { "Eva", "RXZh" },
-          { "eve", "ZXZl" },
-          { "ewe", "ZXdl" },
-          { "eye", "ZXll" },
-          { "FAA", "RkFB" },
-          { "fad", "ZmFk" },
-          { "fag", "ZmFn" },
-          { "fan", "ZmFu" },
-          { "far", "ZmFy" },
-          { "fat", "ZmF0" },
-          { "fay", "ZmF5" },
-          { "FBI", "RkJJ" },
-          { "FCC", "RkND" },
-          { "FDA", "RkRB" },
-          { "Feb", "RmVi" },
-          { "fed", "ZmVk" },
-          { "fee", "ZmVl" },
-          { "few", "ZmV3" },
-          { "fib", "Zmli" },
-          { "fig", "Zmln" },
-          { "fin", "Zmlu" },
-          { "fir", "Zmly" },
-          { "fit", "Zml0" },
-          { "fix", "Zml4" },
-          { "Flo", "Rmxv" },
-          { "flu", "Zmx1" },
-          { "fly", "Zmx5" },
-          { "FMC", "Rk1D" },
-          { "fob", "Zm9i" },
-          { "foe", "Zm9l" },
-          { "fog", "Zm9n" },
-          { "fop", "Zm9w" },
-          { "for", "Zm9y" },
-          { "fox", "Zm94" },
-          { "FPC", "RlBD" },
-          { "fro", "ZnJv" },
-          { "fry", "ZnJ5" },
-          { "f's", "Zidz" },
-          { "FTC", "RlRD" },
-          { "fum", "ZnVt" },
-          { "fun", "ZnVu" },
-          { "fur", "ZnVy" },
-          { "gab", "Z2Fi" },
-          { "gad", "Z2Fk" },
-          { "gag", "Z2Fn" },
-          { "gal", "Z2Fs" },
-          { "gam", "Z2Ft" },
-          { "GAO", "R0FP" },
-          { "gap", "Z2Fw" },
-          { "gar", "Z2Fy" },
-          { "gas", "Z2Fz" },
-          { "gay", "Z2F5" },
-          { "gee", "Z2Vl" },
-          { "gel", "Z2Vs" },
-          { "gem", "Z2Vt" },
-          { "get", "Z2V0" },
-          { "gig", "Z2ln" },
-          { "Gil", "R2ls" },
-          { "gin", "Z2lu" },
-          { "GMT", "R01U" },
-          { "GNP", "R05Q" },
-          { "gnu", "Z251" },
-          { "Goa", "R29h" },
-          { "gob", "Z29i" },
-          { "god", "Z29k" },
-          { "gog", "Z29n" },
-          { "GOP", "R09Q" },
-          { "got", "Z290" },
-          { "GPO", "R1BP" },
-          { "g's", "Zydz" },
-          { "GSA", "R1NB" },
-          { "gum", "Z3Vt" },
-          { "gun", "Z3Vu" },
-          { "Gus", "R3Vz" },
-          { "gut", "Z3V0" },
-          { "guy", "Z3V5" },
-          { "gym", "Z3lt" },
-          { "gyp", "Z3lw" },
-          { "had", "aGFk" },
-          { "Hal", "SGFs" },
-          { "ham", "aGFt" },
-          { "Han", "SGFu" },
-          { "hap", "aGFw" },
-          { "hat", "aGF0" },
-          { "haw", "aGF3" },
-          { "hay", "aGF5" },
-          { "hem", "aGVt" },
-          { "hen", "aGVu" },
-          { "her", "aGVy" },
-          { "hew", "aGV3" },
-          { "hex", "aGV4" },
-          { "hey", "aGV5" },
-          { "hid", "aGlk" },
-          { "him", "aGlt" },
-          { "hip", "aGlw" },
-          { "his", "aGlz" },
-          { "hit", "aGl0" },
-          { "hob", "aG9i" },
-          { "hoc", "aG9j" },
-          { "hoe", "aG9l" },
-          { "hog", "aG9n" },
-          { "hoi", "aG9p" },
-          { "Hom", "SG9t" },
-          { "hop", "aG9w" },
-          { "hot", "aG90" },
-          { "how", "aG93" },
-          { "hoy", "aG95" },
-          { "h's", "aCdz" },
-          { "hub", "aHVi" },
-          { "hue", "aHVl" },
-          { "hug", "aHVn" },
-          { "huh", "aHVo" },
-          { "hum", "aHVt" },
-          { "Hun", "SHVu" },
-          { "hut", "aHV0" },
-          { "Ian", "SWFu" },
-          { "IBM", "SUJN" },
-          { "Ibn", "SWJu" },
-          { "ICC", "SUND" },
-          { "ice", "aWNl" },
-          { "icy", "aWN5" },
-          { "I'd", "SSdk" },
-          { "Ida", "SWRh" },
-          { "i.e", "aS5l" },
-          { "iii", "aWlp" },
-          { "Ike", "SWtl" },
-          { "ill", "aWxs" },
-          { "I'm", "SSdt" },
-          { "imp", "aW1w" },
-          { "Inc", "SW5j" },
-          { "ink", "aW5r" },
-          { "inn", "aW5u" },
-          { "ion", "aW9u" },
-          { "Ira", "SXJh" },
-          { "ire", "aXJl" },
-          { "irk", "aXJr" },
-          { "IRS", "SVJT" },
-          { "i's", "aSdz" },
-          { "Ito", "SXRv" },
-          { "ITT", "SVRU" },
-          { "ivy", "aXZ5" },
-          { "jab", "amFi" },
-          { "jag", "amFn" },
-          { "jam", "amFt" },
-          { "Jan", "SmFu" },
-          { "jar", "amFy" },
-          { "jaw", "amF3" },
-          { "jay", "amF5" },
-          { "Jed", "SmVk" },
-          { "jet", "amV0" },
-          { "Jew", "SmV3" },
-          { "jig", "amln" },
-          { "Jim", "Smlt" },
-          { "job", "am9i" },
-          { "Joe", "Sm9l" },
-          { "jog", "am9n" },
-          { "Jon", "Sm9u" },
-          { "jot", "am90" },
-          { "joy", "am95" },
-          { "j's", "aidz" },
-          { "jug", "anVn" },
-          { "jut", "anV0" },
-          { "Kay", "S2F5" },
-          { "keg", "a2Vn" },
-          { "ken", "a2Vu" },
-          { "key", "a2V5" },
-          { "kid", "a2lk" },
-          { "Kim", "S2lt" },
-          { "kin", "a2lu" },
-          { "kit", "a2l0" },
-          { "k's", "aydz" },
-          { "lab", "bGFi" },
-          { "lac", "bGFj" },
-          { "lad", "bGFk" },
-          { "lag", "bGFn" },
-          { "lam", "bGFt" },
-          { "Lao", "TGFv" },
-          { "lap", "bGFw" },
-          { "law", "bGF3" },
-          { "lax", "bGF4" },
-          { "lay", "bGF5" },
-          { "lea", "bGVh" },
-          { "led", "bGVk" },
-          { "lee", "bGVl" },
-          { "leg", "bGVn" },
-          { "Len", "TGVu" },
-          { "Leo", "TGVv" },
-          { "let", "bGV0" },
-          { "Lev", "TGV2" },
-          { "Lew", "TGV3" },
-          { "lew", "bGV3" },
-          { "lid", "bGlk" },
-          { "lie", "bGll" },
-          { "lim", "bGlt" },
-          { "Lin", "TGlu" },
-          { "lip", "bGlw" },
-          { "lit", "bGl0" },
-          { "Liz", "TGl6" },
-          { "lob", "bG9i" },
-          { "log", "bG9n" },
-          { "lop", "bG9w" },
-          { "Los", "TG9z" },
-          { "lot", "bG90" },
-          { "Lou", "TG91" },
-          { "low", "bG93" },
-          { "loy", "bG95" },
-          { "l's", "bCdz" },
-          { "LSI", "TFNJ" },
-          { "Ltd", "THRk" },
-          { "LTV", "TFRW" },
-          { "lug", "bHVn" },
-          { "lux", "bHV4" },
-          { "lye", "bHll" },
-          { "Mac", "TWFj" },
-          { "mad", "bWFk" },
-          { "Mae", "TWFl" },
-          { "man", "bWFu" },
-          { "Mao", "TWFv" },
-          { "map", "bWFw" },
-          { "mar", "bWFy" },
-          { "mat", "bWF0" },
-          { "maw", "bWF3" },
-          { "Max", "TWF4" },
-          { "max", "bWF4" },
-          { "may", "bWF5" },
-          { "MBA", "TUJB" },
-          { "Meg", "TWVn" },
-          { "Mel", "TWVs" },
-          { "men", "bWVu" },
-          { "met", "bWV0" },
-          { "mew", "bWV3" },
-          { "mid", "bWlk" },
-          { "mig", "bWln" },
-          { "min", "bWlu" },
-          { "MIT", "TUlU" },
-          { "mix", "bWl4" },
-          { "mob", "bW9i" },
-          { "Moe", "TW9l" },
-          { "moo", "bW9v" },
-          { "mop", "bW9w" },
-          { "mot", "bW90" },
-          { "mow", "bW93" },
-          { "MPH", "TVBI" },
-          { "Mrs", "TXJz" },
-          { "m's", "bSdz" },
-          { "mud", "bXVk" },
-          { "mug", "bXVn" },
-          { "mum", "bXVt" },
-          { "nab", "bmFi" },
-          { "nag", "bmFn" },
-          { "Nan", "TmFu" },
-          { "nap", "bmFw" },
-          { "Nat", "TmF0" },
-          { "nay", "bmF5" },
-          { "NBC", "TkJD" },
-          { "NBS", "TkJT" },
-          { "NCO", "TkNP" },
-          { "NCR", "TkNS" },
-          { "Ned", "TmVk" },
-          { "nee", "bmVl" },
-          { "net", "bmV0" },
-          { "new", "bmV3" },
-          { "nib", "bmli" },
-          { "NIH", "TklI" },
-          { "nil", "bmls" },
-          { "nip", "bmlw" },
-          { "nit", "bml0" },
-          { "NNE", "Tk5F" },
-          { "NNW", "Tk5X" },
-          { "nob", "bm9i" },
-          { "nod", "bm9k" },
-          { "non", "bm9u" },
-          { "nor", "bm9y" },
-          { "not", "bm90" },
-          { "Nov", "Tm92" },
-          { "now", "bm93" },
-          { "NRC", "TlJD" },
-          { "n's", "bidz" },
-          { "NSF", "TlNG" },
-          { "nun", "bnVu" },
-          { "nut", "bnV0" },
-          { "NYC", "TllD" },
-          { "NYU", "TllV" },
-          { "oaf", "b2Fm" },
-          { "oak", "b2Fr" },
-          { "oar", "b2Fy" },
-          { "oat", "b2F0" },
-          { "Oct", "T2N0" },
-          { "odd", "b2Rk" },
-          { "ode", "b2Rl" },
-          { "off", "b2Zm" },
-          { "oft", "b2Z0" },
-          { "ohm", "b2ht" },
-          { "oil", "b2ls" },
-          { "old", "b2xk" },
-          { "one", "b25l" },
-          { "opt", "b3B0" },
-          { "orb", "b3Ji" },
-          { "ore", "b3Jl" },
-          { "Orr", "T3Jy" },
-          { "o's", "bydz" },
-          { "Ott", "T3R0" },
-          { "our", "b3Vy" },
-          { "out", "b3V0" },
-          { "ova", "b3Zh" },
-          { "owe", "b3dl" },
-          { "owl", "b3ds" },
-          { "own", "b3du" },
-          { "pad", "cGFk" },
-          { "pal", "cGFs" },
-          { "Pam", "UGFt" },
-          { "pan", "cGFu" },
-          { "pap", "cGFw" },
-          { "par", "cGFy" },
-          { "pat", "cGF0" },
-          { "paw", "cGF3" },
-          { "pax", "cGF4" },
-          { "pay", "cGF5" },
-          { "Paz", "UGF6" },
-          { "PBS", "UEJT" },
-          { "PDP", "UERQ" },
-          { "pea", "cGVh" },
-          { "pee", "cGVl" },
-          { "peg", "cGVn" },
-          { "pen", "cGVu" },
-          { "pep", "cGVw" },
-          { "per", "cGVy" },
-          { "pet", "cGV0" },
-          { "pew", "cGV3" },
-          { "PhD", "UGhE" },
-          { "phi", "cGhp" },
-          { "pie", "cGll" },
-          { "pig", "cGln" },
-          { "pin", "cGlu" },
-          { "pip", "cGlw" },
-          { "pit", "cGl0" },
-          { "ply", "cGx5" },
-          { "pod", "cG9k" },
-          { "Poe", "UG9l" },
-          { "poi", "cG9p" },
-          { "pol", "cG9s" },
-          { "pop", "cG9w" },
-          { "pot", "cG90" },
-          { "pow", "cG93" },
-          { "ppm", "cHBt" },
-          { "pro", "cHJv" },
-          { "pry", "cHJ5" },
-          { "p's", "cCdz" },
-          { "psi", "cHNp" },
-          { "PTA", "UFRB" },
-          { "pub", "cHVi" },
-          { "PUC", "UFVD" },
-          { "pug", "cHVn" },
-          { "pun", "cHVu" },
-          { "pup", "cHVw" },
-          { "pus", "cHVz" },
-          { "put", "cHV0" },
-          { "PVC", "UFZD" },
-          { "QED", "UUVE" },
-          { "q's", "cSdz" },
-          { "qua", "cXVh" },
-          { "quo", "cXVv" },
-          { "Rae", "UmFl" },
-          { "rag", "cmFn" },
-          { "raj", "cmFq" },
-          { "ram", "cmFt" },
-          { "ran", "cmFu" },
-          { "rap", "cmFw" },
-          { "rat", "cmF0" },
-          { "raw", "cmF3" },
-          { "ray", "cmF5" },
-          { "RCA", "UkNB" },
-          { "R&D", "UiZE" },
-          { "reb", "cmVi" },
-          { "red", "cmVk" },
-          { "rep", "cmVw" },
-          { "ret", "cmV0" },
-          { "rev", "cmV2" },
-          { "Rex", "UmV4" },
-          { "rho", "cmhv" },
-          { "rib", "cmli" },
-          { "rid", "cmlk" },
-          { "rig", "cmln" },
-          { "rim", "cmlt" },
-          { "Rio", "Umlv" },
-          { "rip", "cmlw" },
-          { "RNA", "Uk5B" },
-          { "rob", "cm9i" },
-          { "rod", "cm9k" },
-          { "roe", "cm9l" },
-          { "Ron", "Um9u" },
-          { "rot", "cm90" },
-          { "row", "cm93" },
-          { "Roy", "Um95" },
-          { "RPM", "UlBN" },
-          { "r's", "cidz" },
-          { "rub", "cnVi" },
-          { "rue", "cnVl" },
-          { "rug", "cnVn" },
-          { "rum", "cnVt" },
-          { "run", "cnVu" },
-          { "rut", "cnV0" },
-          { "rye", "cnll" },
-          { "sac", "c2Fj" },
-          { "sad", "c2Fk" },
-          { "sag", "c2Fn" },
-          { "Sal", "U2Fs" },
-          { "Sam", "U2Ft" },
-          { "San", "U2Fu" },
-          { "Sao", "U2Fv" },
-          { "sap", "c2Fw" },
-          { "sat", "c2F0" },
-          { "saw", "c2F3" },
-          { "sax", "c2F4" },
-          { "say", "c2F5" },
-          { "Sci", "U2Np" },
-          { "SCM", "U0NN" },
-          { "sea", "c2Vh" },
-          { "sec", "c2Vj" },
-          { "see", "c2Vl" },
-          { "sen", "c2Vu" },
-          { "seq", "c2Vx" },
-          { "set", "c2V0" },
-          { "sew", "c2V3" },
-          { "sex", "c2V4" },
-          { "she", "c2hl" },
-          { "Shu", "U2h1" },
-          { "shy", "c2h5" },
-          { "sib", "c2li" },
-          { "sic", "c2lj" },
-          { "sin", "c2lu" },
-          { "sip", "c2lw" },
-          { "sir", "c2ly" },
-          { "sis", "c2lz" },
-          { "sit", "c2l0" },
-          { "six", "c2l4" },
-          { "ski", "c2tp" },
-          { "sky", "c2t5" },
-          { "sly", "c2x5" },
-          { "sob", "c29i" },
-          { "Soc", "U29j" },
-          { "sod", "c29k" },
-          { "Sol", "U29s" },
-          { "son", "c29u" },
-          { "sop", "c29w" },
-          { "sou", "c291" },
-          { "sow", "c293" },
-          { "soy", "c295" },
-          { "spa", "c3Bh" },
-          { "spy", "c3B5" },
-          { "Sri", "U3Jp" },
-          { "s's", "cydz" },
-          { "SSE", "U1NF" },
-          { "SST", "U1NU" },
-          { "SSW", "U1NX" },
-          { "Stu", "U3R1" },
-          { "sub", "c3Vi" },
-          { "sud", "c3Vk" },
-          { "sue", "c3Vl" },
-          { "sum", "c3Vt" },
-          { "sun", "c3Vu" },
-          { "sup", "c3Vw" },
-          { "Sus", "U3Vz" },
-          { "tab", "dGFi" },
-          { "tad", "dGFk" },
-          { "tag", "dGFn" },
-          { "tam", "dGFt" },
-          { "tan", "dGFu" },
-          { "tao", "dGFv" },
-          { "tap", "dGFw" },
-          { "tar", "dGFy" },
-          { "tat", "dGF0" },
-          { "tau", "dGF1" },
-          { "tax", "dGF4" },
-          { "tea", "dGVh" },
-          { "Ted", "VGVk" },
-          { "ted", "dGVk" },
-          { "tee", "dGVl" },
-          { "Tel", "VGVs" },
-          { "ten", "dGVu" },
-          { "the", "dGhl" },
-          { "thy", "dGh5" },
-          { "tic", "dGlj" },
-          { "tid", "dGlk" },
-          { "tie", "dGll" },
-          { "til", "dGls" },
-          { "Tim", "VGlt" },
-          { "tin", "dGlu" },
-          { "tip", "dGlw" },
-          { "tit", "dGl0" },
-          { "TNT", "VE5U" },
-          { "toe", "dG9l" },
-          { "tog", "dG9n" },
-          { "Tom", "VG9t" },
-          { "ton", "dG9u" },
-          { "too", "dG9v" },
-          { "top", "dG9w" },
-          { "tor", "dG9y" },
-          { "tot", "dG90" },
-          { "tow", "dG93" },
-          { "toy", "dG95" },
-          { "TRW", "VFJX" },
-          { "try", "dHJ5" },
-          { "t's", "dCdz" },
-          { "TTL", "VFRM" },
-          { "TTY", "VFRZ" },
-          { "tub", "dHVi" },
-          { "tug", "dHVn" },
-          { "tum", "dHVt" },
-          { "tun", "dHVu" },
-          { "TVA", "VFZB" },
-          { "TWA", "VFdB" },
-          { "two", "dHdv" },
-          { "TWX", "VFdY" },
-          { "ugh", "dWdo" },
-          { "UHF", "VUhG" },
-          { "Uri", "VXJp" },
-          { "urn", "dXJu" },
-          { "U.S", "VS5T" },
-          { "u's", "dSdz" },
-          { "USA", "VVNB" },
-          { "USC", "VVND" },
-          { "use", "dXNl" },
-          { "USN", "VVNO" },
-          { "van", "dmFu" },
-          { "vat", "dmF0" },
-          { "vee", "dmVl" },
-          { "vet", "dmV0" },
-          { "vex", "dmV4" },
-          { "VHF", "VkhG" },
-          { "via", "dmlh" },
-          { "vie", "dmll" },
-          { "vii", "dmlp" },
-          { "vis", "dmlz" },
-          { "viz", "dml6" },
-          { "von", "dm9u" },
-          { "vow", "dm93" },
-          { "v's", "didz" },
-          { "WAC", "V0FD" },
-          { "wad", "d2Fk" },
-          { "wag", "d2Fn" },
-          { "wah", "d2Fo" },
-          { "wan", "d2Fu" },
-          { "war", "d2Fy" },
-          { "was", "d2Fz" },
-          { "wax", "d2F4" },
-          { "way", "d2F5" },
-          { "web", "d2Vi" },
-          { "wed", "d2Vk" },
-          { "wee", "d2Vl" },
-          { "Wei", "V2Vp" },
-          { "wet", "d2V0" },
-          { "who", "d2hv" },
-          { "why", "d2h5" },
-          { "wig", "d2ln" },
-          { "win", "d2lu" },
-          { "wit", "d2l0" },
-          { "woe", "d29l" },
-          { "wok", "d29r" },
-          { "won", "d29u" },
-          { "woo", "d29v" },
-          { "wop", "d29w" },
-          { "wow", "d293" },
-          { "wry", "d3J5" },
-          { "w's", "dydz" },
-          { "x's", "eCdz" },
-          { "yah", "eWFo" },
-          { "yak", "eWFr" },
-          { "yam", "eWFt" },
-          { "yap", "eWFw" },
-          { "yaw", "eWF3" },
-          { "yea", "eWVh" },
-          { "yen", "eWVu" },
-          { "yet", "eWV0" },
-          { "yin", "eWlu" },
-          { "yip", "eWlw" },
-          { "yon", "eW9u" },
-          { "you", "eW91" },
-          { "yow", "eW93" },
-          { "y's", "eSdz" },
-          { "yuh", "eXVo" },
-          { "zag", "emFn" },
-          { "Zan", "WmFu" },
-          { "zap", "emFw" },
-          { "Zen", "WmVu" },
-          { "zig", "emln" },
-          { "zip", "emlw" },
-          { "Zoe", "Wm9l" },
-          { "zoo", "em9v" },
-          { "z's", "eidz" },
-          /* the false rumors file */
-          { "\"So when I die, the first thing I will see in heaven is a score list?\"", 
-            "IlNvIHdoZW4gSSBkaWUsIHRoZSBmaXJzdCB0aGluZyBJIHdpbGwgc2VlIGluIGhlYXZlbiBpcyBhIHNjb3JlIGxpc3Q/Ig==" },
-          { "1st Law of Hacking: leaving is much more difficult than entering.", 
-            "MXN0IExhdyBvZiBIYWNraW5nOiBsZWF2aW5nIGlzIG11Y2ggbW9yZSBkaWZmaWN1bHQgdGhhbiBlbnRlcmluZy4=" },
-          { "2nd Law of Hacking: first in, first out.", 
-            "Mm5kIExhdyBvZiBIYWNraW5nOiBmaXJzdCBpbiwgZmlyc3Qgb3V0Lg==" },
-          { "3rd Law of Hacking: the last blow counts most.", 
-            "M3JkIExhdyBvZiBIYWNraW5nOiB0aGUgbGFzdCBibG93IGNvdW50cyBtb3N0Lg==" },
-          { "4th Law of Hacking: you will find the exit at the entrance.", 
-            "NHRoIExhdyBvZiBIYWNraW5nOiB5b3Ugd2lsbCBmaW5kIHRoZSBleGl0IGF0IHRoZSBlbnRyYW5jZS4=" },
-          { "A chameleon imitating a mail daemon often delivers scrolls of fire.", 
-            "QSBjaGFtZWxlb24gaW1pdGF0aW5nIGEgbWFpbCBkYWVtb24gb2Z0ZW4gZGVsaXZlcnMgc2Nyb2xscyBvZiBmaXJlLg==" },
-          { "A cockatrice corpse is guaranteed to be untainted!", 
-            "QSBjb2NrYXRyaWNlIGNvcnBzZSBpcyBndWFyYW50ZWVkIHRvIGJlIHVudGFpbnRlZCE=" },
-          { "A dead cockatrice is just a dead lizard.", 
-            "QSBkZWFkIGNvY2thdHJpY2UgaXMganVzdCBhIGRlYWQgbGl6YXJkLg==" },
-          { "A dragon is just a snake that ate a scroll of fire.", 
-            "QSBkcmFnb24gaXMganVzdCBhIHNuYWtlIHRoYXQgYXRlIGEgc2Nyb2xsIG9mIGZpcmUu" },
-          { "A fading corridor enlightens your insight.", 
-            "QSBmYWRpbmcgY29ycmlkb3IgZW5saWdodGVucyB5b3VyIGluc2lnaHQu" },
-          { "A glowing potion is too hot to drink.", 
-            "QSBnbG93aW5nIHBvdGlvbiBpcyB0b28gaG90IHRvIGRyaW5rLg==" },
-          { "A good amulet may protect you against guards.", 
-            "QSBnb29kIGFtdWxldCBtYXkgcHJvdGVjdCB5b3UgYWdhaW5zdCBndWFyZHMu" },
-          { "A lizard corpse is a good thing to turn undead.", 
-            "QSBsaXphcmQgY29ycHNlIGlzIGEgZ29vZCB0aGluZyB0byB0dXJuIHVuZGVhZC4=" },
-          { "A long worm can be defined recursively. So how should you attack it?", 
-            "QSBsb25nIHdvcm0gY2FuIGJlIGRlZmluZWQgcmVjdXJzaXZlbHkuIFNvIGhvdyBzaG91bGQgeW91IGF0dGFjayBpdD8=" },
-          { "A monstrous mind is a toy forever.", 
-            "QSBtb25zdHJvdXMgbWluZCBpcyBhIHRveSBmb3JldmVyLg==" },
-          { "A nymph will be very pleased if you call her by her real name: Lorelei.", 
-            "QSBueW1waCB3aWxsIGJlIHZlcnkgcGxlYXNlZCBpZiB5b3UgY2FsbCBoZXIgYnkgaGVyIHJlYWwgbmFtZTogTG9yZWxlaS4=" },
-          { "A ring of dungeon master control is a great find.", 
-            "QSByaW5nIG9mIGR1bmdlb24gbWFzdGVyIGNvbnRyb2wgaXMgYSBncmVhdCBmaW5kLg==" },
-          { "A ring of extra ring finger is useless if not enchanted.", 
-            "QSByaW5nIG9mIGV4dHJhIHJpbmcgZmluZ2VyIGlzIHVzZWxlc3MgaWYgbm90IGVuY2hhbnRlZC4=" },
-          { "A rope may form a trail in a maze.", 
-            "QSByb3BlIG1heSBmb3JtIGEgdHJhaWwgaW4gYSBtYXplLg==" },
-          { "A staff may recharge if you drop it for awhile.", 
-            "QSBzdGFmZiBtYXkgcmVjaGFyZ2UgaWYgeW91IGRyb3AgaXQgZm9yIGF3aGlsZS4=" },
-          { "A visit to the Zoo is very educational; you meet interesting animals.", 
-            "QSB2aXNpdCB0byB0aGUgWm9vIGlzIHZlcnkgZWR1Y2F0aW9uYWw7IHlvdSBtZWV0IGludGVyZXN0aW5nIGFuaW1hbHMu" },
-          { "A wand of deaf is a more dangerous weapon than a wand of sheep.", 
-            "QSB3YW5kIG9mIGRlYWYgaXMgYSBtb3JlIGRhbmdlcm91cyB3ZWFwb24gdGhhbiBhIHdhbmQgb2Ygc2hlZXAu" },
-          { "A wand of vibration might bring the whole cave crashing about your ears.", 
-            "QSB3YW5kIG9mIHZpYnJhdGlvbiBtaWdodCBicmluZyB0aGUgd2hvbGUgY2F2ZSBjcmFzaGluZyBhYm91dCB5b3VyIGVhcnMu" },
-          { "A winner never quits. A quitter never wins.", 
-            "QSB3aW5uZXIgbmV2ZXIgcXVpdHMuIEEgcXVpdHRlciBuZXZlciB3aW5zLg==" },
-          { "A wish? Okay, make me a fortune cookie!", 
-            "QSB3aXNoPyBPa2F5LCBtYWtlIG1lIGEgZm9ydHVuZSBjb29raWUh" },
-          { "Afraid of mimics? Try to wear a ring of true seeing.", 
-            "QWZyYWlkIG9mIG1pbWljcz8gVHJ5IHRvIHdlYXIgYSByaW5nIG9mIHRydWUgc2VlaW5nLg==" },
-          { "All monsters are created evil, but some are more evil than others.", 
-            "QWxsIG1vbnN0ZXJzIGFyZSBjcmVhdGVkIGV2aWwsIGJ1dCBzb21lIGFyZSBtb3JlIGV2aWwgdGhhbiBvdGhlcnMu" },
-          { "Always attack a floating eye from behind!", 
-            "QWx3YXlzIGF0dGFjayBhIGZsb2F0aW5nIGV5ZSBmcm9tIGJlaGluZCE=" },
-          { "An elven cloak is always the height of fashion.", 
-            "QW4gZWx2ZW4gY2xvYWsgaXMgYWx3YXlzIHRoZSBoZWlnaHQgb2YgZmFzaGlvbi4=" },
-          { "Any small object that is accidentally dropped will hide under a larger object.", 
-            "QW55IHNtYWxsIG9iamVjdCB0aGF0IGlzIGFjY2lkZW50YWxseSBkcm9wcGVkIHdpbGwgaGlkZSB1bmRlciBhIGxhcmdlciBvYmplY3Qu" },
-          { "Balrogs do not appear above level 20.", 
-            "QmFscm9ncyBkbyBub3QgYXBwZWFyIGFib3ZlIGxldmVsIDIwLg==" },
-          { "Banana peels work especially well against Keystone Kops.", 
-            "QmFuYW5hIHBlZWxzIHdvcmsgZXNwZWNpYWxseSB3ZWxsIGFnYWluc3QgS2V5c3RvbmUgS29wcy4=" },
-          { "Be careful when eating bananas. Monsters might slip on the peels.", 
-            "QmUgY2FyZWZ1bCB3aGVuIGVhdGluZyBiYW5hbmFzLiBNb25zdGVycyBtaWdodCBzbGlwIG9uIHRoZSBwZWVscy4=" },
-          { "Better leave the dungeon; otherwise you might get hurt badly.", 
-            "QmV0dGVyIGxlYXZlIHRoZSBkdW5nZW9uOyBvdGhlcndpc2UgeW91IG1pZ2h0IGdldCBodXJ0IGJhZGx5Lg==" },
-          { "Beware of the potion of nitroglycerin -- it's not for the weak of heart.", 
-            "QmV3YXJlIG9mIHRoZSBwb3Rpb24gb2Ygbml0cm9nbHljZXJpbiAtLSBpdCdzIG5vdCBmb3IgdGhlIHdlYWsgb2YgaGVhcnQu" },
-          { "Beware: there's always a chance that your wand explodes as you try to zap it!", 
-            "QmV3YXJlOiB0aGVyZSdzIGFsd2F5cyBhIGNoYW5jZSB0aGF0IHlvdXIgd2FuZCBleHBsb2RlcyBhcyB5b3UgdHJ5IHRvIHphcCBpdCE=" },
-          { "Beyond the 23rd level lies a happy retirement in a room of your own.", 
-            "QmV5b25kIHRoZSAyM3JkIGxldmVsIGxpZXMgYSBoYXBweSByZXRpcmVtZW50IGluIGEgcm9vbSBvZiB5b3VyIG93bi4=" },
-          { "Changing your suit without dropping your sword? You must be kidding!", 
-            "Q2hhbmdpbmcgeW91ciBzdWl0IHdpdGhvdXQgZHJvcHBpbmcgeW91ciBzd29yZD8gWW91IG11c3QgYmUga2lkZGluZyE=" },
-          { "Cockatrices might turn themselves to stone faced with a mirror.", 
-            "Q29ja2F0cmljZXMgbWlnaHQgdHVybiB0aGVtc2VsdmVzIHRvIHN0b25lIGZhY2VkIHdpdGggYSBtaXJyb3Iu" },
-          { "Consumption of home-made food is strictly forbidden in this dungeon.", 
-            "Q29uc3VtcHRpb24gb2YgaG9tZS1tYWRlIGZvb2QgaXMgc3RyaWN0bHkgZm9yYmlkZGVuIGluIHRoaXMgZHVuZ2Vvbi4=" },
-          { "Dark room? Your chance to develop your photographs!", 
-            "RGFyayByb29tPyBZb3VyIGNoYW5jZSB0byBkZXZlbG9wIHlvdXIgcGhvdG9ncmFwaHMh" },
-          { "Dark rooms are not *completely* dark: just wait and let your eyes adjust...", 
-            "RGFyayByb29tcyBhcmUgbm90ICpjb21wbGV0ZWx5KiBkYXJrOiBqdXN0IHdhaXQgYW5kIGxldCB5b3VyIGV5ZXMgYWRqdXN0Li4u" },
-          { "David London sez, \"Hey guys, *WIELD* a lizard corpse against a cockatrice!\"", 
-            "RGF2aWQgTG9uZG9uIHNleiwgIkhleSBndXlzLCAqV0lFTEQqIGEgbGl6YXJkIGNvcnBzZSBhZ2FpbnN0IGEgY29ja2F0cmljZSEi" },
-          { "Death is just life's way of telling you you've been fired.", 
-            "RGVhdGggaXMganVzdCBsaWZlJ3Mgd2F5IG9mIHRlbGxpbmcgeW91IHlvdSd2ZSBiZWVuIGZpcmVkLg==" },
-          { "Demi-gods don't need any help from the gods.", 
-            "RGVtaS1nb2RzIGRvbid0IG5lZWQgYW55IGhlbHAgZnJvbSB0aGUgZ29kcy4=" },
-          { "Demons *HATE* Priests and Priestesses.", 
-            "RGVtb25zICpIQVRFKiBQcmllc3RzIGFuZCBQcmllc3Rlc3Nlcy4=" },
-          { "Didn't you forget to pay?", 
-            "RGlkbid0IHlvdSBmb3JnZXQgdG8gcGF5Pw==" },
-          { "Didn't your mother tell you not to eat food off the floor?", 
-            "RGlkbid0IHlvdXIgbW90aGVyIHRlbGwgeW91IG5vdCB0byBlYXQgZm9vZCBvZmYgdGhlIGZsb29yPw==" },
-          { "Direct a direct hit on your direct opponent, directing in the right direction.", 
-            "RGlyZWN0IGEgZGlyZWN0IGhpdCBvbiB5b3VyIGRpcmVjdCBvcHBvbmVudCwgZGlyZWN0aW5nIGluIHRoZSByaWdodCBkaXJlY3Rpb24u" },
-          { "Do you want to make more money? Sure, we all do! Join the Fort Ludios guard!", 
-            "RG8geW91IHdhbnQgdG8gbWFrZSBtb3JlIG1vbmV5PyBTdXJlLCB3ZSBhbGwgZG8hIEpvaW4gdGhlIEZvcnQgTHVkaW9zIGd1YXJkIQ==" },
-          { "Don't eat too much: you might start hiccoughing!", 
-            "RG9uJ3QgZWF0IHRvbyBtdWNoOiB5b3UgbWlnaHQgc3RhcnQgaGljY291Z2hpbmch" },
-          { "Don't play hack at your work; your boss might hit you!", 
-            "RG9uJ3QgcGxheSBoYWNrIGF0IHlvdXIgd29yazsgeW91ciBib3NzIG1pZ2h0IGhpdCB5b3Uh" },
-          { "Don't tell a soul you found a secret door, otherwise it isn't a secret anymore.", 
-            "RG9uJ3QgdGVsbCBhIHNvdWwgeW91IGZvdW5kIGEgc2VjcmV0IGRvb3IsIG90aGVyd2lzZSBpdCBpc24ndCBhIHNlY3JldCBhbnltb3JlLg==" },
-          { "Drinking potions of booze may land you in jail if you are under 21.", 
-            "RHJpbmtpbmcgcG90aW9ucyBvZiBib296ZSBtYXkgbGFuZCB5b3UgaW4gamFpbCBpZiB5b3UgYXJlIHVuZGVyIDIxLg==" },
-          { "Drop your vanity and get rid of your jewels! Pickpockets about!", 
-            "RHJvcCB5b3VyIHZhbml0eSBhbmQgZ2V0IHJpZCBvZiB5b3VyIGpld2VscyEgUGlja3BvY2tldHMgYWJvdXQh" },
-          { "Eat 10 cloves of garlic and keep all humans at a two-square distance.", 
-            "RWF0IDEwIGNsb3ZlcyBvZiBnYXJsaWMgYW5kIGtlZXAgYWxsIGh1bWFucyBhdCBhIHR3by1zcXVhcmUgZGlzdGFuY2Uu" },
-          { "Eels hide under mud. Use a unicorn to clear the water and make them visible.", 
-            "RWVscyBoaWRlIHVuZGVyIG11ZC4gVXNlIGEgdW5pY29ybiB0byBjbGVhciB0aGUgd2F0ZXIgYW5kIG1ha2UgdGhlbSB2aXNpYmxlLg==" },
-          { "Engrave your wishes with a wand of wishing.", 
-            "RW5ncmF2ZSB5b3VyIHdpc2hlcyB3aXRoIGEgd2FuZCBvZiB3aXNoaW5nLg==" },
-          { "Eventually you will come to admire the swift elegance of a retreating nymph.", 
-            "RXZlbnR1YWxseSB5b3Ugd2lsbCBjb21lIHRvIGFkbWlyZSB0aGUgc3dpZnQgZWxlZ2FuY2Ugb2YgYSByZXRyZWF0aW5nIG55bXBoLg==" },
-          { "Ever heard hissing outside? I *knew* you hadn't!", 
-            "RXZlciBoZWFyZCBoaXNzaW5nIG91dHNpZGU/IEkgKmtuZXcqIHlvdSBoYWRuJ3Qh" },
-          { "Ever lifted a dragon corpse?", 
-            "RXZlciBsaWZ0ZWQgYSBkcmFnb24gY29ycHNlPw==" },
-          { "Ever seen a leocrotta dancing the tengu?", 
-            "RXZlciBzZWVuIGEgbGVvY3JvdHRhIGRhbmNpbmcgdGhlIHRlbmd1Pw==" },
-          { "Ever seen your weapon glow plaid?", 
-            "RXZlciBzZWVuIHlvdXIgd2VhcG9uIGdsb3cgcGxhaWQ/" },
-          { "Ever tamed a shopkeeper?", 
-            "RXZlciB0YW1lZCBhIHNob3BrZWVwZXI/" },
-          { "Ever tried digging through a Vault Guard?", 
-            "RXZlciB0cmllZCBkaWdnaW5nIHRocm91Z2ggYSBWYXVsdCBHdWFyZD8=" },
-          { "Ever tried enchanting a rope?", 
-            "RXZlciB0cmllZCBlbmNoYW50aW5nIGEgcm9wZT8=" },
-          { "Floating eyes can't stand Hawaiian shirts.", 
-            "RmxvYXRpbmcgZXllcyBjYW4ndCBzdGFuZCBIYXdhaWlhbiBzaGlydHMu" },
-          { "For any remedy there is a misery.", 
-            "Rm9yIGFueSByZW1lZHkgdGhlcmUgaXMgYSBtaXNlcnku" },
-          { "Giant bats turn into giant vampires.", 
-            "R2lhbnQgYmF0cyB0dXJuIGludG8gZ2lhbnQgdmFtcGlyZXMu" },
-          { "Good day for overcoming obstacles. Try a steeplechase.", 
-            "R29vZCBkYXkgZm9yIG92ZXJjb21pbmcgb2JzdGFjbGVzLiBUcnkgYSBzdGVlcGxlY2hhc2Uu" },
-          { "Half Moon tonight. (At least it's better than no Moon at all.)", 
-            "SGFsZiBNb29uIHRvbmlnaHQuIChBdCBsZWFzdCBpdCdzIGJldHRlciB0aGFuIG5vIE1vb24gYXQgYWxsLik=" },
-          { "Help! I'm being held prisoner in a fortune cookie factory!", 
-            "SGVscCEgSSdtIGJlaW5nIGhlbGQgcHJpc29uZXIgaW4gYSBmb3J0dW5lIGNvb2tpZSBmYWN0b3J5IQ==" },
-          { "Housecats have nine lives, kittens only one.", 
-            "SG91c2VjYXRzIGhhdmUgbmluZSBsaXZlcywga2l0dGVucyBvbmx5IG9uZS4=" },
-          { "How long can you tread water?", 
-            "SG93IGxvbmcgY2FuIHlvdSB0cmVhZCB3YXRlcj8=" },
-          { "Hungry? There is an abundance of food on the next level.", 
-            "SHVuZ3J5PyBUaGVyZSBpcyBhbiBhYnVuZGFuY2Ugb2YgZm9vZCBvbiB0aGUgbmV4dCBsZXZlbC4=" },
-          { "I guess you've never hit a mail daemon with the Amulet of Yendor...", 
-            "SSBndWVzcyB5b3UndmUgbmV2ZXIgaGl0IGEgbWFpbCBkYWVtb24gd2l0aCB0aGUgQW11bGV0IG9mIFllbmRvci4uLg==" },
-          { "If you are the shopkeeper, you can take things for free.", 
-            "SWYgeW91IGFyZSB0aGUgc2hvcGtlZXBlciwgeW91IGNhbiB0YWtlIHRoaW5ncyBmb3IgZnJlZS4=" },
-          { "If you can't learn to do it well, learn to enjoy doing it badly.", 
-            "SWYgeW91IGNhbid0IGxlYXJuIHRvIGRvIGl0IHdlbGwsIGxlYXJuIHRvIGVuam95IGRvaW5nIGl0IGJhZGx5Lg==" },
-          { "If you thought the Wizard was bad, just wait till you meet the Warlord!", 
-            "SWYgeW91IHRob3VnaHQgdGhlIFdpemFyZCB3YXMgYmFkLCBqdXN0IHdhaXQgdGlsbCB5b3UgbWVldCB0aGUgV2FybG9yZCE=" },
-          { "If you turn blind, don't expect your dog to be turned into a seeing-eye dog.", 
-            "SWYgeW91IHR1cm4gYmxpbmQsIGRvbid0IGV4cGVjdCB5b3VyIGRvZyB0byBiZSB0dXJuZWQgaW50byBhIHNlZWluZy1leWUgZG9nLg==" },
-          { "If you want to feel great, you must eat something real big.", 
-            "SWYgeW91IHdhbnQgdG8gZmVlbCBncmVhdCwgeW91IG11c3QgZWF0IHNvbWV0aGluZyByZWFsIGJpZy4=" },
-          { "If you want to float, you'd better eat a floating eye.", 
-            "SWYgeW91IHdhbnQgdG8gZmxvYXQsIHlvdSdkIGJldHRlciBlYXQgYSBmbG9hdGluZyBleWUu" },
-          { "If your ghost kills a player, it increases your score.", 
-            "SWYgeW91ciBnaG9zdCBraWxscyBhIHBsYXllciwgaXQgaW5jcmVhc2VzIHlvdXIgc2NvcmUu" },
-          { "Increase mindpower: Tame your own ghost!", 
-            "SW5jcmVhc2UgbWluZHBvd2VyOiBUYW1lIHlvdXIgb3duIGdob3N0IQ==" },
-          { "It furthers one to see the great man.", 
-            "SXQgZnVydGhlcnMgb25lIHRvIHNlZSB0aGUgZ3JlYXQgbWFuLg==" },
-          { "It's easy to overlook a monster in a wood.", 
-            "SXQncyBlYXN5IHRvIG92ZXJsb29rIGEgbW9uc3RlciBpbiBhIHdvb2Qu" },
-          { "Just below any trapdoor there may be another one. Just keep falling!", 
-            "SnVzdCBiZWxvdyBhbnkgdHJhcGRvb3IgdGhlcmUgbWF5IGJlIGFub3RoZXIgb25lLiBKdXN0IGtlZXAgZmFsbGluZyE=" },
-          { "Katanas are very sharp; watch you don't cut yourself.", 
-            "S2F0YW5hcyBhcmUgdmVyeSBzaGFycDsgd2F0Y2ggeW91IGRvbid0IGN1dCB5b3Vyc2VsZi4=" },
-          { "Keep a clear mind: quaff clear potions.", 
-            "S2VlcCBhIGNsZWFyIG1pbmQ6IHF1YWZmIGNsZWFyIHBvdGlvbnMu" },
-          { "Kicking the terminal doesn't hurt the monsters.", 
-            "S2lja2luZyB0aGUgdGVybWluYWwgZG9lc24ndCBodXJ0IHRoZSBtb25zdGVycy4=" },
-          { "Killer bees keep appearing till you kill their queen.", 
-            "S2lsbGVyIGJlZXMga2VlcCBhcHBlYXJpbmcgdGlsbCB5b3Uga2lsbCB0aGVpciBxdWVlbi4=" },
-          { "Killer bunnies can be tamed with carrots only.", 
-            "S2lsbGVyIGJ1bm5pZXMgY2FuIGJlIHRhbWVkIHdpdGggY2Fycm90cyBvbmx5Lg==" },
-          { "Latest news? Put `rec.games.roguelike.nethack' in your .newsrc!", 
-            "TGF0ZXN0IG5ld3M/IFB1dCBgcmVjLmdhbWVzLnJvZ3VlbGlrZS5uZXRoYWNrJyBpbiB5b3VyIC5uZXdzcmMh" },
-          { "Learn how to spell. Play NetHack!", 
-            "TGVhcm4gaG93IHRvIHNwZWxsLiBQbGF5IE5ldEhhY2sh" },
-          { "Leprechauns hide their gold in a secret room.", 
-            "TGVwcmVjaGF1bnMgaGlkZSB0aGVpciBnb2xkIGluIGEgc2VjcmV0IHJvb20u" },
-          { "Let your fingers do the walking on the yulkjhnb keys.", 
-            "TGV0IHlvdXIgZmluZ2VycyBkbyB0aGUgd2Fsa2luZyBvbiB0aGUgeXVsa2pobmIga2V5cy4=" },
-          { "Let's face it: this time you're not going to win.", 
-            "TGV0J3MgZmFjZSBpdDogdGhpcyB0aW1lIHlvdSdyZSBub3QgZ29pbmcgdG8gd2luLg==" },
-          { "Let's have a party, drink a lot of booze.", 
-            "TGV0J3MgaGF2ZSBhIHBhcnR5LCBkcmluayBhIGxvdCBvZiBib296ZS4=" },
-          { "Liquor sellers do not drink; they hate to see you twice.", 
-            "TGlxdW9yIHNlbGxlcnMgZG8gbm90IGRyaW5rOyB0aGV5IGhhdGUgdG8gc2VlIHlvdSB0d2ljZS4=" },
-          { "Lunar eclipse tonight. May as well quit now!", 
-            "THVuYXIgZWNsaXBzZSB0b25pZ2h0LiBNYXkgYXMgd2VsbCBxdWl0IG5vdyE=" },
-          { "Meeting your own ghost decreases your luck considerably!", 
-            "TWVldGluZyB5b3VyIG93biBnaG9zdCBkZWNyZWFzZXMgeW91ciBsdWNrIGNvbnNpZGVyYWJseSE=" },
-          { "Money to invest? Take it to the local branch of the Magic Memory Vault!", 
-            "TW9uZXkgdG8gaW52ZXN0PyBUYWtlIGl0IHRvIHRoZSBsb2NhbCBicmFuY2ggb2YgdGhlIE1hZ2ljIE1lbW9yeSBWYXVsdCE=" },
-          { "Monsters come from nowhere to hit you everywhere.", 
-            "TW9uc3RlcnMgY29tZSBmcm9tIG5vd2hlcmUgdG8gaGl0IHlvdSBldmVyeXdoZXJlLg==" },
-          { "Monsters sleep because you are boring, not because they ever get tired.", 
-            "TW9uc3RlcnMgc2xlZXAgYmVjYXVzZSB5b3UgYXJlIGJvcmluZywgbm90IGJlY2F1c2UgdGhleSBldmVyIGdldCB0aXJlZC4=" },
-          { "Most monsters prefer minced meat. That's why they are hitting you!", 
-            "TW9zdCBtb25zdGVycyBwcmVmZXIgbWluY2VkIG1lYXQuIFRoYXQncyB3aHkgdGhleSBhcmUgaGl0dGluZyB5b3Uh" },
-          { "Most of the bugs in NetHack are on the floor.", 
-            "TW9zdCBvZiB0aGUgYnVncyBpbiBOZXRIYWNrIGFyZSBvbiB0aGUgZmxvb3Iu" },
-          { "Much ado Nothing Happens.", 
-            "TXVjaCBhZG8gTm90aGluZyBIYXBwZW5zLg==" },
-          { "Multi-player NetHack is a myth.", 
-            "TXVsdGktcGxheWVyIE5ldEhhY2sgaXMgYSBteXRoLg==" },
-          { "NetHack is addictive. Too late, you're already hooked.", 
-            "TmV0SGFjayBpcyBhZGRpY3RpdmUuIFRvbyBsYXRlLCB5b3UncmUgYWxyZWFkeSBob29rZWQu" },
-          { "Never ask a shopkeeper for a price list.", 
-            "TmV2ZXIgYXNrIGEgc2hvcGtlZXBlciBmb3IgYSBwcmljZSBsaXN0Lg==" },
-          { "Never burn a tree, unless you like getting whacked with a +5 shovel.", 
-            "TmV2ZXIgYnVybiBhIHRyZWUsIHVubGVzcyB5b3UgbGlrZSBnZXR0aW5nIHdoYWNrZWQgd2l0aCBhICs1IHNob3ZlbC4=" },
-          { "Never eat with glowing hands!", 
-            "TmV2ZXIgZWF0IHdpdGggZ2xvd2luZyBoYW5kcyE=" },
-          { "Never mind the monsters hitting you: they just replace the charwomen.", 
-            "TmV2ZXIgbWluZCB0aGUgbW9uc3RlcnMgaGl0dGluZyB5b3U6IHRoZXkganVzdCByZXBsYWNlIHRoZSBjaGFyd29tZW4u" },
-          { "Never play leapfrog with a unicorn.", 
-            "TmV2ZXIgcGxheSBsZWFwZnJvZyB3aXRoIGEgdW5pY29ybi4=" },
-          { "Never step on a cursed engraving.", 
-            "TmV2ZXIgc3RlcCBvbiBhIGN1cnNlZCBlbmdyYXZpbmcu" },
-          { "Never swim with a camera: there's nothing to take pictures of.", 
-            "TmV2ZXIgc3dpbSB3aXRoIGEgY2FtZXJhOiB0aGVyZSdzIG5vdGhpbmcgdG8gdGFrZSBwaWN0dXJlcyBvZi4=" },
-          { "Never teach your pet rust monster to fetch.", 
-            "TmV2ZXIgdGVhY2ggeW91ciBwZXQgcnVzdCBtb25zdGVyIHRvIGZldGNoLg==" },
-          { "Never trust a random generator in magic fields.", 
-            "TmV2ZXIgdHJ1c3QgYSByYW5kb20gZ2VuZXJhdG9yIGluIG1hZ2ljIGZpZWxkcy4=" },
-          { "Never use a wand of death.", 
-            "TmV2ZXIgdXNlIGEgd2FuZCBvZiBkZWF0aC4=" },
-          { "No level contains two shops. The maze is no level. So...", 
-            "Tm8gbGV2ZWwgY29udGFpbnMgdHdvIHNob3BzLiBUaGUgbWF6ZSBpcyBubyBsZXZlbC4gU28uLi4=" },
-          { "No part of this fortune may be reproduced, stored in a retrieval system, ...", 
-            "Tm8gcGFydCBvZiB0aGlzIGZvcnR1bmUgbWF5IGJlIHJlcHJvZHVjZWQsIHN0b3JlZCBpbiBhIHJldHJpZXZhbCBzeXN0ZW0sIC4uLg==" },
-          { "Not all rumors are as misleading as this one.", 
-            "Tm90IGFsbCBydW1vcnMgYXJlIGFzIG1pc2xlYWRpbmcgYXMgdGhpcyBvbmUu" },
-          { "Nymphs and nurses like beautiful rings.", 
-            "TnltcGhzIGFuZCBudXJzZXMgbGlrZSBiZWF1dGlmdWwgcmluZ3Mu" },
-          { "Nymphs are blondes. Are you a gentleman?", 
-            "TnltcGhzIGFyZSBibG9uZGVzLiBBcmUgeW91IGEgZ2VudGxlbWFuPw==" },
-          { "Offering a unicorn a worthless piece of glass might prove to be fatal!", 
-            "T2ZmZXJpbmcgYSB1bmljb3JuIGEgd29ydGhsZXNzIHBpZWNlIG9mIGdsYXNzIG1pZ2h0IHByb3ZlIHRvIGJlIGZhdGFsIQ==" },
-          { "Old hackers never die: young ones do.", 
-            "T2xkIGhhY2tlcnMgbmV2ZXIgZGllOiB5b3VuZyBvbmVzIGRvLg==" },
-          { "One has to leave shops before closing time.", 
-            "T25lIGhhcyB0byBsZWF2ZSBzaG9wcyBiZWZvcmUgY2xvc2luZyB0aW1lLg==" },
-          { "One homunculus a day keeps the doctor away.", 
-            "T25lIGhvbXVuY3VsdXMgYSBkYXkga2VlcHMgdGhlIGRvY3RvciBhd2F5Lg==" },
-          { "One level further down somebody is getting killed, right now.", 
-            "T25lIGxldmVsIGZ1cnRoZXIgZG93biBzb21lYm9keSBpcyBnZXR0aW5nIGtpbGxlZCwgcmlnaHQgbm93Lg==" },
-          { "Only a wizard can use a magic whistle.", 
-            "T25seSBhIHdpemFyZCBjYW4gdXNlIGEgbWFnaWMgd2hpc3RsZS4=" },
-          { "Only adventurers of evil alignment think of killing their dog.", 
-            "T25seSBhZHZlbnR1cmVycyBvZiBldmlsIGFsaWdubWVudCB0aGluayBvZiBraWxsaW5nIHRoZWlyIGRvZy4=" },
-          { "Only chaotic evils kill sleeping monsters.", 
-            "T25seSBjaGFvdGljIGV2aWxzIGtpbGwgc2xlZXBpbmcgbW9uc3RlcnMu" },
-          { "Only real trappers escape traps.", 
-            "T25seSByZWFsIHRyYXBwZXJzIGVzY2FwZSB0cmFwcy4=" },
-          { "Only real wizards can write scrolls.", 
-            "T25seSByZWFsIHdpemFyZHMgY2FuIHdyaXRlIHNjcm9sbHMu" },
-          { "Operation OVERKILL has started now.", 
-            "T3BlcmF0aW9uIE9WRVJLSUxMIGhhcyBzdGFydGVkIG5vdy4=" },
-          { "PLEASE ignore previous rumor.", 
-            "UExFQVNFIGlnbm9yZSBwcmV2aW91cyBydW1vci4=" },
-          { "Polymorph into an ettin; meet your opponents face to face to face.", 
-            "UG9seW1vcnBoIGludG8gYW4gZXR0aW47IG1lZXQgeW91ciBvcHBvbmVudHMgZmFjZSB0byBmYWNlIHRvIGZhY2Uu" },
-          { "Praying will frighten demons.", 
-            "UHJheWluZyB3aWxsIGZyaWdodGVuIGRlbW9ucy4=" },
-          { "Row (3x) that boat gently down the stream, Charon (4x), death is but a dream.", 
-            "Um93ICgzeCkgdGhhdCBib2F0IGdlbnRseSBkb3duIHRoZSBzdHJlYW0sIENoYXJvbiAoNHgpLCBkZWF0aCBpcyBidXQgYSBkcmVhbS4=" },
-          { "Running is good for your legs.", 
-            "UnVubmluZyBpcyBnb29kIGZvciB5b3VyIGxlZ3Mu" },
-          { "Screw up your courage! You've screwed up everything else.", 
-            "U2NyZXcgdXAgeW91ciBjb3VyYWdlISBZb3UndmUgc2NyZXdlZCB1cCBldmVyeXRoaW5nIGVsc2Uu" },
-          { "Seepage? Leaky pipes? Rising damp? Summon the plumber!", 
-            "U2VlcGFnZT8gTGVha3kgcGlwZXM/IFJpc2luZyBkYW1wPyBTdW1tb24gdGhlIHBsdW1iZXIh" },
-          { "Segmentation fault (core dumped).", 
-            "U2VnbWVudGF0aW9uIGZhdWx0IChjb3JlIGR1bXBlZCku" },
-          { "Shopkeepers sometimes die from old age.", 
-            "U2hvcGtlZXBlcnMgc29tZXRpbWVzIGRpZSBmcm9tIG9sZCBhZ2Uu" },
-          { "Some mazes (especially small ones) have no solutions, says man 6 maze.", 
-            "U29tZSBtYXplcyAoZXNwZWNpYWxseSBzbWFsbCBvbmVzKSBoYXZlIG5vIHNvbHV0aW9ucywgc2F5cyBtYW4gNiBtYXplLg==" },
-          { "Some questions the Sphynx asks just *don't* have any answers.", 
-            "U29tZSBxdWVzdGlvbnMgdGhlIFNwaHlueCBhc2tzIGp1c3QgKmRvbid0KiBoYXZlIGFueSBhbnN3ZXJzLg==" },
-          { "Sometimes \"mu\" is the answer.", 
-            "U29tZXRpbWVzICJtdSIgaXMgdGhlIGFuc3dlci4=" },
-          { "Sorry, no fortune this time. Better luck next cookie!", 
-            "U29ycnksIG5vIGZvcnR1bmUgdGhpcyB0aW1lLiBCZXR0ZXIgbHVjayBuZXh0IGNvb2tpZSE=" },
-          { "Spare your scrolls of make-edible until it's really necessary!", 
-            "U3BhcmUgeW91ciBzY3JvbGxzIG9mIG1ha2UtZWRpYmxlIHVudGlsIGl0J3MgcmVhbGx5IG5lY2Vzc2FyeSE=" },
-          { "Suddenly, the dungeon will collapse...", 
-            "U3VkZGVubHksIHRoZSBkdW5nZW9uIHdpbGwgY29sbGFwc2UuLi4=" },
-          { "Taming a mail daemon may cause a system security violation.", 
-            "VGFtaW5nIGEgbWFpbCBkYWVtb24gbWF5IGNhdXNlIGEgc3lzdGVtIHNlY3VyaXR5IHZpb2xhdGlvbi4=" },
-          { "The crowd was so tough, the Stooges won't play the Dungeon anymore, nyuk nyuk.", 
-            "VGhlIGNyb3dkIHdhcyBzbyB0b3VnaCwgdGhlIFN0b29nZXMgd29uJ3QgcGxheSB0aGUgRHVuZ2VvbiBhbnltb3JlLCBueXVrIG55dWsu" },
-          { "The leprechauns hide their treasure in a small hidden room.", 
-            "VGhlIGxlcHJlY2hhdW5zIGhpZGUgdGhlaXIgdHJlYXN1cmUgaW4gYSBzbWFsbCBoaWRkZW4gcm9vbS4=" },
-          { "The longer the wand the better.", 
-            "VGhlIGxvbmdlciB0aGUgd2FuZCB0aGUgYmV0dGVyLg==" },
-          { "The magic word is \"XYZZY\".", 
-            "VGhlIG1hZ2ljIHdvcmQgaXMgIlhZWlpZIi4=" },
-          { "The meek shall inherit your bones files.", 
-            "VGhlIG1lZWsgc2hhbGwgaW5oZXJpdCB5b3VyIGJvbmVzIGZpbGVzLg==" },
-          { "The mines are dark and deep, and I have levels to go before I sleep.", 
-            "VGhlIG1pbmVzIGFyZSBkYXJrIGFuZCBkZWVwLCBhbmQgSSBoYXZlIGxldmVscyB0byBnbyBiZWZvcmUgSSBzbGVlcC4=" },
-          { "The use of dynamite is dangerous.", 
-            "VGhlIHVzZSBvZiBkeW5hbWl0ZSBpcyBkYW5nZXJvdXMu" },
-          { "There are no worms in the UNIX version.", 
-            "VGhlcmUgYXJlIG5vIHdvcm1zIGluIHRoZSBVTklYIHZlcnNpb24u" },
-          { "There is a trap on this level!", 
-            "VGhlcmUgaXMgYSB0cmFwIG9uIHRoaXMgbGV2ZWwh" },
-          { "They say that Demogorgon, Asmodeus, Orcus, Yeenoghu & Juiblex is no law firm.", 
-            "VGhleSBzYXkgdGhhdCBEZW1vZ29yZ29uLCBBc21vZGV1cywgT3JjdXMsIFllZW5vZ2h1ICYgSnVpYmxleCBpcyBubyBsYXcgZmlybS4=" },
-          { "They say that Geryon has an evil twin, beware!", 
-            "VGhleSBzYXkgdGhhdCBHZXJ5b24gaGFzIGFuIGV2aWwgdHdpbiwgYmV3YXJlIQ==" },
-          { "They say that Medusa would make a terrible pet.", 
-            "VGhleSBzYXkgdGhhdCBNZWR1c2Egd291bGQgbWFrZSBhIHRlcnJpYmxlIHBldC4=" },
-          { "They say that NetHack bugs are Seldon planned.", 
-            "VGhleSBzYXkgdGhhdCBOZXRIYWNrIGJ1Z3MgYXJlIFNlbGRvbiBwbGFubmVkLg==" },
-          { "They say that NetHack comes in 256 flavors.", 
-            "VGhleSBzYXkgdGhhdCBOZXRIYWNrIGNvbWVzIGluIDI1NiBmbGF2b3JzLg==" },
-          { "They say that NetHack is just a computer game.", 
-            "VGhleSBzYXkgdGhhdCBOZXRIYWNrIGlzIGp1c3QgYSBjb21wdXRlciBnYW1lLg==" },
-          { "They say that NetHack is more than just a computer game.", 
-            "VGhleSBzYXkgdGhhdCBOZXRIYWNrIGlzIG1vcmUgdGhhbiBqdXN0IGEgY29tcHV0ZXIgZ2FtZS4=" },
-          { "They say that NetHack is never what it used to be.", 
-            "VGhleSBzYXkgdGhhdCBOZXRIYWNrIGlzIG5ldmVyIHdoYXQgaXQgdXNlZCB0byBiZS4=" },
-          { "They say that a baby dragon is too small to hurt or help you.", 
-            "VGhleSBzYXkgdGhhdCBhIGJhYnkgZHJhZ29uIGlzIHRvbyBzbWFsbCB0byBodXJ0IG9yIGhlbHAgeW91Lg==" },
-          { "They say that a black pudding is simply a brown pudding gone bad.", 
-            "VGhleSBzYXkgdGhhdCBhIGJsYWNrIHB1ZGRpbmcgaXMgc2ltcGx5IGEgYnJvd24gcHVkZGluZyBnb25lIGJhZC4=" },
-          { "They say that a black sheep has 3 bags full of wool.", 
-            "VGhleSBzYXkgdGhhdCBhIGJsYWNrIHNoZWVwIGhhcyAzIGJhZ3MgZnVsbCBvZiB3b29sLg==" },
-          { "They say that a blank scroll is like a blank check.", 
-            "VGhleSBzYXkgdGhhdCBhIGJsYW5rIHNjcm9sbCBpcyBsaWtlIGEgYmxhbmsgY2hlY2su" },
-          { "They say that a cat named Morris has nine lives.", 
-            "VGhleSBzYXkgdGhhdCBhIGNhdCBuYW1lZCBNb3JyaXMgaGFzIG5pbmUgbGl2ZXMu" },
-          { "They say that a desperate shopper might pay any price in a shop.", 
-            "VGhleSBzYXkgdGhhdCBhIGRlc3BlcmF0ZSBzaG9wcGVyIG1pZ2h0IHBheSBhbnkgcHJpY2UgaW4gYSBzaG9wLg==" },
-          { "They say that a diamond dog is everybody's best friend.", 
-            "VGhleSBzYXkgdGhhdCBhIGRpYW1vbmQgZG9nIGlzIGV2ZXJ5Ym9keSdzIGJlc3QgZnJpZW5kLg==" },
-          { "They say that a dwarf lord can carry a pick-axe because his armor is light.", 
-            "VGhleSBzYXkgdGhhdCBhIGR3YXJmIGxvcmQgY2FuIGNhcnJ5IGEgcGljay1heGUgYmVjYXVzZSBoaXMgYXJtb3IgaXMgbGlnaHQu" },
-          { "They say that a floating eye can defeat Medusa.", 
-            "VGhleSBzYXkgdGhhdCBhIGZsb2F0aW5nIGV5ZSBjYW4gZGVmZWF0IE1lZHVzYS4=" },
-          { "They say that a fortune only has 1 line and you can't read between it.", 
-            "VGhleSBzYXkgdGhhdCBhIGZvcnR1bmUgb25seSBoYXMgMSBsaW5lIGFuZCB5b3UgY2FuJ3QgcmVhZCBiZXR3ZWVuIGl0Lg==" },
-          { "They say that a fortune only has 1 line, but you can read between it.", 
-            "VGhleSBzYXkgdGhhdCBhIGZvcnR1bmUgb25seSBoYXMgMSBsaW5lLCBidXQgeW91IGNhbiByZWFkIGJldHdlZW4gaXQu" },
-          { "They say that a fountain looks nothing like a regularly erupting geyser.", 
-            "VGhleSBzYXkgdGhhdCBhIGZvdW50YWluIGxvb2tzIG5vdGhpbmcgbGlrZSBhIHJlZ3VsYXJseSBlcnVwdGluZyBnZXlzZXIu" },
-          { "They say that a gold doubloon is worth more than its weight in gold.", 
-            "VGhleSBzYXkgdGhhdCBhIGdvbGQgZG91Ymxvb24gaXMgd29ydGggbW9yZSB0aGFuIGl0cyB3ZWlnaHQgaW4gZ29sZC4=" },
-          { "They say that a grid bug won't pay a shopkeeper for zapping you in a shop.", 
-            "VGhleSBzYXkgdGhhdCBhIGdyaWQgYnVnIHdvbid0IHBheSBhIHNob3BrZWVwZXIgZm9yIHphcHBpbmcgeW91IGluIGEgc2hvcC4=" },
-          { "They say that a gypsy could tell your fortune for a price.", 
-            "VGhleSBzYXkgdGhhdCBhIGd5cHN5IGNvdWxkIHRlbGwgeW91ciBmb3J0dW5lIGZvciBhIHByaWNlLg==" },
-          { "They say that a hacker named Alice once level teleported by using a mirror.", 
-            "VGhleSBzYXkgdGhhdCBhIGhhY2tlciBuYW1lZCBBbGljZSBvbmNlIGxldmVsIHRlbGVwb3J0ZWQgYnkgdXNpbmcgYSBtaXJyb3Iu" },
-          { "They say that a hacker named David once slew a giant with a sling and a rock.", 
-            "VGhleSBzYXkgdGhhdCBhIGhhY2tlciBuYW1lZCBEYXZpZCBvbmNlIHNsZXcgYSBnaWFudCB3aXRoIGEgc2xpbmcgYW5kIGEgcm9jay4=" },
-          { "They say that a hacker named Dorothy once rode a fog cloud to Oz.", 
-            "VGhleSBzYXkgdGhhdCBhIGhhY2tlciBuYW1lZCBEb3JvdGh5IG9uY2Ugcm9kZSBhIGZvZyBjbG91ZCB0byBPei4=" },
-          { "They say that a hacker named Mary once lost a white sheep in the mazes.", 
-            "VGhleSBzYXkgdGhhdCBhIGhhY2tlciBuYW1lZCBNYXJ5IG9uY2UgbG9zdCBhIHdoaXRlIHNoZWVwIGluIHRoZSBtYXplcy4=" },
-          { "They say that a helm of brilliance is not to be taken lightly.", 
-            "VGhleSBzYXkgdGhhdCBhIGhlbG0gb2YgYnJpbGxpYW5jZSBpcyBub3QgdG8gYmUgdGFrZW4gbGlnaHRseS4=" },
-          { "They say that a hot dog and a hell hound are the same thing.", 
-            "VGhleSBzYXkgdGhhdCBhIGhvdCBkb2cgYW5kIGEgaGVsbCBob3VuZCBhcmUgdGhlIHNhbWUgdGhpbmcu" },
-          { "They say that a lamp named Aladdin's Lamp contains a djinni with 3 wishes.", 
-            "VGhleSBzYXkgdGhhdCBhIGxhbXAgbmFtZWQgQWxhZGRpbidzIExhbXAgY29udGFpbnMgYSBkamlubmkgd2l0aCAzIHdpc2hlcy4=" },
-          { "They say that a large dog named Lassie will lead you to the amulet.", 
-            "VGhleSBzYXkgdGhhdCBhIGxhcmdlIGRvZyBuYW1lZCBMYXNzaWUgd2lsbCBsZWFkIHlvdSB0byB0aGUgYW11bGV0Lg==" },
-          { "They say that a long sword is not a light sword.", 
-            "VGhleSBzYXkgdGhhdCBhIGxvbmcgc3dvcmQgaXMgbm90IGEgbGlnaHQgc3dvcmQu" },
-          { "They say that a manes won't mince words with you.", 
-            "VGhleSBzYXkgdGhhdCBhIG1hbmVzIHdvbid0IG1pbmNlIHdvcmRzIHdpdGggeW91Lg==" },
-          { "They say that a mind is a terrible thing to waste.", 
-            "VGhleSBzYXkgdGhhdCBhIG1pbmQgaXMgYSB0ZXJyaWJsZSB0aGluZyB0byB3YXN0ZS4=" },
-          { "They say that a plain nymph will only wear a wire ring in one ear.", 
-            "VGhleSBzYXkgdGhhdCBhIHBsYWluIG55bXBoIHdpbGwgb25seSB3ZWFyIGEgd2lyZSByaW5nIGluIG9uZSBlYXIu" },
-          { "They say that a plumed hat could be a previously used crested helmet.", 
-            "VGhleSBzYXkgdGhhdCBhIHBsdW1lZCBoYXQgY291bGQgYmUgYSBwcmV2aW91c2x5IHVzZWQgY3Jlc3RlZCBoZWxtZXQu" },
-          { "They say that a potion of oil is difficult to grasp.", 
-            "VGhleSBzYXkgdGhhdCBhIHBvdGlvbiBvZiBvaWwgaXMgZGlmZmljdWx0IHRvIGdyYXNwLg==" },
-          { "They say that a potion of yogurt is a cancelled potion of sickness.", 
-            "VGhleSBzYXkgdGhhdCBhIHBvdGlvbiBvZiB5b2d1cnQgaXMgYSBjYW5jZWxsZWQgcG90aW9uIG9mIHNpY2tuZXNzLg==" },
-          { "They say that a purple worm is not a baby purple dragon.", 
-            "VGhleSBzYXkgdGhhdCBhIHB1cnBsZSB3b3JtIGlzIG5vdCBhIGJhYnkgcHVycGxlIGRyYWdvbi4=" },
-          { "They say that a quivering blob tastes different than a gelatinous cube.", 
-            "VGhleSBzYXkgdGhhdCBhIHF1aXZlcmluZyBibG9iIHRhc3RlcyBkaWZmZXJlbnQgdGhhbiBhIGdlbGF0aW5vdXMgY3ViZS4=" },
-          { "They say that a runed broadsword named Stormbringer attracts vortices.", 
-            "VGhleSBzYXkgdGhhdCBhIHJ1bmVkIGJyb2Fkc3dvcmQgbmFtZWQgU3Rvcm1icmluZ2VyIGF0dHJhY3RzIHZvcnRpY2VzLg==" },
-          { "They say that a scroll of summoning has other names.", 
-            "VGhleSBzYXkgdGhhdCBhIHNjcm9sbCBvZiBzdW1tb25pbmcgaGFzIG90aGVyIG5hbWVzLg==" },
-          { "They say that a shaman can bestow blessings but usually doesn't.", 
-            "VGhleSBzYXkgdGhhdCBhIHNoYW1hbiBjYW4gYmVzdG93IGJsZXNzaW5ncyBidXQgdXN1YWxseSBkb2Vzbid0Lg==" },
-          { "They say that a shaman will bless you for an eye of newt and wing of bat.", 
-            "VGhleSBzYXkgdGhhdCBhIHNoYW1hbiB3aWxsIGJsZXNzIHlvdSBmb3IgYW4gZXllIG9mIG5ld3QgYW5kIHdpbmcgb2YgYmF0Lg==" },
-          { "They say that a shimmering gold shield is not a polished silver shield.", 
-            "VGhleSBzYXkgdGhhdCBhIHNoaW1tZXJpbmcgZ29sZCBzaGllbGQgaXMgbm90IGEgcG9saXNoZWQgc2lsdmVyIHNoaWVsZC4=" },
-          { "They say that a spear will hit a neo-otyugh. (Do YOU know what that is?)", 
-            "VGhleSBzYXkgdGhhdCBhIHNwZWFyIHdpbGwgaGl0IGEgbmVvLW90eXVnaC4gKERvIFlPVSBrbm93IHdoYXQgdGhhdCBpcz8p" },
-          { "They say that a spotted dragon is the ultimate shape changer.", 
-            "VGhleSBzYXkgdGhhdCBhIHNwb3R0ZWQgZHJhZ29uIGlzIHRoZSB1bHRpbWF0ZSBzaGFwZSBjaGFuZ2VyLg==" },
-          { "They say that a stethoscope is no good if you can only hear your heartbeat.", 
-            "VGhleSBzYXkgdGhhdCBhIHN0ZXRob3Njb3BlIGlzIG5vIGdvb2QgaWYgeW91IGNhbiBvbmx5IGhlYXIgeW91ciBoZWFydGJlYXQu" },
-          { "They say that a succubus named Suzy will sometimes warn you of danger.", 
-            "VGhleSBzYXkgdGhhdCBhIHN1Y2N1YnVzIG5hbWVkIFN1enkgd2lsbCBzb21ldGltZXMgd2FybiB5b3Ugb2YgZGFuZ2VyLg==" },
-          { "They say that a wand of cancellation is not like a wand of polymorph.", 
-            "VGhleSBzYXkgdGhhdCBhIHdhbmQgb2YgY2FuY2VsbGF0aW9uIGlzIG5vdCBsaWtlIGEgd2FuZCBvZiBwb2x5bW9ycGgu" },
-          { "They say that a wood golem named Pinocchio would be easy to control.", 
-            "VGhleSBzYXkgdGhhdCBhIHdvb2QgZ29sZW0gbmFtZWQgUGlub2NjaGlvIHdvdWxkIGJlIGVhc3kgdG8gY29udHJvbC4=" },
-          { "They say that after killing a dragon it's time for a change of scenery.", 
-            "VGhleSBzYXkgdGhhdCBhZnRlciBraWxsaW5nIGEgZHJhZ29uIGl0J3MgdGltZSBmb3IgYSBjaGFuZ2Ugb2Ygc2NlbmVyeS4=" },
-          { "They say that an amulet of strangulation is worse than ring around the collar.", 
-            "VGhleSBzYXkgdGhhdCBhbiBhbXVsZXQgb2Ygc3RyYW5ndWxhdGlvbiBpcyB3b3JzZSB0aGFuIHJpbmcgYXJvdW5kIHRoZSBjb2xsYXIu" },
-          { "They say that an attic is the best place to hide your toys.", 
-            "VGhleSBzYXkgdGhhdCBhbiBhdHRpYyBpcyB0aGUgYmVzdCBwbGFjZSB0byBoaWRlIHlvdXIgdG95cy4=" },
-          { "They say that an axe named Cleaver once belonged to a hacker named Beaver.", 
-            "VGhleSBzYXkgdGhhdCBhbiBheGUgbmFtZWQgQ2xlYXZlciBvbmNlIGJlbG9uZ2VkIHRvIGEgaGFja2VyIG5hbWVkIEJlYXZlci4=" },
-          { "They say that an eye of newt and a wing of bat are double the trouble.", 
-            "VGhleSBzYXkgdGhhdCBhbiBleWUgb2YgbmV3dCBhbmQgYSB3aW5nIG9mIGJhdCBhcmUgZG91YmxlIHRoZSB0cm91YmxlLg==" },
-          { "They say that an incubus named Izzy sometimes makes women feel sensitive.", 
-            "VGhleSBzYXkgdGhhdCBhbiBpbmN1YnVzIG5hbWVkIEl6enkgc29tZXRpbWVzIG1ha2VzIHdvbWVuIGZlZWwgc2Vuc2l0aXZlLg==" },
-          { "They say that an opulent throne room is rarely a place to wish you'd be in.", 
-            "VGhleSBzYXkgdGhhdCBhbiBvcHVsZW50IHRocm9uZSByb29tIGlzIHJhcmVseSBhIHBsYWNlIHRvIHdpc2ggeW91J2QgYmUgaW4u" },
-          { "They say that an unlucky hacker once had a nose bleed at an altar and died.", 
-            "VGhleSBzYXkgdGhhdCBhbiB1bmx1Y2t5IGhhY2tlciBvbmNlIGhhZCBhIG5vc2UgYmxlZWQgYXQgYW4gYWx0YXIgYW5kIGRpZWQu" },
-          { "They say that and they say this but they never say never, never!", 
-            "VGhleSBzYXkgdGhhdCBhbmQgdGhleSBzYXkgdGhpcyBidXQgdGhleSBuZXZlciBzYXkgbmV2ZXIsIG5ldmVyIQ==" },
-          { "They say that any quantum mechanic knows that speed kills.", 
-            "VGhleSBzYXkgdGhhdCBhbnkgcXVhbnR1bSBtZWNoYW5pYyBrbm93cyB0aGF0IHNwZWVkIGtpbGxzLg==" },
-          { "They say that applying a unicorn horn means you've missed the point.", 
-            "VGhleSBzYXkgdGhhdCBhcHBseWluZyBhIHVuaWNvcm4gaG9ybiBtZWFucyB5b3UndmUgbWlzc2VkIHRoZSBwb2ludC4=" },
-          { "They say that blue stones are radioactive, beware.", 
-            "VGhleSBzYXkgdGhhdCBibHVlIHN0b25lcyBhcmUgcmFkaW9hY3RpdmUsIGJld2FyZS4=" },
-          { "They say that building a dungeon is a team effort.", 
-            "VGhleSBzYXkgdGhhdCBidWlsZGluZyBhIGR1bmdlb24gaXMgYSB0ZWFtIGVmZm9ydC4=" },
-          { "They say that chaotic characters never get a kick out of altars.", 
-            "VGhleSBzYXkgdGhhdCBjaGFvdGljIGNoYXJhY3RlcnMgbmV2ZXIgZ2V0IGEga2ljayBvdXQgb2YgYWx0YXJzLg==" },
-          { "They say that collapsing a dungeon often creates a panic.", 
-            "VGhleSBzYXkgdGhhdCBjb2xsYXBzaW5nIGEgZHVuZ2VvbiBvZnRlbiBjcmVhdGVzIGEgcGFuaWMu" },
-          { "They say that counting your eggs before they hatch shows that you care.", 
-            "VGhleSBzYXkgdGhhdCBjb3VudGluZyB5b3VyIGVnZ3MgYmVmb3JlIHRoZXkgaGF0Y2ggc2hvd3MgdGhhdCB5b3UgY2FyZS4=" },
-          { "They say that dipping a bag of tricks in a fountain won't make it an icebox.", 
-            "VGhleSBzYXkgdGhhdCBkaXBwaW5nIGEgYmFnIG9mIHRyaWNrcyBpbiBhIGZvdW50YWluIHdvbid0IG1ha2UgaXQgYW4gaWNlYm94Lg==" },
-          { "They say that dipping an eel and brown mold in hot water makes bouillabaisse.", 
-            "VGhleSBzYXkgdGhhdCBkaXBwaW5nIGFuIGVlbCBhbmQgYnJvd24gbW9sZCBpbiBob3Qgd2F0ZXIgbWFrZXMgYm91aWxsYWJhaXNzZS4=" },
-          { "They say that donating a doubloon is extremely pious charity.", 
-            "VGhleSBzYXkgdGhhdCBkb25hdGluZyBhIGRvdWJsb29uIGlzIGV4dHJlbWVseSBwaW91cyBjaGFyaXR5Lg==" },
-          { "They say that eating royal jelly attracts grizzly owlbears.", 
-            "VGhleSBzYXkgdGhhdCBlYXRpbmcgcm95YWwgamVsbHkgYXR0cmFjdHMgZ3JpenpseSBvd2xiZWFycy4=" },
-          { "They say that eggs, pancakes and juice are just a mundane breakfast.", 
-            "VGhleSBzYXkgdGhhdCBlZ2dzLCBwYW5jYWtlcyBhbmQganVpY2UgYXJlIGp1c3QgYSBtdW5kYW5lIGJyZWFrZmFzdC4=" },
-          { "They say that everyone knows why Medusa stands alone in the dark.", 
-            "VGhleSBzYXkgdGhhdCBldmVyeW9uZSBrbm93cyB3aHkgTWVkdXNhIHN0YW5kcyBhbG9uZSBpbiB0aGUgZGFyay4=" },
-          { "They say that everyone wanted rec.games.hack to undergo a name change.", 
-            "VGhleSBzYXkgdGhhdCBldmVyeW9uZSB3YW50ZWQgcmVjLmdhbWVzLmhhY2sgdG8gdW5kZXJnbyBhIG5hbWUgY2hhbmdlLg==" },
-          { "They say that finding a winning strategy is a deliberate move on your part.", 
-            "VGhleSBzYXkgdGhhdCBmaW5kaW5nIGEgd2lubmluZyBzdHJhdGVneSBpcyBhIGRlbGliZXJhdGUgbW92ZSBvbiB5b3VyIHBhcnQu" },
-          { "They say that finding worthless glass is worth something.", 
-            "VGhleSBzYXkgdGhhdCBmaW5kaW5nIHdvcnRobGVzcyBnbGFzcyBpcyB3b3J0aCBzb21ldGhpbmcu" },
-          { "They say that fortune cookies are food for thought.", 
-            "VGhleSBzYXkgdGhhdCBmb3J0dW5lIGNvb2tpZXMgYXJlIGZvb2QgZm9yIHRob3VnaHQu" },
-          { "They say that gold is only wasted on a pet dragon.", 
-            "VGhleSBzYXkgdGhhdCBnb2xkIGlzIG9ubHkgd2FzdGVkIG9uIGEgcGV0IGRyYWdvbi4=" },
-          { "They say that good things come to those that wait.", 
-            "VGhleSBzYXkgdGhhdCBnb29kIHRoaW5ncyBjb21lIHRvIHRob3NlIHRoYXQgd2FpdC4=" },
-          { "They say that greased objects will slip out of monsters' hands.", 
-            "VGhleSBzYXkgdGhhdCBncmVhc2VkIG9iamVjdHMgd2lsbCBzbGlwIG91dCBvZiBtb25zdGVycycgaGFuZHMu" },
-          { "They say that if you can't spell then you'll wish you had a spell book.", 
-            "VGhleSBzYXkgdGhhdCBpZiB5b3UgY2FuJ3Qgc3BlbGwgdGhlbiB5b3UnbGwgd2lzaCB5b3UgaGFkIGEgc3BlbGwgYm9vay4=" },
-          { "They say that if you live by the sword, you'll die by the sword.", 
-            "VGhleSBzYXkgdGhhdCBpZiB5b3UgbGl2ZSBieSB0aGUgc3dvcmQsIHlvdSdsbCBkaWUgYnkgdGhlIHN3b3JkLg==" },
-          { "They say that if you play like a monster you'll have a better game.", 
-            "VGhleSBzYXkgdGhhdCBpZiB5b3UgcGxheSBsaWtlIGEgbW9uc3RlciB5b3UnbGwgaGF2ZSBhIGJldHRlciBnYW1lLg==" },
-          { "They say that if you sleep with a demon you might awake with a headache.", 
-            "VGhleSBzYXkgdGhhdCBpZiB5b3Ugc2xlZXAgd2l0aCBhIGRlbW9uIHlvdSBtaWdodCBhd2FrZSB3aXRoIGEgaGVhZGFjaGUu" },
-          { "They say that if you step on a crack you could break your mother's back.", 
-            "VGhleSBzYXkgdGhhdCBpZiB5b3Ugc3RlcCBvbiBhIGNyYWNrIHlvdSBjb3VsZCBicmVhayB5b3VyIG1vdGhlcidzIGJhY2su" },
-          { "They say that if you're invisible you can still be heard!", 
-            "VGhleSBzYXkgdGhhdCBpZiB5b3UncmUgaW52aXNpYmxlIHlvdSBjYW4gc3RpbGwgYmUgaGVhcmQh" },
-          { "They say that if you're lucky you can feel the runes on a scroll.", 
-            "VGhleSBzYXkgdGhhdCBpZiB5b3UncmUgbHVja3kgeW91IGNhbiBmZWVsIHRoZSBydW5lcyBvbiBhIHNjcm9sbC4=" },
-          { "They say that in the big picture gold is only small change.", 
-            "VGhleSBzYXkgdGhhdCBpbiB0aGUgYmlnIHBpY3R1cmUgZ29sZCBpcyBvbmx5IHNtYWxsIGNoYW5nZS4=" },
-          { "They say that in the dungeon it's not what you know that really matters.", 
-            "VGhleSBzYXkgdGhhdCBpbiB0aGUgZHVuZ2VvbiBpdCdzIG5vdCB3aGF0IHlvdSBrbm93IHRoYXQgcmVhbGx5IG1hdHRlcnMu" },
-          { "They say that in the dungeon moon rocks are really dilithium crystals.", 
-            "VGhleSBzYXkgdGhhdCBpbiB0aGUgZHVuZ2VvbiBtb29uIHJvY2tzIGFyZSByZWFsbHkgZGlsaXRoaXVtIGNyeXN0YWxzLg==" },
-          { "They say that in the dungeon the boorish customer is never right.", 
-            "VGhleSBzYXkgdGhhdCBpbiB0aGUgZHVuZ2VvbiB0aGUgYm9vcmlzaCBjdXN0b21lciBpcyBuZXZlciByaWdodC4=" },
-          { "They say that in the dungeon you don't need a watch to tell time.", 
-            "VGhleSBzYXkgdGhhdCBpbiB0aGUgZHVuZ2VvbiB5b3UgZG9uJ3QgbmVlZCBhIHdhdGNoIHRvIHRlbGwgdGltZS4=" },
-          { "They say that in the dungeon you need something old, new, burrowed and blue.", 
-            "VGhleSBzYXkgdGhhdCBpbiB0aGUgZHVuZ2VvbiB5b3UgbmVlZCBzb21ldGhpbmcgb2xkLCBuZXcsIGJ1cnJvd2VkIGFuZCBibHVlLg==" },
-          { "They say that in the dungeon you should always count your blessings.", 
-            "VGhleSBzYXkgdGhhdCBpbiB0aGUgZHVuZ2VvbiB5b3Ugc2hvdWxkIGFsd2F5cyBjb3VudCB5b3VyIGJsZXNzaW5ncy4=" },
-          { "They say that iron golem plate mail isn't worth wishing for.", 
-            "VGhleSBzYXkgdGhhdCBpcm9uIGdvbGVtIHBsYXRlIG1haWwgaXNuJ3Qgd29ydGggd2lzaGluZyBmb3Iu" },
-          { "They say that it takes four quarterstaffs to make one staff.", 
-            "VGhleSBzYXkgdGhhdCBpdCB0YWtlcyBmb3VyIHF1YXJ0ZXJzdGFmZnMgdG8gbWFrZSBvbmUgc3RhZmYu" },
-          { "They say that it's not over till the fat ladies sing.", 
-            "VGhleSBzYXkgdGhhdCBpdCdzIG5vdCBvdmVyIHRpbGwgdGhlIGZhdCBsYWRpZXMgc2luZy4=" },
-          { "They say that it's not over till the fat lady shouts `Off with its head'.", 
-            "VGhleSBzYXkgdGhhdCBpdCdzIG5vdCBvdmVyIHRpbGwgdGhlIGZhdCBsYWR5IHNob3V0cyBgT2ZmIHdpdGggaXRzIGhlYWQnLg==" },
-          { "They say that kicking a heavy statue is really a dumb move.", 
-            "VGhleSBzYXkgdGhhdCBraWNraW5nIGEgaGVhdnkgc3RhdHVlIGlzIHJlYWxseSBhIGR1bWIgbW92ZS4=" },
-          { "They say that kicking a valuable gem doesn't seem to make sense.", 
-            "VGhleSBzYXkgdGhhdCBraWNraW5nIGEgdmFsdWFibGUgZ2VtIGRvZXNuJ3Qgc2VlbSB0byBtYWtlIHNlbnNlLg==" },
-          { "They say that leprechauns know Latin and you should too.", 
-            "VGhleSBzYXkgdGhhdCBsZXByZWNoYXVucyBrbm93IExhdGluIGFuZCB5b3Ugc2hvdWxkIHRvby4=" },
-          { "They say that minotaurs get lost outside of the mazes.", 
-            "VGhleSBzYXkgdGhhdCBtaW5vdGF1cnMgZ2V0IGxvc3Qgb3V0c2lkZSBvZiB0aGUgbWF6ZXMu" },
-          { "They say that most trolls are born again.", 
-            "VGhleSBzYXkgdGhhdCBtb3N0IHRyb2xscyBhcmUgYm9ybiBhZ2Fpbi4=" },
-          { "They say that naming your cat Garfield will make you more attractive.", 
-            "VGhleSBzYXkgdGhhdCBuYW1pbmcgeW91ciBjYXQgR2FyZmllbGQgd2lsbCBtYWtlIHlvdSBtb3JlIGF0dHJhY3RpdmUu" },
-          { "They say that no one knows everything about everything in the dungeon.", 
-            "VGhleSBzYXkgdGhhdCBubyBvbmUga25vd3MgZXZlcnl0aGluZyBhYm91dCBldmVyeXRoaW5nIGluIHRoZSBkdW5nZW9uLg==" },
-          { "They say that no one plays NetHack just for the fun of it.", 
-            "VGhleSBzYXkgdGhhdCBubyBvbmUgcGxheXMgTmV0SGFjayBqdXN0IGZvciB0aGUgZnVuIG9mIGl0Lg==" },
-          { "They say that no one really subscribes to rec.games.roguelike.nethack.", 
-            "VGhleSBzYXkgdGhhdCBubyBvbmUgcmVhbGx5IHN1YnNjcmliZXMgdG8gcmVjLmdhbWVzLnJvZ3VlbGlrZS5uZXRoYWNrLg==" },
-          { "They say that no one will admit to starting a rumor.", 
-            "VGhleSBzYXkgdGhhdCBubyBvbmUgd2lsbCBhZG1pdCB0byBzdGFydGluZyBhIHJ1bW9yLg==" },
-          { "They say that nurses sometimes carry scalpels and never use them.", 
-            "VGhleSBzYXkgdGhhdCBudXJzZXMgc29tZXRpbWVzIGNhcnJ5IHNjYWxwZWxzIGFuZCBuZXZlciB1c2UgdGhlbS4=" },
-          { "They say that once you've met one wizard you've met them all.", 
-            "VGhleSBzYXkgdGhhdCBvbmNlIHlvdSd2ZSBtZXQgb25lIHdpemFyZCB5b3UndmUgbWV0IHRoZW0gYWxsLg==" },
-          { "They say that one troll is worth 10,000 newts.", 
-            "VGhleSBzYXkgdGhhdCBvbmUgdHJvbGwgaXMgd29ydGggMTAsMDAwIG5ld3RzLg==" },
-          { "They say that only David can find the zoo!", 
-            "VGhleSBzYXkgdGhhdCBvbmx5IERhdmlkIGNhbiBmaW5kIHRoZSB6b28h" },
-          { "They say that only angels play their harps for their pets.", 
-            "VGhleSBzYXkgdGhhdCBvbmx5IGFuZ2VscyBwbGF5IHRoZWlyIGhhcnBzIGZvciB0aGVpciBwZXRzLg==" },
-          { "They say that only big spenders carry gold.", 
-            "VGhleSBzYXkgdGhhdCBvbmx5IGJpZyBzcGVuZGVycyBjYXJyeSBnb2xkLg==" },
-          { "They say that orc shamans are healthy, wealthy and wise.", 
-            "VGhleSBzYXkgdGhhdCBvcmMgc2hhbWFucyBhcmUgaGVhbHRoeSwgd2VhbHRoeSBhbmQgd2lzZS4=" },
-          { "They say that playing NetHack is like walking into a death trap.", 
-            "VGhleSBzYXkgdGhhdCBwbGF5aW5nIE5ldEhhY2sgaXMgbGlrZSB3YWxraW5nIGludG8gYSBkZWF0aCB0cmFwLg==" },
-          { "They say that problem breathing is best treated by a proper diet.", 
-            "VGhleSBzYXkgdGhhdCBwcm9ibGVtIGJyZWF0aGluZyBpcyBiZXN0IHRyZWF0ZWQgYnkgYSBwcm9wZXIgZGlldC4=" },
-          { "They say that quaffing many potions of levitation can give you a headache.", 
-            "VGhleSBzYXkgdGhhdCBxdWFmZmluZyBtYW55IHBvdGlvbnMgb2YgbGV2aXRhdGlvbiBjYW4gZ2l2ZSB5b3UgYSBoZWFkYWNoZS4=" },
-          { "They say that queen bees get that way by eating royal jelly.", 
-            "VGhleSBzYXkgdGhhdCBxdWVlbiBiZWVzIGdldCB0aGF0IHdheSBieSBlYXRpbmcgcm95YWwgamVsbHku" },
-          { "They say that reading a scare monster scroll is the same as saying Elbereth.", 
-            "VGhleSBzYXkgdGhhdCByZWFkaW5nIGEgc2NhcmUgbW9uc3RlciBzY3JvbGwgaXMgdGhlIHNhbWUgYXMgc2F5aW5nIEVsYmVyZXRoLg==" },
-          { "They say that real hackers always are controlled.", 
-            "VGhleSBzYXkgdGhhdCByZWFsIGhhY2tlcnMgYWx3YXlzIGFyZSBjb250cm9sbGVkLg==" },
-          { "They say that real hackers never sleep.", 
-            "VGhleSBzYXkgdGhhdCByZWFsIGhhY2tlcnMgbmV2ZXIgc2xlZXAu" },
-          { "They say that shopkeepers are insured by Croesus himself!", 
-            "VGhleSBzYXkgdGhhdCBzaG9wa2VlcGVycyBhcmUgaW5zdXJlZCBieSBDcm9lc3VzIGhpbXNlbGYh" },
-          { "They say that shopkeepers never carry more than 20 gold pieces, at night.", 
-            "VGhleSBzYXkgdGhhdCBzaG9wa2VlcGVycyBuZXZlciBjYXJyeSBtb3JlIHRoYW4gMjAgZ29sZCBwaWVjZXMsIGF0IG5pZ2h0Lg==" },
-          { "They say that shopkeepers never sell blessed potions of invisibility.", 
-            "VGhleSBzYXkgdGhhdCBzaG9wa2VlcGVycyBuZXZlciBzZWxsIGJsZXNzZWQgcG90aW9ucyBvZiBpbnZpc2liaWxpdHku" },
-          { "They say that soldiers wear kid gloves and silly helmets.", 
-            "VGhleSBzYXkgdGhhdCBzb2xkaWVycyB3ZWFyIGtpZCBnbG92ZXMgYW5kIHNpbGx5IGhlbG1ldHMu" },
-          { "They say that some Kops are on the take.", 
-            "VGhleSBzYXkgdGhhdCBzb21lIEtvcHMgYXJlIG9uIHRoZSB0YWtlLg==" },
-          { "They say that some guards' palms can be greased.", 
-            "VGhleSBzYXkgdGhhdCBzb21lIGd1YXJkcycgcGFsbXMgY2FuIGJlIGdyZWFzZWQu" },
-          { "They say that some monsters may kiss your boots to stop your drum playing.", 
-            "VGhleSBzYXkgdGhhdCBzb21lIG1vbnN0ZXJzIG1heSBraXNzIHlvdXIgYm9vdHMgdG8gc3RvcCB5b3VyIGRydW0gcGxheWluZy4=" },
-          { "They say that sometimes you can be the hit of the party when playing a horn.", 
-            "VGhleSBzYXkgdGhhdCBzb21ldGltZXMgeW91IGNhbiBiZSB0aGUgaGl0IG9mIHRoZSBwYXJ0eSB3aGVuIHBsYXlpbmcgYSBob3JuLg==" },
-          { "They say that the NetHack gods generally welcome your sacrifices.", 
-            "VGhleSBzYXkgdGhhdCB0aGUgTmV0SGFjayBnb2RzIGdlbmVyYWxseSB3ZWxjb21lIHlvdXIgc2FjcmlmaWNlcy4=" },
-          { "They say that the Three Rings are named Vilya, Nenya and Narya.", 
-            "VGhleSBzYXkgdGhhdCB0aGUgVGhyZWUgUmluZ3MgYXJlIG5hbWVkIFZpbHlhLCBOZW55YSBhbmQgTmFyeWEu" },
-          { "They say that the Wizard of Yendor has a death wish.", 
-            "VGhleSBzYXkgdGhhdCB0aGUgV2l6YXJkIG9mIFllbmRvciBoYXMgYSBkZWF0aCB3aXNoLg==" },
-          { "They say that the `hair of the dog' is sometimes an effective remedy.", 
-            "VGhleSBzYXkgdGhhdCB0aGUgYGhhaXIgb2YgdGhlIGRvZycgaXMgc29tZXRpbWVzIGFuIGVmZmVjdGl2ZSByZW1lZHku" },
-          { "They say that the best time to save your game is now before its too late.", 
-            "VGhleSBzYXkgdGhhdCB0aGUgYmVzdCB0aW1lIHRvIHNhdmUgeW91ciBnYW1lIGlzIG5vdyBiZWZvcmUgaXRzIHRvbyBsYXRlLg==" },
-          { "They say that the biggest obstacle in NetHack is your mind.", 
-            "VGhleSBzYXkgdGhhdCB0aGUgYmlnZ2VzdCBvYnN0YWNsZSBpbiBOZXRIYWNrIGlzIHlvdXIgbWluZC4=" },
-          { "They say that the gods are angry when they hit you with objects.", 
-            "VGhleSBzYXkgdGhhdCB0aGUgZ29kcyBhcmUgYW5ncnkgd2hlbiB0aGV5IGhpdCB5b3Ugd2l0aCBvYmplY3RzLg==" },
-          { "They say that the priesthood are specially favored by the gods.", 
-            "VGhleSBzYXkgdGhhdCB0aGUgcHJpZXN0aG9vZCBhcmUgc3BlY2lhbGx5IGZhdm9yZWQgYnkgdGhlIGdvZHMu" },
-          { "They say that the way to make a unicorn happy is to give it what it wants.", 
-            "VGhleSBzYXkgdGhhdCB0aGUgd2F5IHRvIG1ha2UgYSB1bmljb3JuIGhhcHB5IGlzIHRvIGdpdmUgaXQgd2hhdCBpdCB3YW50cy4=" },
-          { "They say that there are no black or white stones, only gray.", 
-            "VGhleSBzYXkgdGhhdCB0aGVyZSBhcmUgbm8gYmxhY2sgb3Igd2hpdGUgc3RvbmVzLCBvbmx5IGdyYXku" },
-          { "They say that there are no skeletons hence there are no skeleton keys.", 
-            "VGhleSBzYXkgdGhhdCB0aGVyZSBhcmUgbm8gc2tlbGV0b25zIGhlbmNlIHRoZXJlIGFyZSBubyBza2VsZXRvbiBrZXlzLg==" },
-          { "They say that there is a clever rogue in every hacker just dying to escape.", 
-            "VGhleSBzYXkgdGhhdCB0aGVyZSBpcyBhIGNsZXZlciByb2d1ZSBpbiBldmVyeSBoYWNrZXIganVzdCBkeWluZyB0byBlc2NhcGUu" },
-          { "They say that there is no such thing as free advice.", 
-            "VGhleSBzYXkgdGhhdCB0aGVyZSBpcyBubyBzdWNoIHRoaW5nIGFzIGZyZWUgYWR2aWNlLg==" },
-          { "They say that there is only one way to win at NetHack.", 
-            "VGhleSBzYXkgdGhhdCB0aGVyZSBpcyBvbmx5IG9uZSB3YXkgdG8gd2luIGF0IE5ldEhhY2su" },
-          { "They say that there once was a fearsome chaotic samurai named Luk No.", 
-            "VGhleSBzYXkgdGhhdCB0aGVyZSBvbmNlIHdhcyBhIGZlYXJzb21lIGNoYW90aWMgc2FtdXJhaSBuYW1lZCBMdWsgTm8u" },
-          { "They say that there was a time when cursed holy water wasn't water.", 
-            "VGhleSBzYXkgdGhhdCB0aGVyZSB3YXMgYSB0aW1lIHdoZW4gY3Vyc2VkIGhvbHkgd2F0ZXIgd2Fzbid0IHdhdGVyLg==" },
-          { "They say that there's no point in crying over a gray ooze.", 
-            "VGhleSBzYXkgdGhhdCB0aGVyZSdzIG5vIHBvaW50IGluIGNyeWluZyBvdmVyIGEgZ3JheSBvb3plLg==" },
-          { "They say that there's only hope left after you've opened Pandora's box.", 
-            "VGhleSBzYXkgdGhhdCB0aGVyZSdzIG9ubHkgaG9wZSBsZWZ0IGFmdGVyIHlvdSd2ZSBvcGVuZWQgUGFuZG9yYSdzIGJveC4=" },
-          { "They say that trapdoors should always be marked `Caution: Trap Door'.", 
-            "VGhleSBzYXkgdGhhdCB0cmFwZG9vcnMgc2hvdWxkIGFsd2F5cyBiZSBtYXJrZWQgYENhdXRpb246IFRyYXAgRG9vcicu" },
-          { "They say that using an amulet of change isn't a difficult operation.", 
-            "VGhleSBzYXkgdGhhdCB1c2luZyBhbiBhbXVsZXQgb2YgY2hhbmdlIGlzbid0IGEgZGlmZmljdWx0IG9wZXJhdGlvbi4=" },
-          { "They say that water walking boots are better if you are fast like Hermes.", 
-            "VGhleSBzYXkgdGhhdCB3YXRlciB3YWxraW5nIGJvb3RzIGFyZSBiZXR0ZXIgaWYgeW91IGFyZSBmYXN0IGxpa2UgSGVybWVzLg==" },
-          { "They say that when you wear a circular amulet you might resemble a troll.", 
-            "VGhleSBzYXkgdGhhdCB3aGVuIHlvdSB3ZWFyIGEgY2lyY3VsYXIgYW11bGV0IHlvdSBtaWdodCByZXNlbWJsZSBhIHRyb2xsLg==" },
-          { "They say that when you're hungry you can get a pizza in 30 moves or it's free.", 
-            "VGhleSBzYXkgdGhhdCB3aGVuIHlvdSdyZSBodW5ncnkgeW91IGNhbiBnZXQgYSBwaXp6YSBpbiAzMCBtb3ZlcyBvciBpdCdzIGZyZWUu" },
-          { "They say that when your god is angry you should try another one.", 
-            "VGhleSBzYXkgdGhhdCB3aGVuIHlvdXIgZ29kIGlzIGFuZ3J5IHlvdSBzaG91bGQgdHJ5IGFub3RoZXIgb25lLg==" },
-          { "They say that wielding a unicorn horn takes strength.", 
-            "VGhleSBzYXkgdGhhdCB3aWVsZGluZyBhIHVuaWNvcm4gaG9ybiB0YWtlcyBzdHJlbmd0aC4=" },
-          { "They say that with speed boots you never worry about hit and run accidents.", 
-            "VGhleSBzYXkgdGhhdCB3aXRoIHNwZWVkIGJvb3RzIHlvdSBuZXZlciB3b3JyeSBhYm91dCBoaXQgYW5kIHJ1biBhY2NpZGVudHMu" },
-          { "They say that you can defeat a killer bee with a unicorn horn.", 
-            "VGhleSBzYXkgdGhhdCB5b3UgY2FuIGRlZmVhdCBhIGtpbGxlciBiZWUgd2l0aCBhIHVuaWNvcm4gaG9ybi4=" },
-          { "They say that you can only cross the River Styx in Charon's boat.", 
-            "VGhleSBzYXkgdGhhdCB5b3UgY2FuIG9ubHkgY3Jvc3MgdGhlIFJpdmVyIFN0eXggaW4gQ2hhcm9uJ3MgYm9hdC4=" },
-          { "They say that you can only kill a lich once and then you'd better be careful.", 
-            "VGhleSBzYXkgdGhhdCB5b3UgY2FuIG9ubHkga2lsbCBhIGxpY2ggb25jZSBhbmQgdGhlbiB5b3UnZCBiZXR0ZXIgYmUgY2FyZWZ1bC4=" },
-          { "They say that you can only wish for things you've already had.", 
-            "VGhleSBzYXkgdGhhdCB5b3UgY2FuIG9ubHkgd2lzaCBmb3IgdGhpbmdzIHlvdSd2ZSBhbHJlYWR5IGhhZC4=" },
-          { "They say that you can train a cat by talking gently to it.", 
-            "VGhleSBzYXkgdGhhdCB5b3UgY2FuIHRyYWluIGEgY2F0IGJ5IHRhbGtpbmcgZ2VudGx5IHRvIGl0Lg==" },
-          { "They say that you can train a dog by talking firmly to it.", 
-            "VGhleSBzYXkgdGhhdCB5b3UgY2FuIHRyYWluIGEgZG9nIGJ5IHRhbGtpbmcgZmlybWx5IHRvIGl0Lg==" },
-          { "They say that you can trust your gold with the king.", 
-            "VGhleSBzYXkgdGhhdCB5b3UgY2FuIHRydXN0IHlvdXIgZ29sZCB3aXRoIHRoZSBraW5nLg==" },
-          { "They say that you can't wipe your greasy bare hands on a blank scroll.", 
-            "VGhleSBzYXkgdGhhdCB5b3UgY2FuJ3Qgd2lwZSB5b3VyIGdyZWFzeSBiYXJlIGhhbmRzIG9uIGEgYmxhbmsgc2Nyb2xsLg==" },
-          { "They say that you cannot trust scrolls of rumor.", 
-            "VGhleSBzYXkgdGhhdCB5b3UgY2Fubm90IHRydXN0IHNjcm9sbHMgb2YgcnVtb3Iu" },
-          { "They say that you could fall head over heels for an energy vortex.", 
-            "VGhleSBzYXkgdGhhdCB5b3UgY291bGQgZmFsbCBoZWFkIG92ZXIgaGVlbHMgZm9yIGFuIGVuZXJneSB2b3J0ZXgu" },
-          { "They say that you need a key in order to open locked doors.", 
-            "VGhleSBzYXkgdGhhdCB5b3UgbmVlZCBhIGtleSBpbiBvcmRlciB0byBvcGVuIGxvY2tlZCBkb29ycy4=" },
-          { "They say that you need a mirror to notice a mimic in an antique shop.", 
-            "VGhleSBzYXkgdGhhdCB5b3UgbmVlZCBhIG1pcnJvciB0byBub3RpY2UgYSBtaW1pYyBpbiBhbiBhbnRpcXVlIHNob3Au" },
-          { "They say that you really can use a pick-axe unless you really can't.", 
-            "VGhleSBzYXkgdGhhdCB5b3UgcmVhbGx5IGNhbiB1c2UgYSBwaWNrLWF4ZSB1bmxlc3MgeW91IHJlYWxseSBjYW4ndC4=" },
-          { "They say that you should always store your tools in the cellar.", 
-            "VGhleSBzYXkgdGhhdCB5b3Ugc2hvdWxkIGFsd2F5cyBzdG9yZSB5b3VyIHRvb2xzIGluIHRoZSBjZWxsYXIu" },
-          { "They say that you should be careful while climbing the ladder to success.", 
-            "VGhleSBzYXkgdGhhdCB5b3Ugc2hvdWxkIGJlIGNhcmVmdWwgd2hpbGUgY2xpbWJpbmcgdGhlIGxhZGRlciB0byBzdWNjZXNzLg==" },
-          { "They say that you should call your armor `rustproof'.", 
-            "VGhleSBzYXkgdGhhdCB5b3Ugc2hvdWxkIGNhbGwgeW91ciBhcm1vciBgcnVzdHByb29mJy4=" },
-          { "They say that you should name your dog Spuds to have a cool pet.", 
-            "VGhleSBzYXkgdGhhdCB5b3Ugc2hvdWxkIG5hbWUgeW91ciBkb2cgU3B1ZHMgdG8gaGF2ZSBhIGNvb2wgcGV0Lg==" },
-          { "They say that you should name your weapon after your first monster kill.", 
-            "VGhleSBzYXkgdGhhdCB5b3Ugc2hvdWxkIG5hbWUgeW91ciB3ZWFwb24gYWZ0ZXIgeW91ciBmaXJzdCBtb25zdGVyIGtpbGwu" },
-          { "They say that you should never introduce a rope golem to a succubus.", 
-            "VGhleSBzYXkgdGhhdCB5b3Ugc2hvdWxkIG5ldmVyIGludHJvZHVjZSBhIHJvcGUgZ29sZW0gdG8gYSBzdWNjdWJ1cy4=" },
-          { "They say that you should never sleep near invisible ring wraiths.", 
-            "VGhleSBzYXkgdGhhdCB5b3Ugc2hvdWxkIG5ldmVyIHNsZWVwIG5lYXIgaW52aXNpYmxlIHJpbmcgd3JhaXRocy4=" },
-          { "They say that you should never try to leave the dungeon with a bag of gems.", 
-            "VGhleSBzYXkgdGhhdCB5b3Ugc2hvdWxkIG5ldmVyIHRyeSB0byBsZWF2ZSB0aGUgZHVuZ2VvbiB3aXRoIGEgYmFnIG9mIGdlbXMu" },
-          { "They say that you should remove your armor before sitting on a throne.", 
-            "VGhleSBzYXkgdGhhdCB5b3Ugc2hvdWxkIHJlbW92ZSB5b3VyIGFybW9yIGJlZm9yZSBzaXR0aW5nIG9uIGEgdGhyb25lLg==" },
-          { "This fortune cookie is copy protected.", 
-            "VGhpcyBmb3J0dW5lIGNvb2tpZSBpcyBjb3B5IHByb3RlY3RlZC4=" },
-          { "This fortune cookie is the property of Fortune Cookies, Inc.", 
-            "VGhpcyBmb3J0dW5lIGNvb2tpZSBpcyB0aGUgcHJvcGVydHkgb2YgRm9ydHVuZSBDb29raWVzLCBJbmMu" },
-          { "Tired? Try a scroll of charging on yourself.", 
-            "VGlyZWQ/IFRyeSBhIHNjcm9sbCBvZiBjaGFyZ2luZyBvbiB5b3Vyc2VsZi4=" },
-          { "To achieve the next higher rating, you need 3 more points.", 
-            "VG8gYWNoaWV2ZSB0aGUgbmV4dCBoaWdoZXIgcmF0aW5nLCB5b3UgbmVlZCAzIG1vcmUgcG9pbnRzLg==" },
-          { "To reach heaven, escape the dungeon while wearing a ring of levitation.", 
-            "VG8gcmVhY2ggaGVhdmVuLCBlc2NhcGUgdGhlIGR1bmdlb24gd2hpbGUgd2VhcmluZyBhIHJpbmcgb2YgbGV2aXRhdGlvbi4=" },
-          { "Tourists wear shirts loud enough to wake the dead.", 
-            "VG91cmlzdHMgd2VhciBzaGlydHMgbG91ZCBlbm91Z2ggdG8gd2FrZSB0aGUgZGVhZC4=" },
-          { "Try calling your katana Moulinette.", 
-            "VHJ5IGNhbGxpbmcgeW91ciBrYXRhbmEgTW91bGluZXR0ZS4=" },
-          { "Ulch! That meat was painted!", 
-            "VWxjaCEgVGhhdCBtZWF0IHdhcyBwYWludGVkIQ==" },
-          { "Unfortunately, this message was left intentionally blank.", 
-            "VW5mb3J0dW5hdGVseSwgdGhpcyBtZXNzYWdlIHdhcyBsZWZ0IGludGVudGlvbmFsbHkgYmxhbmsu" },
-          { "Using a morning star in the evening has no effect.", 
-            "VXNpbmcgYSBtb3JuaW5nIHN0YXIgaW4gdGhlIGV2ZW5pbmcgaGFzIG5vIGVmZmVjdC4=" },
-          { "Want a hint? Zap a wand of make invisible on your weapon!", 
-            "V2FudCBhIGhpbnQ/IFphcCBhIHdhbmQgb2YgbWFrZSBpbnZpc2libGUgb24geW91ciB3ZWFwb24h" },
-          { "Want to ascend in a hurry? Apply at Gizmonic Institute.", 
-            "V2FudCB0byBhc2NlbmQgaW4gYSBodXJyeT8gQXBwbHkgYXQgR2l6bW9uaWMgSW5zdGl0dXRlLg==" },
-          { "Wanted: shopkeepers. Send a scroll of mail to Mage of Yendor/Level 35/Dungeon.", 
-            "V2FudGVkOiBzaG9wa2VlcGVycy4gU2VuZCBhIHNjcm9sbCBvZiBtYWlsIHRvIE1hZ2Ugb2YgWWVuZG9yL0xldmVsIDM1L0R1bmdlb24u" },
-          { "Warning: fortune reading can be hazardous to your health.", 
-            "V2FybmluZzogZm9ydHVuZSByZWFkaW5nIGNhbiBiZSBoYXphcmRvdXMgdG8geW91ciBoZWFsdGgu" },
-          { "We have new ways of detecting treachery...", 
-            "V2UgaGF2ZSBuZXcgd2F5cyBvZiBkZXRlY3RpbmcgdHJlYWNoZXJ5Li4u" },
-          { "Wet towels make great weapons!", 
-            "V2V0IHRvd2VscyBtYWtlIGdyZWF0IHdlYXBvbnMh" },
-          { "What a pity, you cannot read it!", 
-            "V2hhdCBhIHBpdHksIHlvdSBjYW5ub3QgcmVhZCBpdCE=" },
-          { "When a piercer drops in on you, you will be tempted to hit the ceiling!", 
-            "V2hlbiBhIHBpZXJjZXIgZHJvcHMgaW4gb24geW91LCB5b3Ugd2lsbCBiZSB0ZW1wdGVkIHRvIGhpdCB0aGUgY2VpbGluZyE=" },
-          { "When in a maze follow the right wall and you will never get lost.", 
-            "V2hlbiBpbiBhIG1hemUgZm9sbG93IHRoZSByaWdodCB3YWxsIGFuZCB5b3Ugd2lsbCBuZXZlciBnZXQgbG9zdC4=" },
-          { "When you have a key, you don't have to wait for the guard.", 
-            "V2hlbiB5b3UgaGF2ZSBhIGtleSwgeW91IGRvbid0IGhhdmUgdG8gd2FpdCBmb3IgdGhlIGd1YXJkLg==" },
-          { "Why are you wasting time reading fortunes?", 
-            "V2h5IGFyZSB5b3Ugd2FzdGluZyB0aW1lIHJlYWRpbmcgZm9ydHVuZXM/" },
-          { "Wish for a master key and open the Magic Memory Vault!", 
-            "V2lzaCBmb3IgYSBtYXN0ZXIga2V5IGFuZCBvcGVuIHRoZSBNYWdpYyBNZW1vcnkgVmF1bHQh" },
-          { "Wizard expects every monster to do its duty.", 
-            "V2l6YXJkIGV4cGVjdHMgZXZlcnkgbW9uc3RlciB0byBkbyBpdHMgZHV0eS4=" },
-          { "Wow! You could've had a potion of fruit juice!", 
-            "V293ISBZb3UgY291bGQndmUgaGFkIGEgcG90aW9uIG9mIGZydWl0IGp1aWNlIQ==" },
-          { "Yet Another Silly Message (YASM).", 
-            "WWV0IEFub3RoZXIgU2lsbHkgTWVzc2FnZSAoWUFTTSku" },
-          { "You are destined to be misled by a fortune.", 
-            "WW91IGFyZSBkZXN0aW5lZCB0byBiZSBtaXNsZWQgYnkgYSBmb3J0dW5lLg==" },
-          { "You can get a genuine Amulet of Yendor by doing the following: --More--", 
-            "WW91IGNhbiBnZXQgYSBnZW51aW5lIEFtdWxldCBvZiBZZW5kb3IgYnkgZG9pbmcgdGhlIGZvbGxvd2luZzogLS1Nb3JlLS0=" },
-          { "You can protect yourself from black dragons by doing the following: --More--", 
-            "WW91IGNhbiBwcm90ZWN0IHlvdXJzZWxmIGZyb20gYmxhY2sgZHJhZ29ucyBieSBkb2luZyB0aGUgZm9sbG93aW5nOiAtLU1vcmUtLQ==" },
-          { "You can't get by the snake.", 
-            "WW91IGNhbid0IGdldCBieSB0aGUgc25ha2Uu" },
-          { "You feel like someone is pulling your leg.", 
-            "WW91IGZlZWwgbGlrZSBzb21lb25lIGlzIHB1bGxpbmcgeW91ciBsZWcu" },
-          { "You have to outwit the Sphynx or pay her.", 
-            "WW91IGhhdmUgdG8gb3V0d2l0IHRoZSBTcGh5bnggb3IgcGF5IGhlci4=" },
-          { "You hear the fortune cookie's hissing!", 
-            "WW91IGhlYXIgdGhlIGZvcnR1bmUgY29va2llJ3MgaGlzc2luZyE=" },
-          { "You may get rich selling letters, but beware of being blackmailed!", 
-            "WW91IG1heSBnZXQgcmljaCBzZWxsaW5nIGxldHRlcnMsIGJ1dCBiZXdhcmUgb2YgYmVpbmcgYmxhY2ttYWlsZWQh" },
-          { "You offend Shai-Hulud by sheathing your crysknife without having drawn blood.", 
-            "WW91IG9mZmVuZCBTaGFpLUh1bHVkIGJ5IHNoZWF0aGluZyB5b3VyIGNyeXNrbmlmZSB3aXRob3V0IGhhdmluZyBkcmF3biBibG9vZC4=" },
-          { "You swallowed the fortune!", 
-            "WW91IHN3YWxsb3dlZCB0aGUgZm9ydHVuZSE=" },
-          { "You want to regain strength? Two levels ahead is a guesthouse!", 
-            "WW91IHdhbnQgdG8gcmVnYWluIHN0cmVuZ3RoPyBUd28gbGV2ZWxzIGFoZWFkIGlzIGEgZ3Vlc3Rob3VzZSE=" },
-          { "You will encounter a tall, dark, and gruesome creature...", 
-            "WW91IHdpbGwgZW5jb3VudGVyIGEgdGFsbCwgZGFyaywgYW5kIGdydWVzb21lIGNyZWF0dXJlLi4u" },
+    { "AB", "QUI=" },
+    { "AH", "QUg=" },
+    { "AQ", "QVE=" },
+    { "BD", "QkQ=" },
+    { "CR", "Q1I=" },
+    { "CS", "Q1M=" },
+    { "DB", "REI=" },
+    { "DC", "REM=" },
+    { "EK", "RUs=" },
+    { "ET", "RVQ=" },
+    { "IM", "SU0=" },
+    { "JR", "SlI=" },
+    { "LO", "TE8=" },
+    { "LW", "TFc=" },
+    { "ML", "TUw=" },
+    { "SB", "U0I=" },
+    { "TO", "VE8=" },
+    { "VS", "VlM=" },
+    { "WP", "V1A=" },
+    /* legitimate two-letter words */
+    { "ad", "YWQ=" },
+    { "ah", "YWg=" },
+    { "am", "YW0=" },
+    { "an", "YW4=" },
+    { "as", "YXM=" },
+    { "at", "YXQ=" },
+    { "ax", "YXg=" },
+    { "be", "YmU=" },
+    { "by", "Ynk=" },
+    { "do", "ZG8=" },
+    { "go", "Z28=" },
+    { "he", "aGU=" },
+    { "hi", "aGk=" },
+    { "if", "aWY=" },
+    { "in", "aW4=" },
+    { "is", "aXM=" },
+    { "it", "aXQ=" },
+    { "me", "bWU=" },
+    { "my", "bXk=" },
+    { "no", "bm8=" },
+    { "of", "b2Y=" },
+    { "on", "b24=" },
+    { "or", "b3I=" },
+    { "ox", "b3g=" },
+    { "so", "c28=" },
+    { "to", "dG8=" },
+    { "up", "dXA=" },
+    { "us", "dXM=" },
+    { "we", "d2U=" },
+    /* all three-letter entries in /usr/dict/words */
+    { "1st", "MXN0" },
+    { "2nd", "Mm5k" },
+    { "3rd", "M3Jk" },
+    { "4th", "NHRo" },
+    { "5th", "NXRo" },
+    { "6th", "NnRo" },
+    { "7th", "N3Ro" },
+    { "8th", "OHRo" },
+    { "9th", "OXRo" },
+    { "AAA", "QUFB" },
+    { "AAU", "QUFV" },
+    { "ABA", "QUJB" },
+    { "abc", "YWJj" },
+    { "Abe", "QWJl" },
+    { "Abo", "QWJv" },
+    { "ace", "YWNl" },
+    { "ACM", "QUNN" },
+    { "ACS", "QUNT" },
+    { "act", "YWN0" },
+    { "Ada", "QWRh" },
+    { "add", "YWRk" },
+    { "ado", "YWRv" },
+    { "aft", "YWZ0" },
+    { "age", "YWdl" },
+    { "ago", "YWdv" },
+    { "aid", "YWlk" },
+    { "ail", "YWls" },
+    { "aim", "YWlt" },
+    { "air", "YWly" },
+    { "ala", "YWxh" },
+    { "alb", "YWxi" },
+    { "ale", "YWxl" },
+    { "Ali", "QWxp" },
+    { "all", "YWxs" },
+    { "alp", "YWxw" },
+    { "A&M", "QSZN" },
+    { "AMA", "QU1B" },
+    { "ami", "YW1p" },
+    { "amp", "YW1w" },
+    { "Amy", "QW15" },
+    { "amy", "YW15" },
+    { "ana", "YW5h" },
+    { "and", "YW5k" },
+    { "ani", "YW5p" },
+    { "Ann", "QW5u" },
+    { "ant", "YW50" },
+    { "any", "YW55" },
+    { "A&P", "QSZQ" },
+    { "ape", "YXBl" },
+    { "Apr", "QXBy" },
+    { "APS", "QVBT" },
+    { "apt", "YXB0" },
+    { "arc", "YXJj" },
+    { "are", "YXJl" },
+    { "ark", "YXJr" },
+    { "arm", "YXJt" },
+    { "art", "YXJ0" },
+    { "a's", "YSdz" },
+    { "ash", "YXNo" },
+    { "ask", "YXNr" },
+    { "ass", "YXNz" },
+    { "ate", "YXRl" },
+    { "Aug", "QXVn" },
+    { "auk", "YXVr" },
+    { "Ave", "QXZl" },
+    { "awe", "YXdl" },
+    { "awl", "YXds" },
+    { "awn", "YXdu" },
+    { "axe", "YXhl" },
+    { "aye", "YXll" },
+    { "bad", "YmFk" },
+    { "bag", "YmFn" },
+    { "bah", "YmFo" },
+    { "bam", "YmFt" },
+    { "ban", "YmFu" },
+    { "bar", "YmFy" },
+    { "bat", "YmF0" },
+    { "bay", "YmF5" },
+    { "bed", "YmVk" },
+    { "bee", "YmVl" },
+    { "beg", "YmVn" },
+    { "bel", "YmVs" },
+    { "Ben", "QmVu" },
+    { "bet", "YmV0" },
+    { "bey", "YmV5" },
+    { "bib", "Ymli" },
+    { "bid", "Ymlk" },
+    { "big", "Ymln" },
+    { "bin", "Ymlu" },
+    { "bit", "Yml0" },
+    { "biz", "Yml6" },
+    { "BMW", "Qk1X" },
+    { "boa", "Ym9h" },
+    { "bob", "Ym9i" },
+    { "bog", "Ym9n" },
+    { "bon", "Ym9u" },
+    { "boo", "Ym9v" },
+    { "bop", "Ym9w" },
+    { "bow", "Ym93" },
+    { "box", "Ym94" },
+    { "boy", "Ym95" },
+    { "b's", "Yidz" },
+    { "BTL", "QlRM" },
+    { "BTU", "QlRV" },
+    { "bub", "YnVi" },
+    { "bud", "YnVk" },
+    { "bug", "YnVn" },
+    { "bum", "YnVt" },
+    { "bun", "YnVu" },
+    { "bus", "YnVz" },
+    { "but", "YnV0" },
+    { "buy", "YnV5" },
+    { "bye", "Ynll" },
+    { "cab", "Y2Fi" },
+    { "Cal", "Q2Fs" },
+    { "cam", "Y2Ft" },
+    { "can", "Y2Fu" },
+    { "cap", "Y2Fw" },
+    { "car", "Y2Fy" },
+    { "cat", "Y2F0" },
+    { "caw", "Y2F3" },
+    { "CBS", "Q0JT" },
+    { "CDC", "Q0RD" },
+    { "CEQ", "Q0VR" },
+    { "chi", "Y2hp" },
+    { "CIA", "Q0lB" },
+    { "cit", "Y2l0" },
+    { "cod", "Y29k" },
+    { "cog", "Y29n" },
+    { "col", "Y29s" },
+    { "con", "Y29u" },
+    { "coo", "Y29v" },
+    { "cop", "Y29w" },
+    { "cos", "Y29z" },
+    { "cot", "Y290" },
+    { "cow", "Y293" },
+    { "cox", "Y294" },
+    { "coy", "Y295" },
+    { "CPA", "Q1BB" },
+    { "cpu", "Y3B1" },
+    { "CRT", "Q1JU" },
+    { "cry", "Y3J5" },
+    { "c's", "Yydz" },
+    { "cub", "Y3Vi" },
+    { "cud", "Y3Vk" },
+    { "cue", "Y3Vl" },
+    { "cup", "Y3Vw" },
+    { "cur", "Y3Vy" },
+    { "cut", "Y3V0" },
+    { "dab", "ZGFi" },
+    { "dad", "ZGFk" },
+    { "dam", "ZGFt" },
+    { "Dan", "RGFu" },
+    { "Dar", "RGFy" },
+    { "day", "ZGF5" },
+    { "Dec", "RGVj" },
+    { "Dee", "RGVl" },
+    { "Del", "RGVs" },
+    { "den", "ZGVu" },
+    { "Des", "RGVz" },
+    { "dew", "ZGV3" },
+    { "dey", "ZGV5" },
+    { "did", "ZGlk" },
+    { "die", "ZGll" },
+    { "dig", "ZGln" },
+    { "dim", "ZGlt" },
+    { "din", "ZGlu" },
+    { "dip", "ZGlw" },
+    { "Dis", "RGlz" },
+    { "DNA", "RE5B" },
+    { "DOD", "RE9E" },
+    { "doe", "ZG9l" },
+    { "dog", "ZG9n" },
+    { "don", "ZG9u" },
+    { "dot", "ZG90" },
+    { "Dow", "RG93" },
+    { "dry", "ZHJ5" },
+    { "d's", "ZCdz" },
+    { "dub", "ZHVi" },
+    { "dud", "ZHVk" },
+    { "due", "ZHVl" },
+    { "dug", "ZHVn" },
+    { "dun", "ZHVu" },
+    { "dye", "ZHll" },
+    { "ear", "ZWFy" },
+    { "eat", "ZWF0" },
+    { "ebb", "ZWJi" },
+    { "EDT", "RURU" },
+    { "eel", "ZWVs" },
+    { "eft", "ZWZ0" },
+    { "e.g", "ZS5n" },
+    { "egg", "ZWdn" },
+    { "ego", "ZWdv" },
+    { "eke", "ZWtl" },
+    { "Eli", "RWxp" },
+    { "elk", "ZWxr" },
+    { "ell", "ZWxs" },
+    { "elm", "ZWxt" },
+    { "Ely", "RWx5" },
+    { "end", "ZW5k" },
+    { "Eng", "RW5n" },
+    { "EPA", "RVBB" },
+    { "era", "ZXJh" },
+    { "ere", "ZXJl" },
+    { "erg", "ZXJn" },
+    { "err", "ZXJy" },
+    { "e's", "ZSdz" },
+    { "EST", "RVNU" },
+    { "eta", "ZXRh" },
+    { "etc", "ZXRj" },
+    { "Eva", "RXZh" },
+    { "eve", "ZXZl" },
+    { "ewe", "ZXdl" },
+    { "eye", "ZXll" },
+    { "FAA", "RkFB" },
+    { "fad", "ZmFk" },
+    { "fag", "ZmFn" },
+    { "fan", "ZmFu" },
+    { "far", "ZmFy" },
+    { "fat", "ZmF0" },
+    { "fay", "ZmF5" },
+    { "FBI", "RkJJ" },
+    { "FCC", "RkND" },
+    { "FDA", "RkRB" },
+    { "Feb", "RmVi" },
+    { "fed", "ZmVk" },
+    { "fee", "ZmVl" },
+    { "few", "ZmV3" },
+    { "fib", "Zmli" },
+    { "fig", "Zmln" },
+    { "fin", "Zmlu" },
+    { "fir", "Zmly" },
+    { "fit", "Zml0" },
+    { "fix", "Zml4" },
+    { "Flo", "Rmxv" },
+    { "flu", "Zmx1" },
+    { "fly", "Zmx5" },
+    { "FMC", "Rk1D" },
+    { "fob", "Zm9i" },
+    { "foe", "Zm9l" },
+    { "fog", "Zm9n" },
+    { "fop", "Zm9w" },
+    { "for", "Zm9y" },
+    { "fox", "Zm94" },
+    { "FPC", "RlBD" },
+    { "fro", "ZnJv" },
+    { "fry", "ZnJ5" },
+    { "f's", "Zidz" },
+    { "FTC", "RlRD" },
+    { "fum", "ZnVt" },
+    { "fun", "ZnVu" },
+    { "fur", "ZnVy" },
+    { "gab", "Z2Fi" },
+    { "gad", "Z2Fk" },
+    { "gag", "Z2Fn" },
+    { "gal", "Z2Fs" },
+    { "gam", "Z2Ft" },
+    { "GAO", "R0FP" },
+    { "gap", "Z2Fw" },
+    { "gar", "Z2Fy" },
+    { "gas", "Z2Fz" },
+    { "gay", "Z2F5" },
+    { "gee", "Z2Vl" },
+    { "gel", "Z2Vs" },
+    { "gem", "Z2Vt" },
+    { "get", "Z2V0" },
+    { "gig", "Z2ln" },
+    { "Gil", "R2ls" },
+    { "gin", "Z2lu" },
+    { "GMT", "R01U" },
+    { "GNP", "R05Q" },
+    { "gnu", "Z251" },
+    { "Goa", "R29h" },
+    { "gob", "Z29i" },
+    { "god", "Z29k" },
+    { "gog", "Z29n" },
+    { "GOP", "R09Q" },
+    { "got", "Z290" },
+    { "GPO", "R1BP" },
+    { "g's", "Zydz" },
+    { "GSA", "R1NB" },
+    { "gum", "Z3Vt" },
+    { "gun", "Z3Vu" },
+    { "Gus", "R3Vz" },
+    { "gut", "Z3V0" },
+    { "guy", "Z3V5" },
+    { "gym", "Z3lt" },
+    { "gyp", "Z3lw" },
+    { "had", "aGFk" },
+    { "Hal", "SGFs" },
+    { "ham", "aGFt" },
+    { "Han", "SGFu" },
+    { "hap", "aGFw" },
+    { "hat", "aGF0" },
+    { "haw", "aGF3" },
+    { "hay", "aGF5" },
+    { "hem", "aGVt" },
+    { "hen", "aGVu" },
+    { "her", "aGVy" },
+    { "hew", "aGV3" },
+    { "hex", "aGV4" },
+    { "hey", "aGV5" },
+    { "hid", "aGlk" },
+    { "him", "aGlt" },
+    { "hip", "aGlw" },
+    { "his", "aGlz" },
+    { "hit", "aGl0" },
+    { "hob", "aG9i" },
+    { "hoc", "aG9j" },
+    { "hoe", "aG9l" },
+    { "hog", "aG9n" },
+    { "hoi", "aG9p" },
+    { "Hom", "SG9t" },
+    { "hop", "aG9w" },
+    { "hot", "aG90" },
+    { "how", "aG93" },
+    { "hoy", "aG95" },
+    { "h's", "aCdz" },
+    { "hub", "aHVi" },
+    { "hue", "aHVl" },
+    { "hug", "aHVn" },
+    { "huh", "aHVo" },
+    { "hum", "aHVt" },
+    { "Hun", "SHVu" },
+    { "hut", "aHV0" },
+    { "Ian", "SWFu" },
+    { "IBM", "SUJN" },
+    { "Ibn", "SWJu" },
+    { "ICC", "SUND" },
+    { "ice", "aWNl" },
+    { "icy", "aWN5" },
+    { "I'd", "SSdk" },
+    { "Ida", "SWRh" },
+    { "i.e", "aS5l" },
+    { "iii", "aWlp" },
+    { "Ike", "SWtl" },
+    { "ill", "aWxs" },
+    { "I'm", "SSdt" },
+    { "imp", "aW1w" },
+    { "Inc", "SW5j" },
+    { "ink", "aW5r" },
+    { "inn", "aW5u" },
+    { "ion", "aW9u" },
+    { "Ira", "SXJh" },
+    { "ire", "aXJl" },
+    { "irk", "aXJr" },
+    { "IRS", "SVJT" },
+    { "i's", "aSdz" },
+    { "Ito", "SXRv" },
+    { "ITT", "SVRU" },
+    { "ivy", "aXZ5" },
+    { "jab", "amFi" },
+    { "jag", "amFn" },
+    { "jam", "amFt" },
+    { "Jan", "SmFu" },
+    { "jar", "amFy" },
+    { "jaw", "amF3" },
+    { "jay", "amF5" },
+    { "Jed", "SmVk" },
+    { "jet", "amV0" },
+    { "Jew", "SmV3" },
+    { "jig", "amln" },
+    { "Jim", "Smlt" },
+    { "job", "am9i" },
+    { "Joe", "Sm9l" },
+    { "jog", "am9n" },
+    { "Jon", "Sm9u" },
+    { "jot", "am90" },
+    { "joy", "am95" },
+    { "j's", "aidz" },
+    { "jug", "anVn" },
+    { "jut", "anV0" },
+    { "Kay", "S2F5" },
+    { "keg", "a2Vn" },
+    { "ken", "a2Vu" },
+    { "key", "a2V5" },
+    { "kid", "a2lk" },
+    { "Kim", "S2lt" },
+    { "kin", "a2lu" },
+    { "kit", "a2l0" },
+    { "k's", "aydz" },
+    { "lab", "bGFi" },
+    { "lac", "bGFj" },
+    { "lad", "bGFk" },
+    { "lag", "bGFn" },
+    { "lam", "bGFt" },
+    { "Lao", "TGFv" },
+    { "lap", "bGFw" },
+    { "law", "bGF3" },
+    { "lax", "bGF4" },
+    { "lay", "bGF5" },
+    { "lea", "bGVh" },
+    { "led", "bGVk" },
+    { "lee", "bGVl" },
+    { "leg", "bGVn" },
+    { "Len", "TGVu" },
+    { "Leo", "TGVv" },
+    { "let", "bGV0" },
+    { "Lev", "TGV2" },
+    { "Lew", "TGV3" },
+    { "lew", "bGV3" },
+    { "lid", "bGlk" },
+    { "lie", "bGll" },
+    { "lim", "bGlt" },
+    { "Lin", "TGlu" },
+    { "lip", "bGlw" },
+    { "lit", "bGl0" },
+    { "Liz", "TGl6" },
+    { "lob", "bG9i" },
+    { "log", "bG9n" },
+    { "lop", "bG9w" },
+    { "Los", "TG9z" },
+    { "lot", "bG90" },
+    { "Lou", "TG91" },
+    { "low", "bG93" },
+    { "loy", "bG95" },
+    { "l's", "bCdz" },
+    { "LSI", "TFNJ" },
+    { "Ltd", "THRk" },
+    { "LTV", "TFRW" },
+    { "lug", "bHVn" },
+    { "lux", "bHV4" },
+    { "lye", "bHll" },
+    { "Mac", "TWFj" },
+    { "mad", "bWFk" },
+    { "Mae", "TWFl" },
+    { "man", "bWFu" },
+    { "Mao", "TWFv" },
+    { "map", "bWFw" },
+    { "mar", "bWFy" },
+    { "mat", "bWF0" },
+    { "maw", "bWF3" },
+    { "Max", "TWF4" },
+    { "max", "bWF4" },
+    { "may", "bWF5" },
+    { "MBA", "TUJB" },
+    { "Meg", "TWVn" },
+    { "Mel", "TWVs" },
+    { "men", "bWVu" },
+    { "met", "bWV0" },
+    { "mew", "bWV3" },
+    { "mid", "bWlk" },
+    { "mig", "bWln" },
+    { "min", "bWlu" },
+    { "MIT", "TUlU" },
+    { "mix", "bWl4" },
+    { "mob", "bW9i" },
+    { "Moe", "TW9l" },
+    { "moo", "bW9v" },
+    { "mop", "bW9w" },
+    { "mot", "bW90" },
+    { "mow", "bW93" },
+    { "MPH", "TVBI" },
+    { "Mrs", "TXJz" },
+    { "m's", "bSdz" },
+    { "mud", "bXVk" },
+    { "mug", "bXVn" },
+    { "mum", "bXVt" },
+    { "nab", "bmFi" },
+    { "nag", "bmFn" },
+    { "Nan", "TmFu" },
+    { "nap", "bmFw" },
+    { "Nat", "TmF0" },
+    { "nay", "bmF5" },
+    { "NBC", "TkJD" },
+    { "NBS", "TkJT" },
+    { "NCO", "TkNP" },
+    { "NCR", "TkNS" },
+    { "Ned", "TmVk" },
+    { "nee", "bmVl" },
+    { "net", "bmV0" },
+    { "new", "bmV3" },
+    { "nib", "bmli" },
+    { "NIH", "TklI" },
+    { "nil", "bmls" },
+    { "nip", "bmlw" },
+    { "nit", "bml0" },
+    { "NNE", "Tk5F" },
+    { "NNW", "Tk5X" },
+    { "nob", "bm9i" },
+    { "nod", "bm9k" },
+    { "non", "bm9u" },
+    { "nor", "bm9y" },
+    { "not", "bm90" },
+    { "Nov", "Tm92" },
+    { "now", "bm93" },
+    { "NRC", "TlJD" },
+    { "n's", "bidz" },
+    { "NSF", "TlNG" },
+    { "nun", "bnVu" },
+    { "nut", "bnV0" },
+    { "NYC", "TllD" },
+    { "NYU", "TllV" },
+    { "oaf", "b2Fm" },
+    { "oak", "b2Fr" },
+    { "oar", "b2Fy" },
+    { "oat", "b2F0" },
+    { "Oct", "T2N0" },
+    { "odd", "b2Rk" },
+    { "ode", "b2Rl" },
+    { "off", "b2Zm" },
+    { "oft", "b2Z0" },
+    { "ohm", "b2ht" },
+    { "oil", "b2ls" },
+    { "old", "b2xk" },
+    { "one", "b25l" },
+    { "opt", "b3B0" },
+    { "orb", "b3Ji" },
+    { "ore", "b3Jl" },
+    { "Orr", "T3Jy" },
+    { "o's", "bydz" },
+    { "Ott", "T3R0" },
+    { "our", "b3Vy" },
+    { "out", "b3V0" },
+    { "ova", "b3Zh" },
+    { "owe", "b3dl" },
+    { "owl", "b3ds" },
+    { "own", "b3du" },
+    { "pad", "cGFk" },
+    { "pal", "cGFs" },
+    { "Pam", "UGFt" },
+    { "pan", "cGFu" },
+    { "pap", "cGFw" },
+    { "par", "cGFy" },
+    { "pat", "cGF0" },
+    { "paw", "cGF3" },
+    { "pax", "cGF4" },
+    { "pay", "cGF5" },
+    { "Paz", "UGF6" },
+    { "PBS", "UEJT" },
+    { "PDP", "UERQ" },
+    { "pea", "cGVh" },
+    { "pee", "cGVl" },
+    { "peg", "cGVn" },
+    { "pen", "cGVu" },
+    { "pep", "cGVw" },
+    { "per", "cGVy" },
+    { "pet", "cGV0" },
+    { "pew", "cGV3" },
+    { "PhD", "UGhE" },
+    { "phi", "cGhp" },
+    { "pie", "cGll" },
+    { "pig", "cGln" },
+    { "pin", "cGlu" },
+    { "pip", "cGlw" },
+    { "pit", "cGl0" },
+    { "ply", "cGx5" },
+    { "pod", "cG9k" },
+    { "Poe", "UG9l" },
+    { "poi", "cG9p" },
+    { "pol", "cG9s" },
+    { "pop", "cG9w" },
+    { "pot", "cG90" },
+    { "pow", "cG93" },
+    { "ppm", "cHBt" },
+    { "pro", "cHJv" },
+    { "pry", "cHJ5" },
+    { "p's", "cCdz" },
+    { "psi", "cHNp" },
+    { "PTA", "UFRB" },
+    { "pub", "cHVi" },
+    { "PUC", "UFVD" },
+    { "pug", "cHVn" },
+    { "pun", "cHVu" },
+    { "pup", "cHVw" },
+    { "pus", "cHVz" },
+    { "put", "cHV0" },
+    { "PVC", "UFZD" },
+    { "QED", "UUVE" },
+    { "q's", "cSdz" },
+    { "qua", "cXVh" },
+    { "quo", "cXVv" },
+    { "Rae", "UmFl" },
+    { "rag", "cmFn" },
+    { "raj", "cmFq" },
+    { "ram", "cmFt" },
+    { "ran", "cmFu" },
+    { "rap", "cmFw" },
+    { "rat", "cmF0" },
+    { "raw", "cmF3" },
+    { "ray", "cmF5" },
+    { "RCA", "UkNB" },
+    { "R&D", "UiZE" },
+    { "reb", "cmVi" },
+    { "red", "cmVk" },
+    { "rep", "cmVw" },
+    { "ret", "cmV0" },
+    { "rev", "cmV2" },
+    { "Rex", "UmV4" },
+    { "rho", "cmhv" },
+    { "rib", "cmli" },
+    { "rid", "cmlk" },
+    { "rig", "cmln" },
+    { "rim", "cmlt" },
+    { "Rio", "Umlv" },
+    { "rip", "cmlw" },
+    { "RNA", "Uk5B" },
+    { "rob", "cm9i" },
+    { "rod", "cm9k" },
+    { "roe", "cm9l" },
+    { "Ron", "Um9u" },
+    { "rot", "cm90" },
+    { "row", "cm93" },
+    { "Roy", "Um95" },
+    { "RPM", "UlBN" },
+    { "r's", "cidz" },
+    { "rub", "cnVi" },
+    { "rue", "cnVl" },
+    { "rug", "cnVn" },
+    { "rum", "cnVt" },
+    { "run", "cnVu" },
+    { "rut", "cnV0" },
+    { "rye", "cnll" },
+    { "sac", "c2Fj" },
+    { "sad", "c2Fk" },
+    { "sag", "c2Fn" },
+    { "Sal", "U2Fs" },
+    { "Sam", "U2Ft" },
+    { "San", "U2Fu" },
+    { "Sao", "U2Fv" },
+    { "sap", "c2Fw" },
+    { "sat", "c2F0" },
+    { "saw", "c2F3" },
+    { "sax", "c2F4" },
+    { "say", "c2F5" },
+    { "Sci", "U2Np" },
+    { "SCM", "U0NN" },
+    { "sea", "c2Vh" },
+    { "sec", "c2Vj" },
+    { "see", "c2Vl" },
+    { "sen", "c2Vu" },
+    { "seq", "c2Vx" },
+    { "set", "c2V0" },
+    { "sew", "c2V3" },
+    { "sex", "c2V4" },
+    { "she", "c2hl" },
+    { "Shu", "U2h1" },
+    { "shy", "c2h5" },
+    { "sib", "c2li" },
+    { "sic", "c2lj" },
+    { "sin", "c2lu" },
+    { "sip", "c2lw" },
+    { "sir", "c2ly" },
+    { "sis", "c2lz" },
+    { "sit", "c2l0" },
+    { "six", "c2l4" },
+    { "ski", "c2tp" },
+    { "sky", "c2t5" },
+    { "sly", "c2x5" },
+    { "sob", "c29i" },
+    { "Soc", "U29j" },
+    { "sod", "c29k" },
+    { "Sol", "U29s" },
+    { "son", "c29u" },
+    { "sop", "c29w" },
+    { "sou", "c291" },
+    { "sow", "c293" },
+    { "soy", "c295" },
+    { "spa", "c3Bh" },
+    { "spy", "c3B5" },
+    { "Sri", "U3Jp" },
+    { "s's", "cydz" },
+    { "SSE", "U1NF" },
+    { "SST", "U1NU" },
+    { "SSW", "U1NX" },
+    { "Stu", "U3R1" },
+    { "sub", "c3Vi" },
+    { "sud", "c3Vk" },
+    { "sue", "c3Vl" },
+    { "sum", "c3Vt" },
+    { "sun", "c3Vu" },
+    { "sup", "c3Vw" },
+    { "Sus", "U3Vz" },
+    { "tab", "dGFi" },
+    { "tad", "dGFk" },
+    { "tag", "dGFn" },
+    { "tam", "dGFt" },
+    { "tan", "dGFu" },
+    { "tao", "dGFv" },
+    { "tap", "dGFw" },
+    { "tar", "dGFy" },
+    { "tat", "dGF0" },
+    { "tau", "dGF1" },
+    { "tax", "dGF4" },
+    { "tea", "dGVh" },
+    { "Ted", "VGVk" },
+    { "ted", "dGVk" },
+    { "tee", "dGVl" },
+    { "Tel", "VGVs" },
+    { "ten", "dGVu" },
+    { "the", "dGhl" },
+    { "thy", "dGh5" },
+    { "tic", "dGlj" },
+    { "tid", "dGlk" },
+    { "tie", "dGll" },
+    { "til", "dGls" },
+    { "Tim", "VGlt" },
+    { "tin", "dGlu" },
+    { "tip", "dGlw" },
+    { "tit", "dGl0" },
+    { "TNT", "VE5U" },
+    { "toe", "dG9l" },
+    { "tog", "dG9n" },
+    { "Tom", "VG9t" },
+    { "ton", "dG9u" },
+    { "too", "dG9v" },
+    { "top", "dG9w" },
+    { "tor", "dG9y" },
+    { "tot", "dG90" },
+    { "tow", "dG93" },
+    { "toy", "dG95" },
+    { "TRW", "VFJX" },
+    { "try", "dHJ5" },
+    { "t's", "dCdz" },
+    { "TTL", "VFRM" },
+    { "TTY", "VFRZ" },
+    { "tub", "dHVi" },
+    { "tug", "dHVn" },
+    { "tum", "dHVt" },
+    { "tun", "dHVu" },
+    { "TVA", "VFZB" },
+    { "TWA", "VFdB" },
+    { "two", "dHdv" },
+    { "TWX", "VFdY" },
+    { "ugh", "dWdo" },
+    { "UHF", "VUhG" },
+    { "Uri", "VXJp" },
+    { "urn", "dXJu" },
+    { "U.S", "VS5T" },
+    { "u's", "dSdz" },
+    { "USA", "VVNB" },
+    { "USC", "VVND" },
+    { "use", "dXNl" },
+    { "USN", "VVNO" },
+    { "van", "dmFu" },
+    { "vat", "dmF0" },
+    { "vee", "dmVl" },
+    { "vet", "dmV0" },
+    { "vex", "dmV4" },
+    { "VHF", "VkhG" },
+    { "via", "dmlh" },
+    { "vie", "dmll" },
+    { "vii", "dmlp" },
+    { "vis", "dmlz" },
+    { "viz", "dml6" },
+    { "von", "dm9u" },
+    { "vow", "dm93" },
+    { "v's", "didz" },
+    { "WAC", "V0FD" },
+    { "wad", "d2Fk" },
+    { "wag", "d2Fn" },
+    { "wah", "d2Fo" },
+    { "wan", "d2Fu" },
+    { "war", "d2Fy" },
+    { "was", "d2Fz" },
+    { "wax", "d2F4" },
+    { "way", "d2F5" },
+    { "web", "d2Vi" },
+    { "wed", "d2Vk" },
+    { "wee", "d2Vl" },
+    { "Wei", "V2Vp" },
+    { "wet", "d2V0" },
+    { "who", "d2hv" },
+    { "why", "d2h5" },
+    { "wig", "d2ln" },
+    { "win", "d2lu" },
+    { "wit", "d2l0" },
+    { "woe", "d29l" },
+    { "wok", "d29r" },
+    { "won", "d29u" },
+    { "woo", "d29v" },
+    { "wop", "d29w" },
+    { "wow", "d293" },
+    { "wry", "d3J5" },
+    { "w's", "dydz" },
+    { "x's", "eCdz" },
+    { "yah", "eWFo" },
+    { "yak", "eWFr" },
+    { "yam", "eWFt" },
+    { "yap", "eWFw" },
+    { "yaw", "eWF3" },
+    { "yea", "eWVh" },
+    { "yen", "eWVu" },
+    { "yet", "eWV0" },
+    { "yin", "eWlu" },
+    { "yip", "eWlw" },
+    { "yon", "eW9u" },
+    { "you", "eW91" },
+    { "yow", "eW93" },
+    { "y's", "eSdz" },
+    { "yuh", "eXVo" },
+    { "zag", "emFn" },
+    { "Zan", "WmFu" },
+    { "zap", "emFw" },
+    { "Zen", "WmVu" },
+    { "zig", "emln" },
+    { "zip", "emlw" },
+    { "Zoe", "Wm9l" },
+    { "zoo", "em9v" },
+    { "z's", "eidz" },
+    /* the false rumors file */
+    {   "\"So when I die, the first thing I will see in heaven is a score list?\"",
+        "IlNvIHdoZW4gSSBkaWUsIHRoZSBmaXJzdCB0aGluZyBJIHdpbGwgc2VlIGluIGhlYXZlbiBpcyBhIHNjb3JlIGxpc3Q/Ig=="
+    },
+    {   "1st Law of Hacking: leaving is much more difficult than entering.",
+        "MXN0IExhdyBvZiBIYWNraW5nOiBsZWF2aW5nIGlzIG11Y2ggbW9yZSBkaWZmaWN1bHQgdGhhbiBlbnRlcmluZy4="
+    },
+    {   "2nd Law of Hacking: first in, first out.",
+        "Mm5kIExhdyBvZiBIYWNraW5nOiBmaXJzdCBpbiwgZmlyc3Qgb3V0Lg=="
+    },
+    {   "3rd Law of Hacking: the last blow counts most.",
+        "M3JkIExhdyBvZiBIYWNraW5nOiB0aGUgbGFzdCBibG93IGNvdW50cyBtb3N0Lg=="
+    },
+    {   "4th Law of Hacking: you will find the exit at the entrance.",
+        "NHRoIExhdyBvZiBIYWNraW5nOiB5b3Ugd2lsbCBmaW5kIHRoZSBleGl0IGF0IHRoZSBlbnRyYW5jZS4="
+    },
+    {   "A chameleon imitating a mail daemon often delivers scrolls of fire.",
+        "QSBjaGFtZWxlb24gaW1pdGF0aW5nIGEgbWFpbCBkYWVtb24gb2Z0ZW4gZGVsaXZlcnMgc2Nyb2xscyBvZiBmaXJlLg=="
+    },
+    {   "A cockatrice corpse is guaranteed to be untainted!",
+        "QSBjb2NrYXRyaWNlIGNvcnBzZSBpcyBndWFyYW50ZWVkIHRvIGJlIHVudGFpbnRlZCE="
+    },
+    {   "A dead cockatrice is just a dead lizard.",
+        "QSBkZWFkIGNvY2thdHJpY2UgaXMganVzdCBhIGRlYWQgbGl6YXJkLg=="
+    },
+    {   "A dragon is just a snake that ate a scroll of fire.",
+        "QSBkcmFnb24gaXMganVzdCBhIHNuYWtlIHRoYXQgYXRlIGEgc2Nyb2xsIG9mIGZpcmUu"
+    },
+    {   "A fading corridor enlightens your insight.",
+        "QSBmYWRpbmcgY29ycmlkb3IgZW5saWdodGVucyB5b3VyIGluc2lnaHQu"
+    },
+    {   "A glowing potion is too hot to drink.",
+        "QSBnbG93aW5nIHBvdGlvbiBpcyB0b28gaG90IHRvIGRyaW5rLg=="
+    },
+    {   "A good amulet may protect you against guards.",
+        "QSBnb29kIGFtdWxldCBtYXkgcHJvdGVjdCB5b3UgYWdhaW5zdCBndWFyZHMu"
+    },
+    {   "A lizard corpse is a good thing to turn undead.",
+        "QSBsaXphcmQgY29ycHNlIGlzIGEgZ29vZCB0aGluZyB0byB0dXJuIHVuZGVhZC4="
+    },
+    {   "A long worm can be defined recursively. So how should you attack it?",
+        "QSBsb25nIHdvcm0gY2FuIGJlIGRlZmluZWQgcmVjdXJzaXZlbHkuIFNvIGhvdyBzaG91bGQgeW91IGF0dGFjayBpdD8="
+    },
+    {   "A monstrous mind is a toy forever.",
+        "QSBtb25zdHJvdXMgbWluZCBpcyBhIHRveSBmb3JldmVyLg=="
+    },
+    {   "A nymph will be very pleased if you call her by her real name: Lorelei.",
+        "QSBueW1waCB3aWxsIGJlIHZlcnkgcGxlYXNlZCBpZiB5b3UgY2FsbCBoZXIgYnkgaGVyIHJlYWwgbmFtZTogTG9yZWxlaS4="
+    },
+    {   "A ring of dungeon master control is a great find.",
+        "QSByaW5nIG9mIGR1bmdlb24gbWFzdGVyIGNvbnRyb2wgaXMgYSBncmVhdCBmaW5kLg=="
+    },
+    {   "A ring of extra ring finger is useless if not enchanted.",
+        "QSByaW5nIG9mIGV4dHJhIHJpbmcgZmluZ2VyIGlzIHVzZWxlc3MgaWYgbm90IGVuY2hhbnRlZC4="
+    },
+    {   "A rope may form a trail in a maze.",
+        "QSByb3BlIG1heSBmb3JtIGEgdHJhaWwgaW4gYSBtYXplLg=="
+    },
+    {   "A staff may recharge if you drop it for awhile.",
+        "QSBzdGFmZiBtYXkgcmVjaGFyZ2UgaWYgeW91IGRyb3AgaXQgZm9yIGF3aGlsZS4="
+    },
+    {   "A visit to the Zoo is very educational; you meet interesting animals.",
+        "QSB2aXNpdCB0byB0aGUgWm9vIGlzIHZlcnkgZWR1Y2F0aW9uYWw7IHlvdSBtZWV0IGludGVyZXN0aW5nIGFuaW1hbHMu"
+    },
+    {   "A wand of deaf is a more dangerous weapon than a wand of sheep.",
+        "QSB3YW5kIG9mIGRlYWYgaXMgYSBtb3JlIGRhbmdlcm91cyB3ZWFwb24gdGhhbiBhIHdhbmQgb2Ygc2hlZXAu"
+    },
+    {   "A wand of vibration might bring the whole cave crashing about your ears.",
+        "QSB3YW5kIG9mIHZpYnJhdGlvbiBtaWdodCBicmluZyB0aGUgd2hvbGUgY2F2ZSBjcmFzaGluZyBhYm91dCB5b3VyIGVhcnMu"
+    },
+    {   "A winner never quits. A quitter never wins.",
+        "QSB3aW5uZXIgbmV2ZXIgcXVpdHMuIEEgcXVpdHRlciBuZXZlciB3aW5zLg=="
+    },
+    {   "A wish? Okay, make me a fortune cookie!",
+        "QSB3aXNoPyBPa2F5LCBtYWtlIG1lIGEgZm9ydHVuZSBjb29raWUh"
+    },
+    {   "Afraid of mimics? Try to wear a ring of true seeing.",
+        "QWZyYWlkIG9mIG1pbWljcz8gVHJ5IHRvIHdlYXIgYSByaW5nIG9mIHRydWUgc2VlaW5nLg=="
+    },
+    {   "All monsters are created evil, but some are more evil than others.",
+        "QWxsIG1vbnN0ZXJzIGFyZSBjcmVhdGVkIGV2aWwsIGJ1dCBzb21lIGFyZSBtb3JlIGV2aWwgdGhhbiBvdGhlcnMu"
+    },
+    {   "Always attack a floating eye from behind!",
+        "QWx3YXlzIGF0dGFjayBhIGZsb2F0aW5nIGV5ZSBmcm9tIGJlaGluZCE="
+    },
+    {   "An elven cloak is always the height of fashion.",
+        "QW4gZWx2ZW4gY2xvYWsgaXMgYWx3YXlzIHRoZSBoZWlnaHQgb2YgZmFzaGlvbi4="
+    },
+    {   "Any small object that is accidentally dropped will hide under a larger object.",
+        "QW55IHNtYWxsIG9iamVjdCB0aGF0IGlzIGFjY2lkZW50YWxseSBkcm9wcGVkIHdpbGwgaGlkZSB1bmRlciBhIGxhcmdlciBvYmplY3Qu"
+    },
+    {   "Balrogs do not appear above level 20.",
+        "QmFscm9ncyBkbyBub3QgYXBwZWFyIGFib3ZlIGxldmVsIDIwLg=="
+    },
+    {   "Banana peels work especially well against Keystone Kops.",
+        "QmFuYW5hIHBlZWxzIHdvcmsgZXNwZWNpYWxseSB3ZWxsIGFnYWluc3QgS2V5c3RvbmUgS29wcy4="
+    },
+    {   "Be careful when eating bananas. Monsters might slip on the peels.",
+        "QmUgY2FyZWZ1bCB3aGVuIGVhdGluZyBiYW5hbmFzLiBNb25zdGVycyBtaWdodCBzbGlwIG9uIHRoZSBwZWVscy4="
+    },
+    {   "Better leave the dungeon; otherwise you might get hurt badly.",
+        "QmV0dGVyIGxlYXZlIHRoZSBkdW5nZW9uOyBvdGhlcndpc2UgeW91IG1pZ2h0IGdldCBodXJ0IGJhZGx5Lg=="
+    },
+    {   "Beware of the potion of nitroglycerin -- it's not for the weak of heart.",
+        "QmV3YXJlIG9mIHRoZSBwb3Rpb24gb2Ygbml0cm9nbHljZXJpbiAtLSBpdCdzIG5vdCBmb3IgdGhlIHdlYWsgb2YgaGVhcnQu"
+    },
+    {   "Beware: there's always a chance that your wand explodes as you try to zap it!",
+        "QmV3YXJlOiB0aGVyZSdzIGFsd2F5cyBhIGNoYW5jZSB0aGF0IHlvdXIgd2FuZCBleHBsb2RlcyBhcyB5b3UgdHJ5IHRvIHphcCBpdCE="
+    },
+    {   "Beyond the 23rd level lies a happy retirement in a room of your own.",
+        "QmV5b25kIHRoZSAyM3JkIGxldmVsIGxpZXMgYSBoYXBweSByZXRpcmVtZW50IGluIGEgcm9vbSBvZiB5b3VyIG93bi4="
+    },
+    {   "Changing your suit without dropping your sword? You must be kidding!",
+        "Q2hhbmdpbmcgeW91ciBzdWl0IHdpdGhvdXQgZHJvcHBpbmcgeW91ciBzd29yZD8gWW91IG11c3QgYmUga2lkZGluZyE="
+    },
+    {   "Cockatrices might turn themselves to stone faced with a mirror.",
+        "Q29ja2F0cmljZXMgbWlnaHQgdHVybiB0aGVtc2VsdmVzIHRvIHN0b25lIGZhY2VkIHdpdGggYSBtaXJyb3Iu"
+    },
+    {   "Consumption of home-made food is strictly forbidden in this dungeon.",
+        "Q29uc3VtcHRpb24gb2YgaG9tZS1tYWRlIGZvb2QgaXMgc3RyaWN0bHkgZm9yYmlkZGVuIGluIHRoaXMgZHVuZ2Vvbi4="
+    },
+    {   "Dark room? Your chance to develop your photographs!",
+        "RGFyayByb29tPyBZb3VyIGNoYW5jZSB0byBkZXZlbG9wIHlvdXIgcGhvdG9ncmFwaHMh"
+    },
+    {   "Dark rooms are not *completely* dark: just wait and let your eyes adjust...",
+        "RGFyayByb29tcyBhcmUgbm90ICpjb21wbGV0ZWx5KiBkYXJrOiBqdXN0IHdhaXQgYW5kIGxldCB5b3VyIGV5ZXMgYWRqdXN0Li4u"
+    },
+    {   "David London sez, \"Hey guys, *WIELD* a lizard corpse against a cockatrice!\"",
+        "RGF2aWQgTG9uZG9uIHNleiwgIkhleSBndXlzLCAqV0lFTEQqIGEgbGl6YXJkIGNvcnBzZSBhZ2FpbnN0IGEgY29ja2F0cmljZSEi"
+    },
+    {   "Death is just life's way of telling you you've been fired.",
+        "RGVhdGggaXMganVzdCBsaWZlJ3Mgd2F5IG9mIHRlbGxpbmcgeW91IHlvdSd2ZSBiZWVuIGZpcmVkLg=="
+    },
+    {   "Demi-gods don't need any help from the gods.",
+        "RGVtaS1nb2RzIGRvbid0IG5lZWQgYW55IGhlbHAgZnJvbSB0aGUgZ29kcy4="
+    },
+    {   "Demons *HATE* Priests and Priestesses.",
+        "RGVtb25zICpIQVRFKiBQcmllc3RzIGFuZCBQcmllc3Rlc3Nlcy4="
+    },
+    {   "Didn't you forget to pay?",
+        "RGlkbid0IHlvdSBmb3JnZXQgdG8gcGF5Pw=="
+    },
+    {   "Didn't your mother tell you not to eat food off the floor?",
+        "RGlkbid0IHlvdXIgbW90aGVyIHRlbGwgeW91IG5vdCB0byBlYXQgZm9vZCBvZmYgdGhlIGZsb29yPw=="
+    },
+    {   "Direct a direct hit on your direct opponent, directing in the right direction.",
+        "RGlyZWN0IGEgZGlyZWN0IGhpdCBvbiB5b3VyIGRpcmVjdCBvcHBvbmVudCwgZGlyZWN0aW5nIGluIHRoZSByaWdodCBkaXJlY3Rpb24u"
+    },
+    {   "Do you want to make more money? Sure, we all do! Join the Fort Ludios guard!",
+        "RG8geW91IHdhbnQgdG8gbWFrZSBtb3JlIG1vbmV5PyBTdXJlLCB3ZSBhbGwgZG8hIEpvaW4gdGhlIEZvcnQgTHVkaW9zIGd1YXJkIQ=="
+    },
+    {   "Don't eat too much: you might start hiccoughing!",
+        "RG9uJ3QgZWF0IHRvbyBtdWNoOiB5b3UgbWlnaHQgc3RhcnQgaGljY291Z2hpbmch"
+    },
+    {   "Don't play hack at your work; your boss might hit you!",
+        "RG9uJ3QgcGxheSBoYWNrIGF0IHlvdXIgd29yazsgeW91ciBib3NzIG1pZ2h0IGhpdCB5b3Uh"
+    },
+    {   "Don't tell a soul you found a secret door, otherwise it isn't a secret anymore.",
+        "RG9uJ3QgdGVsbCBhIHNvdWwgeW91IGZvdW5kIGEgc2VjcmV0IGRvb3IsIG90aGVyd2lzZSBpdCBpc24ndCBhIHNlY3JldCBhbnltb3JlLg=="
+    },
+    {   "Drinking potions of booze may land you in jail if you are under 21.",
+        "RHJpbmtpbmcgcG90aW9ucyBvZiBib296ZSBtYXkgbGFuZCB5b3UgaW4gamFpbCBpZiB5b3UgYXJlIHVuZGVyIDIxLg=="
+    },
+    {   "Drop your vanity and get rid of your jewels! Pickpockets about!",
+        "RHJvcCB5b3VyIHZhbml0eSBhbmQgZ2V0IHJpZCBvZiB5b3VyIGpld2VscyEgUGlja3BvY2tldHMgYWJvdXQh"
+    },
+    {   "Eat 10 cloves of garlic and keep all humans at a two-square distance.",
+        "RWF0IDEwIGNsb3ZlcyBvZiBnYXJsaWMgYW5kIGtlZXAgYWxsIGh1bWFucyBhdCBhIHR3by1zcXVhcmUgZGlzdGFuY2Uu"
+    },
+    {   "Eels hide under mud. Use a unicorn to clear the water and make them visible.",
+        "RWVscyBoaWRlIHVuZGVyIG11ZC4gVXNlIGEgdW5pY29ybiB0byBjbGVhciB0aGUgd2F0ZXIgYW5kIG1ha2UgdGhlbSB2aXNpYmxlLg=="
+    },
+    {   "Engrave your wishes with a wand of wishing.",
+        "RW5ncmF2ZSB5b3VyIHdpc2hlcyB3aXRoIGEgd2FuZCBvZiB3aXNoaW5nLg=="
+    },
+    {   "Eventually you will come to admire the swift elegance of a retreating nymph.",
+        "RXZlbnR1YWxseSB5b3Ugd2lsbCBjb21lIHRvIGFkbWlyZSB0aGUgc3dpZnQgZWxlZ2FuY2Ugb2YgYSByZXRyZWF0aW5nIG55bXBoLg=="
+    },
+    {   "Ever heard hissing outside? I *knew* you hadn't!",
+        "RXZlciBoZWFyZCBoaXNzaW5nIG91dHNpZGU/IEkgKmtuZXcqIHlvdSBoYWRuJ3Qh"
+    },
+    {   "Ever lifted a dragon corpse?",
+        "RXZlciBsaWZ0ZWQgYSBkcmFnb24gY29ycHNlPw=="
+    },
+    {   "Ever seen a leocrotta dancing the tengu?",
+        "RXZlciBzZWVuIGEgbGVvY3JvdHRhIGRhbmNpbmcgdGhlIHRlbmd1Pw=="
+    },
+    {   "Ever seen your weapon glow plaid?",
+        "RXZlciBzZWVuIHlvdXIgd2VhcG9uIGdsb3cgcGxhaWQ/"
+    },
+    {   "Ever tamed a shopkeeper?",
+        "RXZlciB0YW1lZCBhIHNob3BrZWVwZXI/"
+    },
+    {   "Ever tried digging through a Vault Guard?",
+        "RXZlciB0cmllZCBkaWdnaW5nIHRocm91Z2ggYSBWYXVsdCBHdWFyZD8="
+    },
+    {   "Ever tried enchanting a rope?",
+        "RXZlciB0cmllZCBlbmNoYW50aW5nIGEgcm9wZT8="
+    },
+    {   "Floating eyes can't stand Hawaiian shirts.",
+        "RmxvYXRpbmcgZXllcyBjYW4ndCBzdGFuZCBIYXdhaWlhbiBzaGlydHMu"
+    },
+    {   "For any remedy there is a misery.",
+        "Rm9yIGFueSByZW1lZHkgdGhlcmUgaXMgYSBtaXNlcnku"
+    },
+    {   "Giant bats turn into giant vampires.",
+        "R2lhbnQgYmF0cyB0dXJuIGludG8gZ2lhbnQgdmFtcGlyZXMu"
+    },
+    {   "Good day for overcoming obstacles. Try a steeplechase.",
+        "R29vZCBkYXkgZm9yIG92ZXJjb21pbmcgb2JzdGFjbGVzLiBUcnkgYSBzdGVlcGxlY2hhc2Uu"
+    },
+    {   "Half Moon tonight. (At least it's better than no Moon at all.)",
+        "SGFsZiBNb29uIHRvbmlnaHQuIChBdCBsZWFzdCBpdCdzIGJldHRlciB0aGFuIG5vIE1vb24gYXQgYWxsLik="
+    },
+    {   "Help! I'm being held prisoner in a fortune cookie factory!",
+        "SGVscCEgSSdtIGJlaW5nIGhlbGQgcHJpc29uZXIgaW4gYSBmb3J0dW5lIGNvb2tpZSBmYWN0b3J5IQ=="
+    },
+    {   "Housecats have nine lives, kittens only one.",
+        "SG91c2VjYXRzIGhhdmUgbmluZSBsaXZlcywga2l0dGVucyBvbmx5IG9uZS4="
+    },
+    {   "How long can you tread water?",
+        "SG93IGxvbmcgY2FuIHlvdSB0cmVhZCB3YXRlcj8="
+    },
+    {   "Hungry? There is an abundance of food on the next level.",
+        "SHVuZ3J5PyBUaGVyZSBpcyBhbiBhYnVuZGFuY2Ugb2YgZm9vZCBvbiB0aGUgbmV4dCBsZXZlbC4="
+    },
+    {   "I guess you've never hit a mail daemon with the Amulet of Yendor...",
+        "SSBndWVzcyB5b3UndmUgbmV2ZXIgaGl0IGEgbWFpbCBkYWVtb24gd2l0aCB0aGUgQW11bGV0IG9mIFllbmRvci4uLg=="
+    },
+    {   "If you are the shopkeeper, you can take things for free.",
+        "SWYgeW91IGFyZSB0aGUgc2hvcGtlZXBlciwgeW91IGNhbiB0YWtlIHRoaW5ncyBmb3IgZnJlZS4="
+    },
+    {   "If you can't learn to do it well, learn to enjoy doing it badly.",
+        "SWYgeW91IGNhbid0IGxlYXJuIHRvIGRvIGl0IHdlbGwsIGxlYXJuIHRvIGVuam95IGRvaW5nIGl0IGJhZGx5Lg=="
+    },
+    {   "If you thought the Wizard was bad, just wait till you meet the Warlord!",
+        "SWYgeW91IHRob3VnaHQgdGhlIFdpemFyZCB3YXMgYmFkLCBqdXN0IHdhaXQgdGlsbCB5b3UgbWVldCB0aGUgV2FybG9yZCE="
+    },
+    {   "If you turn blind, don't expect your dog to be turned into a seeing-eye dog.",
+        "SWYgeW91IHR1cm4gYmxpbmQsIGRvbid0IGV4cGVjdCB5b3VyIGRvZyB0byBiZSB0dXJuZWQgaW50byBhIHNlZWluZy1leWUgZG9nLg=="
+    },
+    {   "If you want to feel great, you must eat something real big.",
+        "SWYgeW91IHdhbnQgdG8gZmVlbCBncmVhdCwgeW91IG11c3QgZWF0IHNvbWV0aGluZyByZWFsIGJpZy4="
+    },
+    {   "If you want to float, you'd better eat a floating eye.",
+        "SWYgeW91IHdhbnQgdG8gZmxvYXQsIHlvdSdkIGJldHRlciBlYXQgYSBmbG9hdGluZyBleWUu"
+    },
+    {   "If your ghost kills a player, it increases your score.",
+        "SWYgeW91ciBnaG9zdCBraWxscyBhIHBsYXllciwgaXQgaW5jcmVhc2VzIHlvdXIgc2NvcmUu"
+    },
+    {   "Increase mindpower: Tame your own ghost!",
+        "SW5jcmVhc2UgbWluZHBvd2VyOiBUYW1lIHlvdXIgb3duIGdob3N0IQ=="
+    },
+    {   "It furthers one to see the great man.",
+        "SXQgZnVydGhlcnMgb25lIHRvIHNlZSB0aGUgZ3JlYXQgbWFuLg=="
+    },
+    {   "It's easy to overlook a monster in a wood.",
+        "SXQncyBlYXN5IHRvIG92ZXJsb29rIGEgbW9uc3RlciBpbiBhIHdvb2Qu"
+    },
+    {   "Just below any trapdoor there may be another one. Just keep falling!",
+        "SnVzdCBiZWxvdyBhbnkgdHJhcGRvb3IgdGhlcmUgbWF5IGJlIGFub3RoZXIgb25lLiBKdXN0IGtlZXAgZmFsbGluZyE="
+    },
+    {   "Katanas are very sharp; watch you don't cut yourself.",
+        "S2F0YW5hcyBhcmUgdmVyeSBzaGFycDsgd2F0Y2ggeW91IGRvbid0IGN1dCB5b3Vyc2VsZi4="
+    },
+    {   "Keep a clear mind: quaff clear potions.",
+        "S2VlcCBhIGNsZWFyIG1pbmQ6IHF1YWZmIGNsZWFyIHBvdGlvbnMu"
+    },
+    {   "Kicking the terminal doesn't hurt the monsters.",
+        "S2lja2luZyB0aGUgdGVybWluYWwgZG9lc24ndCBodXJ0IHRoZSBtb25zdGVycy4="
+    },
+    {   "Killer bees keep appearing till you kill their queen.",
+        "S2lsbGVyIGJlZXMga2VlcCBhcHBlYXJpbmcgdGlsbCB5b3Uga2lsbCB0aGVpciBxdWVlbi4="
+    },
+    {   "Killer bunnies can be tamed with carrots only.",
+        "S2lsbGVyIGJ1bm5pZXMgY2FuIGJlIHRhbWVkIHdpdGggY2Fycm90cyBvbmx5Lg=="
+    },
+    {   "Latest news? Put `rec.games.roguelike.nethack' in your .newsrc!",
+        "TGF0ZXN0IG5ld3M/IFB1dCBgcmVjLmdhbWVzLnJvZ3VlbGlrZS5uZXRoYWNrJyBpbiB5b3VyIC5uZXdzcmMh"
+    },
+    {   "Learn how to spell. Play NetHack!",
+        "TGVhcm4gaG93IHRvIHNwZWxsLiBQbGF5IE5ldEhhY2sh"
+    },
+    {   "Leprechauns hide their gold in a secret room.",
+        "TGVwcmVjaGF1bnMgaGlkZSB0aGVpciBnb2xkIGluIGEgc2VjcmV0IHJvb20u"
+    },
+    {   "Let your fingers do the walking on the yulkjhnb keys.",
+        "TGV0IHlvdXIgZmluZ2VycyBkbyB0aGUgd2Fsa2luZyBvbiB0aGUgeXVsa2pobmIga2V5cy4="
+    },
+    {   "Let's face it: this time you're not going to win.",
+        "TGV0J3MgZmFjZSBpdDogdGhpcyB0aW1lIHlvdSdyZSBub3QgZ29pbmcgdG8gd2luLg=="
+    },
+    {   "Let's have a party, drink a lot of booze.",
+        "TGV0J3MgaGF2ZSBhIHBhcnR5LCBkcmluayBhIGxvdCBvZiBib296ZS4="
+    },
+    {   "Liquor sellers do not drink; they hate to see you twice.",
+        "TGlxdW9yIHNlbGxlcnMgZG8gbm90IGRyaW5rOyB0aGV5IGhhdGUgdG8gc2VlIHlvdSB0d2ljZS4="
+    },
+    {   "Lunar eclipse tonight. May as well quit now!",
+        "THVuYXIgZWNsaXBzZSB0b25pZ2h0LiBNYXkgYXMgd2VsbCBxdWl0IG5vdyE="
+    },
+    {   "Meeting your own ghost decreases your luck considerably!",
+        "TWVldGluZyB5b3VyIG93biBnaG9zdCBkZWNyZWFzZXMgeW91ciBsdWNrIGNvbnNpZGVyYWJseSE="
+    },
+    {   "Money to invest? Take it to the local branch of the Magic Memory Vault!",
+        "TW9uZXkgdG8gaW52ZXN0PyBUYWtlIGl0IHRvIHRoZSBsb2NhbCBicmFuY2ggb2YgdGhlIE1hZ2ljIE1lbW9yeSBWYXVsdCE="
+    },
+    {   "Monsters come from nowhere to hit you everywhere.",
+        "TW9uc3RlcnMgY29tZSBmcm9tIG5vd2hlcmUgdG8gaGl0IHlvdSBldmVyeXdoZXJlLg=="
+    },
+    {   "Monsters sleep because you are boring, not because they ever get tired.",
+        "TW9uc3RlcnMgc2xlZXAgYmVjYXVzZSB5b3UgYXJlIGJvcmluZywgbm90IGJlY2F1c2UgdGhleSBldmVyIGdldCB0aXJlZC4="
+    },
+    {   "Most monsters prefer minced meat. That's why they are hitting you!",
+        "TW9zdCBtb25zdGVycyBwcmVmZXIgbWluY2VkIG1lYXQuIFRoYXQncyB3aHkgdGhleSBhcmUgaGl0dGluZyB5b3Uh"
+    },
+    {   "Most of the bugs in NetHack are on the floor.",
+        "TW9zdCBvZiB0aGUgYnVncyBpbiBOZXRIYWNrIGFyZSBvbiB0aGUgZmxvb3Iu"
+    },
+    {   "Much ado Nothing Happens.",
+        "TXVjaCBhZG8gTm90aGluZyBIYXBwZW5zLg=="
+    },
+    {   "Multi-player NetHack is a myth.",
+        "TXVsdGktcGxheWVyIE5ldEhhY2sgaXMgYSBteXRoLg=="
+    },
+    {   "NetHack is addictive. Too late, you're already hooked.",
+        "TmV0SGFjayBpcyBhZGRpY3RpdmUuIFRvbyBsYXRlLCB5b3UncmUgYWxyZWFkeSBob29rZWQu"
+    },
+    {   "Never ask a shopkeeper for a price list.",
+        "TmV2ZXIgYXNrIGEgc2hvcGtlZXBlciBmb3IgYSBwcmljZSBsaXN0Lg=="
+    },
+    {   "Never burn a tree, unless you like getting whacked with a +5 shovel.",
+        "TmV2ZXIgYnVybiBhIHRyZWUsIHVubGVzcyB5b3UgbGlrZSBnZXR0aW5nIHdoYWNrZWQgd2l0aCBhICs1IHNob3ZlbC4="
+    },
+    {   "Never eat with glowing hands!",
+        "TmV2ZXIgZWF0IHdpdGggZ2xvd2luZyBoYW5kcyE="
+    },
+    {   "Never mind the monsters hitting you: they just replace the charwomen.",
+        "TmV2ZXIgbWluZCB0aGUgbW9uc3RlcnMgaGl0dGluZyB5b3U6IHRoZXkganVzdCByZXBsYWNlIHRoZSBjaGFyd29tZW4u"
+    },
+    {   "Never play leapfrog with a unicorn.",
+        "TmV2ZXIgcGxheSBsZWFwZnJvZyB3aXRoIGEgdW5pY29ybi4="
+    },
+    {   "Never step on a cursed engraving.",
+        "TmV2ZXIgc3RlcCBvbiBhIGN1cnNlZCBlbmdyYXZpbmcu"
+    },
+    {   "Never swim with a camera: there's nothing to take pictures of.",
+        "TmV2ZXIgc3dpbSB3aXRoIGEgY2FtZXJhOiB0aGVyZSdzIG5vdGhpbmcgdG8gdGFrZSBwaWN0dXJlcyBvZi4="
+    },
+    {   "Never teach your pet rust monster to fetch.",
+        "TmV2ZXIgdGVhY2ggeW91ciBwZXQgcnVzdCBtb25zdGVyIHRvIGZldGNoLg=="
+    },
+    {   "Never trust a random generator in magic fields.",
+        "TmV2ZXIgdHJ1c3QgYSByYW5kb20gZ2VuZXJhdG9yIGluIG1hZ2ljIGZpZWxkcy4="
+    },
+    {   "Never use a wand of death.",
+        "TmV2ZXIgdXNlIGEgd2FuZCBvZiBkZWF0aC4="
+    },
+    {   "No level contains two shops. The maze is no level. So...",
+        "Tm8gbGV2ZWwgY29udGFpbnMgdHdvIHNob3BzLiBUaGUgbWF6ZSBpcyBubyBsZXZlbC4gU28uLi4="
+    },
+    {   "No part of this fortune may be reproduced, stored in a retrieval system, ...",
+        "Tm8gcGFydCBvZiB0aGlzIGZvcnR1bmUgbWF5IGJlIHJlcHJvZHVjZWQsIHN0b3JlZCBpbiBhIHJldHJpZXZhbCBzeXN0ZW0sIC4uLg=="
+    },
+    {   "Not all rumors are as misleading as this one.",
+        "Tm90IGFsbCBydW1vcnMgYXJlIGFzIG1pc2xlYWRpbmcgYXMgdGhpcyBvbmUu"
+    },
+    {   "Nymphs and nurses like beautiful rings.",
+        "TnltcGhzIGFuZCBudXJzZXMgbGlrZSBiZWF1dGlmdWwgcmluZ3Mu"
+    },
+    {   "Nymphs are blondes. Are you a gentleman?",
+        "TnltcGhzIGFyZSBibG9uZGVzLiBBcmUgeW91IGEgZ2VudGxlbWFuPw=="
+    },
+    {   "Offering a unicorn a worthless piece of glass might prove to be fatal!",
+        "T2ZmZXJpbmcgYSB1bmljb3JuIGEgd29ydGhsZXNzIHBpZWNlIG9mIGdsYXNzIG1pZ2h0IHByb3ZlIHRvIGJlIGZhdGFsIQ=="
+    },
+    {   "Old hackers never die: young ones do.",
+        "T2xkIGhhY2tlcnMgbmV2ZXIgZGllOiB5b3VuZyBvbmVzIGRvLg=="
+    },
+    {   "One has to leave shops before closing time.",
+        "T25lIGhhcyB0byBsZWF2ZSBzaG9wcyBiZWZvcmUgY2xvc2luZyB0aW1lLg=="
+    },
+    {   "One homunculus a day keeps the doctor away.",
+        "T25lIGhvbXVuY3VsdXMgYSBkYXkga2VlcHMgdGhlIGRvY3RvciBhd2F5Lg=="
+    },
+    {   "One level further down somebody is getting killed, right now.",
+        "T25lIGxldmVsIGZ1cnRoZXIgZG93biBzb21lYm9keSBpcyBnZXR0aW5nIGtpbGxlZCwgcmlnaHQgbm93Lg=="
+    },
+    {   "Only a wizard can use a magic whistle.",
+        "T25seSBhIHdpemFyZCBjYW4gdXNlIGEgbWFnaWMgd2hpc3RsZS4="
+    },
+    {   "Only adventurers of evil alignment think of killing their dog.",
+        "T25seSBhZHZlbnR1cmVycyBvZiBldmlsIGFsaWdubWVudCB0aGluayBvZiBraWxsaW5nIHRoZWlyIGRvZy4="
+    },
+    {   "Only chaotic evils kill sleeping monsters.",
+        "T25seSBjaGFvdGljIGV2aWxzIGtpbGwgc2xlZXBpbmcgbW9uc3RlcnMu"
+    },
+    {   "Only real trappers escape traps.",
+        "T25seSByZWFsIHRyYXBwZXJzIGVzY2FwZSB0cmFwcy4="
+    },
+    {   "Only real wizards can write scrolls.",
+        "T25seSByZWFsIHdpemFyZHMgY2FuIHdyaXRlIHNjcm9sbHMu"
+    },
+    {   "Operation OVERKILL has started now.",
+        "T3BlcmF0aW9uIE9WRVJLSUxMIGhhcyBzdGFydGVkIG5vdy4="
+    },
+    {   "PLEASE ignore previous rumor.",
+        "UExFQVNFIGlnbm9yZSBwcmV2aW91cyBydW1vci4="
+    },
+    {   "Polymorph into an ettin; meet your opponents face to face to face.",
+        "UG9seW1vcnBoIGludG8gYW4gZXR0aW47IG1lZXQgeW91ciBvcHBvbmVudHMgZmFjZSB0byBmYWNlIHRvIGZhY2Uu"
+    },
+    {   "Praying will frighten demons.",
+        "UHJheWluZyB3aWxsIGZyaWdodGVuIGRlbW9ucy4="
+    },
+    {   "Row (3x) that boat gently down the stream, Charon (4x), death is but a dream.",
+        "Um93ICgzeCkgdGhhdCBib2F0IGdlbnRseSBkb3duIHRoZSBzdHJlYW0sIENoYXJvbiAoNHgpLCBkZWF0aCBpcyBidXQgYSBkcmVhbS4="
+    },
+    {   "Running is good for your legs.",
+        "UnVubmluZyBpcyBnb29kIGZvciB5b3VyIGxlZ3Mu"
+    },
+    {   "Screw up your courage! You've screwed up everything else.",
+        "U2NyZXcgdXAgeW91ciBjb3VyYWdlISBZb3UndmUgc2NyZXdlZCB1cCBldmVyeXRoaW5nIGVsc2Uu"
+    },
+    {   "Seepage? Leaky pipes? Rising damp? Summon the plumber!",
+        "U2VlcGFnZT8gTGVha3kgcGlwZXM/IFJpc2luZyBkYW1wPyBTdW1tb24gdGhlIHBsdW1iZXIh"
+    },
+    {   "Segmentation fault (core dumped).",
+        "U2VnbWVudGF0aW9uIGZhdWx0IChjb3JlIGR1bXBlZCku"
+    },
+    {   "Shopkeepers sometimes die from old age.",
+        "U2hvcGtlZXBlcnMgc29tZXRpbWVzIGRpZSBmcm9tIG9sZCBhZ2Uu"
+    },
+    {   "Some mazes (especially small ones) have no solutions, says man 6 maze.",
+        "U29tZSBtYXplcyAoZXNwZWNpYWxseSBzbWFsbCBvbmVzKSBoYXZlIG5vIHNvbHV0aW9ucywgc2F5cyBtYW4gNiBtYXplLg=="
+    },
+    {   "Some questions the Sphynx asks just *don't* have any answers.",
+        "U29tZSBxdWVzdGlvbnMgdGhlIFNwaHlueCBhc2tzIGp1c3QgKmRvbid0KiBoYXZlIGFueSBhbnN3ZXJzLg=="
+    },
+    {   "Sometimes \"mu\" is the answer.",
+        "U29tZXRpbWVzICJtdSIgaXMgdGhlIGFuc3dlci4="
+    },
+    {   "Sorry, no fortune this time. Better luck next cookie!",
+        "U29ycnksIG5vIGZvcnR1bmUgdGhpcyB0aW1lLiBCZXR0ZXIgbHVjayBuZXh0IGNvb2tpZSE="
+    },
+    {   "Spare your scrolls of make-edible until it's really necessary!",
+        "U3BhcmUgeW91ciBzY3JvbGxzIG9mIG1ha2UtZWRpYmxlIHVudGlsIGl0J3MgcmVhbGx5IG5lY2Vzc2FyeSE="
+    },
+    {   "Suddenly, the dungeon will collapse...",
+        "U3VkZGVubHksIHRoZSBkdW5nZW9uIHdpbGwgY29sbGFwc2UuLi4="
+    },
+    {   "Taming a mail daemon may cause a system security violation.",
+        "VGFtaW5nIGEgbWFpbCBkYWVtb24gbWF5IGNhdXNlIGEgc3lzdGVtIHNlY3VyaXR5IHZpb2xhdGlvbi4="
+    },
+    {   "The crowd was so tough, the Stooges won't play the Dungeon anymore, nyuk nyuk.",
+        "VGhlIGNyb3dkIHdhcyBzbyB0b3VnaCwgdGhlIFN0b29nZXMgd29uJ3QgcGxheSB0aGUgRHVuZ2VvbiBhbnltb3JlLCBueXVrIG55dWsu"
+    },
+    {   "The leprechauns hide their treasure in a small hidden room.",
+        "VGhlIGxlcHJlY2hhdW5zIGhpZGUgdGhlaXIgdHJlYXN1cmUgaW4gYSBzbWFsbCBoaWRkZW4gcm9vbS4="
+    },
+    {   "The longer the wand the better.",
+        "VGhlIGxvbmdlciB0aGUgd2FuZCB0aGUgYmV0dGVyLg=="
+    },
+    {   "The magic word is \"XYZZY\".",
+        "VGhlIG1hZ2ljIHdvcmQgaXMgIlhZWlpZIi4="
+    },
+    {   "The meek shall inherit your bones files.",
+        "VGhlIG1lZWsgc2hhbGwgaW5oZXJpdCB5b3VyIGJvbmVzIGZpbGVzLg=="
+    },
+    {   "The mines are dark and deep, and I have levels to go before I sleep.",
+        "VGhlIG1pbmVzIGFyZSBkYXJrIGFuZCBkZWVwLCBhbmQgSSBoYXZlIGxldmVscyB0byBnbyBiZWZvcmUgSSBzbGVlcC4="
+    },
+    {   "The use of dynamite is dangerous.",
+        "VGhlIHVzZSBvZiBkeW5hbWl0ZSBpcyBkYW5nZXJvdXMu"
+    },
+    {   "There are no worms in the UNIX version.",
+        "VGhlcmUgYXJlIG5v