Bug 1581890 - formatted code with artistic style utility. r=glandium
authorKai Engert <kaie@kuix.de>
Tue, 24 Sep 2019 00:53:06 +0000
changeset 4836 b2e285dc48be27713b3c648de3cf33f8637a3e94
parent 4835 753c7baeb58d34bb93f6bdcdd49f8e74bc32ee41
child 4837 06272844133b5c8ccb535391e1a1a7a40d98d86c
push id335
push userkaie@kuix.de
push dateTue, 24 Sep 2019 09:52:51 +0000
reviewersglandium
bugs1581890
Bug 1581890 - formatted code with artistic style utility. r=glandium Differential Revision: https://phabricator.services.mozilla.com/D46204
config/nsinstall.c
lib/ds/plarena.c
lib/ds/plhash.c
lib/ds/plvrsion.c
lib/libc/include/plgetopt.h
lib/libc/src/plerror.c
lib/libc/src/plgetopt.c
lib/libc/src/plvrsion.c
lib/libc/src/strcase.c
lib/libc/src/strcat.c
lib/libc/src/strchr.c
lib/libc/src/strcmp.c
lib/libc/src/strcpy.c
lib/libc/src/strdup.c
lib/libc/src/strlen.c
lib/libc/src/strpbrk.c
lib/libc/src/strstr.c
lib/libc/src/strtok.c
lib/prstreams/plvrsion.c
lib/prstreams/prstrms.cpp
lib/prstreams/prstrms.h
lib/prstreams/tests/testprstrm/testprstrm.cpp
lib/tests/arena.c
lib/tests/base64t.c
lib/tests/getopt.c
lib/tests/string.c
pr/include/gencfg.c
pr/include/md/_aix.h
pr/include/md/_bsdi.h
pr/include/md/_darwin.h
pr/include/md/_freebsd.h
pr/include/md/_hpux.h
pr/include/md/_linux.h
pr/include/md/_netbsd.h
pr/include/md/_nspr_pthread.h
pr/include/md/_nto.h
pr/include/md/_openbsd.h
pr/include/md/_os2.h
pr/include/md/_os2_errors.h
pr/include/md/_pcos.h
pr/include/md/_pth.h
pr/include/md/_qnx.h
pr/include/md/_riscos.h
pr/include/md/_scoos.h
pr/include/md/_solaris.h
pr/include/md/_unix_errors.h
pr/include/md/_unixos.h
pr/include/md/_unixware.h
pr/include/md/_win32_errors.h
pr/include/md/_win95.h
pr/include/md/_winnt.h
pr/include/obsolete/pralarm.h
pr/include/obsolete/protypes.h
pr/include/pratom.h
pr/include/prbit.h
pr/include/prclist.h
pr/include/prcountr.h
pr/include/prcvar.h
pr/include/prdtoa.h
pr/include/prerror.h
pr/include/prinet.h
pr/include/prinit.h
pr/include/prinrval.h
pr/include/prio.h
pr/include/private/pprio.h
pr/include/private/pprthred.h
pr/include/private/primpl.h
pr/include/prlink.h
pr/include/prlock.h
pr/include/prlog.h
pr/include/prmem.h
pr/include/prnetdb.h
pr/include/prolock.h
pr/include/prpdce.h
pr/include/prprf.h
pr/include/prrwlock.h
pr/include/prshm.h
pr/include/prthread.h
pr/include/prtime.h
pr/include/prtpool.h
pr/include/prtrace.h
pr/include/prtypes.h
pr/include/prwin16.h
pr/src/cplus/rcbase.cpp
pr/src/cplus/rcbase.h
pr/src/cplus/rccv.cpp
pr/src/cplus/rccv.h
pr/src/cplus/rcfileio.cpp
pr/src/cplus/rcfileio.h
pr/src/cplus/rcinrval.cpp
pr/src/cplus/rcinrval.h
pr/src/cplus/rcio.h
pr/src/cplus/rclock.cpp
pr/src/cplus/rclock.h
pr/src/cplus/rcnetdb.cpp
pr/src/cplus/rcnetdb.h
pr/src/cplus/rcnetio.cpp
pr/src/cplus/rcnetio.h
pr/src/cplus/rcthread.cpp
pr/src/cplus/rcthread.h
pr/src/cplus/rctime.cpp
pr/src/cplus/rctime.h
pr/src/cplus/tests/ranfile.cpp
pr/src/cplus/tests/switch.cpp
pr/src/cplus/tests/thread.cpp
pr/src/cplus/tests/tpd.cpp
pr/src/io/prdir.c
pr/src/io/prfdcach.c
pr/src/io/prfile.c
pr/src/io/prio.c
pr/src/io/priometh.c
pr/src/io/pripv6.c
pr/src/io/prlayer.c
pr/src/io/prlog.c
pr/src/io/prmapopt.c
pr/src/io/prmmap.c
pr/src/io/prmwait.c
pr/src/io/prpolevt.c
pr/src/io/prprf.c
pr/src/io/prscanf.c
pr/src/io/prsocket.c
pr/src/linking/prlink.c
pr/src/malloc/prmalloc.c
pr/src/malloc/prmem.c
pr/src/md/os2/os2_errors.c
pr/src/md/os2/os2cv.c
pr/src/md/os2/os2inrval.c
pr/src/md/os2/os2io.c
pr/src/md/os2/os2misc.c
pr/src/md/os2/os2poll.c
pr/src/md/os2/os2rng.c
pr/src/md/os2/os2sem.c
pr/src/md/os2/os2sock.c
pr/src/md/os2/os2thred.c
pr/src/md/prosdep.c
pr/src/md/unix/aix.c
pr/src/md/unix/aixwrap.c
pr/src/md/unix/bsdi.c
pr/src/md/unix/darwin.c
pr/src/md/unix/freebsd.c
pr/src/md/unix/hpux.c
pr/src/md/unix/linux.c
pr/src/md/unix/nto.c
pr/src/md/unix/pthreads_user.c
pr/src/md/unix/qnx.c
pr/src/md/unix/riscos.c
pr/src/md/unix/scoos.c
pr/src/md/unix/solaris.c
pr/src/md/unix/unix.c
pr/src/md/unix/unix_errors.c
pr/src/md/unix/unixware.c
pr/src/md/unix/uxpoll.c
pr/src/md/unix/uxproces.c
pr/src/md/unix/uxrng.c
pr/src/md/unix/uxshm.c
pr/src/md/unix/uxwrap.c
pr/src/md/windows/ntdllmn.c
pr/src/md/windows/ntinrval.c
pr/src/md/windows/ntio.c
pr/src/md/windows/ntmisc.c
pr/src/md/windows/ntsec.c
pr/src/md/windows/ntsem.c
pr/src/md/windows/ntthread.c
pr/src/md/windows/w32ipcsem.c
pr/src/md/windows/w32poll.c
pr/src/md/windows/w32rng.c
pr/src/md/windows/w32shm.c
pr/src/md/windows/w95cv.c
pr/src/md/windows/w95dllmain.c
pr/src/md/windows/w95io.c
pr/src/md/windows/w95sock.c
pr/src/md/windows/w95thred.c
pr/src/memory/prseg.c
pr/src/memory/prshm.c
pr/src/misc/dtoa.c
pr/src/misc/pralarm.c
pr/src/misc/pratom.c
pr/src/misc/praton.c
pr/src/misc/prcountr.c
pr/src/misc/prdtoa.c
pr/src/misc/prenv.c
pr/src/misc/prerr.c
pr/src/misc/prerror.c
pr/src/misc/prerrortable.c
pr/src/misc/prinit.c
pr/src/misc/prinrval.c
pr/src/misc/pripcsem.c
pr/src/misc/prlong.c
pr/src/misc/prnetdb.c
pr/src/misc/prolock.c
pr/src/misc/prrng.c
pr/src/misc/prsystem.c
pr/src/misc/prthinfo.c
pr/src/misc/prtime.c
pr/src/misc/prtpool.c
pr/src/misc/prtrace.c
pr/src/prvrsion.c
pr/src/pthreads/ptio.c
pr/src/pthreads/ptmisc.c
pr/src/pthreads/ptsynch.c
pr/src/pthreads/ptthread.c
pr/src/threads/combined/prucpu.c
pr/src/threads/combined/prucv.c
pr/src/threads/combined/prulock.c
pr/src/threads/combined/prustack.c
pr/src/threads/combined/pruthr.c
pr/src/threads/prcmon.c
pr/src/threads/prcthr.c
pr/src/threads/prdump.c
pr/src/threads/prmon.c
pr/src/threads/prrwlock.c
pr/src/threads/prsem.c
pr/src/threads/prtpd.c
pr/tests/abstract.c
pr/tests/accept.c
pr/tests/acceptread.c
pr/tests/acceptreademu.c
pr/tests/addrstr.c
pr/tests/affinity.c
pr/tests/alarm.c
pr/tests/anonfm.c
pr/tests/append.c
pr/tests/attach.c
pr/tests/bigfile.c
pr/tests/bigfile2.c
pr/tests/bigfile3.c
pr/tests/bug1test.c
pr/tests/cleanup.c
pr/tests/cltsrv.c
pr/tests/concur.c
pr/tests/cvar.c
pr/tests/cvar2.c
pr/tests/dbmalloc.c
pr/tests/dbmalloc1.c
pr/tests/dceemu.c
pr/tests/depend.c
pr/tests/dlltest.c
pr/tests/dtoa.c
pr/tests/env.c
pr/tests/errcodes.c
pr/tests/errset.c
pr/tests/exit.c
pr/tests/fileio.c
pr/tests/foreign.c
pr/tests/forktest.c
pr/tests/formattm.c
pr/tests/freeif.c
pr/tests/fsync.c
pr/tests/getai.c
pr/tests/gethost.c
pr/tests/getproto.c
pr/tests/i2l.c
pr/tests/initclk.c
pr/tests/inrval.c
pr/tests/instrumt.c
pr/tests/intrio.c
pr/tests/intrupt.c
pr/tests/io_timeout.c
pr/tests/io_timeoutk.c
pr/tests/io_timeoutu.c
pr/tests/ioconthr.c
pr/tests/ipv6.c
pr/tests/join.c
pr/tests/joinkk.c
pr/tests/joinku.c
pr/tests/joinuk.c
pr/tests/joinuu.c
pr/tests/layer.c
pr/tests/lazyinit.c
pr/tests/libfilename.c
pr/tests/lltest.c
pr/tests/lock.c
pr/tests/lockfile.c
pr/tests/logger.c
pr/tests/many_cv.c
pr/tests/mbcs.c
pr/tests/multiacc.c
pr/tests/multiwait.c
pr/tests/nameshm1.c
pr/tests/nbconn.c
pr/tests/nblayer.c
pr/tests/nonblock.c
pr/tests/ntioto.c
pr/tests/ntoh.c
pr/tests/op_2long.c
pr/tests/op_excl.c
pr/tests/op_filnf.c
pr/tests/op_filok.c
pr/tests/op_nofil.c
pr/tests/parent.c
pr/tests/parsetm.c
pr/tests/peek.c
pr/tests/perf.c
pr/tests/pipeself.c
pr/tests/poll_er.c
pr/tests/poll_nm.c
pr/tests/poll_to.c
pr/tests/pollable.c
pr/tests/prftest.c
pr/tests/prftest1.c
pr/tests/prftest2.c
pr/tests/primblok.c
pr/tests/priotest.c
pr/tests/provider.c
pr/tests/prpoll.c
pr/tests/prpollml.c
pr/tests/prselect.c
pr/tests/randseed.c
pr/tests/ranfile.c
pr/tests/rmdir.c
pr/tests/rwlockrank.c
pr/tests/rwlocktest.c
pr/tests/sel_spd.c
pr/tests/selct_er.c
pr/tests/selct_nm.c
pr/tests/selct_to.c
pr/tests/select2.c
pr/tests/sem.c
pr/tests/sema.c
pr/tests/semaerr.c
pr/tests/semaerr1.c
pr/tests/semaping.c
pr/tests/semapong.c
pr/tests/sendzlf.c
pr/tests/server_test.c
pr/tests/servr_kk.c
pr/tests/servr_ku.c
pr/tests/servr_uk.c
pr/tests/servr_uu.c
pr/tests/short_thread.c
pr/tests/sigpipe.c
pr/tests/sleep.c
pr/tests/socket.c
pr/tests/sockopt.c
pr/tests/sprintf.c
pr/tests/stack.c
pr/tests/stat.c
pr/tests/stdio.c
pr/tests/strod.c
pr/tests/suspend.c
pr/tests/switch.c
pr/tests/system.c
pr/tests/testbit.c
pr/tests/testfile.c
pr/tests/threads.c
pr/tests/thrpool_client.c
pr/tests/thrpool_server.c
pr/tests/thruput.c
pr/tests/time.c
pr/tests/timemac.c
pr/tests/timetest.c
pr/tests/tmoacc.c
pr/tests/tmocon.c
pr/tests/tpd.c
pr/tests/udpsrv.c
pr/tests/version.c
pr/tests/writev.c
pr/tests/xnotify.c
pr/tests/y2k.c
pr/tests/y2ktmo.c
pr/tests/yield.c
pr/tests/zerolen.c
tools/httpget.c
tools/tail.c
--- a/config/nsinstall.c
+++ b/config/nsinstall.c
@@ -40,89 +40,96 @@
 #endif
 
 #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/lib/ds/plarena.c
+++ b/lib/ds/plarena.c
@@ -30,45 +30,50 @@ 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 */
+        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
 }
 
@@ -97,18 +102,19 @@ PR_IMPLEMENT(void *) PL_ArenaAllocate(PL
     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;
@@ -134,38 +140,41 @@ PR_IMPLEMENT(void *) PL_ArenaAllocate(PL
             rp = (char *)a->avail;
             a->avail += nb;
             PR_ASSERT(a->avail <= a->limit);
             /* 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) {
@@ -178,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,--);
@@ -220,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;
             }
         }
     }
@@ -262,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/lib/ds/plhash.c
+++ b/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/lib/ds/plvrsion.c
+++ b/lib/ds/plvrsion.c
@@ -63,19 +63,19 @@ 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()
--- a/lib/libc/include/plgetopt.h
+++ b/lib/libc/include/plgetopt.h
@@ -15,27 +15,27 @@
 #include "prtypes.h"
 
 PR_BEGIN_EXTERN_C
 
 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 */
@@ -47,32 +47,32 @@ typedef struct 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.
  */
 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.
  * 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.
  */
 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);
 
--- a/lib/libc/src/plerror.c
+++ b/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/lib/libc/src/plgetopt.c
+++ b/lib/libc/src/plgetopt.c
@@ -153,20 +153,22 @@ PR_IMPLEMENT(PLOptStatus) PL_GetNextOpt(
         const PLLongOpt *longOpt = internal->longOpts;
         PLOptStatus result = PL_OPT_BAD;
 
         opt->option = 0;
         opt->value  = NULL;
 
         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)
             {
@@ -222,18 +224,19 @@ PR_IMPLEMENT(PLOptStatus) PL_GetNextOpt(
                     else
                     {
                         return PL_OPT_BAD;
                     }
 
                     internal->xargv = &static_Nul;
                     internal->minus = 0;
                 }
-                else
+                else {
                     opt->value = NULL;
+                }
                 return PL_OPT_OK;
             }
         }
         internal->xargv += 1;  /* consume that option */
         return PL_OPT_BAD;
     }
 
     /*
--- a/lib/libc/src/plvrsion.c
+++ b/lib/libc/src/plvrsion.c
@@ -63,19 +63,19 @@ 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()
--- a/lib/libc/src/strcase.c
+++ b/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/lib/libc/src/strcat.c
+++ b/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/lib/libc/src/strchr.c
+++ b/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/lib/libc/src/strcmp.c
+++ b/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/lib/libc/src/strcpy.c
+++ b/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/lib/libc/src/strdup.c
+++ b/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/lib/libc/src/strlen.c
+++ b/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/lib/libc/src/strpbrk.c
+++ b/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/lib/libc/src/strstr.c
+++ b/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/lib/libc/src/strtok.c
+++ b/lib/libc/src/strtok.c
@@ -9,31 +9,34 @@ 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 )
+        if( sc == 0 ) {
             break;
+        }
     }
 
     if( c == 0 )
     {
         *lasts = NULL;
         return NULL;
     }
 
--- a/lib/prstreams/plvrsion.c
+++ b/lib/prstreams/plvrsion.c
@@ -63,19 +63,19 @@ 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()
--- a/lib/prstreams/prstrms.cpp
+++ b/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/lib/prstreams/prstrms.h
+++ b/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/lib/prstreams/tests/testprstrm/testprstrm.cpp
+++ b/lib/prstreams/tests/testprstrm/testprstrm.cpp
@@ -36,136 +36,137 @@ threadmain(void *mytag)
     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/lib/tests/arena.c
+++ b/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  ));
+                                &ap, ap.first, ap.current, ap.arenasize  ));
 
-	for( i = 0; i < 150; i++ )
-	{
-		PL_ARENA_ALLOCATE( ptr, &ap, 512 );
+    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 ));
-	}
+                                   &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 );
+    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 ));
-	}
+                                   &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,73 +106,73 @@ 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
 ** min..max, rounded to the next doubleword
 **
@@ -246,34 +246,34 @@ static void Stress( void )
     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 )
     {
         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.
@@ -308,60 +308,62 @@ void Help( void )
     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/lib/tests/base64t.c
+++ b/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.",
+        "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"
+    },
 
-          { "The End", "VGhlIEVuZA==" }
-      };
+    { "The End", "VGhlIEVuZA==" }
+};
 
 /* PL_Base64Encode, random strings */
 PRBool test_004(void)
 {
     int i;
     char result[ 4096 ];
 
     printf("Test 004 (PL_Base64Encode, random strings)                            ..."); fflush(stdout);
--- a/lib/tests/getopt.c
+++ b/lib/tests/getopt.c
@@ -7,38 +7,39 @@
 #include <stdlib.h>
 
 #include "nspr.h"
 #include "plgetopt.h"
 
 
 
 static const PLLongOpt optArray[] = {
-    { "longa", 'a'        , PR_TRUE  },
-    { "longb", 'b'        , PR_TRUE  },
-    { "longc", 'c'        , PR_FALSE },
+    { "longa", 'a', PR_TRUE  },
+    { "longb", 'b', PR_TRUE  },
+    { "longc", 'c', PR_FALSE },
     { "longd", 'd' | 0x100, PR_TRUE  },
     { "longe", 'e' | 0x100, PR_FALSE },
     {    NULL,                       }
 };
 
 int
 main(int argc, char **argv)
 {
     PLOptState *opt;
     PLOptStatus ostat;
 
     opt = PL_CreateLongOptState(argc, argv, "a:b:c", optArray);
 
     while (PL_OPT_OK == (ostat = PL_GetNextOpt(opt))) {
-	if (opt->option == 0 && opt->longOptIndex < 0)
-	    printf("Positional parameter: \"%s\"\n", opt->value);
-	else
-	    printf("%s option: %x (\'%c\', index %d), argument: \"%s\"\n",
-		   (ostat == PL_OPT_BAD) ? "BAD" : "GOOD",
-		   opt->longOption, opt->option ? opt->option : ' ',
-		   opt->longOptIndex, opt->value);
+        if (opt->option == 0 && opt->longOptIndex < 0) {
+            printf("Positional parameter: \"%s\"\n", opt->value);
+        }
+        else
+            printf("%s option: %x (\'%c\', index %d), argument: \"%s\"\n",
+                   (ostat == PL_OPT_BAD) ? "BAD" : "GOOD",
+                   opt->longOption, opt->option ? opt->option : ' ',
+                   opt->longOptIndex, opt->value);
 
     }
     printf("last result was %s\n", (ostat == PL_OPT_BAD) ? "BAD" : "EOL");
     PL_DestroyOptState(opt);
     return 0;
 }
--- a/lib/tests/string.c
+++ b/lib/tests/string.c
@@ -11,23 +11,23 @@
 /* PL_strlen */
 PRBool test_001(void)
 {
     static struct
     {
         const char *str;
         PRUint32    len;
     } array[] =
-      {
-          { (const char *)0, 0 },
-          { "", 0 },
-          { "a", 1 },
-          { "abcdefg", 7 },
-          { "abcdefg\0hijk", 7 }
-      };
+    {
+        { (const char *)0, 0 },
+        { "", 0 },
+        { "a", 1 },
+        { "abcdefg", 7 },
+        { "abcdefg\0hijk", 7 }
+    };
 
     int i;
 
     printf("Test 001 (PL_strlen)      ..."); fflush(stdout);
 
     for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
     {
         if( PL_strlen(array[i].str) != array[i].len )
@@ -47,33 +47,33 @@ PRBool test_001(void)
 PRBool test_002(void)
 {
     static struct
     {
         const char *str;
         PRUint32    max;
         PRUint32    len;
     } array[] =
-      {
-          { (const char *)0, 0, 0 },
-          { (const char *)0, 12, 0 },
-          { "", 0, 0 },
-          { "", 12, 0 },
-          { "a", 0, 0 },
-          { "a", 1, 1 },
-          { "a", 12, 1 },
-          { "abcdefg", 0, 0 },
-          { "abcdefg", 1, 1 },
-          { "abcdefg", 7, 7 },
-          { "abcdefg", 12, 7 },
-          { "abcdefg\0hijk", 0, 0 },
-          { "abcdefg\0hijk", 1, 1 },
-          { "abcdefg\0hijk", 7, 7 },
-          { "abcdefg\0hijk", 12, 7 },
-      };
+    {
+        { (const char *)0, 0, 0 },
+        { (const char *)0, 12, 0 },
+        { "", 0, 0 },
+        { "", 12, 0 },
+        { "a", 0, 0 },
+        { "a", 1, 1 },
+        { "a", 12, 1 },
+        { "abcdefg", 0, 0 },
+        { "abcdefg", 1, 1 },
+        { "abcdefg", 7, 7 },
+        { "abcdefg", 12, 7 },
+        { "abcdefg\0hijk", 0, 0 },
+        { "abcdefg\0hijk", 1, 1 },
+        { "abcdefg\0hijk", 7, 7 },
+        { "abcdefg\0hijk", 12, 7 },
+    };
 
     int i;
 
     printf("Test 002 (PL_strnlen)     ..."); fflush(stdout);
 
     for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
     {
         if( PL_strnlen(array[i].str, array[i].max) != array[i].len )
@@ -96,28 +96,28 @@ PRBool test_003(void)
 
     static struct
     {
         const char *str;
         char       *dest;
         char       *rv;
         PRBool      comp;
     } array[] =
-      {
-          { (const char *)0, (char *)0, (char *)0, PR_FALSE },
-          { (const char *)0, buffer, (char *)0, PR_FALSE },
-          { "", (char *)0, (char *)0, PR_FALSE },
-          { "", buffer, buffer, PR_TRUE },
-          { "a", (char *)0, (char *)0, PR_FALSE },
-          { "a", buffer, buffer, PR_TRUE },
-          { "abcdefg", (char *)0, (char *)0, PR_FALSE },
-          { "abcdefg", buffer, buffer, PR_TRUE },
-          { "wxyz\0abcdefg", (char *)0, (char *)0, PR_FALSE },
-          { "wxyz\0abcdefg", buffer, buffer, PR_TRUE }
-      };
+    {
+        { (const char *)0, (char *)0, (char *)0, PR_FALSE },
+        { (const char *)0, buffer, (char *)0, PR_FALSE },
+        { "", (char *)0, (char *)0, PR_FALSE },
+        { "", buffer, buffer, PR_TRUE },
+        { "a", (char *)0, (char *)0, PR_FALSE },
+        { "a", buffer, buffer, PR_TRUE },
+        { "abcdefg", (char *)0, (char *)0, PR_FALSE },
+        { "abcdefg", buffer, buffer, PR_TRUE },
+        { "wxyz\0abcdefg", (char *)0, (char *)0, PR_FALSE },
+        { "wxyz\0abcdefg", buffer, buffer, PR_TRUE }
+    };
 
     int i;
 
     printf("Test 003 (PL_strcpy)      ..."); fflush(stdout);
 
     for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
     {
         char *rv;
@@ -139,17 +139,19 @@ PRBool test_003(void)
                 if( *a != *b )
                 {
                     printf("FAIL %d: %s->%.32s\n", i,
                            array[i].str ? array[i].str : "(null)",
                            array[i].dest ? array[i].dest : "(null)");
                     return PR_FALSE;
                 }
 
-                if( (char)0 == *a ) break;
+                if( (char)0 == *a ) {
+                    break;
+                }
 
                 a++;
                 b++;
             }
         }
     }
 
     printf("PASS\n");
@@ -166,78 +168,79 @@ PRBool test_004(void)
         const char *str;
         PRUint32    len;
         char       *dest;
         char       *rv;
         PRBool      comp;
         const char *result;
         PRBool      nulled;
     } array[] =
-      {
-          { (const char *)0, 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { (const char *)0, 0, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { (const char *)0, 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { (const char *)0, 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { (const char *)0, 1, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { (const char *)0, 7, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
-          { "", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "", 1, buffer, buffer, PR_TRUE, "", PR_TRUE },
-          { "", 7, buffer, buffer, PR_TRUE, "", PR_TRUE },
-          { "a", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "a", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
-          { "a", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "a", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "b", 1, buffer, buffer, PR_TRUE, "b", PR_FALSE },
-          { "c", 7, buffer, buffer, PR_TRUE, "c", PR_TRUE },
-          { "de", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "de", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
-          { "de", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "de", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "fg", 1, buffer, buffer, PR_TRUE, "f", PR_FALSE },
-          { "hi", 7, buffer, buffer, PR_TRUE, "hi", PR_TRUE },
-          { "jklmnopq", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "jklmnopq", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
-          { "jklmnopq", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "jklmnopq", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "rstuvwxy", 1, buffer, buffer, PR_TRUE, "r", PR_FALSE },
-          { "zABCDEFG", 7, buffer, buffer, PR_TRUE, "zABCDEF", PR_FALSE },
-          { "a\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "a\0XXX", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
-          { "a\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "a\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "b\0XXX", 1, buffer, buffer, PR_TRUE, "b", PR_FALSE },
-          { "c\0XXX", 7, buffer, buffer, PR_TRUE, "c", PR_TRUE },
-          { "de\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "de\0XXX", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
-          { "de\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "de\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "fg\0XXX", 1, buffer, buffer, PR_TRUE, "f", PR_FALSE },
-          { "hi\0XXX", 7, buffer, buffer, PR_TRUE, "hi", PR_TRUE },
-          { "jklmnopq\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "jklmnopq\0XXX", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
-          { "jklmnopq\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "jklmnopq\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
-          { "rstuvwxy\0XXX", 1, buffer, buffer, PR_TRUE, "r", PR_FALSE },
-          { "zABCDEFG\0XXX", 7, buffer, buffer, PR_TRUE, "zABCDEF", PR_FALSE },
-      };
+    {
+        { (const char *)0, 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
+        { (const char *)0, 0, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
+        { (const char *)0, 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
+        { (const char *)0, 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
+        { (const char *)0, 1, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
+        { (const char *)0, 7, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
+        { "", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
+        { "", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
+        { "", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
+        { "", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
+        { "