diff --git a/bash/.bash_profile b/bash/.bash_profile
index d920cfe..9e325e5 100644
--- a/bash/.bash_profile
+++ b/bash/.bash_profile
@@ -1,15 +1,6 @@
-<<<<<<< HEAD
-=======
-#
 # ~/.bash_profile
 #
 # Get the aliases and functions
 [ -f $HOME/.bashrc ] && . $HOME/.bashrc
 [[ -f ~/.bashrc ]] && . ~/.bashrc
 
-export XDG_CONFIG_HOME="$HOME/.config"
-#export DISPLAY=:0
-export BROWSER=firefox
-export EDITOR=vim
-export TERM=screen-256color
->>>>>>> 05f5a5326ea758311bda4cc4225cd0ce265b8ec0
diff --git a/mpd/mpd.conf b/mpd/mpd.conf
index a0548ec..b22f35a 100644
--- a/mpd/mpd.conf
+++ b/mpd/mpd.conf
@@ -1,6 +1,6 @@
 db_file            "~/.config/mpd/database"
 log_file           "~/.config/mpd/log"
-music_directory    "~/Music"
+music_directory    "/mnt/media/music"
 playlist_directory "~/.config/mpd/playlists"
 pid_file           "~/.config/mpd/pid"
 state_file         "~/.config/mpd/state"
@@ -15,7 +15,7 @@ max_output_buffer_size "16384"
 audio_output {
       type  "alsa"
       name  "alsa for audio soundcard"
-      mixer_type "software"
+      # mixer_type "software"
 }
 
 audio_output {
@@ -24,3 +24,17 @@ name               "toggle_visualizer"
 path               "/tmp/mpd.fifo"
 format             "44100:16:2"
 }
+
+audio_output {
+        type    "pulse"
+        name    "PulseAudio Output"
+        #server  "localhost"   # optional
+        #sink    "alsa_output" # optional
+}
+
+audio_output {
+    type           "alsa"
+    name           "MPD"
+    device         "pulse"
+    mixer_control  "Master"
+}
diff --git a/newsboat/config b/newsboat/config
index 36e126d..8fa3c35 100644
--- a/newsboat/config
+++ b/newsboat/config
@@ -30,7 +30,7 @@ color listfocus_unread yellow default bold
 color info red black bold
 color article cyan default
 
-browser linkhandler
+# browser linkhandler
 macro , open-in-browser
 macro t set browser "tsp youtube-dl --add-metadata -ic"; open-in-browser ; set browser linkhandler
 macro a set browser "tsp youtube-dl --add-metadata -xic -f bestaudio/best"; open-in-browser ; set browser linkhandler
diff --git a/ranger/rc.conf b/ranger/rc.conf
new file mode 100644
index 0000000..ca99503
--- /dev/null
+++ b/ranger/rc.conf
@@ -0,0 +1 @@
+map bw shell wal -i %s
diff --git a/ranger/rifle.conf b/ranger/rifle.conf
new file mode 100644
index 0000000..a388b59
--- /dev/null
+++ b/ranger/rifle.conf
@@ -0,0 +1,264 @@
+# vim: ft=cfg
+#
+# This is the configuration file of "rifle", ranger's file executor/opener.
+# Each line consists of conditions and a command.  For each line the conditions
+# are checked and if they are met, the respective command is run.
+#
+# Syntax:
+#   <condition1> , <condition2> , ... = command
+#
+# The command can contain these environment variables:
+#   $1-$9 | The n-th selected file
+#   $@    | All selected files
+#
+# If you use the special command "ask", rifle will ask you what program to run.
+#
+# Prefixing a condition with "!" will negate its result.
+# These conditions are currently supported:
+#   match <regexp> | The regexp matches $1
+#   ext <regexp>   | The regexp matches the extension of $1
+#   mime <regexp>  | The regexp matches the mime type of $1
+#   name <regexp>  | The regexp matches the basename of $1
+#   path <regexp>  | The regexp matches the absolute path of $1
+#   has <program>  | The program is installed (i.e. located in $PATH)
+#   env <variable> | The environment variable "variable" is non-empty
+#   file           | $1 is a file
+#   directory      | $1 is a directory
+#   number <n>     | change the number of this command to n
+#   terminal       | stdin, stderr and stdout are connected to a terminal
+#   X              | $DISPLAY is not empty (i.e. Xorg runs)
+#
+# There are also pseudo-conditions which have a "side effect":
+#   flag <flags>  | Change how the program is run. See below.
+#   label <label> | Assign a label or name to the command so it can
+#                 | be started with :open_with <label> in ranger
+#                 | or `rifle -p <label>` in the standalone executable.
+#   else          | Always true.
+#
+# Flags are single characters which slightly transform the command:
+#   f | Fork the program, make it run in the background.
+#     |   New command = setsid $command >& /dev/null &
+#   r | Execute the command with root permissions
+#     |   New command = sudo $command
+#   t | Run the program in a new terminal.  If $TERMCMD is not defined,
+#     | rifle will attempt to extract it from $TERM.
+#     |   New command = $TERMCMD -e $command
+# Note: The "New command" serves only as an illustration, the exact
+# implementation may differ.
+# Note: When using rifle in ranger, there is an additional flag "c" for
+# only running the current file even if you have marked multiple files.
+
+#-------------------------------------------
+# Websites
+#-------------------------------------------
+# Rarely installed browsers get higher priority; It is assumed that if you
+# install a rare browser, you probably use it.  Firefox/konqueror/w3m on the
+# other hand are often only installed as fallback browsers.
+ext x?html?, has surf,             X, flag f = surf -- file://"$1"
+ext x?html?, has vimprobable,      X, flag f = vimprobable -- "$@"
+ext x?html?, has vimprobable2,     X, flag f = vimprobable2 -- "$@"
+ext x?html?, has qutebrowser,      X, flag f = qutebrowser -- "$@"
+ext x?html?, has dwb,              X, flag f = dwb -- "$@"
+ext x?html?, has jumanji,          X, flag f = jumanji -- "$@"
+ext x?html?, has luakit,           X, flag f = luakit -- "$@"
+ext x?html?, has uzbl,             X, flag f = uzbl -- "$@"
+ext x?html?, has uzbl-tabbed,      X, flag f = uzbl-tabbed -- "$@"
+ext x?html?, has uzbl-browser,     X, flag f = uzbl-browser -- "$@"
+ext x?html?, has uzbl-core,        X, flag f = uzbl-core -- "$@"
+ext x?html?, has midori,           X, flag f = midori -- "$@"
+ext x?html?, has chromium-browser, X, flag f = chromium-browser -- "$@"
+ext x?html?, has chromium,         X, flag f = chromium -- "$@"
+ext x?html?, has google-chrome,    X, flag f = google-chrome -- "$@"
+ext x?html?, has opera,            X, flag f = opera -- "$@"
+ext x?html?, has firefox,          X, flag f = firefox -- "$@"
+ext x?html?, has seamonkey,        X, flag f = seamonkey -- "$@"
+ext x?html?, has iceweasel,        X, flag f = iceweasel -- "$@"
+ext x?html?, has epiphany,         X, flag f = epiphany -- "$@"
+ext x?html?, has konqueror,        X, flag f = konqueror -- "$@"
+ext x?html?, has elinks,            terminal = elinks "$@"
+ext x?html?, has links2,            terminal = links2 "$@"
+ext x?html?, has links,             terminal = links "$@"
+ext x?html?, has lynx,              terminal = lynx -- "$@"
+ext x?html?, has w3m,               terminal = w3m "$@"
+
+#-------------------------------------------
+# Spreadsheets
+#-------------------------------------------
+ext csv = sc-im "$@"
+ext xls = sc-im "$@"
+ext xlsx = sc-im "$1"
+
+#-------------------------------------------
+# Misc
+#-------------------------------------------
+# Define the "editor" for text files as first action
+mime ^text,  label editor = ${VISUAL:-$EDITOR} -- "$@"
+mime ^text,  label pager  = "$PAGER" -- "$@"
+!mime ^text, label editor, ext xml|json|tex|py|pl|rb|js|sh|php = ${VISUAL:-$EDITOR} -- "$@"
+!mime ^text, label pager,  ext xml|json|tex|py|pl|rb|js|sh|php = "$PAGER" -- "$@"
+
+ext 1                         = man "$1"
+ext s[wmf]c, has zsnes, X     = zsnes "$1"
+ext s[wmf]c, has snes9x-gtk,X = snes9x-gtk "$1"
+ext nes, has fceux, X         = fceux "$1"
+ext exe                       = wine "$1"
+name ^[mM]akefile$            = make
+
+
+#--------------------------------------------
+# Code
+#-------------------------------------------
+ext py  = python -- "$1"
+ext pl  = perl -- "$1"
+ext rb  = ruby -- "$1"
+ext js  = node -- "$1"
+ext sh  = sh -- "$1"
+ext php = php -- "$1"
+
+#--------------------------------------------
+# Audio without X
+#-------------------------------------------
+mime ^audio|ogg$, terminal, has mpv      = mpv -- "$@"
+mime ^audio|ogg$, terminal, has mplayer2 = mplayer2 -- "$@"
+mime ^audio|ogg$, terminal, has mplayer  = mplayer -- "$@"
+ext midi?,        terminal, has wildmidi = wildmidi -- "$@"
+
+#--------------------------------------------
+# Video/Audio with a GUI
+#-------------------------------------------
+mime ^video|audio, has gmplayer, X, flag f = gmplayer -- "$@"
+mime ^video|audio, has smplayer, X, flag f = smplayer "$@"
+mime ^video,       has mpv,      X, flag f = mpv -- "$@"
+mime ^video,       has mpv,      X, flag f = mpv --fs -- "$@"
+mime ^video,       has mplayer2, X, flag f = mplayer2 -- "$@"
+mime ^video,       has mplayer2, X, flag f = mplayer2 -fs -- "$@"
+mime ^video,       has mplayer,  X, flag f = mplayer -- "$@"
+mime ^video,       has mplayer,  X, flag f = mplayer -fs -- "$@"
+mime ^video|audio, has vlc,      X, flag f = vlc -- "$@"
+mime ^video|audio, has totem,    X, flag f = totem -- "$@"
+mime ^video|audio, has totem,    X, flag f = totem --fullscreen -- "$@"
+
+#--------------------------------------------
+# Video without X:
+#-------------------------------------------
+mime ^video, terminal, !X, has mpv       = mpv -- "$@"
+mime ^video, terminal, !X, has mplayer2  = mplayer2 -- "$@"
+mime ^video, terminal, !X, has mplayer   = mplayer -- "$@"
+
+#-------------------------------------------
+# Documents
+#-------------------------------------------
+ext pdf, has llpp,     X, flag f = llpp "$@"
+ext pdf, has zathura,  X, flag f = zathura -- "$@"
+ext pdf, has mupdf,    X, flag f = mupdf "$@"
+ext pdf, has mupdf-x11,X, flag f = mupdf-x11 "$@"
+ext pdf, has apvlv,    X, flag f = apvlv -- "$@"
+ext pdf, has xpdf,     X, flag f = xpdf -- "$@"
+ext pdf, has evince,   X, flag f = evince -- "$@"
+ext pdf, has atril,    X, flag f = atril -- "$@"
+ext pdf, has okular,   X, flag f = okular -- "$@"
+ext pdf, has epdfview, X, flag f = epdfview -- "$@"
+ext pdf, has qpdfview, X, flag f = qpdfview "$@"
+ext pdf, has open,     X, flag f = open "$@"
+
+ext docx?, has catdoc,       terminal = catdoc -- "$@" | "$PAGER"
+
+ext                        sxc|xlsx?|xlt|xlw|gnm|gnumeric, has gnumeric,    X, flag f = gnumeric -- "$@"
+ext                        sxc|xlsx?|xlt|xlw|gnm|gnumeric, has kspread,     X, flag f = kspread -- "$@"
+ext pptx?|od[dfgpst]|docx?|sxc|xlsx?|xlt|xlw|gnm|gnumeric, has libreoffice, X, flag f = libreoffice "$@"
+ext pptx?|od[dfgpst]|docx?|sxc|xlsx?|xlt|xlw|gnm|gnumeric, has soffice,     X, flag f = soffice "$@"
+ext pptx?|od[dfgpst]|docx?|sxc|xlsx?|xlt|xlw|gnm|gnumeric, has ooffice,     X, flag f = ooffice "$@"
+
+ext djvu, has zathura,X, flag f = zathura -- "$@"
+ext djvu, has evince, X, flag f = evince -- "$@"
+ext djvu, has atril,  X, flag f = atril -- "$@"
+ext djvu, has djview, X, flag f = djview -- "$@"
+
+ext epub, has ebook-viewer, X, flag f = ebook-viewer -- "$@"
+ext mobi, has ebook-viewer, X, flag f = ebook-viewer -- "$@"
+
+#-------------------------------------------
+# Image Viewing:
+#-------------------------------------------
+mime ^image/svg, has inkscape, X, flag f = inkscape -- "$@"
+mime ^image/svg, has display,  X, flag f = display -- "$@"
+
+mime ^image, has pqiv,      X, flag f = pqiv -- "$@"
+mime ^image, has sxiv,      X, flag f = sxiv -- "$@"
+mime ^image, has feh,       X, flag f = feh -- "$@"
+mime ^image, has mirage,    X, flag f = mirage -- "$@"
+mime ^image, has ristretto, X, flag f = ristretto "$@"
+mime ^image, has eog,       X, flag f = eog -- "$@"
+mime ^image, has eom,       X, flag f = eom -- "$@"
+mime ^image, has nomacs,    X, flag f = nomacs -- "$@"
+mime ^image, has geeqie,    X, flag f = geeqie -- "$@"
+mime ^image, has gwenview,  X, flag f = gwenview -- "$@"
+mime ^image, has gimp,      X, flag f = gimp -- "$@"
+ext xcf,                    X, flag f = gimp -- "$@"
+
+#-------------------------------------------
+# Archives
+#-------------------------------------------
+
+# avoid password prompt by providing empty password
+ext 7z, has 7z = 7z -p l "$@" | "$PAGER"
+# This requires atool
+ext ace|ar|arc|bz2?|cab|cpio|cpt|deb|dgc|dmg|gz,     has atool = atool --list --each -- "$@" | "$PAGER"
+ext iso|jar|msi|pkg|rar|shar|tar|tgz|xar|xpi|xz|zip, has atool = atool --list --each -- "$@" | "$PAGER"
+ext 7z|ace|ar|arc|bz2?|cab|cpio|cpt|deb|dgc|dmg|gz,  has atool = atool --extract --each -- "$@"
+ext iso|jar|msi|pkg|rar|shar|tar|tgz|xar|xpi|xz|zip, has atool = atool --extract --each -- "$@"
+
+# Listing and extracting archives without atool:
+ext tar|gz|bz2|xz, has tar = tar vvtf "$1" | "$PAGER"
+ext tar|gz|bz2|xz, has tar = for file in "$@"; do tar vvxf "$file"; done
+ext bz2, has bzip2 = for file in "$@"; do bzip2 -dk "$file"; done
+ext zip, has unzip = unzip -l "$1" | less
+ext zip, has unzip = for file in "$@"; do unzip -d "${file%.*}" "$file"; done
+ext ace, has unace = unace l "$1" | less
+ext ace, has unace = for file in "$@"; do unace e "$file"; done
+ext rar, has unrar = unrar l "$1" | less
+ext rar, has unrar = for file in "$@"; do unrar x "$file"; done
+
+#-------------------------------------------
+# Flag t fallback terminals
+#-------------------------------------------
+# Rarely installed terminal emulators get higher priority; It is assumed that
+# if you install a rare terminal emulator, you probably use it.
+# gnome-terminal/konsole/xterm on the other hand are often installed as part of
+# a desktop environment or as fallback terminal emulators.
+mime ^ranger/x-terminal-emulator, has terminology = terminology -e "$@"
+mime ^ranger/x-terminal-emulator, has kitty = kitty -- "$@"
+mime ^ranger/x-terminal-emulator, has alacritty = alacritty -e "$@"
+mime ^ranger/x-terminal-emulator, has sakura = sakura -e "$@"
+mime ^ranger/x-terminal-emulator, has lilyterm = lilyterm -e "$@"
+#mime ^ranger/x-terminal-emulator, has cool-retro-term = cool-retro-term -e "$@"
+mime ^ranger/x-terminal-emulator, has termite = termite -x '"$@"'
+#mime ^ranger/x-terminal-emulator, has yakuake = yakuake -e "$@"
+mime ^ranger/x-terminal-emulator, has guake = guake -ne "$@"
+mime ^ranger/x-terminal-emulator, has tilda = tilda -c "$@"
+mime ^ranger/x-terminal-emulator, has st = st -e "$@"
+mime ^ranger/x-terminal-emulator, has terminator = terminator -x "$@"
+mime ^ranger/x-terminal-emulator, has urxvt = urxvt -e "$@"
+mime ^ranger/x-terminal-emulator, has pantheon-terminal = pantheon-terminal -e "$@"
+mime ^ranger/x-terminal-emulator, has lxterminal = lxterminal -e "$@"
+mime ^ranger/x-terminal-emulator, has mate-terminal = mate-terminal -x "$@"
+mime ^ranger/x-terminal-emulator, has xfce4-terminal = xfce4-terminal -x "$@"
+mime ^ranger/x-terminal-emulator, has konsole = konsole -e "$@"
+mime ^ranger/x-terminal-emulator, has gnome-terminal = gnome-terminal -- "$@"
+mime ^ranger/x-terminal-emulator, has xterm = xterm -e "$@"
+
+#-------------------------------------------
+# Misc
+#-------------------------------------------
+label wallpaper, number 11, mime ^image, has feh, X = feh --bg-scale "$1"
+label wallpaper, number 12, mime ^image, has feh, X = feh --bg-tile "$1"
+label wallpaper, number 13, mime ^image, has feh, X = feh --bg-center "$1"
+label wallpaper, number 14, mime ^image, has feh, X = feh --bg-fill "$1"
+
+# Define the editor for non-text files + pager as last action
+              !mime ^text, !ext xml|json|csv|tex|py|pl|rb|js|sh|php  = ask
+label editor, !mime ^text, !ext xml|json|csv|tex|py|pl|rb|js|sh|php  = ${VISUAL:-$EDITOR} -- "$@"
+label pager,  !mime ^text, !ext xml|json|csv|tex|py|pl|rb|js|sh|php  = "$PAGER" -- "$@"
+
+# The very last action, so that it's never triggered accidentally, is to execute a program:
+mime application/x-executable = "$1"
diff --git a/sbcl/.quicklisp/dists/quicklisp/archives/anaphora-20191007-git.tgz b/sbcl/.quicklisp/dists/quicklisp/archives/anaphora-20191007-git.tgz
new file mode 100644
index 0000000..d2f4bea
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/archives/anaphora-20191007-git.tgz differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/archives/cl-ansi-text-20150804-git.tgz b/sbcl/.quicklisp/dists/quicklisp/archives/cl-ansi-text-20150804-git.tgz
new file mode 100644
index 0000000..410d166
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/archives/cl-ansi-text-20150804-git.tgz differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/archives/cl-colors-20180328-git.tgz b/sbcl/.quicklisp/dists/quicklisp/archives/cl-colors-20180328-git.tgz
new file mode 100644
index 0000000..88b0888
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/archives/cl-colors-20180328-git.tgz differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/archives/cl-emb-20190521-git.tgz b/sbcl/.quicklisp/dists/quicklisp/archives/cl-emb-20190521-git.tgz
new file mode 100644
index 0000000..3c909f0
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/archives/cl-emb-20190521-git.tgz differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/archives/cl-ppcre-20190521-git.tgz b/sbcl/.quicklisp/dists/quicklisp/archives/cl-ppcre-20190521-git.tgz
new file mode 100644
index 0000000..d5c007b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/archives/cl-ppcre-20190521-git.tgz differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/archives/cl-project-20190521-git.tgz b/sbcl/.quicklisp/dists/quicklisp/archives/cl-project-20190521-git.tgz
new file mode 100644
index 0000000..74a23da
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/archives/cl-project-20190521-git.tgz differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/archives/let-plus-20191130-git.tgz b/sbcl/.quicklisp/dists/quicklisp/archives/let-plus-20191130-git.tgz
new file mode 100644
index 0000000..a451854
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/archives/let-plus-20191130-git.tgz differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/archives/local-time-20190710-git.tgz b/sbcl/.quicklisp/dists/quicklisp/archives/local-time-20190710-git.tgz
new file mode 100644
index 0000000..7c52f01
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/archives/local-time-20190710-git.tgz differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/archives/prove-20171130-git.tgz b/sbcl/.quicklisp/dists/quicklisp/archives/prove-20171130-git.tgz
new file mode 100644
index 0000000..caab817
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/archives/prove-20171130-git.tgz differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/releases/anaphora.txt b/sbcl/.quicklisp/dists/quicklisp/installed/releases/anaphora.txt
new file mode 100644
index 0000000..e2ab29f
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/releases/anaphora.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/anaphora-20191007-git/
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-ansi-text.txt b/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-ansi-text.txt
new file mode 100644
index 0000000..6692a2f
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-ansi-text.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/cl-ansi-text-20150804-git/
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-colors.txt b/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-colors.txt
new file mode 100644
index 0000000..b41f24c
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-colors.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/cl-colors-20180328-git/
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-emb.txt b/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-emb.txt
new file mode 100644
index 0000000..88fbd80
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-emb.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/cl-emb-20190521-git/
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-ppcre.txt b/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-ppcre.txt
new file mode 100644
index 0000000..11bae42
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-ppcre.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/cl-ppcre-20190521-git/
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-project.txt b/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-project.txt
new file mode 100644
index 0000000..04eabea
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/releases/cl-project.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/cl-project-20190521-git/
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/releases/let-plus.txt b/sbcl/.quicklisp/dists/quicklisp/installed/releases/let-plus.txt
new file mode 100644
index 0000000..3a2dfb3
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/releases/let-plus.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/let-plus-20191130-git/
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/releases/local-time.txt b/sbcl/.quicklisp/dists/quicklisp/installed/releases/local-time.txt
new file mode 100644
index 0000000..61900cf
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/releases/local-time.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/local-time-20190710-git/
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/releases/prove.txt b/sbcl/.quicklisp/dists/quicklisp/installed/releases/prove.txt
new file mode 100644
index 0000000..9ea2f5e
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/releases/prove.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/prove-20171130-git/
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/anaphora.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/anaphora.txt
new file mode 100644
index 0000000..65f11d4
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/anaphora.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/anaphora-20191007-git/anaphora.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-ansi-text-test.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-ansi-text-test.txt
new file mode 100644
index 0000000..25f6096
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-ansi-text-test.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/cl-ansi-text-20150804-git/cl-ansi-text-test.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-ansi-text.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-ansi-text.txt
new file mode 100644
index 0000000..c5ae783
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-ansi-text.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/cl-ansi-text-20150804-git/cl-ansi-text.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-colors.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-colors.txt
new file mode 100644
index 0000000..472e19a
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-colors.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/cl-colors-20180328-git/cl-colors.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-emb.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-emb.txt
new file mode 100644
index 0000000..b5a7d69
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-emb.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/cl-emb-20190521-git/cl-emb.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-postgres+local-time.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-postgres+local-time.txt
new file mode 100644
index 0000000..f1f74d9
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-postgres+local-time.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/local-time-20190710-git/cl-postgres+local-time.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-ppcre-unicode.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-ppcre-unicode.txt
new file mode 100644
index 0000000..6e4b68f
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-ppcre-unicode.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre-unicode.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-ppcre.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-ppcre.txt
new file mode 100644
index 0000000..5515d9e
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-ppcre.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-project-test.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-project-test.txt
new file mode 100644
index 0000000..abeedbb
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-project-test.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/cl-project-20190521-git/cl-project-test.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-project.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-project.txt
new file mode 100644
index 0000000..5f1aec3
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-project.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/cl-project-20190521-git/cl-project.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-test-more.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-test-more.txt
new file mode 100644
index 0000000..77c5a45
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/cl-test-more.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/prove-20171130-git/cl-test-more.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/let-plus.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/let-plus.txt
new file mode 100644
index 0000000..7874a6b
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/let-plus.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/let-plus-20191130-git/let-plus.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/local-time.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/local-time.txt
new file mode 100644
index 0000000..8f414e0
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/local-time.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/local-time-20190710-git/local-time.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/prove-asdf.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/prove-asdf.txt
new file mode 100644
index 0000000..19a2b00
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/prove-asdf.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/prove-20171130-git/prove-asdf.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/prove-test.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/prove-test.txt
new file mode 100644
index 0000000..fe21905
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/prove-test.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/prove-20171130-git/prove-test.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/installed/systems/prove.txt b/sbcl/.quicklisp/dists/quicklisp/installed/systems/prove.txt
new file mode 100644
index 0000000..5e51355
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/installed/systems/prove.txt
@@ -0,0 +1 @@
+dists/quicklisp/software/prove-20171130-git/prove.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/.travis.yml b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/.travis.yml
new file mode 100644
index 0000000..9a1fdd8
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/.travis.yml
@@ -0,0 +1,34 @@
+language: lisp
+sudo: required
+
+env:
+  matrix:
+    - LISP=abcl
+    - LISP=allegro
+    - LISP=sbcl
+    - LISP=sbcl32
+    - LISP=ccl
+    - LISP=ccl32
+    - LISP=ecl
+    - LISP=clisp
+    - LISP=clisp32
+    - LISP=cmucl
+
+matrix:
+  allow_failures:
+    # Disabled until issue #6 is fixed.
+    - env: LISP=clisp
+    - env: LISP=clisp32
+    # Disabled until cim supports cmucl.
+    - env: LISP=cmucl
+
+install:
+  - curl -L https://github.com/tokenrove/cl-travis/raw/master/install.sh | sh
+  - if [ "${LISP:(-2)}" = "32" ]; then
+      sudo apt-get install -qq -y libc6-dev-i386;
+    fi
+
+script:
+  - cl -e '(ql:quickload :anaphora/test)
+           (unless (asdf:oos :test-op :anaphora/test)
+             (uiop:quit 1))'
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/LICENSE b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/LICENSE
new file mode 100644
index 0000000..8a7316d
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/LICENSE
@@ -0,0 +1,3 @@
+;;;; This file is part of the Anaphora package Common Lisp, 
+;;;; and has been placed in Public Domain by the author, 
+;;;; Nikodemus Siivola <nikodemus@random-state.net>
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/README.md b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/README.md
new file mode 100644
index 0000000..5fa3c97
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/README.md
@@ -0,0 +1,50 @@
+# Anaphora
+
+Anaphora is the anaphoric macro collection from Hell: it includes many
+new fiends in addition to old friends like `AIF` and `AWHEN`.
+Anaphora has been placed in Public Domain by the author, [Nikodemus
+Siivola](mailto:nikodemus@random-state.net).
+
+# Installation
+
+Use [quicklisp](http://www.quicklisp.org/), and simply:
+
+```
+CL-USER(1): (ql:quickload "anaphora")
+```
+
+# Documentation
+
+Anaphoric macros provide implicit bindings for various
+operations. Extensive use of anaphoric macros is not good style,
+and probably makes you go blind as well — there's a reason why
+Anaphora claims to be from Hell.
+
+Anaphora provides two families of anaphoric macros, which can be
+identified by their names and packages (both families are also
+exported from the package `ANAPHORA`). The implicitly-bound symbol
+`ANAPHORA:IT` is also exported from all three packages.
+
+## Basic anaphora
+
+#### Exported from package `ANAPHORA-BASIC`
+
+These bind their first argument to `IT` via `LET`. In case of `COND`
+all clauses have their test-values bound to `IT`.
+
+Variants: `AAND`, `ALET`, `APROG1`, `AIF`, `ACOND`, `AWHEN`, `ACASE`,
+`ACCASE`, `AECASE`, `ATYPECASE`, `ACTYPECASE`, and `AETYPECASE`.
+
+## Symbol-macro anaphora
+
+#### Exported from package `ANAPHORA-SYMBOL`
+
+These bind their first argument (unevaluated) to `IT` via
+SYMBOL-`MACROLET.`
+
+Variants: `SOR`, `SLET`, `SIF`, `SCOND`, `SUNLESS`,
+`SWHEN`, `SCASE`, `SCCASE`, `SECASE`, `STYPECASE`, `SCTYPECASE`,
+`SETYPECASE`.
+
+Also: `ASIF`, which binds via `LET` for the
+then-clause, and `SYMBOL-MACROLET` for the else-clause.
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/anaphora.asd b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/anaphora.asd
new file mode 100644
index 0000000..d02b818
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/anaphora.asd
@@ -0,0 +1,31 @@
+;;;; -*- Mode: Lisp; Base: 10; Syntax: ANSI-Common-lisp; -*-
+
+;;;; Anaphora: The Anaphoric Macro Package from Hell
+;;;;
+;;;; This been placed in Public Domain by the author,
+;;;; Nikodemus Siivola <nikodemus@random-state.net>
+
+(defsystem :anaphora
+    :version "0.9.6"
+    :description "The Anaphoric Macro Package from Hell"
+    :author "Nikodemus Siivola <nikodemus@random-state.net>"
+    :license "Public Domain"
+    :components
+    ((:file "packages")
+     (:file "early" :depends-on ("packages"))
+     (:file "symbolic" :depends-on ("early"))
+     (:file "anaphora" :depends-on ("symbolic"))))
+
+(defsystem :anaphora/test
+    :description "Tests for anaphora"
+    :author "Nikodemus Siivola <nikodemus@random-state.net>"
+    :license "Public Domain"
+    :depends-on (:anaphora :rt)
+    :components ((:file "tests")))
+
+(defmethod perform ((o test-op) (c (eql (find-system :anaphora))))
+  (test-system :anaphora/test))
+
+(defmethod perform ((o test-op) (c (eql (find-system :anaphora/test))))
+  (or (symbol-call :rt '#:do-tests)
+      (error "test-op failed")))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/anaphora.lisp b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/anaphora.lisp
new file mode 100644
index 0000000..1cfd8e4
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/anaphora.lisp
@@ -0,0 +1,162 @@
+;;;; -*- Mode: Lisp; Base: 10; Syntax: ANSI-Common-Lisp; Package: ANAPHORA -*-
+
+;;;; Anaphora: The Anaphoric Macro Package from Hell
+;;;;
+;;;; This been placed in Public Domain by the author, 
+;;;; Nikodemus Siivola <nikodemus@random-state.net>
+
+(in-package :anaphora)
+
+;;; This was the original implementation of SYMBOLIC -- and still good
+;;; for getting the basic idea. Brian Masterbrooks solution to
+;;; infinite recusion during macroexpansion, that nested forms of this
+;;; are subject to, is in symbolic.lisp.
+;;;
+;;; (defmacro symbolic (op test &body body &environment env)
+;;;   `(symbol-macrolet ((it ,test))
+;;;        (,op it ,@body)))
+
+(defmacro alet (form &body body)
+  "Binds the FORM to IT (via LET) in the scope of the BODY."
+  `(anaphoric ignore-first ,form (progn ,@body)))
+
+(defmacro slet (form &body body)
+  "Binds the FORM to IT (via SYMBOL-MACROLET) in the scope of the BODY. IT can
+be set with SETF."
+  `(symbolic ignore-first ,form (progn ,@body)))
+
+(defmacro aand (first &rest rest)
+  "Like AND, except binds the first argument to IT (via LET) for the
+scope of the rest of the arguments."
+  `(anaphoric and ,first ,@rest))
+
+(defmacro sor (first &rest rest)
+  "Like OR, except binds the first argument to IT (via SYMBOL-MACROLET) for
+the scope of the rest of the arguments. IT can be set with SETF."
+  `(symbolic or ,first ,@rest))
+
+(defmacro aif (test then &optional else)
+  "Like IF, except binds the result of the test to IT (via LET) for
+the scope of the then and else expressions."  
+  `(anaphoric if ,test ,then ,else))
+
+(defmacro sif (test then &optional else)
+  "Like IF, except binds the test form to IT (via SYMBOL-MACROLET) for
+the scope of the then and else expressions. IT can be set with SETF"
+  `(symbolic if ,test ,then ,else))
+
+(defmacro asif (test then &optional else)
+  "Like IF, except binds the result of the test to IT (via LET) for
+the the scope of the then-expression, and the test form to IT (via
+SYMBOL-MACROLET) for the scope of the else-expression. Within scope of
+the else-expression, IT can be set with SETF."
+    `(let ((it ,test))
+       (if it
+	   ,then
+	   (symbolic ignore-first ,test ,else))))
+
+(defmacro aprog1 (first &body rest)
+  "Binds IT to the first form so that it can be used in the rest of the
+forms. The whole thing returns IT."
+  `(anaphoric prog1 ,first ,@rest))
+
+(defmacro awhen (test &body body)
+  "Like WHEN, except binds the result of the test to IT (via LET) for the scope
+of the body."
+  `(anaphoric when ,test ,@body))
+
+(defmacro swhen (test &body body)
+  "Like WHEN, except binds the test form to IT (via SYMBOL-MACROLET) for the
+scope of the body. IT can be set with SETF."
+  `(symbolic when ,test ,@body))
+
+(defmacro sunless (test &body body)
+  "Like UNLESS, except binds the test form to IT (via SYMBOL-MACROLET) for the
+scope of the body. IT can be set with SETF."
+  `(symbolic unless ,test ,@body))
+
+(defmacro acase (keyform &body cases)
+  "Like CASE, except binds the result of the keyform to IT (via LET) for the
+scope of the cases."
+  `(anaphoric case ,keyform ,@cases))
+
+(defmacro scase (keyform &body cases)
+  "Like CASE, except binds the keyform to IT (via SYMBOL-MACROLET) for the
+scope of the body. IT can be set with SETF."
+  `(symbolic case ,keyform ,@cases))
+
+(defmacro aecase (keyform &body cases)
+  "Like ECASE, except binds the result of the keyform to IT (via LET) for the
+scope of the cases."
+  `(anaphoric ecase ,keyform ,@cases))
+
+(defmacro secase (keyform &body cases)
+  "Like ECASE, except binds the keyform to IT (via SYMBOL-MACROLET) for the
+scope of the cases. IT can be set with SETF."
+  `(symbolic ecase ,keyform ,@cases))
+  
+(defmacro accase (keyform &body cases)
+  "Like CCASE, except binds the result of the keyform to IT (via LET) for the
+scope of the cases. Unlike CCASE, the keyform/place doesn't receive new values
+possibly stored with STORE-VALUE restart; the new value is received by IT."
+  `(anaphoric ccase ,keyform ,@cases))
+
+(defmacro sccase (keyform &body cases)
+  "Like CCASE, except binds the keyform to IT (via SYMBOL-MACROLET) for the
+scope of the cases. IT can be set with SETF."
+  `(symbolic ccase ,keyform ,@cases))
+
+(defmacro atypecase (keyform &body cases)
+  "Like TYPECASE, except binds the result of the keyform to IT (via LET) for
+the scope of the cases."
+  `(anaphoric typecase ,keyform ,@cases))
+
+(defmacro stypecase (keyform &body cases)
+  "Like TYPECASE, except binds the keyform to IT (via SYMBOL-MACROLET) for the
+scope of the cases. IT can be set with SETF."
+  `(symbolic typecase ,keyform ,@cases))
+
+(defmacro aetypecase (keyform &body cases)
+  "Like ETYPECASE, except binds the result of the keyform to IT (via LET) for
+the scope of the cases."
+  `(anaphoric etypecase ,keyform ,@cases))
+
+(defmacro setypecase (keyform &body cases)
+  "Like ETYPECASE, except binds the keyform to IT (via SYMBOL-MACROLET) for
+the scope of the cases. IT can be set with SETF."
+  `(symbolic etypecase ,keyform ,@cases))
+
+(defmacro actypecase (keyform &body cases)
+  "Like CTYPECASE, except binds the result of the keyform to IT (via LET) for
+the scope of the cases. Unlike CTYPECASE, new values possible stored by the
+STORE-VALUE restart are not received by the keyform/place, but by IT."
+  `(anaphoric ctypecase ,keyform ,@cases))
+
+(defmacro sctypecase (keyform &body cases)
+  "Like CTYPECASE, except binds the keyform to IT (via SYMBOL-MACROLET) for
+the scope of the cases. IT can be set with SETF."
+  `(symbolic ctypecase ,keyform ,@cases))
+
+(defmacro acond (&body clauses)
+  "Like COND, except result of each test-form is bound to IT (via LET) for the
+scope of the corresponding clause."
+  (labels ((rec (clauses)
+	     (if clauses
+		 (destructuring-bind ((test &body body) . rest)  clauses
+		   (if body
+		       `(anaphoric if ,test (progn ,@body) ,(rec rest))
+		       `(anaphoric if ,test it ,(rec rest))))
+		 nil)))
+    (rec clauses)))
+
+(defmacro scond (&body clauses)
+  "Like COND, except each test-form is bound to IT (via SYMBOL-MACROLET) for the
+scope of the corresponsing clause. IT can be set with SETF."
+  (labels ((rec (clauses)
+	     (if clauses
+		 (destructuring-bind ((test &body body) . rest) clauses
+		   (if body
+		       `(symbolic if ,test (progn ,@body) ,(rec rest))
+		       `(symbolic if ,test it ,(rec rest))))
+		 nil)))
+    (rec clauses)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/early.lisp b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/early.lisp
new file mode 100644
index 0000000..db044af
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/early.lisp
@@ -0,0 +1,20 @@
+;;;; -*- Mode: Lisp; Base: 10; Syntax: ANSI-Common-Lisp; Package: ANAPHORA -*-
+
+;;;; Anaphora: The Anaphoric Macro Package from Hell
+;;;;
+;;;; This been placed in Public Domain by the author, 
+;;;; Nikodemus Siivola <nikodemus@random-state.net>
+
+(in-package :anaphora)
+
+(defmacro with-unique-names ((&rest bindings) &body body)
+  `(let ,(mapcar #'(lambda (binding)
+		     (destructuring-bind (var prefix)
+			 (if (consp binding) binding (list binding binding))
+		       `(,var (gensym ,(string prefix)))))
+		 bindings)
+     ,@body))
+
+(defmacro ignore-first (first expr)
+  (declare (ignore first))
+  expr)
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/packages.lisp b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/packages.lisp
new file mode 100644
index 0000000..3b36730
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/packages.lisp
@@ -0,0 +1,90 @@
+;;;; -*- Mode: Lisp; Base: 10; Syntax: ANSI-Common-Lisp; Package: CL-USER -*-
+
+;;;; Anaphora: The Anaphoric Macro Package from Hell
+;;;;
+;;;; This been placed in Public Domain by the author, 
+;;;; Nikodemus Siivola <nikodemus@random-state.net>
+
+(defpackage :anaphora
+  (:use :cl)
+  (:export
+   #:it
+   #:alet
+   #:slet
+   #:aif
+   #:aand
+   #:sor
+   #:awhen
+   #:aprog1
+   #:acase
+   #:aecase
+   #:accase
+   #:atypecase
+   #:aetypecase
+   #:actypecase
+   #:acond
+   #:sif
+   #:asif
+   #:swhen
+   #:sunless
+   #:scase
+   #:secase
+   #:sccase
+   #:stypecase
+   #:setypecase
+   #:sctypecase
+   #:scond)
+  (:documentation 
+   "ANAPHORA provides a full complement of anaphoric macros. Subsets of the
+functionality provided by this package are exported from ANAPHORA-BASIC and
+ANAPHORA-SYMBOL."))
+
+(defpackage :anaphora-basic
+  (:use :cl :anaphora)
+  (:export
+   #:it
+   #:alet
+   #:aif
+   #:aand
+   #:awhen
+   #:aprog1
+   #:acase
+   #:aecase
+   #:accase
+   #:atypecase
+   #:aetypecase
+   #:actypecase
+   #:acond)
+  (:documentation 
+   "ANAPHORA-BASIC provides all normal anaphoric constructs, which bind
+primary values to IT."))
+   
+(defpackage :anaphora-symbol
+  (:use :cl :anaphora)
+  (:export
+   #:it
+   #:slet
+   #:sor
+   #:sif
+   #:asif
+   #:swhen
+   #:sunless
+   #:scase
+   #:secase
+   #:sccase
+   #:stypecase
+   #:setypecase
+   #:sctypecase
+   #:scond)
+  (:documentation
+   "ANAPHORA-SYMBOL provides ``symbolic anaphoric macros'', which bind forms
+to IT via SYMBOL-MACROLET. 
+
+Examples:
+
+  (sor (gethash key table) (setf it default))
+
+  (asif (gethash key table)
+        (foo it)            ; IT is a value bound by LET here
+        (setf it default))  ; IT is the GETHASH form bound by SYMBOL-MACROLET here
+"))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/symbolic.lisp b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/symbolic.lisp
new file mode 100644
index 0000000..686c6fd
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/symbolic.lisp
@@ -0,0 +1,54 @@
+;;;; -*- Mode: Lisp; Base: 10; Syntax: ANSI-Common-Lisp; Package: ANAPHORA -*-
+
+;;;; Copyright (c) 2003 Brian Mastenbrook
+
+;;;; Permission is hereby granted, free of charge, to any person obtaining
+;;;; a copy of this software and associated documentation files (the
+;;;; "Software"), to deal in the Software without restriction, including
+;;;; without limitation the rights to use, copy, modify, merge, publish,
+;;;; distribute, sublicense, and/or sell copies of the Software, and to
+;;;; permit persons to whom the Software is furnished to do so, subject to
+;;;; the following conditions:
+
+;;;; The above copyright notice and this permission notice shall be
+;;;; included in all copies or substantial portions of the Software.
+
+;;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+;;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+;;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+;;;; IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+;;;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+;;;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+;;;; SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+(in-package :anaphora)
+
+(defmacro internal-symbol-macrolet (&rest whatever)
+  `(symbol-macrolet ,@whatever))
+
+(define-setf-expander internal-symbol-macrolet (binding-forms place &environment env)
+  (multiple-value-bind (dummies vals newvals setter getter)
+      (get-setf-expansion place env)
+    (values dummies
+	    (substitute `(symbol-macrolet ,binding-forms it) 'it vals)
+	    newvals
+	    `(symbol-macrolet ,binding-forms ,setter)
+	    `(symbol-macrolet ,binding-forms ,getter))))
+
+(with-unique-names (s-indicator current-s-indicator)
+  (defmacro symbolic (operation test &rest other-args)
+    (with-unique-names (this-s)
+      (let ((current-s (get s-indicator current-s-indicator)))
+        (setf (get s-indicator current-s-indicator) this-s)
+        `(symbol-macrolet
+             ((,this-s (internal-symbol-macrolet ((it ,current-s)) ,test))
+              (it ,this-s))
+           (,operation it ,@other-args)))))
+
+  (defmacro anaphoric (op test &body body)  
+    (with-unique-names (this-s)
+      (setf (get s-indicator current-s-indicator) this-s)
+      `(let* ((it ,test)
+              (,this-s it))
+         (declare (ignorable ,this-s))
+         (,op it ,@body)))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/tests.lisp b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/tests.lisp
new file mode 100644
index 0000000..e4a26fc
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/anaphora-20191007-git/tests.lisp
@@ -0,0 +1,427 @@
+;;;; Anaphora: The Anaphoric Macro Package from Hell
+;;;;
+;;;; This been placed in Public Domain by the author,
+;;;; Nikodemus Siivola <nikodemus@random-state.net>
+
+(defpackage :anaphora-test
+  (:use :cl :anaphora :rt))
+
+(in-package :anaphora-test)
+
+(deftest alet.1
+    (alet (1+ 1)
+      (1+ it))
+  3)
+
+(deftest alet.2
+    (alet (1+ 1)
+      it
+      (1+ it))
+  3)
+
+(deftest slet.1
+    (let ((x (list 1 2 3)))
+      (slet (car x)
+	(incf it) (values it x)))
+  2 (2 2 3))
+
+(deftest aand.1
+    (aand (+ 1 1)
+	  (+ 1 it))
+  3)
+
+(deftest aand.2
+    (aand 1 t (values it 2))
+  1 2)
+
+(deftest aand.3
+    (let ((x 1))
+      (aand (incf x) t t (values t it)))
+  t 2)
+
+(deftest aand.4
+    (aand 1 (values t it))
+  t 1)
+
+#+(or)
+;;; bug or a feature? forms like this expand to
+;;;
+;;; (let ((it (values ...))) (and it ...))
+;;;
+(deftest aand.5
+    (aand (values nil t) it)
+  nil t)
+
+(deftest sor.1
+    (let ((x (list nil)))
+      (sor (car x)
+	   (setf it t))
+      x)
+  (t))
+
+(deftest aif.1
+    (aif (+ 1 1)
+	 (+ 1 it)
+	 :never)
+  3)
+
+(deftest aif.2
+    (let ((x 0))
+      (aif (incf x)
+	   it
+	   :never))
+  1)
+
+(deftest aif.3
+    (let ((x 0))
+      (aif (eval `(and ,(incf x) nil))
+	   :never
+	   (list it x)))
+  (nil 1))
+
+(deftest sif.1
+    (let ((x (list nil)))
+      (sif (car x)
+	   (setf it :oops)
+	   (setf it :yes!))
+      (car x))
+  :yes!)
+
+(deftest sif.2
+    (let ((x (list t)))
+      (sif (car x)
+	   (setf it :yes!)
+	   (setf it :oops))
+      (car x))
+  :yes!)
+
+(deftest sif.3
+    (sif (list 1 2 3)
+	 (sif (car it)
+	      (setf it 'a)
+	      :foo))
+  a)
+
+(deftest sif.4
+    (progn
+      (defclass sif.4 ()
+	((a :initform (list :sif))))
+      (with-slots (a)
+	  (make-instance 'sif.4)
+	(sif a
+	     (sif (car it)
+		  it))))
+  :sif)
+
+(deftest asif.1
+    (let ((x (list 0)))
+      (asif (incf (car x))
+	    it
+	    (list :oops it)))
+  1)
+
+(deftest asif.2
+    (let ((x (list nil)))
+      (asif (car x)
+	    (setf x :oops)
+	    (setf it :yes!))
+      x)
+  (:yes!))
+
+(deftest awhen.1
+    (let ((x 0))
+      (awhen (incf x)
+	(+ 1 it)))
+  2)
+
+(deftest awhen.2
+    (let ((x 0))
+      (or (awhen (not (incf x))
+	    t)
+	  x))
+  1)
+
+(deftest swhen.1
+    (let ((x 0))
+      (swhen x
+	(setf it :ok))
+      x)
+  :ok)
+
+(deftest swhen.2
+    (let ((x nil))
+      (swhen x
+	(setf it :oops))
+      x)
+  nil)
+
+(deftest sunless.1
+    (let ((x nil))
+      (sunless x
+	(setf it :ok))
+      x)
+  :ok)
+
+(deftest sunless.2
+    (let ((x t))
+      (sunless x
+	(setf it :oops))
+      x)
+  t)
+
+(deftest acase.1
+    (let ((x 0))
+      (acase (incf x)
+	(0 :no)
+	(1 (list :yes it))
+	(2 :nono)))
+  (:yes 1))
+
+(deftest scase.1
+    (let ((x (list 3)))
+      (scase (car x)
+	(0 (setf it :no))
+	(3 (setf it :yes!))
+	(t (setf it :nono)))
+      x)
+  (:yes!))
+
+(deftest aecase.1
+    (let ((x (list :x)))
+      (aecase (car x)
+	(:y :no)
+        (:x (list it :yes))))
+  (:x :yes))
+
+(deftest aecase.2
+    (nth-value 0 (ignore-errors
+		   (let ((x (list :x)))
+		     (secase (car x)
+			     (:y :no)))
+		   :oops))
+  nil)
+
+(deftest secase.1
+    (let ((x (list :x)))
+      (secase (car x)
+	      (:y (setf it :no))
+	      (:x (setf it :yes)))
+      x)
+  (:yes))
+
+(deftest secase.2
+    (nth-value 0 (ignore-errors
+		   (let ((x (list :x)))
+		     (secase (car x)
+			     (:y (setf it :no)))
+		     :oops)))
+  nil)
+
+(deftest accase.1
+    (let ((x (list :x)))
+      (accase (car x)
+	      (:y :no)
+	      (:x (list it :yes))))
+  (:x :yes))
+
+(deftest accase.2
+    (let ((x (list :x)))
+      (handler-bind ((type-error (lambda (e) (store-value :z e))))
+	(accase (car x)
+		(:y (setf x :no))
+		(:z (setf x :yes))))
+      x)
+  :yes)
+
+(deftest accase.3
+    (let ((x (list :x)))
+      (accase (car x)
+	      (:x (setf it :foo)))
+      x)
+  (:x))
+
+(deftest sccase.1
+    (let ((x (list :x)))
+      (sccase (car x)
+	      (:y (setf it :no))
+	      (:x (setf it :yes)))
+      x)
+  (:yes))
+
+(deftest sccase.2
+    (let ((x (list :x)))
+      (handler-bind ((type-error (lambda (e) (store-value :z e))))
+	(sccase (car x)
+		(:y (setf it :no))
+		(:z (setf it :yes))))
+      x)
+  (:yes))
+
+(deftest atypecase.1
+    (atypecase 1.0
+       (integer (+ 2 it))
+       (float (1- it)))
+  0.0)
+
+(deftest atypecase.2
+    (atypecase "Foo"
+       (fixnum :no)
+       (hash-table :nono))
+  nil)
+
+(deftest stypecase.1
+    (let ((x (list 'foo)))
+      (stypecase (car x)
+	 (vector (setf it :no))
+	 (symbol (setf it :yes)))
+      x)
+  (:yes))
+
+(deftest stypecase.2
+    (let ((x (list :bar)))
+      (stypecase (car x)
+	 (fixnum (setf it :no)))
+      x)
+  (:bar))
+
+(deftest aetypecase.1
+    (aetypecase 1.0
+       (fixnum (* 2 it))
+       (float (+ 2.0 it))
+       (symbol :oops))
+  3.0)
+
+(deftest aetypecase.2
+    (nth-value 0 (ignore-errors
+		   (aetypecase 1.0
+		       (symbol :oops))))
+  nil)
+
+(deftest setypecase.1
+    (let ((x (list "Foo")))
+      (setypecase (car x)
+	  (symbol (setf it :no))
+	  (string (setf it "OK"))
+	  (integer (setf it :noon)))
+      x)
+  ("OK"))
+
+(deftest setypecase.2
+    (nth-value 0 (ignore-errors
+		   (setypecase 'foo
+		       (string :nono))))
+  nil)
+
+(deftest actypecase.1
+    (actypecase :foo
+       (string (list :string it))
+       (keyword (list :keyword it))
+       (symbol (list :symbol it)))
+  (:keyword :foo))
+
+(deftest actypecase.2
+    (handler-bind ((type-error (lambda (e) (store-value "OK" e))))
+      (actypecase 0
+	 (string it)))
+  "OK")
+
+(deftest sctypecase.1
+    (let ((x (list 0)))
+      (sctypecase (car x)
+	 (symbol (setf it 'symbol))
+	 (bit (setf it 'bit)))
+      x)
+  (bit))
+
+(deftest sctypecase.2
+    (handler-bind ((type-error (lambda (e) (store-value "OK" e))))
+      (let ((x (list 0)))
+	(sctypecase (car x)
+	  (string (setf it :ok)))
+	x))
+  (:ok))
+
+(deftest acond.1
+    (acond (:foo))
+  :foo)
+
+(deftest acond.2
+    (acond ((null 1) (list :no it))
+	   ((+ 1 2) (list :yes it))
+	   (t :nono))
+  (:yes 3))
+
+(deftest acond.3
+    (acond ((= 1 2) :no)
+	   (nil :nono)
+	   (t :yes))
+  :yes)
+
+;; Test COND with multiple forms in the implicit progn.
+(deftest acond.4
+    (let ((foo))
+      (acond ((+ 2 2) (setf foo 38) (incf foo it) foo)
+	     (t nil)))
+  42)
+
+(deftest scond.1
+    (let ((x (list nil))
+	  (y (list t)))
+      (scond ((car x) (setf it :nono))
+	     ((car y) (setf it :yes)))
+      (values x y))
+  (nil)
+  (:yes))
+
+(deftest scond.2
+    (scond ((= 1 2) :no!))
+  nil)
+
+(deftest aprog.1
+    (aprog1 :yes
+        (unless (eql it :yes) (error "Broken."))
+      :no)
+  :yes)
+
+(deftest aif.sif.1
+    (sif 1 (aif it it))
+  1)
+
+(deftest aif.sif.2
+    (aif 1 (sif it it))
+  1)
+
+(deftest aif.sif.3
+    (aif (list 1 2 3)
+        (sif (car it)
+             (setf it 'a)
+             :foo))
+  a)
+
+(deftest alet.slet.1
+    (slet 42 (alet 43 (slet it it)))
+  43)
+
+
+(defun elt-like (index seq)
+  (elt seq index))
+
+(define-setf-expander elt-like (index seq)
+  (let ((index-var (gensym "index"))
+	(seq-var (gensym "seq"))
+	(store (gensym "store")))
+    (values (list index-var seq-var)
+	    (list index seq)
+	    (list store)
+	    `(if (listp ,seq-var)
+		 (setf (nth ,index-var ,seq-var) ,store)
+		 (setf (aref ,seq-var ,index-var) ,store))
+	    `(if (listp ,seq-var)
+		 (nth ,index-var ,seq-var)
+		 (aref ,seq-var ,index-var)))))
+
+(deftest symbolic.setf-expansion.1
+    (let ((cell (list nil)))
+      (sor (elt-like 0 cell) (setf it 1))
+      (equal cell '(1)))
+  t)
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/.travis.yml b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/.travis.yml
new file mode 100644
index 0000000..033c340
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/.travis.yml
@@ -0,0 +1,13 @@
+before_script:
+        - curl -O -L http://prdownloads.sourceforge.net/sbcl/sbcl-1.2.6-x86-64-linux-binary.tar.bz2
+        - tar xjf sbcl-1.2.6-x86-64-linux-binary.tar.bz2
+        - pushd sbcl-1.2.6-x86-64-linux/ && sudo bash install.sh && popd
+        - curl -O -L http://beta.quicklisp.org/quicklisp.lisp
+        - sbcl --load quicklisp.lisp --eval '(quicklisp-quickstart:install)' --eval '(quit)'
+        - curl -OL http://ccl.clozure.com/ftp/pub/release/1.10/ccl-1.10-linuxx86.tar.gz
+        - tar xzf ccl-1.10-linuxx86.tar.gz
+        - export PATH=`pwd`/ccl:$PATH
+#        - lx86cl64 -b --load quicklisp.lisp --eval '(progn (quicklisp-quickstart:install) (quit))'
+
+script:
+        - ./ci-test-run.sh
\ No newline at end of file
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/README.md b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/README.md
new file mode 100644
index 0000000..45fad05
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/README.md
@@ -0,0 +1,140 @@
+# cl-ansi-text
+
+Because color in your terminal is nice.
+[![Build Status](https://travis-ci.org/pnathan/cl-ansi-text.svg?branch=master)](https://travis-ci.org/pnathan/cl-ansi-text)
+
+## Usage example -
+```lisp
+* (ql:quickload :cl-ansi-text)
+;To load "cl-ansi-text":
+;  Load 1 ASDF system:
+;    cl-ansi-text
+;; Loading "cl-ansi-text"
+; => (:CL-ANSI-TEXT)
+```
+
+The main macro is called `with-color`, which creates an enviroment where everything that is put on `stream` gets colored according to `color`. Color options are `:black`, `:red`, `:green`, `:yellow`, `:blue`, `:magenta`, `:cyan` and `:white`. You can also use a color structure from `CL-COLORS`, like `cl-colors:+red+`.
+
+```lisp
+* (import 'cl-ansi-text:with-color)
+; => T
+* (with-color (:red)
+    (princ "Gets printed red...")
+    (princ "and this too!"))
+; Gets printed red...and this too!
+; => "and this too!"
+```
+
+There are also functions with the name of the colors, that return the string, colored:
+```lisp
+* (import 'cl-ansi-text:yellow)
+; => T
+* (yellow "Yellow string")
+; => "Yellow string"
+* (princ (yellow "String with yellow background" :style :background))
+; "String with yellow background"
+; => "String with yellow background"
+* (import 'cl-ansi-text:red)
+; => T
+* (princ
+   (concatenate
+    'string
+    (yellow "Five") " test results went " (red "terribly wrong") "!"))
+; Five test results went terribly wrong!
+; => "Five test results went terribly wrong!"
+```
+At any point, you can bind the `*enabled*` special variable to `nil`, and anything inside that binding will not be printed colorfully:
+```lisp
+* (let (cl-ansi-text:*enabled*)
+    (princ (red "This string is printed normally")))
+```
+
+# API
+
+
+## BLUE
+
+Returns a string with the `blue'string denotation preppended and the `reset' string denotation appended.
+
+*enabled* dynamically controls the function.
+
+## MAGENTA
+
+Returns a string with the `magenta'string denotation preppended and the `reset' string denotation appended.
+
+*enabled* dynamically controls the function.
+
+## CYAN
+
+Returns a string with the `cyan'string denotation preppended and the `reset' string denotation appended.
+
+*enabled* dynamically controls the function.
+
+## GREEN
+
+Returns a string with the `green'string denotation preppended and the `reset' string denotation appended.
+
+*enabled* dynamically controls the function.
+
+## WITH-COLOR
+
+Writes out the string denoting a switch to `color`, executes body,
+then writes out the string denoting a `reset`.
+
+*enabled* dynamically controls expansion..
+
+## YELLOW
+
+Returns a string with the `yellow'string denotation preppended and the `reset' string denotation appended.
+
+*enabled* dynamically controls the function.
+
+## BLACK
+
+Returns a string with the `black'string denotation preppended and the `reset' string denotation appended.
+
+*enabled* dynamically controls the function.
+
+## *ENABLED*
+
+Turns on/off the colorization of functions
+
+## MAKE-COLOR-STRING
+
+Takes either a cl-color or a list denoting the ANSI colors and
+returns a string sufficient to change to the given color.
+
+Will be dynamically controlled by *enabled* unless manually specified
+otherwise
+
+## RED
+
+Returns a string with the `red'string denotation preppended and the `reset' string denotation appended.
+
+*enabled* dynamically controls the function.
+
+## WHITE
+
+Returns a string with the `white'string denotation preppended and the `reset' string denotation appended.
+
+*enabled* dynamically controls the function.
+
+## +RESET-COLOR-STRING+
+
+This string will reset ANSI colors
+
+
+# Note
+
+Note that your terminal MUST be ANSI-compliant to show these
+colors. My SLIME REPL (as of Feb 2013) does not display these
+colors. I have to use a typical Linux/OSX terminal to see them.
+
+This has been tested to work on a Linux system with SBCL, CLISP and
+CCL. CCL may not work quite perfectly, some level of conniptions were
+encountered in testing. The interested reader is advised to check the
+MAKE-LOAD-FORM defmethod in cl-ansi-text.lisp.
+
+An earlier variant was tested on OSX 10.6 with SBCL.
+
+License: LLGPL
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/ci-test-run.sh b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/ci-test-run.sh
new file mode 100644
index 0000000..25e8107
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/ci-test-run.sh
@@ -0,0 +1,15 @@
+#!/bin/bash
+error=0
+if which sbcl; then
+    echo "CI run using SBCL"
+    sbcl --script run-tests.lisp
+    error=$?
+fi
+
+if which lx86cl64; then
+   echo "CI run using CCL"
+   lx86cl64 -b --load run-tests.lisp
+   error=$(($error+$?))
+fi
+
+exit $error
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/cl-ansi-text-test.asd b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/cl-ansi-text-test.asd
new file mode 100644
index 0000000..73cee9c
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/cl-ansi-text-test.asd
@@ -0,0 +1,11 @@
+(asdf:defsystem #:cl-ansi-text-test
+  :depends-on ( #:cl-colors #:alexandria #:cl-ansi-text #:fiveam)
+  :components ((:module "test"
+                :components
+                ((:file "cl-ansi-text-test"))))
+  :name "cl-ansi-text-test"
+  :version "1.0"
+  :maintainer "Paul Nathan"
+  :author "Paul Nathan"
+  :licence "LLGPL"
+  :description "Test system for cl-ansi-text")
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/cl-ansi-text.asd b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/cl-ansi-text.asd
new file mode 100644
index 0000000..a29781f
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/cl-ansi-text.asd
@@ -0,0 +1,11 @@
+(asdf:defsystem #:cl-ansi-text
+  :depends-on ( #:cl-colors #:alexandria)
+  :components ((:file "cl-ansi-text"))
+  :name "cl-ansi-text"
+  :version "1.0"
+  :maintainer "Paul Nathan"
+  :author "Paul Nathan"
+  :licence "LLGPL"
+  :description "ANSI control string characters, focused on color"
+  :long-description "ANSI control string management, specializing in
+  colors. Sometimes it is nice to have text output in colors")
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/cl-ansi-text.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/cl-ansi-text.lisp
new file mode 100644
index 0000000..7cba11c
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/cl-ansi-text.lisp
@@ -0,0 +1,285 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;; Paul Nathan 2013
+;;;; cl-ansi-text.lisp
+;;;;
+;;;; Portions of this code were written by taksatou under the
+;;;; cl-rainbow name.
+;;;;
+;;;; A library to produce ANSI escape sequences. Particularly,
+;;;; produces colorized text on terminals
+
+(defpackage :cl-ansi-text
+  (:use :common-lisp)
+  (:export
+   #:with-color
+   #:make-color-string
+   #:+reset-color-string+
+   #:*enabled*
+   #:black
+   #:red
+   #:green
+   #:yellow
+   #:blue
+   #:magenta
+   #:cyan
+   #:white))
+(in-package :cl-ansi-text)
+
+;;; !!! NOTE TO CCL USERS !!!
+;;;
+;;; This seems to be *required* to make this compile in CCL. The
+;;; reason is that CCL expects to be able to inline on compile, but
+;;; structs don't set up that infrastructure by default.
+;;;
+;;; At least from the thread "Compiler problem, MCL 3.9" by Arthur
+;;; Cater around '96.
+#+ccl(common-lisp:eval-when (:compile-toplevel :load-toplevel :execute)
+       (defmethod make-load-form ((obj cl-colors:rgb )  &optional env)
+	 (make-load-form-saving-slots obj)))
+
+(defparameter *enabled* t
+  "Turns on/off the colorization of functions")
+
+(defparameter +reset-color-string+
+  (concatenate 'string (list (code-char 27) #\[ #\0 #\m))
+  "This string will reset ANSI colors")
+
+(defvar +cl-colors+
+  (vector
+   cl-colors:+black+
+   cl-colors:+red+
+   cl-colors:+green+
+   cl-colors:+yellow+
+   cl-colors:+blue+
+   cl-colors:+magenta+
+   cl-colors:+cyan+
+   cl-colors:+white+)
+  "CL-COLORS colors")
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (defparameter +term-colors+
+    (vector
+     :black
+     :red
+     :green
+     :yellow
+     :blue
+     :magenta
+     :cyan
+     :white)
+    "Basic colors"))
+
+(defparameter +text-style+
+  '((:foreground . 30)
+    (:background . 40))
+  "One or the other. Not an ANSI effect")
+
+(defparameter +term-effects+
+  '((:unset . t)
+    (:reset . 0)
+    (:bright . 1)
+    (:italic . 3)
+    (:underline . 4)
+    (:blink . 5)
+    (:inverse . 7)
+    (:hide . 8)
+    (:normal . 22)
+    (:framed . 51)
+    (:encircled . 52)
+    (:overlined . 53)
+    (:not-framed-or-circled . 54)
+    (:not-overlined . 55))
+  "ANSI terminal effects")
+
+(defun eq-colors (a b)
+  "Equality for cl-colors"
+
+  ;; CL-COLORS LIB!
+
+  ;; eql, equal doesn't quite work for compiled cl-colors on CCL
+  (and
+   (= (cl-colors:rgb-red a)
+      (cl-colors:rgb-red b))
+   (= (cl-colors:rgb-green a)
+      (cl-colors:rgb-green b))
+   (= (cl-colors:rgb-blue a)
+      (cl-colors:rgb-blue b))))
+
+(defun cl-colors-to-ansi (color)
+  (position color +cl-colors+ :test #'eq-colors))
+
+(defun term-colors-to-ansi (color)
+  (position color +term-colors+))
+
+
+
+;; Find-X-code is the top-level interface for code-finding
+
+(defun find-color-code (color)
+  "Find the list denoting the color"
+  (typecase color
+    ;; Did we get a cl-color that we know about?
+    (cl-colors:rgb (cl-colors-to-ansi color))
+    (symbol (term-colors-to-ansi color))))
+
+(defun find-effect-code (effect)
+  "Returns the number for the text effect OR
+t if no effect should be used OR
+nil if the effect is unknown.
+
+effect should be a member of +term-effects+"
+  (cdr (assoc effect +term-effects+)))
+
+(defun find-style-code (style)
+  (cdr (assoc style +text-style+)))
+
+(defun rgb-code-p (color)
+  (typecase color
+    (list t)
+    (integer t)))
+
+(defun generate-control-string (code)
+  "General ANSI code"
+  (format nil "~c[~a" (code-char #o33) code))
+
+(defun generate-color-string (code)
+  ;; m is the action character for color
+  (format nil "~am" (generate-control-string code)))
+
+(defun build-control-string (color
+			     &optional
+			     (effect :unset)
+			     (style :foreground))
+  "Color (cl-color or term-color)
+Effect
+Style"
+  (let ((effect-code (find-effect-code effect))
+	(color-code (find-color-code color))
+	(style-code (find-style-code style)))
+
+    ;; Nil here indicates an error
+    (assert  effect-code)
+    (assert  style-code)
+
+    ;; Returns a list for inspection; next layer turns it back into a
+    ;; string.
+    (concatenate
+     'list
+     ;; We split between RGB and 32-color here; this preserves the
+     ;; interface without cluttering the 32-color code up.
+     ;;
+     (let ((codes nil))
+       (unless (eq effect-code t)
+           (setf codes (cons effect-code codes)))
+       (if (rgb-code-p color)
+           (setf codes (cons (rgb-color-code color style) codes))
+           (setf codes (cons (+ style-code color-code) codes)))
+
+       (generate-color-string (format nil "~{~A~^;~}" codes))))))
+
+;; Public callables.
+
+(defun make-color-string (color &key
+				  (effect :unset)
+				  (style :foreground)
+				  ((enabled *enabled*) *enabled*))
+  "Takes either a cl-color or a list denoting the ANSI colors and
+returns a string sufficient to change to the given color.
+
+Will be dynamically controlled by *enabled* unless manually specified
+otherwise"
+  (when *enabled*
+    (concatenate 'string
+		 (build-control-string color effect style))))
+
+(defmacro with-color ((color  &key
+			      (stream t)
+			      (effect :unset)
+			      (style :foreground))
+		      &body body)
+  "Writes out the string denoting a switch to `color`, executes body,
+then writes out the string denoting a `reset`.
+
+*enabled* dynamically controls expansion.."
+  `(progn
+     (when *enabled*
+      (format ,stream "~a" (make-color-string ,color
+					      :effect ,effect
+					      :style ,style)))
+     (unwind-protect
+	 (progn
+	   ,@body)
+      (when *enabled*
+	(format ,stream "~a" +reset-color-string+)))))
+
+(defmacro gen-color-functions (color-names-vector)
+  `(progn
+     ,@(map 'list
+            (lambda (color)
+              `(defun ,(intern (symbol-name color)) (string &key
+                                                              (effect :unset)
+                                                              (style :foreground))
+                 ,(concatenate
+                   'string
+                   "Returns a string with the `" (string-downcase color)
+                   "'string denotation preppended and the `reset' string denotation appended.
+
+*enabled* dynamically controls the function." )
+                 (concatenate
+                  'string
+                  (when *enabled*
+                    (format nil "~a" (make-color-string ,color
+                                                        :effect effect
+                                                        :style style)))
+                  string
+                  (when *enabled*
+                    (format nil "~a" +reset-color-string+)))))
+            color-names-vector)))
+
+(gen-color-functions #.(coerce +term-colors+ 'list))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  RGB color codes for some enhanced terminals
+
+;;; http://www.frexx.de/xterm-256-notes/
+(defun rgb-to-ansi (red green blue)
+  (let ((ansi-domain (mapcar #'(lambda (x)
+                                 (floor (* 6 (/ x 256.0))))
+                             (list red green blue))))
+    (+ 16
+     (* 36 (first ansi-domain))
+     (* 6 (second ansi-domain))
+     (third ansi-domain))))
+
+(defun code-from-rgb (style red green blue)
+  (format nil "~d;5;~d"
+	  (if (eql style :foreground) 38 48)
+          (rgb-to-ansi red green blue)))
+
+
+(defgeneric rgb-color-code (color &optional style)
+  (:documentation
+   "Returns the 256-color code suitable for rendering on the Linux
+extensions to xterm"))
+
+(defmethod rgb-color-code ((color list) &optional (style :foreground))
+  (unless (consp color)
+    (error "~a must be a three-integer list" color))
+
+  (unless (and (integerp (first color))
+               (integerp (second color))
+               (integerp (second color)))
+    (error "~a must have three integers" color))
+
+  (code-from-rgb style
+                 (first color)
+                 (second color)
+                 (third color)))
+
+(defmethod rgb-color-code ((color integer) &optional (style :foreground))
+  ;; Takes RGB integer ala Web integers
+  (code-from-rgb style
+                 ;; classic bitmask
+                 (ash  (logand color #xff0000) -16)
+                 (ash  (logand color #x00ff00) -8)
+                 (logand color #x0000ff)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/run-tests.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/run-tests.lisp
new file mode 100644
index 0000000..f369b89
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/run-tests.lisp
@@ -0,0 +1,29 @@
+#-quicklisp
+(let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp"
+                                       (user-homedir-pathname))))
+  (when (probe-file quicklisp-init)
+    (load quicklisp-init)))
+
+#+sbcl(require "sb-posix")
+
+(defparameter *pwd*
+  (concatenate 'string
+               (progn #+sbcl(sb-posix:getcwd)
+                      #+ccl(ccl::current-directory-name))
+               "/"))
+
+(push *pwd* asdf:*central-registry*)
+
+
+(ql:quickload '(:cl-colors
+                :alexandria
+                :fiveam
+
+                :cl-ansi-text
+                :cl-ansi-text-test))
+
+(let ((result-status (cl-ansi-text-test::ci-run)))
+  (let ((posix-status
+          (if result-status 0 1)))
+    #+sbcl(sb-posix:exit posix-status)
+    #+ccl (quit posix-status)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/test/cl-ansi-text-test.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/test/cl-ansi-text-test.lisp
new file mode 100644
index 0000000..20cfc04
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ansi-text-20150804-git/test/cl-ansi-text-test.lisp
@@ -0,0 +1,123 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; test suite for cl-ansi-text
+
+(defpackage :cl-ansi-text-test
+  (:use :common-lisp
+        :cl-user
+        :cl-ansi-text
+        :fiveam))
+
+(in-package :cl-ansi-text-test)
+(use-package :fiveam)
+(use-package :cl-ansi-text)
+
+(def-suite test-suite
+    :description "test suite.")
+
+(in-suite test-suite)
+
+
+(test basic-color-strings
+  "Test the basic stuff"
+  (is (equal '(#\Esc #\[ #\3 #\1 #\m)
+             (cl-ansi-text::build-control-string :red :unset :foreground)))
+  (is (equal '(#\Esc #\[ #\4 #\1 #\m)
+             (cl-ansi-text::build-control-string :red :unset :background)))
+  (is (equal '(#\Esc #\[ #\4 #\2 #\; #\1 #\m)
+             (cl-ansi-text::build-control-string :green :bright :background))))
+
+(test enabled-connectivity
+  "Test *enabled*'s capability"
+ (is (equal  '(#\Esc #\[ #\3 #\1 #\m)
+             (let ((*enabled* t))
+               (concatenate
+                'list
+                (cl-ansi-text:make-color-string :red)))))
+ (is (equal  '()
+            (let ((*enabled* nil))
+              (concatenate
+               'list
+               (cl-ansi-text:make-color-string :red)))))
+ (is (equal "hi"
+            (let ((*enabled* nil))
+              (with-output-to-string (s)
+                (with-color (:red :stream s) (format s "hi"))))))
+ (is (equal '(#\Esc #\[ #\3 #\1 #\m #\T #\e #\s #\t #\! #\Esc #\[ #\0 #\m)
+            (concatenate
+             'list
+             (with-output-to-string (s)
+               (with-color (:red :stream s)
+                 (format s "Test!")))))))
+
+(test rgb-suite
+  "Test RGB colors"
+  (is (equal '(#\Esc #\[ #\3 #\8 #\; #\5 #\; #\2 #\1 #\4 #\m)
+             (cl-ansi-text::build-control-string #xFFAA00
+                                                 :unset :foreground)))
+  (is (equal '(#\Esc #\[ #\4 #\8 #\; #\5 #\; #\2 #\1 #\4 #\m)
+             (cl-ansi-text::build-control-string #xFFAA00
+                                                 :unset :background)))
+  (is (equal '(#\Esc #\[ #\4 #\8 #\; #\5 #\; #\1 #\6 #\m)
+             (cl-ansi-text::build-control-string #x000000
+                                                 :unset :background)))
+  (is (equal '(#\Esc #\[ #\4 #\8 #\; #\5 #\; #\2 #\3 #\1 #\m)
+             (cl-ansi-text::build-control-string #xFFFFFF
+                                                 :unset :background))))
+
+(test color-named-functions
+  (let ((str "Test string."))
+    (is (equal (black str)
+               (with-output-to-string (s)
+                 (with-color (:black :stream s)
+                   (format s str)))))
+    (is (equal (red str)
+               (with-output-to-string (s)
+                 (with-color (:red :stream s)
+                   (format s str)))))
+
+    (is (equal (green str)
+               (with-output-to-string (s)
+                 (with-color (:green :stream s)
+                   (format s str)))))
+
+    (is (equal (yellow str)
+               (with-output-to-string (s)
+                 (with-color (:yellow :stream s)
+                   (format s str)))))
+    (is (equal (blue str)
+               (with-output-to-string (s)
+                 (with-color (:blue :stream s)
+                   (format s str)))))
+    (is (equal (magenta str)
+               (with-output-to-string (s)
+                 (with-color (:magenta :stream s)
+                   (format s str)))))
+    (is (equal (cyan str)
+               (with-output-to-string (s)
+                 (with-color (:cyan :stream s)
+                   (format s str)))))
+    (is (equal (white str)
+               (with-output-to-string (s)
+                 (with-color (:white :stream s)
+                   (format s str)))))))
+
+(test color-named-functions-*enabled*
+  (let ((str "Other test string.")
+        (*enabled* nil))
+    (is
+     (equal str
+            (white (cyan (magenta (blue (yellow (green (red (black str))))))))))))
+
+(defun run-tests ()
+  (let  ((results (run 'test-suite)))
+    (explain! results)
+    (if (position-if #'(lambda (e)
+                         (eq (type-of e)
+                             'IT.BESE.FIVEAM::TEST-FAILURE
+                             ))
+                     results)
+        nil
+        t)))
+
+(defun ci-run ()
+  (run-tests))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/Makefile b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/Makefile
new file mode 100644
index 0000000..1bdcd80
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/Makefile
@@ -0,0 +1,8 @@
+## note: this works on my system, you don't need to run it because the
+## distribution contains the generated file
+
+SBCL=/usr/bin/sbcl
+
+colornames.lisp: /usr/share/X11/rgb.txt parse-x11-colors.lisp
+	rm -f colornames.lisp
+	$(SBCL) --load parse-x11-colors.lisp --eval '(quit)'
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/README.org b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/README.org
new file mode 100644
index 0000000..d87c1ed
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/README.org
@@ -0,0 +1,43 @@
+*IMPORTANT* This library is [[https://tpapp.github.io/post/orphaned-lisp-libraries/][unsupported]].
+
+* cl-colors: a simple color library for Common Lisp
+
+This is a very simple color library for Common Lisp, providing
+
+1. Types for representing colors in HSV and RGB spaces.
+2. Simple conversion functions between the above types (and also hexadecimal representation for RGB).
+3. Some predefined colors (currently X11 color names -- of course the library does not depend on X11).
+
+** Examples
+
+#+BEGIN_SRC lisp
+(let ((color1 (hsv 107 62/100 52/100))          ; greenish
+      (color2 (rgb 14/15 26/51 14/15))  ; = violet from X11
+      (color3 (as-rgb "ff9e00")))        ; from hexadecimal
+  (list                                 ;
+   (as-rgb color1)                    ; converting to RGB
+   (rgb-combination color1 +blue+ 0.4) ; HSV autoconverted to RGB
+   (hsv-combination color2 +blue+ 0.4) ; RGB autoconverted to HSV
+   color3))
+#+END_SRC
+evaluates to
+#+BEGIN_EXAMPLE
+'(#S(RGB :RED 20059/75000 :GREEN 13/25 :BLUE 247/1250)
+  #S(RGB :RED 0.160472 :GREEN 0.312 :BLUE 0.51856) ; observe float contagion
+  #S(HSV :HUE 60.0 :SATURATION 0.6722689 :VALUE 0.96000004)
+  #S(RGB :RED 1 :GREEN 158/255 :BLUE 0))
+#+END_EXAMPLE
+
+Observe the float contagion: =cl-colors= functions don't care about the type of the numbers as long as they are a subtype of =real= and within the right range.
+
+** Documentation
+
+This library is so simple that it does not need a lot of documentation --- just look at the docsstrings in =colors.lisp=.
+
+** Regeneration of the X11 color names
+
+Normally you should not need to do this, the sources already contain the autogenerated file =colornames.lisp=.  However, if for some reason you need to regenerate this, you can use =make=.  Even though the library itself does not depend on X11, regenerating this file will require the appropriate file in X11.
+
+** Bugs and issues
+
+Please report them on [[https://github.com/tpapp/cl-colors/issues][Github]].
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/cl-colors.asd b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/cl-colors.asd
new file mode 100644
index 0000000..e603937
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/cl-colors.asd
@@ -0,0 +1,19 @@
+(defsystem #:cl-colors
+  :description "Simple color library for Common Lisp"
+  :version "0.2"
+  :author "Tamas K Papp <tkpapp@gmail.com>"
+  :license "Boost Software License - Version 1.0"
+  :serial t
+  :components ((:file "package")
+               (:file "colors")
+               (:file "colornames")
+               (:file "hexcolors"))
+  :depends-on (#:alexandria #:let-plus))
+
+(defsystem #:cl-colors-tests
+  :description "Unit tests for CL-COLORS."
+  :author "Tamas K Papp <tkpapp@gmail.com>"
+  :license "Boost Software License - Version 1.0"
+  :serial t
+  :components ((:file "test"))
+  :depends-on (#:cl-colors #:lift))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/colornames.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/colornames.lisp
new file mode 100644
index 0000000..2d65136
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/colornames.lisp
@@ -0,0 +1,663 @@
+;;;; This file was generated automatically by parse-x11.lisp
+;;;; Please do not edit directly, just run make if necessary (but should not be).
+
+(in-package #:cl-colors)
+
+(define-rgb-color snow 1 50/51 50/51)
+(define-rgb-color ghostwhite 248/255 248/255 1)
+(define-rgb-color whitesmoke 49/51 49/51 49/51)
+(define-rgb-color gainsboro 44/51 44/51 44/51)
+(define-rgb-color floralwhite 1 50/51 16/17)
+(define-rgb-color oldlace 253/255 49/51 46/51)
+(define-rgb-color linen 50/51 16/17 46/51)
+(define-rgb-color antiquewhite 50/51 47/51 43/51)
+(define-rgb-color papayawhip 1 239/255 71/85)
+(define-rgb-color blanchedalmond 1 47/51 41/51)
+(define-rgb-color bisque 1 76/85 196/255)
+(define-rgb-color peachpuff 1 218/255 37/51)
+(define-rgb-color navajowhite 1 74/85 173/255)
+(define-rgb-color moccasin 1 76/85 181/255)
+(define-rgb-color cornsilk 1 248/255 44/51)
+(define-rgb-color ivory 1 1 16/17)
+(define-rgb-color lemonchiffon 1 50/51 41/51)
+(define-rgb-color seashell 1 49/51 14/15)
+(define-rgb-color honeydew 16/17 1 16/17)
+(define-rgb-color mintcream 49/51 1 50/51)
+(define-rgb-color azure 16/17 1 1)
+(define-rgb-color aliceblue 16/17 248/255 1)
+(define-rgb-color lavender 46/51 46/51 50/51)
+(define-rgb-color lavenderblush 1 16/17 49/51)
+(define-rgb-color mistyrose 1 76/85 15/17)
+(define-rgb-color white 1 1 1)
+(define-rgb-color black 0 0 0)
+(define-rgb-color darkslategray 47/255 79/255 79/255)
+(define-rgb-color darkslategrey 47/255 79/255 79/255)
+(define-rgb-color dimgray 7/17 7/17 7/17)
+(define-rgb-color dimgrey 7/17 7/17 7/17)
+(define-rgb-color slategray 112/255 128/255 48/85)
+(define-rgb-color slategrey 112/255 128/255 48/85)
+(define-rgb-color lightslategray 7/15 8/15 3/5)
+(define-rgb-color lightslategrey 7/15 8/15 3/5)
+(define-rgb-color gray 38/51 38/51 38/51)
+(define-rgb-color grey 38/51 38/51 38/51)
+(define-rgb-color lightgrey 211/255 211/255 211/255)
+(define-rgb-color lightgray 211/255 211/255 211/255)
+(define-rgb-color midnightblue 5/51 5/51 112/255)
+(define-rgb-color navy 0 0 128/255)
+(define-rgb-color navyblue 0 0 128/255)
+(define-rgb-color cornflowerblue 20/51 149/255 79/85)
+(define-rgb-color darkslateblue 24/85 61/255 139/255)
+(define-rgb-color slateblue 106/255 6/17 41/51)
+(define-rgb-color mediumslateblue 41/85 104/255 14/15)
+(define-rgb-color lightslateblue 44/85 112/255 1)
+(define-rgb-color mediumblue 0 0 41/51)
+(define-rgb-color royalblue 13/51 7/17 15/17)
+(define-rgb-color blue 0 0 1)
+(define-rgb-color dodgerblue 2/17 48/85 1)
+(define-rgb-color deepskyblue 0 191/255 1)
+(define-rgb-color skyblue 9/17 206/255 47/51)
+(define-rgb-color lightskyblue 9/17 206/255 50/51)
+(define-rgb-color steelblue 14/51 26/51 12/17)
+(define-rgb-color lightsteelblue 176/255 196/255 74/85)
+(define-rgb-color lightblue 173/255 72/85 46/51)
+(define-rgb-color powderblue 176/255 224/255 46/51)
+(define-rgb-color paleturquoise 35/51 14/15 14/15)
+(define-rgb-color darkturquoise 0 206/255 209/255)
+(define-rgb-color mediumturquoise 24/85 209/255 4/5)
+(define-rgb-color turquoise 64/255 224/255 208/255)
+(define-rgb-color cyan 0 1 1)
+(define-rgb-color lightcyan 224/255 1 1)
+(define-rgb-color cadetblue 19/51 158/255 32/51)
+(define-rgb-color mediumaquamarine 2/5 41/51 2/3)
+(define-rgb-color aquamarine 127/255 1 212/255)
+(define-rgb-color darkgreen 0 20/51 0)
+(define-rgb-color darkolivegreen 1/3 107/255 47/255)
+(define-rgb-color darkseagreen 143/255 188/255 143/255)
+(define-rgb-color seagreen 46/255 139/255 29/85)
+(define-rgb-color mediumseagreen 4/17 179/255 113/255)
+(define-rgb-color lightseagreen 32/255 178/255 2/3)
+(define-rgb-color palegreen 152/255 251/255 152/255)
+(define-rgb-color springgreen 0 1 127/255)
+(define-rgb-color lawngreen 124/255 84/85 0)
+(define-rgb-color green 0 1 0)
+(define-rgb-color chartreuse 127/255 1 0)
+(define-rgb-color mediumspringgreen 0 50/51 154/255)
+(define-rgb-color greenyellow 173/255 1 47/255)
+(define-rgb-color limegreen 10/51 41/51 10/51)
+(define-rgb-color yellowgreen 154/255 41/51 10/51)
+(define-rgb-color forestgreen 2/15 139/255 2/15)
+(define-rgb-color olivedrab 107/255 142/255 7/51)
+(define-rgb-color darkkhaki 63/85 61/85 107/255)
+(define-rgb-color khaki 16/17 46/51 28/51)
+(define-rgb-color palegoldenrod 14/15 232/255 2/3)
+(define-rgb-color lightgoldenrodyellow 50/51 50/51 14/17)
+(define-rgb-color lightyellow 1 1 224/255)
+(define-rgb-color yellow 1 1 0)
+(define-rgb-color gold 1 43/51 0)
+(define-rgb-color lightgoldenrod 14/15 13/15 26/51)
+(define-rgb-color goldenrod 218/255 11/17 32/255)
+(define-rgb-color darkgoldenrod 184/255 134/255 11/255)
+(define-rgb-color rosybrown 188/255 143/255 143/255)
+(define-rgb-color indianred 41/51 92/255 92/255)
+(define-rgb-color saddlebrown 139/255 23/85 19/255)
+(define-rgb-color sienna 32/51 82/255 3/17)
+(define-rgb-color peru 41/51 133/255 21/85)
+(define-rgb-color burlywood 74/85 184/255 9/17)
+(define-rgb-color beige 49/51 49/51 44/51)
+(define-rgb-color wheat 49/51 74/85 179/255)
+(define-rgb-color sandybrown 244/255 164/255 32/85)
+(define-rgb-color tan 14/17 12/17 28/51)
+(define-rgb-color chocolate 14/17 7/17 2/17)
+(define-rgb-color firebrick 178/255 2/15 2/15)
+(define-rgb-color brown 11/17 14/85 14/85)
+(define-rgb-color darksalmon 233/255 10/17 122/255)
+(define-rgb-color salmon 50/51 128/255 38/85)
+(define-rgb-color lightsalmon 1 32/51 122/255)
+(define-rgb-color orange 1 11/17 0)
+(define-rgb-color darkorange 1 28/51 0)
+(define-rgb-color coral 1 127/255 16/51)
+(define-rgb-color lightcoral 16/17 128/255 128/255)
+(define-rgb-color tomato 1 33/85 71/255)
+(define-rgb-color orangered 1 23/85 0)
+(define-rgb-color red 1 0 0)
+(define-rgb-color hotpink 1 7/17 12/17)
+(define-rgb-color deeppink 1 4/51 49/85)
+(define-rgb-color pink 1 64/85 203/255)
+(define-rgb-color lightpink 1 182/255 193/255)
+(define-rgb-color palevioletred 73/85 112/255 49/85)
+(define-rgb-color maroon 176/255 16/85 32/85)
+(define-rgb-color mediumvioletred 199/255 7/85 133/255)
+(define-rgb-color violetred 208/255 32/255 48/85)
+(define-rgb-color magenta 1 0 1)
+(define-rgb-color violet 14/15 26/51 14/15)
+(define-rgb-color plum 13/15 32/51 13/15)
+(define-rgb-color orchid 218/255 112/255 214/255)
+(define-rgb-color mediumorchid 62/85 1/3 211/255)
+(define-rgb-color darkorchid 3/5 10/51 4/5)
+(define-rgb-color darkviolet 148/255 0 211/255)
+(define-rgb-color blueviolet 46/85 43/255 226/255)
+(define-rgb-color purple 32/51 32/255 16/17)
+(define-rgb-color mediumpurple 49/85 112/255 73/85)
+(define-rgb-color thistle 72/85 191/255 72/85)
+(define-rgb-color snow1 1 50/51 50/51)
+(define-rgb-color snow2 14/15 233/255 233/255)
+(define-rgb-color snow3 41/51 67/85 67/85)
+(define-rgb-color snow4 139/255 137/255 137/255)
+(define-rgb-color seashell1 1 49/51 14/15)
+(define-rgb-color seashell2 14/15 229/255 74/85)
+(define-rgb-color seashell3 41/51 197/255 191/255)
+(define-rgb-color seashell4 139/255 134/255 26/51)
+(define-rgb-color antiquewhite1 1 239/255 73/85)
+(define-rgb-color antiquewhite2 14/15 223/255 4/5)
+(define-rgb-color antiquewhite3 41/51 64/85 176/255)
+(define-rgb-color antiquewhite4 139/255 131/255 8/17)
+(define-rgb-color bisque1 1 76/85 196/255)
+(define-rgb-color bisque2 14/15 71/85 61/85)
+(define-rgb-color bisque3 41/51 61/85 158/255)
+(define-rgb-color bisque4 139/255 25/51 107/255)
+(define-rgb-color peachpuff1 1 218/255 37/51)
+(define-rgb-color peachpuff2 14/15 203/255 173/255)
+(define-rgb-color peachpuff3 41/51 35/51 149/255)
+(define-rgb-color peachpuff4 139/255 7/15 101/255)
+(define-rgb-color navajowhite1 1 74/85 173/255)
+(define-rgb-color navajowhite2 14/15 69/85 161/255)
+(define-rgb-color navajowhite3 41/51 179/255 139/255)
+(define-rgb-color navajowhite4 139/255 121/255 94/255)
+(define-rgb-color lemonchiffon1 1 50/51 41/51)
+(define-rgb-color lemonchiffon2 14/15 233/255 191/255)
+(define-rgb-color lemonchiffon3 41/51 67/85 11/17)
+(define-rgb-color lemonchiffon4 139/255 137/255 112/255)
+(define-rgb-color cornsilk1 1 248/255 44/51)
+(define-rgb-color cornsilk2 14/15 232/255 41/51)
+(define-rgb-color cornsilk3 41/51 40/51 59/85)
+(define-rgb-color cornsilk4 139/255 8/15 8/17)
+(define-rgb-color ivory1 1 1 16/17)
+(define-rgb-color ivory2 14/15 14/15 224/255)
+(define-rgb-color ivory3 41/51 41/51 193/255)
+(define-rgb-color ivory4 139/255 139/255 131/255)
+(define-rgb-color honeydew1 16/17 1 16/17)
+(define-rgb-color honeydew2 224/255 14/15 224/255)
+(define-rgb-color honeydew3 193/255 41/51 193/255)
+(define-rgb-color honeydew4 131/255 139/255 131/255)
+(define-rgb-color lavenderblush1 1 16/17 49/51)
+(define-rgb-color lavenderblush2 14/15 224/255 229/255)
+(define-rgb-color lavenderblush3 41/51 193/255 197/255)
+(define-rgb-color lavenderblush4 139/255 131/255 134/255)
+(define-rgb-color mistyrose1 1 76/85 15/17)
+(define-rgb-color mistyrose2 14/15 71/85 14/17)
+(define-rgb-color mistyrose3 41/51 61/85 181/255)
+(define-rgb-color mistyrose4 139/255 25/51 41/85)
+(define-rgb-color azure1 16/17 1 1)
+(define-rgb-color azure2 224/255 14/15 14/15)
+(define-rgb-color azure3 193/255 41/51 41/51)
+(define-rgb-color azure4 131/255 139/255 139/255)
+(define-rgb-color slateblue1 131/255 37/85 1)
+(define-rgb-color slateblue2 122/255 103/255 14/15)
+(define-rgb-color slateblue3 7/17 89/255 41/51)
+(define-rgb-color slateblue4 71/255 4/17 139/255)
+(define-rgb-color royalblue1 24/85 118/255 1)
+(define-rgb-color royalblue2 67/255 22/51 14/15)
+(define-rgb-color royalblue3 58/255 19/51 41/51)
+(define-rgb-color royalblue4 13/85 64/255 139/255)
+(define-rgb-color blue1 0 0 1)
+(define-rgb-color blue2 0 0 14/15)
+(define-rgb-color blue3 0 0 41/51)
+(define-rgb-color blue4 0 0 139/255)
+(define-rgb-color dodgerblue1 2/17 48/85 1)
+(define-rgb-color dodgerblue2 28/255 134/255 14/15)
+(define-rgb-color dodgerblue3 8/85 116/255 41/51)
+(define-rgb-color dodgerblue4 16/255 26/85 139/255)
+(define-rgb-color steelblue1 33/85 184/255 1)
+(define-rgb-color steelblue2 92/255 172/255 14/15)
+(define-rgb-color steelblue3 79/255 148/255 41/51)
+(define-rgb-color steelblue4 18/85 20/51 139/255)
+(define-rgb-color deepskyblue1 0 191/255 1)
+(define-rgb-color deepskyblue2 0 178/255 14/15)
+(define-rgb-color deepskyblue3 0 154/255 41/51)
+(define-rgb-color deepskyblue4 0 104/255 139/255)
+(define-rgb-color skyblue1 9/17 206/255 1)
+(define-rgb-color skyblue2 42/85 64/85 14/15)
+(define-rgb-color skyblue3 36/85 166/255 41/51)
+(define-rgb-color skyblue4 74/255 112/255 139/255)
+(define-rgb-color lightskyblue1 176/255 226/255 1)
+(define-rgb-color lightskyblue2 164/255 211/255 14/15)
+(define-rgb-color lightskyblue3 47/85 182/255 41/51)
+(define-rgb-color lightskyblue4 32/85 41/85 139/255)
+(define-rgb-color slategray1 66/85 226/255 1)
+(define-rgb-color slategray2 37/51 211/255 14/15)
+(define-rgb-color slategray3 53/85 182/255 41/51)
+(define-rgb-color slategray4 36/85 41/85 139/255)
+(define-rgb-color lightsteelblue1 202/255 15/17 1)
+(define-rgb-color lightsteelblue2 188/255 14/17 14/15)
+(define-rgb-color lightsteelblue3 54/85 181/255 41/51)
+(define-rgb-color lightsteelblue4 22/51 41/85 139/255)
+(define-rgb-color lightblue1 191/255 239/255 1)
+(define-rgb-color lightblue2 178/255 223/255 14/15)
+(define-rgb-color lightblue3 154/255 64/85 41/51)
+(define-rgb-color lightblue4 104/255 131/255 139/255)
+(define-rgb-color lightcyan1 224/255 1 1)
+(define-rgb-color lightcyan2 209/255 14/15 14/15)
+(define-rgb-color lightcyan3 12/17 41/51 41/51)
+(define-rgb-color lightcyan4 122/255 139/255 139/255)
+(define-rgb-color paleturquoise1 11/15 1 1)
+(define-rgb-color paleturquoise2 58/85 14/15 14/15)
+(define-rgb-color paleturquoise3 10/17 41/51 41/51)
+(define-rgb-color paleturquoise4 2/5 139/255 139/255)
+(define-rgb-color cadetblue1 152/255 49/51 1)
+(define-rgb-color cadetblue2 142/255 229/255 14/15)
+(define-rgb-color cadetblue3 122/255 197/255 41/51)
+(define-rgb-color cadetblue4 83/255 134/255 139/255)
+(define-rgb-color turquoise1 0 49/51 1)
+(define-rgb-color turquoise2 0 229/255 14/15)
+(define-rgb-color turquoise3 0 197/255 41/51)
+(define-rgb-color turquoise4 0 134/255 139/255)
+(define-rgb-color cyan1 0 1 1)
+(define-rgb-color cyan2 0 14/15 14/15)
+(define-rgb-color cyan3 0 41/51 41/51)
+(define-rgb-color cyan4 0 139/255 139/255)
+(define-rgb-color darkslategray1 151/255 1 1)
+(define-rgb-color darkslategray2 47/85 14/15 14/15)
+(define-rgb-color darkslategray3 121/255 41/51 41/51)
+(define-rgb-color darkslategray4 82/255 139/255 139/255)
+(define-rgb-color aquamarine1 127/255 1 212/255)
+(define-rgb-color aquamarine2 118/255 14/15 66/85)
+(define-rgb-color aquamarine3 2/5 41/51 2/3)
+(define-rgb-color aquamarine4 23/85 139/255 116/255)
+(define-rgb-color darkseagreen1 193/255 1 193/255)
+(define-rgb-color darkseagreen2 12/17 14/15 12/17)
+(define-rgb-color darkseagreen3 31/51 41/51 31/51)
+(define-rgb-color darkseagreen4 7/17 139/255 7/17)
+(define-rgb-color seagreen1 28/85 1 53/85)
+(define-rgb-color seagreen2 26/85 14/15 148/255)
+(define-rgb-color seagreen3 67/255 41/51 128/255)
+(define-rgb-color seagreen4 46/255 139/255 29/85)
+(define-rgb-color palegreen1 154/255 1 154/255)
+(define-rgb-color palegreen2 48/85 14/15 48/85)
+(define-rgb-color palegreen3 124/255 41/51 124/255)
+(define-rgb-color palegreen4 28/85 139/255 28/85)
+(define-rgb-color springgreen1 0 1 127/255)
+(define-rgb-color springgreen2 0 14/15 118/255)
+(define-rgb-color springgreen3 0 41/51 2/5)
+(define-rgb-color springgreen4 0 139/255 23/85)
+(define-rgb-color green1 0 1 0)
+(define-rgb-color green2 0 14/15 0)
+(define-rgb-color green3 0 41/51 0)
+(define-rgb-color green4 0 139/255 0)
+(define-rgb-color chartreuse1 127/255 1 0)
+(define-rgb-color chartreuse2 118/255 14/15 0)
+(define-rgb-color chartreuse3 2/5 41/51 0)
+(define-rgb-color chartreuse4 23/85 139/255 0)
+(define-rgb-color olivedrab1 64/85 1 62/255)
+(define-rgb-color olivedrab2 179/255 14/15 58/255)
+(define-rgb-color olivedrab3 154/255 41/51 10/51)
+(define-rgb-color olivedrab4 7/17 139/255 2/15)
+(define-rgb-color darkolivegreen1 202/255 1 112/255)
+(define-rgb-color darkolivegreen2 188/255 14/15 104/255)
+(define-rgb-color darkolivegreen3 54/85 41/51 6/17)
+(define-rgb-color darkolivegreen4 22/51 139/255 61/255)
+(define-rgb-color khaki1 1 82/85 143/255)
+(define-rgb-color khaki2 14/15 46/51 133/255)
+(define-rgb-color khaki3 41/51 66/85 23/51)
+(define-rgb-color khaki4 139/255 134/255 26/85)
+(define-rgb-color lightgoldenrod1 1 236/255 139/255)
+(define-rgb-color lightgoldenrod2 14/15 44/51 26/51)
+(define-rgb-color lightgoldenrod3 41/51 38/51 112/255)
+(define-rgb-color lightgoldenrod4 139/255 43/85 76/255)
+(define-rgb-color lightyellow1 1 1 224/255)
+(define-rgb-color lightyellow2 14/15 14/15 209/255)
+(define-rgb-color lightyellow3 41/51 41/51 12/17)
+(define-rgb-color lightyellow4 139/255 139/255 122/255)
+(define-rgb-color yellow1 1 1 0)
+(define-rgb-color yellow2 14/15 14/15 0)
+(define-rgb-color yellow3 41/51 41/51 0)
+(define-rgb-color yellow4 139/255 139/255 0)
+(define-rgb-color gold1 1 43/51 0)
+(define-rgb-color gold2 14/15 67/85 0)
+(define-rgb-color gold3 41/51 173/255 0)
+(define-rgb-color gold4 139/255 39/85 0)
+(define-rgb-color goldenrod1 1 193/255 37/255)
+(define-rgb-color goldenrod2 14/15 12/17 2/15)
+(define-rgb-color goldenrod3 41/51 31/51 29/255)
+(define-rgb-color goldenrod4 139/255 7/17 4/51)
+(define-rgb-color darkgoldenrod1 1 37/51 1/17)
+(define-rgb-color darkgoldenrod2 14/15 173/255 14/255)
+(define-rgb-color darkgoldenrod3 41/51 149/255 4/85)
+(define-rgb-color darkgoldenrod4 139/255 101/255 8/255)
+(define-rgb-color rosybrown1 1 193/255 193/255)
+(define-rgb-color rosybrown2 14/15 12/17 12/17)
+(define-rgb-color rosybrown3 41/51 31/51 31/51)
+(define-rgb-color rosybrown4 139/255 7/17 7/17)
+(define-rgb-color indianred1 1 106/255 106/255)
+(define-rgb-color indianred2 14/15 33/85 33/85)
+(define-rgb-color indianred3 41/51 1/3 1/3)
+(define-rgb-color indianred4 139/255 58/255 58/255)
+(define-rgb-color sienna1 1 26/51 71/255)
+(define-rgb-color sienna2 14/15 121/255 22/85)
+(define-rgb-color sienna3 41/51 104/255 19/85)
+(define-rgb-color sienna4 139/255 71/255 38/255)
+(define-rgb-color burlywood1 1 211/255 31/51)
+(define-rgb-color burlywood2 14/15 197/255 29/51)
+(define-rgb-color burlywood3 41/51 2/3 25/51)
+(define-rgb-color burlywood4 139/255 23/51 1/3)
+(define-rgb-color wheat1 1 77/85 62/85)
+(define-rgb-color wheat2 14/15 72/85 58/85)
+(define-rgb-color wheat3 41/51 62/85 10/17)
+(define-rgb-color wheat4 139/255 42/85 2/5)
+(define-rgb-color tan1 1 11/17 79/255)
+(define-rgb-color tan2 14/15 154/255 73/255)
+(define-rgb-color tan3 41/51 133/255 21/85)
+(define-rgb-color tan4 139/255 6/17 43/255)
+(define-rgb-color chocolate1 1 127/255 12/85)
+(define-rgb-color chocolate2 14/15 118/255 11/85)
+(define-rgb-color chocolate3 41/51 2/5 29/255)
+(define-rgb-color chocolate4 139/255 23/85 19/255)
+(define-rgb-color firebrick1 1 16/85 16/85)
+(define-rgb-color firebrick2 14/15 44/255 44/255)
+(define-rgb-color firebrick3 41/51 38/255 38/255)
+(define-rgb-color firebrick4 139/255 26/255 26/255)
+(define-rgb-color brown1 1 64/255 64/255)
+(define-rgb-color brown2 14/15 59/255 59/255)
+(define-rgb-color brown3 41/51 1/5 1/5)
+(define-rgb-color brown4 139/255 7/51 7/51)
+(define-rgb-color salmon1 1 28/51 7/17)
+(define-rgb-color salmon2 14/15 26/51 98/255)
+(define-rgb-color salmon3 41/51 112/255 28/85)
+(define-rgb-color salmon4 139/255 76/255 19/85)
+(define-rgb-color lightsalmon1 1 32/51 122/255)
+(define-rgb-color lightsalmon2 14/15 149/255 38/85)
+(define-rgb-color lightsalmon3 41/51 43/85 98/255)
+(define-rgb-color lightsalmon4 139/255 29/85 22/85)
+(define-rgb-color orange1 1 11/17 0)
+(define-rgb-color orange2 14/15 154/255 0)
+(define-rgb-color orange3 41/51 133/255 0)
+(define-rgb-color orange4 139/255 6/17 0)
+(define-rgb-color darkorange1 1 127/255 0)
+(define-rgb-color darkorange2 14/15 118/255 0)
+(define-rgb-color darkorange3 41/51 2/5 0)
+(define-rgb-color darkorange4 139/255 23/85 0)
+(define-rgb-color coral1 1 38/85 86/255)
+(define-rgb-color coral2 14/15 106/255 16/51)
+(define-rgb-color coral3 41/51 91/255 23/85)
+(define-rgb-color coral4 139/255 62/255 47/255)
+(define-rgb-color tomato1 1 33/85 71/255)
+(define-rgb-color tomato2 14/15 92/255 22/85)
+(define-rgb-color tomato3 41/51 79/255 19/85)
+(define-rgb-color tomato4 139/255 18/85 38/255)
+(define-rgb-color orangered1 1 23/85 0)
+(define-rgb-color orangered2 14/15 64/255 0)
+(define-rgb-color orangered3 41/51 11/51 0)
+(define-rgb-color orangered4 139/255 37/255 0)
+(define-rgb-color red1 1 0 0)
+(define-rgb-color red2 14/15 0 0)
+(define-rgb-color red3 41/51 0 0)
+(define-rgb-color red4 139/255 0 0)
+(define-rgb-color debianred 43/51 7/255 27/85)
+(define-rgb-color deeppink1 1 4/51 49/85)
+(define-rgb-color deeppink2 14/15 6/85 137/255)
+(define-rgb-color deeppink3 41/51 16/255 118/255)
+(define-rgb-color deeppink4 139/255 2/51 16/51)
+(define-rgb-color hotpink1 1 22/51 12/17)
+(define-rgb-color hotpink2 14/15 106/255 167/255)
+(define-rgb-color hotpink3 41/51 32/85 48/85)
+(define-rgb-color hotpink4 139/255 58/255 98/255)
+(define-rgb-color pink1 1 181/255 197/255)
+(define-rgb-color pink2 14/15 169/255 184/255)
+(define-rgb-color pink3 41/51 29/51 158/255)
+(define-rgb-color pink4 139/255 33/85 36/85)
+(define-rgb-color lightpink1 1 58/85 37/51)
+(define-rgb-color lightpink2 14/15 54/85 173/255)
+(define-rgb-color lightpink3 41/51 28/51 149/255)
+(define-rgb-color lightpink4 139/255 19/51 101/255)
+(define-rgb-color palevioletred1 1 26/51 57/85)
+(define-rgb-color palevioletred2 14/15 121/255 53/85)
+(define-rgb-color palevioletred3 41/51 104/255 137/255)
+(define-rgb-color palevioletred4 139/255 71/255 31/85)
+(define-rgb-color maroon1 1 52/255 179/255)
+(define-rgb-color maroon2 14/15 16/85 167/255)
+(define-rgb-color maroon3 41/51 41/255 48/85)
+(define-rgb-color maroon4 139/255 28/255 98/255)
+(define-rgb-color violetred1 1 62/255 10/17)
+(define-rgb-color violetred2 14/15 58/255 28/51)
+(define-rgb-color violetred3 41/51 10/51 8/17)
+(define-rgb-color violetred4 139/255 2/15 82/255)
+(define-rgb-color magenta1 1 0 1)
+(define-rgb-color magenta2 14/15 0 14/15)
+(define-rgb-color magenta3 41/51 0 41/51)
+(define-rgb-color magenta4 139/255 0 139/255)
+(define-rgb-color orchid1 1 131/255 50/51)
+(define-rgb-color orchid2 14/15 122/255 233/255)
+(define-rgb-color orchid3 41/51 7/17 67/85)
+(define-rgb-color orchid4 139/255 71/255 137/255)
+(define-rgb-color plum1 1 11/15 1)
+(define-rgb-color plum2 14/15 58/85 14/15)
+(define-rgb-color plum3 41/51 10/17 41/51)
+(define-rgb-color plum4 139/255 2/5 139/255)
+(define-rgb-color mediumorchid1 224/255 2/5 1)
+(define-rgb-color mediumorchid2 209/255 19/51 14/15)
+(define-rgb-color mediumorchid3 12/17 82/255 41/51)
+(define-rgb-color mediumorchid4 122/255 11/51 139/255)
+(define-rgb-color darkorchid1 191/255 62/255 1)
+(define-rgb-color darkorchid2 178/255 58/255 14/15)
+(define-rgb-color darkorchid3 154/255 10/51 41/51)
+(define-rgb-color darkorchid4 104/255 2/15 139/255)
+(define-rgb-color purple1 31/51 16/85 1)
+(define-rgb-color purple2 29/51 44/255 14/15)
+(define-rgb-color purple3 25/51 38/255 41/51)
+(define-rgb-color purple4 1/3 26/255 139/255)
+(define-rgb-color mediumpurple1 57/85 26/51 1)
+(define-rgb-color mediumpurple2 53/85 121/255 14/15)
+(define-rgb-color mediumpurple3 137/255 104/255 41/51)
+(define-rgb-color mediumpurple4 31/85 71/255 139/255)
+(define-rgb-color thistle1 1 15/17 1)
+(define-rgb-color thistle2 14/15 14/17 14/15)
+(define-rgb-color thistle3 41/51 181/255 41/51)
+(define-rgb-color thistle4 139/255 41/85 139/255)
+(define-rgb-color gray0 0 0 0)
+(define-rgb-color grey0 0 0 0)
+(define-rgb-color gray1 1/85 1/85 1/85)
+(define-rgb-color grey1 1/85 1/85 1/85)
+(define-rgb-color gray2 1/51 1/51 1/51)
+(define-rgb-color grey2 1/51 1/51 1/51)
+(define-rgb-color gray3 8/255 8/255 8/255)
+(define-rgb-color grey3 8/255 8/255 8/255)
+(define-rgb-color gray4 2/51 2/51 2/51)
+(define-rgb-color grey4 2/51 2/51 2/51)
+(define-rgb-color gray5 13/255 13/255 13/255)
+(define-rgb-color grey5 13/255 13/255 13/255)
+(define-rgb-color gray6 1/17 1/17 1/17)
+(define-rgb-color grey6 1/17 1/17 1/17)
+(define-rgb-color gray7 6/85 6/85 6/85)
+(define-rgb-color grey7 6/85 6/85 6/85)
+(define-rgb-color gray8 4/51 4/51 4/51)
+(define-rgb-color grey8 4/51 4/51 4/51)
+(define-rgb-color gray9 23/255 23/255 23/255)
+(define-rgb-color grey9 23/255 23/255 23/255)
+(define-rgb-color gray10 26/255 26/255 26/255)
+(define-rgb-color grey10 26/255 26/255 26/255)
+(define-rgb-color gray11 28/255 28/255 28/255)
+(define-rgb-color grey11 28/255 28/255 28/255)
+(define-rgb-color gray12 31/255 31/255 31/255)
+(define-rgb-color grey12 31/255 31/255 31/255)
+(define-rgb-color gray13 11/85 11/85 11/85)
+(define-rgb-color grey13 11/85 11/85 11/85)
+(define-rgb-color gray14 12/85 12/85 12/85)
+(define-rgb-color grey14 12/85 12/85 12/85)
+(define-rgb-color gray15 38/255 38/255 38/255)
+(define-rgb-color grey15 38/255 38/255 38/255)
+(define-rgb-color gray16 41/255 41/255 41/255)
+(define-rgb-color grey16 41/255 41/255 41/255)
+(define-rgb-color gray17 43/255 43/255 43/255)
+(define-rgb-color grey17 43/255 43/255 43/255)
+(define-rgb-color gray18 46/255 46/255 46/255)
+(define-rgb-color grey18 46/255 46/255 46/255)
+(define-rgb-color gray19 16/85 16/85 16/85)
+(define-rgb-color grey19 16/85 16/85 16/85)
+(define-rgb-color gray20 1/5 1/5 1/5)
+(define-rgb-color grey20 1/5 1/5 1/5)
+(define-rgb-color gray21 18/85 18/85 18/85)
+(define-rgb-color grey21 18/85 18/85 18/85)
+(define-rgb-color gray22 56/255 56/255 56/255)
+(define-rgb-color grey22 56/255 56/255 56/255)
+(define-rgb-color gray23 59/255 59/255 59/255)
+(define-rgb-color grey23 59/255 59/255 59/255)
+(define-rgb-color gray24 61/255 61/255 61/255)
+(define-rgb-color grey24 61/255 61/255 61/255)
+(define-rgb-color gray25 64/255 64/255 64/255)
+(define-rgb-color grey25 64/255 64/255 64/255)
+(define-rgb-color gray26 22/85 22/85 22/85)
+(define-rgb-color grey26 22/85 22/85 22/85)
+(define-rgb-color gray27 23/85 23/85 23/85)
+(define-rgb-color grey27 23/85 23/85 23/85)
+(define-rgb-color gray28 71/255 71/255 71/255)
+(define-rgb-color grey28 71/255 71/255 71/255)
+(define-rgb-color gray29 74/255 74/255 74/255)
+(define-rgb-color grey29 74/255 74/255 74/255)
+(define-rgb-color gray30 77/255 77/255 77/255)
+(define-rgb-color grey30 77/255 77/255 77/255)
+(define-rgb-color gray31 79/255 79/255 79/255)
+(define-rgb-color grey31 79/255 79/255 79/255)
+(define-rgb-color gray32 82/255 82/255 82/255)
+(define-rgb-color grey32 82/255 82/255 82/255)
+(define-rgb-color gray33 28/85 28/85 28/85)
+(define-rgb-color grey33 28/85 28/85 28/85)
+(define-rgb-color gray34 29/85 29/85 29/85)
+(define-rgb-color grey34 29/85 29/85 29/85)
+(define-rgb-color gray35 89/255 89/255 89/255)
+(define-rgb-color grey35 89/255 89/255 89/255)
+(define-rgb-color gray36 92/255 92/255 92/255)
+(define-rgb-color grey36 92/255 92/255 92/255)
+(define-rgb-color gray37 94/255 94/255 94/255)
+(define-rgb-color grey37 94/255 94/255 94/255)
+(define-rgb-color gray38 97/255 97/255 97/255)
+(define-rgb-color grey38 97/255 97/255 97/255)
+(define-rgb-color gray39 33/85 33/85 33/85)
+(define-rgb-color grey39 33/85 33/85 33/85)
+(define-rgb-color gray40 2/5 2/5 2/5)
+(define-rgb-color grey40 2/5 2/5 2/5)
+(define-rgb-color gray41 7/17 7/17 7/17)
+(define-rgb-color grey41 7/17 7/17 7/17)
+(define-rgb-color gray42 107/255 107/255 107/255)
+(define-rgb-color grey42 107/255 107/255 107/255)
+(define-rgb-color gray43 22/51 22/51 22/51)
+(define-rgb-color grey43 22/51 22/51 22/51)
+(define-rgb-color gray44 112/255 112/255 112/255)
+(define-rgb-color grey44 112/255 112/255 112/255)
+(define-rgb-color gray45 23/51 23/51 23/51)
+(define-rgb-color grey45 23/51 23/51 23/51)
+(define-rgb-color gray46 39/85 39/85 39/85)
+(define-rgb-color grey46 39/85 39/85 39/85)
+(define-rgb-color gray47 8/17 8/17 8/17)
+(define-rgb-color grey47 8/17 8/17 8/17)
+(define-rgb-color gray48 122/255 122/255 122/255)
+(define-rgb-color grey48 122/255 122/255 122/255)
+(define-rgb-color gray49 25/51 25/51 25/51)
+(define-rgb-color grey49 25/51 25/51 25/51)
+(define-rgb-color gray50 127/255 127/255 127/255)
+(define-rgb-color grey50 127/255 127/255 127/255)
+(define-rgb-color gray51 26/51 26/51 26/51)
+(define-rgb-color grey51 26/51 26/51 26/51)
+(define-rgb-color gray52 133/255 133/255 133/255)
+(define-rgb-color grey52 133/255 133/255 133/255)
+(define-rgb-color gray53 9/17 9/17 9/17)
+(define-rgb-color grey53 9/17 9/17 9/17)
+(define-rgb-color gray54 46/85 46/85 46/85)
+(define-rgb-color grey54 46/85 46/85 46/85)
+(define-rgb-color gray55 28/51 28/51 28/51)
+(define-rgb-color grey55 28/51 28/51 28/51)
+(define-rgb-color gray56 143/255 143/255 143/255)
+(define-rgb-color grey56 143/255 143/255 143/255)
+(define-rgb-color gray57 29/51 29/51 29/51)
+(define-rgb-color grey57 29/51 29/51 29/51)
+(define-rgb-color gray58 148/255 148/255 148/255)
+(define-rgb-color grey58 148/255 148/255 148/255)
+(define-rgb-color gray59 10/17 10/17 10/17)
+(define-rgb-color grey59 10/17 10/17 10/17)
+(define-rgb-color gray60 3/5 3/5 3/5)
+(define-rgb-color grey60 3/5 3/5 3/5)
+(define-rgb-color gray61 52/85 52/85 52/85)
+(define-rgb-color grey61 52/85 52/85 52/85)
+(define-rgb-color gray62 158/255 158/255 158/255)
+(define-rgb-color grey62 158/255 158/255 158/255)
+(define-rgb-color gray63 161/255 161/255 161/255)
+(define-rgb-color grey63 161/255 161/255 161/255)
+(define-rgb-color gray64 163/255 163/255 163/255)
+(define-rgb-color grey64 163/255 163/255 163/255)
+(define-rgb-color gray65 166/255 166/255 166/255)
+(define-rgb-color grey65 166/255 166/255 166/255)
+(define-rgb-color gray66 56/85 56/85 56/85)
+(define-rgb-color grey66 56/85 56/85 56/85)
+(define-rgb-color gray67 57/85 57/85 57/85)
+(define-rgb-color grey67 57/85 57/85 57/85)
+(define-rgb-color gray68 173/255 173/255 173/255)
+(define-rgb-color grey68 173/255 173/255 173/255)
+(define-rgb-color gray69 176/255 176/255 176/255)
+(define-rgb-color grey69 176/255 176/255 176/255)
+(define-rgb-color gray70 179/255 179/255 179/255)
+(define-rgb-color grey70 179/255 179/255 179/255)
+(define-rgb-color gray71 181/255 181/255 181/255)
+(define-rgb-color grey71 181/255 181/255 181/255)
+(define-rgb-color gray72 184/255 184/255 184/255)
+(define-rgb-color grey72 184/255 184/255 184/255)
+(define-rgb-color gray73 62/85 62/85 62/85)
+(define-rgb-color grey73 62/85 62/85 62/85)
+(define-rgb-color gray74 63/85 63/85 63/85)
+(define-rgb-color grey74 63/85 63/85 63/85)
+(define-rgb-color gray75 191/255 191/255 191/255)
+(define-rgb-color grey75 191/255 191/255 191/255)
+(define-rgb-color gray76 194/255 194/255 194/255)
+(define-rgb-color grey76 194/255 194/255 194/255)
+(define-rgb-color gray77 196/255 196/255 196/255)
+(define-rgb-color grey77 196/255 196/255 196/255)
+(define-rgb-color gray78 199/255 199/255 199/255)
+(define-rgb-color grey78 199/255 199/255 199/255)
+(define-rgb-color gray79 67/85 67/85 67/85)
+(define-rgb-color grey79 67/85 67/85 67/85)
+(define-rgb-color gray80 4/5 4/5 4/5)
+(define-rgb-color grey80 4/5 4/5 4/5)
+(define-rgb-color gray81 69/85 69/85 69/85)
+(define-rgb-color grey81 69/85 69/85 69/85)
+(define-rgb-color gray82 209/255 209/255 209/255)
+(define-rgb-color grey82 209/255 209/255 209/255)
+(define-rgb-color gray83 212/255 212/255 212/255)
+(define-rgb-color grey83 212/255 212/255 212/255)
+(define-rgb-color gray84 214/255 214/255 214/255)
+(define-rgb-color grey84 214/255 214/255 214/255)
+(define-rgb-color gray85 217/255 217/255 217/255)
+(define-rgb-color grey85 217/255 217/255 217/255)
+(define-rgb-color gray86 73/85 73/85 73/85)
+(define-rgb-color grey86 73/85 73/85 73/85)
+(define-rgb-color gray87 74/85 74/85 74/85)
+(define-rgb-color grey87 74/85 74/85 74/85)
+(define-rgb-color gray88 224/255 224/255 224/255)
+(define-rgb-color grey88 224/255 224/255 224/255)
+(define-rgb-color gray89 227/255 227/255 227/255)
+(define-rgb-color grey89 227/255 227/255 227/255)
+(define-rgb-color gray90 229/255 229/255 229/255)
+(define-rgb-color grey90 229/255 229/255 229/255)
+(define-rgb-color gray91 232/255 232/255 232/255)
+(define-rgb-color grey91 232/255 232/255 232/255)
+(define-rgb-color gray92 47/51 47/51 47/51)
+(define-rgb-color grey92 47/51 47/51 47/51)
+(define-rgb-color gray93 79/85 79/85 79/85)
+(define-rgb-color grey93 79/85 79/85 79/85)
+(define-rgb-color gray94 16/17 16/17 16/17)
+(define-rgb-color grey94 16/17 16/17 16/17)
+(define-rgb-color gray95 242/255 242/255 242/255)
+(define-rgb-color grey95 242/255 242/255 242/255)
+(define-rgb-color gray96 49/51 49/51 49/51)
+(define-rgb-color grey96 49/51 49/51 49/51)
+(define-rgb-color gray97 247/255 247/255 247/255)
+(define-rgb-color grey97 247/255 247/255 247/255)
+(define-rgb-color gray98 50/51 50/51 50/51)
+(define-rgb-color grey98 50/51 50/51 50/51)
+(define-rgb-color gray99 84/85 84/85 84/85)
+(define-rgb-color grey99 84/85 84/85 84/85)
+(define-rgb-color gray100 1 1 1)
+(define-rgb-color grey100 1 1 1)
+(define-rgb-color darkgrey 169/255 169/255 169/255)
+(define-rgb-color darkgray 169/255 169/255 169/255)
+(define-rgb-color darkblue 0 0 139/255)
+(define-rgb-color darkcyan 0 139/255 139/255)
+(define-rgb-color darkmagenta 139/255 0 139/255)
+(define-rgb-color darkred 139/255 0 0)
+(define-rgb-color lightgreen 48/85 14/15 48/85)
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/colors.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/colors.lisp
new file mode 100644
index 0000000..c0f3e47
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/colors.lisp
@@ -0,0 +1,167 @@
+(in-package :cl-colors)
+
+;;; color representations
+
+(deftype unit-real ()
+  "Real number in [0,1]."
+  '(real 0 1))
+
+(defstruct (rgb (:constructor rgb (red green blue)))
+  "RGB color."
+  (red nil :type unit-real :read-only t)
+  (green nil :type unit-real :read-only t)
+  (blue nil :type unit-real :read-only t))
+
+(defmethod make-load-form ((p rgb) &optional env)
+  (declare (ignore env))
+  (make-load-form-saving-slots p))
+
+(defun gray (value)
+  "Create an RGB representation of a gray color (value in [0,1)."
+  (rgb value value value))
+
+(define-structure-let+ (rgb) red green blue)
+
+(defstruct (hsv (:constructor hsv (hue saturation value)))
+  "HSV color."
+  (hue nil :type (real 0 360) :read-only t)
+  (saturation nil :type unit-real :read-only t)
+  (value nil :type unit-real :read-only t))
+
+(defmethod make-load-form ((p hsv) &optional env)
+  (declare (ignore env))
+  (make-load-form-saving-slots p))
+
+(define-structure-let+ (hsv) hue saturation value)
+
+(defun normalize-hue (hue)
+  "Normalize hue to the interval [0,360)."
+  (mod hue 360))
+
+;;; conversions
+
+(defun rgb-to-hsv (rgb &optional (undefined-hue 0))
+  "Convert RGB to HSV representation.  When hue is undefined (saturation is
+zero), UNDEFINED-HUE will be assigned."
+  (let+ (((&rgb red green blue) rgb)
+         (value (max red green blue))
+         (delta (- value (min red green blue)))
+         (saturation (if (plusp value)
+                         (/ delta value)
+                         0))
+         ((&flet normalize (constant right left)
+            (let ((hue (+ constant (/ (* 60 (- right left)) delta))))
+              (if (minusp hue)
+                  (+ hue 360)
+                  hue)))))
+    (hsv (cond
+           ((zerop saturation) undefined-hue) ; undefined
+           ((= red value) (normalize 0 green blue)) ; dominant red
+           ((= green value) (normalize 120 blue red)) ; dominant green
+           (t (normalize 240 red green)))
+         saturation
+         value)))
+
+(defun hsv-to-rgb (hsv)
+  "Convert HSV to RGB representation.  When SATURATION is zero, HUE is
+ignored."
+  (let+ (((&hsv hue saturation value) hsv))
+    ;; if saturation=0, color is on the gray line
+    (when (zerop saturation)
+      (return-from hsv-to-rgb (gray value)))
+    ;; nonzero saturation: normalize hue to [0,6)
+    (let+ ((h (/ (normalize-hue hue) 60))
+           ((&values quotient remainder) (floor h))
+           (p (* value (- 1 saturation)))
+           (q (* value (- 1 (* saturation remainder))))
+           (r (* value (- 1 (* saturation (- 1 remainder)))))
+           ((&values red green blue) (case quotient
+                                       (0 (values value r p))
+                                       (1 (values q value p))
+                                       (2 (values p value r))
+                                       (3 (values p q value))
+                                       (4 (values r p value))
+                                       (t (values value p q)))))
+      (rgb red green blue))))
+
+(defun hex-to-rgb (string)
+  "Parse hexadecimal notation (eg ff0000 or f00 for red) into an RGB color."
+  (let+ (((&values width max)
+          (case (length string)
+            (3 (values 1 15))
+            (6 (values 2 255))
+            (t (error "string ~A doesn't have length 3 or 6, can't parse as ~
+                       RGB specification" string))))
+         ((&flet parse (index)
+            (/ (parse-integer string :start (* index width)
+                                     :end (* (1+ index) width)
+                                     :radix 16)
+               max))))
+    (rgb (parse 0) (parse 1) (parse 2))))
+
+
+
+;;; conversion with generic functions
+
+(defgeneric as-hsv (color &optional undefined-hue)
+  (:method ((color rgb) &optional (undefined-hue 0))
+    (rgb-to-hsv color undefined-hue))
+  (:method ((color hsv) &optional undefined-hue)
+    (declare (ignore undefined-hue))
+    color))
+
+(defgeneric as-rgb (color)
+  (:method ((rgb rgb))
+    rgb)
+  (:method ((hsv hsv))
+    (hsv-to-rgb hsv))
+  (:method ((string string))
+    ;; TODO in the long run this should recognize color names too
+    (hex-to-rgb string)))
+
+
+
+;;; combinations
+
+;;; internal functions
+
+(declaim (inline cc))
+(defun cc (a b alpha)
+  "Convex combination (1-ALPHA)*A+ALPHA*B, ie  ALPHA is the weight of A."
+  (declare (type (real 0 1) alpha))
+  (+ (* (- 1 alpha) a) (* alpha b)))
+
+(defun rgb-combination (color1 color2 alpha)
+  "Color combination in RGB space."
+  (let+ (((&rgb red1 green1 blue1) (as-rgb color1))
+         ((&rgb red2 green2 blue2) (as-rgb color2))
+         ((&flet c (c1 c2) (cc c1 c2 alpha))))
+    (rgb (c red1 red2)
+         (c green1 green2)
+         (c blue1 blue2))))
+
+(defun hsv-combination (hsv1 hsv2 alpha &optional (positive? t))
+  "Color combination in HSV space.  POSITIVE? determines whether the hue
+combination is in the positive or negative direction on the color wheel."
+  (let+ (((&hsv hue1 saturation1 value1) (as-hsv hsv1))
+         ((&hsv hue2 saturation2 value2) (as-hsv hsv2))
+         ((&flet c (c1 c2) (cc c1 c2 alpha))))
+    (hsv (cond
+           ((and positive? (> hue1 hue2))
+            (normalize-hue (c hue1 (+ hue2 360))))
+           ((and (not positive?) (< hue1 hue2))
+            (normalize-hue (c (+ hue1 360) hue2)))
+           (t (c hue1 hue2)))
+         (c saturation1 saturation2)
+         (c value1 value2))))
+
+
+
+;;; macros used by the autogenerated files
+
+(defmacro define-rgb-color (name red green blue)
+  "Macro for defining color constants.  Used by the automatically generated color file."
+  (let ((constant-name (symbolicate #\+ name #\+)))
+    `(progn
+       (define-constant ,constant-name (rgb ,red ,green ,blue)
+         :test #'equalp :documentation ,(format nil "X11 color ~A." name)))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/hexcolors.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/hexcolors.lisp
new file mode 100644
index 0000000..289f8fd
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/hexcolors.lisp
@@ -0,0 +1,69 @@
+(in-package #:cl-colors)
+
+;;; parsing and printing of CSS-like colors
+
+(defun print-hex-rgb (color &key short (hash T) alpha destination)
+  "Converts a COLOR to its hexadecimal RGB string representation.  If
+SHORT is specified each component gets just one character.
+
+A hash character (#) is prepended if HASH is true (default).
+
+If ALPHA is set it is included as an ALPHA component.
+
+DESTINATION is the first argument to FORMAT, by default NIL."
+  (let+ (((&rgb red green blue) (as-rgb color))
+         (factor (if short 15 255))
+         ((&flet c (x) (round (* x factor)))))
+    (format destination (if short
+                            "~@[~C~]~X~X~X~@[~X~]"
+                            "~@[~C~]~2,'0X~2,'0X~2,'0X~@[~X~]")
+            (and hash #\#)
+            (c red) (c green) (c blue)
+            (and alpha (c alpha)))))
+
+;; TODO: a JUNK-ALLOWED parameter, like for PARSE-INTEGER, would be nice
+(defun parse-hex-rgb (string &key (start 0) end)
+  "Parses a hexadecimal RGB(A) color string.  Returns a new RGB color value
+and an alpha component if present."
+  (let* ((length (length string))
+         (end (or end length))
+         (sub-length (- end start)))
+    (cond
+      ;; check for valid range, we need at least three and accept at most
+      ;; nine characters
+      ((and (<= #.(length "fff") sub-length)
+            (<= sub-length #.(length "#ffffff00")))
+       (when (char= (char string start) #\#)
+         (incf start)
+         (decf sub-length))
+       (labels ((parse (string index offset)
+                  (parse-integer string :start index :end (+ offset index)
+                                        :radix 16))
+                (short (string index)
+                  (/ (parse string index 1) 15))
+                (long (string index)
+                  (/ (parse string index 2) 255)))
+         ;; recognize possible combinations of alpha component and length
+         ;; of the rest of the encoded color
+         (multiple-value-bind (shortp alphap)
+             (case sub-length
+               (#.(length "fff") (values T NIL))
+               (#.(length "fff0") (values T T))
+               (#.(length "ffffff") (values NIL NIL))
+               (#.(length "ffffff00") (values NIL T)))
+           (if shortp
+               (values
+                (rgb
+                 (short string start)
+                 (short string (+ 1 start))
+                 (short string (+ 2 start)))
+                (and alphap (short string (+ 3 start))))
+               (values
+                (rgb
+                 (long string start)
+                 (long string (+ 2 start))
+                 (long string (+ 4 start)))
+                (and alphap (long string (+ 6 start))))))))
+      (T
+       (error "not enough or too many characters in indicated sequence: ~A"
+              (subseq string start end))))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/introduction.txt b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/introduction.txt
new file mode 100644
index 0000000..88d1764
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/introduction.txt
@@ -0,0 +1,52 @@
+Color classes
+-------------
+
+The two main color classes are rgb and hsv, which have slots red,
+green, blue and hue, saturation, value respectively.  There is also an
+rgb class with an alpha channel (slot alpha) called rgba.  In the rgb
+class, valid slot values are from 0 to 1, while in the hsv class,
+saturation and value are in the interval [0,1], but hue is in [0,360).
+
+You can convert between rgb and hsv using rgb->hsv and hsv->rgb.  Note
+that for the former, you need to specify what happens when the hue is
+undefined (ie the color is gray).  By default, the hue of red (0) is
+assigned.
+
+Generic functions which find the appropriate conversion method are
+available with names ->rgb and ->hsv.  Use these if you want your
+functions to handle various different color representations but
+eventually you need to work with a single one.
+
+
+
+Named colors
+------------
+
+Named colors, parsed from the X11 colors file, are loaded from
+colornames.lisp.  As they are constants, names are between +'s.  All
+named colors are rgb.
+
+
+
+Convex combinations
+-------------------
+
+Use hsv-combination or rgb-combination for taking convex combinations
+in the respective color space.  Note that in the HSV space, you need
+to specify the direction on the color wheel, the default is positive.
+
+
+Example session
+---------------
+
+CL-COLORS> +blue+
+#<RGB red: 0.0d0  green: 0.0d0  blue: 1.0d0>
+CL-COLORS> (->hsv +blue+)
+#<HSV hue: 240.0d0  saturation: 1.0d0  value: 1.0d0>
+CL-COLORS> (rgb-combination +blue+ +green+ 0.5)
+#<RGB red: 0.0d0  green: 0.5d0  blue: 0.5d0>
+CL-COLORS> (->rgb (hsv-combination (->hsv +blue+) (->hsv +green+) 0.5))
+#<RGB red: 1.0d0  green: 0.0d0  blue: 0.0d0>
+CL-COLORS> (->rgb (hsv-combination (->hsv +blue+) (->hsv +green+) 0.5 nil))
+#<RGB red: 0.0d0  green: 1.0d0  blue: 1.0d0>
+
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/package-template.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/package-template.lisp
new file mode 100644
index 0000000..7306fde
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/package-template.lisp
@@ -0,0 +1,17 @@
+;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
+
+(in-package #:common-lisp-user)
+
+(defpackage #:cl-colors
+  (:use #:alexandria
+        #:common-lisp
+        #:let-plus)
+  (:export
+   #:rgb #:rgb-red #:rgb-green #:rgb-blue #:gray #:&rgb
+   #:hsv #:hsv-hue #:hsv-saturation #:hsv-value #:&hsv
+   #:rgb-to-hsv #:hsv-to-rgb #:hex-to-rgb #:as-hsv #:as-rgb
+   #:rgb-combination #:hsv-combination
+   #:parse-hex-rgb #:print-hex-rgb
+
+   ;; predefined color names
+~A))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/package.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/package.lisp
new file mode 100644
index 0000000..d96740b
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/package.lisp
@@ -0,0 +1,674 @@
+;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
+
+(in-package #:common-lisp-user)
+
+(defpackage #:cl-colors
+  (:use #:alexandria
+        #:common-lisp
+        #:let-plus)
+  (:export
+   #:rgb #:rgb-red #:rgb-green #:rgb-blue #:gray #:&rgb
+   #:hsv #:hsv-hue #:hsv-saturation #:hsv-value #:&hsv
+   #:rgb-to-hsv #:hsv-to-rgb #:hex-to-rgb #:as-hsv #:as-rgb
+   #:rgb-combination #:hsv-combination
+   #:parse-hex-rgb #:print-hex-rgb
+
+   ;; predefined color names
+   #:+snow+
+   #:+ghostwhite+
+   #:+whitesmoke+
+   #:+gainsboro+
+   #:+floralwhite+
+   #:+oldlace+
+   #:+linen+
+   #:+antiquewhite+
+   #:+papayawhip+
+   #:+blanchedalmond+
+   #:+bisque+
+   #:+peachpuff+
+   #:+navajowhite+
+   #:+moccasin+
+   #:+cornsilk+
+   #:+ivory+
+   #:+lemonchiffon+
+   #:+seashell+
+   #:+honeydew+
+   #:+mintcream+
+   #:+azure+
+   #:+aliceblue+
+   #:+lavender+
+   #:+lavenderblush+
+   #:+mistyrose+
+   #:+white+
+   #:+black+
+   #:+darkslategray+
+   #:+darkslategrey+
+   #:+dimgray+
+   #:+dimgrey+
+   #:+slategray+
+   #:+slategrey+
+   #:+lightslategray+
+   #:+lightslategrey+
+   #:+gray+
+   #:+grey+
+   #:+lightgrey+
+   #:+lightgray+
+   #:+midnightblue+
+   #:+navy+
+   #:+navyblue+
+   #:+cornflowerblue+
+   #:+darkslateblue+
+   #:+slateblue+
+   #:+mediumslateblue+
+   #:+lightslateblue+
+   #:+mediumblue+
+   #:+royalblue+
+   #:+blue+
+   #:+dodgerblue+
+   #:+deepskyblue+
+   #:+skyblue+
+   #:+lightskyblue+
+   #:+steelblue+
+   #:+lightsteelblue+
+   #:+lightblue+
+   #:+powderblue+
+   #:+paleturquoise+
+   #:+darkturquoise+
+   #:+mediumturquoise+
+   #:+turquoise+
+   #:+cyan+
+   #:+lightcyan+
+   #:+cadetblue+
+   #:+mediumaquamarine+
+   #:+aquamarine+
+   #:+darkgreen+
+   #:+darkolivegreen+
+   #:+darkseagreen+
+   #:+seagreen+
+   #:+mediumseagreen+
+   #:+lightseagreen+
+   #:+palegreen+
+   #:+springgreen+
+   #:+lawngreen+
+   #:+green+
+   #:+chartreuse+
+   #:+mediumspringgreen+
+   #:+greenyellow+
+   #:+limegreen+
+   #:+yellowgreen+
+   #:+forestgreen+
+   #:+olivedrab+
+   #:+darkkhaki+
+   #:+khaki+
+   #:+palegoldenrod+
+   #:+lightgoldenrodyellow+
+   #:+lightyellow+
+   #:+yellow+
+   #:+gold+
+   #:+lightgoldenrod+
+   #:+goldenrod+
+   #:+darkgoldenrod+
+   #:+rosybrown+
+   #:+indianred+
+   #:+saddlebrown+
+   #:+sienna+
+   #:+peru+
+   #:+burlywood+
+   #:+beige+
+   #:+wheat+
+   #:+sandybrown+
+   #:+tan+
+   #:+chocolate+
+   #:+firebrick+
+   #:+brown+
+   #:+darksalmon+
+   #:+salmon+
+   #:+lightsalmon+
+   #:+orange+
+   #:+darkorange+
+   #:+coral+
+   #:+lightcoral+
+   #:+tomato+
+   #:+orangered+
+   #:+red+
+   #:+hotpink+
+   #:+deeppink+
+   #:+pink+
+   #:+lightpink+
+   #:+palevioletred+
+   #:+maroon+
+   #:+mediumvioletred+
+   #:+violetred+
+   #:+magenta+
+   #:+violet+
+   #:+plum+
+   #:+orchid+
+   #:+mediumorchid+
+   #:+darkorchid+
+   #:+darkviolet+
+   #:+blueviolet+
+   #:+purple+
+   #:+mediumpurple+
+   #:+thistle+
+   #:+snow1+
+   #:+snow2+
+   #:+snow3+
+   #:+snow4+
+   #:+seashell1+
+   #:+seashell2+
+   #:+seashell3+
+   #:+seashell4+
+   #:+antiquewhite1+
+   #:+antiquewhite2+
+   #:+antiquewhite3+
+   #:+antiquewhite4+
+   #:+bisque1+
+   #:+bisque2+
+   #:+bisque3+
+   #:+bisque4+
+   #:+peachpuff1+
+   #:+peachpuff2+
+   #:+peachpuff3+
+   #:+peachpuff4+
+   #:+navajowhite1+
+   #:+navajowhite2+
+   #:+navajowhite3+
+   #:+navajowhite4+
+   #:+lemonchiffon1+
+   #:+lemonchiffon2+
+   #:+lemonchiffon3+
+   #:+lemonchiffon4+
+   #:+cornsilk1+
+   #:+cornsilk2+
+   #:+cornsilk3+
+   #:+cornsilk4+
+   #:+ivory1+
+   #:+ivory2+
+   #:+ivory3+
+   #:+ivory4+
+   #:+honeydew1+
+   #:+honeydew2+
+   #:+honeydew3+
+   #:+honeydew4+
+   #:+lavenderblush1+
+   #:+lavenderblush2+
+   #:+lavenderblush3+
+   #:+lavenderblush4+
+   #:+mistyrose1+
+   #:+mistyrose2+
+   #:+mistyrose3+
+   #:+mistyrose4+
+   #:+azure1+
+   #:+azure2+
+   #:+azure3+
+   #:+azure4+
+   #:+slateblue1+
+   #:+slateblue2+
+   #:+slateblue3+
+   #:+slateblue4+
+   #:+royalblue1+
+   #:+royalblue2+
+   #:+royalblue3+
+   #:+royalblue4+
+   #:+blue1+
+   #:+blue2+
+   #:+blue3+
+   #:+blue4+
+   #:+dodgerblue1+
+   #:+dodgerblue2+
+   #:+dodgerblue3+
+   #:+dodgerblue4+
+   #:+steelblue1+
+   #:+steelblue2+
+   #:+steelblue3+
+   #:+steelblue4+
+   #:+deepskyblue1+
+   #:+deepskyblue2+
+   #:+deepskyblue3+
+   #:+deepskyblue4+
+   #:+skyblue1+
+   #:+skyblue2+
+   #:+skyblue3+
+   #:+skyblue4+
+   #:+lightskyblue1+
+   #:+lightskyblue2+
+   #:+lightskyblue3+
+   #:+lightskyblue4+
+   #:+slategray1+
+   #:+slategray2+
+   #:+slategray3+
+   #:+slategray4+
+   #:+lightsteelblue1+
+   #:+lightsteelblue2+
+   #:+lightsteelblue3+
+   #:+lightsteelblue4+
+   #:+lightblue1+
+   #:+lightblue2+
+   #:+lightblue3+
+   #:+lightblue4+
+   #:+lightcyan1+
+   #:+lightcyan2+
+   #:+lightcyan3+
+   #:+lightcyan4+
+   #:+paleturquoise1+
+   #:+paleturquoise2+
+   #:+paleturquoise3+
+   #:+paleturquoise4+
+   #:+cadetblue1+
+   #:+cadetblue2+
+   #:+cadetblue3+
+   #:+cadetblue4+
+   #:+turquoise1+
+   #:+turquoise2+
+   #:+turquoise3+
+   #:+turquoise4+
+   #:+cyan1+
+   #:+cyan2+
+   #:+cyan3+
+   #:+cyan4+
+   #:+darkslategray1+
+   #:+darkslategray2+
+   #:+darkslategray3+
+   #:+darkslategray4+
+   #:+aquamarine1+
+   #:+aquamarine2+
+   #:+aquamarine3+
+   #:+aquamarine4+
+   #:+darkseagreen1+
+   #:+darkseagreen2+
+   #:+darkseagreen3+
+   #:+darkseagreen4+
+   #:+seagreen1+
+   #:+seagreen2+
+   #:+seagreen3+
+   #:+seagreen4+
+   #:+palegreen1+
+   #:+palegreen2+
+   #:+palegreen3+
+   #:+palegreen4+
+   #:+springgreen1+
+   #:+springgreen2+
+   #:+springgreen3+
+   #:+springgreen4+
+   #:+green1+
+   #:+green2+
+   #:+green3+
+   #:+green4+
+   #:+chartreuse1+
+   #:+chartreuse2+
+   #:+chartreuse3+
+   #:+chartreuse4+
+   #:+olivedrab1+
+   #:+olivedrab2+
+   #:+olivedrab3+
+   #:+olivedrab4+
+   #:+darkolivegreen1+
+   #:+darkolivegreen2+
+   #:+darkolivegreen3+
+   #:+darkolivegreen4+
+   #:+khaki1+
+   #:+khaki2+
+   #:+khaki3+
+   #:+khaki4+
+   #:+lightgoldenrod1+
+   #:+lightgoldenrod2+
+   #:+lightgoldenrod3+
+   #:+lightgoldenrod4+
+   #:+lightyellow1+
+   #:+lightyellow2+
+   #:+lightyellow3+
+   #:+lightyellow4+
+   #:+yellow1+
+   #:+yellow2+
+   #:+yellow3+
+   #:+yellow4+
+   #:+gold1+
+   #:+gold2+
+   #:+gold3+
+   #:+gold4+
+   #:+goldenrod1+
+   #:+goldenrod2+
+   #:+goldenrod3+
+   #:+goldenrod4+
+   #:+darkgoldenrod1+
+   #:+darkgoldenrod2+
+   #:+darkgoldenrod3+
+   #:+darkgoldenrod4+
+   #:+rosybrown1+
+   #:+rosybrown2+
+   #:+rosybrown3+
+   #:+rosybrown4+
+   #:+indianred1+
+   #:+indianred2+
+   #:+indianred3+
+   #:+indianred4+
+   #:+sienna1+
+   #:+sienna2+
+   #:+sienna3+
+   #:+sienna4+
+   #:+burlywood1+
+   #:+burlywood2+
+   #:+burlywood3+
+   #:+burlywood4+
+   #:+wheat1+
+   #:+wheat2+
+   #:+wheat3+
+   #:+wheat4+
+   #:+tan1+
+   #:+tan2+
+   #:+tan3+
+   #:+tan4+
+   #:+chocolate1+
+   #:+chocolate2+
+   #:+chocolate3+
+   #:+chocolate4+
+   #:+firebrick1+
+   #:+firebrick2+
+   #:+firebrick3+
+   #:+firebrick4+
+   #:+brown1+
+   #:+brown2+
+   #:+brown3+
+   #:+brown4+
+   #:+salmon1+
+   #:+salmon2+
+   #:+salmon3+
+   #:+salmon4+
+   #:+lightsalmon1+
+   #:+lightsalmon2+
+   #:+lightsalmon3+
+   #:+lightsalmon4+
+   #:+orange1+
+   #:+orange2+
+   #:+orange3+
+   #:+orange4+
+   #:+darkorange1+
+   #:+darkorange2+
+   #:+darkorange3+
+   #:+darkorange4+
+   #:+coral1+
+   #:+coral2+
+   #:+coral3+
+   #:+coral4+
+   #:+tomato1+
+   #:+tomato2+
+   #:+tomato3+
+   #:+tomato4+
+   #:+orangered1+
+   #:+orangered2+
+   #:+orangered3+
+   #:+orangered4+
+   #:+red1+
+   #:+red2+
+   #:+red3+
+   #:+red4+
+   #:+debianred+
+   #:+deeppink1+
+   #:+deeppink2+
+   #:+deeppink3+
+   #:+deeppink4+
+   #:+hotpink1+
+   #:+hotpink2+
+   #:+hotpink3+
+   #:+hotpink4+
+   #:+pink1+
+   #:+pink2+
+   #:+pink3+
+   #:+pink4+
+   #:+lightpink1+
+   #:+lightpink2+
+   #:+lightpink3+
+   #:+lightpink4+
+   #:+palevioletred1+
+   #:+palevioletred2+
+   #:+palevioletred3+
+   #:+palevioletred4+
+   #:+maroon1+
+   #:+maroon2+
+   #:+maroon3+
+   #:+maroon4+
+   #:+violetred1+
+   #:+violetred2+
+   #:+violetred3+
+   #:+violetred4+
+   #:+magenta1+
+   #:+magenta2+
+   #:+magenta3+
+   #:+magenta4+
+   #:+orchid1+
+   #:+orchid2+
+   #:+orchid3+
+   #:+orchid4+
+   #:+plum1+
+   #:+plum2+
+   #:+plum3+
+   #:+plum4+
+   #:+mediumorchid1+
+   #:+mediumorchid2+
+   #:+mediumorchid3+
+   #:+mediumorchid4+
+   #:+darkorchid1+
+   #:+darkorchid2+
+   #:+darkorchid3+
+   #:+darkorchid4+
+   #:+purple1+
+   #:+purple2+
+   #:+purple3+
+   #:+purple4+
+   #:+mediumpurple1+
+   #:+mediumpurple2+
+   #:+mediumpurple3+
+   #:+mediumpurple4+
+   #:+thistle1+
+   #:+thistle2+
+   #:+thistle3+
+   #:+thistle4+
+   #:+gray0+
+   #:+grey0+
+   #:+gray1+
+   #:+grey1+
+   #:+gray2+
+   #:+grey2+
+   #:+gray3+
+   #:+grey3+
+   #:+gray4+
+   #:+grey4+
+   #:+gray5+
+   #:+grey5+
+   #:+gray6+
+   #:+grey6+
+   #:+gray7+
+   #:+grey7+
+   #:+gray8+
+   #:+grey8+
+   #:+gray9+
+   #:+grey9+
+   #:+gray10+
+   #:+grey10+
+   #:+gray11+
+   #:+grey11+
+   #:+gray12+
+   #:+grey12+
+   #:+gray13+
+   #:+grey13+
+   #:+gray14+
+   #:+grey14+
+   #:+gray15+
+   #:+grey15+
+   #:+gray16+
+   #:+grey16+
+   #:+gray17+
+   #:+grey17+
+   #:+gray18+
+   #:+grey18+
+   #:+gray19+
+   #:+grey19+
+   #:+gray20+
+   #:+grey20+
+   #:+gray21+
+   #:+grey21+
+   #:+gray22+
+   #:+grey22+
+   #:+gray23+
+   #:+grey23+
+   #:+gray24+
+   #:+grey24+
+   #:+gray25+
+   #:+grey25+
+   #:+gray26+
+   #:+grey26+
+   #:+gray27+
+   #:+grey27+
+   #:+gray28+
+   #:+grey28+
+   #:+gray29+
+   #:+grey29+
+   #:+gray30+
+   #:+grey30+
+   #:+gray31+
+   #:+grey31+
+   #:+gray32+
+   #:+grey32+
+   #:+gray33+
+   #:+grey33+
+   #:+gray34+
+   #:+grey34+
+   #:+gray35+
+   #:+grey35+
+   #:+gray36+
+   #:+grey36+
+   #:+gray37+
+   #:+grey37+
+   #:+gray38+
+   #:+grey38+
+   #:+gray39+
+   #:+grey39+
+   #:+gray40+
+   #:+grey40+
+   #:+gray41+
+   #:+grey41+
+   #:+gray42+
+   #:+grey42+
+   #:+gray43+
+   #:+grey43+
+   #:+gray44+
+   #:+grey44+
+   #:+gray45+
+   #:+grey45+
+   #:+gray46+
+   #:+grey46+
+   #:+gray47+
+   #:+grey47+
+   #:+gray48+
+   #:+grey48+
+   #:+gray49+
+   #:+grey49+
+   #:+gray50+
+   #:+grey50+
+   #:+gray51+
+   #:+grey51+
+   #:+gray52+
+   #:+grey52+
+   #:+gray53+
+   #:+grey53+
+   #:+gray54+
+   #:+grey54+
+   #:+gray55+
+   #:+grey55+
+   #:+gray56+
+   #:+grey56+
+   #:+gray57+
+   #:+grey57+
+   #:+gray58+
+   #:+grey58+
+   #:+gray59+
+   #:+grey59+
+   #:+gray60+
+   #:+grey60+
+   #:+gray61+
+   #:+grey61+
+   #:+gray62+
+   #:+grey62+
+   #:+gray63+
+   #:+grey63+
+   #:+gray64+
+   #:+grey64+
+   #:+gray65+
+   #:+grey65+
+   #:+gray66+
+   #:+grey66+
+   #:+gray67+
+   #:+grey67+
+   #:+gray68+
+   #:+grey68+
+   #:+gray69+
+   #:+grey69+
+   #:+gray70+
+   #:+grey70+
+   #:+gray71+
+   #:+grey71+
+   #:+gray72+
+   #:+grey72+
+   #:+gray73+
+   #:+grey73+
+   #:+gray74+
+   #:+grey74+
+   #:+gray75+
+   #:+grey75+
+   #:+gray76+
+   #:+grey76+
+   #:+gray77+
+   #:+grey77+
+   #:+gray78+
+   #:+grey78+
+   #:+gray79+
+   #:+grey79+
+   #:+gray80+
+   #:+grey80+
+   #:+gray81+
+   #:+grey81+
+   #:+gray82+
+   #:+grey82+
+   #:+gray83+
+   #:+grey83+
+   #:+gray84+
+   #:+grey84+
+   #:+gray85+
+   #:+grey85+
+   #:+gray86+
+   #:+grey86+
+   #:+gray87+
+   #:+grey87+
+   #:+gray88+
+   #:+grey88+
+   #:+gray89+
+   #:+grey89+
+   #:+gray90+
+   #:+grey90+
+   #:+gray91+
+   #:+grey91+
+   #:+gray92+
+   #:+grey92+
+   #:+gray93+
+   #:+grey93+
+   #:+gray94+
+   #:+grey94+
+   #:+gray95+
+   #:+grey95+
+   #:+gray96+
+   #:+grey96+
+   #:+gray97+
+   #:+grey97+
+   #:+gray98+
+   #:+grey98+
+   #:+gray99+
+   #:+grey99+
+   #:+gray100+
+   #:+grey100+
+   #:+darkgrey+
+   #:+darkgray+
+   #:+darkblue+
+   #:+darkcyan+
+   #:+darkmagenta+
+   #:+darkred+
+   #:+lightgreen+))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/parse-x11-colors.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/parse-x11-colors.lisp
new file mode 100644
index 0000000..4735c20
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/parse-x11-colors.lisp
@@ -0,0 +1,68 @@
+;;; parse X11's rgb.txt
+;;;
+;;; no packages defined as this should just be run as a script.
+
+(require :cl-ppcre)
+(require :alexandria)
+
+(defun write-package-file (colornames
+                           &key (package-template-path "package-template.lisp")
+                                (package-file-path "package.lisp"))
+  "Write a package definition file, exporting COLORNAMES, using the given template."
+  (let* ((package-template (alexandria:read-file-into-string package-template-path))
+         (colornames-export
+           (reduce (lambda (a b) (format nil "~A~%~A" a b))
+                   colornames
+                   :key (lambda (colorname)
+                          (format nil "   #:+~A+" colorname)))))
+    (with-open-file (package-file package-file-path
+                                  :direction :output
+                                  :if-exists :supersede
+                                  :if-does-not-exist :create)
+      (format package-file package-template colornames-export))
+    (values)))
+
+(defun parse-and-write-color-definitions (&key
+                                          (source-path "/usr/share/X11/rgb.txt")
+                                          (destination-path "colornames.lisp"))
+  "Parse color definitions and write them into a file. Return the list of colors (for exporting)."
+  (let ((color-scanner                  ; will only take names w/o spaces
+          (cl-ppcre:create-scanner
+           "^\\s*(\\d+)\\s+(\\d+)\\s+(\\d+)\\s+([\\s\\w]+\?)\\s*$"
+           :extended-mode t))
+        (comment-scanner (cl-ppcre:create-scanner "^\\s*!"))
+        colornames)
+    (with-open-file (source source-path
+                       :direction :input
+                       :if-does-not-exist :error)
+      (with-open-file (colordefs destination-path
+                                 :direction :output
+                                 :if-exists :supersede
+                                 :if-does-not-exist :create)
+        (format colordefs ";;;; This file was generated automatically ~
+by parse-x11.lisp~%~
+;;;; Please do not edit directly, just run make if necessary (but should not be).~2%~
+ (in-package #:cl-colors)~2%")
+        (labels ((parse-channel (string)
+                   (let ((i (read-from-string string)))
+                     (assert (and (typep i 'integer) (<= i 255)))
+                     (/ i 255))))
+          (do ((line (read-line source nil nil) (read-line source nil nil)))
+              ((not line))
+            (unless (cl-ppcre:scan-to-strings comment-scanner line)
+              (multiple-value-bind (match registers)
+                  (cl-ppcre:scan-to-strings color-scanner line)
+                (if (and match (not (find #\space (aref registers 3))))
+                    (let ((colorname (string-downcase (aref registers 3))))
+                      (format colordefs
+                              "(define-rgb-color ~A ~A ~A ~A)~%"
+                              colorname
+                              (parse-channel (aref registers 0))
+                              (parse-channel (aref registers 1))
+                              (parse-channel (aref registers 2)))
+                      (push colorname colornames))
+                    (format t "ignoring line ~A~%" line)))))))
+      (nreverse colornames))))
+
+(let ((colornames (parse-and-write-color-definitions)))
+  (write-package-file colornames))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/test.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/test.lisp
new file mode 100644
index 0000000..f44ce78
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-colors-20180328-git/test.lisp
@@ -0,0 +1,82 @@
+(in-package #:cl-user)
+
+(defpackage #:cl-colors-tests
+  (:use #:alexandria #:common-lisp #:cl-colors #:let-plus #:lift)
+  (:export #:run))
+
+(in-package #:cl-colors-tests)
+
+(deftestsuite cl-colors-tests () ())
+
+(defun run ()
+  "Run all the tests for CL-COLORS-TESTS."
+  (run-tests :suite 'cl-colors-tests))
+
+(defun eps= (a b &optional (epsilon 1e-10))
+  (<= (abs (- a b)) epsilon))
+
+(defun rgb= (rgb1 rgb2 &optional (epsilon 1e-10))
+  "Compare RGB colors for (numerical) equality."
+  (let+ (((&rgb red1 green1 blue1) rgb1)
+         ((&rgb red2 green2 blue2) rgb2))
+    (and (eps= red1 red2 epsilon)
+         (eps= green1 green2 epsilon)
+         (eps= blue1 blue2 epsilon))))
+
+(defun random-rgb ()
+  (rgb (random 1d0) (random 1d0) (random 1d0)))
+
+(addtest (cl-colors-tests)
+  rgb<->hsv
+  (loop repeat 100 do
+    (let ((rgb (random-rgb)))
+      (ensure-same rgb (as-rgb (as-hsv rgb)) :test #'rgb=))))
+
+;; (defun test-hue-combination (from to positivep)
+;;   (dotimes (i 21)
+;;     (format t "~a " (hue-combination from to (/ i 20) positivep))))
+
+(addtest (cl-colors-tests)
+  print-hex-rgb
+  (let ((rgb (rgb 0.070 0.203 0.337)))
+    (ensure-same "#123456" (print-hex-rgb rgb))
+    (ensure-same "123456" (print-hex-rgb rgb :hash nil))
+    (ensure-same "#135" (print-hex-rgb rgb :short t))
+    (ensure-same "135" (print-hex-rgb rgb :hash nil :short t))
+    (ensure-same "#12345678" (print-hex-rgb rgb :alpha 0.47))
+    (ensure-same "12345678" (print-hex-rgb rgb :alpha 0.47 :hash nil))
+    (ensure-same "#1357" (print-hex-rgb rgb :alpha 0.47 :short t))
+    (ensure-same "1357" (print-hex-rgb rgb :alpha 0.47 :hash nil :short t))))
+
+(addtest (cl-colors-tests)
+  parse-hex-rgb
+  (let ((rgb (rgb 0.070 0.203 0.337)))
+    (ensure-same rgb (parse-hex-rgb "#123456") :test (rcurry #'rgb= 0.01))
+    (ensure-same rgb (parse-hex-rgb "123456") :test (rcurry #'rgb= 0.01))
+    (ensure-same rgb (parse-hex-rgb "#135") :test (rcurry #'rgb= 0.01))
+    (ensure-same rgb (parse-hex-rgb "135") :test (rcurry #'rgb= 0.01))
+
+    (flet ((aux (list1 list2)
+             (and (rgb= (car list1) (car list2) 0.01)
+                  (eps= (cadr list1) (cadr list2) 0.01))))
+      (ensure-same (list rgb 0.47) (multiple-value-list (parse-hex-rgb "#12345678")) :test #'aux)
+      (ensure-same (list rgb 0.47) (multiple-value-list (parse-hex-rgb "12345678")) :test #'aux)
+      (ensure-same (list rgb 0.47) (multiple-value-list (parse-hex-rgb "#1357")) :test #'aux)
+      (ensure-same (list rgb 0.47) (multiple-value-list (parse-hex-rgb "1357")) :test #'aux))))
+
+(addtest (cl-colors-tests)
+  print-hex-rgb/format
+  (ensure-same "#123456" (with-output-to-string (*standard-output*)
+                           (print-hex-rgb (rgb 0.070 0.203 0.337)
+                                          :destination T))))
+
+(addtest (cl-colors-tests)
+  hex<->rgb
+  (loop repeat 100 do
+    (let ((rgb (random-rgb)))
+      (ensure-same rgb (parse-hex-rgb (print-hex-rgb rgb)) :test (rcurry #'rgb= 0.01)))))
+
+(addtest (cl-colors-tests)
+  parse-hex-rgb-ranges
+  (ensure-same (rgb 0.070 0.203 0.337) (parse-hex-rgb "foo#123456zzz" :start 3 :end 10)
+               :test (rcurry #'rgb= 0.001)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/LICENSE.txt b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/LICENSE.txt
new file mode 100644
index 0000000..5eaf87c
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/LICENSE.txt
@@ -0,0 +1,14 @@
+CL-EMB has fixes by current maintainer, Michael Raskin <38a938c2@rambler.ru>
+This fixes are Copyright (c) 2009 by Moscow Center of Continious 
+Mathematical Education.
+
+CL-EMB is written and Copyright (c) 2004, 2005, 2006 by Stefan Scholl.
+Parts of the source are taken from LSP, written by
+John Wiseman and copyright 2001, 2002 I/NET Inc.
+See lsp-LICENSE.txt
+
+CL-EMB is licensed under the terms of the Lisp Lesser GNU
+Public License (http://opensource.franz.com/preamble.html), known as
+the LLGPL.  The LLGPL consists of a preamble (see above URL) and the
+LGPL.  Where these conflict, the preamble takes precedence. 
+CL-EMB is referenced in the preamble as the "LIBRARY."
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/README.md b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/README.md
new file mode 100644
index 0000000..70d91e1
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/README.md
@@ -0,0 +1,339 @@
+# cl-emb: Embedded Common Lisp
+
+A mixture of features from eRuby and HTML::Template. You could name it "Yet
+Another LSP" (LispServer Pages) but it's a bit more than that and not limited to
+a certain server or text format.
+
+This is a mirror of http://mtn-host.prjek.net/projects/cl-emb
+
+The primary development repository is in Monotone, this repository will receive
+just the automated snapshots.
+
+# License
+
+[LLGPL](http://opensource.franz.com/preamble.html)
+
+# Installing
+
+```lisp
+(ql:quickload :cl-emb)
+```
+
+CL-EMB can also be installed manually with [ASDF-INSTALL](http://weitz.de/asdf-install/).
+
+# Usage
+
+## [generic function] `EXECUTE-EMB name &key env generator-maker => string`
+
+`NAME` can be a registered (with `REGISTER-EMB`) emb code or a pathname (type
+`PATHNAME`) of a file containing the code. Returns a string.  Keyword parameter
+ENV to pass objects to the code. `ENV` must be a plist. `ENV` can be accessed
+within your emb code.  The `GENERATOR-MAKER` is a function which gets called
+with a key and value from the given `ENV` and should return a generator function
+like described
+[here](http://www.cs.northwestern.edu/academics/courses/325/readings/graham/generators.html).
+
+
+## [generic function] `REGISTER-EMB name code => emb-function`
+
+Internally registeres given `CODE` with `NAME` to be called with
+`EXECUTE-EMB`. `CODE` can be a string or a pathname (type `PATHNAME`) of a file
+containing the code.
+
+## [function] `PPRINT-EMB-FUNCTION name`
+
+`DEBUG` function. Pretty prints function form, if `*DEBUG*` was `T` when the
+function was registered.
+
+## [function] `CLEAR-EMB name`
+
+Remove named emb code.
+
+## [function] `CLEAR-EMB-ALL`
+
+Remove all registered emb code.
+
+## [function] `CLEAR-EMB-ALL-FILES`
+
+Remove all registered file emb code (registered/executed by a pathname).
+
+## [special variable] `*EMB-START-MARKER*` (default `"<%"`)
+
+Start of scriptlet or expression. Remember that a following `#\=` indicates an
+expression.
+
+## [special variable] `*EMB-END-MARKER*` (default `"%>"`)
+
+End of scriptlet or expression.
+
+## [special variable] `*ESCAPE-TYPE*`
+
+Default value for escaping `@var` output is `:RAW` Can be changed to `:XML`,
+`:HTML`, `:URI`, `:URL`, `:URL-ENCODE`, `:LATEX`.
+
+## [special variable] `*FUNCTION-PACKAGE*`
+
+Package the emb function body gets interned to.
+
+Default: `(find-package :cl-emb-intern)`.
+
+## [special variable] `*DEBUG*`
+
+Debugging mode if `T`. Default: `NIL`.
+
+## [special variable] `*LOCKING-FUNCTION*`
+
+Function to call to lock access to an internal hash table.  Must accept a
+function designator which must be called with the lock hold.
+
+**IMPORTANT:** The locking function must return the value of the function it
+calls!
+
+Example:
+
+```lisp
+(defvar *emb-lock* (kmrcl::make-lock "emb-lock")
+  "Lock for CL-EMB.")
+
+(defun emb-lock-function (func)
+  "Lock function for CL-EMB."
+  (kmrcl::with-lock-held (*emb-lock*)
+  (funcall func)))
+
+(setf emb:*locking-function* 'emb-lock-function)
+```
+
+Files get cached and reread when they change.
+
+The emb code consists of normal text (HTML, XML, or any other text format) and
+special tags you know from eRuby or JSP (JavaServer Pages) which can hold Common
+Lisp or CL-EMB's template tags, perhaps comparable to JSP's taglib.
+
+- `<% ... %>` is a scriptlet tag, and wraps Common Lisp code.
+- `<%= ... %>` is an expression tag. Its content gets evaluated and fed as a
+            parameter to `(FORMAT T "~A" ...)`.
+- `<%# ... #%>` is a comment. Everything within will be removed/ignored.  Can't
+            be nested!
+
+## Examples
+
+```lisp
+CL-USER> (asdf:oos 'asdf:load-op :cl-emb)
+CL-USER> (cl-emb:register-emb "test1"
+                              "10 stars: <% (dotimes (i 10) %>*<% ) %>")
+#<CL-EMB::EMB-FUNCTION {9B74259}>
+CL-USER> (cl-emb:execute-emb "test1")
+"10 stars: **********"
+
+CL-USER> (cl-emb:register-emb "test2" "2 + 2 = <%= (+ 2 2) %>")
+#<CL-EMB::EMB-FUNCTION {9BCACE1}>
+CL-USER> (cl-emb:execute-emb "test2")
+"2 + 2 = 4"
+
+CL-USER> (let ((emb:*emb-start-marker* "<?emb")
+               (emb:*emb-end-marker* "?>"))
+           (emb:register-emb "marker-test"
+                             "42 + 42 = <?emb= (+ 42 42) ?>"))
+#<CL-EMB::EMB-FUNCTION {97BEFD9}>
+CL-USER> (emb:execute-emb "marker-test")
+"42 + 42 = 84"
+```
+
+# Template Tags
+
+You can use special template tags instead of Common Lisp code between `<%` and
+`%>`. This will be translated to Common Lisp and serves as a simple shortcut for
+you.
+
+And more important: It's easier to use for non-programmers. A designer can work
+on HTML code and insert these simple template tags.
+
+Template tags start with `@`.
+
+Currently supported: `@if`, `@else`, `@endif`, `@ifnotempty`, `@unless`, 
+`@endunless`, `@var`, `@repeat`, `@endrepeat`, `@loop`, `@endloop`, `@include`,
+`@includevar`, `@call`, `@with`, `@endwith`, `@set`, `@genloop`, `@endgenloop`,
+`@insert`.
+
+`@if` and `@unless` check if the given parameter is set in the supplied
+environment (parameter ENV of `EXECUTE-EMB`). The environment is a plist with
+keyword + value pairs. Must be terminated with `@endif` or `@endunless`.
+
+`@ifnotempty` works like `@if` but considers the empty string false.
+
+`@ifequal` accepts two parameters interpreted as variable names. It works like
+`@if` but checks whether the values of two variables are equal. Variable names
+are intepreted as in `@var`.
+
+Note that `@ifnotempty` and `@ifequal` are supposed to be used together with
+`@else` and `@endif`.
+
+`@var` emits the corresponding value from the environment. Uses the escape type
+defined in `*ESCAPE-TYPE*` (Default `:raw`, no escaping) or with -escape
+modifier. E.g. `<% @var foo -escape xml %>` or without modifier `<% @var foo
+%>` Supported escaping: `raw`, `xml` (aka `html`), `uri` (aka `url` or
+`url-encode`), `latex`.
+
+`@insert` inserts a given (text) file. Parameter from the environment. E.g. `<%
+@insert textfile %>`.
+
+`@repeat` repeats everything between it and `@endrepeat` the given
+times. Parameter can be a number or a name. The name will be used to lookup the
+corresponding value from the environment.
+
+`@loop` loops over a named list in the environment. Environment gets set to
+current plist inside this list. Must be terminated with `@endloop`.
+
+`@include` includes a given file. Relative to current template. `@includevar`
+does the same, but the parameter is treated like a variable name containing the
+path to the file. Variable name is treated like in `@var`.
+
+`@call` calls a given emb-function, which was registered with `REGISTER-EMB`.
+
+`@with` is similar to `@loop` as it sets the current environment to the named
+plist. `@loop` needs a list of plists and `@with` just a plist associated to the
+given name. Block ends in `@endwith`.
+
+`@set` is used to set special variables like `*ESCAPE-TYPE*` from within a emb
+code. This way a default for a file can be specified in the file itself. The
+variables are changed for the current and called/included code.  Changes to the
+variables in called/included code don't effect the caller/ includer. E.g. `<%
+@set escape=uri %>`. Currently supported: `escape` (`raw`, `xml`, `html`, `url`,
+`uri`, `url-encode`, `latex`).
+
+`@genloop` starts a special kind of loop: a generator loop. It must be
+terminated by `@endgenloop` and operates on a generator returned by the given
+`GENERATOR-MAKER` (see `EXECUTE-EMB`). The `GENERATOR-MAKER` gets called with
+two parameters: the key (which is the argument to `@genloop`) and the
+corresponding value in the plist. Each time in the loop the generator is called
+first with the parameter `:TEST` to see if there's data left.  The generator
+must return a plist on `:NEXT`, which will be the current `ENV` (like `@with` or
+within a normal `@loop`).
+
+The parameters which access the environment can just be the name of a keyword
+symbol in the plist. `foo` -> :FOO in `(:FOO "bar")` Or you can provide a path
+within a nested plist structure by dividing the parts of the path with a
+slash. `foo/bar` -> Value of `:BAR` inside the plist at `:FOO`. `(:FOO (:BAR
+"yeah"))` -> `"yeah"` Starting the parameter with a slash lets it traverse the
+nested plists from the top. That way you can access top values inside loops.
+
+Writing `<% @var foo/bar/quux %>` can be translated to `(GETF (GETF (GETF ENV
+:FOO) :BAR) :QUUX)`.
+
+## Examples
+
+```lisp
+CL-USER> (cl-emb:register-emb "test1"
+                              "Foo: <% @if foo %>Yes!<% @else %>No!<% @endif %>")
+#<CL-EMB::EMB-FUNCTION {9C0F2D1}>
+CL-USER> (cl-emb:execute-emb "test1" :env '(:foo t))
+"Foo: Yes!"
+CL-USER> (cl-emb:execute-emb "test1")
+"Foo: No!"
+CL-USER> (cl-emb:execute-emb "test1" :env '(:foo nil))
+"Foo: No!"
+
+CL-USER> (cl-emb:register-emb "test2"
+                              "What is set? -> <% @call test1 %>")
+#<CL-EMB::EMB-FUNCTION {9C526E9}>
+CL-USER> (cl-emb:execute-emb "test2" :env '(:foo t))
+"What is set? -> Foo: Yes!"
+
+CL-USER> (cl-emb:register-emb "test3"
+                              "10 stars: <% @repeat 10 %>*<% @endrepeat %>")
+#<CL-EMB::EMB-FUNCTION {9C9F1D1}>
+CL-USER> (cl-emb:execute-emb "test3")
+"10 stars: **********"
+
+CL-USER> (cl-emb:register-emb "test4"
+                              "<% @loop numbers %>[<% @var de %>,<% @var en %>]<% @endloop %>")
+#<CL-EMB::EMB-FUNCTION {9174DF1}>
+CL-USER> (cl-emb:execute-emb "test4"
+                             :env '(:numbers ((:de "EINS" :en "ONE")
+                                              (:de "ZWEI" :en "TWO"))))
+"[EINS,ONE][ZWEI,TWO]"
+
+CL-USER> (emb:register-emb "test5"
+                           "<a href=\"http://somewhere.test/test.cgi?<% @var foo -escape uri %>\"><% @var foo %></a>")
+#<CL-EMB::EMB-FUNCTION {9FBF5F1}>
+CL-USER> (let ((emb:*escape-type* :html))
+           (emb:execute-emb "test5" :env '(:foo "10 > 7")))
+"<a href=\"http://somewhere.test/test.cgi?10+%3E+7\">10 &gt; 7</a>"
+
+CL-USER> (emb:register-emb "test6" "1. <% @with one %>BAZ: <% @var baz %><% @endwith%>
+2. <% @with two %>BAZ: <% @var baz %><% @endwith%>")
+#<CL-EMB::EMB-FUNCTION {9916EB1}>
+CL-USER> (emb:execute-emb "test6" :env '(:one (:baz "first")
+                                         :two (:baz "second")))
+"1. BAZ: first
+2. BAZ: second"
+
+CL-USER> (emb:register-emb "test7" " - <% @var foo -escape uri %> - ")
+#<CL-EMB::EMB-FUNCTION {96F1239}>
+CL-USER> (emb:pprint-emb-function "test7")
+
+(LAMBDA (&OPTIONAL CL-EMB-INTERN::ENV)
+  (WITH-OUTPUT-TO-STRING (*STANDARD-OUTPUT*)
+    (PROGN
+     (WRITE-STRING " - ")
+     (FORMAT T "~A" (CL-EMB::ECHO (GETF CL-EMB-INTERN::ENV :FOO) :ESCAPE :URI))
+     (WRITE-STRING " - "))))
+; No value
+
+CL-USER> (emb:register-emb "test8" "<% @set escape=xml %>--<% @var hey %>--")
+#<CL-EMB::EMB-FUNCTION {962B839}>
+CL-USER> (emb:register-emb "test9" "--<% @var hey %>--<% @call test8 %>--<% @var hey %>--")
+#<CL-EMB::EMB-FUNCTION {96931A9}>
+CL-USER> (emb:execute-emb "test9" :env '(:hey "5>2"))
+"--5>2----5&gt;2----5>2--"
+
+CL-USER> (emb:register-emb "test10" "Square root from 1 to <% @var numbers %>: <% @genloop numbers %>sqrt(<% @var number %>) = <% @var sqrt %> <% @endgenloop %>")
+#<CL-EMB::EMB-FUNCTION {581EC765}>
+CL-USER> (defun make-sqrt-1-to-n-gen (key n)
+           (declare (ignore key))
+           (let ((i 1))
+             #'(lambda (cmd)
+                 (ecase cmd
+                   (:test (> i n))
+                   (:get `(:number ,i :sqrt ,(sqrt i)))
+                   (:next (prog1 `(:number ,i :sqrt ,(sqrt i))
+                            (unless (> i n)
+                              (incf i))))))))
+MAKE-SQRT-1-TO-N-GEN
+CL-USER> (emb:execute-emb "test10" :env '(:numbers 10) :generator-maker 'make-sqrt-1-to-n-gen)
+"Square root from 1 to 10: sqrt(1) = 1.0 sqrt(2) = 1.4142135 sqrt(3) = 1.7320508 sqrt(4) = 2.0 sqrt(5) = 2.236068 sqrt(6) = 2.4494898 sqrt(7) = 2.6457512 sqrt(8) = 2.828427 sqrt(9) = 3.0 sqrt(10) = 3.1622777 "
+
+CL-USER> (emb:register-emb "test11" "<% @loop bands %>Band: <% @var band %> (Genre: <% @var /genre %>)<br><% @endloop %>")
+#<CL-EMB::EMB-FUNCTION {58ADB12D}>
+CL-USER> (emb:execute-emb "test11" :env '(:genre "Rock" :bands ((:band "Queen") (:band "The Rolling Stones") (:band "ZZ Top"))))
+"Band: Queen (Genre: Rock)<br>Band: The Rolling Stones (Genre: Rock)<br>Band: ZZ Top (Genre: Rock)<br>"
+
+CL-USER> (emb:register-emb "test12" "<% @repeat /foo/bar/count %>*<% @endrepeat %>")
+#<CL-EMB::EMB-FUNCTION {58B7583D}>
+CL-USER> (emb:execute-emb "test12" :env '(:foo (:bar (:count 42))))
+"******************************************"
+
+CL-USER> (emb:register-emb "test13" "The file:<pre><% @insert textfile %></pre>")
+#<CL-EMB::EMB-FUNCTION {5894326D}>
+CL-USER> (emb:execute-emb "test13" :env '(:textfile "/etc/gentoo-release"))
+"The file:<pre>Gentoo Base System version 1.6.14
+</pre>"
+```
+
+# Credits
+
+Uses code from John Wiseman. See http://lemonodor.com/archives/000128.html and
+lsp-LICENSE.txt Thanks to Edi Weitz for letting me use his code for
+`ESCAPE-FOR-XML`.
+
+Thanks to Eitarow Fukamachi for the whitespace-trimming patch.
+
+Thanks to Christoph Finkensiep for making `getf*` a generic function.
+
+# Author
+
+Stefan Scholl <stesch@no-spoon.de>
+
+# Current Maintainer
+
+Michael Raskin <38a938c2@rambler.ru>
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/TODO b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/TODO
new file mode 100644
index 0000000..f8a1418
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/TODO
@@ -0,0 +1,14 @@
+
+- Documentation
+
+- More examples
+
+- Tests
+
+- Writing own escape functions?
+
+- Better error handling
+
+- Examples for generator loop in the examples.html
+
+- Export GETF-EMB
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/cl-emb.asd b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/cl-emb.asd
new file mode 100644
index 0000000..695e8b6
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/cl-emb.asd
@@ -0,0 +1,26 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
+
+;;; This software is Copyright (c) Stefan Scholl, 2004.
+;;; Stefan Scholl grants you the rights to distribute
+;;; and use this software as governed by the terms
+;;; of the Lisp Lesser GNU Public License
+;;; (http://opensource.franz.com/preamble.html),
+;;; known as the LLGPL.
+
+
+(in-package #:cl-user)
+
+(defpackage #:cl-emb.system
+  (:use #:cl
+        #:asdf))
+
+(in-package #:cl-emb.system)
+
+(defsystem #:cl-emb
+    :version "0.4.3"
+    :author "Stefan Scholl <stesch@no-spoon.de>"
+    :licence "Lesser Lisp General Public License"
+    :description "A templating system for Common Lisp"
+    :depends-on (#:cl-ppcre)
+    :components ((:file "packages")
+                 (:file "emb" :depends-on ("packages"))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/emb.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/emb.lisp
new file mode 100644
index 0000000..bcf3a3b
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/emb.lisp
@@ -0,0 +1,523 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
+
+;;; This file contains some fixes by Michael Raskin
+;;; They are Copyright (c) Moscow Center of Continious Mathematical 
+;;; Education, 2009
+
+;;; This software is Copyright (c) Stefan Scholl, 2004.
+;;; Stefan Scholl grants you the rights to distribute
+;;; and use this software as governed by the terms
+;;; of the Lisp Lesser GNU Public License
+;;; (http://opensource.franz.com/preamble.html),
+;;; known as the LLGPL.
+
+;;; Parts of the source are taken from LSP, written by
+;;; John Wiseman and copyright 2001, 2002 I/NET Inc.
+;;; (http://www.inetmi.com/)
+;;; See lsp-LICENSE.txt
+
+
+(in-package :cl-emb)
+
+(defpackage :cl-emb-intern (:use :cl))
+
+(defvar *function-package* (find-package :cl-emb-intern)
+  "Package the emb function body gets interned to.")
+
+(defvar *debug* nil
+  "Debugging for CL-EMB.")
+
+(defvar *locking-function* nil
+  "Function to call to lock access to an internal hash table. Must accept
+a function designator which must be called with the lock hold.")
+
+
+(defmacro with-lock (&body body)
+  "Locking all accesses to *functions*"
+  `(cond (*locking-function*
+           (funcall *locking-function* #'(lambda () ,@body)))
+          (t ,@body)))
+  
+(defgeneric execute-emb (name &key env generator-maker)
+  (:documentation "Execute named emb code. Returns a string. Keyword parameter ENV
+to pass objects to the code. ENV must be a plist."))
+
+(defmethod execute-emb ((name t) &key env generator-maker)
+  (funcall (get-emb-function name) :env env :generator-maker generator-maker :name name))
+
+(defmethod execute-emb ((name pathname) &key env generator-maker)
+  (let ((fun (or (get-emb-function name)
+                 (emb-function-function (register-emb name name)))))
+    (funcall fun :env env :generator-maker generator-maker :name name)))
+
+(defvar *functions* (make-hash-table :test #'equal)
+  "Table mapping names to emb-function instances.")
+
+(defclass emb-function ()
+  ((path :initarg :path
+         :accessor emb-function-path)
+   (time :initarg :time
+         :accessor emb-function-time)
+   (function :initarg :function
+             :accessor emb-function-function)
+   (form :initarg :form
+         :initform nil
+         :accessor  emb-function-form)))
+
+(defun make-emb-function (path time function &optional form)
+  "Constructor for class EMB-FUNCTION."
+  (make-instance 'emb-function
+                 :path path
+                 :time time
+                 :function function
+                 :form form))
+
+
+(defun pprint-emb-function (name)
+  "DEBUG function. Pretty prints function form, if *DEBUG* was t
+when the function was registered."
+  (with-lock 
+    (pprint (emb-function-form (gethash name *functions*)))))
+
+
+(defun clear-emb-all ()
+  "Remove all registered emb code."
+  (with-lock
+    (clrhash *functions*)))
+
+(defun clear-emb (name)
+  "Remove named emb code."
+  (with-lock
+    (remhash name *functions*)))
+
+(defun clear-emb-all-files ()
+  "Remove all registered file emb code (registered/executed by a pathname)."
+  (with-lock
+    (maphash (lambda (key value) (declare (ignore value))
+                     (when (typep key 'pathname) (remhash key *functions*)))
+             *functions*)))
+
+(defun get-emb-function (name)
+  "Returns the named function implementing a registered emb code.
+Rebuilds it when text template was a file which has been modified."
+  (with-lock
+    (let* ((emb-function (gethash name *functions*))
+           (path (when emb-function (emb-function-path emb-function))))
+      (cond ((and (not (typep name 'pathname)) (null emb-function))
+             (error "Function ~S not found." name))
+            ((null emb-function)
+             (return-from get-emb-function))
+            ((and path
+                  (> (file-write-date path) (emb-function-time emb-function)))
+             ;; Update when file is newer
+             (multiple-value-bind (function form)
+                 (construct-emb-function (contents-of-file path))
+               (setf (emb-function-time emb-function) (file-write-date path)
+                     (emb-function-function emb-function) function
+                     (emb-function-form emb-function) form))))
+      (emb-function-function emb-function))))
+
+
+(defgeneric register-emb (name code)
+  (:documentation "Register given CODE as NAME."))
+
+(defmethod register-emb (name (code pathname))
+  (multiple-value-bind (function form)
+      (construct-emb-function (contents-of-file code))
+    (with-lock
+      (setf (gethash name *functions*)
+            (make-emb-function code
+                               (file-write-date code)
+                               function
+                               form)))))
+
+(defmethod register-emb (name (code string))
+  (multiple-value-bind (function form)
+      (construct-emb-function code)
+    (with-lock
+      (setf (gethash name *functions*)
+            (make-emb-function nil
+                               (get-universal-time)
+                               function
+                               form)))))
+
+(defvar *emb-start-marker* "<%"
+  "Start of scriptlet or expression. Remember that a following #\=
+indicates an expression.")
+
+(defvar *emb-end-marker* "%>"
+  "End of scriptlet or expression.")
+
+
+(defparameter *set-special-list*
+  '(("escape" . "cl-emb:*escape-type*")
+    ("case-sensitivity" . "cl-emb:*case-sensitivity*")))
+
+(defparameter *set-parameter-list*
+  '(("xml" . ":xml")
+    ("html" . ":html")
+    ("url" . ":url")
+    ("uri" . ":uri")
+    ("url-encode" . ":url-encode")
+    ("raw" . ":raw")
+    ("latex" . ":latex")
+    ("t" . "t")
+    ("nil" . "nil")))
+
+;; TODO: Refactor! Looks a bit clumsy.
+(defun set-specials (match &rest registers)
+  "Parse parameter(s) of @set and set special variables
+like e. g. *ESCAPE-TYPE*."
+  ;;  <% @set escape=xml schnuffel=poe %>
+  (declare (ignore match))
+  (let ((setf-pairs
+         (let ((setf-list nil))
+           (dolist (pair (cl-ppcre:split "\\s+" (first registers))
+                    (when (first setf-list)
+                      (format nil "~{ ~A~}" (reverse setf-list))))
+             (destructuring-bind (left right)
+                 (cl-ppcre:split "=" pair)
+               (let ((place (rest (assoc left *set-special-list* :test #'equalp)))
+                     (value (rest (assoc right *set-parameter-list* :test #'equalp))))
+                 (when (and place value)
+                   (push (concatenate 'string place " " value) setf-list))))))))
+    (if setf-pairs
+        (format nil "(setf ~A)" setf-pairs)
+        "")))
+
+(defparameter *template-tag-expand*
+  `(("\\s+@if\\s+(\\S+)\\s*"      . " (cond ((cl-emb::autofuncall (cl-emb::getf-emb \"\\1\")) ")
+    ("\\s+@ifnotempty\\s+(\\S+)\\s*"      . " (cond ((let* ((value (cl-emb::autofuncall (cl-emb::getf-emb \"\\1\")))) (or (numberp value) (> (length value) 0))) ")
+    ("\\s+@ifequal\\s+(\\S+)\\s+(\\S+)\\s*"      . "  (cond ((equal (format nil \"~a\" (cl-emb::autofuncall (cl-emb::getf-emb \"\\1\"))) (format nil \"~a\" (cl-emb::autofuncall (cl-emb::getf-emb \"\\2\")))) ")
+    ("\\s+@else\\s*"              . " ) (t ")
+    ("\\s+@endif\\s*"             . " )) ")
+    ("\\s+@unless\\s+(\\S+)\\s*"  . " (cond ((not (cl-emb::autofuncall (cl-emb::getf-emb \"\\1\"))) ")
+    ("\\s+@endunless\\s*"         . " )) ")
+    ("=?\\s+@var\\s+(\\S+)\\s+-(\\S+)\\s+(\\S+)\\s*"
+     . "= (cl-emb::echo (cl-emb::getf-emb \"\\1\") :\\2 :\\3) ")
+    ("=?\\s+@var\\s+(\\S+)\\s*"   . "= (cl-emb::echo (cl-emb::getf-emb \"\\1\")) ")
+    ("\\s+@repeat\\s+(\\d+)\\s*"  . " (dotimes (i \\1) ")
+    ("\\s+@repeat\\s+(\\S+)\\s*"  . " (dotimes (i (or (cl-emb::autofuncall (cl-emb::getf-emb \"\\1\")) 0)) ")
+    ("\\s+@endrepeat\\s*"         . " ) ")
+    ("\\s+@loop\\s+(\\S+)\\s*"    . " (dolist (env (cl-emb::autofuncall (cl-emb::getf-emb \"\\1\"))) ")
+    ("\\s+@endloop\\s*"           . " ) ")
+    ("\\s+@genloop\\s+(\\S+)\\s*" . " (let ((env) 
+                                            (%gen (funcall generator-maker :\\1 
+                                                           (cl-emb::getf-emb \"\\1\"))))
+                                           (loop
+                                            (when (funcall %gen :test) (return))
+                                            (setq env (funcall %gen :next))
+                                            (progn ")
+    ("\\s+@endgenloop\\s*"        . " ))) ")
+    ("\\s+@with\\s+(\\S+)\\s*"    . " (let ((env (cl-emb::autofuncall (cl-emb::getf-emb \"\\1\")))) ")
+    ("\\s+@endwith\\s*"           . " ) ")
+    ("\\s+@include\\s+(\\S+)\\s*" . "= (let ((cl-emb:*escape-type* cl-emb:*escape-type*))
+                                            (cl-emb:execute-emb (merge-pathnames \"\\1\" template-path-default) :env env :generator-maker generator-maker)) ")
+    ("\\s+@includevar\\s+(\\S+)\\s*" . "= (let* ((cl-emb:*escape-type* cl-emb:*escape-type*) 
+                                                  (parameter (cl-emb::autofuncall (cl-emb::getf-emb \"\\1\"))))
+                                                (unless parameter (error \"use of @includevar on undefined parameter ~s\" \"\\1\"))
+						(cl-emb:execute-emb (merge-pathnames parameter template-path-default) :env env :generator-maker generator-maker)) ")
+    ("\\s+@call\\s+(\\S+)\\s*"    . "= (let ((cl-emb:*escape-type* cl-emb:*escape-type*))
+                                            (cl-emb:execute-emb \"\\1\" :env env :generator-maker generator-maker)) ")
+    ("\\s+@insert\\s+(\\S+)\\s*"  . "= (cl-emb::contents-of-file (merge-pathnames (cl-emb::autofuncall (cl-emb::getf-emb \"\\1\")) template-path-default)) ")
+    ("\\s+@set\\s+(.*?)\\s*"      . ,(function set-specials))
+    ("#.*"                        . "")
+    )
+  "List of conses. FIRST is regex, REST replacement (STRING or FUNCTION).
+Functions get called with two parameters: match and list of registers.")
+
+;; Code from Edi Weitz's TBNL <http://weitz.de/tbnl/>
+(defun escape-for-xml (string)
+  (with-output-to-string (out)
+    (with-input-from-string (in string)
+      (loop for char = (read-char in nil nil)
+            while char
+            do (case char
+                 ((#\<) (write-string "&lt;" out))
+                 ((#\>) (write-string "&gt;" out))
+                 ((#\") (write-string "&quot;" out))
+                 ((#\') (write-string "&#39;" out))
+                 ((#\&) (write-string "&amp;" out))
+                 (otherwise (write-char char out)))))))
+
+(defun escape-by-table (string replacements)
+  (with-output-to-string (out)
+    (with-input-from-string (in string)
+      (loop for char = (read-char in nil nil)
+            while char
+            do (let ((new (find char replacements 
+                                :test 'equal
+                                :key 'car)))
+                    (if new 
+                        (write-string (cdr new) out)
+                        (write-char char out))
+                    )))))
+
+(defvar *latex-replacements*)
+(setf *latex-replacements*
+  (mapcar 
+   (lambda (x) `(,(character (car x)) . ,(cdr x)))
+  `(
+    ("#" . "\\#")
+    ("$" . "\\$")
+    ("%" . "\\%")
+    ("&" . "\\&")
+    ("_" . "\\_")
+    ("{" . "\\{")
+    ("}" . "\\}")
+    ("<" . "{$<$}")
+    (">" . "{$>$}")
+    ("\\" . "{$\\backslash{}$}")
+    ("|" . "{$\\vert{}$}")
+    ("~" . "{\\,$\\tilde{}$\\,}")
+    ("^" . "{\\,$\\hat{}$\\,}")
+    (,(string #\Return) . "~\\\\")
+    (,(string #\NewLine) . "~\\\\")
+    ("\"" . "{'{}'}")
+    (,(string (code-char 173)) . "\\-")   ; Soft hyphen
+    (,(string (code-char 160)) . "~")     ; No-break space
+    (,(string (code-char 8209)) . "-")    ; Non-breaking hyphen
+    (,(string (code-char 8211)) . "--")   ; En-dash
+    (,(string (code-char 8212)) . "---")  ; Em-dash
+    (,(string (code-char 8470)) . "{\\textnumero}") ; Number sign
+    )))
+
+(defun escape-for-latex (string)
+  (escape-by-table string 
+                   *latex-replacements*))
+
+;; Inspired by Edi Weitz' ESCAPE-FOR-HTML
+(defun url-encode (string)
+  "URL-encode a string."
+  (with-output-to-string (out)
+    (with-input-from-string (in string)
+      (loop for char = (read-char in nil nil)
+            while char
+            if (find char "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-.")
+               do (write-char char out)
+            else if (char= char #\Space)
+                    do (write-char #\+ out)
+                 else
+                    do (format out "%~2,'0x" (char-code char))))))
+
+
+(defvar *case-sensitivity* nil
+  "Whether use case-sensitive mode (the default) or case-insensitive mode. If this is set NIL, the case of keys in ENV will be ignored.")
+
+(defun string-to-keyword (string)
+  "Interns a given STRING uppercased in the keyword package."
+  (nth-value 0 (intern
+                (if *case-sensitivity*
+                    string
+                    (string-upcase string)) :keyword)))
+
+(defgeneric getf* (thing key &optional default)
+  (:documentation "Returns a value by a key"))
+
+(defmethod getf* ((plist list) key &optional default)
+  "Uses getf to get a value from a plist"
+  (if *case-sensitivity*
+      (getf plist key default)
+      (loop for (k v) on plist by #'cddr
+            when (string-equal k key)
+              do (return v)
+            finally (return default))))
+
+(defmethod getf* ((table hash-table) key &optional default)
+  "Uses gethash to get a value from a hash-table"
+  (gethash key table default))
+
+(defmethod getf* ((object standard-object) key &optional default)
+  "Uses slot-value to get a value from a standard object, where the slot name is derived from key"
+  (let ((slot-name (intern (princ-to-string key)
+                           (symbol-package (class-name (class-of object))))))
+    (if (and (slot-exists-p object slot-name)
+             (slot-boundp object slot-name))
+        (slot-value object slot-name)
+        default)))
+
+(defmacro getf-emb (key)
+  "Search either plist TOPENV or ENV according to the search path in KEY. KEY
+is a string."
+  (let ((plist (if (char= (char key 0) #\/)
+                   (find-symbol "TOPENV" emb:*function-package*)
+                   (find-symbol "ENV" emb:*function-package*)))
+        (path-parts (cl-ppcre:split "/" key :sharedp t)))
+    (labels ((dig-plist (plist keys)
+               (if (null keys)
+                   plist
+                   (dig-plist
+                    (if (zerop (length (first keys)))
+                        plist
+                        `(getf* ,plist ,(string-to-keyword (first keys))))
+                    (rest keys)))))
+      (dig-plist plist path-parts))))
+
+(defvar *escape-type* :raw
+  "Default value for escaping @var output.")
+
+(defun autofuncall (v)
+  (if (functionp v)
+    (autofuncall (funcall v))
+    v))
+
+(defun echo (string &key (escape *escape-type*))
+  "Emit given STRING. Escape if wanted (global or via ESCAPE keyword).
+STRING can be NIL."
+  (let ((str (cond 
+              ((stringp string) string)
+              ((null string) "")
+              ((functionp string) 
+               (format nil "~a" (or (autofuncall string) "")))
+              (t (format nil "~a" string))
+              )))
+    (case escape 
+      ((:html :xml)
+       (escape-for-xml str))
+      ((:latex)
+       (escape-for-latex str))
+      ((:url :uri :url-encode)
+       (url-encode str))
+      (otherwise                        ; incl. :raw
+       str))))
+
+(defun insert-file (filename)
+  "Get given file FILENAME."
+  (contents-of-file filename))
+
+(let ((scanner-hash (make-hash-table :test #'equal)))
+  (defun scanner-for-expand-template-tag (tag)
+    "Returns a CL-PPCRE scanner which matches a template tag expanded by EXPAND-TEMPLATE-TAGS.
+Scanners are memoized in SCANNER-HASH once they are created."
+    (or (gethash tag scanner-hash)
+        (setf (gethash tag scanner-hash)
+              (ppcre:create-scanner tag))))
+  (defun clear-expand-template-tag-hash ()
+    "Removes all scanners for template tags from cache."
+    (clrhash scanner-hash)))
+
+(defun expand-template-tags (string)
+  "Expand template-tags (@if, @else, ...) to Common Lisp.
+Replacement and regex in *TEMPLATE-TAG-EXPAND*"
+  (labels ((expand-tags (string &optional (expands *template-tag-expand*))
+             (let ((regex (scanner-for-expand-template-tag
+                           (concatenate 'string "(?is)"
+                                        "^" (first (first expands)) "$")))
+                   (replacement (rest (first expands))))
+               (if (null (rest expands))
+                   (ppcre:regex-replace-all regex string replacement :simple-calls t)
+                   (expand-tags
+                    (ppcre:regex-replace-all regex string replacement :simple-calls t)
+                    (rest expands))))))
+    (ppcre:regex-replace-all (format nil "(?is)(~A\\-?)(.+?)(\\-?~A)"
+                                     (ppcre:quote-meta-chars *emb-start-marker*)
+                                     (ppcre:quote-meta-chars *emb-end-marker*))
+                             string
+                             (lambda (match start-tag string end-tag)
+                               (declare (ignore match))
+                               (if (ppcre:scan "(?is)^#.+#$" string)
+                                   ""
+                                   (concatenate 'string
+                                                start-tag
+                                                (expand-tags string)
+                                                end-tag)))
+                             :simple-calls t)))
+
+(defvar *emb-stream-redirection* "with-output-to-string (*standard-output*)")
+
+(defun construct-emb-function (code)
+  "Builds and compiles the emb-function out of template code."
+  (let ((form 
+         `,(let ((*package* *function-package*))
+                (read-from-string
+                 (format nil "(lambda (&key env generator-maker name)(declare (ignorable env generator-maker))
+                               (let ((topenv env)
+                                     (template-path-default (if (typep name 'pathname) name *default-pathname-defaults*)))
+                                    (declare (ignorable topenv template-path-default))
+                                (~a
+                                (progn ~A))))"
+                         *emb-stream-redirection*
+                         (construct-emb-body-string
+                          (expand-template-tags code)))))))
+    (values (compile nil form)
+            (when *debug* form))))
+
+(defun contents-of-file (pathname)
+  "Returns a string with the entire contents of the specified file."
+  (with-open-file (in pathname :direction :input)
+    ;; See http://www.emmett.ca/~sabet/licensets/slurp.html
+    (let* ((file-length (file-length in))
+           (seq (make-string file-length))
+           (pos (read-sequence seq in)))
+      (if (< pos file-length)
+          (subseq seq 0 pos)
+          seq))))
+
+(defun string-right-trim-spaces-until-newline (string)
+  (remove #\Newline (string-right-trim '(#\Space #\Tab) string)
+          :from-end t
+          :count 1))
+
+;; (i) Converts text outside <% ... %> tags into calls
+;; to WRITE-STRING, (ii) Text inside <% ... %>
+;; ("scriptlets") is straight lisp code, (iii) Text inside <%= ... %>
+;; ("expressions") becomes the argument to (FORMAT t "~A" ...)
+;; The markers <% and %> can be overridden by setting
+;; *emb-start-marker* and *emb-end-marker*
+(defun construct-emb-body-string (code &optional (start 0))
+  "Takes a string containing an emb code and returns a string
+containing the lisp code that implements that emb code."
+  (multiple-value-bind (start-tag start-code tag-type trim-start-whitespaces)
+      (next-code code start)
+    (if (not start-tag)
+        (format nil "(write-string ~S)" (subseq code start))
+        (let* ((end-code (search *emb-end-marker* code :start2 start-code))
+               (trim-end-whitespaces (char= (char code (1- end-code)) #\-)))
+          (if (not end-code)
+              (error "EOF reached in EMB inside open '~A' tag." *emb-start-marker*)
+              (format nil "(write-string ~S) ~A ~A"
+                      (if trim-start-whitespaces
+                          (string-right-trim-spaces-until-newline (subseq code start start-tag))
+                          (subseq code start start-tag))
+                      (format nil (tag-template tag-type)
+                              (subseq code start-code (if trim-end-whitespaces
+                                                          (1- end-code)
+                                                          end-code)))
+                      (construct-emb-body-string
+                       code
+                       (if trim-end-whitespaces
+                           (let ((next-pos (cl-ppcre:scan "(?:\\S|\\n)" code :start (+ end-code (length *emb-end-marker*)))))
+                             (cond
+                               ((null next-pos) (length code))
+                               ((char= (elt code next-pos) #\Newline)
+                                (1+ next-pos))
+                               (t next-pos)))
+                           (+ end-code (length *emb-end-marker*))))))))))
+
+
+;; Finds the next scriptlet or expression tag in EMB source.  Returns
+;; nil if none are found, otherwise returns 3 values:
+;;  1. The position of the first character of the start tag.
+;;  2. The position of the contents of the tag.
+;;  3. The type of tag (:scriptlet or :expression).
+;;  4. Whether trim whitespaces before the start tag.
+(defun next-code (string start)
+  (let ((start-tag (search *emb-start-marker* string :start2 start)))
+    (if (not start-tag)
+        nil
+        (let ((start-code (+ start-tag (length *emb-start-marker*))))
+          (case (and (> (length string) start-code)
+                     (char string start-code))
+            (#\= (values start-tag (1+ start-code) :expression nil))
+            (#\- (values start-tag (1+ start-code) :scriptlet t))
+            (otherwise (values start-tag start-code :scriptlet nil)))))))
+
+
+;; Given a tag type (:scriptlet or :expression), returns a format
+;; string to be used to generate source code from the contents of the
+;; tag.
+(defun tag-template (tag-type)
+  (ecase tag-type
+    ((:scriptlet) "~A")
+    ((:expression) "(format t \"~~A\" ~A)")))
+
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/examples.css b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/examples.css
new file mode 100644
index 0000000..1f644ae
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/examples.css
@@ -0,0 +1,18 @@
+
+body { font-family: sans-serif; 
+       background-color: #fff;
+       color: #000; }
+
+pre { margin-top: 0; 
+      margin-bottom: 0; }
+
+table { width: 100%; }
+
+th, td { text-align: left;
+         vertical-align: top; }
+
+th { background-color: #eee; }
+
+caption { font-weight: bold; }
+
+table, ol { margin-bottom: 2em; }
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/examples.html b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/examples.html
new file mode 100644
index 0000000..311cb33
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/examples.html
@@ -0,0 +1,232 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <link href="examples.css" rel="stylesheet" type="text/css" />
+    <title>CL-EMB: Examples</title>
+  </head>
+  <body>
+    <h1>Some examples of <a href="http://common-lisp.net/project/cl-emb/">CL-EMB</a> usage</h1>
+    <ol>
+      <li><a href="#combine-cl-who">Combining CL-EMB with CL-WHO</a></li>
+      <li><a href="#simple-loop">A simple loop</a></li>
+      <li><a href="#build-dropdown">Build a dropdown</a></li>
+      <li><a href="#mark-fields">Mark invalid form fields</a></li>
+      <li><a href="#using-generic-templates">Using generic templates</a></li>
+    </ol>
+    <table border="1" cellpadding="2" id="combine-cl-who">
+      <caption>Combining CL-EMB with CL-WHO</caption>
+      <tr>
+        <th>
+          Description
+        </th>
+        <td>
+          You can mix several methods of HTML generating together. Think of <a href="http://www.cliki.net/Lisp%20Markup%20Languages">Lisp Markup Languages</a> like <a href="http://weitz.de/cl-who/">CL-WHO</a>. <small>(Example code from the <a href="http://weitz.de/cl-who/">CL-WHO</a> documentation.)</small>
+        </td>
+      </tr>
+      <tr>
+        <th>
+          ENV
+        </th>
+        <td>
+          <code>NIL</code>
+        </td>
+      </tr>
+      <tr>
+        <th>
+          Dependencies
+        </th>
+        <td>
+          <a href="http://weitz.de/cl-who/">CL-WHO</a>
+        </td>
+      </tr>
+      <tr>
+        <td colspan="2">
+          <pre>&lt;h1&gt;Music links&lt;/h1&gt;
+&lt;%
+(cl-who:with-html-output (*standard-output*)
+  (loop for (link . title) in 
+        '((&quot;http://zappa.com/&quot; . &quot;Frank Zappa&quot;)
+          (&quot;http://marcusmiller.com/&quot; . &quot;Marcus Miller&quot;)
+          (&quot;http://www.milesdavis.com/&quot; . &quot;Miles Davis&quot;))
+        do (cl-who:htm (:a :href link
+                           (:b (cl-who:str title)))
+                       :br)))
+%&gt;</pre>
+        </td>
+      </tr>
+    </table>
+
+    <table border="1" cellpadding="2" id="simple-loop">
+      <caption>A simple loop</caption>
+      <tr>
+        <th>
+          Description
+        </th>
+        <td>
+          The "Music links" example with template tags and a loop. This example isn't meant to prove anything! Use the method which fits your problem!<br/>
+          The output of the title gets escaped by CL-EMB ("-escape html"). Depending on the situation you'd rather escape the output yourself and don't want to use any complicated modifiers in the template code itself.
+        </td>
+      </tr>
+      <tr>
+        <th>
+          ENV
+        </th>
+        <td>
+<pre>'(:music-list
+  ((:link "http://zappa.com/" :title "Frank Zappa")
+   (:link "http://marcusmiller.com/" :title "Marcus Miller")
+   (:link "http://www.milesdavis.com/" :title "Miles Davis")))</pre>
+        </td>
+      </tr>
+      <tr>
+        <th>
+          Dependencies
+        </th>
+        <td>
+          -
+        </td>
+      </tr>
+      <tr>
+        <td colspan="2">
+          <pre>&lt;h1&gt;Music links&lt;/h1&gt;
+&lt;% @loop music-list %&gt;
+&lt;a href=&quot;&lt;% @var link %&gt;&quot;&gt;&lt;b&gt;&lt;% @var title -escape html%&gt;&lt;/b&gt;&lt;/a&gt;&lt;br /&gt;
+&lt;% @endloop %&gt;</pre>
+        </td>
+      </tr>
+    </table>
+
+    <table border="1" cellpadding="2" id="build-dropdown">
+      <caption>Build a dropdown</caption>
+      <tr>
+        <th>
+          Description
+        </th>
+        <td>
+          You can mix template style with embedded Common Lisp style. This example shows how to access the plist ENV. Within the loop (<code >@loop</code>) ENV gets bound to every plist in the list.<br/>
+          <a href="http://weitz.de/tbnl/">TBNL</a> is used to access a submitted parameter "product" and compare it to the current value attribute of the option element.<br/>
+          Remember the escaping! Set <code>cl-emb:*escape-type*</code> to <code>:html</code> and all output of <code>@var</code> will be escaped correctly.
+        </td>
+      </tr>
+      <tr>
+        <th>
+          ENV
+        </th>
+        <td>
+<pre>'(:products
+  ((:value "foo1" :text "Super Foo")
+   (:value "fooxl" :text "Super Foo XL")
+   (:value "bar2000" :text "Ultra Bar 2000")
+   (:value "hl2" :text "Half-Life 2")
+   (:value "dn4e4" :text "Vaporware")))</pre>
+        </td>
+      </tr>
+      <tr>
+        <th>
+          Dependencies
+        </th>
+        <td>
+          <a href="http://weitz.de/tbnl/">TBNL</a>
+        </td>
+      </tr>
+      <tr>
+        <td colspan="2">
+          <pre>&lt;select name=&quot;product&quot;&gt;
+  &lt;% @loop products %&gt;
+    &lt;option value=&quot;&lt;% @var value %&gt;&quot;&lt;%
+      (when (equal (getf env :value) (tbnl:parameter &quot;product&quot;)) 
+    %&gt; selected=&quot;selected&quot;&lt;% ) %&gt;&gt;&lt;% @var text %&gt;&lt;/option&gt;
+  &lt;% @endloop %&gt;
+&lt;/select&gt;</pre>
+        </td>
+      </tr>
+    </table>
+
+    <table border="1" cellpadding="2" id="mark-fields">
+      <caption>Mark invalid form fields</caption>
+      <tr>
+        <th>
+          Description
+        </th>
+        <td>
+          Validate a form and mark the errors in the <em>ENV</em> plist.<br />
+          Again: Remember the escaping!
+        </td>
+      </tr>
+      <tr>
+        <th>
+          ENV
+        </th>
+        <td>
+<pre>'(:email "stesch@home" :email-error t)</pre>
+        </td>
+      </tr>
+      <tr>
+        <th>
+          Dependencies
+        </th>
+        <td>
+          -
+        </td>
+      </tr>
+      <tr>
+        <td colspan="2">
+          <pre>&lt;% @if email-error %&gt;
+  &lt;span class=&quot;error&quot;&gt;Please provide valid e-mail address&lt;/span&gt;&lt;br /&gt;
+&lt;% @endif %&gt;
+&lt;input type=&quot;text&quot; name=&quot;email&quot; value=&quot;&lt;% @var email %&gt;&quot;/&gt;</pre>
+        </td>
+      </tr>
+    </table>
+
+    <table border="1" cellpadding="2" id="using-generic-templates">
+      <caption>Using generic templates</caption>
+      <tr>
+        <th>
+          Description
+        </th>
+        <td>
+          You want to use generic templates which can be called with a defined set of parameters? Then <code>@with</code> and <code>@endwith</code> is what you are looking for. It sets the current <em>ENV</em> to the one accessed by a given name. See the example below, which calls a template for textinput fields.
+        </td>
+      </tr>
+      <tr>
+        <th>
+          ENV
+        </th>
+        <td>
+<pre>'(:name (:name "name"
+         :length 40)
+  :e-mail (:name "email"
+           :value "no@no"
+           :error t
+           :length 120))</pre>
+        </td>
+      </tr>
+      <tr>
+        <th>
+          Dependencies
+        </th>
+        <td>
+          -
+        </td>
+      </tr>
+      <tr>
+        <td colspan="2">
+          <pre>Please enter your name:&lt;br /&gt;
+&lt;% @with name %&gt;
+  &lt;% @include &quot;includes/textinput.tmpl&quot; %&gt;
+&lt;% @endwith %&gt;
+&lt;br /&gt;
+Please enter your e-mail address:&lt;br /&gt;
+&lt;small&gt;(Use the TLD &lt;em&gt;.invalid&lt;/em&gt;
+if you don't want to receive mail&lt;/small&gt;
+&lt;% @with e-mail %&gt;
+  &lt;% @include &quot;includes/textinput.tmpl&quot; %&gt;
+&lt;% @endwith %&gt;</pre>
+        </td>
+      </tr>
+    </table>
+  </body>
+</html>
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/lsp-LICENSE.txt b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/lsp-LICENSE.txt
new file mode 100644
index 0000000..776174f
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/lsp-LICENSE.txt
@@ -0,0 +1,27 @@
+
+CL-EMB uses parts of LSP, written by John Wiseman.
+
+See the copyright notice and license for LSP:
+
+---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---
+
+Copyright (c) 2001, 2002 I/NET Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/packages.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/packages.lisp
new file mode 100644
index 0000000..33285e3
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-emb-20190521-git/packages.lisp
@@ -0,0 +1,31 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
+
+;;; This software is Copyright (c) Stefan Scholl, 2004.
+;;; Stefan Scholl grants you the rights to distribute
+;;; and use this software as governed by the terms
+;;; of the Lisp Lesser GNU Public License
+;;; (http://opensource.franz.com/preamble.html),
+;;; known as the LLGPL.
+
+
+(in-package #:cl-user)
+
+(defpackage #:cl-emb
+  (:nicknames #:emb)
+  (:use #:cl)
+  (:export #:execute-emb
+           #:register-emb
+           #:pprint-emb-function
+           #:clear-emb
+           #:clear-emb-all
+           #:clear-emb-all-files
+           #:clear-expand-template-tag-hash
+           #:*debug*
+           #:*emb-start-marker*
+           #:*emb-end-marker*
+           #:*escape-type*
+           #:*case-sensitivity*
+           #:*locking-function*
+           #:*function-package*
+	   #:getf*
+           #:construct-emb-function ))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/CHANGELOG b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/CHANGELOG
new file mode 100644
index 0000000..fbd8333
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/CHANGELOG
@@ -0,0 +1,400 @@
+Version 2.1.1
+2019-04-07
+Version 2.0.11
+2015-08-26
+Fix for type checks in LispWorks 7 (Martin Simmons)
+
+Version 2.0.10
+2015-05-28
+Add :author/:license/:description fields to .asd files (Hans Huebner)
+Move inlined definitions before they are used. (Stas Boukarev)
+
+Version 2.0.9
+2014-11-28
+Merge branch 'master' of github.com:edicl/cl-ppcre (Hans Huebner)
+Merge pull request #20 from billitch/master (Hans Huebner)
+Typo in CREATE-SCANNER documentation. (Thomas de Grivel)
+
+Version 2.0.8
+2014-11-28
+Update support info (Hans Huebner)
+
+Version 2.0.7
+2014-01-23
+Doc: Update repository location, remove the darcs mirror. (Stas Boukarev)
+
+Version 2.0.6
+2015-01-05
+Fix failing tests and spurious compiler warnings
+
+Version 2.0.5
+2014-01-05
+Fix spurious test failures (Edi Weitz)
+
+Version 2.0.4
+2013-04-13
+Rewrite SEQ without using recursion (Stas Boukarev)
+:property and :invert-property scanning bug fix (Cyrus Harmon)
+Improve documentation (David Lindes)
+
+Version 2.0.3
+2009-10-28
+Use LW:SIMPLE-TEXT-STRING throughout for LispWorks
+
+Version 2.0.2
+2009-09-17
+Fixed typo in chartest.lisp (caught by Peter Seibel)
+Appease CCL (thanks to Hans H�bner)
+
+Version 2.0.1
+2008-09-02
+Fixed faulty declaration (caught by Brent Fulgham)
+
+Version 2.0.0
+2008-07-24
+Added named properties (\p{foo})
+Added Unicode support
+Introduced test functions for character classes
+Added optional test function optimization
+Cleaned up test suite, removed performance cruft
+Removed the various alternative system definitions (too much maintenance work)
+Exported PARSE-STRING
+Changed default value of *USE-BMH-MATCHERS*
+General cleanup
+Lots of documentation additions
+
+Version 1.4.1
+2008-07-03
+Skip non-characters in CREATE-RANGES-FROM-SET
+
+Version 1.4.0
+2008-07-03
+Replaced hash tables with charsets (by Nikodemus Siivola)
+Get rid of duplicates in REGEX-APROPOS(-LIST)
+
+Version 1.3.3
+2008-06-25
+Let the Lisp decide how it wants to enlarge its hash tables
+Fixed anchors for special variables in docs
+Fixed typo in docs (thanks to Jason S. Cornez)
+
+Version 1.3.2
+2007-09-13
+Updated docs and ChangeLog to be really in sync with 1.3.1 changes (thanks to S�bastien Saint-Sevin)
+
+Version 1.3.1
+2007-08-24
+Second return value for REGEX-REPLACE and REGEX-REPLACE-ALL (patch by Matthew Sachs)
+
+Version 1.3.0
+2007-03-24
+Optional support for named registers (patch by Ondrej Svitek)
+
+Version 1.2.19
+2007-01-16
+Fixed behaviour of look-behind in repeated scans (caught by RegexCoach user Hans Jud)
+
+Version 1.2.18
+2006-10-12
+Changed default element type for LispWorks
+Fixed documentation for REGEX-REPLACE-ALL
+
+Version 1.2.17
+2006-10-11
+Fixed bug in DO-SCANS which affected anchors (caught by RegexCoach user Laurent Taupiac)
+Update link for 'man perlre' (thanks to Ricardo Boccato Alves)
+
+Version 1.2.16
+2006-07-16
+Added :ELEMENT-TYPE to REGEX-REPLACE(-ALL)
+
+Version 1.2.15
+2006-07-03
+Added :REGEX tag to parse tree syntax (thanks to Fr�d�ric Jolliton)
+
+Version 1.2.14
+2006-05-24
+Added missing </code> tag in docs (thanks to Wojciech Kaczmarek)
+Fixed IMPORT statement for LW
+
+Version 1.2.13
+2005-12-06
+Fixed bug involving *REAL-START-POS* (caught by "tichy")
+
+Version 1.2.12
+2005-11-01
+REGEX-APROPOS-AUX now also uses :INHERITED
+Fixed typo in parser.lisp (thanks to Derek Peschel)
+Fixed value of *REGEX-CHAR-CODE-LIMIT* in docs and test (thanks to Christophe Rhodes)
+
+Version 1.2.11
+2005-08-01
+Added external format for SBCL in ppcre-tests.lisp (thanks to Christophe Rhodes)
+
+Version 1.2.10
+2005-07-20
+Fixed bug in CHAR-SEARCHER-AUX (caught by Peter Schuller)
+Don't redefine what's already there (for LispWorks)
+
+Version 1.2.9
+2005-06-27
+Hide compiler macros from CCL (thanks to Karsten Poeck)
+
+Version 1.2.8
+2005-06-10
+Change EQ to EQL in REGEX-LENGTH for ANSI conformance and ABCL compatibility (thanks to Peter Graves)
+
+Version 1.2.7
+2005-05-16
+Added lispworks-defsystem.lisp (thanks to Wade Humeniuk)
+Fixed bug in WORD-BOUNDARY-P
+
+Version 1.2.6
+2005-04-13
+Added some DEFGENERICs to appease SBCL (thanks to Alan Shields)
+Removed wrong FTYPE declaration for STR (thanks to Alan Shields)
+
+Version 1.2.5
+2005-03-09
+Customizable optimize qualities (thanks to Damien Kick)
+
+Version 1.2.4
+2005-03-07
+Changed DEBUG optimize quality from 0 to 1
+
+Version 1.2.3
+2005-02-02
+Wrapped WITH-COMPILATION-UNIT around loop in load.lisp
+
+Version 1.2.2
+2005-02-02
+Fixed bug in hash table optimization (introduced in 1.1.0)
+
+Version 1.2.1
+2005-01-25
+There was a wrong read-time conditional in api.lisp, sorry
+
+Version 1.2.0
+2005-01-24
+AllegroCL compatibility mode
+Fixed broken load.lisp file (caught by Jim Prewett and Zach Beane)
+
+Version 1.1.0
+2005-01-23
+Cleaned up load.lisp and cl-ppcre.asd
+Make large hash tables smaller, if possible
+Correct treatment of constant regular expressions in DO-SCANS
+
+Version 1.0.0
+2004-12-22
+Special anniversary release... :)
+
+Version 0.9.4
+2004-12-18
+Fixed bug in NORMALIZE-VAR-LIST (caught by Dave Roberts)
+
+Version 0.9.3
+2004-12-09
+Fixed bug in CREATE-SCANNER-AUX (caught by Allan Ruttenberg and Gary Byers)
+
+Version 0.9.2
+2004-12-06
+More compiler macros (thanks to Allan Ruttenberg)
+
+Version 0.9.1
+2004-11-29
+Shortcuts for REGISTER-GROUPS-BIND and DO-REGISTER-GROUPS (suggested by Alexander Kjeldaas)
+
+Version 0.9.0
+2004-10-14
+Experimental support for "filters"
+Bugfix for standalone regular expressions (ACCUMULATE-START-P wasn't set to NIL)
+
+Version 0.8.1
+2004-09-30
+Patches for Genera 8.5 (thanks to Patrick O'Donnell)
+
+Version 0.8.0
+2004-09-16
+Added parse tree synonyms (thanks to Patrick O'Donnell)
+
+Version 0.7.9
+2004-07-13
+Fixed bug in DO-SCANS (caught by Jan Rychter)
+
+Version 0.7.8
+2004-07-13
+New SIMPLE-CALLS keyword argument for REGEX-REPLACE(-ALL)
+Added environment parameter to compiler macros (thanks to c.l.l article <aczhx5hj.fsf@ccs.neu.edu> by Joe Marshall)
+Added compiler macros for SCAN-TO-STRINGS and REGEX-REPLACE(-ALL) (they somehow got lost)
+
+Version 0.7.7
+2004-05-19
+Fixed bug in NEWLINE-SKIPPER (caught by RegexCoach user Thomas-Paz Hartman)
+Added doc strings for PPCRE-SYNTAX-ERROR and friends (after playing with slime-apropos-package)
+Added hyperdoc support
+
+Version 0.7.6
+2004-04-20
+The closures created by CREATE-BMH-MATCHER now cleanly cope with negative arguments (bug caught by Damien Kick)
+
+Version 0.7.5
+2004-04-19
+Fixed a bug with constant-length repetitions of . (dot) in single-line mode (caught by RegexCoach user Lee Gold)
+
+Version 0.7.4
+2004-02-16
+Fixed wrong call to SIGNAL-PPCRE-SIGNAL-ERROR in lexer.lisp (caught by Peter Graves)
+Added :CL-PPCRE to *FEATURES* (for CL-INTERPOL)
+Compiler macro for SPLIT
+
+Version 0.7.3
+2004-01-28
+Fixed bug in CURRENT-MIN-REST for lookaheads (reported by RegexCoach user Thomas-Paz Hartman)
+Added tests for this bug
+
+Version 0.7.2
+2004-01-27
+Fixed typo (SUBSEQ/NSUBSEQ) in SPLIT (thanks to Alan Ruttenberg)
+Updated docs with respect to ECL (thanks to Alex Mizrahi)
+Mention FreeBSD port in docs
+
+Version 0.7.1
+2003-10-24
+Fixed version numbers in docs (thanks to S�bastien Saint-Sevin)
+
+Version 0.7.0
+2003-10-23
+New macros REGISTER-GROUPS-BIND and DO-REGISTER-GROUPS
+Added SHAREP keyword argument to most API functions and macros
+Mention CL-INTERPOL in docs
+Partial code cleanup (using WITH-UNIQUE-NAMES and REBINDING)
+
+Version 0.6.1
+2003-10-11
+Added EXTERNAL-FORMAT keyword args to CL-PPCRE-TEST:TEST for some CLs (thanks to JP Massar and Scott D. Kalter)
+Fixed bug with REGEX-REPLACE and REGEX-REPLACE-ALL when (= START END) was true
+Added doc sections for quoting problems and backslash confusions (thanks to conversations with Peter Seibel)
+Disable quoting in definition of QUOTE-SECTIONS so you can always safely rebuild CL-PPCRE
+
+Version 0.6.0
+2003-10-07
+CL-PPCRE now has its own condition types
+Added support for Perl's \Q and \E (Peter Seibel convinced me to do it) - see QUOTE-META-CHARS and *ALLOW-QUOTING*
+Added tests for this new feature
+Threaded tests are more verbose now and use only keyword args
+
+Version 0.5.9
+2003-10-03
+Changed "^" optimizations with respect to constant end strings with offsets (bug caught by Yexuan Gui)
+Added tests for this bug
+Removed *.dos files from CL-PPCRE-TEST tests (thanks to JP Massar)
+Added threaded tests for SBCL (thanks to Christophe Rhodes)
+
+Version 0.5.8
+2003-09-17
+Optimizations for ".*" were too optimistic when look-behinds were involved
+Added tests for this bug
+Removed *.dos files
+
+Version 0.5.7
+2003-08-20
+Fixed (CL-PPCRE:SCAN "(.)X$" "ABCX" :START 4) bug (spotted by Tibor Simko)
+Forgot to export *REGEX-CHAR-CODE-LIMIT* in Corman version of DEFPACKAGE
+Removed Emacs local variables from source code (finally...)
+Mention Gentoo in docs
+
+Version 0.5.6
+2003-06-30
+Replaced wrong COPY-REGEX code for WORD-BOUNDARY objects (detected by Max Goldberg)
+Added info about possible TRUENAME problems with ACL in README (thanks to Kevin Layer for providing a patch for this)
+
+Version 0.5.5
+2003-06-09
+Patch for SBCL/Debian compatibility by Kevin Rosenberg
+Simpler version of compiler macro
+Availability through asdf-install
+
+Version 0.5.4
+2003-04-09
+Added DESTRUCTIVE keyword to CREATE-SCANNER
+
+Version 0.5.3
+2003-03-31
+Fixed bug in REGEX-REPLACE (replacement string couldn't contain literal backslash)
+Fixed bug in definition of CHAR-CLASS (since 0.5.0 the hash slot may be NIL - CMUCL's new PCL detects this)
+Micro-optimization in INSERT-CHAR-CLASS-TESTER: CHAR-NOT-GREATERP instead of CHAR-DOWNCASE
+
+Version 0.5.2
+2003-03-28
+Better compiler macro (thanks to Kent M. Pitman)
+
+Version 0.5.1
+2003-03-27
+Removed compiler macro
+
+Version 0.5.0
+2003-03-27
+Lexer, parser, and converter mostly re-written to reduce consing and increase speed
+Get rid of FIX-POS in lexer and parser, "ism" flags are handled after parsing now
+Smaller test suite (again) due to literal embedding of line breaks
+Seperate test files for DOS line endings
+Replaced constant +REGEX-CHAR-CODE-LIMIT+ with special variable *REGEX-CHAR-CODE-LIMIT*
+
+Version 0.4.1
+2003-03-19
+Added compiler macro for SCAN
+Changed test suite to be nicer to Corman Lisp and ECL (see docs for new syntax)
+Incorporated visual feedback (dots) in test suite (thanks to JP Massar)
+Added README file
+Replaced STRING-LIST-TO-SIMPLE-STRING with a much improved version by JP Massar
+
+Version 0.4.0
+2003-02-27
+Added *USE-BMH-MATCHER*
+
+Version 0.3.2
+2003-02-21
+Added load.lisp
+Various minor changes for Corman Lisp compatibility (thanks to Karsten Poeck and JP Massar)
+
+Version 0.3.1
+2003-01-18
+Bugfix in CREATE-SCANNER (didn't work if flags were given and arg was a parse-tree)
+
+Version 0.3.0
+2003-01-12
+Added new features to REGEX-REPLACE and REGEX-REPLACE-ALL
+
+Version 0.2.0
+2003-01-11
+Make SPLIT more Perl-compatible, including new keyword parameters
+
+Version 0.1.4
+2003-01-10
+Don't move "^" and "\A" while iterating with DO-SCANS
+Added link to Debian package
+
+Version 0.1.3
+2002-12-25
+More usable MK:DEFSYSTEM files (courtesy of Hannu Koivisto)
+Fixed typo in documentation
+
+Version 0.1.2
+2002-12-22
+Added version numbers for Debian packaging
+Be friendly to case-sensitive ACL images (courtesy of Kevin Rosenberg and Douglas Crosher)
+"Fixed" two cases where declarations came after docstrings (because of bugs in Corman Lisp and older CMUCL versions)
+Added #-cormanlisp to hide (INCF (THE FIXNUM POS)) from Corman Lisp
+Added file doc/benchmarks.2002-12-22.txt
+
+Version 0.1.1
+2002-12-21
+Added asdf system definitions by Marco Baringer
+Small additions to documentation
+Correct (Emacs) local variables list in closures.lisp and api.lisp
+Added this CHANGELOG
+
+Version 0.1.0
+2002-12-20
+Initial release
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/README.md b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/README.md
new file mode 100644
index 0000000..f20b767
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/README.md
@@ -0,0 +1,30 @@
+# CL-PPCRE - Portable Perl-compatible regular expressions for Common Lisp
+
+## Abstract
+
+CL-PPCRE is a portable regular expression library for Common Lisp
+which has the following features:
+
+* It is **compatible with Perl** (especially when used in conjunction
+  with [cl-interpol](http://weitz.de/cl-interpol/), to allow
+  compatible parsing of regexp strings).
+* It is pretty **fast**.
+* It is **portable** between ANSI-compliant Common Lisp
+  implementations.
+* It is **thread-safe**.
+* In addition to specifying regular expressions as strings like in
+  Perl you can also use **S-expressions**.
+* It comes with a
+  **[BSD-style license](http://www.opensource.org/licenses/bsd-license.php)**
+  so you can basically do with it whatever you want.
+
+CL-PPCRE has been used successfully in various applications like
+[BioBike](http://nostoc.stanford.edu/Docs/),
+[clutu](http://clutu.com/),
+[LoGS](http://www.hpc.unm.edu/~download/LoGS/),
+[CafeSpot](http://cafespot.net/),
+[Eboy](http://www.eboy.com/), or
+[The Regex Coach](http://weitz.de/regex-coach/).
+
+Further documentation can be found in `docs/index.html`, or on
+[the cl-ppcre homepage](https://edicl.github.io/cl-ppcre/).
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/api.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/api.lisp
new file mode 100644
index 0000000..f440361
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/api.lisp
@@ -0,0 +1,1278 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/api.lisp,v 1.85 2009/09/17 19:17:30 edi Exp $
+
+;;; The external API for creating and using scanners.
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defvar *look-ahead-for-suffix* t
+  "Controls whether scanners will optimistically look ahead for a
+  constant suffix of a regular expression, if there is one.")
+
+(defgeneric create-scanner (regex &key case-insensitive-mode
+                                       multi-line-mode
+                                       single-line-mode
+                                       extended-mode
+                                       destructive)
+  (:documentation "Accepts a regular expression - either as a
+parse-tree or as a string - and returns a scan closure which will scan
+strings for this regular expression and a list mapping registers to
+their names \(NIL stands for unnamed ones).  The \"mode\" keyword
+arguments are equivalent to the imsx modifiers in Perl.  If
+DESTRUCTIVE is not NIL, the function is allowed to destructively
+modify its first argument \(but only if it's a parse tree)."))
+
+#-:use-acl-regexp2-engine
+(defmethod create-scanner ((regex-string string) &key case-insensitive-mode
+                                                      multi-line-mode
+                                                      single-line-mode
+                                                      extended-mode
+                                                      destructive)
+  (declare #.*standard-optimize-settings*)
+  (declare (ignore destructive))
+  ;; parse the string into a parse-tree and then call CREATE-SCANNER
+  ;; again
+  (let* ((*extended-mode-p* extended-mode)
+         (quoted-regex-string (if *allow-quoting*
+                                (quote-sections (clean-comments regex-string extended-mode))
+                                regex-string))
+         (*syntax-error-string* (copy-seq quoted-regex-string)))
+    ;; wrap the result with :GROUP to avoid infinite loops for
+    ;; constant strings
+    (create-scanner (cons :group (list (parse-string quoted-regex-string)))
+                    :case-insensitive-mode case-insensitive-mode
+                    :multi-line-mode multi-line-mode
+                    :single-line-mode single-line-mode
+                    :destructive t)))
+
+#-:use-acl-regexp2-engine
+(defmethod create-scanner ((scanner function) &key case-insensitive-mode
+                                                   multi-line-mode
+                                                   single-line-mode
+                                                   extended-mode
+                                                   destructive)
+  (declare #.*standard-optimize-settings*)
+  (declare (ignore destructive))
+  (when (or case-insensitive-mode multi-line-mode single-line-mode extended-mode)
+    (signal-invocation-error "You can't use the keyword arguments to modify an existing scanner."))
+  scanner)
+
+#-:use-acl-regexp2-engine
+(defmethod create-scanner ((parse-tree t) &key case-insensitive-mode
+                                               multi-line-mode
+                                               single-line-mode
+                                               extended-mode
+                                               destructive)
+  (declare #.*standard-optimize-settings*)
+  (when extended-mode
+    (signal-invocation-error "Extended mode doesn't make sense in parse trees."))
+  ;; convert parse-tree into internal representation REGEX and at the
+  ;; same time compute the number of registers and the constant string
+  ;; (or anchor) the regex starts with (if any)
+  (unless destructive
+    (setq parse-tree (copy-tree parse-tree)))
+  (let (flags)
+    (if single-line-mode
+      (push :single-line-mode-p flags))
+    (if multi-line-mode
+      (push :multi-line-mode-p flags))
+    (if case-insensitive-mode
+      (push :case-insensitive-p flags))
+    (when flags
+      (setq parse-tree (list :group (cons :flags flags) parse-tree))))
+  (let ((*syntax-error-string* nil))
+    (multiple-value-bind (regex reg-num starts-with reg-names)
+        (convert parse-tree)
+      ;; simplify REGEX by flattening nested SEQ and ALTERNATION
+      ;; constructs and gathering STR objects
+      (let ((regex (gather-strings (flatten regex))))
+        ;; set the MIN-REST slots of the REPETITION objects
+        (compute-min-rest regex 0)
+        ;; set the OFFSET slots of the STR objects
+        (compute-offsets regex 0)
+        (let* (end-string-offset
+               end-anchored-p
+               ;; compute the constant string the regex ends with (if
+               ;; any) and at the same time set the special variables
+               ;; END-STRING-OFFSET and END-ANCHORED-P
+               (end-string (end-string regex))
+               ;; if we found a non-zero-length end-string we create an
+               ;; efficient search function for it
+               (end-string-test (and *look-ahead-for-suffix*
+                                     end-string
+                                     (plusp (len end-string))
+                                     (if (= 1 (len end-string))
+                                       (create-char-searcher
+                                        (schar (str end-string) 0)
+                                        (case-insensitive-p end-string))
+                                       (create-bmh-matcher
+                                        (str end-string)
+                                        (case-insensitive-p end-string)))))
+               ;; initialize the counters for CREATE-MATCHER-AUX
+               (*rep-num* 0)
+               (*zero-length-num* 0)
+               ;; create the actual matcher function (which does all the
+               ;; work of matching the regular expression) corresponding
+               ;; to REGEX and at the same time set the special
+               ;; variables *REP-NUM* and *ZERO-LENGTH-NUM*
+               (match-fn (create-matcher-aux regex #'identity))
+               ;; if the regex starts with a string we create an
+               ;; efficient search function for it
+               (start-string-test (and (typep starts-with 'str)
+                                       (plusp (len starts-with))
+                                       (if (= 1 (len starts-with))
+                                         (create-char-searcher
+                                          (schar (str starts-with) 0)
+                                          (case-insensitive-p starts-with))
+                                         (create-bmh-matcher
+                                          (str starts-with)
+                                          (case-insensitive-p starts-with))))))
+          (declare (special end-string-offset end-anchored-p end-string))
+          ;; now create the scanner and return it
+          (values (create-scanner-aux match-fn
+                                      (regex-min-length regex)
+                                      (or (start-anchored-p regex)
+                                          ;; a dot in single-line-mode also
+                                          ;; implicitly anchors the regex at
+                                          ;; the start, i.e. if we can't match
+                                          ;; from the first position we won't
+                                          ;; match at all
+                                          (and (typep starts-with 'everything)
+                                               (single-line-p starts-with)))
+                                      starts-with
+                                      start-string-test
+                                      ;; only mark regex as end-anchored if we
+                                      ;; found a non-zero-length string before
+                                      ;; the anchor
+                                      (and end-string-test end-anchored-p)
+                                      end-string-test
+                                      (if end-string-test
+                                          (len end-string)
+                                          nil)
+                                      end-string-offset
+                                      *rep-num*
+                                      *zero-length-num*
+                                      reg-num)
+                  reg-names))))))
+
+#+:use-acl-regexp2-engine
+(declaim (inline create-scanner))
+#+:use-acl-regexp2-engine
+(defmethod create-scanner ((scanner regexp::regular-expression) &key case-insensitive-mode
+                                                                     multi-line-mode
+                                                                     single-line-mode
+                                                                     extended-mode
+                                                                     destructive)
+  (declare #.*standard-optimize-settings*)
+  (declare (ignore destructive))
+  (when (or case-insensitive-mode multi-line-mode single-line-mode extended-mode)
+    (signal-invocation-error "You can't use the keyword arguments to modify an existing scanner."))
+  scanner)
+
+#+:use-acl-regexp2-engine
+(defmethod create-scanner ((parse-tree t) &key case-insensitive-mode
+                                               multi-line-mode
+                                               single-line-mode
+                                               extended-mode
+                                               destructive)
+  (declare #.*standard-optimize-settings*)
+  (declare (ignore destructive))
+  (excl:compile-re parse-tree
+                   :case-fold case-insensitive-mode
+                   :ignore-whitespace extended-mode
+                   :multiple-lines multi-line-mode
+                   :single-line single-line-mode
+                   :return :index))
+
+(defgeneric scan (regex target-string &key start end real-start-pos)
+  (:documentation "Searches TARGET-STRING from START to END and tries
+to match REGEX.  On success returns four values - the start of the
+match, the end of the match, and two arrays denoting the beginnings
+and ends of register matches.  On failure returns NIL.  REGEX can be a
+string which will be parsed according to Perl syntax, a parse tree, or
+a pre-compiled scanner created by CREATE-SCANNER.  TARGET-STRING will
+be coerced to a simple string if it isn't one already.  The
+REAL-START-POS parameter should be ignored - it exists only for
+internal purposes."))
+
+#-:use-acl-regexp2-engine
+(defmethod scan ((regex-string string) target-string
+                                       &key (start 0)
+                                            (end (length target-string))
+                                            ((:real-start-pos *real-start-pos*) nil))
+  (declare #.*standard-optimize-settings*)
+  ;; note that the scanners are optimized for simple strings so we
+  ;; have to coerce TARGET-STRING into one if it isn't already
+  (funcall (create-scanner regex-string)
+           (maybe-coerce-to-simple-string target-string)
+           start end))
+
+#-:use-acl-regexp2-engine
+(defmethod scan ((scanner function) target-string
+                                    &key (start 0)
+                                         (end (length target-string))
+                                         ((:real-start-pos *real-start-pos*) nil))
+  (declare #.*standard-optimize-settings*)
+  (funcall scanner
+           (maybe-coerce-to-simple-string target-string)
+           start end))
+
+#-:use-acl-regexp2-engine
+(defmethod scan ((parse-tree t) target-string
+                                &key (start 0)
+                                     (end (length target-string))
+                                     ((:real-start-pos *real-start-pos*) nil))
+  (declare #.*standard-optimize-settings*)
+  (funcall (create-scanner parse-tree)
+           (maybe-coerce-to-simple-string target-string)
+           start end))
+
+#+:use-acl-regexp2-engine
+(declaim (inline scan))
+#+:use-acl-regexp2-engine
+(defmethod scan ((parse-tree t) target-string
+                                &key (start 0)
+                                     (end (length target-string))
+                                     ((:real-start-pos *real-start-pos*) nil))
+  (declare #.*standard-optimize-settings*)
+  (when (< end start)
+    (return-from scan nil))
+  (let ((results (multiple-value-list (excl:match-re parse-tree target-string
+                                                     :start start
+                                                     :end end
+                                                     :return :index))))
+    (declare (dynamic-extent results))
+    (cond ((null (first results)) nil)
+          (t (let* ((no-of-regs (- (length results) 2))
+                    (reg-starts (make-array no-of-regs
+                                            :element-type '(or null fixnum)))
+                    (reg-ends (make-array no-of-regs
+                                          :element-type '(or null fixnum)))
+                    (match (second results)))
+               (loop for (start . end) in (cddr results)
+                     for i from 0
+                     do (setf (aref reg-starts i) start
+                              (aref reg-ends i) end))
+               (values (car match) (cdr match) reg-starts reg-ends))))))
+
+#-:cormanlisp
+(define-compiler-macro scan (&whole form regex target-string &rest rest)
+  "Make sure that constant forms are compiled into scanners at compile time."
+  ;; Don't pass &environment to CONSTANTP, it may not be digestable by
+  ;; LOAD-TIME-VALUE, e.g., MACROLETs.
+  (cond ((constantp regex)
+         `(scan (load-time-value (create-scanner ,regex))
+                ,target-string ,@rest))
+        (t form)))
+
+(defun scan-to-strings (regex target-string &key (start 0)
+                                                 (end (length target-string))
+                                                 sharedp)
+  "Like SCAN but returns substrings of TARGET-STRING instead of
+positions, i.e. this function returns two values on success: the whole
+match as a string plus an array of substrings (or NILs) corresponding
+to the matched registers.  If SHAREDP is true, the substrings may
+share structure with TARGET-STRING."
+  (declare #.*standard-optimize-settings*)
+  (multiple-value-bind (match-start match-end reg-starts reg-ends)
+      (scan regex target-string :start start :end end)
+    (unless match-start
+      (return-from scan-to-strings nil))
+    (let ((substr-fn (if sharedp #'nsubseq #'subseq)))
+      (values (funcall substr-fn
+                       target-string match-start match-end)
+              (map 'vector
+                   (lambda (reg-start reg-end)
+                     (if reg-start
+                       (funcall substr-fn
+                                target-string reg-start reg-end)
+                       nil))
+                   reg-starts
+                   reg-ends)))))
+
+#-:cormanlisp
+(define-compiler-macro scan-to-strings
+    (&whole form regex target-string &rest rest)
+  "Make sure that constant forms are compiled into scanners at compile time."
+  (cond ((constantp regex)
+         `(scan-to-strings (load-time-value (create-scanner ,regex))
+                           ,target-string ,@rest))
+        (t form)))
+
+(defmacro register-groups-bind (var-list (regex target-string
+                                                &key start end sharedp)
+                                &body body)
+  "Executes BODY with the variables in VAR-LIST bound to the
+corresponding register groups after TARGET-STRING has been matched
+against REGEX, i.e. each variable is either bound to a string or to
+NIL.  If there is no match, BODY is _not_ executed. For each element
+of VAR-LIST which is NIL there's no binding to the corresponding
+register group.  The number of variables in VAR-LIST must not be
+greater than the number of register groups.  If SHAREDP is true, the
+substrings may share structure with TARGET-STRING."
+  (with-rebinding (target-string)
+    (with-unique-names (match-start match-end reg-starts reg-ends
+                                    start-index substr-fn)
+      (let ((var-bindings
+              (loop for (function var) in (normalize-var-list var-list)
+                    for counter from 0
+                    when var
+                      collect `(,var (let ((,start-index
+                                             (aref ,reg-starts ,counter)))
+                                       (if ,start-index
+                                           (funcall ,function
+                                                    (funcall ,substr-fn
+                                                             ,target-string
+                                                             ,start-index
+                                                             (aref ,reg-ends ,counter)))
+                                           nil))))))
+        `(multiple-value-bind (,match-start ,match-end ,reg-starts ,reg-ends)
+             (scan ,regex ,target-string :start (or ,start 0)
+                                         :end (or ,end (length ,target-string)))
+           (declare (ignore ,match-end))
+           ,@(unless var-bindings
+               `((declare (ignore ,reg-starts ,reg-ends))))
+           (when ,match-start
+             ,@(if var-bindings
+                   `((let* ,(list*
+                             `(,substr-fn (if ,sharedp #'nsubseq #'subseq))
+                             var-bindings)
+                       ,@body))
+                   body)))))))
+
+(defmacro do-scans ((match-start match-end reg-starts reg-ends regex
+                                 target-string
+                                 &optional result-form
+                                 &key start end)
+                    &body body
+                    &environment env)
+  "Iterates over TARGET-STRING and tries to match REGEX as often as
+possible evaluating BODY with MATCH-START, MATCH-END, REG-STARTS, and
+REG-ENDS bound to the four return values of each match in turn.  After
+the last match, returns RESULT-FORM if provided or NIL otherwise. An
+implicit block named NIL surrounds DO-SCANS; RETURN may be used to
+terminate the loop immediately.  If REGEX matches an empty string the
+scan is continued one position behind this match. BODY may start with
+declarations."
+  (with-rebinding (target-string)
+    (with-unique-names (%start %end %regex scanner)
+      (declare (ignorable %regex scanner))
+      ;; the NIL BLOCK to enable exits via (RETURN ...)
+      `(block nil
+         (let* ((,%start (or ,start 0))
+                (,%end (or ,end (length ,target-string)))
+                ,@(unless (constantp regex env)
+                    ;; leave constant regular expressions as they are -
+                    ;; SCAN's compiler macro will take care of them;
+                    ;; otherwise create a scanner unless the regex is
+                    ;; already a function (otherwise SCAN will do this
+                    ;; on each iteration)
+                    `((,%regex ,regex)
+                      (,scanner (typecase ,%regex
+                                  (function ,%regex)
+                                  (t (create-scanner ,%regex)))))))
+           ;; coerce TARGET-STRING to a simple string unless it is one
+           ;; already (otherwise SCAN will do this on each iteration)
+           (setq ,target-string
+                 (maybe-coerce-to-simple-string ,target-string))
+           (loop
+            ;; invoke SCAN and bind the returned values to the
+            ;; provided variables
+            (multiple-value-bind
+                (,match-start ,match-end ,reg-starts ,reg-ends)
+                (scan ,(cond ((constantp regex env) regex)
+                             (t scanner))
+                      ,target-string :start ,%start :end ,%end
+                      :real-start-pos (or ,start 0))
+              ;; declare the variables to be IGNORABLE to prevent the
+              ;; compiler from issuing warnings
+              (declare
+               (ignorable ,match-start ,match-end ,reg-starts ,reg-ends))
+              (unless ,match-start
+                ;; stop iteration on first failure
+                (return ,result-form))
+              ;; execute BODY (wrapped in LOCALLY so it can start with
+              ;; declarations)
+              (locally
+                ,@body)
+              ;; advance by one position if we had a zero-length match
+              (setq ,%start (if (= ,match-start ,match-end)
+                              (1+ ,match-end)
+                              ,match-end)))))))))
+
+(defmacro do-matches ((match-start match-end regex
+                                   target-string
+                                   &optional result-form
+                                   &key start end)
+                      &body body)
+  "Iterates over TARGET-STRING and tries to match REGEX as often as
+possible evaluating BODY with MATCH-START and MATCH-END bound to the
+start/end positions of each match in turn.  After the last match,
+returns RESULT-FORM if provided or NIL otherwise.  An implicit block
+named NIL surrounds DO-MATCHES; RETURN may be used to terminate the
+loop immediately.  If REGEX matches an empty string the scan is
+continued one position behind this match.  BODY may start with
+declarations."
+  ;; this is a simplified form of DO-SCANS - we just provide two dummy
+  ;; vars and ignore them
+  (with-unique-names (reg-starts reg-ends)
+    `(do-scans (,match-start ,match-end
+                ,reg-starts ,reg-ends
+                ,regex ,target-string
+                ,result-form
+                :start ,start :end ,end)
+      ,@body)))
+
+(defmacro do-matches-as-strings ((match-var regex
+                                            target-string
+                                            &optional result-form
+                                            &key start end sharedp)
+                                 &body body)
+  "Iterates over TARGET-STRING and tries to match REGEX as often as
+possible evaluating BODY with MATCH-VAR bound to the substring of
+TARGET-STRING corresponding to each match in turn.  After the last
+match, returns RESULT-FORM if provided or NIL otherwise.  An implicit
+block named NIL surrounds DO-MATCHES-AS-STRINGS; RETURN may be used to
+terminate the loop immediately.  If REGEX matches an empty string the
+scan is continued one position behind this match.  If SHAREDP is true,
+the substrings may share structure with TARGET-STRING.  BODY may start
+with declarations."
+  (with-rebinding (target-string)
+    (with-unique-names (match-start match-end substr-fn)
+      `(let ((,substr-fn (if ,sharedp #'nsubseq #'subseq)))
+        ;; simple use DO-MATCHES to extract the substrings
+        (do-matches (,match-start ,match-end ,regex ,target-string
+                     ,result-form :start ,start :end ,end)
+          (let ((,match-var
+                  (funcall ,substr-fn
+                           ,target-string ,match-start ,match-end)))
+            ,@body))))))
+
+(defmacro do-register-groups (var-list (regex target-string
+                                              &optional result-form
+                                              &key start end sharedp)
+                                       &body body)
+  "Iterates over TARGET-STRING and tries to match REGEX as often as
+possible evaluating BODY with the variables in VAR-LIST bound to the
+corresponding register groups for each match in turn, i.e. each
+variable is either bound to a string or to NIL.  For each element of
+VAR-LIST which is NIL there's no binding to the corresponding register
+group. The number of variables in VAR-LIST must not be greater than
+the number of register groups.  After the last match, returns
+RESULT-FORM if provided or NIL otherwise.  An implicit block named NIL
+surrounds DO-REGISTER-GROUPS; RETURN may be used to terminate the loop
+immediately. If REGEX matches an empty string the scan is continued
+one position behind this match.  If SHAREDP is true, the substrings
+may share structure with TARGET-STRING.  BODY may start with
+declarations."
+  (with-rebinding (target-string)
+    (with-unique-names (substr-fn match-start match-end
+                                  reg-starts reg-ends start-index)
+      `(let ((,substr-fn (if ,sharedp
+                          #'nsubseq
+                          #'subseq)))
+        (do-scans (,match-start ,match-end ,reg-starts ,reg-ends
+                                ,regex ,target-string
+                                ,result-form :start ,start :end ,end)
+          (let ,(loop for (function var) in (normalize-var-list var-list)
+                      for counter from 0
+                      when var
+                        collect `(,var (let ((,start-index
+                                               (aref ,reg-starts ,counter)))
+                                         (if ,start-index
+                                           (funcall ,function
+                                                    (funcall ,substr-fn
+                                                             ,target-string
+                                                             ,start-index
+                                                             (aref ,reg-ends ,counter)))
+                                           nil))))
+            ,@body))))))
+
+(defun all-matches (regex target-string
+                          &key (start 0)
+                               (end (length target-string)))
+  "Returns a list containing the start and end positions of all
+matches of REGEX against TARGET-STRING, i.e. if there are N matches
+the list contains (* 2 N) elements.  If REGEX matches an empty string
+the scan is continued one position behind this match."
+  (declare #.*standard-optimize-settings*)
+  (let (result-list)
+    (do-matches (match-start match-end
+                 regex target-string
+                 (nreverse result-list)
+                 :start start :end end)
+      (push match-start result-list)
+      (push match-end result-list))))
+
+#-:cormanlisp
+(define-compiler-macro all-matches (&whole form regex &rest rest)
+   "Make sure that constant forms are compiled into scanners at
+compile time."
+   (cond ((constantp regex)
+          `(all-matches (load-time-value (create-scanner ,regex))
+                        ,@rest))
+         (t form)))
+
+(defun all-matches-as-strings (regex target-string
+                                     &key (start 0)
+                                          (end (length target-string))
+                                          sharedp)
+  "Returns a list containing all substrings of TARGET-STRING which
+match REGEX. If REGEX matches an empty string the scan is continued
+one position behind this match. If SHAREDP is true, the substrings may
+share structure with TARGET-STRING."
+  (declare #.*standard-optimize-settings*)
+  (let (result-list)
+    (do-matches-as-strings (match regex target-string (nreverse result-list)
+                                  :start start :end end :sharedp sharedp)
+      (push match result-list))))
+
+#-:cormanlisp
+(define-compiler-macro all-matches-as-strings (&whole form regex &rest rest)
+   "Make sure that constant forms are compiled into scanners at
+compile time."
+   (cond ((constantp regex)
+          `(all-matches-as-strings
+            (load-time-value (create-scanner ,regex))
+            ,@rest))
+         (t form)))
+
+(defun split (regex target-string
+                    &key (start 0)
+                         (end (length target-string))
+                         limit
+                         with-registers-p
+                         omit-unmatched-p
+                         sharedp)
+  "Matches REGEX against TARGET-STRING as often as possible and
+returns a list of the substrings between the matches.  If
+WITH-REGISTERS-P is true, substrings corresponding to matched
+registers are inserted into the list as well.  If OMIT-UNMATCHED-P is
+true, unmatched registers will simply be left out, otherwise they will
+show up as NIL.  LIMIT limits the number of elements returned -
+registers aren't counted.  If LIMIT is NIL \(or 0 which is
+equivalent), trailing empty strings are removed from the result list.
+If REGEX matches an empty string the scan is continued one position
+behind this match.  If SHAREDP is true, the substrings may share
+structure with TARGET-STRING."
+  (declare #.*standard-optimize-settings*)
+  ;; initialize list of positions POS-LIST to extract substrings with
+  ;; START so that the start of the next match will mark the end of
+  ;; the first substring
+  (let ((pos-list (list start))
+        (counter 0))
+    ;; how would Larry Wall do it?
+    (when (eql limit 0)
+      (setq limit nil))
+    (do-scans (match-start match-end
+               reg-starts reg-ends
+               regex target-string nil
+               :start start :end end)
+      (unless (and (= match-start match-end)
+                   (= match-start (car pos-list)))
+        ;; push start of match on list unless this would be an empty
+        ;; string adjacent to the last element pushed onto the list
+        (when (and limit
+                   ;; perlfunc(1) says
+                   ;;   If LIMIT is negative, it is treated as if
+                   ;;   it were instead arbitrarily large;
+                   ;;   as many fields as possible are produced.
+                   (plusp limit)
+                   (>= (incf counter) limit))
+          (return))
+        (push match-start pos-list)
+        (when with-registers-p
+          ;; optionally insert matched registers
+          (loop for reg-start across reg-starts
+                for reg-end across reg-ends
+                if reg-start
+                  ;; but only if they've matched
+                  do (push reg-start pos-list)
+                     (push reg-end pos-list)
+                else unless omit-unmatched-p
+                  ;; or if we're allowed to insert NIL instead
+                  do (push nil pos-list)
+                     (push nil pos-list)))
+        ;; now end of match
+        (push match-end pos-list)))
+    ;; end of whole string
+    (push end pos-list)
+    ;; now collect substrings
+    (nreverse
+     (loop with substr-fn = (if sharedp #'nsubseq #'subseq)
+           with string-seen = nil
+           for (this-end this-start) on pos-list by #'cddr
+           ;; skip empty strings from end of list
+           if (or limit
+                  (setq string-seen
+                          (or string-seen
+                              (and this-start
+                                   (> this-end this-start)))))
+           collect (if this-start
+                     (funcall substr-fn
+                              target-string this-start this-end)
+                     nil)))))
+
+#-:cormanlisp
+(define-compiler-macro split (&whole form regex target-string &rest rest)
+  "Make sure that constant forms are compiled into scanners at compile time."
+  (cond ((constantp regex)
+         `(split (load-time-value (create-scanner ,regex))
+                 ,target-string ,@rest))
+        (t form)))
+
+(defun string-case-modifier (str from to start end)
+  (declare #.*standard-optimize-settings*)
+  (declare (fixnum from to start end))
+  "Checks whether all words in STR between FROM and TO are upcased,
+downcased or capitalized and returns a function which applies a
+corresponding case modification to strings.  Returns #'IDENTITY
+otherwise, especially if words in the target area extend beyond FROM
+or TO.  STR is supposed to be bounded by START and END.  It is assumed
+that \(<= START FROM TO END)."
+  (case
+      (if (or (<= to from)
+              (and (< start from)
+                   (alphanumericp (char str (1- from)))
+                   (alphanumericp (char str from)))
+              (and (< to end)
+                   (alphanumericp (char str to))
+                   (alphanumericp (char str (1- to)))))
+        ;; if it's a zero-length string or if words extend beyond FROM
+        ;; or TO we return NIL, i.e. #'IDENTITY
+        nil
+        ;; otherwise we loop through STR from FROM to TO
+        (loop with last-char-both-case
+              with current-result
+              for index of-type fixnum from from below to
+              for chr = (char str index)
+              do (cond ((not #-:cormanlisp (both-case-p chr)
+                             #+:cormanlisp (or (upper-case-p chr)
+                                               (lower-case-p chr)))
+                         ;; this character doesn't have a case so we
+                         ;; consider it as a word boundary (note that
+                         ;; this differs from how \b works in Perl)
+                         (setq last-char-both-case nil))
+                       ((upper-case-p chr)
+                         ;; an uppercase character
+                         (setq current-result
+                                 (if last-char-both-case
+                                   ;; not the first character in a 
+                                   (case current-result
+                                     ((:undecided) :upcase)
+                                     ((:downcase :capitalize) (return nil))
+                                     ((:upcase) current-result))
+                                   (case current-result
+                                     ((nil) :undecided)
+                                     ((:downcase) (return nil))
+                                     ((:capitalize :upcase) current-result)))
+                               last-char-both-case t))
+                       (t
+                         ;; a lowercase character
+                         (setq current-result
+                                 (case current-result
+                                   ((nil) :downcase)
+                                   ((:undecided) :capitalize)
+                                   ((:downcase) current-result)
+                                   ((:capitalize) (if last-char-both-case
+                                                    current-result
+                                                    (return nil)))
+                                   ((:upcase) (return nil)))
+                               last-char-both-case t)))
+              finally (return current-result)))
+    ((nil) #'identity)
+    ((:undecided :upcase) #'string-upcase)
+    ((:downcase) #'string-downcase)
+    ((:capitalize) #'string-capitalize)))
+
+;; first create a scanner to identify the special parts of the
+;; replacement string (eat your own dog food...)
+
+(defgeneric build-replacement-template (replacement-string)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Converts a replacement string for REGEX-REPLACE or
+REGEX-REPLACE-ALL into a replacement template which is an
+S-expression."))
+
+#-:cormanlisp
+(let* ((*use-bmh-matchers* nil)
+       (reg-scanner (create-scanner "\\\\(?:\\\\|\\{\\d+\\}|\\d+|&|`|')")))
+  (defmethod build-replacement-template ((replacement-string string))
+    (declare #.*standard-optimize-settings*)
+    (let ((from 0)
+          ;; COLLECTOR will hold the (reversed) template
+          (collector '()))
+      ;; scan through all special parts of the replacement string
+      (do-matches (match-start match-end reg-scanner replacement-string)
+        (when (< from match-start)
+          ;; strings between matches are copied verbatim
+          (push (subseq replacement-string from match-start) collector))
+        ;; PARSE-START is true if the pattern matched a number which
+        ;; refers to a register
+        (let* ((parse-start (position-if #'digit-char-p
+                                         replacement-string
+                                         :start match-start
+                                         :end match-end))
+               (token (if parse-start
+                        (1- (parse-integer replacement-string
+                                           :start parse-start
+                                           :junk-allowed t))
+                        ;; if we didn't match a number we convert the
+                        ;; character to a symbol
+                        (case (char replacement-string (1+ match-start))
+                          ((#\&) :match)
+                          ((#\`) :before-match)
+                          ((#\') :after-match)
+                          ((#\\) :backslash)))))
+          (when (and (numberp token) (< token 0))
+            ;; make sure we don't accept something like "\\0"
+            (signal-invocation-error "Illegal substring ~S in replacement string."
+                                     (subseq replacement-string match-start match-end)))
+          (push token collector))
+        ;; remember where the match ended
+        (setq from match-end))
+      (when (< from (length replacement-string))
+        ;; push the rest of the replacement string onto the list
+        (push (subseq replacement-string from) collector))
+      (nreverse collector))))
+
+#-:cormanlisp
+(defmethod build-replacement-template ((replacement-function function))
+  (declare #.*standard-optimize-settings*)
+  (list replacement-function))
+
+#-:cormanlisp
+(defmethod build-replacement-template ((replacement-function-symbol symbol))
+  (declare #.*standard-optimize-settings*)
+  (list replacement-function-symbol))
+        
+#-:cormanlisp
+(defmethod build-replacement-template ((replacement-list list))
+  (declare #.*standard-optimize-settings*)
+  replacement-list)
+
+;;; Corman Lisp's methods can't be closures... :(
+#+:cormanlisp
+(let* ((*use-bmh-matchers* nil)
+       (reg-scanner (create-scanner "\\\\(?:\\\\|\\{\\d+\\}|\\d+|&|`|')")))
+  (defun build-replacement-template (replacement)
+    (declare #.*standard-optimize-settings*)
+    (typecase replacement
+      (string
+        (let ((from 0)
+              ;; COLLECTOR will hold the (reversed) template
+              (collector '()))
+          ;; scan through all special parts of the replacement string
+          (do-matches (match-start match-end reg-scanner replacement)
+            (when (< from match-start)
+              ;; strings between matches are copied verbatim
+              (push (subseq replacement from match-start) collector))
+            ;; PARSE-START is true if the pattern matched a number which
+            ;; refers to a register
+            (let* ((parse-start (position-if #'digit-char-p
+                                             replacement
+                                             :start match-start
+                                             :end match-end))
+                   (token (if parse-start
+                            (1- (parse-integer replacement
+                                               :start parse-start
+                                               :junk-allowed t))
+                            ;; if we didn't match a number we convert the
+                            ;; character to a symbol
+                            (case (char replacement (1+ match-start))
+                              ((#\&) :match)
+                              ((#\`) :before-match)
+                              ((#\') :after-match)
+                              ((#\\) :backslash)))))
+              (when (and (numberp token) (< token 0))
+                ;; make sure we don't accept something like "\\0"
+                (signal-invocation-error "Illegal substring ~S in replacement string."
+                                         (subseq replacement match-start match-end)))
+              (push token collector))
+            ;; remember where the match ended
+            (setq from match-end))
+          (when (< from (length replacement))
+            ;; push the rest of the replacement string onto the list
+            (push (nsubseq replacement from) collector))
+          (nreverse collector)))
+      (list
+        replacement)
+      (t
+        (list replacement)))))
+        
+(defun build-replacement (replacement-template
+                          target-string
+                          start end
+                          match-start match-end
+                          reg-starts reg-ends
+                          simple-calls
+                          element-type)
+  (declare #.*standard-optimize-settings*)
+  "Accepts a replacement template and the current values from the
+matching process in REGEX-REPLACE or REGEX-REPLACE-ALL and returns the
+corresponding string."
+  ;; the upper exclusive bound of the register numbers in the regular
+  ;; expression
+  (let ((reg-bound (if reg-starts
+                     (array-dimension reg-starts 0)
+                     0)))
+    (with-output-to-string (s nil :element-type element-type)
+      (loop for token in replacement-template
+            do (typecase token
+                 (string
+                   ;; transfer string parts verbatim
+                   (write-string token s))
+                 (integer
+                   ;; replace numbers with the corresponding registers
+                   (when (>= token reg-bound)
+                     ;; but only if the register was referenced in the
+                     ;; regular expression
+                     (signal-invocation-error "Reference to non-existent register ~A in replacement string."
+                                              (1+ token)))
+                   (when (svref reg-starts token)
+                     ;; and only if it matched, i.e. no match results
+                     ;; in an empty string
+                     (write-string target-string s
+                                   :start (svref reg-starts token)
+                                   :end (svref reg-ends token))))
+                 (function
+                   (write-string 
+                    (cond (simple-calls
+                           (apply token
+                                  (nsubseq target-string match-start match-end)
+                                  (map 'list
+                                       (lambda (reg-start reg-end)
+                                         (and reg-start
+                                              (nsubseq target-string reg-start reg-end)))
+                                       reg-starts reg-ends)))
+                          (t
+                           (funcall token
+                                    target-string
+                                    start end
+                                    match-start match-end
+                                    reg-starts reg-ends)))
+                    s))
+                 (symbol
+                   (case token
+                     ((:backslash)
+                       ;; just a backslash
+                       (write-char #\\ s))
+                     ((:match)
+                       ;; the whole match
+                       (write-string target-string s
+                                     :start match-start
+                                     :end match-end))
+                     ((:before-match)
+                       ;; the part of the target string before the match
+                       (write-string target-string s
+                                     :start start
+                                     :end match-start))
+                     ((:after-match)
+                       ;; the part of the target string after the match
+                       (write-string target-string s
+                                     :start match-end
+                                     :end end))
+                     (otherwise
+                      (write-string
+                       (cond (simple-calls
+                              (apply token
+                                     (nsubseq target-string match-start match-end)
+                                     (map 'list
+                                          (lambda (reg-start reg-end)
+                                            (and reg-start
+                                                 (nsubseq target-string reg-start reg-end)))
+                                          reg-starts reg-ends)))
+                             (t
+                              (funcall token
+                                       target-string
+                                       start end
+                                       match-start match-end
+                                       reg-starts reg-ends)))
+                       s)))))))))
+
+(defun replace-aux (target-string replacement pos-list reg-list start end
+                                  preserve-case simple-calls element-type)
+  "Auxiliary function used by REGEX-REPLACE and REGEX-REPLACE-ALL.
+POS-LIST contains a list with the start and end positions of all
+matches while REG-LIST contains a list of arrays representing the
+corresponding register start and end positions."
+  (declare #.*standard-optimize-settings*)
+  ;; build the template once before we start the loop
+  (let ((replacement-template (build-replacement-template replacement)))
+    (with-output-to-string (s nil :element-type element-type)
+      ;; loop through all matches and take the start and end of the
+      ;; whole string into account
+      (loop for (from to) on (append (list start) pos-list (list end))
+            ;; alternate between replacement and no replacement
+            for replace = nil then (and (not replace) to)
+            for reg-starts = (if replace (pop reg-list) nil)
+            for reg-ends = (if replace (pop reg-list) nil)
+            for curr-replacement = (if replace
+                                     ;; build the replacement string
+                                     (build-replacement replacement-template
+                                                        target-string
+                                                        start end
+                                                        from to
+                                                        reg-starts reg-ends
+                                                        simple-calls
+                                                        element-type)
+                                     nil)
+            while to
+            if replace
+              do (write-string (if preserve-case
+                                 ;; modify the case of the replacement
+                                 ;; string if necessary
+                                 (funcall (string-case-modifier target-string
+                                                                from to
+                                                                start end)
+                                          curr-replacement)
+                                 curr-replacement)
+                               s)
+            else
+              ;; no replacement
+              do (write-string target-string s :start from :end to)))))
+
+(defun regex-replace (regex target-string replacement &key
+                            (start 0)
+                            (end (length target-string))
+                            preserve-case
+                            simple-calls
+                            (element-type #+:lispworks 'lw:simple-char #-:lispworks 'character))
+  "Try to match TARGET-STRING between START and END against REGEX and
+replace the first match with REPLACEMENT.  Two values are returned;
+the modified string, and T if REGEX matched or NIL otherwise.
+
+  REPLACEMENT can be a string which may contain the special substrings
+\"\\&\" for the whole match, \"\\`\" for the part of TARGET-STRING
+before the match, \"\\'\" for the part of TARGET-STRING after the
+match, \"\\N\" or \"\\{N}\" for the Nth register where N is a positive
+integer.
+
+  REPLACEMENT can also be a function designator in which case the
+match will be replaced with the result of calling the function
+designated by REPLACEMENT with the arguments TARGET-STRING, START,
+END, MATCH-START, MATCH-END, REG-STARTS, and REG-ENDS. (REG-STARTS and
+REG-ENDS are arrays holding the start and end positions of matched
+registers or NIL - the meaning of the other arguments should be
+obvious.)
+
+  Finally, REPLACEMENT can be a list where each element is a string,
+one of the symbols :MATCH, :BEFORE-MATCH, or :AFTER-MATCH -
+corresponding to \"\\&\", \"\\`\", and \"\\'\" above -, an integer N -
+representing register (1+ N) -, or a function designator.
+
+  If PRESERVE-CASE is true, the replacement will try to preserve the
+case (all upper case, all lower case, or capitalized) of the
+match. The result will always be a fresh string, even if REGEX doesn't
+match.
+
+  ELEMENT-TYPE is the element type of the resulting string."
+  (declare #.*standard-optimize-settings*)
+  (multiple-value-bind (match-start match-end reg-starts reg-ends)
+      (scan regex target-string :start start :end end)
+    (if match-start
+      (values (replace-aux target-string replacement
+                           (list match-start match-end)
+                           (list reg-starts reg-ends)
+                           start end preserve-case
+                           simple-calls element-type)
+              t)
+      (values (subseq target-string start end)
+              nil))))
+
+#-:cormanlisp
+(define-compiler-macro regex-replace
+    (&whole form regex target-string replacement &rest rest)
+  "Make sure that constant forms are compiled into scanners at compile time."
+  (cond ((constantp regex)
+         `(regex-replace (load-time-value (create-scanner ,regex))
+                         ,target-string ,replacement ,@rest))
+        (t form)))
+
+(defun regex-replace-all (regex target-string replacement &key
+                                (start 0)
+                                (end (length target-string))
+                                preserve-case
+                                simple-calls
+                                (element-type #+:lispworks 'lw:simple-char #-:lispworks 'character))
+  "Try to match TARGET-STRING between START and END against REGEX and
+replace all matches with REPLACEMENT.  Two values are returned; the
+modified string, and T if REGEX matched or NIL otherwise.
+
+  REPLACEMENT can be a string which may contain the special substrings
+\"\\&\" for the whole match, \"\\`\" for the part of TARGET-STRING
+before the match, \"\\'\" for the part of TARGET-STRING after the
+match, \"\\N\" or \"\\{N}\" for the Nth register where N is a positive
+integer.
+
+  REPLACEMENT can also be a function designator in which case the
+match will be replaced with the result of calling the function
+designated by REPLACEMENT with the arguments TARGET-STRING, START,
+END, MATCH-START, MATCH-END, REG-STARTS, and REG-ENDS. (REG-STARTS and
+REG-ENDS are arrays holding the start and end positions of matched
+registers or NIL - the meaning of the other arguments should be
+obvious.)
+
+  Finally, REPLACEMENT can be a list where each element is a string,
+one of the symbols :MATCH, :BEFORE-MATCH, or :AFTER-MATCH -
+corresponding to \"\\&\", \"\\`\", and \"\\'\" above -, an integer N -
+representing register (1+ N) -, or a function designator.
+
+  If PRESERVE-CASE is true, the replacement will try to preserve the
+case (all upper case, all lower case, or capitalized) of the
+match. The result will always be a fresh string, even if REGEX doesn't
+match.
+
+  ELEMENT-TYPE is the element type of the resulting string."
+  (declare #.*standard-optimize-settings*)
+  (let ((pos-list '())
+        (reg-list '()))
+    (do-scans (match-start match-end reg-starts reg-ends regex target-string
+                           nil
+                           :start start :end end)
+      (push match-start pos-list)
+      (push match-end pos-list)
+      (push reg-starts reg-list)
+      (push reg-ends reg-list))
+    (if pos-list
+      (values (replace-aux target-string replacement
+                           (nreverse pos-list)
+                           (nreverse reg-list)
+                           start end preserve-case
+                           simple-calls element-type)
+              t)
+      (values (subseq target-string start end)
+              nil))))
+
+#-:cormanlisp
+(define-compiler-macro regex-replace-all
+    (&whole form regex target-string replacement &rest rest)
+  "Make sure that constant forms are compiled into scanners at compile time."
+  (cond ((constantp regex)
+         `(regex-replace-all (load-time-value (create-scanner ,regex))
+                             ,target-string ,replacement ,@rest))
+        (t form)))
+
+#-:cormanlisp
+(defmacro regex-apropos-aux ((regex packages case-insensitive &optional return-form)
+                             &body body)
+  "Auxiliary macro used by REGEX-APROPOS and REGEX-APROPOS-LIST. Loops
+through PACKAGES and executes BODY with SYMBOL bound to each symbol
+which matches REGEX. Optionally evaluates and returns RETURN-FORM at
+the end. If CASE-INSENSITIVE is true and REGEX isn't already a
+scanner, a case-insensitive scanner is used."
+  (with-rebinding (regex)
+    (with-unique-names (scanner %packages next morep hash)
+      `(let* ((,scanner (create-scanner ,regex
+                                        :case-insensitive-mode
+                                        (and ,case-insensitive
+                                             (not (functionp ,regex)))))
+              (,%packages (or ,packages
+                              (list-all-packages)))
+              (,hash (make-hash-table :test #'eq)))
+         (with-package-iterator (,next ,%packages :external :internal :inherited)
+           (loop
+             (multiple-value-bind (,morep symbol)
+                 (,next)
+               (unless ,morep
+                 (return ,return-form))
+               (unless (gethash symbol ,hash)
+                 (when (scan ,scanner (symbol-name symbol))
+                   (setf (gethash symbol ,hash) t)
+                   ,@body)))))))))
+
+;;; The following two functions were provided by Karsten Poeck
+
+#+:cormanlisp
+(defmacro do-with-all-symbols ((variable package-or-packagelist) &body body)
+  "Executes BODY with VARIABLE bound to each symbol in
+PACKAGE-OR-PACKAGELIST \(a designator for a list of packages) in
+turn."
+  (with-unique-names (pack-var)
+    `(if (listp ,package-or-packagelist)
+      (dolist (,pack-var ,package-or-packagelist)
+        (do-symbols (,variable ,pack-var)
+          ,@body))
+      (do-symbols (,variable ,package-or-packagelist)
+        ,@body))))
+
+#+:cormanlisp
+(defmacro regex-apropos-aux ((regex packages case-insensitive &optional return-form)
+                             &body body)
+  "Auxiliary macro used by REGEX-APROPOS and REGEX-APROPOS-LIST.
+Loops through PACKAGES and executes BODY with SYMBOL bound to each
+symbol which matches REGEX.  Optionally evaluates and returns
+RETURN-FORM at the end.  If CASE-INSENSITIVE is true and REGEX isn't
+already a scanner, a case-insensitive scanner is used."
+  (with-rebinding (regex)
+    (with-unique-names (scanner %packages hash)
+      `(let* ((,scanner (create-scanner ,regex
+                         :case-insensitive-mode
+                         (and ,case-insensitive
+                              (not (functionp ,regex)))))
+              (,%packages (or ,packages
+                             (list-all-packages)))
+              (,hash (make-hash-table :test #'eq)))
+        (do-with-all-symbols (symbol ,%packages)
+          (unless (gethash symbol ,hash)
+            (when (scan ,scanner (symbol-name symbol))
+              (setf (gethash symbol ,hash) t)
+              ,@body)))
+        ,return-form))))
+
+(defun regex-apropos-list (regex &optional packages &key (case-insensitive t))
+  (declare #.*standard-optimize-settings*)
+  "Similar to the standard function APROPOS-LIST but returns a list of
+all symbols which match the regular expression REGEX.  If
+CASE-INSENSITIVE is true and REGEX isn't already a scanner, a
+case-insensitive scanner is used."
+  (let ((collector '()))
+    (regex-apropos-aux (regex packages case-insensitive collector)
+      (push symbol collector))))
+
+(defun print-symbol-info (symbol)
+  "Auxiliary function used by REGEX-APROPOS. Tries to print some
+meaningful information about a symbol."
+  (declare #.*standard-optimize-settings*)
+  (handler-case
+    (let ((output-list '()))
+      (cond ((special-operator-p symbol)
+              (push "[special operator]" output-list))
+            ((macro-function symbol)
+              (push "[macro]" output-list))
+            ((fboundp symbol)
+              (let* ((function (symbol-function symbol))
+                     (compiledp (compiled-function-p function)))
+                (multiple-value-bind (lambda-expr closurep)
+                    (function-lambda-expression function)
+                  (push
+                    (format nil
+                            "[~:[~;compiled ~]~:[function~;closure~]]~:[~; ~A~]"
+                            compiledp closurep lambda-expr (cadr lambda-expr))
+                    output-list)))))
+      (let ((class (find-class symbol nil)))
+        (when class
+          (push (format nil "[class] ~S" class) output-list)))
+      (cond ((keywordp symbol)
+              (push "[keyword]" output-list))
+            ((constantp symbol)
+              (push (format nil "[constant]~:[~; value: ~S~]"
+                            (boundp symbol) (symbol-value symbol)) output-list))
+            ((boundp symbol)
+              (push #+(or :lispworks :clisp) "[variable]"
+                    #-(or :lispworks :clisp) (format nil "[variable] value: ~S"
+                                                   (symbol-value symbol))
+                    output-list)))
+      #-(or :cormanlisp :clisp)
+      (format t "~&~S ~<~;~^~A~@{~:@_~A~}~;~:>" symbol output-list)
+      #+(or :cormanlisp :clisp)
+      (loop for line in output-list
+            do (format t "~&~S ~A" symbol line)))
+    (condition ()
+      ;; this seems to be necessary due to some errors I encountered
+      ;; with LispWorks
+      (format t "~&~S [an error occurred while trying to print more info]" symbol))))
+
+(defun regex-apropos (regex &optional packages &key (case-insensitive t))
+  "Similar to the standard function APROPOS but returns a list of all
+symbols which match the regular expression REGEX.  If CASE-INSENSITIVE
+is true and REGEX isn't already a scanner, a case-insensitive scanner
+is used."
+  (declare #.*standard-optimize-settings*)
+  (regex-apropos-aux (regex packages case-insensitive)
+    (print-symbol-info symbol))
+  (values))
+
+(let* ((*use-bmh-matchers* nil)
+       (non-word-char-scanner (create-scanner "[^a-zA-Z_0-9]")))
+  (defun quote-meta-chars (string &key (start 0) (end (length string)))
+    "Quote, i.e. prefix with #\\\\, all non-word characters in STRING."
+    (regex-replace-all non-word-char-scanner string "\\\\\\&"
+                       :start start :end end)))
+
+(let* ((*use-bmh-matchers* nil)
+       (*allow-quoting* nil)
+       (quote-char-scanner (create-scanner "\\\\Q"))
+       (section-scanner (create-scanner "\\\\Q((?:[^\\\\]|\\\\(?!Q))*?)(?:\\\\E|$)")))
+  (defun quote-sections (string)
+    "Replace sections inside of STRING which are enclosed by \\Q and
+\\E with the quoted equivalent of these sections \(see
+QUOTE-META-CHARS). Repeat this as long as there are such
+sections. These sections may nest."
+    (flet ((quote-substring (target-string start end match-start
+                                           match-end reg-starts reg-ends)
+             (declare (ignore start end match-start match-end))
+             (quote-meta-chars target-string
+                               :start (svref reg-starts 0)
+                               :end (svref reg-ends 0))))
+      (loop for result = string then (regex-replace-all section-scanner
+                                                        result
+                                                        #'quote-substring)
+            while (scan quote-char-scanner result)
+            finally (return result)))))
+
+(let* ((*use-bmh-matchers* nil)
+       (comment-scanner (create-scanner "(?s)\\(\\?#.*?\\)"))
+       (extended-comment-scanner (create-scanner "(?m:#.*?$)|(?s:\\(\\?#.*?\\))"))
+       (quote-token-scanner (create-scanner "\\\\[QE]"))
+       (quote-token-replace-scanner (create-scanner "\\\\([QE])")))
+  (defun clean-comments (string &optional extended-mode)
+    "Clean \(?#...) comments within STRING for quoting, i.e. convert
+\\Q to Q and \\E to E.  If EXTENDED-MODE is true, also clean
+end-of-line comments, i.e. those starting with #\\# and ending with
+#\\Newline."
+    (flet ((remove-tokens (target-string start end match-start
+                                         match-end reg-starts reg-ends)
+             (declare (ignore start end reg-starts reg-ends))
+             (loop for result = (nsubseq target-string match-start match-end)
+                   then (regex-replace-all quote-token-replace-scanner result "\\1")
+                   ;; we must probably repeat this because the comment
+                   ;; can contain substrings like \\Q
+                   while (scan quote-token-scanner result)
+                   finally (return result))))
+      (regex-replace-all (if extended-mode
+                           extended-comment-scanner
+                           comment-scanner)
+                         string
+                         #'remove-tokens))))
+
+(defun parse-tree-synonym (symbol)
+  "Returns the parse tree the SYMBOL symbol is a synonym for.  Returns
+NIL is SYMBOL wasn't yet defined to be a synonym."
+  (get symbol 'parse-tree-synonym))
+
+(defun (setf parse-tree-synonym) (new-parse-tree symbol)
+  "Defines SYMBOL to be a synonm for the parse tree NEW-PARSE-TREE."
+  (setf (get symbol 'parse-tree-synonym) new-parse-tree))
+
+(defmacro define-parse-tree-synonym (name parse-tree)
+  "Defines the symbol NAME to be a synonym for the parse tree
+PARSE-TREE.  Both arguments are quoted."
+  `(eval-when (:compile-toplevel :load-toplevel :execute)
+     (setf (parse-tree-synonym ',name) ',parse-tree)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/charmap.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/charmap.lisp
new file mode 100644
index 0000000..844594a
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/charmap.lisp
@@ -0,0 +1,152 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/charmap.lisp,v 1.19 2009/09/17 19:17:30 edi Exp $
+
+;;; An optimized representation of sets of characters.
+
+;;; Copyright (c) 2008-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defstruct (charmap  (:constructor make-charmap%))
+  ;; a bit vector mapping char codes to "booleans" (1 for set members,
+  ;; 0 for others)
+  (vector #*0 :type simple-bit-vector)
+  ;; the smallest character code of all characters in the set
+  (start 0 :type fixnum)
+  ;; the upper (exclusive) bound of all character codes in the set
+  (end 0 :type fixnum)
+  ;; the number of characters in the set, or NIL if this is unknown
+  (count nil :type (or fixnum null))
+  ;; whether the charmap actually represents the complement of the set  
+  (complementp nil :type boolean))
+
+;; seems to be necessary for some Lisps like ClozureCL
+(defmethod make-load-form ((map charmap) &optional environment)
+  (make-load-form-saving-slots map :environment environment))
+
+(declaim (inline in-charmap-p))
+(defun in-charmap-p (char charmap)
+  "Tests whether the character CHAR belongs to the set represented by CHARMAP."
+  (declare #.*standard-optimize-settings*)
+  (declare (character char) (charmap charmap))
+  (let* ((char-code (char-code char))
+         (char-in-vector-p
+          (let ((charmap-start (charmap-start charmap)))
+            (declare (fixnum charmap-start))
+            (and (<= charmap-start char-code)
+                 (< char-code (the fixnum (charmap-end charmap)))
+                 (= 1 (sbit (the simple-bit-vector (charmap-vector charmap))
+                            (- char-code charmap-start)))))))
+    (cond ((charmap-complementp charmap) (not char-in-vector-p))
+          (t char-in-vector-p))))
+
+(defun charmap-contents (charmap)
+  "Returns a list of all characters belonging to a character map.
+Only works for non-complement charmaps."
+  (declare #.*standard-optimize-settings*)
+  (declare (charmap charmap))
+  (and (not (charmap-complementp charmap))
+       (loop for code of-type fixnum from (charmap-start charmap) to (charmap-end charmap)
+             for i across (the simple-bit-vector (charmap-vector charmap))
+             when (= i 1)
+             collect (code-char code))))
+
+(defun make-charmap (start end test-function &optional complementp)
+  "Creates and returns a charmap representing all characters with
+character codes in the interval [start end) that satisfy
+TEST-FUNCTION.  The COMPLEMENTP slot of the charmap is set to the
+value of the optional argument, but this argument doesn't have an
+effect on how TEST-FUNCTION is used."
+  (declare #.*standard-optimize-settings*)
+  (declare (fixnum start end))
+  (let ((vector (make-array (- end start) :element-type 'bit))
+        (count 0))
+    (declare (fixnum count))
+    (loop for code from start below end
+          for char = (code-char code)
+          for index from 0
+          when char do
+          (incf count)
+          (setf (sbit vector index) (if (funcall test-function char) 1 0)))
+    (make-charmap% :vector vector
+                   :start start
+                   :end end
+                   ;; we don't know for sure if COMPLEMENTP is true as
+                   ;; there isn't a necessary a character for each
+                   ;; integer below *REGEX-CHAR-CODE-LIMIT*
+                   :count (and (not complementp) count)
+                   ;; make sure it's boolean
+                   :complementp (not (not complementp)))))
+
+(defun create-charmap-from-test-function (test-function start end)
+  "Creates and returns a charmap representing all characters with
+character codes between START and END which satisfy TEST-FUNCTION.
+Tries to find the smallest interval which is necessary to represent
+the character set and uses the complement representation if that
+helps."
+  (declare #.*standard-optimize-settings*)
+  (let (start-in end-in start-out end-out)
+    ;; determine the smallest intervals containing the set and its
+    ;; complement, [start-in, end-in) and [start-out, end-out) - first
+    ;; the lower bound
+    (loop for code from start below end
+          for char = (code-char code)
+          until (and start-in start-out)
+          when (and char
+                    (not start-in)
+                    (funcall test-function char))
+          do (setq start-in code)
+          when (and char
+                    (not start-out)
+                    (not (funcall test-function char)))
+          do (setq start-out code))
+    (unless start-in
+      ;; no character satisfied the test, so return a "pseudo" charmap
+      ;; where IN-CHARMAP-P is always false
+      (return-from create-charmap-from-test-function
+        (make-charmap% :count 0)))
+    (unless start-out
+      ;; no character failed the test, so return a "pseudo" charmap
+      ;; where IN-CHARMAP-P is always true
+      (return-from create-charmap-from-test-function
+        (make-charmap% :complementp t)))
+    ;; now determine upper bound
+    (loop for code from (1- end) downto start
+          for char = (code-char code)
+          until (and end-in end-out)
+          when (and char
+                    (not end-in)
+                    (funcall test-function char))
+          do (setq end-in (1+ code))
+          when (and char
+                    (not end-out)
+                    (not (funcall test-function char)))
+          do (setq end-out (1+ code)))
+    ;; use the smaller interval
+    (cond ((<= (- end-in start-in) (- end-out start-out))
+           (make-charmap start-in end-in test-function))
+          (t (make-charmap start-out end-out (complement* test-function) t)))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/charset.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/charset.lisp
new file mode 100644
index 0000000..4343291
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/charset.lisp
@@ -0,0 +1,242 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/charset.lisp,v 1.10 2009/09/17 19:17:30 edi Exp $
+
+;;; A specialized set implementation for characters by Nikodemus Siivola.
+
+;;; Copyright (c) 2008, Nikodemus Siivola. All rights reserved.
+;;; Copyright (c) 2008-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defconstant +probe-depth+ 3
+  "Maximum number of collisions \(for any element) we accept before we
+allocate more storage.  This is now fixed, but could be made to vary
+depending on the size of the storage vector \(e.g. in the range of
+1-4).  Larger probe-depths mean more collisions are tolerated before
+the table grows, but increase the constant factor.")
+
+(defun make-char-vector (size)
+  "Returns a vector of size SIZE to hold characters.  All elements are
+initialized to #\Null except for the first one which is initialized to
+#\?."
+  (declare #.*standard-optimize-settings*)
+  (declare (type (integer 2 #.(1- array-total-size-limit)) size))
+  ;; since #\Null always hashes to 0, store something else there
+  ;; initially, and #\Null everywhere else
+  (let ((result (make-array size
+                            :element-type #-:lispworks 'character #+:lispworks 'lw:simple-char
+                            :initial-element (code-char 0))))
+    (setf (char result 0) #\?)
+    result))
+
+(defstruct (charset (:constructor make-charset ()))
+  ;; this is set to 0 when we stop hashing and just use a CHAR-CODE
+  ;; indexed vector
+  (depth +probe-depth+ :type fixnum)
+  ;; the number of characters in this set
+  (count 0 :type fixnum)
+  ;; the storage vector
+  (vector (make-char-vector 12) :type (simple-array character (*))))
+
+;; seems to be necessary for some Lisps like ClozureCL
+(defmethod make-load-form ((set charset) &optional environment)
+  (make-load-form-saving-slots set :environment environment))
+
+(declaim (inline mix))
+(defun mix (code hash)
+  "Given a character code CODE and a hash code HASH, computes and
+returns the \"next\" hash code.  See comments below."
+  (declare #.*standard-optimize-settings*)
+  ;; mixing the CHAR-CODE back in at each step makes sure that if two
+  ;; characters collide (their hashes end up pointing in the same
+  ;; storage vector index) on one round, they should (hopefully!) not
+  ;; collide on the next
+  (sxhash (logand most-positive-fixnum (+ code hash))))
+
+(declaim (inline compute-index))
+(defun compute-index (hash vector)
+  "Computes and returns the index into the vector VECTOR corresponding
+to the hash code HASH."
+  (declare #.*standard-optimize-settings*)
+  (1+ (mod hash (1- (length vector)))))
+
+(defun in-charset-p (char set)
+  "Checks whether the character CHAR is in the charset SET."
+  (declare #.*standard-optimize-settings*)
+  (declare (character char) (charset set))
+  (let ((vector (charset-vector set))
+        (depth (charset-depth set))
+        (code (char-code char)))
+    (declare (fixnum depth))
+    ;; as long as the set remains reasonably small, we use non-linear
+    ;; hashing - the first hash of any character is its CHAR-CODE, and
+    ;; subsequent hashes are computed by MIX above
+    (cond ((or
+            ;; depth 0 is special - each char maps only to its code,
+            ;; nothing else
+            (zerop depth)
+            ;; index 0 is special - only #\Null maps to it, no matter
+            ;; what the depth is
+            (zerop code))
+           (eq char (char vector code)))
+          (t
+           ;; otherwise hash starts out as the character code, but
+           ;; maps to indexes 1-N
+           (let ((hash code))
+             (tagbody
+              :retry
+              (let* ((index (compute-index hash vector))
+                     (x (char vector index)))
+                (cond ((eq x (code-char 0))
+                       ;; empty, no need to probe further
+                       (return-from in-charset-p nil))
+                      ((eq x char)
+                       ;; got it
+                       (return-from in-charset-p t))
+                      ((zerop (decf depth))
+                       ;; max probe depth reached, nothing found
+                       (return-from in-charset-p nil))
+                      (t
+                       ;; nothing yet, try next place
+                       (setf hash (mix code hash))
+                       (go :retry))))))))))
+
+(defun add-to-charset (char set)
+  "Adds the character CHAR to the charset SET, extending SET if
+necessary.  Returns CHAR."
+  (declare #.*standard-optimize-settings*)
+  (or (%add-to-charset char set t)
+      (%add-to-charset/expand char set)
+      (error "Oops, this should not happen..."))
+  char)
+
+(defun %add-to-charset (char set count)
+  "Tries to add the character CHAR to the charset SET without
+extending it.  Returns NIL if this fails.  Counts CHAR as new
+if COUNT is true and it is added to SET."
+  (declare #.*standard-optimize-settings*)
+  (declare (character char) (charset set))
+  (let ((vector (charset-vector set))
+        (depth (charset-depth set))
+        (code (char-code char)))
+    (declare (fixnum depth))
+    ;; see comments in IN-CHARSET-P for algorithm
+    (cond ((or (zerop depth) (zerop code))
+           (unless (eq char (char vector code))
+             (setf (char vector code) char)
+             (when count
+               (incf (charset-count set))))
+           char)
+          (t
+           (let ((hash code))
+             (tagbody
+              :retry
+              (let* ((index (compute-index hash vector))
+                     (x (char vector index)))
+                (cond ((eq x (code-char 0))
+                       (setf (char vector index) char)
+                       (when count
+                         (incf (charset-count set)))
+                       (return-from %add-to-charset char))
+                      ((eq x char)
+                       (return-from %add-to-charset char))
+                      ((zerop (decf depth))
+                       ;; need to expand the table
+                       (return-from %add-to-charset nil))
+                      (t
+                       (setf hash (mix code hash))
+                       (go :retry))))))))))
+
+(defun %add-to-charset/expand (char set)
+  "Extends the charset SET and then adds the character CHAR to it."
+  (declare #.*standard-optimize-settings*)
+  (declare (character char) (charset set))
+  (let* ((old-vector (charset-vector set))
+         (new-size (* 2 (length old-vector))))
+    (tagbody
+     :retry
+     ;; when the table grows large (currently over 1/3 of
+     ;; CHAR-CODE-LIMIT), we dispense with hashing and just allocate a
+     ;; storage vector with space for all characters, so that each
+     ;; character always uses only the CHAR-CODE
+     (multiple-value-bind (new-depth new-vector)
+         (if (>= new-size #.(truncate char-code-limit 3))
+           (values 0 (make-char-vector char-code-limit))
+           (values +probe-depth+ (make-char-vector new-size)))
+       (setf (charset-depth set) new-depth
+             (charset-vector set) new-vector)
+       (flet ((try-add (x)
+                ;; don't count - old characters are already accounted
+                ;; for, and might count the new one multiple times as
+                ;; well
+                (unless (%add-to-charset x set nil)
+                  (assert (not (zerop new-depth)))
+                  (setf new-size (* 2 new-size))
+                  (go :retry))))
+         (try-add char)
+         (dotimes (i (length old-vector))
+           (let ((x (char old-vector i)))
+             (if (eq x (code-char 0))
+               (when (zerop i)
+                 (try-add x))
+               (unless (zerop i)
+                 (try-add x))))))))
+    ;; added and expanded, /now/ count the new character.
+    (incf (charset-count set))
+    t))
+
+(defun map-charset (function charset)
+  "Calls FUNCTION with all characters in SET.  Returns NIL."
+  (declare #.*standard-optimize-settings*)
+  (declare (function function))
+  (let* ((n (charset-count charset))
+         (vector (charset-vector charset))
+         (size (length vector)))
+    ;; see comments in IN-CHARSET-P for algorithm
+    (when (eq (code-char 0) (char vector 0))
+      (funcall function (code-char 0))
+      (decf n))
+    (loop for i from 1 below size
+          for char = (char vector i)
+          unless (eq (code-char 0) char) do
+          (funcall function char)
+          ;; this early termination test should be worth it when
+          ;; mapping across depth 0 charsets.
+          (when (zerop (decf n))
+            (return-from map-charset nil))))
+  nil)
+
+(defun create-charset-from-test-function (test-function start end)
+  "Creates and returns a charset representing all characters with
+character codes between START and END which satisfy TEST-FUNCTION."
+  (declare #.*standard-optimize-settings*)
+  (loop with charset = (make-charset)
+        for code from start below end
+        for char = (code-char code)
+        when (and char (funcall test-function char))
+        do (add-to-charset char charset)
+        finally (return charset)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/chartest.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/chartest.lisp
new file mode 100644
index 0000000..b302c1f
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/chartest.lisp
@@ -0,0 +1,98 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/chartest.lisp,v 1.5 2009/09/17 19:17:30 edi Exp $
+
+;;; Copyright (c) 2008-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defun create-hash-table-from-test-function (test-function start end)
+  "Creates and returns a hash table representing all characters with
+character codes between START and END which satisfy TEST-FUNCTION."
+  (declare #.*standard-optimize-settings*)
+  (loop with hash-table = (make-hash-table)
+        for code from start below end
+        for char = (code-char code)
+        when (and char (funcall test-function char))
+        do (setf (gethash char hash-table) t)
+        finally (return hash-table)))
+
+(defun create-optimized-test-function (test-function &key
+                                                     (start 0)
+                                                     (end *regex-char-code-limit*)
+                                                     (kind *optimize-char-classes*))
+  "Given a unary test function which is applicable to characters
+returns a function which yields the same boolean results for all
+characters with character codes from START to \(excluding) END.  If
+KIND is NIL, TEST-FUNCTION will simply be returned.  Otherwise, KIND
+should be one of:
+
+* :HASH-TABLE - builds a hash table representing all characters which
+                satisfy the test and returns a closure which checks if
+                a character is in that hash table
+
+* :CHARSET - instead of a hash table uses a \"charset\" which is a
+             data structure using non-linear hashing and optimized to
+             represent \(sparse) sets of characters in a fast and
+             space-efficient way \(contributed by Nikodemus Siivola)
+
+* :CHARMAP - instead of a hash table uses a bit vector to represent
+             the set of characters
+
+You can also use :HASH-TABLE* or :CHARSET* which are like :HASH-TABLE
+and :CHARSET but use the complement of the set if the set contains
+more than half of all characters between START and END.  This saves
+space but needs an additional pass across all characters to create the
+data structure.  There is no corresponding :CHARMAP* kind as the bit
+vectors are already created to cover the smallest possible interval
+which contains either the set or its complement."
+  (declare #.*standard-optimize-settings*)
+  (ecase kind
+    ((nil) test-function)
+    (:charmap
+     (let ((charmap (create-charmap-from-test-function test-function start end)))
+       (lambda (char)
+         (in-charmap-p char charmap))))
+    ((:charset :charset*)
+     (let ((charset (create-charset-from-test-function test-function start end)))
+       (cond ((or (eq kind :charset)
+                  (<= (charset-count charset) (ceiling (- end start) 2)))
+              (lambda (char)
+                (in-charset-p char charset)))
+             (t (setq charset (create-charset-from-test-function (complement* test-function)
+                                                                 start end))
+                (lambda (char)
+                  (not (in-charset-p char charset)))))))
+    ((:hash-table :hash-table*)
+     (let ((hash-table (create-hash-table-from-test-function test-function start end)))
+       (cond ((or (eq kind :hash-table)
+                  (<= (hash-table-count hash-table) (ceiling (- end start) 2)))
+              (lambda (char)
+                (gethash char hash-table)))
+             (t (setq hash-table (create-hash-table-from-test-function (complement* test-function)
+                                                                       start end))
+                (lambda (char)
+                  (not (gethash char hash-table)))))))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre-unicode.asd b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre-unicode.asd
new file mode 100644
index 0000000..19fb827
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre-unicode.asd
@@ -0,0 +1,64 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/cl-ppcre-unicode.asd,v 1.15 2009/09/17 19:17:30 edi Exp $
+
+;;; This ASDF system definition was kindly provided by Marco Baringer.
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz.  All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-user)
+
+(defpackage :cl-ppcre-unicode-asd
+  (:use :cl :asdf))
+
+(in-package :cl-ppcre-unicode-asd)
+
+(defsystem :cl-ppcre-unicode
+  :description "Perl-compatible regular expression library (Unicode)"
+  :author "Dr. Edi Weitz"
+  :license "BSD"
+  :components ((:module "cl-ppcre-unicode"
+                        :serial t
+                        :components ((:file "packages")
+                                     (:file "resolver"))))
+  :depends-on (:cl-ppcre :cl-unicode))
+
+(defsystem :cl-ppcre-unicode-test
+  :description "Perl-compatible regular expression library tests (Unicode)"
+  :author "Dr. Edi Weitz"
+  :license "BSD"
+  :depends-on (:cl-ppcre-unicode :cl-ppcre-test)
+  :components ((:module "test"
+                        :serial t
+                        :components ((:file "unicode-tests")))))
+
+(defmethod perform ((o test-op) (c (eql (find-system :cl-ppcre-unicode))))
+  ;; we must load CL-PPCRE explicitly so that the CL-PPCRE-TEST system
+  ;; will be found
+  (operate 'load-op :cl-ppcre)
+  (operate 'load-op :cl-ppcre-unicode-test)
+  (funcall (intern (symbol-name :run-all-tests) (find-package :cl-ppcre-test))
+           :more-tests (intern (symbol-name :unicode-test) (find-package :cl-ppcre-test))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre-unicode/packages.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre-unicode/packages.lisp
new file mode 100644
index 0000000..6c9bb7b
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre-unicode/packages.lisp
@@ -0,0 +1,38 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/cl-ppcre-unicode/packages.lisp,v 1.3 2009/09/17 19:17:34 edi Exp $
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-user)
+
+(defpackage :cl-ppcre-unicode
+  #+:genera
+  (:shadowing-import-from :common-lisp :lambda :string)
+  (:use #-:genera :cl #+:genera :future-common-lisp
+        :cl-ppcre :cl-unicode)
+  (:import-from :cl-ppcre :signal-syntax-error)
+  (:export :unicode-property-resolver))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre-unicode/resolver.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre-unicode/resolver.lisp
new file mode 100644
index 0000000..5c73628
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre-unicode/resolver.lisp
@@ -0,0 +1,61 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/cl-ppcre-unicode/resolver.lisp,v 1.5 2008/07/23 02:14:08 edi Exp $
+
+;;; Copyright (c) 2008, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre-unicode)
+
+(defun unicode-property-resolver (property-name)
+  "A property resolver which understands Unicode properties using
+CL-UNICODE's PROPERTY-TEST function.  This resolver is automatically
+installed in *PROPERTY-RESOLVER* when the CL-PPCRE-UNICODE system is
+loaded."
+  (or (property-test property-name :errorp nil)
+      (signal-syntax-error "There is no property named ~S." property-name)))
+
+(setq *property-resolver* 'unicode-property-resolver)
+
+(pushnew :cl-ppcre-unicode *features*)
+
+;; stuff for Nikodemus Siivola's HYPERDOC
+;; see <http://common-lisp.net/project/hyperdoc/>
+;; and <http://www.cliki.net/hyperdoc>
+;; also used by LW-ADD-ONS
+
+(defvar *hyperdoc-base-uri* "http://weitz.de/cl-ppcre/")
+
+(let ((exported-symbols-alist
+       (loop for symbol being the external-symbols of :cl-ppcre-unicode
+             collect (cons symbol
+                           (concatenate 'string
+                                        "#"
+                                        (string-downcase symbol))))))
+  (defun hyperdoc-lookup (symbol type)
+    (declare (ignore type))
+    (cdr (assoc symbol
+                exported-symbols-alist
+                :test #'eq))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre.asd b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre.asd
new file mode 100644
index 0000000..433ad49
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/cl-ppcre.asd
@@ -0,0 +1,85 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/cl-ppcre.asd,v 1.49 2009/10/28 07:36:15 edi Exp $
+
+;;; This ASDF system definition was kindly provided by Marco Baringer.
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz.  All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-user)
+
+(defpackage :cl-ppcre-asd
+  (:use :cl :asdf))
+
+(in-package :cl-ppcre-asd)
+
+(defsystem :cl-ppcre
+  :version "2.1.1"
+  :description "Perl-compatible regular expression library"
+  :author "Dr. Edi Weitz"
+  :license "BSD"
+  :serial t
+  :components ((:file "packages")
+               (:file "specials")
+               (:file "util")
+               (:file "errors")
+               (:file "charset")
+               (:file "charmap")
+               (:file "chartest")
+               #-:use-acl-regexp2-engine
+               (:file "lexer")
+               #-:use-acl-regexp2-engine
+               (:file "parser")
+               #-:use-acl-regexp2-engine
+               (:file "regex-class")
+               #-:use-acl-regexp2-engine
+               (:file "regex-class-util")
+               #-:use-acl-regexp2-engine
+               (:file "convert")
+               #-:use-acl-regexp2-engine
+               (:file "optimize")
+               #-:use-acl-regexp2-engine
+               (:file "closures")
+               #-:use-acl-regexp2-engine
+               (:file "repetition-closures")
+               #-:use-acl-regexp2-engine
+               (:file "scanner")
+               (:file "api")))
+
+(defsystem :cl-ppcre-test
+  :description "Perl-compatible regular expression library tests"
+  :author "Dr. Edi Weitz"
+  :license "BSD"
+  :depends-on (:cl-ppcre :flexi-streams)
+  :components ((:module "test"
+                        :serial t
+                        :components ((:file "packages")
+                                     (:file "tests")
+                                     (:file "perl-tests")))))
+
+(defmethod perform ((o test-op) (c (eql (find-system :cl-ppcre))))
+  (operate 'load-op :cl-ppcre-test)
+  (funcall (intern (symbol-name :run-all-tests) (find-package :cl-ppcre-test))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/closures.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/closures.lisp
new file mode 100644
index 0000000..a275078
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/closures.lisp
@@ -0,0 +1,471 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/closures.lisp,v 1.45 2009/09/17 19:17:30 edi Exp $
+
+;;; Here we create the closures which together build the final
+;;; scanner.
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(declaim (inline *string*= *string*-equal))
+(defun *string*= (string2 start1 end1 start2 end2)
+  "Like STRING=, i.e. compares the special string *STRING* from START1
+to END1 with STRING2 from START2 to END2. Note that there's no
+boundary check - this has to be implemented by the caller."
+  (declare #.*standard-optimize-settings*)
+  (declare (fixnum start1 end1 start2 end2))
+  (loop for string1-idx of-type fixnum from start1 below end1
+        for string2-idx of-type fixnum from start2 below end2
+        always (char= (schar *string* string1-idx)
+                      (schar string2 string2-idx))))
+
+(defun *string*-equal (string2 start1 end1 start2 end2)
+  "Like STRING-EQUAL, i.e. compares the special string *STRING* from
+START1 to END1 with STRING2 from START2 to END2. Note that there's no
+boundary check - this has to be implemented by the caller."
+  (declare #.*standard-optimize-settings*)
+  (declare (fixnum start1 end1 start2 end2))
+  (loop for string1-idx of-type fixnum from start1 below end1
+        for string2-idx of-type fixnum from start2 below end2
+        always (char-equal (schar *string* string1-idx)
+                           (schar string2 string2-idx))))
+
+(defgeneric create-matcher-aux (regex next-fn)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Creates a closure which takes one parameter,
+START-POS, and tests whether REGEX can match *STRING* at START-POS
+such that the call to NEXT-FN after the match would succeed."))
+                
+(defmethod create-matcher-aux ((seq seq) next-fn)
+  (declare #.*standard-optimize-settings*)
+  ;; the closure for a SEQ is a chain of closures for the elements of
+  ;; this sequence which call each other in turn; the last closure
+  ;; calls NEXT-FN
+  (loop for element in (reverse (elements seq))
+        for curr-matcher = next-fn then next-matcher
+        for next-matcher = (create-matcher-aux element curr-matcher)
+        finally (return next-matcher)))
+
+(defmethod create-matcher-aux ((alternation alternation) next-fn)
+  (declare #.*standard-optimize-settings*)
+  ;; first create closures for all alternations of ALTERNATION
+  (let ((all-matchers (mapcar #'(lambda (choice)
+                                  (create-matcher-aux choice next-fn))
+                              (choices alternation))))
+    ;; now create a closure which checks if one of the closures
+    ;; created above can succeed
+    (lambda (start-pos)
+      (declare (fixnum start-pos))
+      (loop for matcher in all-matchers
+            thereis (funcall (the function matcher) start-pos)))))
+
+(defmethod create-matcher-aux ((register register) next-fn)
+  (declare #.*standard-optimize-settings*)
+  ;; the position of this REGISTER within the whole regex; we start to
+  ;; count at 0
+  (let ((num (num register)))
+    (declare (fixnum num))
+    ;; STORE-END-OF-REG is a thin wrapper around NEXT-FN which will
+    ;; update the corresponding values of *REGS-START* and *REGS-END*
+    ;; after the inner matcher has succeeded
+    (flet ((store-end-of-reg (start-pos)
+               (declare (fixnum start-pos)
+                        (function next-fn))
+               (setf (svref *reg-starts* num) (svref *regs-maybe-start* num)
+                     (svref *reg-ends* num) start-pos)
+           (funcall next-fn start-pos)))
+      ;; the inner matcher is a closure corresponding to the regex
+      ;; wrapped by this REGISTER
+      (let ((inner-matcher (create-matcher-aux (regex register)
+                                               #'store-end-of-reg)))
+        (declare (function inner-matcher))
+        ;; here comes the actual closure for REGISTER
+        (lambda (start-pos)
+          (declare (fixnum start-pos))
+          ;; remember the old values of *REGS-START* and friends in
+          ;; case we cannot match
+          (let ((old-*reg-starts* (svref *reg-starts* num))
+                (old-*regs-maybe-start* (svref *regs-maybe-start* num))
+                (old-*reg-ends* (svref *reg-ends* num)))
+            ;; we cannot use *REGS-START* here because Perl allows
+            ;; regular expressions like /(a|\1x)*/
+            (setf (svref *regs-maybe-start* num) start-pos)
+            (let ((next-pos (funcall inner-matcher start-pos)))
+              (unless next-pos
+                ;; restore old values on failure
+                (setf (svref *reg-starts* num) old-*reg-starts*
+                      (svref *regs-maybe-start* num) old-*regs-maybe-start*
+                      (svref *reg-ends* num) old-*reg-ends*))
+              next-pos)))))))
+
+(defmethod create-matcher-aux ((lookahead lookahead) next-fn)
+  (declare #.*standard-optimize-settings*)
+  ;; create a closure which just checks for the inner regex and
+  ;; doesn't care about NEXT-FN
+  (let ((test-matcher (create-matcher-aux (regex lookahead) #'identity)))
+    (declare (function next-fn test-matcher))
+    (if (positivep lookahead)
+      ;; positive look-ahead: check success of inner regex, then call
+      ;; NEXT-FN
+      (lambda (start-pos)
+        (and (funcall test-matcher start-pos)
+             (funcall next-fn start-pos)))
+      ;; negative look-ahead: check failure of inner regex, then call
+      ;; NEXT-FN
+      (lambda (start-pos)
+        (and (not (funcall test-matcher start-pos))
+             (funcall next-fn start-pos))))))
+
+(defmethod create-matcher-aux ((lookbehind lookbehind) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (let ((len (len lookbehind))
+        ;; create a closure which just checks for the inner regex and
+        ;; doesn't care about NEXT-FN
+        (test-matcher (create-matcher-aux (regex lookbehind) #'identity)))
+    (declare (function next-fn test-matcher)
+             (fixnum len))
+    (if (positivep lookbehind)
+      ;; positive look-behind: check success of inner regex (if we're
+      ;; far enough from the start of *STRING*), then call NEXT-FN
+      (lambda (start-pos)
+        (declare (fixnum start-pos))
+        (and (>= (- start-pos (or *real-start-pos* *start-pos*)) len)
+             (funcall test-matcher (- start-pos len))
+             (funcall next-fn start-pos)))
+      ;; negative look-behind: check failure of inner regex (if we're
+      ;; far enough from the start of *STRING*), then call NEXT-FN
+      (lambda (start-pos)
+        (declare (fixnum start-pos))
+        (and (or (< (- start-pos (or *real-start-pos* *start-pos*)) len)
+                 (not (funcall test-matcher (- start-pos len))))
+             (funcall next-fn start-pos))))))
+
+(defmacro insert-char-class-tester ((char-class chr-expr) &body body)
+  "Utility macro to replace each occurence of '\(CHAR-CLASS-TEST)
+within BODY with the correct test (corresponding to CHAR-CLASS)
+against CHR-EXPR."
+  (with-rebinding (char-class)
+    (with-unique-names (test-function)
+      (flet ((substitute-char-class-tester (new)
+               (subst new '(char-class-test) body
+                      :test #'equalp)))
+        `(let ((,test-function (test-function ,char-class)))
+           ,@(substitute-char-class-tester
+              `(funcall ,test-function ,chr-expr)))))))
+
+(defmethod create-matcher-aux ((char-class char-class) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (declare (function next-fn))
+  ;; insert a test against the current character within *STRING*
+  (insert-char-class-tester (char-class (schar *string* start-pos))
+    (lambda (start-pos)
+      (declare (fixnum start-pos))
+      (and (< start-pos *end-pos*)
+           (char-class-test)
+           (funcall next-fn (1+ start-pos))))))
+
+(defmethod create-matcher-aux ((str str) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (declare (fixnum *end-string-pos*)
+           (function next-fn)
+           ;; this special value is set by CREATE-SCANNER when the
+           ;; closures are built
+           (special end-string))
+  (let* ((len (len str))
+         (case-insensitive-p (case-insensitive-p str))
+         (start-of-end-string-p (start-of-end-string-p str))
+         (skip (skip str))
+         (str (str str))
+         (chr (schar str 0))
+         (end-string (and end-string (str end-string)))
+         (end-string-len (if end-string
+                           (length end-string)
+                           nil)))
+    (declare (fixnum len))
+    (cond ((and start-of-end-string-p case-insensitive-p)
+            ;; closure for the first STR which belongs to the constant
+            ;; string at the end of the regular expression;
+            ;; case-insensitive version
+            (lambda (start-pos)
+              (declare (fixnum start-pos end-string-len))
+              (let ((test-end-pos (+ start-pos end-string-len)))
+                (declare (fixnum test-end-pos))
+                ;; either we're at *END-STRING-POS* (which means that
+                ;; it has already been confirmed that end-string
+                ;; starts here) or we really have to test
+                (and (or (= start-pos *end-string-pos*)
+                         (and (<= test-end-pos *end-pos*)
+                              (*string*-equal end-string start-pos test-end-pos
+                                              0 end-string-len)))
+                     (funcall next-fn (+ start-pos len))))))
+          (start-of-end-string-p
+            ;; closure for the first STR which belongs to the constant
+            ;; string at the end of the regular expression;
+            ;; case-sensitive version
+            (lambda (start-pos)
+              (declare (fixnum start-pos end-string-len))
+              (let ((test-end-pos (+ start-pos end-string-len)))
+                (declare (fixnum test-end-pos))
+                ;; either we're at *END-STRING-POS* (which means that
+                ;; it has already been confirmed that end-string
+                ;; starts here) or we really have to test
+                (and (or (= start-pos *end-string-pos*)
+                         (and (<= test-end-pos *end-pos*)
+                              (*string*= end-string start-pos test-end-pos
+                                         0 end-string-len)))
+                     (funcall next-fn (+ start-pos len))))))
+          (skip
+            ;; a STR which can be skipped because some other function
+            ;; has already confirmed that it matches
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (funcall next-fn (+ start-pos len))))
+          ((and (= len 1) case-insensitive-p)
+            ;; STR represent exactly one character; case-insensitive
+            ;; version
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (and (< start-pos *end-pos*)
+                   (char-equal (schar *string* start-pos) chr)
+                   (funcall next-fn (1+ start-pos)))))
+          ((= len 1)
+            ;; STR represent exactly one character; case-sensitive
+            ;; version
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (and (< start-pos *end-pos*)
+                   (char= (schar *string* start-pos) chr)
+                   (funcall next-fn (1+ start-pos)))))
+          (case-insensitive-p
+            ;; general case, case-insensitive version
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (let ((next-pos (+ start-pos len)))
+                (declare (fixnum next-pos))
+                (and (<= next-pos *end-pos*)
+                     (*string*-equal str start-pos next-pos 0 len)
+                     (funcall next-fn next-pos)))))
+          (t
+            ;; general case, case-sensitive version
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (let ((next-pos (+ start-pos len)))
+                (declare (fixnum next-pos))
+                (and (<= next-pos *end-pos*)
+                     (*string*= str start-pos next-pos 0 len)
+                     (funcall next-fn next-pos))))))))
+
+(declaim (inline word-boundary-p))
+(defun word-boundary-p (start-pos)
+  "Check whether START-POS is a word-boundary within *STRING*."
+  (declare #.*standard-optimize-settings*)
+  (declare (fixnum start-pos))
+  (let ((1-start-pos (1- start-pos))
+        (*start-pos* (or *real-start-pos* *start-pos*)))
+    ;; either the character before START-POS is a word-constituent and
+    ;; the character at START-POS isn't...
+    (or (and (or (= start-pos *end-pos*)
+                 (and (< start-pos *end-pos*)
+                      (not (word-char-p (schar *string* start-pos)))))
+             (and (< 1-start-pos *end-pos*)
+                  (<= *start-pos* 1-start-pos)
+                  (word-char-p (schar *string* 1-start-pos))))
+        ;; ...or vice versa
+        (and (or (= start-pos *start-pos*)
+                 (and (< 1-start-pos *end-pos*)
+                      (<= *start-pos* 1-start-pos)
+                      (not (word-char-p (schar *string* 1-start-pos)))))
+             (and (< start-pos *end-pos*)
+                  (word-char-p (schar *string* start-pos)))))))
+
+(defmethod create-matcher-aux ((word-boundary word-boundary) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (declare (function next-fn))
+  (if (negatedp word-boundary)
+    (lambda (start-pos)
+      (and (not (word-boundary-p start-pos))
+           (funcall next-fn start-pos)))
+    (lambda (start-pos)
+      (and (word-boundary-p start-pos)
+           (funcall next-fn start-pos)))))
+
+(defmethod create-matcher-aux ((everything everything) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (declare (function next-fn))
+  (if (single-line-p everything)
+    ;; closure for single-line-mode: we really match everything, so we
+    ;; just advance the index into *STRING* by one and carry on
+    (lambda (start-pos)
+      (declare (fixnum start-pos))
+      (and (< start-pos *end-pos*)
+           (funcall next-fn (1+ start-pos))))
+    ;; not single-line-mode, so we have to make sure we don't match
+    ;; #\Newline
+    (lambda (start-pos)
+      (declare (fixnum start-pos))
+      (and (< start-pos *end-pos*)
+           (char/= (schar *string* start-pos) #\Newline)
+           (funcall next-fn (1+ start-pos))))))
+
+(defmethod create-matcher-aux ((anchor anchor) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (declare (function next-fn))
+  (let ((startp (startp anchor))
+        (multi-line-p (multi-line-p anchor)))
+    (cond ((no-newline-p anchor)
+            ;; this must be an end-anchor and it must be modeless, so
+            ;; we just have to check whether START-POS equals
+            ;; *END-POS*
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (and (= start-pos *end-pos*)
+                   (funcall next-fn start-pos))))
+          ((and startp multi-line-p)
+            ;; a start-anchor in multi-line-mode: check if we're at
+            ;; *START-POS* or if the last character was #\Newline
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (let ((*start-pos* (or *real-start-pos* *start-pos*)))
+                (and (or (= start-pos *start-pos*)
+                         (and (<= start-pos *end-pos*)
+                              (> start-pos *start-pos*)
+                              (char= #\Newline
+                                     (schar *string* (1- start-pos)))))
+                     (funcall next-fn start-pos)))))
+          (startp
+            ;; a start-anchor which is not in multi-line-mode, so just
+            ;; check whether we're at *START-POS*
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (and (= start-pos (or *real-start-pos* *start-pos*))
+                   (funcall next-fn start-pos))))
+          (multi-line-p
+            ;; an end-anchor in multi-line-mode: check if we're at
+            ;; *END-POS* or if the character we're looking at is
+            ;; #\Newline
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (and (or (= start-pos *end-pos*)
+                       (and (< start-pos *end-pos*)
+                            (char= #\Newline
+                                   (schar *string* start-pos))))
+                   (funcall next-fn start-pos))))
+          (t
+            ;; an end-anchor which is not in multi-line-mode, so just
+            ;; check if we're at *END-POS* or if we're looking at
+            ;; #\Newline and there's nothing behind it
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (and (or (= start-pos *end-pos*)
+                       (and (= start-pos (1- *end-pos*))
+                            (char= #\Newline
+                                   (schar *string* start-pos))))
+                   (funcall next-fn start-pos)))))))
+
+(defmethod create-matcher-aux ((back-reference back-reference) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (declare (function next-fn))
+  ;; the position of the corresponding REGISTER within the whole
+  ;; regex; we start to count at 0
+  (let ((num (num back-reference)))
+    (if (case-insensitive-p back-reference)
+      ;; the case-insensitive version
+      (lambda (start-pos)
+        (declare (fixnum start-pos))
+        (let ((reg-start (svref *reg-starts* num))
+              (reg-end (svref *reg-ends* num)))
+          ;; only bother to check if the corresponding REGISTER as
+          ;; matched successfully already
+          (and reg-start
+               (let ((next-pos (+ start-pos (- (the fixnum reg-end)
+                                               (the fixnum reg-start)))))
+                 (declare (fixnum next-pos))
+                 (and
+                   (<= next-pos *end-pos*)
+                   (*string*-equal *string* start-pos next-pos
+                                   reg-start reg-end)
+                   (funcall next-fn next-pos))))))
+      ;; the case-sensitive version
+      (lambda (start-pos)
+        (declare (fixnum start-pos))
+        (let ((reg-start (svref *reg-starts* num))
+              (reg-end (svref *reg-ends* num)))
+          ;; only bother to check if the corresponding REGISTER as
+          ;; matched successfully already
+          (and reg-start
+               (let ((next-pos (+ start-pos (- (the fixnum reg-end)
+                                               (the fixnum reg-start)))))
+                 (declare (fixnum next-pos))
+                 (and
+                   (<= next-pos *end-pos*)
+                   (*string*= *string* start-pos next-pos
+                              reg-start reg-end)
+                   (funcall next-fn next-pos)))))))))
+
+(defmethod create-matcher-aux ((branch branch) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (let* ((test (test branch))
+         (then-matcher (create-matcher-aux (then-regex branch) next-fn))
+         (else-matcher (create-matcher-aux (else-regex branch) next-fn)))
+    (declare (function then-matcher else-matcher))
+    (cond ((numberp test)
+            (lambda (start-pos)
+              (declare (fixnum test))
+              (if (and (< test (length *reg-starts*))
+                       (svref *reg-starts* test))
+                (funcall then-matcher start-pos)
+                (funcall else-matcher start-pos))))
+          (t
+            (let ((test-matcher (create-matcher-aux test #'identity)))
+              (declare (function test-matcher))
+              (lambda (start-pos)
+                (if (funcall test-matcher start-pos)
+                  (funcall then-matcher start-pos)
+                  (funcall else-matcher start-pos))))))))
+
+(defmethod create-matcher-aux ((standalone standalone) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (let ((inner-matcher (create-matcher-aux (regex standalone) #'identity)))
+    (declare (function next-fn inner-matcher))
+    (lambda (start-pos)
+      (let ((next-pos (funcall inner-matcher start-pos)))
+        (and next-pos
+             (funcall next-fn next-pos))))))
+
+(defmethod create-matcher-aux ((filter filter) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (let ((fn (fn filter)))
+    (lambda (start-pos)
+      (let ((next-pos (funcall fn start-pos)))
+        (and next-pos
+             (funcall next-fn next-pos))))))
+
+(defmethod create-matcher-aux ((void void) next-fn)
+  (declare #.*standard-optimize-settings*)
+  ;; optimize away VOIDs: don't create a closure, just return NEXT-FN
+  next-fn)
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/convert.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/convert.lisp
new file mode 100644
index 0000000..c2683ae
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/convert.lisp
@@ -0,0 +1,879 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/convert.lisp,v 1.57 2009/09/17 19:17:31 edi Exp $
+
+;;; Here the parse tree is converted into its internal representation
+;;; using REGEX objects.  At the same time some optimizations are
+;;; already applied.
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+;;; The flags that represent the "ism" modifiers are always kept
+;;; together in a three-element list. We use the following macros to
+;;; access individual elements.
+
+(defmacro case-insensitive-mode-p (flags)
+  "Accessor macro to extract the first flag out of a three-element flag list."
+  `(first ,flags))
+
+(defmacro multi-line-mode-p (flags)
+  "Accessor macro to extract the second flag out of a three-element flag list."
+  `(second ,flags))
+
+(defmacro single-line-mode-p (flags)
+  "Accessor macro to extract the third flag out of a three-element flag list."
+  `(third ,flags))
+
+(defun set-flag (token)
+  "Reads a flag token and sets or unsets the corresponding entry in
+the special FLAGS list."
+  (declare #.*standard-optimize-settings*)
+  (declare (special flags))
+  (case token
+    ((:case-insensitive-p)
+      (setf (case-insensitive-mode-p flags) t))
+    ((:case-sensitive-p)
+      (setf (case-insensitive-mode-p flags) nil))
+    ((:multi-line-mode-p)
+      (setf (multi-line-mode-p flags) t))
+    ((:not-multi-line-mode-p)
+      (setf (multi-line-mode-p flags) nil))
+    ((:single-line-mode-p)
+      (setf (single-line-mode-p flags) t))
+    ((:not-single-line-mode-p)
+      (setf (single-line-mode-p flags) nil))
+    (otherwise
+      (signal-syntax-error "Unknown flag token ~A." token))))
+
+(defgeneric resolve-property (property)
+  (:documentation "Resolves PROPERTY to a unary character test
+function.  PROPERTY can either be a function designator or it can be a
+string which is resolved using *PROPERTY-RESOLVER*.")
+  (:method ((property-name string))
+   (funcall *property-resolver* property-name))
+  (:method ((function-name symbol))
+   function-name)
+  (:method ((test-function function))
+   test-function))
+
+(defun convert-char-class-to-test-function (list invertedp case-insensitive-p)
+  "Combines all items in LIST into test function and returns a
+logical-OR combination of these functions.  Items can be single
+characters, character ranges like \(:RANGE #\\A #\\E), or special
+character classes like :DIGIT-CLASS.  Does the right thing with
+respect to case-\(in)sensitivity as specified by the special variable
+FLAGS."
+  (declare #.*standard-optimize-settings*)
+  (declare (special flags))
+  (let ((test-functions
+         (loop for item in list
+               collect (cond ((characterp item)
+                              ;; rebind so closure captures the right one
+                              (let ((this-char item))
+                                (lambda (char)
+                                  (declare (character char this-char))
+                                  (char= char this-char))))
+                             ((symbolp item)
+                              (case item
+                                ((:digit-class) #'digit-char-p)
+                                ((:non-digit-class) (complement* #'digit-char-p))
+                                ((:whitespace-char-class) #'whitespacep)
+                                ((:non-whitespace-char-class) (complement* #'whitespacep))
+                                ((:word-char-class) #'word-char-p)
+                                ((:non-word-char-class) (complement* #'word-char-p))
+                                (otherwise
+                                 (signal-syntax-error "Unknown symbol ~A in character class." item))))
+                             ((and (consp item)
+                                   (eq (first item) :property))
+                              (resolve-property (second item)))
+                             ((and (consp item)
+                                   (eq (first item) :inverted-property))
+                              (complement* (resolve-property (second item))))
+                             ((and (consp item)
+                                   (eq (first item) :range))
+                              (let ((from (second item))
+                                    (to (third item)))
+                                (when (char> from to)
+                                  (signal-syntax-error "Invalid range from ~S to ~S in char-class." from to))
+                                (lambda (char)
+                                  (declare (character char from to))
+                                  (char<= from char to))))
+                             (t (signal-syntax-error "Unknown item ~A in char-class list." item))))))
+    (unless test-functions
+      (signal-syntax-error "Empty character class."))
+    (cond ((cdr test-functions)           
+           (cond ((and invertedp case-insensitive-p)
+                  (lambda (char)
+                    (declare (character char))
+                    (loop with both-case-p = (both-case-p char)
+                          with char-down = (if both-case-p (char-downcase char) char)
+                          with char-up = (if both-case-p (char-upcase char) nil)
+                          for test-function in test-functions
+                          never (or (funcall test-function char-down)
+                                    (and char-up (funcall test-function char-up))))))
+                 (case-insensitive-p
+                  (lambda (char)
+                    (declare (character char))
+                    (loop with both-case-p = (both-case-p char)
+                          with char-down = (if both-case-p (char-downcase char) char)
+                          with char-up = (if both-case-p (char-upcase char) nil)
+                          for test-function in test-functions
+                          thereis (or (funcall test-function char-down)
+                                      (and char-up (funcall test-function char-up))))))
+                 (invertedp
+                  (lambda (char)
+                    (loop for test-function in test-functions
+                          never (funcall test-function char))))
+                 (t
+                  (lambda (char)
+                    (loop for test-function in test-functions
+                          thereis (funcall test-function char))))))
+          ;; there's only one test-function
+          (t (let ((test-function (first test-functions)))
+               (cond ((and invertedp case-insensitive-p)
+                      (lambda (char)
+                        (declare (character char))
+                        (not (or (funcall test-function (char-downcase char))
+                                 (and (both-case-p char)
+                                      (funcall test-function (char-upcase char)))))))
+                     (case-insensitive-p
+                      (lambda (char)
+                        (declare (character char))
+                        (or (funcall test-function (char-downcase char))
+                            (and (both-case-p char)
+                                 (funcall test-function (char-upcase char))))))
+                     (invertedp (complement* test-function))
+                     (t test-function)))))))
+
+(defun maybe-split-repetition (regex
+                               greedyp
+                               minimum
+                               maximum
+                               min-len
+                               length
+                               reg-seen)
+  "Splits a REPETITION object into a constant and a varying part if
+applicable, i.e. something like
+  a{3,} -> a{3}a*
+The arguments to this function correspond to the REPETITION slots of
+the same name."
+  (declare #.*standard-optimize-settings*)
+  (declare (fixnum minimum)
+           (type (or fixnum null) maximum))
+  ;; note the usage of COPY-REGEX here; we can't use the same REGEX
+  ;; object in both REPETITIONS because they will have different
+  ;; offsets
+  (when maximum
+    (when (zerop maximum)
+      ;; trivial case: don't repeat at all
+      (return-from maybe-split-repetition
+        (make-instance 'void)))
+    (when (= 1 minimum maximum)
+      ;; another trivial case: "repeat" exactly once
+      (return-from maybe-split-repetition
+        regex)))
+  ;; first set up the constant part of the repetition
+  ;; maybe that's all we need
+  (let ((constant-repetition (if (plusp minimum)
+                               (make-instance 'repetition
+                                              :regex (copy-regex regex)
+                                              :greedyp greedyp
+                                              :minimum minimum
+                                              :maximum minimum
+                                              :min-len min-len
+                                              :len length
+                                              :contains-register-p reg-seen)
+                               ;; don't create garbage if minimum is 0
+                               nil)))
+    (when (and maximum
+               (= maximum minimum))
+      (return-from maybe-split-repetition
+        ;; no varying part needed because min = max
+        constant-repetition))
+    ;; now construct the varying part
+    (let ((varying-repetition
+            (make-instance 'repetition
+                           :regex regex
+                           :greedyp greedyp
+                           :minimum 0
+                           :maximum (if maximum (- maximum minimum) nil)
+                           :min-len min-len
+                           :len length
+                           :contains-register-p reg-seen)))
+      (cond ((zerop minimum)
+              ;; min = 0, no constant part needed
+              varying-repetition)
+            ((= 1 minimum)
+              ;; min = 1, constant part needs no REPETITION wrapped around
+              (make-instance 'seq
+                             :elements (list (copy-regex regex)
+                                             varying-repetition)))
+            (t
+              ;; general case
+              (make-instance 'seq
+                             :elements (list constant-repetition
+                                             varying-repetition)))))))
+
+;; During the conversion of the parse tree we keep track of the start
+;; of the parse tree in the special variable STARTS-WITH which'll
+;; either hold a STR object or an EVERYTHING object. The latter is the
+;; case if the regex starts with ".*" which implicitly anchors the
+;; regex at the start (perhaps modulo #\Newline).
+
+(defun maybe-accumulate (str)
+  "Accumulate STR into the special variable STARTS-WITH if
+ACCUMULATE-START-P (also special) is true and STARTS-WITH is either
+NIL or a STR object of the same case mode. Always returns NIL."
+  (declare #.*standard-optimize-settings*)
+  (declare (special accumulate-start-p starts-with))
+  (declare (ftype (function (t) fixnum) len))
+  (when accumulate-start-p
+    (etypecase starts-with
+      (str
+        ;; STARTS-WITH already holds a STR, so we check if we can
+        ;; concatenate
+        (cond ((eq (case-insensitive-p starts-with)
+                   (case-insensitive-p str))
+                ;; we modify STARTS-WITH in place
+                (setf (len starts-with)
+                        (+ (len starts-with) (len str)))
+                ;; note that we use SLOT-VALUE because the accessor
+                ;; STR has a declared FTYPE which doesn't fit here
+                (adjust-array (slot-value starts-with 'str)
+                              (len starts-with)
+                              :fill-pointer t)
+                (setf (subseq (slot-value starts-with 'str)
+                              (- (len starts-with) (len str)))
+                        (str str)
+                      ;; STR objects that are parts of STARTS-WITH
+                      ;; always have their SKIP slot set to true
+                      ;; because the SCAN function will take care of
+                      ;; them, i.e. the matcher can ignore them
+                      (skip str) t))
+              (t (setq accumulate-start-p nil))))
+      (null
+        ;; STARTS-WITH is still empty, so we create a new STR object
+        (setf starts-with
+                (make-instance 'str
+                               :str ""
+                               :case-insensitive-p (case-insensitive-p str))
+              ;; INITIALIZE-INSTANCE will coerce the STR to a simple
+              ;; string, so we have to fill it afterwards
+              (slot-value starts-with 'str)
+                (make-array (len str)
+                            :initial-contents (str str)
+                            :element-type 'character
+                            :fill-pointer t
+                            :adjustable t)
+              (len starts-with)
+                (len str)
+              ;; see remark about SKIP above
+              (skip str) t))
+      (everything
+        ;; STARTS-WITH already holds an EVERYTHING object - we can't
+        ;; concatenate
+        (setq accumulate-start-p nil))))
+  nil)
+
+(declaim (inline convert-aux))
+(defun convert-aux (parse-tree)
+  "Converts the parse tree PARSE-TREE into a REGEX object and returns
+it.  Will also
+
+  - split and optimize repetitions,
+  - accumulate strings or EVERYTHING objects into the special variable
+    STARTS-WITH,
+  - keep track of all registers seen in the special variable REG-NUM,
+  - keep track of all named registers seen in the special variable REG-NAMES
+  - keep track of the highest backreference seen in the special
+    variable MAX-BACK-REF,
+  - maintain and adher to the currently applicable modifiers in the special
+    variable FLAGS, and
+  - maybe even wash your car..."
+  (declare #.*standard-optimize-settings*)
+  (if (consp parse-tree)
+    (convert-compound-parse-tree (first parse-tree) parse-tree)
+    (convert-simple-parse-tree parse-tree)))
+
+(defgeneric convert-compound-parse-tree (token parse-tree &key)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Helper function for CONVERT-AUX which converts
+parse trees which are conses and dispatches on TOKEN which is the
+first element of the parse tree.")
+  (:method ((token t) (parse-tree t) &key)
+   (signal-syntax-error "Unknown token ~A in parse-tree." token)))
+
+(defmethod convert-compound-parse-tree ((token (eql :sequence)) parse-tree &key)
+  "The case for parse trees like \(:SEQUENCE {<regex>}*)."
+  (declare #.*standard-optimize-settings*)
+  (cond ((cddr parse-tree)
+         ;; this is essentially like
+         ;; (MAPCAR 'CONVERT-AUX (REST PARSE-TREE))
+         ;; but we don't cons a new list
+         (loop for parse-tree-rest on (rest parse-tree)
+               while parse-tree-rest
+               do (setf (car parse-tree-rest)
+                        (convert-aux (car parse-tree-rest))))
+         (make-instance 'seq :elements (rest parse-tree)))
+        (t (convert-aux (second parse-tree)))))
+
+(defmethod convert-compound-parse-tree ((token (eql :group)) parse-tree &key)
+  "The case for parse trees like \(:GROUP {<regex>}*).
+
+This is a syntactical construct equivalent to :SEQUENCE intended to
+keep the effect of modifiers local."
+  (declare #.*standard-optimize-settings*)
+  (declare (special flags))
+  ;; make a local copy of FLAGS and shadow the global value while we
+  ;; descend into the enclosed regexes
+  (let ((flags (copy-list flags)))
+    (declare (special flags))
+    (cond ((cddr parse-tree)
+           (loop for parse-tree-rest on (rest parse-tree)
+                 while parse-tree-rest
+                 do (setf (car parse-tree-rest)
+                          (convert-aux (car parse-tree-rest))))
+           (make-instance 'seq :elements (rest parse-tree)))
+          (t (convert-aux (second parse-tree))))))
+
+(defmethod convert-compound-parse-tree ((token (eql :alternation)) parse-tree &key)
+  "The case for \(:ALTERNATION {<regex>}*)."
+  (declare #.*standard-optimize-settings*)
+  (declare (special accumulate-start-p))
+  ;; we must stop accumulating objects into STARTS-WITH once we reach
+  ;; an alternation
+  (setq accumulate-start-p nil)
+  (loop for parse-tree-rest on (rest parse-tree)
+        while parse-tree-rest
+        do (setf (car parse-tree-rest)
+                 (convert-aux (car parse-tree-rest))))
+  (make-instance 'alternation :choices (rest parse-tree)))
+
+(defmethod convert-compound-parse-tree ((token (eql :branch)) parse-tree &key)
+  "The case for \(:BRANCH <test> <regex>).
+
+Here, <test> must be look-ahead, look-behind or number; if <regex> is
+an alternation it must have one or two choices."
+  (declare #.*standard-optimize-settings*)
+  (declare (special accumulate-start-p))
+  (setq accumulate-start-p nil)
+  (let* ((test-candidate (second parse-tree))
+         (test (cond ((numberp test-candidate)
+                      (when (zerop (the fixnum test-candidate))
+                        (signal-syntax-error "Register 0 doesn't exist: ~S." parse-tree))
+                      (1- (the fixnum test-candidate)))
+                     (t (convert-aux test-candidate))))
+         (alternations (convert-aux (third parse-tree))))
+    (when (and (not (numberp test))
+               (not (typep test 'lookahead))
+               (not (typep test 'lookbehind)))
+      (signal-syntax-error "Branch test must be look-ahead, look-behind or number: ~S." parse-tree))
+    (typecase alternations
+      (alternation
+       (case (length (choices alternations))
+         ((0)
+          (signal-syntax-error "No choices in branch: ~S." parse-tree))
+         ((1)
+          (make-instance 'branch
+                         :test test
+                         :then-regex (first
+                                      (choices alternations))))
+         ((2)
+          (make-instance 'branch
+                         :test test
+                         :then-regex (first
+                                      (choices alternations))
+                         :else-regex (second
+                                      (choices alternations))))
+         (otherwise
+          (signal-syntax-error "Too much choices in branch: ~S." parse-tree))))
+      (t
+       (make-instance 'branch
+                      :test test
+                      :then-regex alternations)))))
+
+(defmethod convert-compound-parse-tree ((token (eql :positive-lookahead)) parse-tree &key)
+  "The case for \(:POSITIVE-LOOKAHEAD <regex>)."
+  (declare #.*standard-optimize-settings*)
+  (declare (special flags accumulate-start-p))
+  ;; keep the effect of modifiers local to the enclosed regex and stop
+  ;; accumulating into STARTS-WITH
+  (setq accumulate-start-p nil)
+  (let ((flags (copy-list flags)))
+    (declare (special flags))
+    (make-instance 'lookahead
+                   :regex (convert-aux (second parse-tree))
+                   :positivep t)))
+
+(defmethod convert-compound-parse-tree ((token (eql :negative-lookahead)) parse-tree &key)
+  "The case for \(:NEGATIVE-LOOKAHEAD <regex>)."
+  (declare #.*standard-optimize-settings*)
+  ;; do the same as for positive look-aheads and just switch afterwards
+  (let ((regex (convert-compound-parse-tree :positive-lookahead parse-tree)))
+    (setf (slot-value regex 'positivep) nil)
+    regex))
+
+(defmethod convert-compound-parse-tree ((token (eql :positive-lookbehind)) parse-tree &key)
+  "The case for \(:POSITIVE-LOOKBEHIND <regex>)."
+  (declare #.*standard-optimize-settings*)
+  (declare (special flags accumulate-start-p))
+  ;; keep the effect of modifiers local to the enclosed regex and stop
+  ;; accumulating into STARTS-WITH
+  (setq accumulate-start-p nil)
+  (let* ((flags (copy-list flags))
+         (regex (convert-aux (second parse-tree)))
+         (len (regex-length regex)))
+    (declare (special flags))
+    ;; lookbehind assertions must be of fixed length
+    (unless len
+      (signal-syntax-error "Variable length look-behind not implemented \(yet): ~S." parse-tree))
+    (make-instance 'lookbehind
+                   :regex regex
+                   :positivep t
+                   :len len)))
+
+(defmethod convert-compound-parse-tree ((token (eql :negative-lookbehind)) parse-tree &key)
+  "The case for \(:NEGATIVE-LOOKBEHIND <regex>)."
+  (declare #.*standard-optimize-settings*)
+  ;; do the same as for positive look-behinds and just switch afterwards
+  (let ((regex (convert-compound-parse-tree :positive-lookbehind parse-tree)))
+    (setf (slot-value regex 'positivep) nil)
+    regex))
+
+(defmethod convert-compound-parse-tree ((token (eql :greedy-repetition)) parse-tree &key (greedyp t))
+  "The case for \(:GREEDY-REPETITION|:NON-GREEDY-REPETITION <min> <max> <regex>).
+
+This function is also used for the non-greedy case in which case it is
+called with GREEDYP set to NIL as you would expect."
+  (declare #.*standard-optimize-settings*)
+  (declare (special accumulate-start-p starts-with))
+  ;; remember the value of ACCUMULATE-START-P upon entering
+  (let ((local-accumulate-start-p accumulate-start-p))
+    (let ((minimum (second parse-tree))
+          (maximum (third parse-tree)))
+      (declare (fixnum minimum))
+      (declare (type (or null fixnum) maximum))
+      (unless (and maximum
+                   (= 1 minimum maximum))
+        ;; set ACCUMULATE-START-P to NIL for the rest of
+        ;; the conversion because we can't continue to
+        ;; accumulate inside as well as after a proper
+        ;; repetition
+        (setq accumulate-start-p nil))
+      (let* (reg-seen
+             (regex (convert-aux (fourth parse-tree)))
+             (min-len (regex-min-length regex))
+             (length (regex-length regex)))
+        ;; note that this declaration already applies to
+        ;; the call to CONVERT-AUX above
+        (declare (special reg-seen))
+        (when (and local-accumulate-start-p
+                   (not starts-with)
+                   (zerop minimum)
+                   (not maximum))
+          ;; if this repetition is (equivalent to) ".*"
+          ;; and if we're at the start of the regex we
+          ;; remember it for ADVANCE-FN (see the SCAN
+          ;; function)
+          (setq starts-with (everythingp regex)))
+        (if (or (not reg-seen)
+                (not greedyp)
+                (not length)
+                (zerop length)
+                (and maximum (= minimum maximum)))
+          ;; the repetition doesn't enclose a register, or
+          ;; it's not greedy, or we can't determine it's
+          ;; (inner) length, or the length is zero, or the
+          ;; number of repetitions is fixed; in all of
+          ;; these cases we don't bother to optimize
+          (maybe-split-repetition regex
+                                  greedyp
+                                  minimum
+                                  maximum
+                                  min-len
+                                  length
+                                  reg-seen)
+          ;; otherwise we make a transformation that looks
+          ;; roughly like one of
+          ;;   <regex>* -> (?:<regex'>*<regex>)?
+          ;;   <regex>+ -> <regex'>*<regex>
+          ;; where the trick is that as much as possible
+          ;; registers from <regex> are removed in
+          ;; <regex'>
+          (let* (reg-seen ; new instance for REMOVE-REGISTERS
+                 (remove-registers-p t)
+                 (inner-regex (remove-registers regex))
+                 (inner-repetition
+                  ;; this is the "<regex'>" part
+                  (maybe-split-repetition inner-regex
+                                          ;; always greedy
+                                          t
+                                          ;; reduce minimum by 1
+                                          ;; unless it's already 0
+                                          (if (zerop minimum)
+                                            0
+                                            (1- minimum))
+                                          ;; reduce maximum by 1
+                                          ;; unless it's NIL
+                                          (and maximum
+                                               (1- maximum))
+                                          min-len
+                                          length
+                                          reg-seen))
+                 (inner-seq
+                  ;; this is the "<regex'>*<regex>" part
+                  (make-instance 'seq
+                                 :elements (list inner-repetition
+                                                 regex))))
+            ;; note that this declaration already applies
+            ;; to the call to REMOVE-REGISTERS above
+            (declare (special remove-registers-p reg-seen))
+            ;; wrap INNER-SEQ with a greedy
+            ;; {0,1}-repetition (i.e. "?") if necessary
+            (if (plusp minimum)
+              inner-seq
+              (maybe-split-repetition inner-seq
+                                      t
+                                      0
+                                      1
+                                      min-len
+                                      nil
+                                      t))))))))
+
+(defmethod convert-compound-parse-tree ((token (eql :non-greedy-repetition)) parse-tree &key)
+  "The case for \(:NON-GREEDY-REPETITION <min> <max> <regex>)."
+  (declare #.*standard-optimize-settings*)
+  ;; just dispatch to the method above with GREEDYP explicitly set to NIL
+  (convert-compound-parse-tree :greedy-repetition parse-tree :greedyp nil))
+
+(defmethod convert-compound-parse-tree ((token (eql :register)) parse-tree &key name)
+  "The case for \(:REGISTER <regex>).  Also used for named registers
+when NAME is not NIL."
+  (declare #.*standard-optimize-settings*)
+  (declare (special flags reg-num reg-names))
+  ;; keep the effect of modifiers local to the enclosed regex; also,
+  ;; assign the current value of REG-NUM to the corresponding slot of
+  ;; the REGISTER object and increase this counter afterwards; for
+  ;; named register update REG-NAMES and set the corresponding name
+  ;; slot of the REGISTER object too
+  (let ((flags (copy-list flags))
+        (stored-reg-num reg-num))
+    (declare (special flags reg-seen named-reg-seen))
+    (setq reg-seen t)
+    (when name (setq named-reg-seen t))
+    (incf (the fixnum reg-num))
+    (push name reg-names)
+    (make-instance 'register
+                   :regex (convert-aux (if name (third parse-tree) (second parse-tree)))
+                   :num stored-reg-num
+                   :name name)))
+
+(defmethod convert-compound-parse-tree ((token (eql :named-register)) parse-tree &key)
+  "The case for \(:NAMED-REGISTER <regex>)."
+  (declare #.*standard-optimize-settings*)
+  ;; call the method above and use the :NAME keyword argument
+  (convert-compound-parse-tree :register parse-tree :name (copy-seq (second parse-tree))))
+
+(defmethod convert-compound-parse-tree ((token (eql :filter)) parse-tree &key)
+  "The case for \(:FILTER <function> &optional <length>)."
+  (declare #.*standard-optimize-settings*)
+  (declare (special accumulate-start-p))
+  ;; stop accumulating into STARTS-WITH
+  (setq accumulate-start-p nil)
+  (make-instance 'filter
+                 :fn (second parse-tree)
+                 :len (third parse-tree)))
+
+(defmethod convert-compound-parse-tree ((token (eql :standalone)) parse-tree &key)
+  "The case for \(:STANDALONE <regex>)."
+  (declare #.*standard-optimize-settings*)
+  (declare (special flags accumulate-start-p))
+  ;; stop accumulating into STARTS-WITH
+  (setq accumulate-start-p nil)
+  ;; keep the effect of modifiers local to the enclosed regex
+  (let ((flags (copy-list flags)))
+    (declare (special flags))
+    (make-instance 'standalone :regex (convert-aux (second parse-tree)))))
+
+(defmethod convert-compound-parse-tree ((token (eql :back-reference)) parse-tree &key)
+  "The case for \(:BACK-REFERENCE <number>|<name>)."
+  (declare #.*standard-optimize-settings*)
+  (declare (special flags accumulate-start-p reg-num reg-names max-back-ref))
+  (let* ((backref-name (and (stringp (second parse-tree))
+                            (second parse-tree)))
+         (referred-regs
+          (when backref-name
+            ;; find which register corresponds to the given name
+            ;; we have to deal with case where several registers share
+            ;; the same name and collect their respective numbers
+            (loop for name in reg-names
+                  for reg-index from 0
+                  when (string= name backref-name)
+                  ;; NOTE: REG-NAMES stores register names in reversed
+                  ;; order REG-NUM contains number of (any) registers
+                  ;; seen so far; 1- will be done later
+                  collect (- reg-num reg-index))))
+         ;; store the register number for the simple case
+         (backref-number (or (first referred-regs) (second parse-tree))))
+    (declare (type (or fixnum null) backref-number))
+    (when (or (not (typep backref-number 'fixnum))
+              (<= backref-number 0))
+      (signal-syntax-error "Illegal back-reference: ~S." parse-tree))
+    ;; stop accumulating into STARTS-WITH and increase MAX-BACK-REF if
+    ;; necessary
+    (setq accumulate-start-p nil
+          max-back-ref (max (the fixnum max-back-ref)
+                            backref-number))
+    (flet ((make-back-ref (backref-number)
+             (make-instance 'back-reference
+                            ;; we start counting from 0 internally
+                            :num (1- backref-number)
+                            :case-insensitive-p (case-insensitive-mode-p flags)
+                            ;; backref-name is NIL or string, safe to copy
+                            :name (copy-seq backref-name))))
+      (cond
+       ((cdr referred-regs)
+        ;; several registers share the same name we will try to match
+        ;; any of them, starting with the most recent first
+        ;; alternation is used to accomplish matching
+        (make-instance 'alternation
+                       :choices (loop
+                                 for reg-index in referred-regs
+                                 collect (make-back-ref reg-index))))
+       ;; simple case - backref corresponds to only one register
+       (t
+        (make-back-ref backref-number))))))
+
+(defmethod convert-compound-parse-tree ((token (eql :regex)) parse-tree &key)
+  "The case for \(:REGEX <string>)."
+  (declare #.*standard-optimize-settings*)
+  (convert-aux (parse-string (second parse-tree))))
+
+(defmethod convert-compound-parse-tree ((token (eql :char-class)) parse-tree &key invertedp)
+  "The case for \(:CHAR-CLASS {<item>}*) where item is one of
+
+- a character,
+- a character range: \(:RANGE <char1> <char2>), or
+- a special char class symbol like :DIGIT-CHAR-CLASS.
+
+Also used for inverted char classes when INVERTEDP is true."
+  (declare #.*standard-optimize-settings*)
+  (declare (special flags accumulate-start-p))
+  (let ((test-function
+         (create-optimized-test-function
+          (convert-char-class-to-test-function (rest parse-tree)
+                                               invertedp
+                                               (case-insensitive-mode-p flags)))))
+    (setq accumulate-start-p nil)
+    (make-instance 'char-class :test-function test-function)))
+
+(defmethod convert-compound-parse-tree ((token (eql :inverted-char-class)) parse-tree &key)
+  "The case for \(:INVERTED-CHAR-CLASS {<item>}*)."
+  (declare #.*standard-optimize-settings*)
+  ;; just dispatch to the "real" method
+  (convert-compound-parse-tree :char-class parse-tree :invertedp t))
+
+(defmethod convert-compound-parse-tree ((token (eql :property)) parse-tree &key)
+  "The case for \(:PROPERTY <name>) where <name> is a string."
+  (declare #.*standard-optimize-settings*)
+  (declare (special accumulate-start-p))
+  (setq accumulate-start-p nil)
+  (make-instance 'char-class :test-function (resolve-property (second parse-tree))))
+
+(defmethod convert-compound-parse-tree ((token (eql :inverted-property)) parse-tree &key)
+  "The case for \(:INVERTED-PROPERTY <name>) where <name> is a string."
+  (declare #.*standard-optimize-settings*)
+  (declare (special accumulate-start-p))
+  (setq accumulate-start-p nil)
+  (make-instance 'char-class :test-function (complement* (resolve-property (second parse-tree)))))
+
+(defmethod convert-compound-parse-tree ((token (eql :flags)) parse-tree &key)
+  "The case for \(:FLAGS {<flag>}*) where flag is a modifier symbol
+like :CASE-INSENSITIVE-P."
+  (declare #.*standard-optimize-settings*)
+  ;; set/unset the flags corresponding to the symbols
+  ;; following :FLAGS
+  (mapc #'set-flag (rest parse-tree))
+  ;; we're only interested in the side effect of
+  ;; setting/unsetting the flags and turn this syntactical
+  ;; construct into a VOID object which'll be optimized
+  ;; away when creating the matcher
+  (make-instance 'void))
+
+(defgeneric convert-simple-parse-tree (parse-tree)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Helper function for CONVERT-AUX which converts
+parse trees which are atoms.")
+  (:method ((parse-tree (eql :void)))
+   (declare #.*standard-optimize-settings*)
+   (make-instance 'void))
+  (:method ((parse-tree (eql :word-boundary)))
+   (declare #.*standard-optimize-settings*)
+   (make-instance 'word-boundary :negatedp nil))
+  (:method ((parse-tree (eql :non-word-boundary)))
+   (declare #.*standard-optimize-settings*)
+   (make-instance 'word-boundary :negatedp t))
+  (:method ((parse-tree (eql :everything)))
+   (declare #.*standard-optimize-settings*)
+   (declare (special flags accumulate-start-p))
+   (setq accumulate-start-p nil)
+   (make-instance 'everything :single-line-p (single-line-mode-p flags)))
+  (:method ((parse-tree (eql :digit-class)))
+   (declare #.*standard-optimize-settings*)
+   (declare (special accumulate-start-p))
+   (setq accumulate-start-p nil)
+   (make-instance 'char-class :test-function #'digit-char-p))
+  (:method ((parse-tree (eql :word-char-class)))
+   (declare #.*standard-optimize-settings*)
+   (declare (special accumulate-start-p))
+   (setq accumulate-start-p nil)
+   (make-instance 'char-class :test-function #'word-char-p))
+  (:method ((parse-tree (eql :whitespace-char-class)))
+   (declare #.*standard-optimize-settings*)
+   (declare (special accumulate-start-p))
+   (setq accumulate-start-p nil)
+   (make-instance 'char-class :test-function #'whitespacep))
+  (:method ((parse-tree (eql :non-digit-class)))
+   (declare #.*standard-optimize-settings*)
+   (declare (special accumulate-start-p))
+   (setq accumulate-start-p nil)
+   (make-instance 'char-class :test-function (complement* #'digit-char-p)))
+  (:method ((parse-tree (eql :non-word-char-class)))
+   (declare #.*standard-optimize-settings*)
+   (declare (special accumulate-start-p))
+   (setq accumulate-start-p nil)
+   (make-instance 'char-class :test-function (complement* #'word-char-p)))
+  (:method ((parse-tree (eql :non-whitespace-char-class)))
+   (declare #.*standard-optimize-settings*)
+   (declare (special accumulate-start-p))
+   (setq accumulate-start-p nil)
+   (make-instance 'char-class :test-function (complement* #'whitespacep)))
+  (:method ((parse-tree (eql :start-anchor)))
+   ;; Perl's "^"
+   (declare #.*standard-optimize-settings*)
+   (declare (special flags))
+   (make-instance 'anchor :startp t :multi-line-p (multi-line-mode-p flags)))
+  (:method ((parse-tree (eql :end-anchor)))
+   ;; Perl's "$"
+   (declare #.*standard-optimize-settings*)
+   (declare (special flags))
+   (make-instance 'anchor :startp nil :multi-line-p (multi-line-mode-p flags)))
+  (:method ((parse-tree (eql :modeless-start-anchor)))
+   ;; Perl's "\A"
+   (declare #.*standard-optimize-settings*)
+   (make-instance 'anchor :startp t))
+  (:method ((parse-tree (eql :modeless-end-anchor)))
+   ;; Perl's "$\Z"
+   (declare #.*standard-optimize-settings*)
+   (make-instance 'anchor :startp nil))
+  (:method ((parse-tree (eql :modeless-end-anchor-no-newline)))
+   ;; Perl's "$\z"
+   (declare #.*standard-optimize-settings*)
+   (make-instance 'anchor :startp nil :no-newline-p t))
+  (:method ((parse-tree (eql :case-insensitive-p)))
+   (declare #.*standard-optimize-settings*)
+   (set-flag parse-tree)
+   (make-instance 'void))
+  (:method ((parse-tree (eql :case-sensitive-p)))
+   (declare #.*standard-optimize-settings*)
+   (set-flag parse-tree)
+   (make-instance 'void))
+  (:method ((parse-tree (eql :multi-line-mode-p)))
+   (declare #.*standard-optimize-settings*)
+   (set-flag parse-tree)
+   (make-instance 'void))
+  (:method ((parse-tree (eql :not-multi-line-mode-p)))
+   (declare #.*standard-optimize-settings*)
+   (set-flag parse-tree)
+   (make-instance 'void))
+  (:method ((parse-tree (eql :single-line-mode-p)))
+   (declare #.*standard-optimize-settings*)
+   (set-flag parse-tree)
+   (make-instance 'void))
+  (:method ((parse-tree (eql :not-single-line-mode-p)))
+   (declare #.*standard-optimize-settings*)
+   (set-flag parse-tree)
+   (make-instance 'void)))
+
+(defmethod convert-simple-parse-tree ((parse-tree string))
+  (declare #.*standard-optimize-settings*)
+  (declare (special flags))
+  ;; turn strings into STR objects and try to accumulate into
+  ;; STARTS-WITH
+  (let ((str (make-instance 'str
+                            :str parse-tree
+                            :case-insensitive-p (case-insensitive-mode-p flags))))
+    (maybe-accumulate str)
+    str))
+
+(defmethod convert-simple-parse-tree ((parse-tree character))
+  (declare #.*standard-optimize-settings*)
+  ;; dispatch to the method for strings
+  (convert-simple-parse-tree (string parse-tree)))
+        
+(defmethod convert-simple-parse-tree (parse-tree)
+  "The default method - check if there's a translation."
+  (declare #.*standard-optimize-settings*)
+  (let ((translation (and (symbolp parse-tree) (parse-tree-synonym parse-tree))))
+    (if translation
+      (convert-aux (copy-tree translation))
+      (signal-syntax-error "Unknown token ~A in parse tree." parse-tree))))
+
+(defun convert (parse-tree)
+  "Converts the parse tree PARSE-TREE into an equivalent REGEX object
+and returns three values: the REGEX object, the number of registers
+seen and an object the regex starts with which is either a STR object
+or an EVERYTHING object \(if the regex starts with something like
+\".*\") or NIL."
+  (declare #.*standard-optimize-settings*)
+  ;; this function basically just initializes the special variables
+  ;; and then calls CONVERT-AUX to do all the work
+  (let* ((flags (list nil nil nil))
+         (reg-num 0)
+         reg-names
+         named-reg-seen
+         (accumulate-start-p t)
+         starts-with
+         (max-back-ref 0)
+         (converted-parse-tree (convert-aux parse-tree)))
+    (declare (special flags reg-num reg-names named-reg-seen
+                      accumulate-start-p starts-with max-back-ref))
+    ;; make sure we don't reference registers which aren't there
+    (when (> (the fixnum max-back-ref)
+             (the fixnum reg-num))
+      (signal-syntax-error "Backreference to register ~A which has not been defined." max-back-ref))
+    (when (typep starts-with 'str)
+      (setf (slot-value starts-with 'str)
+              (coerce (slot-value starts-with 'str)
+                      #+:lispworks 'lw:simple-text-string
+                      #-:lispworks 'simple-string)))
+    (values converted-parse-tree reg-num starts-with
+            ;; we can't simply use *ALLOW-NAMED-REGISTERS*
+            ;; since parse-tree syntax ignores it
+            (when named-reg-seen
+              (nreverse reg-names)))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/docs/index.html b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/docs/index.html
new file mode 100644
index 0000000..6da6a15
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/docs/index.html
@@ -0,0 +1,2231 @@
+<html>
+
+<head>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+  <title>CL-PPCRE - Portable Perl-compatible regular expressions for Common Lisp</title>
+  <style type="text/css">
+  pre { padding:5px; background-color:#e0e0e0 }
+  h3, h4 { text-decoration: underline; }
+  a { text-decoration: none; padding: 1px 2px 1px 2px; }
+  a:visited { text-decoration: none; padding: 1px 2px 1px 2px; }
+  a:hover { text-decoration: none; padding: 1px 1px 1px 1px; border: 1px solid #000000; }
+  a:focus { text-decoration: none; padding: 1px 2px 1px 2px; border: none; }
+  a.none { text-decoration: none; padding: 0; }
+  a.none:visited { text-decoration: none; padding: 0; }
+  a.none:hover { text-decoration: none; border: none; padding: 0; }
+  a.none:focus { text-decoration: none; border: none; padding: 0; }
+  a.noborder { text-decoration: none; padding: 0; }
+  a.noborder:visited { text-decoration: none; padding: 0; }
+  a.noborder:hover { text-decoration: none; border: none; padding: 0; }
+  a.noborder:focus { text-decoration: none; border: none; padding: 0; }
+  pre.none { padding:5px; background-color:#ffffff }
+  </style>
+  <meta name="description" content="Fast and portable perl-compatible regular expressions for Common Lisp.">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+</head>
+
+<body bgcolor=white>
+
+<h2>CL-PPCRE - Portable Perl-compatible regular expressions for Common Lisp</h2>
+
+<blockquote>
+<br>&nbsp;<br><h3>Abstract</h3>
+
+CL-PPCRE is a portable regular expression library for Common Lisp
+which has the following features:
+
+<ul>
+
+<li>It is <b>compatible with Perl</b>.
+
+<li>It is pretty <b>fast</b>.
+
+<li>It is <b>portable</b> between ANSI-compliant Common Lisp
+implementations.
+
+<li>It is <b>thread-safe</b>.
+
+<li>In addition to specifying regular expressions as strings like in
+Perl you can also use <a
+href="#create-scanner2"><b>S-expressions</b></a>.
+
+<li>It comes with a <a
+href="http://www.opensource.org/licenses/bsd-license.php"><b>BSD-style
+license</b></a> so you can basically do with it whatever you want.
+
+</ul>
+
+CL-PPCRE has been used successfully in various applications like <a
+href="http://nostoc.stanford.edu/Docs/">BioBike</a>,
+<a href="http://clutu.com/">clutu</a>,
+<a
+href="http://www.hpc.unm.edu/~download/LoGS/">LoGS</a>, <a href="http://cafespot.net/">CafeSpot</a>, <a href="http://www.eboy.com/">Eboy</a>, or <a
+href="http://weitz.de/regex-coach/">The Regex Coach</a>.
+
+<p>
+<font color=red><a href="https://github.com/edicl/cl-ppcre/releases/latest">Download current version</a></font> or visit the <a href="https://github.com/edicl/cl-ppcre/">project on Github</a>.
+
+</blockquote>
+
+<br>&nbsp;<br><h3><a class=none name="contents">Contents</a></h3>
+<ol>
+  <li><a href="#install">Download and installation</a>
+  <li><a href="#support">Support</a>
+  <li><a href="#dict">The CL-PPCRE dictionary</a>
+  <ol>
+    <li><a href="#scanning">Scanning</a>
+    <ol>
+      <li><a href="#create-scanner"><code>create-scanner</code></a> (for Perl regex strings)
+      <li><a href="#create-scanner2"><code>create-scanner</code></a> (for parse trees)
+      <li><a href="#scan"><code>scan</code></a>
+      <li><a href="#scan-to-strings"><code>scan-to-strings</code></a>
+      <li><a href="#register-groups-bind"><code>register-groups-bind</code></a>
+      <li><a href="#do-scans"><code>do-scans</code></a>
+      <li><a href="#do-matches"><code>do-matches</code></a>
+      <li><a href="#do-matches-as-strings"><code>do-matches-as-strings</code></a>
+      <li><a href="#do-register-groups"><code>do-register-groups</code></a>
+      <li><a href="#all-matches"><code>all-matches</code></a>
+      <li><a href="#all-matches-as-strings"><code>all-matches-as-strings</code></a>
+    </ol>
+    <li><a href="#splitting">Splitting and replacing</a>
+    <ol>
+      <li><a href="#split"><code>split</code></a>
+      <li><a href="#regex-replace"><code>regex-replace</code></a>
+      <li><a href="#regex-replace-all"><code>regex-replace-all</code></a>
+    </ol>
+    <li><a href="#modify">Modifying scanner behaviour</a>
+    <ol>
+      <li><a href="#*property-resolver*"><code>*property-resolver*</code></a>
+      <li><a href="#parse-tree-synonym"><code>parse-tree-synonym</code></a>
+      <li><a href="#define-parse-tree-synonym"><code>define-parse-tree-synonym</code></a>
+      <li><a href="#*regex-char-code-limit*"><code>*regex-char-code-limit*</code></a>
+      <li><a href="#*use-bmh-matchers*"><code>*use-bmh-matchers*</code></a>
+      <li><a href="#*optimize-char-classes*"><code>*optimize-char-classes*</code></a>
+      <li><a href="#*allow-quoting*"><code>*allow-quoting*</code></a>
+      <li><a href="#*allow-named-registers*"><code>*allow-named-registers*</code></a>
+      <li><a href="#*look-ahead-for-suffix*"><code>*look-ahead-for-suffix*</code></a>
+    </ol>
+    <li><a href="#misc">Miscellaneous</a>
+    <ol>
+      <li><a href="#parse-string"><code>parse-string</code></a>
+      <li><a href="#create-optimized-test-function"><code>create-optimized-test-function</code></a>
+      <li><a href="#quote-meta-chars"><code>quote-meta-chars</code></a>
+      <li><a href="#regex-apropos"><code>regex-apropos</code></a>
+      <li><a href="#regex-apropos-list"><code>regex-apropos-list</code></a>
+    </ol>
+    <li><a href="#conditions">Conditions</a>
+    <ol>
+      <li><a href="#ppcre-error"><code>ppcre-error</code></a>
+      <li><a href="#ppcre-invocation-error"><code>ppcre-invocation-error</code></a>
+      <li><a href="#ppcre-syntax-error"><code>ppcre-syntax-error</code></a>
+      <li><a href="#ppcre-syntax-error-string"><code>ppcre-syntax-error-string</code></a>
+      <li><a href="#ppcre-syntax-error-pos"><code>ppcre-syntax-error-pos</code></a>
+    </ol>
+  </ol>
+  <li><a href="#unicode">Unicode properties</a>
+  <ol>
+      <li><a href="#unicode-property-resolver"><code>unicode-property-resolver</code></a>
+  </ol>
+  <li><a href="#filters">Filters</a>
+  <li><a href="#perl">Compatibility with Perl</a>
+    <ol>
+      <li><a href="#empty">Empty strings instead of <code>undef</code> in <code>$1</code>, <code>$2</code>, etc.</a>
+      <li><a href="#scope">Strange scoping of embedded modifiers</a>
+      <li><a href="#inconsistent">Inconsistent capturing of <code>$1</code>, <code>$2</code>, etc.</a>
+      <li><a href="#lookaround">Captured groups not available outside of look-aheads and look-behinds</a>
+      <li><a href="#order">Alternations don't always work from left to right</a>
+      <li><a href="#uprops">Different names for Unicode properties</a>
+      <li><a href="#mac"><code>&quot;\r&quot;</code> doesn't work with MCL</a>
+      <li><a href="#alpha">What about <code>&quot;\w&quot;</code>?</a>
+    </ol>
+  <li><a href="#bugs">Bugs and problems</a>
+  <ol>
+    <li><a href="#quote"><code>&quot;\Q&quot;</code> doesn't work, or does it?</a>
+    <li><a href="#backslash">Backslashes may confuse you...</a>
+  </ol>
+  <li><a href="#allegro">AllegroCL compatibility mode</a>
+  <li><a href="#blabla">Hints, comments, performance considerations</a>
+  <li><a href="#ack">Acknowledgements</a>
+</ol>
+
+<br>&nbsp;<br><h3><a name="install" class=none>Download and installation</a></h3>
+
+CL-PPCRE together with this documentation can be downloaded from <a
+href="https://github.com/edicl/cl-ppcre/archive/master.zip">Github</a>. The
+current version is 2.0.11.
+<p>
+CL-PPCRE comes with a system definition
+for <a href="http://www.cliki.net/asdf">ASDF</a> and you compile and
+load it in the usual way.  There are no dependencies (except that the
+<a href="#test">test suite</a> which is not needed for normal operation depends
+on <a href="https://github.com/edicl/flexi-streams/">FLEXI-STREAMS</a>).
+<p>
+  The preferred way to install CL-PPCRE is
+through <a href="http://www.quicklisp.org/" target="_new">Quicklisp</a>:
+  <pre>(ql:quickload :cl-ppcre)</pre>
+</p>
+<p>
+<a class=none name="test">You</a> can run a test suite which tests most aspects of the library with
+<pre>
+(asdf:oos 'asdf:test-op :cl-ppcre)
+</pre>
+<p>
+The current development version of CL-PPCRE can be found
+at <a href="https://github.com/edicl/cl-ppcre">https://github.com/edicl/cl-ppcre</a>. If you want to send patches, please fork the github repository and send pull requests.
+<p>
+
+<br>&nbsp;<br><h3><a name="support" class=none>Support</a></h3>
+
+The development version of cl-ppcre can be
+found <a href="https://github.com/edicl/cl-ppcre" target="_new">on
+github</a>.  Please use the github issue tracking system to submit bug
+reports.  Patches are welcome, please
+use <a href="https://github.com/edicl/cl-ppcre/pulls">GitHub pull
+requests</a>.  If you want to make a change,
+please <a href="http://weitz.de/patches.html" target="_new">read this
+first</a>.
+
+<br>&nbsp;<br><h3><a class=none name="dict">The CL-PPCRE dictionary</a></h3>
+
+<h4><a name="scanning" class=none>Scanning</a></h4>
+
+<p><br>[Method]
+<br><a class=none name="create-scanner"><b>create-scanner</b> <i>(string string)<tt>&amp;key</tt> case-insensitive-mode multi-line-mode single-line-mode extended-mode destructive</i> =&gt; <i>scanner, register-names</i></a>
+
+<blockquote><br> Accepts a string which is a regular expression in
+Perl syntax and returns a closure which will scan strings for this
+regular expression. The second value is only returned if <a href="#*allow-named-registers*"><code>*ALLOW-NAMED-REGISTERS*</code></a> is <i>true</i>. It represents a list of strings mapping registers to their respective names - the first element stands for first register, the second element for second register, etc. You have to store this value if you want to map a register number to its name later as <i>scanner</i> doesn't capture any information about register names. If a register isn't named, it has NIL as its name.
+<p>
+The mode keyword arguments are equivalent to the
+<code>&quot;imsx&quot;</code> modifiers in Perl. The
+<code>destructive</code> keyword will be ignored.
+<p>
+The function accepts most of the regex syntax of Perl 5.8 as described
+in <a href="http://perldoc.perl.org/5.8.8/perlre.html"><code>man
+perlre</code></a> including extended features like non-greedy
+repetitions, positive and negative look-ahead and look-behind
+assertions, &quot;standalone&quot; subexpressions, and conditional
+subpatterns. The following Perl features are (currently) <b>not</b>
+supported:
+
+<ul>
+
+<li><code>(?{ code })</code> and <code>(??{ code })</code> because
+they obviously don't make sense in Lisp.
+
+<li><code>\N{name}</code> (named characters), <code>\x{263a}</code>
+(wide hex characters), <code>\l</code>, <code>\u</code>,
+<code>\L</code>, and <code>\U</code>
+because they're actually not part of Perl's <em>regex</em> syntax - but see <a href="https://github.com/edicl/cl-interpol/">CL-INTERPOL</a>.
+
+<li><code>\X</code> (extended Unicode), and <code>\C</code> (single
+character). But you can of course use all characters
+supported by your CL implementation.
+
+<li>Posix character classes like <code>[[:alpha]]</code>.
+Use <a href="#unicode">Unicode properties</a> instead.
+
+<li><code>\G</code> for Perl's <code>pos()</code> because we don't have it.
+
+</ul>
+
+Note, however, that <code>\t</code>, <code>\n</code>, <code>\r</code>,
+<code>\f</code>, <code>\a</code>, <code>\e</code>, <code>\033</code>
+(octal character codes), <code>\x1B</code> (hexadecimal character
+codes), <code>\c[</code> (control characters), <code>\w</code>,
+<code>\W</code>, <code>\s</code>, <code>\S</code>, <code>\d</code>,
+<code>\D</code>, <code>\b</code>, <code>\B</code>, <code>\A</code>,
+<code>\Z</code>, and <code>\z</code> <b>are</b> supported.
+<p>
+Since version 0.6.0, CL-PPCRE also supports Perl's <code>\Q</code> and <code>\E</code> - see <a
+href="#*allow-quoting*"><code>*ALLOW-QUOTING*</code></a> below. Make sure you also read <a href="#quote">the relevant section</a> in &quot;<a href="#bugs">Bugs and problems</a>.&quot;
+<p>
+Since version 1.3.0, CL-PPCRE offers support for <a href="http://www.franz.com/support/documentation/7.0/doc/regexp.htm#regexp-new-capturing-2">AllegroCL's</a> <code>(?&lt;name&gt;"&lt;regex&gt;")</code>  named registers and <code>\k&lt;name&gt;</code> back-references syntax, have a look at <a href="#*allow-named-registers*"><code>*ALLOW-NAMED-REGISTERS*</code></a> for details.
+<p>
+Since version 2.0.0, CL-PPCRE
+supports <a href="#*property-resolver*">named properties</a>
+(<code>\p</code> and <code>\P</code>), but only the long form with
+braces is supported, i.e. <code>\p{Letter}</code>
+and <code>\p{L}</code> will work while <code>\pL</code> won't.
+<p>
+The keyword arguments are just for your
+convenience. You can always use embedded modifiers like
+<code>&quot;(?i-s)&quot;</code> instead.</blockquote>
+
+<p><br>[Method]
+<br><a class=none name="create-scanner"><b>create-scanner</b> <i>(function function)<tt>&amp;key</tt> case-insensitive-mode multi-line-mode single-line-mode extended-mode destructive</i> =&gt; <i>scanner</i></a>
+<blockquote><br> In this case <code><i>function</i></code> should be a
+scanner returned by another invocation
+of <code>CREATE-SCANNER</code>. It will be returned as is.  You can't
+use any of the keyword arguments because the scanner has already been
+created and is immutable.
+</blockquote>
+
+<p><br>[Method]
+<br><a class=none name="create-scanner2"><b>create-scanner</b> <i>(parse-tree t)<tt>&amp;key</tt> case-insensitive-mode multi-line-mode single-line-mode extended-mode destructive</i> =&gt; <i>scanner, register-names</i></a>
+<blockquote><br>
+This is similar to <a
+href="#create-scanner"><code>CREATE-SCANNER</code></a> for regex strings above but
+accepts a <em>parse tree</em> as its first argument. A parse tree is an S-expression
+conforming to the following syntax:
+
+<ul>
+
+<li>Every string and character is a parse tree and is treated
+<em>literally</em> as a part of the regular expression,
+i.e. parentheses, brackets, asterisks and such aren't special.
+
+<li>The symbol <code>:VOID</code> is equivalent to the empty string.
+
+<li>The symbol <code>:EVERYTHING</code> is equivalent to Perl's dot,
+i.e it matches everything (except maybe a newline character depending
+on the mode).
+
+<li>The symbols <code>:WORD-BOUNDARY</code> and
+<code>:NON-WORD-BOUNDARY</code> are equivalent to Perl's
+<code>&quot;\b&quot;</code> and <code>&quot;\B&quot;</code>.
+
+<li>The symbols <code>:DIGIT-CLASS</code>,
+<code>:NON-DIGIT-CLASS</code>, <code>:WORD-CHAR-CLASS</code>,
+<code>:NON-WORD-CHAR-CLASS</code>,
+<code>:WHITESPACE-CHAR-CLASS</code>, and
+<code>:NON-WHITESPACE-CHAR-CLASS</code> are equivalent to Perl's
+<em>special character classes</em> <code>&quot;\d&quot;</code>,
+<code>&quot;\D&quot;</code>, <code>&quot;\w&quot;</code>,
+<code>&quot;\W&quot;</code>, <code>&quot;\s&quot;</code>, and
+<code>&quot;\S&quot;</code> respectively.
+
+<li>The symbols <code>:START-ANCHOR</code>, <code>:END-ANCHOR</code>,
+<code>:MODELESS-START-ANCHOR</code>,
+<code>:MODELESS-END-ANCHOR</code>, and
+<code>:MODELESS-END-ANCHOR-NO-NEWLINE</code> are equivalent to Perl's
+<code>&quot;^&quot;</code>, <code>&quot;$&quot;</code>,
+<code>&quot;\A&quot;</code>, <code>&quot;\Z&quot;</code>, and
+<code>&quot;\z&quot;</code> respectively.
+
+<li>The symbols <code>:CASE-INSENSITIVE-P</code>,
+<code>:CASE-SENSITIVE-P</code>, <code>:MULTI-LINE-MODE-P</code>,
+<code>:NOT-MULTI-LINE-MODE-P</code>, <code>:SINGLE-LINE-MODE-P</code>,
+and <code>:NOT-SINGLE-LINE-MODE-P</code> are equivalent to Perl's
+<em>embedded modifiers</em> <code>&quot;(?i)&quot;</code>,
+<code>&quot;(?-i)&quot;</code>, <code>&quot;(?m)&quot;</code>,
+<code>&quot;(?-m)&quot;</code>, <code>&quot;(?s)&quot;</code>, and
+<code>&quot;(?-s)&quot;</code>. As usual, changes applied to modes are
+kept local to the innermost enclosing grouping or clustering
+construct.
+
+</li><li>All other symbols will signal an error of type <a
+href="#ppcre-syntax-error"><code>PPCRE-SYNTAX-ERROR</code></a>
+<em>unless</em> they are defined to be <a
+href="#parse-tree-synonym"><em>parse tree synonyms</em></a>.
+
+<li><code>(:FLAGS {&lt;modifier&gt;}*)</code> where
+<code>&lt;modifier&gt;</code> is one of the modifier symbols from
+above is used to group modifier symbols. The modifiers are applied
+from left to right. (This construct is obviously redundant. It is only
+there because it's used by the parser.)
+
+<li><code>(:SEQUENCE {&lt;<i>parse-tree</i>&gt;}*)</code> means a
+sequence of parse trees, i.e. the parse trees must match one after
+another. Example: <code>(:SEQUENCE #\f #\o #\o)</code> is equivalent
+to the parse tree <code>&quot;foo&quot;</code>.
+
+<li><code>(:GROUP {&lt;<i>parse-tree</i>&gt;}*)</code> is like
+<code>:SEQUENCE</code> but changes applied to modifier flags (see
+above) are kept local to the parse trees enclosed by this
+construct. Think of it as the S-expression variant of Perl's
+<code>&quot;(?:&lt;<i>pattern</i>&gt;)&quot;</code> construct.
+
+<li><code>(:ALTERNATION {&lt;<i>parse-tree</i>&gt;}*)</code> means an
+alternation of parse trees, i.e. one of the parse trees must
+match. Example: <code>(:ALTERNATION #\b #\a #\z)</code> is equivalent
+to the Perl regex string <code>&quot;b|a|z&quot;</code>.
+
+<li><code>(:BRANCH &lt;<i>test</i>&gt;
+&lt;<i>parse-tree</i>&gt;)</code> is for conditional regular
+expressions. <code>&lt;<i>test</i>&gt;</code> is either a number which
+stands for a register or a parse tree which is a look-ahead or
+look-behind assertion. See the entry for
+<code>(?(&lt;<i>condition</i>&gt;)&lt;<i>yes-pattern</i>&gt;|&lt;<i>no-pattern</i>&gt;)</code>
+in <a
+href="http://perldoc.perl.org/perlre.html#Extended-Patterns"><code>man
+perlre</code></a> for the semantics of this construct. If
+<code>&lt;<i>parse-tree</i>&gt;</code> is an alternation is
+<em>must</em> enclose exactly one or two parse trees where the second
+one (if present) will be treated as the &quot;no-pattern&quot; - in
+all other cases <code>&lt;<i>parse-tree</i>&gt;</code> will be treated
+as the &quot;yes-pattern&quot;.
+
+<li><code>(:POSITIVE-LOOKAHEAD|:NEGATIVE-LOOKAHEAD|:POSITIVE-LOOKBEHIND|:NEGATIVE-LOOKBEHIND
+&lt;<i>parse-tree</i>&gt;)</code> should be pretty obvious...
+
+<li><code>(:GREEDY-REPETITION|:NON-GREEDY-REPETITION
+&lt;<i>min</i>&gt; &lt;<i>max</i>&gt;
+&lt;<i>parse-tree</i>&gt;)</code> where
+<code>&lt;<i>min</i>&gt;</code> is a non-negative integer and
+<code>&lt;<i>max</i>&gt;</code> is either a non-negative integer not
+smaller than <code>&lt;<i>min</i>&gt;</code> or <code>NIL</code> will
+result in a regular expression which tries to match
+<code>&lt;<i>parse-tree</i>&gt;</code> at least
+<code>&lt;<i>min</i>&gt;</code> times and at most
+<code>&lt;<i>max</i>&gt;</code> times (or as often as possible if
+<code>&lt;<i>max</i>&gt;</code> is <code>NIL</code>). So, e.g.,
+<code>(:NON-GREEDY-REPETITION 0 1 &quot;ab&quot;)</code> is equivalent
+to the Perl regex string <code>&quot;(?:ab)??&quot;</code>.
+
+<li><code>(:STANDALONE &lt;<i>parse-tree</i>&gt;)</code> is an
+&quot;independent&quot; subexpression, i.e. <code>(:STANDALONE
+&quot;bar&quot;)</code> is equivalent to the Perl regex string
+<code>&quot;(?>bar)&quot;</code>.
+
+<li><code>(:REGISTER &lt;<i>parse-tree</i>&gt;)</code> is a capturing
+register group. As usual, registers are counted from left to right
+beginning with 1.
+
+<li><code>(:NAMED-REGISTER &lt;<i>name</i>&gt; &lt;<i>parse-tree</i>&gt;)</code> is a named capturing
+register group. Acts as <code>:REGISTER</code>, but assigns <code>&lt;<i>name</i>&gt;</code> to a register too. This <code>&lt;<i>name</i>&gt;</code> can be later referred to via <code>:BACK-REFERENCE</code>. Names are case-sensitive and don't need to be unique. See <a href="#*allow-named-registers*"><code>*ALLOW-NAMED-REGISTERS*</code></a> for details.
+
+
+<li><code>(:BACK-REFERENCE &lt;<i>ref</i>&gt;)</code> is a
+back-reference to a register group. <code>&lt;<i>ref</i>&gt;</code> is
+a positive integer or a string denoting a register name. If there are
+several registers with the same name, the regex engine tries to
+successfully match at least of them, starting with the most recently
+seen register continuing to the least recently seen one, until a match
+is found. See <a
+href="#*allow-named-registers*"><code>*ALLOW-NAMED-REGISTERS*</code></a>
+for more information.
+
+<li><code>(:PROPERTY|:INVERTED-PROPERTY &lt;<i>property</i>&gt;)</code> is
+a <a href="#*property-resolver*">named property</a> (or its inverse) with
+<code>&lt;<i>property</i>&gt;</code> being a function designator or a
+string which must be resolved
+by <a href="#*property-resolver*"><code>*PROPERTY-RESOLVER*</code></a>.
+
+<li><a class=none name="filterdef"><code>(:FILTER &lt;<i>function</i>&gt; <tt>&amp;optional</tt>
+&lt;<i>length</i>&gt;)</code></a> where
+<code>&lt;<i>function</i>&gt;</code> is a <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_f.htm#function_designator">function
+designator</a> and <code>&lt;<i>length</i>&gt;</code> is a
+non-negative integer or <code>NIL</code> is a user-defined <a
+href="#filters">filter</a>.
+
+<li><code>(:REGEX &lt;<i>string</i>&gt;)</code> where
+<code>&lt;<i>string</i>&gt;</code> is an
+embedded <a href="#create-scanner">regular expression in Perl
+syntax</a>.
+
+<li><code>(:CHAR-CLASS|:INVERTED-CHAR-CLASS
+{&lt;<i>item</i>&gt;}*)</code> where <code>&lt;<i>item</i>&gt;</code>
+is either a character, a <em>character range</em>, a named property
+(see above), or a symbol for a special character class (see above)
+will be translated into a (one character wide) character
+class. A <em>character range</em> looks like
+<code>(:RANGE &lt;<i>char1</i>&gt; &lt;<i>char2</i>&gt;)</code> where
+<code>&lt;<i>char1</i>&gt;</code> and
+<code>&lt;<i>char2</i>&gt;</code> are characters such that
+<code>(CHAR&lt;= &lt;<i>char1</i>&gt; &lt;<i>char2</i>&gt;)</code> is
+true. Example: <code>(:INVERTED-CHAR-CLASS #\a (:RANGE #\D #\G)
+:DIGIT-CLASS)</code> is equivalent to the Perl regex string
+<code>&quot;[^aD-G\d]&quot;</code>.
+
+</ul>
+
+Because <code>CREATE-SCANNER</code> is defined as a generic function
+which dispatches on its first argument there's a certain ambiguity:
+Although strings are valid parse trees they will be interpreted as
+Perl regex strings when given to <code>CREATE-SCANNER</code>. To
+circumvent this you can always use the equivalent parse tree <code>(:GROUP
+&lt;<i>string</i>&gt;)</code> instead.
+<p>
+Note that <code>CREATE-SCANNER</code> doesn't always check
+for the well-formedness of its first argument, i.e. you are expected
+to provide <em>correct</em> parse trees.
+
+<p>
+The usage of the keyword argument <code>extended-mode</code> obviously
+doesn't make sense if <code>CREATE-SCANNER</code> is applied to parse
+trees and will signal an error.
+<p>
+If <code>destructive</code> is not <code>NIL</code> (the default is
+<code>NIL</code>), the function is allowed to destructively modify
+<code><i>parse-tree</i></code> while creating the scanner.
+<p>
+If you want to find out how parse trees are related to Perl regex
+strings, you should play around with
+<a href="#parse-string"><code>PARSE-STRING</code></a>:
+
+<pre>
+* (parse-string "(ab)*")
+(:GREEDY-REPETITION 0 NIL (:REGISTER "ab"))
+
+* (parse-string "(a(b))")
+(:REGISTER (:SEQUENCE #\a (:REGISTER #\b)))
+
+* (parse-string "(?:abc){3,5}")
+(:GREEDY-REPETITION 3 5 (:GROUP "abc"))
+<font color=orange>;; (:GREEDY-REPETITION 3 5 "abc") would also be OK</font>
+
+* (parse-string "a(?i)b(?-i)c")
+(:SEQUENCE #\a
+ (:SEQUENCE (:FLAGS :CASE-INSENSITIVE-P)
+  (:SEQUENCE #\b (:SEQUENCE (:FLAGS :CASE-SENSITIVE-P) #\c))))
+<font color=orange>;; same as (:SEQUENCE #\a :CASE-INSENSITIVE-P #\b :CASE-SENSITIVE-P #\c)</font>
+
+* (parse-string "(?=a)b")
+(:SEQUENCE (:POSITIVE-LOOKAHEAD #\a) #\b)
+</pre></blockquote>
+
+<p><br>
+<font color=green><b>For the rest of the dictionary, </b><code><i>regex</i></code><b> can
+always be a string (which is interpreted as a Perl regular
+expression), a parse tree, or a scanner created by
+<a href="#create-scanner"><font color=green><code>CREATE-SCANNER</code></font></a>.  The
+</b><code><i>start</i></code><b> and </b><code><i>end</i></code><b>
+keyword parameters are always used as in <a
+href="#scan"><font color=green><code>SCAN</code></font></a>.</b></font>
+
+
+
+
+<p><br>[Generic Function]
+<br><a class=none name="scan"><b>scan</b> <i>regex target-string <tt>&amp;key</tt> start end</i> =&gt; <i>match-start, match-end, reg-starts, reg-ends</i></a>
+
+<blockquote><br>
+Searches the string <code><i>target-string</i></code>
+from <code><i>start</i></code> (which defaults to 0) to
+<code><i>end</i></code> (which default to the length of
+<code><i>target-string</i></code>) and tries to match
+<code><i>regex</i></code>. On success returns four values - the start
+of the match, the end of the match, and two arrays denoting the
+beginnings and ends of register matches. On failure returns
+<code>NIL</code>.  <code><i>target-string</i></code> will be coerced
+to a simple string if it isn't one already. (There's another keyword
+parameter <code><i>real-start-pos</i></code>.  This one should
+<em>never</em> be set from user code - it is only used internally.)
+<p>
+<code>SCAN</code> acts as if the part of
+<code><i>target-string</i></code> between <code><i>start</i></code>
+and <code><i>end</i></code> were a standalone string, i.e. look-aheads
+and look-behinds can't look beyond these boundaries.
+<pre>
+* (scan "(a)*b" "xaaabd")
+1
+5
+#(3)
+#(4)
+
+* (scan "(a)*b" "xaaabd" :start 1)
+1
+5
+#(3)
+#(4)
+
+* (scan "(a)*b" "xaaabd" :start 2)
+2
+5
+#(3)
+#(4)
+
+* (scan "(a)*b" "xaaabd" :end 4)
+NIL
+
+* (scan '(:greedy-repetition 0 nil #\b) "bbbc")
+0
+3
+#()
+#()
+
+* (scan '(:greedy-repetition 4 6 #\b) "bbbc")
+NIL
+
+* (let ((s (create-scanner "(([a-c])+)x")))
+    (scan s "abcxy"))
+0
+4
+#(0 2)
+#(3 3)
+</pre></blockquote>
+
+
+
+<p><br>[Function]
+<br><a class=none name="scan-to-strings"><b>scan-to-strings</b> <i>regex target-string <tt>&amp;key</tt> start end sharedp</i> =&gt; <i>match, regs</i></a>
+
+<blockquote><br>
+Like <a href="#scan"><code>SCAN</code></a> but returns substrings of
+<code><i>target-string</i></code> instead of positions, i.e. this
+function returns two values on success: the whole match as a string
+plus an array of substrings (or <code>NIL</code>s) corresponding to
+the matched registers. If <code><i>sharedp</i></code> is true, the substrings may share structure with
+<code><i>target-string</i></code>.
+<pre>
+* (scan-to-strings "[^b]*b" "aaabd")
+"aaab"
+#()
+
+* (scan-to-strings "([^b])*b" "aaabd")
+"aaab"
+#("a")
+
+* (scan-to-strings "(([^b])*)b" "aaabd")
+"aaab"
+#("aaa" "a")
+</pre></blockquote>
+
+
+<p><br>[Macro]
+<br><a class=none name="register-groups-bind"><b>register-groups-bind</b> <i>var-list (regex target-string <tt>&amp;key</tt> start end sharedp) declaration* statement*</i> =&gt; <i>result*</i></a>
+
+<blockquote><br>
+Evaluates <code><i>statement*</i></code> with the variables in <code><i>var-list</i></code> bound to the
+corresponding register groups after <code><i>target-string</i></code> has been matched
+against <code><i>regex</i></code>, i.e. each variable is either
+bound to a string or to <code>NIL</code>.
+As a shortcut, the elements of <code><i>var-list</i></code> can also be lists of the form <code>(FN&nbsp;VAR)</code> where <code>VAR</code> is the variable symbol
+and <code>FN</code> is a <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_f.htm#function_designator">function
+designator</a> (which is evaluated) denoting a function which is to be applied to the string before the result is bound to <code>VAR</code>.
+To make this even more convenient the form <code>(FN&nbsp;VAR1&nbsp;...VARn)</code> can be used as an abbreviation for
+<code>(FN&nbsp;VAR1)&nbsp;...&nbsp;(FN&nbsp;VARn)</code>.
+<p>
+If there is no match, the <code><i>statement*</i></code> forms are <em>not</em>
+executed. For each element of
+<code><i>var-list</i></code> which is <code>NIL</code> there's no binding to the corresponding register
+group. The number of variables in <code><i>var-list</i></code> must not be greater than
+the number of register groups. If <code><i>sharedp</i></code> is true, the substrings may
+share structure with <code><i>target-string</i></code>.
+<pre>
+* (register-groups-bind (first second third fourth)
+      (&quot;((a)|(b)|(c))+&quot; &quot;abababc&quot; :sharedp t)
+    (list first second third fourth))
+(&quot;c&quot; &quot;a&quot; &quot;b&quot; &quot;c&quot;)
+
+* (register-groups-bind (nil second third fourth)
+      <font color=orange>;; note that we don't bind the first and fifth register group</font>
+      (&quot;((a)|(b)|(c))()+&quot; &quot;abababc&quot; :start 6)
+    (list second third fourth))
+(NIL NIL &quot;c&quot;)
+
+* (register-groups-bind (first)
+      (&quot;(a|b)+&quot; &quot;accc&quot; :start 1)
+    (format t &quot;This will not be printed: ~A&quot; first))
+NIL
+
+* (register-groups-bind (fname lname (#'parse-integer date month year))
+      (&quot;(\\w+)\\s+(\\w+)\\s+(\\d{1,2})\\.(\\d{1,2})\\.(\\d{4})&quot; &quot;Frank Zappa 21.12.1940&quot;)
+    (list fname lname (encode-universal-time 0 0 0 date month year 0)))
+("Frank" "Zappa" 1292889600)
+</pre>
+</blockquote>
+
+<p><br>[Macro]
+<br><a class=none name="do-scans"><b>do-scans</b> <i>(match-start match-end reg-starts reg-ends regex target-string <tt>&amp;optional</tt> result-form <tt>&amp;key</tt> start end) declaration* statement*</i> =&gt; <i>result*</i></a>
+
+<blockquote><br>
+A macro which iterates over <code><i>target-string</i></code> and
+tries to match <code><i>regex</i></code> as often as possible
+evaluating <code><i>statement*</i></code> with
+<code><i>match-start</i></code>, <code><i>match-end</i></code>,
+<code><i>reg-starts</i></code>, and <code><i>reg-ends</i></code> bound
+to the four return values of each match (see <a
+href="#scan"><code>SCAN</code></a>) in turn. After the last match,
+returns <code><i>result-form</i></code> if provided or
+<code>NIL</code> otherwise. An implicit block named <code>NIL</code>
+surrounds <code>DO-SCANS</code>; <code>RETURN</code> may be used to
+terminate the loop immediately. If <code><i>regex</i></code> matches
+an empty string, the scan is continued one position behind this match.
+<p>
+This is the most general macro to iterate over all matches in a target
+string. See the source code of <a
+href="#do-matches"><code>DO-MATCHES</code></a>, <a
+href="#all-matches"><code>ALL-MATCHES</code></a>, <a
+href="#split"><code>SPLIT</code></a>, or <a
+href="#regex-replace-all"><code>REGEX-REPLACE-ALL</code></a> for examples of its
+usage.</blockquote>
+
+
+
+
+<p><br>[Macro]
+<br><a class=none name="do-matches"><b>do-matches</b> <i>(match-start match-end regex target-string <tt>&amp;optional</tt> result-form <tt>&amp;key</tt> start end) declaration* statement*</i> =&gt; <i>result*</i></a>
+
+<blockquote><br>
+Like <a href="#do-scans"><code>DO-SCANS</code></a> but doesn't bind
+variables to the register arrays.
+<pre>
+* (defun foo (regex target-string &amp;key (start 0) (end (length target-string)))
+    (let ((sum 0))
+      (do-matches (s e regex target-string nil :start start :end end)
+        (incf sum (- e s)))
+      (format t "~,2F% of the string was inside of a match~%"
+                <font color=orange>;; note: doesn't check for division by zero</font>
+                (float (* 100 (/ sum (- end start)))))))
+
+FOO
+
+* (foo "a" "abcabcabc")
+33.33% of the string was inside of a match
+NIL
+* (foo "aa|b" "aacabcbbc")
+55.56% of the string was inside of a match
+NIL
+</pre></blockquote>
+
+
+
+
+<p><br>[Macro]
+<br><a class=none name="do-matches-as-strings"><b>do-matches-as-strings</b> <i>(match-var regex target-string <tt>&amp;optional</tt> result-form <tt>&amp;key</tt> start end sharedp) declaration* statement*</i> =&gt; <i>result*</i></a>
+
+<blockquote><br>
+Like <a href="#do-matches"><code>DO-MATCHES</code></a> but binds
+<code><i>match-var</i></code> to the substring of
+<code><i>target-string</i></code> corresponding to each match in turn. If <code><i>sharedp</i></code> is true, the substrings may share structure with
+<code><i>target-string</i></code>.
+<pre>
+* (defun crossfoot (target-string &amp;key (start 0) (end (length target-string)))
+    (let ((sum 0))
+      (do-matches-as-strings (m :digit-class
+                                         target-string nil
+                                         :start start :end end)
+        (incf sum (parse-integer m)))
+      (if (< sum 10)
+        sum
+        (crossfoot (format nil "~A" sum)))))
+
+CROSSFOOT
+
+* (crossfoot "bar")
+0
+
+* (crossfoot "a3x")
+3
+
+* (crossfoot "12345")
+6
+</pre>
+
+Of course, in real life you would do this with <a href="#do-matches"><code>DO-MATCHES</code></a> and use the <code><i>start</i></code> and <code><i>end</i></code> keyword parameters of <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_parse_.htm"><code>PARSE-INTEGER</code></a>.</blockquote>
+
+<p><br>[Macro]
+<br><a class=none name="do-register-groups"><b>do-register-groups</b> <i>var-list (regex target-string <tt>&amp;optional</tt> result-form <tt>&amp;key</tt> start end sharedp) declaration* statement*</i> =&gt; <i>result*</i></a>
+
+<blockquote><br>
+Iterates over <code><i>target-string</i></code> and tries to match <code><i>regex</i></code> as often as
+possible evaluating <code><i>statement*</i></code> with the variables in <code><i>var-list</i></code> bound to the
+corresponding register groups for each match in turn, i.e. each
+variable is either bound to a string or to <code>NIL</code>. You can use the same shortcuts and abbreviations as in <a href="#register-groups-bind"><code>REGISTER-GROUPS-BIND</code></a>. The number of
+variables in <code><i>var-list</i></code> must not be greater than the number of register
+groups. For each element of
+<code><i>var-list</i></code> which is <code>NIL</code> there's no binding to the corresponding register
+group. After the last match, returns <code><i>result-form</i></code> if provided or <code>NIL</code>
+otherwise. An implicit block named <code>NIL</code> surrounds <code>DO-REGISTER-GROUPS</code>;
+<code>RETURN</code> may be used to terminate the loop immediately. If <code><i>regex</i></code> matches
+an empty string, the scan is continued one position behind this
+match. If <code><i>sharedp</i></code> is true, the substrings may share structure with
+<code><i>target-string</i></code>.
+<pre>
+* (do-register-groups (first second third fourth)
+      (&quot;((a)|(b)|(c))&quot; &quot;abababc&quot; nil :start 2 :sharedp t)
+    (print (list first second third fourth)))
+(&quot;a&quot; &quot;a&quot; NIL NIL)
+(&quot;b&quot; NIL &quot;b&quot; NIL)
+(&quot;a&quot; &quot;a&quot; NIL NIL)
+(&quot;b&quot; NIL &quot;b&quot; NIL)
+(&quot;c&quot; NIL NIL &quot;c&quot;)
+NIL
+
+* (let (result)
+    (do-register-groups ((#'parse-integer n) (#'intern sign) whitespace)
+        (&quot;(\\d+)|(\\+|-|\\*|/)|(\\s+)&quot; &quot;12*15 - 42/3&quot;)
+      (unless whitespace
+        (push (or n sign) result)))
+    (nreverse result))
+(12 * 15 - 42 / 3)
+</pre>
+</blockquote>
+
+
+<p><br>[Function]
+<br><a class=none name="all-matches"><b>all-matches</b> <i>regex target-string <tt>&amp;key</tt> start end</i> =&gt; <i>list</i></a>
+
+<blockquote><br>
+Returns a list containing the start and end positions of all matches
+of <code><i>regex</i></code> against
+<code><i>target-string</i></code>, i.e. if there are <code>N</code>
+matches the list contains <code>(* 2 N)</code> elements. If
+<code><i>regex</i></code> matches an empty string the scan is
+continued one position behind this match.
+<pre>
+* (all-matches "a" "foo bar baz")
+(5 6 9 10)
+
+* (all-matches "\\w*" "foo bar baz")
+(0 3 3 3 4 7 7 7 8 11 11 11)
+</pre></blockquote>
+
+
+
+
+<p><br>[Function]
+<br><a class=none name="all-matches-as-strings"><b>all-matches-as-strings</b> <i>regex target-string <tt>&amp;key</tt> start end sharedp</i> =&gt; <i>list</i></a>
+
+<blockquote><br>
+Like <a href="#all-matches"><code>ALL-MATCHES</code></a> but
+returns a list of substrings instead. If <code><i>sharedp</i></code> is true, the substrings may share structure with
+<code><i>target-string</i></code>.
+<pre>
+* (all-matches-as-strings "a" "foo bar baz")
+("a" "a")
+
+* (all-matches-as-strings "\\w*" "foo bar baz")
+("foo" "" "bar" "" "baz" "")
+</pre></blockquote>
+
+
+
+
+<h4><a name="splitting" class=none>Splitting and replacing</a></h4>
+
+
+<p><br>[Function]
+<br><a class=none name="split"><b>split</b> <i>regex target-string <tt>&amp;key</tt> start end limit with-registers-p omit-unmatched-p sharedp</i> =&gt; <i>list</i></a>
+
+<blockquote><br>
+Matches <code><i>regex</i></code> against
+<code><i>target-string</i></code> as often as possible and returns a
+list of the substrings between the matches. If
+<code><i>with-registers-p</i></code> is true, substrings corresponding
+to matched registers are inserted into the list as well.  If
+<code><i>omit-unmatched-p</i></code> is true, unmatched registers will
+simply be left out, otherwise they will show up as
+<code>NIL</code>. <code><i>limit</i></code> limits the number of
+elements returned - registers aren't counted. If
+<code><i>limit</i></code> is <code>NIL</code> (or 0 which is
+equivalent), trailing empty strings are removed from the result list.
+If <code><i>regex</i></code> matches an empty string, the scan is
+continued one position behind this match. If <code><i>sharedp</i></code> is true, the substrings may share structure with
+<code><i>target-string</i></code>.
+<p>
+This function also tries hard to be
+Perl-compatible - thus the somewhat peculiar behaviour.
+<pre>
+* (split "\\s+" "foo   bar baz
+frob")
+("foo" "bar" "baz" "frob")
+
+* (split "\\s*" "foo bar   baz")
+("f" "o" "o" "b" "a" "r" "b" "a" "z")
+
+* (split "(\\s+)" "foo bar   baz")
+("foo" "bar" "baz")
+
+* (split "(\\s+)" "foo bar   baz" :with-registers-p t)
+("foo" " " "bar" "   " "baz")
+
+* (split "(\\s)(\\s*)" "foo bar   baz" :with-registers-p t)
+("foo" " " "" "bar" " " "  " "baz")
+
+* (split "(,)|(;)" "foo,bar;baz" :with-registers-p t)
+("foo" "," NIL "bar" NIL ";" "baz")
+
+* (split "(,)|(;)" "foo,bar;baz" :with-registers-p t :omit-unmatched-p t)
+("foo" "," "bar" ";" "baz")
+
+* (split ":" "a:b:c:d:e:f:g::")
+("a" "b" "c" "d" "e" "f" "g")
+
+* (split ":" "a:b:c:d:e:f:g::" :limit 1)
+("a:b:c:d:e:f:g::")
+
+* (split ":" "a:b:c:d:e:f:g::" :limit 2)
+("a" "b:c:d:e:f:g::")
+
+* (split ":" "a:b:c:d:e:f:g::" :limit 3)
+("a" "b" "c:d:e:f:g::")
+
+* (split ":" "a:b:c:d:e:f:g::" :limit 1000)
+("a" "b" "c" "d" "e" "f" "g" "" "")
+</pre></blockquote>
+
+
+
+
+
+<p><br>[Function]
+<br><a class=none name="regex-replace"><b>regex-replace</b> <i>regex target-string replacement <tt>&amp;key</tt> start end preserve-case simple-calls element-type</i> =&gt; <i>string, matchp</i></a>
+
+<blockquote><br> Try to match <code><i>target-string</i></code>
+between <code><i>start</i></code> and <code><i>end</i></code> against
+<code><i>regex</i></code> and replace the first match with
+<code><i>replacement</i></code>. Two values are returned; the modified
+string, and <code>T</code> if <code><i>regex</i></code> matched or
+<code>NIL</code> otherwise.
+<p>
+<code><i>replacement</i></code> can be a string which may contain the
+special substrings <code>&quot;\&amp;&quot;</code> for the whole
+match, <code>&quot;\`&quot;</code> for the part of
+<code><i>target-string</i></code> before the match,
+<code>&quot;\'&quot;</code> for the part of
+<code><i>target-string</i></code> after the match,
+<code>&quot;\N&quot;</code> or <code>&quot;\{N}&quot;</code> for the
+<code>N</code>th register where <code>N</code> is a positive integer.
+<p>
+<code><i>replacement</i></code> can also be a <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_f.htm#function_designator">function
+designator</a> in which case the match will be replaced with the
+result of calling the function designated by
+<code><i>replacement</i></code> with the arguments
+<code><i>target-string</i></code>, <code><i>start</i></code>,
+<code><i>end</i></code>, <code><i>match-start</i></code>,
+<code><i>match-end</i></code>, <code><i>reg-starts</i></code>, and
+<code><i>reg-ends</i></code>. (<code><i>reg-starts</i></code> and
+<code><i>reg-ends</i></code> are arrays holding the start and end
+positions of matched registers (or <code>NIL</code>) - the meaning of
+the other arguments should be obvious.)
+<p>
+If <code><i>simple-calls</i></code> is true, a function designated by
+<code><i>replacement</i></code> will instead be called with the
+arguments <code><i>match</i></code>, <code><i>register-1</i></code>,
+..., <code><i>register-n</i></code> where <code><i>match</i></code> is
+the whole match as a string and <code><i>register-1</i></code> to
+<code><i>register-n</i></code> are the matched registers, also as
+strings (or <code>NIL</code>). Note that these strings share structure with
+<code><i>target-string</i></code> so you must not modify them.
+<p>
+Finally, <code><i>replacement</i></code> can be a list where each
+element is a string (which will be inserted verbatim), one of the
+symbols <code>:match</code>, <code>:before-match</code>, or
+<code>:after-match</code> (corresponding to
+<code>&quot;\&amp;&quot;</code>, <code>&quot;\`&quot;</code>, and
+<code>&quot;\'&quot;</code> above), an integer <code>N</code>
+(representing register <code>(1+&nbsp;N)</code>), or a function
+designator.
+<p>
+If <code><i>preserve-case</i></code> is true (default is
+<code>NIL</code>), the replacement will try to preserve the case (all
+upper case, all lower case, or capitalized) of the match. The result
+will always be a <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_f.htm#fresh">fresh</a>
+string, even if <code><i>regex</i></code> doesn't match.
+<p>
+<code><i>element-type</i></code> specifies
+the <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_a.htm#array_element_type">array
+element type</a> of the string which is returned, the default
+is <a
+href="http://www.lispworks.com/documentation/lw50/LWRM/html/lwref-346.htm"><code>LW:SIMPLE-CHAR</code></a>
+for LispWorks
+and <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/t_ch.htm"><code>CHARACTER</code></a>
+for other Lisps.
+<pre>
+* (regex-replace "fo+" "foo bar" "frob")
+"frob bar"
+T
+
+* (regex-replace "fo+" "FOO bar" "frob")
+"FOO bar"
+NIL
+
+* (regex-replace "(?i)fo+" "FOO bar" "frob")
+"frob bar"
+T
+
+* (regex-replace "(?i)fo+" "FOO bar" "frob" :preserve-case t)
+"FROB bar"
+T
+
+* (regex-replace "(?i)fo+" "Foo bar" "frob" :preserve-case t)
+"Frob bar"
+T
+
+* (regex-replace "bar" "foo bar baz" "[frob (was '\\&' between '\\`' and '\\'')]")
+"foo [frob (was 'bar' between 'foo ' and ' baz')] baz"
+T
+
+* (regex-replace "bar" "foo bar baz"
+                          '("[frob (was '" :match "' between '" :before-match "' and '" :after-match "')]"))
+"foo [frob (was 'bar' between 'foo ' and ' baz')] baz"
+T
+
+* (regex-replace "(be)(nev)(o)(lent)"
+                          "benevolent: adj. generous, kind"
+                          #'(lambda (match &amp;rest registers)
+                              (format nil "~A [~{~A~^.~}]" match registers))
+                          :simple-calls t)
+"benevolent [be.nev.o.lent]: adj. generous, kind"
+T
+</pre></blockquote>
+
+
+<p><br>[Function]
+<br><a class=none name="regex-replace-all"><b>regex-replace-all</b> <i>regex target-string replacement <tt>&amp;key</tt> start end preserve-case simple-calls element-type</i> =&gt; <i>string, matchp</i></a>
+
+<blockquote><br>
+Like <a href="#regex-replace"><code>REGEX-REPLACE</code></a> but replaces all matches.
+<pre>
+* (regex-replace-all "(?i)fo+" "foo Fooo FOOOO bar" "frob" :preserve-case t)
+"frob Frob FROB bar"
+T
+
+* (regex-replace-all "(?i)f(o+)" "foo Fooo FOOOO bar" "fr\\1b" :preserve-case t)
+"froob Frooob FROOOOB bar"
+T
+
+* (let ((qp-regex (create-scanner "[\\x80-\\xff]")))
+    (defun encode-quoted-printable (string)
+      "Converts 8-bit string to quoted-printable representation."
+      <font color=orange>;; won't work for Corman Lisp because non-ASCII characters aren't 8-bit there</font>
+      (flet ((convert (target-string start end match-start match-end reg-starts reg-ends)
+             (declare (ignore start end match-end reg-starts reg-ends))
+             (format nil "=~2,'0x" (char-code (char target-string match-start)))))
+        (regex-replace-all qp-regex string #'convert))))
+Converted ENCODE-QUOTED-PRINTABLE.
+ENCODE-QUOTED-PRINTABLE
+
+* (encode-quoted-printable "F&ecirc;te S&oslash;rensen na&iuml;ve H&uuml;hner Stra&szlig;e")
+"F=EAte S=F8rensen na=EFve H=FChner Stra=DFe"
+T
+
+* (let ((url-regex (create-scanner "[^a-zA-Z0-9_\\-.]")))
+    (defun url-encode (string)
+      "URL-encodes a string."
+      <font color=orange>;; won't work for Corman Lisp because non-ASCII characters aren't 8-bit there</font>
+      (flet ((convert (target-string start end match-start match-end reg-starts reg-ends)
+             (declare (ignore start end match-end reg-starts reg-ends))
+             (format nil "%~2,'0x" (char-code (char target-string match-start)))))
+        (regex-replace-all url-regex string #'convert))))
+Converted URL-ENCODE.
+URL-ENCODE
+
+* (url-encode "F&ecirc;te S&oslash;rensen na&iuml;ve H&uuml;hner Stra&szlig;e")
+"F%EAte%20S%F8rensen%20na%EFve%20H%FChner%20Stra%DFe"
+T
+
+* (defun how-many (target-string start end match-start match-end reg-starts reg-ends)
+    (declare (ignore start end match-start match-end))
+    (format nil "~A" (- (svref reg-ends 0)
+                        (svref reg-starts 0))))
+HOW-MANY
+
+* (regex-replace-all "{(.+?)}"
+                              "foo{...}bar{.....}{..}baz{....}frob"
+                              (list "[" 'how-many " dots]"))
+"foo[3 dots]bar[5 dots][2 dots]baz[4 dots]frob"
+T
+
+* (let ((qp-regex (create-scanner "[\\x80-\\xff]")))
+    (defun encode-quoted-printable (string)
+      "Converts 8-bit string to quoted-printable representation.
+Version using SIMPLE-CALLS keyword argument."
+      <font color=orange>;; ;; won't work for Corman Lisp because non-ASCII characters aren't 8-bit there</font>
+      (flet ((convert (match)
+               (format nil "=~2,'0x" (char-code (char match 0)))))
+        (regex-replace-all qp-regex string #'convert
+                                    :simple-calls t))))
+
+Converted ENCODE-QUOTED-PRINTABLE.
+ENCODE-QUOTED-PRINTABLE
+
+* (encode-quoted-printable "F&ecirc;te S&oslash;rensen na&iuml;ve H&uuml;hner Stra&szlig;e")
+"F=EAte S=F8rensen na=EFve H=FChner Stra=DFe"
+T
+
+* (defun how-many (match first-register)
+    (declare (ignore match))
+    (format nil "~A" (length first-register)))
+HOW-MANY
+
+* (regex-replace-all "{(.+?)}"
+                              "foo{...}bar{.....}{..}baz{....}frob"
+                              (list "[" 'how-many " dots]")
+                              :simple-calls t)
+
+"foo[3 dots]bar[5 dots][2 dots]baz[4 dots]frob"
+T
+</pre></blockquote>
+
+<h4><a name="modify" class=none>Modifying scanner behaviour</a></h4>
+
+<p><br>[Special variable]
+<br><a class=none name="*property-resolver*"><b>*property-resolver*</b></a>
+
+</p><blockquote><br> This is the designator for a function responsible
+for resolving named properties like <code>\p{Number}</code>.  If
+CL-PPCRE encounters a <code>\p</code> or a <code>\P</code> it expects
+to see an opening curly brace immediately afterwards and will then
+read everything following that brace until it sees a closing curly
+brace.  The resolver function will be called with this string and must
+return a corresponding unary test function which accepts a character
+as its argument and returns a true value if and only if the character
+has the named property.  If the resolver returns <code>NIL</code>
+instead, it signals that a property of that name is unknown.
+<pre>
+* (labels ((char-code-odd-p (char)
+             (oddp (char-code char)))
+           (char-code-even-p (char)
+             (evenp (char-code char)))
+           (resolver (name)
+             (cond ((string= name "odd") #'char-code-odd-p)
+                   ((string= name "even") #'char-code-even-p)
+                   ((string= name "true") (constantly t))
+                   (t (error "Can't resolve ~S." name)))))
+    (let ((*property-resolver* #'resolver))
+      <font color=orange>;; quiz question - why do we need CREATE-SCANNER here?</font>
+      (list (regex-replace-all (create-scanner "\\p{odd}") "abcd" "+")
+            (regex-replace-all (create-scanner "\\p{even}") "abcd" "+")
+            (regex-replace-all (create-scanner "\\p{true}") "abcd" "+"))))
+("+b+d" "a+c+" "++++")
+</pre>
+If the value
+of <a href="#*property-resolver*"><code>*PROPERTY-RESOLVER*</code></a>
+is <code>NIL</code> (which is the default), <code>\p</code> and <code>\P</code> in regex
+strings will simply be treated like <code>p</code> or <code>P</code>
+as in CL-PPCRE&nbsp;1.4.1 and earlier.  Note that this does not affect
+the validity of <code>(:PROPERTY&nbsp;&lt;<i>name</i>&gt;)</code>
+parts in <a href="#create-scanner2">S-expression syntax</a>.
+</blockquote>
+
+
+<p><br>[Accessor]
+<br><a class="none" name="parse-tree-synonym"><b>parse-tree-synonym</b> <i>symbol</i> =&gt; <i>parse-tree</i>
+<br><tt>(setf (</tt><b>parse-tree-synonym</b> <i>symbol</i><tt>)</tt> <i>new-parse-tree</i><tt>)</tt></a>
+
+</p><blockquote><br>
+Any symbol (unless it's a keyword with a special meaning in parse
+trees) can be made a "synonym", i.e. an abbreviation, for another parse
+tree by this accessor. <code>PARSE-TREE-SYNONYM</code> returns <code>NIL</code> if <code><i>symbol</i></code> isn't a synonym yet.
+<pre>
+* (parse-string "a*b+")
+(:SEQUENCE (:GREEDY-REPETITION 0 NIL #\a) (:GREEDY-REPETITION 1 NIL #\b))
+
+* (defun my-repetition (char min)
+    `(:greedy-repetition ,min nil ,char))
+MY-REPETITION
+
+* (setf (parse-tree-synonym 'a*) (my-repetition #\a 0))
+(:GREEDY-REPETITION 0 NIL #\a)
+
+* (setf (parse-tree-synonym 'b+) (my-repetition #\b 1))
+(:GREEDY-REPETITION 1 NIL #\b)
+
+* (let ((scanner (create-scanner '(:sequence a* b+))))
+    (dolist (string '("ab" "b" "aab" "a" "x"))
+      (print (scan scanner string)))
+    (values))
+0
+0
+0
+NIL
+NIL
+
+* (parse-tree-synonym 'a*)
+(:GREEDY-REPETITION 0 NIL #\a)
+
+* (parse-tree-synonym 'a+)
+NIL
+</pre></blockquote>
+
+<p><br>[Macro]
+<br><a class="none" name="define-parse-tree-synonym"><b>define-parse-tree-synonym</b> <i>name parse-tree</i> =&gt; <i>parse-tree</i></a>
+
+</p><blockquote><br>
+This is a convenience macro for parse tree synonyms defined as
+
+<pre>
+(defmacro define-parse-tree-synonym (name parse-tree)
+  `(eval-when (:compile-toplevel :load-toplevel :execute)
+     (setf (parse-tree-synonym ',name) ',parse-tree)))
+</pre>
+
+so you can write code like this:
+
+<pre>
+(define-parse-tree-synonym a-z
+  (:char-class (:range #\a #\z) (:range #\A #\Z)))
+
+(define-parse-tree-synonym a-z*
+  (:greedy-repetition 0 nil a-z))
+
+(defun ascii-char-tester (string)
+  (scan '(:sequence :start-anchor a-z* :end-anchor)
+        string))
+</pre></blockquote>
+
+<p><br>[Special variable]
+<br><a class=none name="*regex-char-code-limit*"><b>*regex-char-code-limit*</b></a>
+
+<blockquote><br>This variable controls whether scanners take into
+account all characters of your CL implementation or only those
+the <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/f_char_c.htm#char-code"><code>CHAR-CODE</code></a>
+of which is not larger than its value. The default is
+<a href="http://www.lispworks.com/documentation/HyperSpec/Body/v_char_c.htm"><code>CHAR-CODE-LIMIT</code></a>,
+and you might see significant speed and space improvements during
+scanner <em>creation</em> if, say, your target strings only
+contain <a href="http://czyborra.com/charsets/iso8859.html">ISO-8859-1</a>
+characters and you're using a Lisp implementation
+where <code>CHAR-CODE-LIMIT</code> has a value much higher
+than&nbsp;256. The <a href="#test">test suite</a> will automatically
+set <code>*REGEX-CHAR-CODE-LIMIT*</code> to 256 while you're running
+the default test.
+<p>
+Note: Due to the nature of <a href="http://www.lispworks.com/documentation/HyperSpec/Body/s_ld_tim.htm"><code>LOAD-TIME-VALUE</code></a> and the <a
+href="#compiler-macro">compiler macro for <code>SCAN</code> and other functions</a>, some
+scanners might be created in a <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_n.htm#null_lexical_environment">null
+lexical environment</a> at load time or at compile time so be careful
+to which value <code>*REGEX-CHAR-CODE-LIMIT*</code> is bound at that
+time. The default value should always yield correct results unless you
+play dirty tricks with implementation-dependent behaviour, though.</blockquote>
+
+<p><br>[Special variable]
+<br><a class=none name="*use-bmh-matchers*"><b>*use-bmh-matchers*</b></a>
+
+<blockquote><br>Usually, the scanners created
+by <a href="#create-scanner"><code>CREATE-SCANNER</code></a> (or
+implicitly by other functions and macros) will use the standard
+function <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_search.htm"><code>SEARCH</code></a>
+to check for constant strings at the start or end of the regular
+expression.  If <code>*USE-BMH-MATCHERS*</code> is true (the default
+is <code>NIL</code>),
+fast <a href="http://www-igm.univ-mlv.fr/~lecroq/string/node18.html">Boyer-Moore-Horspool
+matchers</a> will be used instead.  This will usually be faster but
+can make the scanners considerably bigger.  Per BMH matcher - there
+can be up to two per scanner - a fixnum array of
+size <a href="#*regex-char-code-limit*"><code>*REGEX-CHAR-CODE-LIMIT*</code></a>
+is allocated and closed over.
+<p>
+Note: Due to the nature of <a href="http://www.lispworks.com/documentation/HyperSpec/Body/s_ld_tim.htm"><code>LOAD-TIME-VALUE</code></a> and the <a
+href="#compiler-macro">compiler macro for <code>SCAN</code> and other functions</a>, some
+scanners might be created in a <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_n.htm#null_lexical_environment">null
+lexical environment</a> at load time or at compile time so be careful
+to which value <code>*USE-BMH-MATCHERS*</code> is bound at that
+time.</blockquote>
+
+<p><br>[Special variable]<br><a class=none name='*optimize-char-classes*'><b>*optimize-char-classes*</b></a>
+<blockquote><br>
+Whether character classes should be compiled into look-ups into <em>O(1)</em>
+data structures.  This is usually fast but will be costly in terms of
+scanner creation time and might be costly in terms of size if
+<a href="#*regex-char-code-limit*"><code>*REGEX-CHAR-CODE-LIMIT*</code></a>
+is high.  This value will be used as the <code><i>kind</i></code>
+keyword argument
+to <a href="#create-optimized-test-function"><code>CREATE-OPTIMIZED-TEST-FUNCTION</code></a>
+- see there for the possible non-<code>NIL</code> values.  The default
+value (<code>NIL</code>) should usually be fine unless you're sure
+that you absolutely have to optimize some character classes for speed.
+<p>
+Note: Due to the nature
+of <a href="http://www.lispworks.com/documentation/HyperSpec/Body/s_ld_tim.htm"><code>LOAD-TIME-VALUE</code></a>
+and the <a href="#compiler-macro">compiler macro for <code>SCAN</code>
+and other functions</a>, some scanners might be created in
+a <a href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_n.htm#null_lexical_environment">null
+lexical environment</a> at load time or at compile time so be careful
+to which value <code>*OPTIMIZE-CHAR-CLASSES*</code> is bound at that
+time.
+</blockquote>
+
+<p><br>[Special variable]
+<br><a class=none name="*allow-quoting*"><b>*allow-quoting*</b></a>
+
+<blockquote><br>
+If this value is <em>true</em> (the default is <code>NIL</code>),
+CL-PPCRE will support <code>\Q</code> and <code>\E</code> in regex
+strings to quote (disable) metacharacters. Note that this entails a
+slight performance penalty when creating scanners because (a copy of) the regex
+string is modified (probably more than once) before it
+is fed to the parser. Also, the parser's <a
+href="#ppcre-syntax-error">syntax error messages</a> will complain
+about the converted string and not about the original regex string.
+
+<pre>
+* (scan &quot;^a+$&quot; &quot;a+&quot;)
+NIL
+
+* (let ((*allow-quoting* t))
+    <font color=orange>;;we use CREATE-SCANNER because of Lisps like SBCL that don't have an interpreter</font>
+    (scan (create-scanner &quot;^\\Qa+\\E$&quot;) &quot;a+&quot;))
+0
+2
+#()
+#()
+
+* (let ((*allow-quoting* t))
+    (scan (create-scanner &quot;\\Qa()\\E(?#comment\\Q)a**b&quot;) &quot;()ab&quot;))
+
+Quantifier '*' not allowed at position 19 in string &quot;a\\(\\)(?#commentQ)a**b&quot;
+</pre>
+
+Note how in the last example the regex string in the error message is
+different from the first argument to the <code>SCAN</code>
+function. Also note that the second example might be easier to
+understand (and Lisp-ier) if you write it like this:
+
+<pre>
+* (scan '(:sequence :start-anchor
+                    &quot;a+&quot; <font color=orange>;; no quoting necessary</font>
+                    :end-anchor)
+        &quot;a+&quot;)
+0
+2
+#()
+#()
+</pre>
+
+Make sure you also read <a href="#quote">the relevant section</a> in &quot;<a href="#bugs">Bugs and problems</a>.&quot;
+<p>
+Note: Due to the nature of <a href="http://www.lispworks.com/documentation/HyperSpec/Body/s_ld_tim.htm"><code>LOAD-TIME-VALUE</code></a> and the <a
+href="#compiler-macro">compiler macro for <code>SCAN</code> and other functions</a>, some
+scanners might be created in a <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_n.htm#null_lexical_environment">null
+lexical environment</a> at load time or at compile time so be careful
+to which value <code>*ALLOW-QUOTING*</code> is bound at that
+time.</blockquote>
+
+</blockquote>
+
+<p><br>[Special variable]
+<br><a class=none name="*allow-named-registers*"><b>*allow-named-registers*</b></a>
+
+<blockquote><br>
+If this value is <em>true</em> (the default is <code>NIL</code>),
+CL-PPCRE will support <code>(?<i>&lt;name&gt;"&lt;regex&gt;"</i>)</code> and <code>\k<i>&lt;name&gt;</i></code> in regex
+strings to provide named registers and back-references as in <a href="http://www.franz.com/support/documentation/7.0/doc/regexp.htm#regexp-new-capturing-2">AllegroCL</a>. <code><i>name</i></code> is has to start with a letter and can contain only alphanumeric characters or minus sign.  Names of registers are matched case-sensitively.
+The <a href="#create-scanner2">parse tree syntax</a> is not affected by the <code>*ALLOW-NAMED-REGISTERS*</code> switch, <code>:NAMED-REGISTER</code> and <code>:BACK-REFERENCE</code> forms are always resolved as expected. There are also no restrictions on register names in this syntax except that they have to be strings.
+
+<pre>
+<font color=orange>;; Perl compatible mode (*ALLOW-NAMED-REGISTERS* is NIL)</font>
+* (create-scanner "(?&lt;reg&gt;.*)")
+Character 'r' may not follow '(?&lt' at position 3 in string "(?&lt;reg&gt;)"
+
+<font color=orange>;; just unescapes "\\k"</font>
+* (parse-string "\\k&lt;reg&gt;")
+"k&lt;reg&gt;"
+
+* (setq *allow-named-registers* t)
+T
+
+* (create-scanner "((?&lt;small&gt;[a-z]*)(?&lt;big&gt;[A-Z]*))")
+#&LT;CLOSURE (LAMBDA (STRING CL-PPCRE::START CL-PPCRE::END)) {AD75BFD}&gt;
+(NIL "small" "big")
+
+<font color=orange>;; the scanner doesn't capture any information about named groups -
+;; you have to store the second value returned from CREATE-SCANNER yourself</font>
+* (scan * "aaaBBB")
+0
+6
+#(0 0 3)
+#(6 3 6)
+
+<font color=orange>;; parse tree syntax</font>
+* (parse-string "((?&lt;small&gt;[a-z]*)(?&lt;big&gt;[A-Z]*))")
+(:REGISTER
+ (:SEQUENCE
+  (:NAMED-REGISTER "small"
+   (:GREEDY-REPETITION 0 NIL (:CHAR-CLASS (:RANGE #\a #\z))))
+  (:NAMED-REGISTER "big"
+   (:GREEDY-REPETITION 0 NIL (:CHAR-CLASS (:RANGE #\A #\Z))))))
+
+* (create-scanner *)
+#&lt;CLOSURE (LAMBDA (STRING CL-PPCRE::START CL-PPCRE::END)) {B158E3D}&gt;
+(NIL "small" "big")
+
+<font color=orange>;; multiple-choice back-reference</font>
+* (scan "^(?&lt;reg&gt;[ab])(?&lt;reg&gt;[12])\\k&lt;reg&gt;\\k&lt;reg&gt;$" "a1aa")
+0
+4
+#(0 1)
+#(1 2)
+
+* (scan "^(?&lt;reg&gt;[ab])(?&lt;reg&gt;[12])\\k&lt;reg&gt;\\k&lt;reg&gt;$" "a22a")
+0
+4
+#(0 1)
+#(1 2)
+
+<font color=orange>;; demonstrating most-recently-seen-register-first property of back-reference;
+;; "greedy" regex (analogous to "aa?")</font>
+* (scan "^(?&lt;reg&gt;)(?&lt;reg&gt;a)(\\k&lt;reg&gt;)" "a")
+0
+1
+#(0 0 1)
+#(0 1 1)
+
+* (scan "^(?&lt;reg&gt;)(?&lt;reg&gt;a)(\\k&lt;reg&gt;)" "aa")
+0
+2
+#(0 0 1)
+#(0 1 2)
+
+<font color=orange>;; switched groups
+;; "lazy" regex (analogous to "aa??")</font>
+* (scan "^(?&lt;reg&gt;a)(?&lt;reg&gt;)(\\k&lt;reg&gt;)" "a")
+0
+1
+#(0 1 1)
+#(1 1 1)
+
+<font color=orange>;; scanner ignores the second "a"</font>
+* (scan "^(?&lt;reg&gt;a)(?&lt;reg&gt;)(\\k&lt;reg&gt;)" "aa")
+0
+1
+#(0 1 1)
+#(1 1 1)
+
+<font color=orange>;; "aa" will be matched only when forced by adding "$" at the end</font>
+* (scan "^(?&lt;reg&gt;a)(?&lt;reg&gt;)(\\k&lt;reg&gt;)$" "aa")
+0
+2
+#(0 1 1)
+#(1 1 2)
+</pre>
+Note: Due to the nature of <a href="http://www.lispworks.com/documentation/HyperSpec/Body/s_ld_tim.htm"><code>LOAD-TIME-VALUE</code></a> and the <a
+href="#compiler-macro">compiler macro for <code>SCAN</code> and other functions</a>, some
+scanners might be created in a <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_n.htm#null_lexical_environment">null
+lexical environment</a> at load time or at compile time so be careful
+to which value <code>*ALLOW-NAMED-REGISTERS*</code> is bound at that
+time.</blockquote>
+</blockquote>
+
+<p><br>[Special variable]
+<br><a class=none name="*look-ahead-for-suffix*"><b>*look-ahead-for-suffix*</b></a>
+
+<blockquote><br>Given a regular expression which has a constant
+suffix, such as <code>(a|b)+x</code> whose constant suffix
+is <code>x</code>, the scanners created
+by <a href="#create-scanner"><code>CREATE-SCANNER</code></a> will
+attempt to optimize by searching for the position of the suffix prior
+to performing the full match. In many cases, this is an optimization,
+especially when backtracking is involved on small strings. However, in
+other cases, such as incremental parsing of a very large string, this
+can cause a degradation in performance, because the entire string is
+searched for the suffix before an otherwise easy prefix match failure
+can occur. The variable <code>*LOOK-AHEAD-FOR-SUFFIX*</code>, whose
+default is <code>T</code>, can be used to selectively control this
+behavior.
+<p>
+Note: Due to the nature of <a href="http://www.lispworks.com/documentation/HyperSpec/Body/s_ld_tim.htm"><code>LOAD-TIME-VALUE</code></a> and the <a
+href="#compiler-macro">compiler macro for <code>SCAN</code> and other functions</a>, some
+scanners might be created in a <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_n.htm#null_lexical_environment">null
+lexical environment</a> at load time or at compile time so be careful
+to which value <code>*LOOK-AHEAD-FOR-SUFFIX*</code> is bound at that
+time.</blockquote>
+
+<h4><a name="misc" class=none>Miscellaneous</a></h4>
+
+<p><br>[Function]
+<br><a class=none name="parse-string"><b>parse-string</b> <i>string</i> =&gt; <i>parse-tree</i></a>
+
+<blockquote><br> Converts the <a href="#create-scanner">regex
+string</a> <code><i>string</i></code> into a <a href="#create-scanner2">parse tree</a>.
+Note that the result is usually one possible way of creating an
+equivalent parse tree and not necessarily the "canonical" one.
+Specifically, the parse tree might contain redundant parts which are
+supposed to be excised when a scanner is created.
+</blockquote>
+
+<p><br>[Function]<br><a class=none name='create-optimized-test-function'><b>create-optimized-test-function</b> <i>test-function <tt>&amp;key</tt> start end kind</i> =&gt; <i>function</i></a>
+<blockquote><br>
+
+Given a unary test function <code><i>test-function</i></code> which is
+applicable to characters returns a function which yields the same
+boolean results for all characters with character codes
+from <code><i>start</i></code> to (excluding) <code><i>end</i></code>.
+If <code><i>kind</i></code>
+is <code>NIL</code>, <code><i>test-function</i></code> will simply be
+returned.  Otherwise, <code><i>kind</i></code> should be one of:
+<dl>
+<dt><code>:HASH-TABLE</code></dt>
+<dd>The function builds a hash table representing all characters which
+satisfy the test and returns a closure which checks if a character is
+in that hash table.</dd>
+<dt><code>:CHARSET</code></dt>
+<dd>Instead of a hash table the function uses a &quot;charset&quot;
+which is a data structure using non-linear hashing and optimized to
+represent (sparse) sets of characters in a fast and space-efficient
+way (contributed by Nikodemus Siivola).</dd>
+<dt><code>:CHARMAP</code></dt>
+<dd>Instead of a hash table the function uses a bit vector to
+represent the set of characters.</dd>
+</dl>
+You can also use <code>:HASH-TABLE*</code> or <code>:CHARSET*</code>
+which are like <code>:HASH-TABLE</code> and <code>:CHARSET</code> but
+use the complement of the set if the set contains more than half of
+all characters between <code><i>start</i></code>
+and <code><i>end</i></code>.  This saves space but needs an additional
+pass across all characters to create the data structure.  There is no
+corresponding <code>:CHARMAP*</code> <code><i>kind</i></code> as the bit vectors are
+already created to cover the smallest possible interval which contains
+either the set or its complement.
+<p>
+See also <a href="#*optimize-char-classes*"><code>*OPTIMIZE-CHAR-CLASSES*</code></a>.
+</blockquote>
+
+<p><br>[Function]
+<br><a class=none name="quote-meta-chars"><b>quote-meta-chars</b> <i>string</i> =&gt; <i>string'</i></a>
+
+<blockquote><br>
+This is a simple utility function used when <a
+href="#*allow-quoting*"><code>*ALLOW-QUOTING*</code></a> is
+<em>true</em>. It returns a string <code>STRING'</code> where all
+non-word characters (everything except ASCII characters, digits and
+underline) of <code>STRING</code> are quoted by prepending a
+backslash similar to Perl's <code>quotemeta</code> function. It always returns a <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_f.htm#fresh">fresh</a>
+string.
+<pre>
+* (quote-meta-chars &quot;[a-z]*&quot;)
+&quot;\\[a\\-z\\]\\*&quot;
+</pre></blockquote>
+
+<p><br>[Function]
+<br><a class=none name="regex-apropos"><b>regex-apropos</b> <i>regex <tt>&amp;optional</tt> packages <tt>&amp;key</tt> case-insensitive</i> =&gt; <i>list</i></a>
+
+<blockquote><br>
+Like <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/f_apropo.htm"><code>APROPOS</code></a>
+but searches for interned symbols which match the regular expression
+<code><i>regex</i></code>. The output is implementation-dependent. If
+<code><i>case-insensitive</i></code> is true (which is the default)
+and <code><i>regex</i></code> isn't already a scanner, a
+case-insensitive scanner is used.
+<p>
+Here are examples for CMUCL:
+
+<pre>
+* *package*
+#&lt;The COMMON-LISP-USER package, 16/21 internal, 0/9 external&gt;
+
+* (defun foo (n &amp;optional (k 0)) (+ 3 n k))
+FOO
+
+* (defparameter foo "bar")
+FOO
+
+* (defparameter |foobar| 42)
+|foobar|
+
+* (defparameter fooboo 43)
+FOOBOO
+
+* (defclass frobar () ())
+#&lt;STANDARD-CLASS FROBAR {4874E625}&gt;
+
+* (regex-apropos "foo(?:bar)?")
+FOO [variable] value: "bar"
+    [compiled function] (N &amp;OPTIONAL (K 0))
+FOOBOO [variable] value: 43
+|foobar| [variable] value: 42
+
+* (regex-apropos "(?:foo|fro)bar")
+PCL::|COMMON-LISP-USER::FROBAR class predicate| [compiled closure]
+FROBAR [class] #&lt;STANDARD-CLASS FROBAR {4874E625}&gt;
+|foobar| [variable] value: 42
+
+* (regex-apropos "(?:foo|fro)bar" 'cl-user)
+FROBAR [class] #&lt;STANDARD-CLASS FROBAR {4874E625}&gt;
+|foobar| [variable] value: 42
+
+* (regex-apropos "(?:foo|fro)bar" '(pcl ext))
+PCL::|COMMON-LISP-USER::FROBAR class predicate| [compiled closure]
+
+* (regex-apropos "foo")
+FOO [variable] value: "bar"
+    [compiled function] (N &amp;OPTIONAL (K 0))
+FOOBOO [variable] value: 43
+|foobar| [variable] value: 42
+
+* (regex-apropos "foo" nil :case-insensitive nil)
+|foobar| [variable] value: 42
+</pre></blockquote>
+
+
+
+
+<p><br>[Function]
+<br><a class=none name="regex-apropos-list"><b>regex-apropos-list</b> <i>regex <tt>&amp;optional</tt> packages <tt>&amp;key</tt> upcase</i> =&gt; <i>list</i></a>
+
+<blockquote><br>
+Like <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/f_apropo.htm"><code>APROPOS-LIST</code></a>
+but searches for interned symbols which match the regular expression
+<code><i>regex</i></code>. If <code><i>case-insensitive</i></code> is
+true (which is the default) and <code><i>regex</i></code> isn't
+already a scanner, a case-insensitive scanner is used.
+<p>
+Example (continued from above):
+
+<pre>
+* (regex-apropos-list &quot;foo(?:bar)?&quot;)
+(|foobar| FOOBOO FOO)
+</pre></blockquote>
+
+<h4><a name="conditions" class=none>Conditions</a></h4>
+
+<p><br>[Condition type]
+<br><a class=none name="ppcre-error"><b>ppcre-error</b></a>
+
+<blockquote><br>
+Every error signaled by CL-PPCRE is of type
+<code>PPCRE-ERROR</code>. This is a direct subtype of <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/e_smp_er.htm"><code>SIMPLE-ERROR</code></a>
+without any additional slots or options.
+</blockquote>
+
+<p><br>[Condition type]
+<br><a class=none name="ppcre-invocation-error"><b>ppcre-invocation-error</b></a>
+
+<blockquote><br>
+Errors of type <code>PPCRE-INVOCATION-ERROR</code>
+are signaled if one of the exported functions of CL-PPCRE is called with wrong or
+inconsistent arguments. This is a direct subtype of <a
+href="#ppcre-error"><code>PPCRE-ERROR</code></a> without any
+additional slots or options.
+</blockquote>
+
+<p><br>[Condition type]
+<br><a class=none name="ppcre-syntax-error"><b>ppcre-syntax-error</b></a>
+
+<blockquote><br>
+An error of type <code>PPCRE-SYNTAX-ERROR</code> is signaled if
+CL-PPCRE's parser encounters an error when trying to parse a regex
+string or to convert a parse tree into its internal representation.
+This is a direct subtype of <a
+href="#ppcre-error"><code>PPCRE-ERROR</code></a> with two additional
+slots. These denote the regex string which HTML-PPCRE was parsing and
+the position within the string where the error occurred.  If the error
+happens while CL-PPCRE is converting a parse tree, both of these slots
+contain <code>NIL</code>.  (See the next two entries on how to access
+these slots.)
+<p>
+As many syntax errors can't be detected before the parser is at the
+end of the stream, the row and column usually denote the last position
+where the parser was happy and not the position where it gave up.
+
+<pre>
+* (handler-case
+    (scan &quot;foo**x&quot; &quot;fooox&quot;)
+    (ppcre-syntax-error (condition)
+      (format t &quot;Houston, we've got a problem with the string ~S:~%~
+                 Looks like something went wrong at position ~A.~%~
+                 The last message we received was \&quot;~?\&quot;.&quot;
+              (ppcre-syntax-error-string condition)
+              (ppcre-syntax-error-pos condition)
+              (simple-condition-format-control condition)
+              (simple-condition-format-arguments condition))
+      (values)))
+Houston, we've got a problem with the string &quot;foo**x&quot;:
+Looks like something went wrong at position 4.
+The last message we received was &quot;Quantifier '*' not allowed.&quot;.
+</pre>
+</blockquote>
+
+<p><br>[Function]
+<br><a class=none name="ppcre-syntax-error-string"><b>ppcre-syntax-error-string</b></a> <i>condition</i> =&gt; <i>string</i>
+
+<blockquote><br>
+If <code><i>condition</i></code> is a condition of type <a
+href="#ppcre-syntax-error"><code>PPCRE-SYNTAX-ERROR</code></a>, this
+function will return the string the parser was parsing when the error was
+encountered (or <code>NIL</code> if the error happened while trying to
+convert a parse tree). This might be particularly useful when <a
+href="#*allow-quoting*"><code>*ALLOW-QUOTING*</code></a> is
+<em>true</em> because in this case the offending string might not be the one you gave to the <a
+href="#create-scanner"><code>CREATE-SCANNER</code></a> function.
+</blockquote>
+
+<p><br>[Function]
+<br><a class=none name="ppcre-syntax-error-pos"><b>ppcre-syntax-error-pos</b></a> <i>condition</i> =&gt; <i>number</i>
+
+<blockquote><br>
+If <code><i>condition</i></code> is a condition of type <a
+href="#ppcre-syntax-error"><code>PPCRE-SYNTAX-ERROR</code></a>, this
+function will return the position within the string where the error
+occurred (or <code>NIL</code> if the error happened while trying to
+convert a parse tree).
+</blockquote>
+
+<br>&nbsp;<br><h3><a name="unicode" class=none>Unicode properties</a></h3>
+
+You can add support for Unicode properties to CL-PPCRE by loading
+the CL-PPCRE-UNICODE system (which depends on <a href="https://github.com/edicl/cl-unicode/">CL-UNICODE</a>):
+<pre>
+(asdf:oos 'asdf:load-op :cl-ppcre-unicode)
+</pre>
+This will automatically
+install <a href="#unicode-property-resolver"><code>UNICODE-PROPERTY-RESOLVER</code></a>
+as your <a href="#*property-resolver*">property resolver</a>.
+<p>
+See the <a href="https://github.com/edicl/cl-unicode/">CL-UNICODE</a>
+documentation for information about the supported Unicode properties
+and how they are named.
+
+<p><br>[Function]<br><a class=none name='unicode-property-resolver'><b>unicode-property-resolver</b> <i>property-name</i> =&gt; <i>function-or-nil</i></a>
+<blockquote><br>
+A <a href="#*property-resolver*">property
+resolver</a> which understands Unicode properties using
+<a href="https://github.com/edicl/cl-unicode/">CL-UNICODE</a>'s <code>PROPERTY-TEST</code>
+function.  This resolver is automatically installed
+in <a href="#*property-resolver*"><code>*PROPERTY-RESOLVER*</code></a>
+when the <a href="#unicode">CL-PPCRE-UNICODE</a> system is loaded.
+<pre>
+* (scan-to-strings "\\p{Script:Latin}+" "0+AB_*")
+"AB"
+#()
+</pre>
+Note that this symbol is exported from
+the <code>CL-PPCRE-UNICODE</code> package and not from
+the <code>CL-PPCRE</code> package.
+</blockquote>
+
+
+<br>&nbsp;<br><h3><a name="filters" class=none>Filters</a></h3>
+
+Because several users have asked for it, CL-PPCRE now offers
+&quot;filters&quot; (see <a href="#filterdef">above</a> for syntax)
+which are basically arbitrary, user-defined functions that can act as
+regex building blocks. Filters can only be used within <a
+href="#create-scanner2">parse trees</a>, not within Perl regex
+strings.
+<p>
+A filter is defined by its <em>filter function</em> which must be a
+function of one argument. During the parsing process this function
+might be called once or several times or it might not be called at
+all. If it's called, its argument is an integer <code><i>pos</i></code>
+which is the current position within the target string. The filter can
+either return <code>NIL</code> (which means that the subexpression
+represented by this filter didn't match) or an integer not smaller
+than <code><i>pos</i></code> for success. A zero-length assertion
+should return <code><i>pos</i></code> itself while a filter which
+wants to consume <code>N</code> characters should return
+<code>(+&nbsp;POS&nbsp;N)</code>.
+<p>
+If you supply the optional value <code><i>length</i></code> and it is
+not <code>NIL</code>, then this is a promise to the regex engine that
+your filter will <em>always</em> consume <em>exactly</em>
+<code><i>length</i></code> characters. The regex engine might use this
+information for optimization purposes but it is otherwise irrelevant
+to the outcome of the matching process.
+<p>
+The filter function can access the following special variables from
+its code body:
+<dl>
+
+<dt><code>CL-PPCRE::*STRING*</code></dt>
+<dd>The target (a string) of the current matching process.</dd>
+
+<dt><code>CL-PPCRE::*START-POS*</code> and
+<code>CL-PPCRE::*END-POS*</code></dt>
+<dd>The start and end (integers) indices
+of the current matching process. These correspond to the
+<code>START</code> and <code>END</code> keyword parameters
+of <a href="#scan"><code>SCAN</code></a>.</dd>
+
+<dt><code>CL-PPCRE::*REAL-START-POS*</code></dt>
+<dd>The initial starting
+position. This is only relevant for repeated scans (as in <a
+href="#do-scans"><code>DO-SCANS</code></a>) where
+<code>CL-PPCRE::*START-POS*</code> will be moved forward while
+<code>CL-PPCRE::*REAL-START-POS*</code> won't. For normal scans the
+value of this variable is <code>NIL</code>.</dd>
+
+<dt><CODE>CL-PPCRE::*REG-STARTS*</CODE> and
+<CODE>CL-PPCRE::*REG-ENDS*</CODE></dt>
+<dd>Two simple vectors which denote the
+start and end indices of registers within the regular expression. The
+first register is indexed by&nbsp;0. If a register hasn't matched yet,
+then its corresponding entry in <CODE>CL-PPCRE::*REG-STARTS*</CODE> is
+<code>NIL</code>.</dd>
+
+</dl>
+
+These variables should be considered read-only. Do <em>not</em> change
+these values unless you really know what you're doing!
+<p>
+Note that the names of the variables are not exported from the
+<code>CL-PPCRE</code> package because there's no explicit guarantee
+that they will be available in future releases.  (Although after so
+many years it is <em>very</em> unlikely that they'll go away...)
+<pre>
+* (defun my-info-filter (pos)
+    &quot;Show some info about the matching process.&quot;
+    (format t &quot;Called at position ~A~%&quot; pos)
+    (loop with dim = (array-dimension cl-ppcre::*reg-starts* 0)
+          for i below dim
+          for reg-start = (aref cl-ppcre::*reg-starts* i)
+          for reg-end = (aref cl-ppcre::*reg-ends* i)
+          do (format t &quot;Register ~A is currently &quot; (1+ i))
+          when reg-start
+               (write-string cl-ppcre::*string* nil
+            do (write-char #\')
+               (write-string cl-ppcre::*string* nil
+                     :start reg-start :end reg-end)
+               (write-char #\')
+          else
+            do (write-string &quot;unbound&quot;)
+          do (terpri))
+    (terpri)
+    pos)
+MY-INFO-FILTER
+
+* (scan '(:sequence
+           (:register
+             (:greedy-repetition 0 nil
+                                 (:char-class (:range #\a #\z))))
+           (:filter my-info-filter 0) &quot;X&quot;)
+        &quot;bYcdeX&quot;)
+Called at position 1
+Register 1 is currently 'b'
+
+Called at position 0
+Register 1 is currently ''
+
+Called at position 1
+Register 1 is currently ''
+
+Called at position 5
+Register 1 is currently 'cde'
+
+2
+6
+#(2)
+#(5)
+
+* (scan '(:sequence
+           (:register
+             (:greedy-repetition 0 nil
+                                 (:char-class (:range #\a #\z))))
+           (:filter my-info-filter 0) &quot;X&quot;)
+        &quot;bYcdeZ&quot;)
+NIL
+
+* (defun my-weird-filter (pos)
+    &quot;Only match at this point if either pos is odd and the character
+  we're looking at is lowercase or if pos is even and the next two
+  characters we're looking at are uppercase. Consume these characters if
+  there's a match.&quot;
+    (format t &quot;Trying at position ~A~%&quot; pos)
+    (cond ((and (oddp pos)
+                (&lt; pos cl-ppcre::*end-pos*)
+                (lower-case-p (char cl-ppcre::*string* pos)))
+           (1+ pos))
+          ((and (evenp pos)
+                (&lt; (1+ pos) cl-ppcre::*end-pos*)
+                (upper-case-p (char cl-ppcre::*string* pos))
+                (upper-case-p (char cl-ppcre::*string* (1+ pos))))
+           (+ pos 2))
+          (t nil)))
+MY-WEIRD-FILTER
+
+* (defparameter *weird-regex*
+                `(:sequence &quot;+&quot; (:filter ,#'my-weird-filter) &quot;+&quot;))
+*WEIRD-REGEX*
+
+* (scan *weird-regex* &quot;+A++a+AA+&quot;)
+Trying at position 1
+Trying at position 3
+Trying at position 4
+Trying at position 6
+5
+9
+#()
+#()
+
+* (fmakunbound 'my-weird-filter)
+MY-WEIRD-FILTER
+
+* (scan *weird-regex* &quot;+A++a+AA+&quot;)
+Trying at position 1
+Trying at position 3
+Trying at position 4
+Trying at position 6
+5
+9
+#()
+#()
+</pre>
+
+Note that in the second call to <code>SCAN</code> our filter wasn't
+invoked at all - it was optimized away by the regex engine because it
+knew that it couldn't match. Also note that <code>*WEIRD-REGEX*</code>
+still worked after we removed the global function definition of
+<code>MY-WEIRD-FILTER</code> because the regular expression had
+captured the original definition.
+
+<p>
+
+For more ideas about what you can do with filters see <a
+href="http://common-lisp.net/pipermail/cl-ppcre-devel/2004-October/000069.html">this
+thread</a> on the <a href="#mail">mailing list</a>.
+
+<br>&nbsp;<br><h3><a name="perl" class=none>Compatibility with Perl</a></h3>
+
+Depending on your Perl version you might encounter a couple of small
+incompatibilities with Perl most of which aren't due to CL-PPCRE:
+
+<h4><a name="empty" class=none>Empty strings instead of <code>undef</code> in <code>$1</code>, <code>$2</code>, etc.</a></h4>
+
+(Cf. case #629 of <a href="#test"><code>perltestdata</code></a>.)
+This is <a
+href="http://groups.google.com/groups?threadm=87u1kw8hfr.fsf%40dyn164.dbdmedia.de">a
+bug</a> in Perl 5.6.1 and earlier which has been fixed in 5.8.0.
+
+<h4><a name="scope" class=none>Strange scoping of embedded modifiers</a></h4>
+
+(Cf. case #430 of <a href="#test"><code>perltestdata</code></a>.)
+This is <a
+href="http://groups.google.com/groups?threadm=871y80dpqh.fsf%40bird.agharta.de">a
+bug</a> in Perl 5.6.1 and earlier which has been fixed in 5.8.0.
+
+<h4><a name="inconsistent" class=none>Inconsistent capturing of <code>$1</code>, <code>$2</code>, etc.</a></h4>
+
+(Cf. case #662 of <a href="#test"><code>perltestdata</code></a>.)
+This is <a
+href="http://bugs6.perl.org/rt2/Ticket/Display.html?id=18708">a
+bug</a> in Perl which hasn't been fixed yet.
+
+<h4><a name="lookaround" class=none>Captured groups not available outside of look-aheads and look-behinds</a></h4>
+
+(Cf. case #1439 of <a href="#test"><code>perltestdata</code></a>.)
+Well, OK, this ain't a Perl bug. I just can't quite understand why
+captured groups should only be seen within the scope of a look-ahead
+or look-behind. For the moment, CL-PPCRE and Perl agree to
+disagree... :)
+
+<h4><a name="order" class=none>Alternations don't always work from left to right</a></h4>
+
+(Cf. case #790 of <a href="#test"><code>perltestdata</code></a>.) I
+also think this a Perl bug but I currently have lost the drive to
+report it.
+
+<h4><a name="uprops" class=none>Different names for Unicode properties</a></h4>
+
+The names of <a href="#unicode">Unicode properties</a> are derived
+from <a href="https://github.com/edicl/cl-unicode/">CL-UNICODE</a> and might
+differ slightly from the names in Perl.  Most of them should be
+identical, though.
+Also, <a href="https://github.com/edicl/cl-unicode/">CL-UNICODE</a> is based on
+Unicode&nbsp;5.1 while your installed Perl version might be not.
+
+<h4><a name="mac" class=none><code>&quot;\r&quot;</code> doesn't work with MCL</a></h4>
+
+(Cf. case #9 of <a href="#test"><code>perltestdata</code></a>.) For
+some strange reason that I don't understand MCL translates
+<code>#\Return</code> to <code>(CODE-CHAR 10)</code> while MacPerl
+translates <code>&quot;\r&quot;</code> to <code>(CODE-CHAR
+13)</code>. Hmmm...
+
+<h4><a name="alpha" class=none>What about <code>&quot;\w&quot;</code>?</a></h4>
+
+CL-PPCRE uses <a
+href="http://www.lispworks.com/documentation/HyperSpec/Body/f_alphan.htm"><code>ALPHANUMERICP</code></a>
+to decide whether a character matches Perl's
+<code>&quot;\w&quot;</code>, so depending on your CL implementation
+you might encounter differences between Perl and CL-PPCRE when
+matching non-ASCII characters.
+
+<br>&nbsp;<br><h3><a name="bugs" class=none>Bugs and problems</a></h3>
+
+<h4><a name="quote" class=none><code>&quot;\Q&quot;</code> doesn't work, or does it?</a></h4>
+
+In Perl the following code works as expected, i.e. it prints <code>1</code>.
+<pre>
+#!/usr/bin/perl -l
+
+$a = '\E*';
+print 1
+  if '\E*\E*' =~ /(?:\Q$a\E){2}/;
+</pre>
+
+If you try to do something similar in CL-PPCRE, you get an error:
+
+<pre>
+* (let ((*allow-quoting* t)
+        (a &quot;\\E*&quot;))
+    (scan (concatenate 'string &quot;(?:\\Q&quot; a &quot;\\E){2}&quot;) &quot;\\E*\\E*&quot;))
+Quantifier '*' not allowed at position 3 in string &quot;(?:*\\E){2}&quot;
+</pre>
+
+The error message might give you a hint as to why this happens:
+Because <a href="#*allow-quoting*"><code>*ALLOW-QUOTING*</code></a>
+was <em>true</em> the concatenated string was pre-processed before it
+was fed to CL-PPCRE's parser - the result of this pre-processing is
+<code>&quot;(?:*\\E){2}&quot;</code> because the
+<code>&quot;\\E&quot;</code> in the string <code>A</code> was taken to
+be the end of the quoted section started by
+<code>&quot;\\Q&quot;</code>. This cannot happen in Perl due to its
+complicated interpolation rules - see <code>man&nbsp;perlop</code> for
+the scary details. It <em>can</em> happen in CL-PPCRE, though.
+Bummer!
+<p>
+What gives? <code>&quot;\\Q...\\E&quot;</code> in CL-PPCRE should only
+be used in literal strings. If you want to quote arbitrary strings,
+try <a href="https://github.com/edicl/cl-interpol/">CL-INTERPOL</a> or use <a
+href="#quote-meta-chars"><code>QUOTE-META-CHARS</code></a>:
+<pre>
+* (let ((a &quot;\\E*&quot;))
+    (scan (concatenate 'string &quot;(?:&quot; (quote-meta-chars a) &quot;){2}&quot;) &quot;\\E*\\E*&quot;))
+0
+6
+#()
+#()
+</pre>
+Or, even better and Lisp-ier, use the <a href="#create-scanner2">S-expression syntax</a> instead - no need for quoting in this case:
+<pre>
+* (let ((a "\\E*"))
+    (scan `(:greedy-repetition 2 2 ,a) "\\E*\\E*"))
+0
+6
+#()
+#()
+</pre>
+
+<h4><a name="backslash" class=none>Backslashes may confuse you...</a></h4>
+
+<pre>
+* (let ((a &quot;y\\y&quot;))
+    (scan a a))
+NIL
+</pre>
+
+You didn't expect this to yield <code>NIL</code>, did you? Shouldn't something like <code>(SCAN&nbsp;A&nbsp;A)</code> always return a true value? No, because the first and the second argument to <code>SCAN</code> are handled differently: The first argument is fed to CL-PPCRE's parser and is treated like a Perl regular expression. In particular, the parser "sees" <code>\y</code> and converts it to <code>y</code> because <code>\y</code> has no special meaning in regular expressions. So, the regular expression is the constant string <code>"yy"</code>. But the second argument isn't converted - it is left as is, i.e. it's equivalent to Perl's <code>'y\y'</code>. In other words, this example would be equivalent to the Perl code
+
+<pre>
+'y\y' =~ /y\y/;
+</pre>
+
+or to
+
+<pre>
+$a = 'y\y';
+$a =~ /$a/;
+</pre>
+
+which should explain why it doesn't match.
+<p>
+Still confused? You might want to try <a href="https://github.com/edicl/cl-interpol/">CL-INTERPOL</a>.
+
+<br>&nbsp;<br><h3><a class=none name="allegro">AllegroCL compatibility mode</a></h3>
+
+Since autumn 2004 <a
+href="http://www.franz.com/products/allegrocl/">AllegroCL</a> offers
+<a
+href="http://www.franz.com/support/documentation/7.0/doc/regexp.htm">a
+new regular expression API</a> with a syntax very similar to
+CL-PPCRE. Although CL-PPCRE is quite fast already, AllegroCL's engine will
+most likely be even faster (but only on AllegroCL, of course).  However, you might want to
+stick to CL-PPCRE because you have a "legacy" application or because
+you want your code to be portable to other Lisp implementations.
+Therefore, beginning from version 1.2.0, CL-PPCRE offers a
+"compatibility mode" where you can continue using the CL-PPCRE API as
+described <a href="#dict">above</a> but deploy the AllegroCL regex
+engine under the hood. (The details are: Calls to <a
+href="#create-scanner"><code>CREATE-SCANNER</code></a> and <a
+href="#scan"><code>SCAN</code></a> are dispatched to their AllegroCL
+counterparts <a
+href="http://www.franz.com/support/documentation/7.0/doc/operators/excl/compile-re.htm"><code>EXCL:COMPILE-RE</code></a>
+and <a
+href="http://www.franz.com/support/documentation/7.0/doc/operators/excl/match-re.htm"><code>EXCL:MATCH-RE</code></a>
+while everything else is left as is.)
+<p>
+The advantage of this mode is that you'll get a much smaller image and
+most likely faster code. (But note that CL-PPCRE needs to do a small amount of work to massage AllegroCL's output into the format expected by CL-PPCRE.) The downside is that your code won't be
+fully compatible with CL-PPCRE anymore. Here are some of the
+differences (most of which probably don't matter very often):
+<ul>
+<li>The AllegroCL engine doesn't offer <a
+href="#parse-tree-synonym">parse tree synonyms</a> and <a href="#filters">filters</a>.
+<li>The AllegroCL engine <a href="http://www.franz.com/support/documentation/8.0/doc/regexp.htm#regexp-new-compatibility-2">will choke on some regular expressions involving curly braces</a> that are accepted by Perl and CL-PPCRE's native engine.
+<li>The AllegroCL engine's case-folding mode switch (which is used instead of CL-PPCRE's <a href="#create-scanner"><code>:CASE-INSENSITIVE</code> keyword parameter</a>) <a href="http://www.franz.com/support/documentation/8.0/doc/regexp.htm#regexp-new-matching-2">is currently only effective for ASCII characters</a>.
+<li>The AllegroCL engine <a href="http://www.franz.com/support/documentation/8.0/doc/regexp.htm#regexp-new-compatibility-2">doesn't support</a> <a href="#*allow-quoting*">quoting of metacharacters</a>.
+<li>In AllegroCL compatibility mode compiled regular expressions (as returned by <a href="#create-scanner"><code>CREATE-SCANNER</code></a>) aren't functions but structures.
+<li>The AllegroCL engine <a href="http://www.franz.com/support/documentation/8.0/doc/regexp.htm#regexp-new-compatibility-2">doesn't support</a> <a href="#*property-resolver*">named properties</a>.
+</ul>
+For more details about the AllegroCL engine and possible deviations from CL-PPCRE see the <a href="http://www.franz.com/support/documentation/8.0/doc/regexp.htm">documentation</a> at the <a href="http://www.franz.com/">Franz Inc. website</a>.
+<p>
+To use the AllegroCL compatibility mode you have to
+<pre>
+(push :use-acl-regexp2-engine *features*)
+</pre>
+<em>before</em> you compile CL-PPCRE.
+
+<br>&nbsp;<br><h3><a class=none name="blabla">Hints, comments, performance considerations</a></h3>
+
+Here are, in no particular order, a couple of things about CL-PPCRE
+and regular expressions in general that you might or might not want to
+read.
+
+<ul>
+  <li>A lot of hackers (especially users of Perl and other scripting
+  languages) think that regular expressions are the greatest thing
+  since sliced bread and use it for almost everything.  That is just
+  plain wrong.  Other hackers (especially Lispers) tend to think that
+  regular expressions are the work of the devil and try to avoid them
+  at all cost.  That's also wrong.  Regular expressions are a handy
+  and useful addition to your toolkit which you should use when
+  appropriate - you should just try to figure out first <em>if</em>
+  they're appropriate for the task at hand.
+
+  <li>If you're concerned about the string syntax of regular
+  expressions which can look like line noise and is really hard to
+  read for long expressions, consider using
+  CL-PPCRE's <a href="#create-scanner2">S-expression syntax</a>
+  instead.  It is less error-prone and you don't have to worry about
+  escaping characters.  It is also easier to manipulate
+  programmatically.
+
+  <li>For alternations, order is important.  The general rule is that
+  the regex engine tries from left to right and tries to match as much
+  as possible.
+<pre>
+CL-USER 1 > (scan-to-strings "<=|<" "<=")
+"<="
+#()
+
+CL-USER 2 > (scan-to-strings "<|<=" "<=")
+"<"
+#()
+</pre>
+
+   <li><a class=none name="compiler-macro">CL-PPCRE</a>
+   uses <a href="http://www.lispworks.com/documentation/HyperSpec/Body/03_bba.htm">compiler
+   macros</a> to pre-compile scanners
+   at <a href=="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_l.htm#load_time">load
+   time</a> if possible.  This happens if the compiler can determine
+   that the regular expression (no matter if it's a string or an
+   S-expression)
+   is <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_consta.htm">constant</a>
+   at <a href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_c.htm#compile_time">compile
+   time</a> and is intended to save the time for creating scanners
+   at <a href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_e.htm#execution_time">execution
+   time</a> (probably creating the same scanner over and over in a
+   loop).  Make sure you don't prevent the compiler from helping you.
+   For example, a definition like this one is usually not a good idea:
+<pre>
+(defun regex-match (regex target)
+  <font color=orange>;; don't do that!</font>
+  (scan regex target))
+</pre>
+
+  <li>If you want to search for a substring in a large string or if
+  you search for the same string very
+  often, <a href="#scan"><code>SCAN</code></a> will usually be faster
+  than Common
+  Lisp's <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_search.htm"><code>SEARCH</code></a>
+  if you <a href="#*use-bmh-matchers*">use BMH matchers</a>.  However,
+  this only makes sense if scanner creation time is not the
+  limiting factor, i.e. if the search target is <em>very</em> large or
+  if you're using the same scanner very often.
+
+  <li>Complementary to the last hint, <em>don't</em> use regular
+  expressions for one-time searches for constant strings.  That's a
+  terrible waste of resources.
+
+  <li><a href="#*use-bmh-matchers*"><code>*USE-BMH-MATCHERS*</code></a> together with a large value for
+  <a href="#*regex-char-code-limit*"><code>*REGEX-CHAR-CODE-LIMIT*</code></a>
+  can lead to huge scanners.
+
+  <li>A character class is by default translated into a sequence of
+  tests exactly as you might expect.  For
+  example, <code>"[af-l\\d]"</code> means to test if the character is
+  equal to <code>#\a</code>, then to test if it's
+  between <code>#\f</code> and <code>#\l</code>, then if it's a digit.
+  There's by default no attempt to remove redundancy (as
+  in <code>"[a-ge-kf]"</code>) or to otherwise optimize these tests
+  for speed.  However, you can play
+  with <a href="#*optimize-char-classes*"><code>*OPTIMIZE-CHAR-CLASSES*</code></a>
+  if you've identified character classes as a bottleneck and want to
+  make sure that you have <em>O(1)</em> test functions.
+
+  <li>If you know that the expression you're looking for is anchored,
+  use anchors in your regex.  This can help the engine a lot to make
+  your scanners more efficient.
+
+  <li>In addition to anchors, constant strings at the start or end of a
+  regular expression can help the engine to quickly scan a string.
+  Note that for example <code>"(a-d|aebf)"</code>
+  and <code>"ab(cd|ef)"</code> are equivalent, but only the second
+  form has a constant start the regex engine can recognize.
+
+  <li>Try to avoid alternations if possible or at least factor them
+  out as in the example above.
+
+  <li>If neither anchors nor constant strings are in sight, maybe
+  "standalone" (sometimes also called "possessive") regular
+  expressions can be helpful.  Try the following:
+<pre>
+(let ((target (make-string 10000 :initial-element #\a))
+      (scanner-1 (create-scanner "a*\\d"))
+      (scanner-2 (create-scanner "(?>a*)\\d")))
+  (time (scan scanner-1 target))
+  (time (scan scanner-2 target)))
+</pre>
+
+  <li>Consider using <a href="#create-scanner">"single-line mode"</a>
+  if it makes sense for your task.  By default (following Perl's
+  practice), a dot means to search for any character <em>except</em>
+  line breaks.  In single-line mode a dot searches for <em>any</em>
+  character which in some cases means that large parts of the target
+  can actually be skipped.  This can be vastly more efficient for
+  large targets.
+
+  <li>Don't use capturing register groups where a non-capturing group
+  would do, i.e. <em>only</em> use registers if you need to refer to
+  them later.  If you use a register, each scan process needs to
+  allocate space for it and update its contents (possibly many times)
+  until it's finished.  (In Perl parlance - use <code>"(?:foo)"</code> instead of
+  <code>"(foo)"</code> whenever possible.)
+
+  <li>In addition to what has been said in the last hint, note that
+  Perl semantics force the regex engine to report the <em>last</em>
+  match for each register.  This implies for example
+  that <code>"([a-c])+"</code> and <code>"[a-c]*([a-c])"</code> have
+  exactly the same semantics but completely different performance
+  characteristics.  (Actually, in some cases CL-PPCRE automatically
+  converts expressions from the first type into the second type.
+  That's not always possible, though, and you shouldn't rely on it.)
+
+  <li>By default, repetitions are "greedy" in Perl (and thus in
+  CL-PPCRE).  This has an impact on performance and also on the actual
+  outcome of a scan.  Look at your repetitions and ponder if a greedy
+  repetition is really what you want.
+</ul>
+
+<br>&nbsp;<br><h3><a class=none name="ack">Acknowledgements</a></h3>
+
+Although I didn't use their code, I was heavily inspired by looking at
+the Scheme/CL regex implementations of <a
+href="http://www.ccs.neu.edu/home/dorai/pregexp/pregexp.html">Dorai
+Sitaram</a> and <a
+href="http://www.geocities.com/mparker762/clawk#regex">Michael
+Parker</a>. Also, the nice folks from CMUCL's <a
+href="http://www.cons.org/cmucl/support.html">mailing list</a> as well
+as the output of Perl's <code>use re &quot;debug&quot;</code> pragma
+have been very helpful in optimizing the scanners created by CL-PPCRE.
+
+<p>The list of people who participated in this project in one way or
+the other has grown too long to maintain it here.  See the ChangeLog
+for all the people who helped with patches, bug reports, or in other
+ways.  Thanks to all of them!
+
+<p>
+Thanks to the guys at
+&quot;<a href="http://www.weinhandel-ottensen.de/">Caf&eacute;
+Ol&eacute;</a>&quot;
+in <a href="http://en.wikipedia.org/wiki/Hamburg">Hamburg</a> where I
+wrote most of the 0.1.0&nbsp;release and thanks to my wife for lending
+me her PowerBook to test early versions of CL-PPCRE with MCL and
+OpenMCL.
+
+<p>
+$Header: /usr/local/cvsrep/cl-ppcre/doc/index.html,v 1.200 2009/10/28 07:36:31 edi Exp $
+<p><a href="https://edicl.github.io">BACK TO THE HOMEPAGE</a>
+
+</body>
+</html>
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/errors.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/errors.lisp
new file mode 100644
index 0000000..edb7858
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/errors.lisp
@@ -0,0 +1,84 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/errors.lisp,v 1.22 2009/09/17 19:17:31 edi Exp $
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defvar *syntax-error-string* nil
+  "The string which caused the syntax error.")
+
+(define-condition ppcre-error (simple-error)
+  ()
+  (:documentation "All errors signaled by CL-PPCRE are of
+this type."))
+
+(define-condition ppcre-syntax-error (ppcre-error)
+  ((string :initarg :string
+           :reader ppcre-syntax-error-string)
+   (pos :initarg :pos
+        :reader ppcre-syntax-error-pos))
+  (:default-initargs
+      :pos nil
+      :string *syntax-error-string*)
+  (:report (lambda (condition stream)
+             (format stream "~?~@[ at position ~A~]~@[ in string ~S~]"
+                     (simple-condition-format-control condition)
+                     (simple-condition-format-arguments condition)
+                     (ppcre-syntax-error-pos condition)
+                     (ppcre-syntax-error-string condition))))
+  (:documentation "Signaled if CL-PPCRE's parser encounters an error
+when trying to parse a regex string or to convert a parse tree into
+its internal representation."))
+
+(setf (documentation 'ppcre-syntax-error-string 'function)
+      "Returns the string the parser was parsing when the error was
+encountered \(or NIL if the error happened while trying to convert a
+parse tree).")
+
+(setf (documentation 'ppcre-syntax-error-pos 'function)
+      "Returns the position within the string where the error occurred
+\(or NIL if the error happened while trying to convert a parse tree")
+
+(define-condition ppcre-invocation-error (ppcre-error)
+  ()
+  (:documentation "Signaled when CL-PPCRE functions are
+invoked with wrong arguments."))
+
+(defmacro signal-syntax-error* (pos format-control &rest format-arguments)
+  `(error 'ppcre-syntax-error
+          :pos ,pos
+          :format-control ,format-control
+          :format-arguments (list ,@format-arguments)))
+
+(defmacro signal-syntax-error (format-control &rest format-arguments)
+  `(signal-syntax-error* nil ,format-control ,@format-arguments))
+
+(defmacro signal-invocation-error (format-control &rest format-arguments)
+  `(error 'ppcre-invocation-error
+          :format-control ,format-control
+          :format-arguments (list ,@format-arguments)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/lexer.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/lexer.lisp
new file mode 100644
index 0000000..3cdc343
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/lexer.lisp
@@ -0,0 +1,738 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/lexer.lisp,v 1.35 2009/09/17 19:17:31 edi Exp $
+
+;;; The lexer's responsibility is to convert the regex string into a
+;;; sequence of tokens which are in turn consumed by the parser.
+;;;
+;;; The lexer is aware of Perl's 'extended mode' and it also 'knows'
+;;; (with a little help from the parser) how many register groups it
+;;; has opened so far.  (The latter is necessary for interpreting
+;;; strings like "\\10" correctly.)
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(declaim (inline map-char-to-special-class))
+(defun map-char-to-special-char-class (chr)
+  (declare #.*standard-optimize-settings*)
+  "Maps escaped characters like \"\\d\" to the tokens which represent
+their associated character classes."
+  (case chr
+    ((#\d)
+      :digit-class)
+    ((#\D)
+      :non-digit-class)
+    ((#\w)
+      :word-char-class)
+    ((#\W)
+      :non-word-char-class)
+    ((#\s)
+      :whitespace-char-class)
+    ((#\S)
+      :non-whitespace-char-class)))
+
+(declaim (inline make-lexer-internal))
+(defstruct (lexer (:constructor make-lexer-internal))
+  "LEXER structures are used to hold the regex string which is
+currently lexed and to keep track of the lexer's state."
+  (str "" :type string :read-only t)
+  (len 0 :type fixnum :read-only t)
+  (reg 0 :type fixnum)
+  (pos 0 :type fixnum)
+  (last-pos nil :type list))
+
+(defun make-lexer (string)
+  (declare #-:genera (string string))
+  (make-lexer-internal :str (maybe-coerce-to-simple-string string)
+                       :len (length string)))
+
+(declaim (inline end-of-string-p))
+(defun end-of-string-p (lexer)
+  (declare #.*standard-optimize-settings*)
+  "Tests whether we're at the end of the regex string."
+  (<= (lexer-len lexer)
+      (lexer-pos lexer)))
+
+(declaim (inline looking-at-p))
+(defun looking-at-p (lexer chr)
+  (declare #.*standard-optimize-settings*)
+  "Tests whether the next character the lexer would see is CHR.
+Does not respect extended mode."
+  (and (not (end-of-string-p lexer))
+       (char= (schar (lexer-str lexer) (lexer-pos lexer))
+              chr)))
+
+(declaim (inline next-char-non-extended))
+(defun next-char-non-extended (lexer)
+  (declare #.*standard-optimize-settings*)
+  "Returns the next character which is to be examined and updates the
+POS slot. Does not respect extended mode."
+  (cond ((end-of-string-p lexer) nil)
+        (t (prog1
+               (schar (lexer-str lexer) (lexer-pos lexer))
+             (incf (lexer-pos lexer))))))
+
+(defun next-char (lexer)
+  (declare #.*standard-optimize-settings*)
+  "Returns the next character which is to be examined and updates the
+POS slot. Respects extended mode, i.e.  whitespace, comments, and also
+nested comments are skipped if applicable."
+  (let ((next-char (next-char-non-extended lexer))
+        last-loop-pos)
+    (loop
+      ;; remember where we started
+      (setq last-loop-pos (lexer-pos lexer))
+      ;; first we look for nested comments like (?#foo)
+      (when (and next-char
+                 (char= next-char #\()
+                 (looking-at-p lexer #\?))
+        (incf (lexer-pos lexer))
+        (cond ((looking-at-p lexer #\#)
+                ;; must be a nested comment - so we have to search for
+                ;; the closing parenthesis
+                (let ((error-pos (- (lexer-pos lexer) 2)))
+                  (unless
+                      ;; loop 'til ')' or end of regex string and
+                      ;; return NIL if ')' wasn't encountered
+                      (loop for skip-char = next-char
+                            then (next-char-non-extended lexer)
+                            while (and skip-char
+                                       (char/= skip-char #\)))
+                            finally (return skip-char))
+                    (signal-syntax-error* error-pos "Comment group not closed.")))
+                (setq next-char (next-char-non-extended lexer)))
+              (t
+                ;; undo effect of previous INCF if we didn't see a #
+                (decf (lexer-pos lexer)))))
+      (when *extended-mode-p*
+        ;; now - if we're in extended mode - we skip whitespace and
+        ;; comments; repeat the following loop while we look at
+        ;; whitespace or #\#
+        (loop while (and next-char
+                         (or (char= next-char #\#)
+                             (whitespacep next-char)))
+              do (setq next-char
+                         (if (char= next-char #\#)
+                           ;; if we saw a comment marker skip until
+                           ;; we're behind #\Newline...
+                           (loop for skip-char = next-char
+                                 then (next-char-non-extended lexer)
+                                 while (and skip-char
+                                            (char/= skip-char #\Newline))
+                                 finally (return (next-char-non-extended lexer)))
+                           ;; ...otherwise (whitespace) skip until we
+                           ;; see the next non-whitespace character
+                           (loop for skip-char = next-char
+                                 then (next-char-non-extended lexer)
+                                 while (and skip-char
+                                            (whitespacep skip-char))
+                                 finally (return skip-char))))))
+      ;; if the position has moved we have to repeat our tests
+      ;; because of cases like /^a (?#xxx) (?#yyy) {3}c/x which
+      ;; would be equivalent to /^a{3}c/ in Perl
+      (unless (> (lexer-pos lexer) last-loop-pos)
+        (return next-char)))))
+
+(declaim (inline fail))
+(defun fail (lexer)
+  (declare #.*standard-optimize-settings*)
+  "Moves (LEXER-POS LEXER) back to the last position stored in
+\(LEXER-LAST-POS LEXER) and pops the LAST-POS stack."
+  (unless (lexer-last-pos lexer)
+    (signal-syntax-error "LAST-POS stack of LEXER ~A is empty." lexer))
+  (setf (lexer-pos lexer) (pop (lexer-last-pos lexer)))
+  nil)
+
+(defun get-number (lexer &key (radix 10) max-length no-whitespace-p)
+  (declare #.*standard-optimize-settings*)
+  "Read and consume the number the lexer is currently looking at and
+return it. Returns NIL if no number could be identified.
+RADIX is used as in PARSE-INTEGER. If MAX-LENGTH is not NIL we'll read
+at most the next MAX-LENGTH characters. If NO-WHITESPACE-P is not NIL
+we don't tolerate whitespace in front of the number."
+  (when (or (end-of-string-p lexer)
+            (and no-whitespace-p
+                 (whitespacep (schar (lexer-str lexer) (lexer-pos lexer)))))
+    (return-from get-number nil))
+  (multiple-value-bind (integer new-pos)
+      (parse-integer (lexer-str lexer)
+                     :start (lexer-pos lexer)
+                     :end (if max-length
+                            (let ((end-pos (+ (lexer-pos lexer)
+                                              (the fixnum max-length)))
+                                  (lexer-len (lexer-len lexer)))
+                              (if (< end-pos lexer-len)
+                                end-pos
+                                lexer-len))
+                            (lexer-len lexer))
+                     :radix radix
+                     :junk-allowed t)
+    (cond ((and integer (>= (the fixnum integer) 0))
+            (setf (lexer-pos lexer) new-pos)
+            integer)
+          (t nil))))
+
+(declaim (inline try-number))
+(defun try-number (lexer &key (radix 10) max-length no-whitespace-p)
+  (declare #.*standard-optimize-settings*)
+  "Like GET-NUMBER but won't consume anything if no number is seen."
+  ;; remember current position
+  (push (lexer-pos lexer) (lexer-last-pos lexer))
+  (let ((number (get-number lexer
+                            :radix radix
+                            :max-length max-length
+                            :no-whitespace-p no-whitespace-p)))
+    (or number (fail lexer))))
+
+(declaim (inline make-char-from-code))
+(defun make-char-from-code (number error-pos)
+  (declare #.*standard-optimize-settings*)
+  "Create character from char-code NUMBER. NUMBER can be NIL
+which is interpreted as 0. ERROR-POS is the position where
+the corresponding number started within the regex string."
+  ;; only look at rightmost eight bits in compliance with Perl
+  (let ((code (logand #o377 (the fixnum (or number 0)))))
+    (or (and (< code char-code-limit)
+             (code-char code))
+        (signal-syntax-error* error-pos "No character for hex-code ~X." number))))
+
+(defun unescape-char (lexer)
+  (declare #.*standard-optimize-settings*)
+  "Convert the characters\(s) following a backslash into a token
+which is returned. This function is to be called when the backslash
+has already been consumed. Special character classes like \\W are
+handled elsewhere."
+  (when (end-of-string-p lexer)
+    (signal-syntax-error "String ends with backslash."))
+  (let ((chr (next-char-non-extended lexer)))
+    (case chr
+      ((#\E)
+        ;; if \Q quoting is on this is ignored, otherwise it's just an
+        ;; #\E
+        (if *allow-quoting*
+          :void
+          #\E))
+      ((#\c)
+        ;; \cx means control-x in Perl
+        (let ((next-char (next-char-non-extended lexer)))
+          (unless next-char
+            (signal-syntax-error* (lexer-pos lexer) "Character missing after '\\c'"))
+          (code-char (logxor #x40 (char-code (char-upcase next-char))))))
+      ((#\x)
+        ;; \x should be followed by a hexadecimal char code,
+        ;; two digits or less
+        (let* ((error-pos (lexer-pos lexer))
+               (number (get-number lexer :radix 16 :max-length 2 :no-whitespace-p t)))
+          ;; note that it is OK if \x is followed by zero digits
+          (make-char-from-code number error-pos)))
+      ((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
+        ;; \x should be followed by an octal char code,
+        ;; three digits or less
+        (let* ((error-pos (decf (lexer-pos lexer)))
+               (number (get-number lexer :radix 8 :max-length 3)))
+          (make-char-from-code number error-pos)))
+      ;; the following five character names are 'semi-standard'
+      ;; according to the CLHS but I'm not aware of any implementation
+      ;; that doesn't implement them
+      ((#\t)
+        #\Tab)
+      ((#\n)
+        #\Newline)
+      ((#\r)
+        #\Return)
+      ((#\f)
+        #\Page)
+      ((#\b)
+        #\Backspace)
+      ((#\a)
+        (code-char 7))                  ; ASCII bell
+      ((#\e)
+        (code-char 27))                 ; ASCII escape
+      (otherwise
+        ;; all other characters aren't affected by a backslash
+        chr))))
+
+(defun read-char-property (lexer first-char)
+  (declare #.*standard-optimize-settings*)
+  (unless (eql (next-char-non-extended lexer) #\{)
+    (signal-syntax-error* (lexer-pos lexer) "Expected left brace after \\~A." first-char))
+  (let ((name (with-output-to-string (out nil :element-type
+                                          #+:lispworks 'lw:simple-char #-:lispworks 'character)
+                  (loop
+                   (let ((char (or (next-char-non-extended lexer)
+                                   (signal-syntax-error "Unexpected EOF after \\~A{." first-char))))
+                     (when (char= char #\})
+                       (return))
+                     (write-char char out))))))
+    (list (if (char= first-char #\p) :property :inverted-property)
+          name)))
+
+(defun collect-char-class (lexer)
+  "Reads and consumes characters from regex string until a right
+bracket is seen.  Assembles them into a list \(which is returned) of
+characters, character ranges, like \(:RANGE #\\A #\\E) for a-e, and
+tokens representing special character classes."
+  (declare #.*standard-optimize-settings*)
+  (let ((start-pos (lexer-pos lexer))         ; remember start for error message
+        hyphen-seen
+        last-char
+        list)
+    (flet ((handle-char (c)
+             "Do the right thing with character C depending on whether
+we're inside a range or not."
+             (cond ((and hyphen-seen last-char)
+                    (setf (car list) (list :range last-char c)
+                          last-char nil))
+                   (t
+                    (push c list)
+                    (setq last-char c)))
+             (setq hyphen-seen nil)))
+      (loop for first = t then nil
+            for c = (next-char-non-extended lexer)
+            ;; leave loop if at end of string
+            while c
+            do (cond
+                ((char= c #\\)
+                 ;; we've seen a backslash
+                 (let ((next-char (next-char-non-extended lexer)))
+                   (case next-char
+                     ((#\d #\D #\w #\W #\s #\S)
+                      ;; a special character class
+                      (push (map-char-to-special-char-class next-char) list)
+                      ;; if the last character was a hyphen
+                      ;; just collect it literally
+                      (when hyphen-seen
+                        (push #\- list))
+                      ;; if the next character is a hyphen do the same
+                      (when (looking-at-p lexer #\-)
+                        (push #\- list)
+                        (incf (lexer-pos lexer)))
+                      (setq hyphen-seen nil))
+                     ((#\P #\p)
+                      ;; maybe a character property
+                      (cond ((null *property-resolver*)
+                             (handle-char next-char))
+                            (t
+                             (push (read-char-property lexer next-char) list)
+                             ;; if the last character was a hyphen
+                             ;; just collect it literally
+                             (when hyphen-seen
+                               (push #\- list))
+                             ;; if the next character is a hyphen do the same
+                             (when (looking-at-p lexer #\-)
+                               (push #\- list)
+                               (incf (lexer-pos lexer)))
+                             (setq hyphen-seen nil))))
+                     ((#\E)
+                      ;; if \Q quoting is on we ignore \E,
+                      ;; otherwise it's just a plain #\E
+                      (unless *allow-quoting*
+                        (handle-char #\E)))
+                     (otherwise
+                      ;; otherwise unescape the following character(s)
+                      (decf (lexer-pos lexer))
+                      (handle-char (unescape-char lexer))))))
+                (first
+                 ;; the first character must not be a right bracket
+                 ;; and isn't treated specially if it's a hyphen
+                 (handle-char c))
+                ((char= c #\])
+                 ;; end of character class
+                 ;; make sure we collect a pending hyphen
+                 (when hyphen-seen
+                   (setq hyphen-seen nil)
+                   (handle-char #\-))
+                 ;; reverse the list to preserve the order intended
+                 ;; by the author of the regex string
+                 (return-from collect-char-class (nreverse list)))
+                ((and (char= c #\-)
+                      last-char
+                      (not hyphen-seen))
+                 ;; if the last character was 'just a character'
+                 ;; we expect to be in the middle of a range
+                 (setq hyphen-seen t))
+                ((char= c #\-)
+                 ;; otherwise this is just an ordinary hyphen
+                 (handle-char #\-))
+                (t
+                 ;; default case - just collect the character
+                 (handle-char c))))
+      ;; we can only exit the loop normally if we've reached the end
+      ;; of the regex string without seeing a right bracket
+      (signal-syntax-error* start-pos "Missing right bracket to close character class."))))
+
+(defun maybe-parse-flags (lexer)
+  (declare #.*standard-optimize-settings*)
+  "Reads a sequence of modifiers \(including #\\- to reverse their
+meaning) and returns a corresponding list of \"flag\" tokens.  The
+\"x\" modifier is treated specially in that it dynamically modifies
+the behaviour of the lexer itself via the special variable
+*EXTENDED-MODE-P*."
+  (prog1
+    (loop with set = t
+          for chr = (next-char-non-extended lexer)
+          unless chr
+            do (signal-syntax-error "Unexpected end of string.")
+          while (find chr "-imsx" :test #'char=)
+          ;; the first #\- will invert the meaning of all modifiers
+          ;; following it
+          if (char= chr #\-)
+            do (setq set nil)
+          else if (char= chr #\x)
+            do (setq *extended-mode-p* set)
+          else collect (if set
+                         (case chr
+                           ((#\i)
+                             :case-insensitive-p)
+                           ((#\m)
+                             :multi-line-mode-p)
+                           ((#\s)
+                             :single-line-mode-p))
+                         (case chr
+                           ((#\i)
+                             :case-sensitive-p)
+                           ((#\m)
+                             :not-multi-line-mode-p)
+                           ((#\s)
+                             :not-single-line-mode-p))))
+    (decf (lexer-pos lexer))))
+
+(defun get-quantifier (lexer)
+  (declare #.*standard-optimize-settings*)
+  "Returns a list of two values (min max) if what the lexer is looking
+at can be interpreted as a quantifier. Otherwise returns NIL and
+resets the lexer to its old position."
+  ;; remember starting position for FAIL and UNGET-TOKEN functions
+  (push (lexer-pos lexer) (lexer-last-pos lexer))
+  (let ((next-char (next-char lexer)))
+    (case next-char
+      ((#\*)
+        ;; * (Kleene star): match 0 or more times
+        '(0 nil))
+      ((#\+)
+        ;; +: match 1 or more times
+        '(1 nil))
+      ((#\?)
+        ;; ?: match 0 or 1 times
+        '(0 1))
+      ((#\{)
+        ;; one of
+        ;;   {n}:   match exactly n times
+        ;;   {n,}:  match at least n times
+        ;;   {n,m}: match at least n but not more than m times
+        ;; note that anything not matching one of these patterns will
+        ;; be interpreted literally - even whitespace isn't allowed
+        (let ((num1 (get-number lexer :no-whitespace-p t)))
+          (if num1
+            (let ((next-char (next-char-non-extended lexer)))
+              (case next-char
+                ((#\,)
+                  (let* ((num2 (get-number lexer :no-whitespace-p t))
+                         (next-char (next-char-non-extended lexer)))
+                    (case next-char
+                      ((#\})
+                        ;; this is the case {n,} (NUM2 is NIL) or {n,m}
+                        (list num1 num2))
+                      (otherwise
+                        (fail lexer)))))
+                ((#\})
+                  ;; this is the case {n}
+                  (list num1 num1))
+                (otherwise
+                  (fail lexer))))
+            ;; no number following left curly brace, so we treat it
+            ;; like a normal character
+            (fail lexer))))
+      ;; cannot be a quantifier
+      (otherwise
+        (fail lexer)))))
+
+(defun parse-register-name-aux (lexer)
+  "Reads and returns the name in a named register group.  It is
+assumed that the starting #\< character has already been read.  The
+closing #\> will also be consumed."
+  ;; we have to look for an ending > character now
+  (let ((end-name (position #\>
+                            (lexer-str lexer)
+                            :start (lexer-pos lexer)
+                            :test #'char=)))
+    (unless end-name
+      ;; there has to be > somewhere, syntax error otherwise
+      (signal-syntax-error* (1- (lexer-pos lexer)) "Opening #\< in named group has no closing #\>."))
+    (let ((name (subseq (lexer-str lexer)
+                        (lexer-pos lexer)
+                        end-name)))
+      (unless (every #'(lambda (char)
+                         (or (alphanumericp char)
+                             (char= #\- char)))
+                     name)
+        ;; register name can contain only alphanumeric characters or #\-
+        (signal-syntax-error* (lexer-pos lexer) "Invalid character in named register group."))
+      ;; advance lexer beyond "<name>" part
+      (setf (lexer-pos lexer) (1+ end-name))
+      name)))
+
+(declaim (inline unget-token))
+(defun unget-token (lexer)
+  (declare #.*standard-optimize-settings*)
+  "Moves the lexer back to the last position stored in the LAST-POS stack."
+  (if (lexer-last-pos lexer)
+    (setf (lexer-pos lexer)
+            (pop (lexer-last-pos lexer)))
+    (error "No token to unget \(this should not happen)")))
+
+(defun get-token (lexer)
+  (declare #.*standard-optimize-settings*)
+  "Returns and consumes the next token from the regex string \(or NIL)."
+  ;; remember starting position for UNGET-TOKEN function
+  (push (lexer-pos lexer)
+        (lexer-last-pos lexer))
+  (let ((next-char (next-char lexer)))
+    (cond (next-char
+           (case next-char
+             ;; the easy cases first - the following six characters
+             ;; always have a special meaning and get translated
+             ;; into tokens immediately
+             ((#\))
+              :close-paren)
+             ((#\|)
+              :vertical-bar)
+             ((#\?)
+              :question-mark)
+             ((#\.)
+              :everything)
+             ((#\^)
+              :start-anchor)
+             ((#\$)
+              :end-anchor)
+             ((#\+ #\*)
+              ;; quantifiers will always be consumend by
+              ;; GET-QUANTIFIER, they must not appear here
+              (signal-syntax-error* (1- (lexer-pos lexer)) "Quantifier '~A' not allowed." next-char))
+             ((#\{)
+              ;; left brace isn't a special character in it's own
+              ;; right but we must check if what follows might
+              ;; look like a quantifier
+              (let ((this-pos (lexer-pos lexer))
+                    (this-last-pos (lexer-last-pos lexer)))
+                (unget-token lexer)
+                (when (get-quantifier lexer)
+                  (signal-syntax-error* (car this-last-pos)
+                                        "Quantifier '~A' not allowed."
+                                        (subseq (lexer-str lexer)
+                                                (car this-last-pos)
+                                                (lexer-pos lexer))))
+                (setf (lexer-pos lexer) this-pos
+                      (lexer-last-pos lexer) this-last-pos)
+                next-char))
+             ((#\[)
+              ;; left bracket always starts a character class
+              (cons  (cond ((looking-at-p lexer #\^)
+                            (incf (lexer-pos lexer))
+                            :inverted-char-class)
+                           (t
+                            :char-class))
+                     (collect-char-class lexer)))
+             ((#\\)
+              ;; backslash might mean different things so we have
+              ;; to peek one char ahead:
+              (let ((next-char (next-char-non-extended lexer)))
+                (case next-char
+                  ((#\A)
+                   :modeless-start-anchor)
+                  ((#\Z)
+                   :modeless-end-anchor)
+                  ((#\z)
+                   :modeless-end-anchor-no-newline)
+                  ((#\b)
+                   :word-boundary)
+                  ((#\B)
+                   :non-word-boundary)
+                  ((#\k)
+                   (cond ((and *allow-named-registers*
+                               (looking-at-p lexer #\<))
+                          ;; back-referencing a named register
+                          (incf (lexer-pos lexer))
+                          (list :back-reference
+                                (parse-register-name-aux lexer)))
+                         (t
+                          ;; false alarm, just unescape \k
+                          #\k)))
+                  ((#\d #\D #\w #\W #\s #\S)
+                   ;; these will be treated like character classes
+                   (map-char-to-special-char-class next-char))
+                  ((#\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
+                   ;; uh, a digit...
+                   (let* ((old-pos (decf (lexer-pos lexer)))
+                          ;; ...so let's get the whole number first
+                          (backref-number (get-number lexer)))
+                     (declare (fixnum backref-number))
+                     (cond ((and (> backref-number (lexer-reg lexer))
+                                 (<= 10 backref-number))
+                            ;; \10 and higher are treated as octal
+                            ;; character codes if we haven't
+                            ;; opened that much register groups
+                            ;; yet
+                            (setf (lexer-pos lexer) old-pos)
+                            ;; re-read the number from the old
+                            ;; position and convert it to its
+                            ;; corresponding character
+                            (make-char-from-code (get-number lexer :radix 8 :max-length 3)
+                                                 old-pos))
+                           (t
+                            ;; otherwise this must refer to a
+                            ;; backreference
+                            (list :back-reference backref-number)))))
+                  ((#\0)
+                   ;; this always means an octal character code
+                   ;; (at most three digits)
+                   (let ((old-pos (decf (lexer-pos lexer))))
+                     (make-char-from-code (get-number lexer :radix 8 :max-length 3)
+                                          old-pos)))
+                  ((#\P #\p)
+                   ;; might be a named property
+                   (cond (*property-resolver* (read-char-property lexer next-char))
+                         (t next-char)))
+                  (otherwise
+                   ;; in all other cases just unescape the
+                   ;; character
+                   (decf (lexer-pos lexer))
+                   (unescape-char lexer)))))
+             ((#\()
+              ;; an open parenthesis might mean different things
+              ;; depending on what follows...
+              (cond ((looking-at-p lexer #\?)
+                     ;; this is the case '(?' (and probably more behind)
+                     (incf (lexer-pos lexer))
+                     ;; we have to check for modifiers first
+                     ;; because a colon might follow
+                     (let* ((flags (maybe-parse-flags lexer))
+                            (next-char (next-char-non-extended lexer)))
+                       ;; modifiers are only allowed if a colon
+                       ;; or a closing parenthesis are following
+                       (when (and flags
+                                  (not (find next-char ":)" :test #'char=)))
+                         (signal-syntax-error* (car (lexer-last-pos lexer))
+                                               "Sequence '~A' not recognized."
+                                               (subseq (lexer-str lexer)
+                                                       (car (lexer-last-pos lexer))
+                                                       (lexer-pos lexer))))
+                       (case next-char
+                         ((nil)
+                          ;; syntax error
+                          (signal-syntax-error "End of string following '(?'."))
+                         ((#\))
+                          ;; an empty group except for the flags
+                          ;; (if there are any)
+                          (or (and flags
+                                   (cons :flags flags))
+                              :void))
+                         ((#\()
+                          ;; branch
+                          :open-paren-paren)
+                         ((#\>)
+                          ;; standalone
+                          :open-paren-greater)
+                         ((#\=)
+                          ;; positive look-ahead
+                          :open-paren-equal)
+                         ((#\!)
+                          ;; negative look-ahead
+                          :open-paren-exclamation)
+                         ((#\:)
+                          ;; non-capturing group - return flags as
+                          ;; second value
+                          (values :open-paren-colon flags))
+                         ((#\<)
+                          ;; might be a look-behind assertion or a named group, so
+                          ;; check next character
+                          (let ((next-char (next-char-non-extended lexer)))
+                            (cond ((and next-char
+                                        (alpha-char-p next-char))
+                                   ;; we have encountered a named group
+                                   ;; are we supporting register naming?
+                                   (unless *allow-named-registers*
+                                     (signal-syntax-error* (1- (lexer-pos lexer))
+                                                           "Character '~A' may not follow '(?<' (because ~a = NIL)"
+                                                           next-char
+                                                           '*allow-named-registers*))
+                                   ;; put the letter back
+                                   (decf (lexer-pos lexer))
+                                   ;; named group
+                                   :open-paren-less-letter)
+                                  (t
+                                   (case next-char
+                                     ((#\=)
+                                      ;; positive look-behind
+                                      :open-paren-less-equal)
+                                     ((#\!)
+                                      ;; negative look-behind
+                                      :open-paren-less-exclamation)
+                                     ((#\))
+                                      ;; Perl allows "(?<)" and treats
+                                      ;; it like a null string
+                                      :void)
+                                     ((nil)
+                                      ;; syntax error
+                                      (signal-syntax-error "End of string following '(?<'."))
+                                     (t
+                                      ;; also syntax error
+                                      (signal-syntax-error* (1- (lexer-pos lexer))
+                                                            "Character '~A' may not follow '(?<'."
+                                                            next-char )))))))
+                         (otherwise
+                          (signal-syntax-error* (1- (lexer-pos lexer))
+                                                "Character '~A' may not follow '(?'."
+                                                next-char)))))
+                    (t
+                     ;; if next-char was not #\? (this is within
+                     ;; the first COND), we've just seen an opening
+                     ;; parenthesis and leave it like that
+                     :open-paren)))
+             (otherwise
+              ;; all other characters are their own tokens
+              next-char)))
+          ;; we didn't get a character (this if the "else" branch from
+          ;; the first IF), so we don't return a token but NIL
+          (t
+           (pop (lexer-last-pos lexer))
+           nil))))
+
+(declaim (inline start-of-subexpr-p))
+(defun start-of-subexpr-p (lexer)
+  (declare #.*standard-optimize-settings*)
+  "Tests whether the next token can start a valid sub-expression, i.e.
+a stand-alone regex."
+  (let* ((pos (lexer-pos lexer))
+         (next-char (next-char lexer)))
+    (not (or (null next-char)
+             (prog1
+               (member (the character next-char)
+                       '(#\) #\|)
+                       :test #'char=)
+               (setf (lexer-pos lexer) pos))))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/optimize.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/optimize.lisp
new file mode 100644
index 0000000..d538733
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/optimize.lisp
@@ -0,0 +1,578 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/optimize.lisp,v 1.36 2009/09/17 19:17:31 edi Exp $
+
+;;; This file contains optimizations which can be applied to converted
+;;; parse trees.
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defgeneric flatten (regex)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Merges adjacent sequences and alternations, i.e. it
+transforms #<SEQ #<STR \"a\"> #<SEQ #<STR \"b\"> #<STR \"c\">>> to
+#<SEQ #<STR \"a\"> #<STR \"b\"> #<STR \"c\">>. This is a destructive
+operation on REGEX."))
+
+(defmethod flatten ((seq seq))
+  (declare #.*standard-optimize-settings*)
+  ;; this looks more complicated than it is because we modify SEQ in
+  ;; place to avoid unnecessary consing
+  (let ((elements-rest (elements seq)))
+    (loop
+      (unless elements-rest
+        (return))
+      (let ((flattened-element (flatten (car elements-rest)))
+            (next-elements-rest (cdr elements-rest)))
+        (cond ((typep flattened-element 'seq)
+                ;; FLATTENED-ELEMENT is a SEQ object, so we "splice"
+                ;; it into out list of elements
+                (let ((flattened-element-elements
+                        (elements flattened-element)))
+                  (setf (car elements-rest)
+                          (car flattened-element-elements)
+                        (cdr elements-rest)
+                          (nconc (cdr flattened-element-elements)
+                                 (cdr elements-rest)))))
+              (t
+                ;; otherwise we just replace the current element with
+                ;; its flattened counterpart
+                (setf (car elements-rest) flattened-element)))
+        (setq elements-rest next-elements-rest))))
+  (let ((elements (elements seq)))
+    (cond ((cadr elements)
+            seq)
+          ((cdr elements)
+            (first elements))
+          (t (make-instance 'void)))))
+
+(defmethod flatten ((alternation alternation))
+  (declare #.*standard-optimize-settings*)
+  ;; same algorithm as above
+  (let ((choices-rest (choices alternation)))
+    (loop
+      (unless choices-rest
+        (return))
+      (let ((flattened-choice (flatten (car choices-rest)))
+            (next-choices-rest (cdr choices-rest)))
+        (cond ((typep flattened-choice 'alternation)
+                (let ((flattened-choice-choices
+                        (choices flattened-choice)))
+                  (setf (car choices-rest)
+                          (car flattened-choice-choices)
+                        (cdr choices-rest)
+                          (nconc (cdr flattened-choice-choices)
+                                 (cdr choices-rest)))))
+              (t
+                (setf (car choices-rest) flattened-choice)))
+        (setq choices-rest next-choices-rest))))
+  (let ((choices (choices alternation)))
+    (cond ((cadr choices)
+            alternation)
+          ((cdr choices)
+            (first choices))
+          (t (signal-syntax-error "Encountered alternation without choices.")))))
+
+(defmethod flatten ((branch branch))
+  (declare #.*standard-optimize-settings*)
+  (with-slots (test then-regex else-regex)
+      branch
+    (setq test
+            (if (numberp test)
+              test
+              (flatten test))
+          then-regex (flatten then-regex)
+          else-regex (flatten else-regex))
+    branch))
+
+(defmethod flatten ((regex regex))
+  (declare #.*standard-optimize-settings*)
+  (typecase regex
+    ((or repetition register lookahead lookbehind standalone)
+      ;; if REGEX contains exactly one inner REGEX object flatten it
+      (setf (regex regex)
+              (flatten (regex regex)))
+      regex)
+    (t
+      ;; otherwise (ANCHOR, BACK-REFERENCE, CHAR-CLASS, EVERYTHING,
+      ;; LOOKAHEAD, LOOKBEHIND, STR, VOID, FILTER, and WORD-BOUNDARY)
+      ;; do nothing
+      regex)))
+
+(defgeneric gather-strings (regex)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Collects adjacent strings or characters into one
+string provided they have the same case mode. This is a destructive
+operation on REGEX."))
+
+(defmethod gather-strings ((seq seq))
+  (declare #.*standard-optimize-settings*)
+  ;; note that GATHER-STRINGS is to be applied after FLATTEN, i.e. it
+  ;; expects SEQ to be flattened already; in particular, SEQ cannot be
+  ;; empty and cannot contain embedded SEQ objects
+  (let* ((start-point (cons nil (elements seq)))
+         (curr-point start-point)
+         old-case-mode
+         collector
+         collector-start
+         (collector-length 0)
+         skip)
+    (declare (fixnum collector-length))
+    (loop
+      (let ((elements-rest (cdr curr-point)))
+        (unless elements-rest
+          (return))
+        (let* ((element (car elements-rest))
+               (case-mode (case-mode element old-case-mode)))
+          (cond ((and case-mode
+                      (eq case-mode old-case-mode))
+                  ;; if ELEMENT is a STR and we have collected a STR of
+                  ;; the same case mode in the last iteration we
+                  ;; concatenate ELEMENT onto COLLECTOR and remember the
+                  ;; value of its SKIP slot
+                  (let ((old-collector-length collector-length))
+                    (unless (and (adjustable-array-p collector)
+                                 (array-has-fill-pointer-p collector))
+                      (setq collector
+                              (make-array collector-length
+                                          :initial-contents collector
+                                          :element-type 'character
+                                          :fill-pointer t
+                                          :adjustable t)
+                            collector-start nil))
+                    (adjust-array collector
+                                  (incf collector-length (len element))
+                                  :fill-pointer t)
+                    (setf (subseq collector
+                                  old-collector-length)
+                            (str element)
+                          ;; it suffices to remember the last SKIP slot
+                          ;; because due to the way MAYBE-ACCUMULATE
+                          ;; works adjacent STR objects have the same
+                          ;; SKIP value
+                          skip (skip element)))
+                  (setf (cdr curr-point) (cdr elements-rest)))
+                (t
+                  (let ((collected-string
+                          (cond (collector-start
+                                  collector-start)
+                                (collector
+                                  ;; if we have collected something already
+                                  ;; we convert it into a STR
+                                  (make-instance 'str
+                                                 :skip skip
+                                                 :str collector
+                                                 :case-insensitive-p
+                                                 (eq old-case-mode
+                                                     :case-insensitive)))
+                                (t nil))))
+                    (cond (case-mode
+                            ;; if ELEMENT is a string with a different case
+                            ;; mode than the last one we have either just
+                            ;; converted COLLECTOR into a STR or COLLECTOR
+                            ;; is still empty; in both cases we can now
+                            ;; begin to fill it anew
+                            (setq collector (str element)
+                                  collector-start element
+                                  ;; and we remember the SKIP value as above
+                                  skip (skip element)
+                                  collector-length (len element))
+                            (cond (collected-string
+                                    (setf (car elements-rest)
+                                            collected-string
+                                          curr-point
+                                            (cdr curr-point)))
+                                  (t
+                                    (setf (cdr curr-point)
+                                            (cdr elements-rest)))))
+                          (t
+                            ;; otherwise this is not a STR so we apply
+                            ;; GATHER-STRINGS to it and collect it directly
+                            ;; into RESULT
+                            (cond (collected-string
+                                    (setf (car elements-rest)
+                                            collected-string
+                                          curr-point
+                                            (cdr curr-point)
+                                          (cdr curr-point)
+                                            (cons (gather-strings element)
+                                                  (cdr curr-point))
+                                          curr-point
+                                            (cdr curr-point)))
+                                  (t
+                                    (setf (car elements-rest)
+                                            (gather-strings element)
+                                          curr-point
+                                            (cdr curr-point))))
+                            ;; we also have to empty COLLECTOR here in case
+                            ;; it was still filled from the last iteration
+                            (setq collector nil
+                                  collector-start nil))))))
+          (setq old-case-mode case-mode))))
+    (when collector
+      (setf (cdr curr-point)
+              (cons
+               (make-instance 'str
+                              :skip skip
+                              :str collector
+                              :case-insensitive-p
+                              (eq old-case-mode
+                                  :case-insensitive))
+               nil)))
+    (setf (elements seq) (cdr start-point))
+    seq))
+
+(defmethod gather-strings ((alternation alternation))
+  (declare #.*standard-optimize-settings*)
+  ;; loop ON the choices of ALTERNATION so we can modify them directly
+  (loop for choices-rest on (choices alternation)
+        while choices-rest
+        do (setf (car choices-rest)
+                   (gather-strings (car choices-rest))))
+  alternation)
+
+(defmethod gather-strings ((branch branch))
+  (declare #.*standard-optimize-settings*)
+  (with-slots (test then-regex else-regex)
+      branch
+    (setq test
+            (if (numberp test)
+              test
+              (gather-strings test))
+          then-regex (gather-strings then-regex)
+          else-regex (gather-strings else-regex))
+    branch))
+
+(defmethod gather-strings ((regex regex))
+  (declare #.*standard-optimize-settings*)
+  (typecase regex
+    ((or repetition register lookahead lookbehind standalone)
+      ;; if REGEX contains exactly one inner REGEX object apply
+      ;; GATHER-STRINGS to it
+      (setf (regex regex)
+              (gather-strings (regex regex)))
+      regex)
+    (t
+      ;; otherwise (ANCHOR, BACK-REFERENCE, CHAR-CLASS, EVERYTHING,
+      ;; LOOKAHEAD, LOOKBEHIND, STR, VOID, FILTER, and WORD-BOUNDARY)
+      ;; do nothing
+      regex)))
+
+;; Note that START-ANCHORED-P will be called after FLATTEN and GATHER-STRINGS.
+
+(defgeneric start-anchored-p (regex &optional in-seq-p)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Returns T if REGEX starts with a \"real\" start
+anchor, i.e. one that's not in multi-line mode, NIL otherwise. If
+IN-SEQ-P is true the function will return :ZERO-LENGTH if REGEX is a
+zero-length assertion."))
+
+(defmethod start-anchored-p ((seq seq) &optional in-seq-p)
+  (declare (ignore in-seq-p))
+  ;; note that START-ANCHORED-P is to be applied after FLATTEN and
+  ;; GATHER-STRINGS, i.e. SEQ cannot be empty and cannot contain
+  ;; embedded SEQ objects
+  (loop for element in (elements seq)
+        for anchored-p = (start-anchored-p element t)
+        ;; skip zero-length elements because they won't affect the
+        ;; "anchoredness" of the sequence
+        while (eq anchored-p :zero-length)
+        finally (return (and anchored-p (not (eq anchored-p :zero-length))))))
+
+(defmethod start-anchored-p ((alternation alternation) &optional in-seq-p)
+  (declare #.*standard-optimize-settings*)
+  (declare (ignore in-seq-p))
+  ;; clearly an alternation can only be start-anchored if all of its
+  ;; choices are start-anchored
+  (loop for choice in (choices alternation)
+        always (start-anchored-p choice)))
+
+(defmethod start-anchored-p ((branch branch) &optional in-seq-p)
+  (declare #.*standard-optimize-settings*)
+  (declare (ignore in-seq-p))
+  (and (start-anchored-p (then-regex branch))
+       (start-anchored-p (else-regex branch))))
+
+(defmethod start-anchored-p ((repetition repetition) &optional in-seq-p)
+  (declare #.*standard-optimize-settings*)
+  (declare (ignore in-seq-p))
+  ;; well, this wouldn't make much sense, but anyway...
+  (and (plusp (minimum repetition))
+       (start-anchored-p (regex repetition))))
+
+(defmethod start-anchored-p ((register register) &optional in-seq-p)
+  (declare #.*standard-optimize-settings*)
+  (declare (ignore in-seq-p))
+  (start-anchored-p (regex register)))
+
+(defmethod start-anchored-p ((standalone standalone) &optional in-seq-p)
+  (declare #.*standard-optimize-settings*)
+  (declare (ignore in-seq-p))
+  (start-anchored-p (regex standalone)))
+
+(defmethod start-anchored-p ((anchor anchor) &optional in-seq-p)
+  (declare #.*standard-optimize-settings*)
+  (declare (ignore in-seq-p))
+  (and (startp anchor)
+       (not (multi-line-p anchor))))
+
+(defmethod start-anchored-p ((regex regex) &optional in-seq-p)
+  (declare #.*standard-optimize-settings*)
+  (typecase regex
+    ((or lookahead lookbehind word-boundary void)
+      ;; zero-length assertions
+      (if in-seq-p
+        :zero-length
+        nil))
+    (filter
+      (if (and in-seq-p
+               (len regex)
+               (zerop (len regex)))
+        :zero-length
+        nil))
+    (t
+      ;; BACK-REFERENCE, CHAR-CLASS, EVERYTHING, and STR
+      nil)))
+
+;; Note that END-STRING-AUX will be called after FLATTEN and GATHER-STRINGS.
+
+(defgeneric end-string-aux (regex &optional old-case-insensitive-p)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Returns the constant string (if it exists) REGEX
+ends with wrapped into a STR object, otherwise NIL.
+OLD-CASE-INSENSITIVE-P is the CASE-INSENSITIVE-P slot of the last STR
+collected or :VOID if no STR has been collected yet. (This is a helper
+function called by END-STRING.)"))
+
+(defmethod end-string-aux ((str str)
+                           &optional (old-case-insensitive-p :void))
+  (declare #.*standard-optimize-settings*)
+  (declare (special last-str))
+  (cond ((and (not (skip str))          ; avoid constituents of STARTS-WITH
+              ;; only use STR if nothing has been collected yet or if
+              ;; the collected string has the same value for
+              ;; CASE-INSENSITIVE-P
+              (or (eq old-case-insensitive-p :void)
+                  (eq (case-insensitive-p str) old-case-insensitive-p)))
+          (setf last-str str
+                ;; set the SKIP property of this STR
+                (skip str) t)
+          str)
+        (t nil)))
+
+(defmethod end-string-aux ((seq seq)
+                           &optional (old-case-insensitive-p :void))
+  (declare #.*standard-optimize-settings*)
+  (declare (special continuep))
+  (let (case-insensitive-p
+        concatenated-string
+        concatenated-start
+        (concatenated-length 0))
+    (declare (fixnum concatenated-length))
+    (loop for element in (reverse (elements seq))
+          ;; remember the case-(in)sensitivity of the last relevant
+          ;; STR object
+          for loop-old-case-insensitive-p = old-case-insensitive-p
+            then (if skip
+                   loop-old-case-insensitive-p
+                   (case-insensitive-p element-end))
+          ;; the end-string of the current element
+          for element-end = (end-string-aux element
+                                            loop-old-case-insensitive-p)
+          ;; whether we encountered a zero-length element
+          for skip = (if element-end
+                       (zerop (len element-end))
+                       nil)
+          ;; set CONTINUEP to NIL if we have to stop collecting to
+          ;; alert END-STRING-AUX methods on enclosing SEQ objects
+          unless element-end
+            do (setq continuep nil)
+          ;; end loop if we neither got a STR nor a zero-length
+          ;; element
+          while element-end
+          ;; only collect if not zero-length
+          unless skip
+            do (cond (concatenated-string
+                       (when concatenated-start
+                         (setf concatenated-string
+                                 (make-array concatenated-length
+                                             :initial-contents (reverse (str concatenated-start))
+                                             :element-type 'character
+                                             :fill-pointer t
+                                             :adjustable t)
+                               concatenated-start nil))
+                       (let ((len (len element-end))
+                             (str (str element-end)))
+                         (declare (fixnum len))
+                         (incf concatenated-length len)
+                         (loop for i of-type fixnum downfrom (1- len) to 0
+                               do (vector-push-extend (char str i)
+                                                      concatenated-string))))
+                     (t
+                       (setf concatenated-string
+                               t
+                             concatenated-start
+                               element-end
+                             concatenated-length
+                               (len element-end)
+                             case-insensitive-p
+                               (case-insensitive-p element-end))))
+          ;; stop collecting if END-STRING-AUX on inner SEQ has said so
+          while continuep)
+    (cond ((zerop concatenated-length)
+            ;; don't bother to return zero-length strings
+            nil)
+          (concatenated-start
+            concatenated-start)
+          (t
+            (make-instance 'str
+                           :str (nreverse concatenated-string)
+                           :case-insensitive-p case-insensitive-p)))))
+
+(defmethod end-string-aux ((register register)
+                           &optional (old-case-insensitive-p :void))
+  (declare #.*standard-optimize-settings*)
+  (end-string-aux (regex register) old-case-insensitive-p))
+    
+(defmethod end-string-aux ((standalone standalone)
+                           &optional (old-case-insensitive-p :void))
+  (declare #.*standard-optimize-settings*)
+  (end-string-aux (regex standalone) old-case-insensitive-p))
+    
+(defmethod end-string-aux ((regex regex)
+                           &optional (old-case-insensitive-p :void))
+  (declare #.*standard-optimize-settings*)
+  (declare (special last-str end-anchored-p continuep))
+  (typecase regex
+    ((or anchor lookahead lookbehind word-boundary void)
+      ;; a zero-length REGEX object - for the sake of END-STRING-AUX
+      ;; this is a zero-length string
+      (when (and (typep regex 'anchor)
+                 (not (startp regex))
+                 (or (no-newline-p regex)
+                     (not (multi-line-p regex)))
+                 (eq old-case-insensitive-p :void))
+        ;; if this is a "real" end-anchor and we haven't collected
+        ;; anything so far we can set END-ANCHORED-P (where 1 or 0
+        ;; indicate whether we accept a #\Newline at the end or not)
+        (setq end-anchored-p (if (no-newline-p regex) 0 1)))
+      (make-instance 'str
+                     :str ""
+                     :case-insensitive-p :void))
+    (t
+      ;; (ALTERNATION, BACK-REFERENCE, BRANCH, CHAR-CLASS, EVERYTHING,
+      ;; REPETITION, FILTER)
+      nil)))
+
+(defun end-string (regex)
+  (declare (special end-string-offset))
+  (declare #.*standard-optimize-settings*)
+  "Returns the constant string (if it exists) REGEX ends with wrapped
+into a STR object, otherwise NIL."
+  ;; LAST-STR points to the last STR object (seen from the end) that's
+  ;; part of END-STRING; CONTINUEP is set to T if we stop collecting
+  ;; in the middle of a SEQ
+  (let ((continuep t)
+        last-str)
+    (declare (special continuep last-str))
+    (prog1
+      (end-string-aux regex)
+      (when last-str
+        ;; if we've found something set the START-OF-END-STRING-P of
+        ;; the leftmost STR collected accordingly and remember the
+        ;; OFFSET of this STR (in a special variable provided by the
+        ;; caller of this function)
+        (setf (start-of-end-string-p last-str) t
+              end-string-offset (offset last-str))))))
+
+(defgeneric compute-min-rest (regex current-min-rest)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Returns the minimal length of REGEX plus
+CURRENT-MIN-REST. This is similar to REGEX-MIN-LENGTH except that it
+recurses down into REGEX and sets the MIN-REST slots of REPETITION
+objects."))
+
+(defmethod compute-min-rest ((seq seq) current-min-rest)
+  (declare #.*standard-optimize-settings*)
+  (loop for element in (reverse (elements seq))
+        for last-min-rest = current-min-rest then this-min-rest
+        for this-min-rest = (compute-min-rest element last-min-rest)
+        finally (return this-min-rest)))
+    
+(defmethod compute-min-rest ((alternation alternation) current-min-rest)
+  (declare #.*standard-optimize-settings*)
+  (loop for choice in (choices alternation)
+        minimize (compute-min-rest choice current-min-rest)))
+
+(defmethod compute-min-rest ((branch branch) current-min-rest)
+  (declare #.*standard-optimize-settings*)
+  (min (compute-min-rest (then-regex branch) current-min-rest)
+       (compute-min-rest (else-regex branch) current-min-rest)))
+
+(defmethod compute-min-rest ((str str) current-min-rest)
+  (declare #.*standard-optimize-settings*)
+  (+ current-min-rest (len str)))
+    
+(defmethod compute-min-rest ((filter filter) current-min-rest)
+  (declare #.*standard-optimize-settings*)
+  (+ current-min-rest (or (len filter) 0)))
+    
+(defmethod compute-min-rest ((repetition repetition) current-min-rest)
+  (declare #.*standard-optimize-settings*)
+  (setf (min-rest repetition) current-min-rest)
+  (compute-min-rest (regex repetition) current-min-rest)
+  (+ current-min-rest (* (minimum repetition) (min-len repetition))))
+
+(defmethod compute-min-rest ((register register) current-min-rest)
+  (declare #.*standard-optimize-settings*)
+  (compute-min-rest (regex register) current-min-rest))
+    
+(defmethod compute-min-rest ((standalone standalone) current-min-rest)
+  (declare #.*standard-optimize-settings*)
+  (declare (ignore current-min-rest))
+  (compute-min-rest (regex standalone) 0))
+    
+(defmethod compute-min-rest ((lookahead lookahead) current-min-rest)
+  (declare #.*standard-optimize-settings*)
+  (compute-min-rest (regex lookahead) 0)
+  current-min-rest)
+    
+(defmethod compute-min-rest ((lookbehind lookbehind) current-min-rest)
+  (declare #.*standard-optimize-settings*)
+  (compute-min-rest (regex lookbehind) (+ current-min-rest (len lookbehind)))
+  current-min-rest)
+    
+(defmethod compute-min-rest ((regex regex) current-min-rest)
+  (declare #.*standard-optimize-settings*)
+  (typecase regex
+    ((or char-class everything)
+      (1+ current-min-rest))
+    (t
+      ;; zero min-len and no embedded regexes (ANCHOR,
+      ;; BACK-REFERENCE, VOID, and WORD-BOUNDARY)
+      current-min-rest)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/packages.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/packages.lisp
new file mode 100644
index 0000000..74faa44
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/packages.lisp
@@ -0,0 +1,69 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/packages.lisp,v 1.39 2009/09/17 19:17:31 edi Exp $
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-user)
+
+(defpackage :cl-ppcre
+  (:nicknames :ppcre)
+  #+:genera
+  (:shadowing-import-from :common-lisp :lambda :simple-string :string)
+  (:use #-:genera :cl #+:genera :future-common-lisp)
+  (:shadow :digit-char-p :defconstant)
+  (:export :parse-string
+           :create-scanner
+           :create-optimized-test-function
+           :parse-tree-synonym
+           :define-parse-tree-synonym
+           :scan
+           :scan-to-strings
+           :do-scans
+           :do-matches
+           :do-matches-as-strings
+           :all-matches
+           :all-matches-as-strings
+           :split
+           :regex-replace
+           :regex-replace-all
+           :regex-apropos
+           :regex-apropos-list
+           :quote-meta-chars
+           :*regex-char-code-limit*
+           :*use-bmh-matchers*
+           :*allow-quoting*
+           :*allow-named-registers*
+           :*optimize-char-classes*
+           :*property-resolver*
+           :*look-ahead-for-suffix*
+           :ppcre-error
+           :ppcre-invocation-error
+           :ppcre-syntax-error
+           :ppcre-syntax-error-string
+           :ppcre-syntax-error-pos
+           :register-groups-bind
+           :do-register-groups))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/parser.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/parser.lisp
new file mode 100644
index 0000000..72e39e9
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/parser.lisp
@@ -0,0 +1,290 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/parser.lisp,v 1.31 2009/09/17 19:17:31 edi Exp $
+
+;;; The parser will - with the help of the lexer - parse a regex
+;;; string and convert it into a "parse tree" (see docs for details
+;;; about the syntax of these trees).  Note that the lexer might
+;;; return illegal parse trees.  It is assumed that the conversion
+;;; process later on will track them down.
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defun group (lexer)
+  "Parses and consumes a <group>.
+The productions are: <group> -> \"\(\"<regex>\")\"
+                                \"\(?:\"<regex>\")\"
+                                \"\(?>\"<regex>\")\"
+                                \"\(?<flags>:\"<regex>\")\"
+                                \"\(?=\"<regex>\")\"
+                                \"\(?!\"<regex>\")\"
+                                \"\(?<=\"<regex>\")\"
+                                \"\(?<!\"<regex>\")\"
+                                \"\(?\(\"<num>\")\"<regex>\")\"
+                                \"\(?\(\"<regex>\")\"<regex>\")\"
+                                \"\(?<name>\"<regex>\")\" \(when *ALLOW-NAMED-REGISTERS* is T)
+                                <legal-token>
+where <flags> is parsed by the lexer function MAYBE-PARSE-FLAGS.
+Will return <parse-tree> or \(<grouping-type> <parse-tree>) where
+<grouping-type> is one of six keywords - see source for details."
+  (declare #.*standard-optimize-settings*)
+  (multiple-value-bind (open-token flags)
+      (get-token lexer)
+    (cond ((eq open-token :open-paren-paren)
+            ;; special case for conditional regular expressions; note
+            ;; that at this point we accept a couple of illegal
+            ;; combinations which'll be sorted out later by the
+            ;; converter
+            (let* ((open-paren-pos (car (lexer-last-pos lexer)))
+                   ;; check if what follows "(?(" is a number
+                   (number (try-number lexer :no-whitespace-p t))
+                   ;; make changes to extended-mode-p local
+                   (*extended-mode-p* *extended-mode-p*))
+              (declare (fixnum open-paren-pos))
+              (cond (number
+                      ;; condition is a number (i.e. refers to a
+                      ;; back-reference)
+                      (let* ((inner-close-token (get-token lexer))
+                             (reg-expr (reg-expr lexer))
+                             (close-token (get-token lexer)))
+                        (unless (eq inner-close-token :close-paren)
+                          (signal-syntax-error* (+ open-paren-pos 2)
+                                                "Opening paren has no matching closing paren."))
+                        (unless (eq close-token :close-paren)
+                          (signal-syntax-error* open-paren-pos
+                                                "Opening paren has no matching closing paren."))
+                        (list :branch number reg-expr)))
+                    (t
+                      ;; condition must be a full regex (actually a
+                      ;; look-behind or look-ahead); and here comes a
+                      ;; terrible kludge: instead of being cleanly
+                      ;; separated from the lexer, the parser pushes
+                      ;; back the lexer by one position, thereby
+                      ;; landing in the middle of the 'token' "(?(" -
+                      ;; yuck!!
+                      (decf (lexer-pos lexer))
+                      (let* ((inner-reg-expr (group lexer))
+                             (reg-expr (reg-expr lexer))
+                             (close-token (get-token lexer)))
+                        (unless (eq close-token :close-paren)
+                          (signal-syntax-error* open-paren-pos
+                                                "Opening paren has no matching closing paren."))
+                        (list :branch inner-reg-expr reg-expr))))))
+          ((member open-token '(:open-paren
+                                :open-paren-colon
+                                :open-paren-greater
+                                :open-paren-equal
+                                :open-paren-exclamation
+                                :open-paren-less-equal
+                                :open-paren-less-exclamation
+                                :open-paren-less-letter)
+                   :test #'eq)
+            ;; make changes to extended-mode-p local
+            (let ((*extended-mode-p* *extended-mode-p*))
+              ;; we saw one of the six token representing opening
+              ;; parentheses
+              (let* ((open-paren-pos (car (lexer-last-pos lexer)))
+                     (register-name (when (eq open-token :open-paren-less-letter)
+                                      (parse-register-name-aux lexer)))
+                     (reg-expr (reg-expr lexer))
+                     (close-token (get-token lexer)))
+                (when (or (eq open-token :open-paren)
+                          (eq open-token :open-paren-less-letter))
+                  ;; if this is the "("<regex>")" or "(?"<name>""<regex>")" production we have to
+                  ;; increment the register counter of the lexer
+                  (incf (lexer-reg lexer)))
+                (unless (eq close-token :close-paren)
+                  ;; the token following <regex> must be the closing
+                  ;; parenthesis or this is a syntax error
+                  (signal-syntax-error* open-paren-pos
+                                        "Opening paren has no matching closing paren."))
+                (if flags
+                  ;; if the lexer has returned a list of flags this must
+                  ;; have been the "(?:"<regex>")" production
+                  (cons :group (nconc flags (list reg-expr)))
+                  (if (eq open-token :open-paren-less-letter)
+                      (list :named-register register-name
+                            reg-expr)
+                      (list (case open-token
+                              ((:open-paren)
+                               :register)
+                              ((:open-paren-colon)
+                               :group)
+                              ((:open-paren-greater)
+                               :standalone)
+                              ((:open-paren-equal)
+                               :positive-lookahead)
+                              ((:open-paren-exclamation)
+                               :negative-lookahead)
+                              ((:open-paren-less-equal)
+                               :positive-lookbehind)
+                              ((:open-paren-less-exclamation)
+                               :negative-lookbehind))
+                            reg-expr))))))
+          (t
+           ;; this is the <legal-token> production; <legal-token> is
+           ;; any token which passes START-OF-SUBEXPR-P (otherwise
+           ;; parsing had already stopped in the SEQ method)
+           open-token))))
+
+(defun greedy-quant (lexer)
+  "Parses and consumes a <greedy-quant>.
+The productions are: <greedy-quant> -> <group> | <group><quantifier>
+where <quantifier> is parsed by the lexer function GET-QUANTIFIER.
+Will return <parse-tree> or (:GREEDY-REPETITION <min> <max> <parse-tree>)."
+  (declare #.*standard-optimize-settings*)
+  (let* ((group (group lexer))
+         (token (get-quantifier lexer)))
+    (if token
+      ;; if GET-QUANTIFIER returned a non-NIL value it's the
+      ;; two-element list (<min> <max>)
+      (list :greedy-repetition (first token) (second token) group)
+      group)))
+
+(defun quant (lexer)
+  "Parses and consumes a <quant>.
+The productions are: <quant> -> <greedy-quant> | <greedy-quant>\"?\".
+Will return the <parse-tree> returned by GREEDY-QUANT and optionally
+change :GREEDY-REPETITION to :NON-GREEDY-REPETITION."
+  (declare #.*standard-optimize-settings*)
+  (let* ((greedy-quant (greedy-quant lexer))
+         (pos (lexer-pos lexer))
+         (next-char (next-char lexer)))
+    (when next-char
+      (if (char= next-char #\?)
+        (setf (car greedy-quant) :non-greedy-repetition)
+        (setf (lexer-pos lexer) pos)))
+    greedy-quant))
+
+(defun seq (lexer)
+  "Parses and consumes a <seq>.
+The productions are: <seq> -> <quant> | <quant><seq>.
+Will return <parse-tree> or (:SEQUENCE <parse-tree> <parse-tree>)."
+  (declare #.*standard-optimize-settings*)
+  (flet ((make-array-from-two-chars (char1 char2)
+           (let ((string (make-array 2
+                                     :element-type 'character
+                                     :fill-pointer t
+                                     :adjustable t)))
+             (setf (aref string 0) char1)
+             (setf (aref string 1) char2)
+             string)))
+    ;; Note that we're calling START-OF-SUBEXPR-P before we actually try
+    ;; to parse a <seq> or <quant> in order to catch empty regular
+    ;; expressions
+    (if (start-of-subexpr-p lexer)
+        (loop with seq-is-sequence-p = nil
+              with last-cdr
+              for quant = (quant lexer)
+              for quant-is-char-p = (characterp quant)
+              for seq = quant
+              then
+              (cond ((and quant-is-char-p (characterp seq))
+                     (make-array-from-two-chars seq quant))
+                    ((and quant-is-char-p (stringp seq))
+                     (vector-push-extend quant seq)
+                     seq)
+                    ((not seq-is-sequence-p)
+                     (setf last-cdr (list quant)
+                           seq-is-sequence-p t)
+                     (list* :sequence seq last-cdr))
+                    ((and quant-is-char-p
+                          (characterp (car last-cdr)))
+                     (setf (car last-cdr)
+                           (make-array-from-two-chars (car last-cdr)
+                                                      quant))
+                     seq)
+                    ((and quant-is-char-p
+                          (stringp (car last-cdr)))
+                     (vector-push-extend quant (car last-cdr))
+                     seq)
+                    (t
+                     ;; if <seq> is also a :SEQUENCE parse tree we merge
+                     ;; both lists into one
+                     (let ((cons (list quant)))
+                       (psetf last-cdr cons
+                              (cdr last-cdr) cons))
+                     seq))
+              while (start-of-subexpr-p lexer)
+              finally (return seq))
+        :void)))
+
+(defun reg-expr (lexer)
+  "Parses and consumes a <regex>, a complete regular expression.
+The productions are: <regex> -> <seq> | <seq>\"|\"<regex>.
+Will return <parse-tree> or (:ALTERNATION <parse-tree> <parse-tree>)."
+  (declare #.*standard-optimize-settings*)
+  (let ((pos (lexer-pos lexer)))
+    (case (next-char lexer)
+      ((nil)
+        ;; if we didn't get any token we return :VOID which stands for
+        ;; "empty regular expression"
+        :void)
+      ((#\|)
+        ;; now check whether the expression started with a vertical
+        ;; bar, i.e. <seq> - the left alternation - is empty
+        (list :alternation :void (reg-expr lexer)))
+      (otherwise
+        ;; otherwise un-read the character we just saw and parse a
+        ;; <seq> plus the character following it
+        (setf (lexer-pos lexer) pos)
+        (let* ((seq (seq lexer))
+               (pos (lexer-pos lexer)))
+          (case (next-char lexer)
+            ((nil)
+              ;; no further character, just a <seq>
+              seq)
+            ((#\|)
+              ;; if the character was a vertical bar, this is an
+              ;; alternation and we have the second production
+              (let ((reg-expr (reg-expr lexer)))
+                (cond ((and (consp reg-expr)
+                            (eq (first reg-expr) :alternation))
+                        ;; again we try to merge as above in SEQ
+                        (setf (cdr reg-expr)
+                                (cons seq (cdr reg-expr)))
+                        reg-expr)
+                      (t (list :alternation seq reg-expr)))))
+            (otherwise
+              ;; a character which is not a vertical bar - this is
+              ;; either a syntax error or we're inside of a group and
+              ;; the next character is a closing parenthesis; so we
+              ;; just un-read the character and let another function
+              ;; take care of it
+              (setf (lexer-pos lexer) pos)
+              seq)))))))
+
+(defun parse-string (string)
+  "Translate the regex string STRING into a parse tree."
+  (declare #.*standard-optimize-settings*)
+  (let* ((lexer (make-lexer string))
+         (parse-tree (reg-expr lexer)))
+    ;; check whether we've consumed the whole regex string
+    (if (end-of-string-p lexer)
+      parse-tree
+      (signal-syntax-error* (lexer-pos lexer) "Expected end of string."))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/regex-class-util.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/regex-class-util.lisp
new file mode 100644
index 0000000..b737378
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/regex-class-util.lisp
@@ -0,0 +1,555 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/regex-class-util.lisp,v 1.9 2009/09/17 19:17:31 edi Exp $
+
+;;; This file contains some utility methods for REGEX objects.
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+;;; The following four methods allow a VOID object to behave like a
+;;; zero-length STR object (only readers needed)
+
+(defmethod len ((void void))
+  (declare #.*standard-optimize-settings*)
+  0)
+
+(defmethod str ((void void))
+  (declare #.*standard-optimize-settings*)
+  "")
+
+(defmethod skip ((void void))
+  (declare #.*standard-optimize-settings*)
+  nil)
+
+(defmethod start-of-end-string-p ((void void))
+  (declare #.*standard-optimize-settings*)
+  nil)
+
+(defgeneric case-mode (regex old-case-mode)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Utility function used by the optimizer (see GATHER-STRINGS).
+Returns a keyword denoting the case-(in)sensitivity of a STR or its
+second argument if the STR has length 0. Returns NIL for REGEX objects
+which are not of type STR."))
+
+(defmethod case-mode ((str str) old-case-mode)
+  (declare #.*standard-optimize-settings*)
+  (cond ((zerop (len str))
+          old-case-mode)
+        ((case-insensitive-p str)
+          :case-insensitive)
+        (t
+          :case-sensitive)))
+
+(defmethod case-mode ((regex regex) old-case-mode)
+  (declare #.*standard-optimize-settings*)
+  (declare (ignore old-case-mode))
+  nil)
+
+(defgeneric copy-regex (regex)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Implements a deep copy of a REGEX object."))
+
+(defmethod copy-regex ((anchor anchor))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'anchor
+                 :startp (startp anchor)
+                 :multi-line-p (multi-line-p anchor)
+                 :no-newline-p (no-newline-p anchor)))
+
+(defmethod copy-regex ((everything everything))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'everything
+                 :single-line-p (single-line-p everything)))
+
+(defmethod copy-regex ((word-boundary word-boundary))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'word-boundary
+                 :negatedp (negatedp word-boundary)))
+
+(defmethod copy-regex ((void void))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'void))
+
+(defmethod copy-regex ((lookahead lookahead))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'lookahead
+                 :regex (copy-regex (regex lookahead))
+                 :positivep (positivep lookahead)))
+
+(defmethod copy-regex ((seq seq))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'seq
+                 :elements (mapcar #'copy-regex (elements seq))))
+
+(defmethod copy-regex ((alternation alternation))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'alternation
+                 :choices (mapcar #'copy-regex (choices alternation))))
+
+(defmethod copy-regex ((branch branch))
+  (declare #.*standard-optimize-settings*)
+  (with-slots (test)
+      branch
+    (make-instance 'branch
+                   :test (if (typep test 'regex)
+                           (copy-regex test)
+                           test)
+                   :then-regex (copy-regex (then-regex branch))
+                   :else-regex (copy-regex (else-regex branch)))))
+
+(defmethod copy-regex ((lookbehind lookbehind))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'lookbehind
+                 :regex (copy-regex (regex lookbehind))
+                 :positivep (positivep lookbehind)
+                 :len (len lookbehind)))
+
+(defmethod copy-regex ((repetition repetition))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'repetition
+                 :regex (copy-regex (regex repetition))
+                 :greedyp (greedyp repetition)
+                 :minimum (minimum repetition)
+                 :maximum (maximum repetition)
+                 :min-len (min-len repetition)
+                 :len (len repetition)
+                 :contains-register-p (contains-register-p repetition)))
+
+(defmethod copy-regex ((register register))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'register
+                 :regex (copy-regex (regex register))
+                 :num (num register)
+                 :name (name register)))
+
+(defmethod copy-regex ((standalone standalone))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'standalone
+                 :regex (copy-regex (regex standalone))))
+
+(defmethod copy-regex ((back-reference back-reference))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'back-reference
+                 :num (num back-reference)
+                 :case-insensitive-p (case-insensitive-p back-reference)))
+
+(defmethod copy-regex ((char-class char-class))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'char-class
+                 :test-function (test-function char-class)))
+
+(defmethod copy-regex ((str str))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'str
+                 :str (str str)
+                 :case-insensitive-p (case-insensitive-p str)))
+
+(defmethod copy-regex ((filter filter))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'filter
+                 :fn (fn filter)
+                 :len (len filter)))
+
+;;; Note that COPY-REGEX and REMOVE-REGISTERS could have easily been
+;;; wrapped into one function. Maybe in the next release...
+
+;;; Further note that this function is used by CONVERT to factor out
+;;; complicated repetitions, i.e. cases like
+;;;   (a)* -> (?:a*(a))?
+;;; This won't work for, say,
+;;;   ((a)|(b))* -> (?:(?:a|b)*((a)|(b)))?
+;;; and therefore we stop REGISTER removal once we see an ALTERNATION.
+
+(defgeneric remove-registers (regex)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Returns a deep copy of a REGEX (see COPY-REGEX) and
+optionally removes embedded REGISTER objects if possible and if the
+special variable REMOVE-REGISTERS-P is true."))
+
+(defmethod remove-registers ((register register))
+  (declare #.*standard-optimize-settings*)
+  (declare (special remove-registers-p reg-seen))
+  (cond (remove-registers-p
+          (remove-registers (regex register)))
+        (t
+          ;; mark REG-SEEN as true so enclosing REPETITION objects
+          ;; (see method below) know if they contain a register or not
+          (setq reg-seen t)
+          (copy-regex register))))
+
+(defmethod remove-registers ((repetition repetition))
+  (declare #.*standard-optimize-settings*)
+  (let* (reg-seen
+         (inner-regex (remove-registers (regex repetition))))
+    ;; REMOVE-REGISTERS will set REG-SEEN (see method above) if
+    ;; (REGEX REPETITION) contains a REGISTER
+    (declare (special reg-seen))
+    (make-instance 'repetition
+                   :regex inner-regex
+                   :greedyp (greedyp repetition)
+                   :minimum (minimum repetition)
+                   :maximum (maximum repetition)
+                   :min-len (min-len repetition)
+                   :len (len repetition)
+                   :contains-register-p reg-seen)))
+
+(defmethod remove-registers ((standalone standalone))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'standalone
+                 :regex (remove-registers (regex standalone))))
+
+(defmethod remove-registers ((lookahead lookahead))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'lookahead
+                 :regex (remove-registers (regex lookahead))
+                 :positivep (positivep lookahead)))
+
+(defmethod remove-registers ((lookbehind lookbehind))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'lookbehind
+                 :regex (remove-registers (regex lookbehind))
+                 :positivep (positivep lookbehind)
+                 :len (len lookbehind)))
+
+(defmethod remove-registers ((branch branch))
+  (declare #.*standard-optimize-settings*)
+  (with-slots (test)
+      branch
+    (make-instance 'branch
+                   :test (if (typep test 'regex)
+                           (remove-registers test)
+                           test)
+                   :then-regex (remove-registers (then-regex branch))
+                   :else-regex (remove-registers (else-regex branch)))))
+
+(defmethod remove-registers ((alternation alternation))
+  (declare #.*standard-optimize-settings*)
+  (declare (special remove-registers-p))
+  ;; an ALTERNATION, so we can't remove REGISTER objects further down
+  (setq remove-registers-p nil)
+  (copy-regex alternation))
+
+(defmethod remove-registers ((regex regex))
+  (declare #.*standard-optimize-settings*)
+  (copy-regex regex))
+
+(defmethod remove-registers ((seq seq))
+  (declare #.*standard-optimize-settings*)
+  (make-instance 'seq
+                 :elements (mapcar #'remove-registers (elements seq))))
+
+(defgeneric everythingp (regex)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Returns an EVERYTHING object if REGEX is equivalent
+to this object, otherwise NIL.  So, \"(.){1}\" would return true
+\(i.e. the object corresponding to \".\", for example."))
+
+(defmethod everythingp ((seq seq))
+  (declare #.*standard-optimize-settings*)
+  ;; we might have degenerate cases like (:SEQUENCE :VOID ...)
+  ;; due to the parsing process
+  (let ((cleaned-elements (remove-if #'(lambda (element)
+                                         (typep element 'void))
+                                     (elements seq))))
+    (and (= 1 (length cleaned-elements))
+         (everythingp (first cleaned-elements)))))
+
+(defmethod everythingp ((alternation alternation))
+  (declare #.*standard-optimize-settings*)
+  (with-slots (choices)
+      alternation
+    (and (= 1 (length choices))
+         ;; this is unlikely to happen for human-generated regexes,
+         ;; but machine-generated ones might look like this
+         (everythingp (first choices)))))
+
+(defmethod everythingp ((repetition repetition))
+  (declare #.*standard-optimize-settings*)
+  (with-slots (maximum minimum regex)
+      repetition
+    (and maximum
+         (= 1 minimum maximum)
+         ;; treat "<regex>{1,1}" like "<regex>"
+         (everythingp regex))))
+
+(defmethod everythingp ((register register))
+  (declare #.*standard-optimize-settings*)
+  (everythingp (regex register)))
+
+(defmethod everythingp ((standalone standalone))
+  (declare #.*standard-optimize-settings*)
+  (everythingp (regex standalone)))
+
+(defmethod everythingp ((everything everything))
+  (declare #.*standard-optimize-settings*)
+  everything)
+
+(defmethod everythingp ((regex regex))
+  (declare #.*standard-optimize-settings*)
+  ;; the general case for ANCHOR, BACK-REFERENCE, BRANCH, CHAR-CLASS,
+  ;; LOOKAHEAD, LOOKBEHIND, STR, VOID, FILTER, and WORD-BOUNDARY
+  nil)
+
+(defgeneric regex-length (regex)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Return the length of REGEX if it is fixed, NIL otherwise."))
+
+(defmethod regex-length ((seq seq))
+  (declare #.*standard-optimize-settings*)
+  ;; simply add all inner lengths unless one of them is NIL
+  (loop for sub-regex in (elements seq)
+        for len = (regex-length sub-regex)
+        if (not len) do (return nil)
+        sum len))
+
+(defmethod regex-length ((alternation alternation))
+  (declare #.*standard-optimize-settings*)
+  ;; only return a true value if all inner lengths are non-NIL and
+  ;; mutually equal
+  (loop for sub-regex in (choices alternation)
+        for old-len = nil then len
+        for len = (regex-length sub-regex)
+        if (or (not len)
+               (and old-len (/= len old-len))) do (return nil)
+        finally (return len)))
+
+(defmethod regex-length ((branch branch))
+  (declare #.*standard-optimize-settings*)
+  ;; only return a true value if both alternations have a length and
+  ;; if they're equal
+  (let ((then-length (regex-length (then-regex branch))))
+    (and then-length
+         (eql then-length (regex-length (else-regex branch)))
+         then-length)))
+
+(defmethod regex-length ((repetition repetition))
+  (declare #.*standard-optimize-settings*)
+  ;; we can only compute the length of a REPETITION object if the
+  ;; number of repetitions is fixed; note that we don't call
+  ;; REGEX-LENGTH for the inner regex, we assume that the LEN slot is
+  ;; always set correctly
+  (with-slots (len minimum maximum)
+      repetition
+    (if (and len
+             (eql minimum maximum))
+      (* minimum len)
+      nil)))
+
+(defmethod regex-length ((register register))
+  (declare #.*standard-optimize-settings*)
+  (regex-length (regex register)))
+
+(defmethod regex-length ((standalone standalone))
+  (declare #.*standard-optimize-settings*)
+  (regex-length (regex standalone)))
+
+(defmethod regex-length ((back-reference back-reference))
+  (declare #.*standard-optimize-settings*)
+  ;; with enough effort we could possibly do better here, but
+  ;; currently we just give up and return NIL
+  nil)
+    
+(defmethod regex-length ((char-class char-class))
+  (declare #.*standard-optimize-settings*)
+  1)
+
+(defmethod regex-length ((everything everything))
+  (declare #.*standard-optimize-settings*)
+  1)
+
+(defmethod regex-length ((str str))
+  (declare #.*standard-optimize-settings*)
+  (len str))
+
+(defmethod regex-length ((filter filter))
+  (declare #.*standard-optimize-settings*)
+  (len filter))
+
+(defmethod regex-length ((regex regex))
+  (declare #.*standard-optimize-settings*)
+  ;; the general case for ANCHOR, LOOKAHEAD, LOOKBEHIND, VOID, and
+  ;; WORD-BOUNDARY (which all have zero-length)
+  0)
+
+(defgeneric regex-min-length (regex)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Returns the minimal length of REGEX."))
+
+(defmethod regex-min-length ((seq seq))
+  (declare #.*standard-optimize-settings*)
+  ;; simply add all inner minimal lengths
+  (loop for sub-regex in (elements seq)
+        for len = (regex-min-length sub-regex)
+        sum len))
+
+(defmethod regex-min-length ((alternation alternation))
+  (declare #.*standard-optimize-settings*)
+  ;; minimal length of an alternation is the minimal length of the
+  ;; "shortest" element
+  (loop for sub-regex in (choices alternation)
+        for len = (regex-min-length sub-regex)
+        minimize len))
+
+(defmethod regex-min-length ((branch branch))
+  (declare #.*standard-optimize-settings*)
+  ;; minimal length of both alternations
+  (min (regex-min-length (then-regex branch))
+       (regex-min-length (else-regex branch))))
+
+(defmethod regex-min-length ((repetition repetition))
+  (declare #.*standard-optimize-settings*)
+  ;; obviously the product of the inner minimal length and the minimal
+  ;; number of repetitions
+  (* (minimum repetition) (min-len repetition)))
+    
+(defmethod regex-min-length ((register register))
+  (declare #.*standard-optimize-settings*)
+  (regex-min-length (regex register)))
+    
+(defmethod regex-min-length ((standalone standalone))
+  (declare #.*standard-optimize-settings*)
+  (regex-min-length (regex standalone)))
+    
+(defmethod regex-min-length ((char-class char-class))
+  (declare #.*standard-optimize-settings*)
+  1)
+
+(defmethod regex-min-length ((everything everything))
+  (declare #.*standard-optimize-settings*)
+  1)
+
+(defmethod regex-min-length ((str str))
+  (declare #.*standard-optimize-settings*)
+  (len str))
+    
+(defmethod regex-min-length ((filter filter))
+  (declare #.*standard-optimize-settings*)
+  (or (len filter)
+      0))
+
+(defmethod regex-min-length ((regex regex))
+  (declare #.*standard-optimize-settings*)
+  ;; the general case for ANCHOR, BACK-REFERENCE, LOOKAHEAD,
+  ;; LOOKBEHIND, VOID, and WORD-BOUNDARY
+  0)
+
+(defgeneric compute-offsets (regex start-pos)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Returns the offset the following regex would have
+relative to START-POS or NIL if we can't compute it. Sets the OFFSET
+slot of REGEX to START-POS if REGEX is a STR. May also affect OFFSET
+slots of STR objects further down the tree."))
+
+;; note that we're actually only interested in the offset of
+;; "top-level" STR objects (see ADVANCE-FN in the SCAN function) so we
+;; can stop at variable-length alternations and don't need to descend
+;; into repetitions
+
+(defmethod compute-offsets ((seq seq) start-pos)
+  (declare #.*standard-optimize-settings*)
+  (loop for element in (elements seq)
+        ;; advance offset argument for next call while looping through
+        ;; the elements
+        for pos = start-pos then curr-offset
+        for curr-offset = (compute-offsets element pos)
+        while curr-offset
+        finally (return curr-offset)))
+
+(defmethod compute-offsets ((alternation alternation) start-pos)
+  (declare #.*standard-optimize-settings*)
+  (loop for choice in (choices alternation)
+        for old-offset = nil then curr-offset
+        for curr-offset = (compute-offsets choice start-pos)
+        ;; we stop immediately if two alternations don't result in the
+        ;; same offset
+        if (or (not curr-offset)
+               (and old-offset (/= curr-offset old-offset)))
+          do (return nil)
+        finally (return curr-offset)))
+
+(defmethod compute-offsets ((branch branch) start-pos)
+  (declare #.*standard-optimize-settings*)
+  ;; only return offset if both alternations have equal value
+  (let ((then-offset (compute-offsets (then-regex branch) start-pos)))
+    (and then-offset
+         (eql then-offset (compute-offsets (else-regex branch) start-pos))
+         then-offset)))
+
+(defmethod compute-offsets ((repetition repetition) start-pos)
+  (declare #.*standard-optimize-settings*)
+  ;; no need to descend into the inner regex
+  (with-slots (len minimum maximum)
+      repetition
+    (if (and len
+             (eq minimum maximum))
+      ;; fixed number of repetitions, so we know how to proceed
+      (+ start-pos (* minimum len))
+      ;; otherwise return NIL
+      nil)))
+
+(defmethod compute-offsets ((register register) start-pos)
+  (declare #.*standard-optimize-settings*)
+  (compute-offsets (regex register) start-pos))
+    
+(defmethod compute-offsets ((standalone standalone) start-pos)
+  (declare #.*standard-optimize-settings*)
+  (compute-offsets (regex standalone) start-pos))
+    
+(defmethod compute-offsets ((char-class char-class) start-pos)
+  (declare #.*standard-optimize-settings*)
+  (1+ start-pos))
+    
+(defmethod compute-offsets ((everything everything) start-pos)
+  (declare #.*standard-optimize-settings*)
+  (1+ start-pos))
+    
+(defmethod compute-offsets ((str str) start-pos)
+  (declare #.*standard-optimize-settings*)
+  (setf (offset str) start-pos)
+  (+ start-pos (len str)))
+
+(defmethod compute-offsets ((back-reference back-reference) start-pos)
+  (declare #.*standard-optimize-settings*)
+  ;; with enough effort we could possibly do better here, but
+  ;; currently we just give up and return NIL
+  (declare (ignore start-pos))
+  nil)
+
+(defmethod compute-offsets ((filter filter) start-pos)
+  (declare #.*standard-optimize-settings*)
+  (let ((len (len filter)))
+    (if len
+      (+ start-pos len)
+      nil)))
+
+(defmethod compute-offsets ((regex regex) start-pos)
+  (declare #.*standard-optimize-settings*)
+  ;; the general case for ANCHOR, LOOKAHEAD, LOOKBEHIND, VOID, and
+  ;; WORD-BOUNDARY (which all have zero-length)
+  start-pos)
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/regex-class.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/regex-class.lisp
new file mode 100644
index 0000000..43c36e5
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/regex-class.lisp
@@ -0,0 +1,271 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/regex-class.lisp,v 1.44 2009/10/28 07:36:15 edi Exp $
+
+;;; This file defines the REGEX class.  REGEX objects are used to
+;;; represent the (transformed) parse trees internally
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defclass regex ()
+  ()
+  (:documentation "The REGEX base class.  All other classes inherit
+from this one."))
+
+(defclass seq (regex)
+  ((elements :initarg :elements
+             :accessor elements
+             :type cons
+             :documentation "A list of REGEX objects."))
+  (:documentation "SEQ objects represents sequences of regexes.
+\(Like \"ab\" is the sequence of \"a\" and \"b\".)"))
+
+(defclass alternation (regex)
+  ((choices :initarg :choices
+            :accessor choices
+            :type cons
+            :documentation "A list of REGEX objects"))
+  (:documentation "ALTERNATION objects represent alternations of
+regexes.  \(Like \"a|b\" ist the alternation of \"a\" or \"b\".)"))
+
+(defclass lookahead (regex)
+  ((regex :initarg :regex
+          :accessor regex
+          :documentation "The REGEX object we're checking.")
+   (positivep :initarg :positivep
+              :reader positivep
+              :documentation "Whether this assertion is positive."))
+  (:documentation "LOOKAHEAD objects represent look-ahead assertions."))
+
+(defclass lookbehind (regex)
+  ((regex :initarg :regex
+          :accessor regex
+          :documentation "The REGEX object we're checking.")
+   (positivep :initarg :positivep
+              :reader positivep
+              :documentation "Whether this assertion is positive.")
+   (len :initarg :len
+        :accessor len
+        :type fixnum
+        :documentation "The \(fixed) length of the enclosed regex."))
+  (:documentation "LOOKBEHIND objects represent look-behind assertions."))
+
+(defclass repetition (regex)
+  ((regex :initarg :regex
+          :accessor regex
+          :documentation "The REGEX that's repeated.")
+   (greedyp :initarg :greedyp
+            :reader greedyp
+            :documentation "Whether the repetition is greedy.")
+   (minimum :initarg :minimum
+            :accessor minimum
+            :type fixnum
+            :documentation "The minimal number of repetitions.")
+   (maximum :initarg :maximum
+            :accessor maximum
+            :documentation "The maximal number of repetitions.
+Can be NIL for unbounded.")
+   (min-len :initarg :min-len
+            :reader min-len
+            :documentation "The minimal length of the enclosed regex.")
+   (len :initarg :len
+        :reader len
+        :documentation "The length of the enclosed regex.  NIL if
+unknown.")
+   (min-rest :initform 0
+             :accessor min-rest
+             :type fixnum
+             :documentation "The minimal number of characters which
+must appear after this repetition.")
+   (contains-register-p :initarg :contains-register-p
+                        :reader contains-register-p
+                        :documentation "Whether the regex contains a
+register."))
+  (:documentation "REPETITION objects represent repetitions of regexes."))
+
+(defmethod print-object ((repetition repetition) stream)
+  (print-unreadable-object (repetition stream :type t :identity t)
+    (princ (regex repetition) stream)))
+
+(defclass register (regex)
+  ((regex :initarg :regex
+          :accessor regex
+          :documentation "The inner regex.")
+   (num :initarg :num
+        :reader num
+        :type fixnum
+        :documentation "The number of this register, starting from 0.
+This is the index into *REGS-START* and *REGS-END*.")
+   (name :initarg :name
+         :reader name
+         :documentation "Name of this register or NIL."))
+  (:documentation "REGISTER objects represent register groups."))
+
+(defmethod print-object ((register register) stream)
+  (print-unreadable-object (register stream :type t :identity t)
+    (princ (regex register) stream)))
+
+(defclass standalone (regex)
+  ((regex :initarg :regex
+          :accessor regex
+          :documentation "The inner regex."))
+  (:documentation "A standalone regular expression."))
+  
+(defclass back-reference (regex)
+  ((num :initarg :num
+        :accessor num
+        :type fixnum
+        :documentation "The number of the register this
+reference refers to.")
+   (name :initarg :name
+         :accessor name
+         :documentation "The name of the register this
+reference refers to or NIL.")
+   (case-insensitive-p :initarg :case-insensitive-p
+                       :reader case-insensitive-p
+                       :documentation "Whether we check
+case-insensitively."))
+  (:documentation "BACK-REFERENCE objects represent backreferences."))
+
+(defclass char-class (regex)
+  ((test-function :initarg :test-function
+                  :reader test-function
+                  :type (or function symbol nil)
+                  :documentation "A unary function \(accepting a
+character) which stands in for the character class and does the work
+of checking whether a character belongs to the class."))
+  (:documentation "CHAR-CLASS objects represent character classes."))
+
+(defclass str (regex)
+  ((str :initarg :str
+        :accessor str
+        :type string
+        :documentation "The actual string.")
+   (len :initform 0
+        :accessor len
+        :type fixnum
+        :documentation "The length of the string.")
+   (case-insensitive-p :initarg :case-insensitive-p
+                       :reader case-insensitive-p
+                       :documentation "If we match case-insensitively.")
+   (offset :initform nil
+           :accessor offset
+           :documentation "Offset from the left of the whole
+parse tree. The first regex has offset 0. NIL if unknown, i.e. behind
+a variable-length regex.")
+   (skip :initform nil
+         :initarg :skip
+         :accessor skip
+         :documentation "If we can avoid testing for this
+string because the SCAN function has done this already.")
+   (start-of-end-string-p :initform nil
+                          :accessor start-of-end-string-p
+                          :documentation "If this is the unique
+STR which starts END-STRING (a slot of MATCHER)."))
+  (:documentation "STR objects represent string."))
+
+(defmethod print-object ((str str) stream)
+  (print-unreadable-object (str stream :type t :identity t)
+    (princ (str str) stream)))
+
+(defclass anchor (regex)
+  ((startp :initarg :startp
+           :reader startp
+           :documentation "Whether this is a \"start anchor\".")
+   (multi-line-p :initarg :multi-line-p
+                 :initform nil
+                 :reader multi-line-p
+                 :documentation "Whether we're in multi-line mode,
+i.e. whether each #\\Newline is surrounded by anchors.")
+   (no-newline-p :initarg :no-newline-p
+                 :initform nil
+                 :reader no-newline-p
+                 :documentation "Whether we ignore #\\Newline at the end."))
+  (:documentation "ANCHOR objects represent anchors like \"^\" or \"$\"."))
+
+(defclass everything (regex)
+  ((single-line-p :initarg :single-line-p
+                  :reader single-line-p
+                  :documentation "Whether we're in single-line mode,
+i.e. whether we also match #\\Newline."))
+  (:documentation "EVERYTHING objects represent regexes matching
+\"everything\", i.e. dots."))
+
+(defclass word-boundary (regex)
+  ((negatedp :initarg :negatedp
+             :reader negatedp
+             :documentation "Whether we mean the opposite,
+i.e. no word-boundary."))
+  (:documentation "WORD-BOUNDARY objects represent word-boundary assertions."))
+
+(defclass branch (regex)
+  ((test :initarg :test
+         :accessor test
+         :documentation "The test of this branch, one of
+LOOKAHEAD, LOOKBEHIND, or a number.")
+   (then-regex :initarg :then-regex
+               :accessor then-regex
+               :documentation "The regex that's to be matched if the
+test succeeds.")
+   (else-regex :initarg :else-regex
+               :initform (make-instance 'void)
+               :accessor else-regex
+               :documentation "The regex that's to be matched if the
+test fails."))
+  (:documentation "BRANCH objects represent Perl's conditional regular
+expressions."))
+    
+(defclass filter (regex)
+  ((fn :initarg :fn
+       :accessor fn
+       :type (or function symbol)
+       :documentation "The user-defined function.")
+   (len :initarg :len
+        :reader len
+        :documentation "The fixed length of this filter or NIL."))
+  (:documentation "FILTER objects represent arbitrary functions
+defined by the user."))
+
+(defclass void (regex)
+  ()
+  (:documentation "VOID objects represent empty regular expressions."))
+
+(defmethod initialize-instance :after ((str str) &rest init-args)
+  (declare #.*standard-optimize-settings*)
+  (declare (ignore init-args))
+  "Automatically computes the length of a STR after initialization."
+  (let ((str-slot (slot-value str 'str)))
+    (unless (typep str-slot
+                   #-:lispworks 'simple-string
+                   #+:lispworks 'lw:simple-text-string)
+      (setf (slot-value str 'str)
+            (coerce str-slot
+                   #-:lispworks 'simple-string
+                   #+:lispworks 'lw:simple-text-string))))
+  (setf (len str) (length (str str))))
+
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/repetition-closures.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/repetition-closures.lisp
new file mode 100644
index 0000000..1bcb08b
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/repetition-closures.lisp
@@ -0,0 +1,833 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/repetition-closures.lisp,v 1.34 2009/09/17 19:17:31 edi Exp $
+
+;;; This is actually a part of closures.lisp which we put into a
+;;; separate file because it is rather complex. We only deal with
+;;; REPETITIONs here. Note that this part of the code contains some
+;;; rather crazy micro-optimizations which were introduced to be as
+;;; competitive with Perl as possible in tight loops.
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defmacro incf-after (place &optional (delta 1) &environment env)
+  "Utility macro inspired by C's \"place++\", i.e. first return the
+value of PLACE and afterwards increment it by DELTA."
+  (with-unique-names (%temp)
+    (multiple-value-bind (vars vals store-vars writer-form reader-form)
+        (get-setf-expansion place env)
+      `(let* (,@(mapcar #'list vars vals)
+              (,%temp ,reader-form)
+              (,(car store-vars) (+ ,%temp ,delta)))
+        ,writer-form
+        ,%temp))))
+
+;; code for greedy repetitions with minimum zero
+
+(defmacro greedy-constant-length-closure (check-curr-pos)
+  "This is the template for simple greedy repetitions (where simple
+means that the minimum number of repetitions is zero, that the inner
+regex to be checked is of fixed length LEN, and that it doesn't
+contain registers, i.e. there's no need for backtracking).
+CHECK-CURR-POS is a form which checks whether the inner regex of the
+repetition matches at CURR-POS."
+  `(if maximum
+    (lambda (start-pos)
+      (declare (fixnum start-pos maximum))
+      ;; because we know LEN we know in advance where to stop at the
+      ;; latest; we also take into consideration MIN-REST, i.e. the
+      ;; minimal length of the part behind the repetition
+      (let ((target-end-pos (min (1+ (- *end-pos* len min-rest))
+                                 ;; don't go further than MAXIMUM
+                                 ;; repetitions, of course
+                                 (+ start-pos
+                                    (the fixnum (* len maximum)))))
+            (curr-pos start-pos))
+        (declare (fixnum target-end-pos curr-pos))
+        (block greedy-constant-length-matcher
+          ;; we use an ugly TAGBODY construct because this might be a
+          ;; tight loop and this version is a bit faster than our LOOP
+          ;; version (at least in CMUCL)
+          (tagbody
+            forward-loop
+            ;; first go forward as far as possible, i.e. while
+            ;; the inner regex matches
+            (when (>= curr-pos target-end-pos)
+              (go backward-loop))
+            (when ,check-curr-pos
+              (incf curr-pos len)
+              (go forward-loop))
+            backward-loop
+            ;; now go back LEN steps each until we're able to match
+            ;; the rest of the regex
+            (when (< curr-pos start-pos)
+              (return-from greedy-constant-length-matcher nil))
+            (let ((result (funcall next-fn curr-pos)))
+              (when result
+                (return-from greedy-constant-length-matcher result)))
+            (decf curr-pos len)
+            (go backward-loop)))))
+    ;; basically the same code; it's just a bit easier because we're
+    ;; not bounded by MAXIMUM
+    (lambda (start-pos)
+      (declare (fixnum start-pos))
+      (let ((target-end-pos (1+ (- *end-pos* len min-rest)))
+            (curr-pos start-pos))
+        (declare (fixnum target-end-pos curr-pos))
+        (block greedy-constant-length-matcher
+          (tagbody
+            forward-loop
+            (when (>= curr-pos target-end-pos)
+              (go backward-loop))
+            (when ,check-curr-pos
+              (incf curr-pos len)
+              (go forward-loop))
+            backward-loop
+            (when (< curr-pos start-pos)
+              (return-from greedy-constant-length-matcher nil))
+            (let ((result (funcall next-fn curr-pos)))
+              (when result
+                (return-from greedy-constant-length-matcher result)))
+            (decf curr-pos len)
+            (go backward-loop)))))))
+
+(defun create-greedy-everything-matcher (maximum min-rest next-fn)
+  "Creates a closure which just matches as far ahead as possible,
+i.e. a closure for a dot in single-line mode."
+  (declare #.*standard-optimize-settings*)
+  (declare (fixnum min-rest) (function next-fn))
+  (if maximum
+    (lambda (start-pos)
+      (declare (fixnum start-pos maximum))
+      ;; because we know LEN we know in advance where to stop at the
+      ;; latest; we also take into consideration MIN-REST, i.e. the
+      ;; minimal length of the part behind the repetition
+      (let ((target-end-pos (min (+ start-pos maximum)
+                                 (- *end-pos* min-rest))))
+        (declare (fixnum target-end-pos))
+        ;; start from the highest possible position and go backward
+        ;; until we're able to match the rest of the regex
+        (loop for curr-pos of-type fixnum from target-end-pos downto start-pos
+              thereis (funcall next-fn curr-pos))))
+    ;; basically the same code; it's just a bit easier because we're
+    ;; not bounded by MAXIMUM
+    (lambda (start-pos)
+      (declare (fixnum start-pos))
+      (let ((target-end-pos (- *end-pos* min-rest)))
+        (declare (fixnum target-end-pos))
+        (loop for curr-pos of-type fixnum from target-end-pos downto start-pos
+              thereis (funcall next-fn curr-pos))))))
+
+(defgeneric create-greedy-constant-length-matcher (repetition next-fn)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Creates a closure which tries to match REPETITION.
+It is assumed that REPETITION is greedy and the minimal number of
+repetitions is zero.  It is furthermore assumed that the inner regex
+of REPETITION is of fixed length and doesn't contain registers."))
+
+(defmethod create-greedy-constant-length-matcher ((repetition repetition)
+                                                  next-fn)
+  (declare #.*standard-optimize-settings*)
+  (let ((len (len repetition))
+        (maximum (maximum repetition))
+        (regex (regex repetition))
+        (min-rest (min-rest repetition)))
+    (declare (fixnum len min-rest)
+             (function next-fn))
+    (cond ((zerop len)
+            ;; inner regex has zero-length, so we can discard it
+            ;; completely
+            next-fn)
+          (t
+            ;; now first try to optimize for a couple of common cases
+            (typecase regex
+              (str
+                (let ((str (str regex)))
+                  (if (= 1 len)
+                    ;; a single character
+                    (let ((chr (schar str 0)))
+                      (if (case-insensitive-p regex)
+                        (greedy-constant-length-closure
+                         (char-equal chr (schar *string* curr-pos)))
+                        (greedy-constant-length-closure
+                         (char= chr (schar *string* curr-pos)))))
+                    ;; a string
+                    (if (case-insensitive-p regex)
+                      (greedy-constant-length-closure
+                       (*string*-equal str curr-pos (+ curr-pos len) 0 len))
+                      (greedy-constant-length-closure
+                       (*string*= str curr-pos (+ curr-pos len) 0 len))))))
+              (char-class
+                ;; a character class
+                (insert-char-class-tester (regex (schar *string* curr-pos))
+                  (greedy-constant-length-closure
+                   (char-class-test))))
+              (everything
+                ;; an EVERYTHING object, i.e. a dot
+                (if (single-line-p regex)
+                  (create-greedy-everything-matcher maximum min-rest next-fn)
+                  (greedy-constant-length-closure
+                   (char/= #\Newline (schar *string* curr-pos)))))
+              (t
+                ;; the general case - we build an inner matcher which
+                ;; just checks for immediate success, i.e. NEXT-FN is
+                ;; #'IDENTITY
+                (let ((inner-matcher (create-matcher-aux regex #'identity)))
+                  (declare (function inner-matcher))
+                  (greedy-constant-length-closure
+                   (funcall inner-matcher curr-pos)))))))))
+
+(defgeneric create-greedy-no-zero-matcher (repetition next-fn)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Creates a closure which tries to match REPETITION.
+It is assumed that REPETITION is greedy and the minimal number of
+repetitions is zero.  It is furthermore assumed that the inner regex
+of REPETITION can never match a zero-length string \(or instead the
+maximal number of repetitions is 1)."))
+
+(defmethod create-greedy-no-zero-matcher ((repetition repetition) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (let ((maximum (maximum repetition))
+        ;; REPEAT-MATCHER is part of the closure's environment but it
+        ;; can only be defined after GREEDY-AUX is defined
+        repeat-matcher)
+    (declare (function next-fn))
+    (cond
+      ((eql maximum 1)
+        ;; this is essentially like the next case but with a known
+        ;; MAXIMUM of 1 we can get away without a counter; note that
+        ;; we always arrive here if CONVERT optimizes <regex>* to
+        ;; (?:<regex'>*<regex>)?
+        (setq repeat-matcher
+                (create-matcher-aux (regex repetition) next-fn))
+        (lambda (start-pos)
+          (declare (function repeat-matcher))
+          (or (funcall repeat-matcher start-pos)
+              (funcall next-fn start-pos))))
+      (maximum
+        ;; we make a reservation for our slot in *REPEAT-COUNTERS*
+        ;; because we need to keep track whether we've reached MAXIMUM
+        ;; repetitions
+        (let ((rep-num (incf-after *rep-num*)))
+          (flet ((greedy-aux (start-pos)
+                   (declare (fixnum start-pos maximum rep-num)
+                            (function repeat-matcher))
+                   ;; the actual matcher which first tries to match the
+                   ;; inner regex of REPETITION (if we haven't done so
+                   ;; too often) and on failure calls NEXT-FN
+                   (or (and (< (aref *repeat-counters* rep-num) maximum)
+                            (incf (aref *repeat-counters* rep-num))
+                            ;; note that REPEAT-MATCHER will call
+                            ;; GREEDY-AUX again recursively
+                            (prog1
+                              (funcall repeat-matcher start-pos)
+                              (decf (aref *repeat-counters* rep-num))))
+                       (funcall next-fn start-pos))))
+            ;; create a closure to match the inner regex and to
+            ;; implement backtracking via GREEDY-AUX
+            (setq repeat-matcher
+                    (create-matcher-aux (regex repetition) #'greedy-aux))
+            ;; the closure we return is just a thin wrapper around
+            ;; GREEDY-AUX to initialize the repetition counter
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (setf (aref *repeat-counters* rep-num) 0)
+              (greedy-aux start-pos)))))
+      (t
+        ;; easier code because we're not bounded by MAXIMUM, but
+        ;; basically the same
+        (flet ((greedy-aux (start-pos)
+                 (declare (fixnum start-pos)
+                          (function repeat-matcher))
+                 (or (funcall repeat-matcher start-pos)
+                     (funcall next-fn start-pos))))
+          (setq repeat-matcher
+                  (create-matcher-aux (regex repetition) #'greedy-aux))
+          #'greedy-aux)))))
+
+(defgeneric create-greedy-matcher (repetition next-fn)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Creates a closure which tries to match REPETITION.
+It is assumed that REPETITION is greedy and the minimal number of
+repetitions is zero."))
+
+(defmethod create-greedy-matcher ((repetition repetition) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (let ((maximum (maximum repetition))
+        ;; we make a reservation for our slot in *LAST-POS-STORES* because
+        ;; we have to watch out for endless loops as the inner regex might
+        ;; match zero-length strings
+        (zero-length-num (incf-after *zero-length-num*))
+        ;; REPEAT-MATCHER is part of the closure's environment but it
+        ;; can only be defined after GREEDY-AUX is defined
+        repeat-matcher)
+    (declare (fixnum zero-length-num)
+             (function next-fn))
+    (cond
+      (maximum
+        ;; we make a reservation for our slot in *REPEAT-COUNTERS*
+        ;; because we need to keep track whether we've reached MAXIMUM
+        ;; repetitions
+        (let ((rep-num (incf-after *rep-num*)))
+          (flet ((greedy-aux (start-pos)
+                   ;; the actual matcher which first tries to match the
+                   ;; inner regex of REPETITION (if we haven't done so
+                   ;; too often) and on failure calls NEXT-FN
+                   (declare (fixnum start-pos maximum rep-num)
+                            (function repeat-matcher))
+                   (let ((old-last-pos
+                           (svref *last-pos-stores* zero-length-num)))
+                     (when (and old-last-pos
+                                (= (the fixnum old-last-pos) start-pos))
+                       ;; stop immediately if we've been here before,
+                       ;; i.e. if the last attempt matched a zero-length
+                       ;; string
+                       (return-from greedy-aux (funcall next-fn start-pos)))
+                     ;; otherwise remember this position for the next
+                     ;; repetition
+                     (setf (svref *last-pos-stores* zero-length-num) start-pos)
+                     (or (and (< (aref *repeat-counters* rep-num) maximum)
+                              (incf (aref *repeat-counters* rep-num))
+                              ;; note that REPEAT-MATCHER will call
+                              ;; GREEDY-AUX again recursively
+                              (prog1
+                                (funcall repeat-matcher start-pos)
+                                (decf (aref *repeat-counters* rep-num))
+                                (setf (svref *last-pos-stores* zero-length-num)
+                                        old-last-pos)))
+                         (funcall next-fn start-pos)))))
+            ;; create a closure to match the inner regex and to
+            ;; implement backtracking via GREEDY-AUX
+            (setq repeat-matcher
+                    (create-matcher-aux (regex repetition) #'greedy-aux))
+            ;; the closure we return is just a thin wrapper around
+            ;; GREEDY-AUX to initialize the repetition counter and our
+            ;; slot in *LAST-POS-STORES*
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (setf (aref *repeat-counters* rep-num) 0
+                    (svref *last-pos-stores* zero-length-num) nil)
+              (greedy-aux start-pos)))))
+      (t
+        ;; easier code because we're not bounded by MAXIMUM, but
+        ;; basically the same
+        (flet ((greedy-aux (start-pos)
+                 (declare (fixnum start-pos)
+                          (function repeat-matcher))
+                 (let ((old-last-pos
+                         (svref *last-pos-stores* zero-length-num)))
+                   (when (and old-last-pos
+                              (= (the fixnum old-last-pos) start-pos))
+                     (return-from greedy-aux (funcall next-fn start-pos)))
+                   (setf (svref *last-pos-stores* zero-length-num) start-pos)
+                   (or (prog1
+                         (funcall repeat-matcher start-pos)
+                         (setf (svref *last-pos-stores* zero-length-num) old-last-pos))
+                       (funcall next-fn start-pos)))))
+          (setq repeat-matcher
+                  (create-matcher-aux (regex repetition) #'greedy-aux))
+          (lambda (start-pos)
+            (declare (fixnum start-pos))
+            (setf (svref *last-pos-stores* zero-length-num) nil)
+            (greedy-aux start-pos)))))))
+  
+;; code for non-greedy repetitions with minimum zero
+
+(defmacro non-greedy-constant-length-closure (check-curr-pos)
+  "This is the template for simple non-greedy repetitions \(where
+simple means that the minimum number of repetitions is zero, that the
+inner regex to be checked is of fixed length LEN, and that it doesn't
+contain registers, i.e. there's no need for backtracking).
+CHECK-CURR-POS is a form which checks whether the inner regex of the
+repetition matches at CURR-POS."
+  `(if maximum
+    (lambda (start-pos)
+      (declare (fixnum start-pos maximum))
+      ;; because we know LEN we know in advance where to stop at the
+      ;; latest; we also take into consideration MIN-REST, i.e. the
+      ;; minimal length of the part behind the repetition
+      (let ((target-end-pos (min (1+ (- *end-pos* len min-rest))
+                                 (+ start-pos
+                                    (the fixnum (* len maximum))))))
+        ;; move forward by LEN and always try NEXT-FN first, then
+        ;; CHECK-CUR-POS
+        (loop for curr-pos of-type fixnum from start-pos
+                                          below target-end-pos
+                                          by len
+              thereis (funcall next-fn curr-pos)
+              while ,check-curr-pos
+              finally (return (funcall next-fn curr-pos)))))
+  ;; basically the same code; it's just a bit easier because we're
+  ;; not bounded by MAXIMUM
+  (lambda (start-pos)
+    (declare (fixnum start-pos))
+    (let ((target-end-pos (1+ (- *end-pos* len min-rest))))
+      (loop for curr-pos of-type fixnum from start-pos
+                                        below target-end-pos
+                                        by len
+            thereis (funcall next-fn curr-pos)
+            while ,check-curr-pos
+            finally (return (funcall next-fn curr-pos)))))))
+
+(defgeneric create-non-greedy-constant-length-matcher (repetition next-fn)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Creates a closure which tries to match REPETITION.
+It is assumed that REPETITION is non-greedy and the minimal number of
+repetitions is zero.  It is furthermore assumed that the inner regex
+of REPETITION is of fixed length and doesn't contain registers."))
+
+(defmethod create-non-greedy-constant-length-matcher ((repetition repetition) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (let ((len (len repetition))
+        (maximum (maximum repetition))
+        (regex (regex repetition))
+        (min-rest (min-rest repetition)))
+    (declare (fixnum len min-rest)
+             (function next-fn))
+    (cond ((zerop len)
+            ;; inner regex has zero-length, so we can discard it
+            ;; completely
+            next-fn)
+          (t
+            ;; now first try to optimize for a couple of common cases
+            (typecase regex
+              (str
+                (let ((str (str regex)))
+                  (if (= 1 len)
+                    ;; a single character
+                    (let ((chr (schar str 0)))
+                      (if (case-insensitive-p regex)
+                        (non-greedy-constant-length-closure
+                         (char-equal chr (schar *string* curr-pos)))
+                        (non-greedy-constant-length-closure
+                         (char= chr (schar *string* curr-pos)))))
+                    ;; a string
+                    (if (case-insensitive-p regex)
+                      (non-greedy-constant-length-closure
+                       (*string*-equal str curr-pos (+ curr-pos len) 0 len))
+                      (non-greedy-constant-length-closure
+                       (*string*= str curr-pos (+ curr-pos len) 0 len))))))
+              (char-class
+                ;; a character class
+                (insert-char-class-tester (regex (schar *string* curr-pos))
+                  (non-greedy-constant-length-closure
+                   (char-class-test))))
+              (everything
+                (if (single-line-p regex)
+                  ;; a dot which really can match everything; we rely
+                  ;; on the compiler to optimize this away
+                  (non-greedy-constant-length-closure
+                   t)
+                  ;; a dot which has to watch out for #\Newline
+                  (non-greedy-constant-length-closure
+                   (char/= #\Newline (schar *string* curr-pos)))))
+              (t
+                ;; the general case - we build an inner matcher which
+                ;; just checks for immediate success, i.e. NEXT-FN is
+                ;; #'IDENTITY
+                (let ((inner-matcher (create-matcher-aux regex #'identity)))
+                  (declare (function inner-matcher))
+                  (non-greedy-constant-length-closure
+                   (funcall inner-matcher curr-pos)))))))))
+
+(defgeneric create-non-greedy-no-zero-matcher (repetition next-fn)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Creates a closure which tries to match REPETITION.
+It is assumed that REPETITION is non-greedy and the minimal number of
+repetitions is zero.  It is furthermore assumed that the inner regex
+of REPETITION can never match a zero-length string \(or instead the
+maximal number of repetitions is 1)."))
+
+(defmethod create-non-greedy-no-zero-matcher ((repetition repetition) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (let ((maximum (maximum repetition))
+        ;; REPEAT-MATCHER is part of the closure's environment but it
+        ;; can only be defined after NON-GREEDY-AUX is defined
+        repeat-matcher)
+    (declare (function next-fn))
+    (cond
+      ((eql maximum 1)
+        ;; this is essentially like the next case but with a known
+        ;; MAXIMUM of 1 we can get away without a counter
+        (setq repeat-matcher
+                (create-matcher-aux (regex repetition) next-fn))
+        (lambda (start-pos)
+          (declare (function repeat-matcher))
+          (or (funcall next-fn start-pos)
+              (funcall repeat-matcher start-pos))))
+      (maximum
+        ;; we make a reservation for our slot in *REPEAT-COUNTERS*
+        ;; because we need to keep track whether we've reached MAXIMUM
+        ;; repetitions
+        (let ((rep-num (incf-after *rep-num*)))
+          (flet ((non-greedy-aux (start-pos)
+                   ;; the actual matcher which first calls NEXT-FN and
+                   ;; on failure tries to match the inner regex of
+                   ;; REPETITION (if we haven't done so too often)
+                   (declare (fixnum start-pos maximum rep-num)
+                            (function repeat-matcher))
+                   (or (funcall next-fn start-pos)
+                       (and (< (aref *repeat-counters* rep-num) maximum)
+                            (incf (aref *repeat-counters* rep-num))
+                            ;; note that REPEAT-MATCHER will call
+                            ;; NON-GREEDY-AUX again recursively
+                            (prog1
+                              (funcall repeat-matcher start-pos)
+                              (decf (aref *repeat-counters* rep-num)))))))
+            ;; create a closure to match the inner regex and to
+            ;; implement backtracking via NON-GREEDY-AUX
+            (setq repeat-matcher
+                    (create-matcher-aux (regex repetition) #'non-greedy-aux))
+            ;; the closure we return is just a thin wrapper around
+            ;; NON-GREEDY-AUX to initialize the repetition counter
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (setf (aref *repeat-counters* rep-num) 0)
+              (non-greedy-aux start-pos)))))
+      (t
+        ;; easier code because we're not bounded by MAXIMUM, but
+        ;; basically the same
+        (flet ((non-greedy-aux (start-pos)
+                 (declare (fixnum start-pos)
+                          (function repeat-matcher))
+                 (or (funcall next-fn start-pos)
+                     (funcall repeat-matcher start-pos))))
+          (setq repeat-matcher
+                  (create-matcher-aux (regex repetition) #'non-greedy-aux))
+          #'non-greedy-aux)))))
+  
+(defgeneric create-non-greedy-matcher (repetition next-fn)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Creates a closure which tries to match REPETITION.
+It is assumed that REPETITION is non-greedy and the minimal number of
+repetitions is zero."))
+
+(defmethod create-non-greedy-matcher ((repetition repetition) next-fn)
+  (declare #.*standard-optimize-settings*)
+  ;; we make a reservation for our slot in *LAST-POS-STORES* because
+  ;; we have to watch out for endless loops as the inner regex might
+  ;; match zero-length strings
+  (let ((zero-length-num (incf-after *zero-length-num*))
+        (maximum (maximum repetition))
+        ;; REPEAT-MATCHER is part of the closure's environment but it
+        ;; can only be defined after NON-GREEDY-AUX is defined
+        repeat-matcher)
+    (declare (fixnum zero-length-num)
+             (function next-fn))
+    (cond
+      (maximum
+        ;; we make a reservation for our slot in *REPEAT-COUNTERS*
+        ;; because we need to keep track whether we've reached MAXIMUM
+        ;; repetitions
+        (let ((rep-num (incf-after *rep-num*)))
+          (flet ((non-greedy-aux (start-pos)
+                   ;; the actual matcher which first calls NEXT-FN and
+                   ;; on failure tries to match the inner regex of
+                   ;; REPETITION (if we haven't done so too often)
+                   (declare (fixnum start-pos maximum rep-num)
+                            (function repeat-matcher))
+                   (let ((old-last-pos
+                           (svref *last-pos-stores* zero-length-num)))
+                     (when (and old-last-pos
+                                (= (the fixnum old-last-pos) start-pos))
+                       ;; stop immediately if we've been here before,
+                       ;; i.e. if the last attempt matched a zero-length
+                       ;; string
+                       (return-from non-greedy-aux (funcall next-fn start-pos)))
+                     ;; otherwise remember this position for the next
+                     ;; repetition
+                     (setf (svref *last-pos-stores* zero-length-num) start-pos)
+                     (or (funcall next-fn start-pos)
+                         (and (< (aref *repeat-counters* rep-num) maximum)
+                              (incf (aref *repeat-counters* rep-num))
+                              ;; note that REPEAT-MATCHER will call
+                              ;; NON-GREEDY-AUX again recursively
+                              (prog1
+                                (funcall repeat-matcher start-pos)
+                                (decf (aref *repeat-counters* rep-num))
+                                (setf (svref *last-pos-stores* zero-length-num)
+                                        old-last-pos)))))))
+            ;; create a closure to match the inner regex and to
+            ;; implement backtracking via NON-GREEDY-AUX
+            (setq repeat-matcher
+                    (create-matcher-aux (regex repetition) #'non-greedy-aux))
+            ;; the closure we return is just a thin wrapper around
+            ;; NON-GREEDY-AUX to initialize the repetition counter and our
+            ;; slot in *LAST-POS-STORES*
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (setf (aref *repeat-counters* rep-num) 0
+                    (svref *last-pos-stores* zero-length-num) nil)
+              (non-greedy-aux start-pos)))))
+      (t
+        ;; easier code because we're not bounded by MAXIMUM, but
+        ;; basically the same
+        (flet ((non-greedy-aux (start-pos)
+                 (declare (fixnum start-pos)
+                          (function repeat-matcher))
+                 (let ((old-last-pos
+                         (svref *last-pos-stores* zero-length-num)))
+                   (when (and old-last-pos
+                              (= (the fixnum old-last-pos) start-pos))
+                     (return-from non-greedy-aux (funcall next-fn start-pos)))
+                   (setf (svref *last-pos-stores* zero-length-num) start-pos)
+                   (or (funcall next-fn start-pos)
+                       (prog1
+                         (funcall repeat-matcher start-pos)
+                         (setf (svref *last-pos-stores* zero-length-num)
+                                 old-last-pos))))))
+          (setq repeat-matcher
+                  (create-matcher-aux (regex repetition) #'non-greedy-aux))
+          (lambda (start-pos)
+            (declare (fixnum start-pos))
+            (setf (svref *last-pos-stores* zero-length-num) nil)
+            (non-greedy-aux start-pos)))))))
+  
+;; code for constant repetitions, i.e. those with a fixed number of repetitions
+                      
+(defmacro constant-repetition-constant-length-closure (check-curr-pos)
+  "This is the template for simple constant repetitions (where simple
+means that the inner regex to be checked is of fixed length LEN, and
+that it doesn't contain registers, i.e. there's no need for
+backtracking) and where constant means that MINIMUM is equal to
+MAXIMUM.  CHECK-CURR-POS is a form which checks whether the inner
+regex of the repetition matches at CURR-POS."
+  `(lambda (start-pos)
+    (declare (fixnum start-pos))
+      (let ((target-end-pos (+ start-pos
+                               (the fixnum (* len repetitions)))))
+        (declare (fixnum target-end-pos))
+        ;; first check if we won't go beyond the end of the string
+        (and (>= *end-pos* target-end-pos)
+             ;; then loop through all repetitions step by step
+             (loop for curr-pos of-type fixnum from start-pos
+                                               below target-end-pos
+                                               by len
+                   always ,check-curr-pos)
+             ;; finally call NEXT-FN if we made it that far
+             (funcall next-fn target-end-pos)))))
+
+(defgeneric create-constant-repetition-constant-length-matcher
+    (repetition next-fn)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Creates a closure which tries to match REPETITION.
+It is assumed that REPETITION has a constant number of repetitions.
+It is furthermore assumed that the inner regex of REPETITION is of
+fixed length and doesn't contain registers."))
+
+(defmethod create-constant-repetition-constant-length-matcher
+       ((repetition repetition) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (let ((len (len repetition))
+        (repetitions (minimum repetition))
+        (regex (regex repetition)))
+    (declare (fixnum len repetitions)
+             (function next-fn))
+    (if (zerop len)
+      ;; if the length is zero it suffices to try once
+      (create-matcher-aux regex next-fn)
+      ;; otherwise try to optimize for a couple of common cases
+      (typecase regex
+        (str
+          (let ((str (str regex)))
+            (if (= 1 len)
+              ;; a single character
+              (let ((chr (schar str 0)))
+                (if (case-insensitive-p regex)
+                  (constant-repetition-constant-length-closure
+                   (and (char-equal chr (schar *string* curr-pos))
+                        (1+ curr-pos)))
+                  (constant-repetition-constant-length-closure
+                   (and (char= chr (schar *string* curr-pos))
+                        (1+ curr-pos)))))
+              ;; a string
+              (if (case-insensitive-p regex)
+                (constant-repetition-constant-length-closure
+                 (let ((next-pos (+ curr-pos len)))
+                   (declare (fixnum next-pos))
+                   (and (*string*-equal str curr-pos next-pos 0 len)
+                        next-pos)))
+                (constant-repetition-constant-length-closure
+                 (let ((next-pos (+ curr-pos len)))
+                   (declare (fixnum next-pos))
+                   (and (*string*= str curr-pos next-pos 0 len)
+                        next-pos)))))))
+        (char-class
+          ;; a character class
+          (insert-char-class-tester (regex (schar *string* curr-pos))
+            (constant-repetition-constant-length-closure
+             (and (char-class-test)
+                  (1+ curr-pos)))))
+        (everything
+          (if (single-line-p regex)
+            ;; a dot which really matches everything - we just have to
+            ;; advance the index into *STRING* accordingly and check
+            ;; if we didn't go past the end
+            (lambda (start-pos)
+              (declare (fixnum start-pos))
+              (let ((next-pos (+ start-pos repetitions)))
+                (declare (fixnum next-pos))
+                (and (<= next-pos *end-pos*)
+                     (funcall next-fn next-pos))))
+            ;; a dot which is not in single-line-mode - make sure we
+            ;; don't match #\Newline
+            (constant-repetition-constant-length-closure
+             (and (char/= #\Newline (schar *string* curr-pos))
+                  (1+ curr-pos)))))
+        (t
+          ;; the general case - we build an inner matcher which just
+          ;; checks for immediate success, i.e. NEXT-FN is #'IDENTITY
+          (let ((inner-matcher (create-matcher-aux regex #'identity)))
+            (declare (function inner-matcher))
+            (constant-repetition-constant-length-closure
+             (funcall inner-matcher curr-pos))))))))
+  
+(defgeneric create-constant-repetition-matcher (repetition next-fn)
+  (declare #.*standard-optimize-settings*)
+  (:documentation "Creates a closure which tries to match REPETITION.
+It is assumed that REPETITION has a constant number of repetitions."))
+
+(defmethod create-constant-repetition-matcher ((repetition repetition) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (let ((repetitions (minimum repetition))
+        ;; we make a reservation for our slot in *REPEAT-COUNTERS*
+        ;; because we need to keep track of the number of repetitions
+        (rep-num (incf-after *rep-num*))
+        ;; REPEAT-MATCHER is part of the closure's environment but it
+        ;; can only be defined after NON-GREEDY-AUX is defined
+        repeat-matcher)
+    (declare (fixnum repetitions rep-num)
+             (function next-fn))
+    (if (zerop (min-len repetition))
+      ;; we make a reservation for our slot in *LAST-POS-STORES*
+      ;; because we have to watch out for needless loops as the inner
+      ;; regex might match zero-length strings
+      (let ((zero-length-num (incf-after *zero-length-num*)))
+        (declare (fixnum zero-length-num))
+        (flet ((constant-aux (start-pos)
+                 ;; the actual matcher which first calls NEXT-FN and
+                 ;; on failure tries to match the inner regex of
+                 ;; REPETITION (if we haven't done so too often)
+                 (declare (fixnum start-pos)
+                          (function repeat-matcher))
+                 (let ((old-last-pos
+                         (svref *last-pos-stores* zero-length-num)))
+                   (when (and old-last-pos
+                              (= (the fixnum old-last-pos) start-pos))
+                     ;; if we've been here before we matched a
+                     ;; zero-length string the last time, so we can
+                     ;; just carry on because we will definitely be
+                     ;; able to do this again often enough
+                     (return-from constant-aux (funcall next-fn start-pos)))
+                   ;; otherwise remember this position for the next
+                   ;; repetition
+                   (setf (svref *last-pos-stores* zero-length-num) start-pos)
+                   (cond ((< (aref *repeat-counters* rep-num) repetitions)
+                           ;; not enough repetitions yet, try it again
+                           (incf (aref *repeat-counters* rep-num))
+                           ;; note that REPEAT-MATCHER will call
+                           ;; CONSTANT-AUX again recursively
+                           (prog1
+                             (funcall repeat-matcher start-pos)
+                             (decf (aref *repeat-counters* rep-num))
+                             (setf (svref *last-pos-stores* zero-length-num)
+                                     old-last-pos)))
+                         (t
+                           ;; we're done - call NEXT-FN
+                           (funcall next-fn start-pos))))))
+          ;; create a closure to match the inner regex and to
+          ;; implement backtracking via CONSTANT-AUX
+          (setq repeat-matcher
+                  (create-matcher-aux (regex repetition) #'constant-aux))
+          ;; the closure we return is just a thin wrapper around
+          ;; CONSTANT-AUX to initialize the repetition counter
+          (lambda (start-pos)
+            (declare (fixnum start-pos))
+            (setf (aref *repeat-counters* rep-num) 0
+                  (aref *last-pos-stores* zero-length-num) nil)
+            (constant-aux start-pos))))
+      ;; easier code because we don't have to care about zero-length
+      ;; matches but basically the same
+      (flet ((constant-aux (start-pos)
+               (declare (fixnum start-pos)
+                        (function repeat-matcher))
+               (cond ((< (aref *repeat-counters* rep-num) repetitions)
+                       (incf (aref *repeat-counters* rep-num))
+                       (prog1
+                         (funcall repeat-matcher start-pos)
+                         (decf (aref *repeat-counters* rep-num))))
+                     (t (funcall next-fn start-pos)))))
+        (setq repeat-matcher
+                (create-matcher-aux (regex repetition) #'constant-aux))
+        (lambda (start-pos)
+          (declare (fixnum start-pos))
+          (setf (aref *repeat-counters* rep-num) 0)
+          (constant-aux start-pos))))))
+  
+;; the actual CREATE-MATCHER-AUX method for REPETITION objects which
+;; utilizes all the functions and macros defined above
+
+(defmethod create-matcher-aux ((repetition repetition) next-fn)
+  (declare #.*standard-optimize-settings*)
+  (with-slots (minimum maximum len min-len greedyp contains-register-p)
+      repetition
+    (cond ((and maximum
+                (zerop maximum))
+           ;; this should have been optimized away by CONVERT but just
+           ;; in case...
+           (error "Got REPETITION with MAXIMUM 0 \(should not happen)"))
+          ((and maximum
+                (= minimum maximum 1))
+           ;; this should have been optimized away by CONVERT but just
+           ;; in case...
+           (error "Got REPETITION with MAXIMUM 1 and MINIMUM 1 \(should not happen)"))
+          ((and (eql minimum maximum)
+                len
+                (not contains-register-p))
+           (create-constant-repetition-constant-length-matcher repetition next-fn))
+          ((eql minimum maximum)
+           (create-constant-repetition-matcher repetition next-fn))
+          ((and greedyp
+                len
+                (not contains-register-p))
+           (create-greedy-constant-length-matcher repetition next-fn))
+          ((and greedyp
+                (or (plusp min-len)
+                    (eql maximum 1)))
+           (create-greedy-no-zero-matcher repetition next-fn))
+          (greedyp
+           (create-greedy-matcher repetition next-fn))
+          ((and len
+                (plusp len)
+                (not contains-register-p))
+           (create-non-greedy-constant-length-matcher repetition next-fn))
+          ((or (plusp min-len)
+               (eql maximum 1))
+           (create-non-greedy-no-zero-matcher repetition next-fn))
+          (t
+           (create-non-greedy-matcher repetition next-fn)))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/scanner.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/scanner.lisp
new file mode 100644
index 0000000..ea43443
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/scanner.lisp
@@ -0,0 +1,506 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/scanner.lisp,v 1.36 2009/09/17 19:17:31 edi Exp $
+
+;;; Here the scanner for the actual regex as well as utility scanners
+;;; for the constant start and end strings are created.
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defmacro bmh-matcher-aux (&key case-insensitive-p)
+  "Auxiliary macro used by CREATE-BMH-MATCHER."
+  (let ((char-compare (if case-insensitive-p 'char-equal 'char=)))
+    `(lambda (start-pos)
+       (declare (fixnum start-pos))
+       (if (or (minusp start-pos)
+               (> (the fixnum (+ start-pos m)) *end-pos*))
+         nil
+         (loop named bmh-matcher
+               for k of-type fixnum = (+ start-pos m -1)
+               then (+ k (max 1 (aref skip (char-code (schar *string* k)))))
+               while (< k *end-pos*)
+               do (loop for j of-type fixnum downfrom (1- m)
+                        for i of-type fixnum downfrom k
+                        while (and (>= j 0)
+                                   (,char-compare (schar *string* i)
+                                                  (schar pattern j)))
+                        finally (if (minusp j)
+                                  (return-from bmh-matcher (1+ i)))))))))
+
+(defun create-bmh-matcher (pattern case-insensitive-p)
+  "Returns a Boyer-Moore-Horspool matcher which searches the (special)
+simple-string *STRING* for the first occurence of the substring
+PATTERN.  The search starts at the position START-POS within *STRING*
+and stops before *END-POS* is reached.  Depending on the second
+argument the search is case-insensitive or not.  If the special
+variable *USE-BMH-MATCHERS* is NIL, use the standard SEARCH function
+instead.  \(BMH matchers are faster but need much more space.)"
+  (declare #.*standard-optimize-settings*)
+  ;; see <http://www-igm.univ-mlv.fr/~lecroq/string/node18.html> for
+  ;; details
+  (unless *use-bmh-matchers*
+    (let ((test (if case-insensitive-p #'char-equal #'char=)))
+      (return-from create-bmh-matcher
+        (lambda (start-pos)
+          (declare (fixnum start-pos))
+          (and (not (minusp start-pos))
+               (search pattern
+                       *string*
+                       :start2 start-pos
+                       :end2 *end-pos*
+                       :test test))))))
+  (let* ((m (length pattern))
+	 (skip (make-array *regex-char-code-limit*
+                           :element-type 'fixnum
+                           :initial-element m)))
+    (declare (fixnum m))
+    (loop for k of-type fixnum below m
+          if case-insensitive-p
+          do (setf (aref skip (char-code (char-upcase (schar pattern k)))) (- m k 1)
+                   (aref skip (char-code (char-downcase (schar pattern k)))) (- m k 1))
+	  else
+          do (setf (aref skip (char-code (schar pattern k))) (- m k 1)))
+    (if case-insensitive-p
+      (bmh-matcher-aux :case-insensitive-p t)
+      (bmh-matcher-aux))))
+
+(defmacro char-searcher-aux (&key case-insensitive-p)
+  "Auxiliary macro used by CREATE-CHAR-SEARCHER."
+  (let ((char-compare (if case-insensitive-p 'char-equal 'char=)))
+    `(lambda (start-pos)
+      (declare (fixnum start-pos))
+      (and (not (minusp start-pos))
+           (loop for i of-type fixnum from start-pos below *end-pos*
+                 thereis (and (,char-compare (schar *string* i) chr) i))))))
+
+(defun create-char-searcher (chr case-insensitive-p)
+  "Returns a function which searches the (special) simple-string
+*STRING* for the first occurence of the character CHR. The search
+starts at the position START-POS within *STRING* and stops before
+*END-POS* is reached.  Depending on the second argument the search is
+case-insensitive or not."
+  (declare #.*standard-optimize-settings*)
+  (if case-insensitive-p
+    (char-searcher-aux :case-insensitive-p t)
+    (char-searcher-aux)))
+
+(declaim (inline newline-skipper))
+(defun newline-skipper (start-pos)
+  "Finds the next occurence of a character in *STRING* which is behind
+a #\Newline."
+  (declare #.*standard-optimize-settings*)
+  (declare (fixnum start-pos))
+  ;; we can start with (1- START-POS) without testing for (PLUSP
+  ;; START-POS) because we know we'll never call NEWLINE-SKIPPER on
+  ;; the first iteration
+  (loop for i of-type fixnum from (1- start-pos) below *end-pos*
+        thereis (and (char= (schar *string* i)
+                            #\Newline)
+                     (1+ i))))
+
+(defmacro insert-advance-fn (advance-fn)
+  "Creates the actual closure returned by CREATE-SCANNER-AUX by
+replacing '(ADVANCE-FN-DEFINITION) with a suitable definition for
+ADVANCE-FN.  This is a utility macro used by CREATE-SCANNER-AUX."
+  (subst
+   advance-fn '(advance-fn-definition)
+   '(lambda (string start end)
+     (block scan
+       ;; initialize a couple of special variables used by the
+       ;; matchers (see file specials.lisp)
+       (let* ((*string* string)
+              (*start-pos* start)
+              (*end-pos* end)
+              ;; we will search forward for END-STRING if this value
+              ;; isn't at least as big as POS (see ADVANCE-FN), so it
+              ;; is safe to start to the left of *START-POS*; note
+              ;; that this value will _never_ be decremented - this
+              ;; is crucial to the scanning process
+              (*end-string-pos* (1- *start-pos*))
+              ;; the next five will shadow the variables defined by
+              ;; DEFPARAMETER; at this point, we don't know if we'll
+              ;; actually use them, though
+              (*repeat-counters* *repeat-counters*)
+              (*last-pos-stores* *last-pos-stores*)
+              (*reg-starts* *reg-starts*)
+              (*regs-maybe-start* *regs-maybe-start*)
+              (*reg-ends* *reg-ends*)
+              ;; we might be able to optimize the scanning process by
+              ;; (virtually) shifting *START-POS* to the right
+              (scan-start-pos *start-pos*)
+              (starts-with-str (if start-string-test
+                                 (str starts-with)
+                                 nil))
+              ;; we don't need to try further than MAX-END-POS
+              (max-end-pos (- *end-pos* min-len)))
+         (declare (fixnum scan-start-pos)
+                  (function match-fn))
+         ;; definition of ADVANCE-FN will be inserted here by macrology
+         (labels ((advance-fn-definition))
+           (declare (inline advance-fn))
+           (when (plusp rep-num)
+             ;; we have at least one REPETITION which needs to count
+             ;; the number of repetitions
+             (setq *repeat-counters* (make-array rep-num
+                                                 :initial-element 0
+                                                 :element-type 'fixnum)))
+           (when (plusp zero-length-num)
+             ;; we have at least one REPETITION which needs to watch
+             ;; out for zero-length repetitions
+             (setq *last-pos-stores* (make-array zero-length-num
+                                                 :initial-element nil)))
+           (when (plusp reg-num)
+             ;; we have registers in our regular expression
+             (setq *reg-starts* (make-array reg-num :initial-element nil)
+                   *regs-maybe-start* (make-array reg-num :initial-element nil)
+                   *reg-ends* (make-array reg-num :initial-element nil)))
+           (when end-anchored-p
+             ;; the regular expression has a constant end string which
+             ;; is anchored at the very end of the target string
+             ;; (perhaps modulo a #\Newline)
+             (let ((end-test-pos (- *end-pos* (the fixnum end-string-len))))
+               (declare (fixnum end-test-pos)
+                        (function end-string-test))
+               (unless (setq *end-string-pos* (funcall end-string-test
+                                                       end-test-pos))
+                 (when (and (= 1 (the fixnum end-anchored-p))
+                            (> *end-pos* scan-start-pos)
+                            (char= #\Newline (schar *string* (1- *end-pos*))))
+                   ;; if we didn't find an end string candidate from
+                   ;; END-TEST-POS and if a #\Newline at the end is
+                   ;; allowed we try it again from one position to the
+                   ;; left
+                   (setq *end-string-pos* (funcall end-string-test
+                                                   (1- end-test-pos))))))
+             (unless (and *end-string-pos*
+                          (<= *start-pos* *end-string-pos*))
+               ;; no end string candidate found, so give up
+               (return-from scan nil))
+             (when end-string-offset
+               ;; if the offset of the constant end string from the
+               ;; left of the regular expression is known we can start
+               ;; scanning further to the right; this is similar to
+               ;; what we might do in ADVANCE-FN
+               (setq scan-start-pos (max scan-start-pos
+                                         (- (the fixnum *end-string-pos*)
+                                            (the fixnum end-string-offset))))))
+             (cond
+               (start-anchored-p
+                 ;; we're anchored at the start of the target string,
+                 ;; so no need to try again after first failure
+                 (when (or (/= *start-pos* scan-start-pos)
+                           (< max-end-pos *start-pos*))
+                   ;; if END-STRING-OFFSET has proven that we don't
+                   ;; need to bother to scan from *START-POS* or if the
+                   ;; minimal length of the regular expression is
+                   ;; longer than the target string we give up
+                   (return-from scan nil))
+                 (when starts-with-str
+                   (locally
+                     (declare (fixnum starts-with-len))
+                     (cond ((and (case-insensitive-p starts-with)
+                                 (not (*string*-equal starts-with-str
+                                                      *start-pos*
+                                                      (+ *start-pos*
+                                                         starts-with-len)
+                                                      0 starts-with-len)))
+                             ;; the regular expression has a
+                             ;; case-insensitive constant start string
+                             ;; and we didn't find it
+                             (return-from scan nil))
+                           ((and (not (case-insensitive-p starts-with))
+                                 (not (*string*= starts-with-str
+                                            *start-pos*
+                                            (+ *start-pos* starts-with-len)
+                                            0 starts-with-len)))
+                             ;; the regular expression has a
+                             ;; case-sensitive constant start string
+                             ;; and we didn't find it
+                             (return-from scan nil))
+                           (t nil))))
+                 (when (and end-string-test
+                            (not end-anchored-p))
+                   ;; the regular expression has a constant end string
+                   ;; which isn't anchored so we didn't check for it
+                   ;; already
+                   (block end-string-loop
+                     ;; we temporarily use *END-STRING-POS* as our
+                     ;; starting position to look for end string
+                     ;; candidates
+                     (setq *end-string-pos* *start-pos*)
+                     (loop
+                       (unless (setq *end-string-pos*
+                                       (funcall (the function end-string-test)
+                                                *end-string-pos*))
+                         ;; no end string candidate found, so give up
+                         (return-from scan nil))
+                       (unless end-string-offset
+                         ;; end string doesn't have an offset so we
+                         ;; can start scanning now
+                         (return-from end-string-loop))
+                       (let ((maybe-start-pos (- (the fixnum *end-string-pos*)
+                                                 (the fixnum end-string-offset))))
+                         (cond ((= maybe-start-pos *start-pos*)
+                                 ;; offset of end string into regular
+                                 ;; expression matches start anchor -
+                                 ;; fine...
+                                 (return-from end-string-loop))
+                               ((and (< maybe-start-pos *start-pos*)
+                                     (< (+ *end-string-pos* end-string-len) *end-pos*))
+                                 ;; no match but maybe we find another
+                                 ;; one to the right - try again
+                                 (incf *end-string-pos*))
+                               (t
+                                 ;; otherwise give up
+                                 (return-from scan nil)))))))
+                 ;; if we got here we scan exactly once
+                 (let ((next-pos (funcall match-fn *start-pos*)))
+                   (when next-pos
+                     (values (if next-pos *start-pos* nil)
+                             next-pos
+                             *reg-starts*
+                             *reg-ends*))))
+               (t
+                 (loop for pos = (if starts-with-everything
+                                   ;; don't jump to the next
+                                   ;; #\Newline on the first
+                                   ;; iteration
+                                   scan-start-pos
+                                   (advance-fn scan-start-pos))
+                           then (advance-fn pos)
+                       ;; give up if the regular expression can't fit
+                       ;; into the rest of the target string
+                       while (and pos
+                                  (<= (the fixnum pos) max-end-pos))
+                       do (let ((next-pos (funcall match-fn pos)))
+                            (when next-pos
+                              (return-from scan (values pos
+                                                        next-pos
+                                                        *reg-starts*
+                                                        *reg-ends*)))
+                            ;; not yet found, increment POS
+                            #-cormanlisp (incf (the fixnum pos))
+                            #+cormanlisp (incf pos)))))))))
+    :test #'equalp))
+
+(defun create-scanner-aux (match-fn
+                           min-len
+                           start-anchored-p
+                           starts-with
+                           start-string-test
+                           end-anchored-p
+                           end-string-test
+                           end-string-len
+                           end-string-offset
+                           rep-num
+                           zero-length-num
+                           reg-num)
+  "Auxiliary function to create and return a scanner \(which is
+actually a closure).  Used by CREATE-SCANNER."
+  (declare #.*standard-optimize-settings*)
+  (declare (fixnum min-len zero-length-num rep-num reg-num))
+  (let ((starts-with-len (if (typep starts-with 'str)
+                           (len starts-with)))
+        (starts-with-everything (typep starts-with 'everything)))
+    (cond
+      ;; this COND statement dispatches on the different versions we
+      ;; have for ADVANCE-FN and creates different closures for each;
+      ;; note that you see only the bodies of ADVANCE-FN below - the
+      ;; actual scanner is defined in INSERT-ADVANCE-FN above; (we
+      ;; could have done this with closures instead of macrology but
+      ;; would have consed a lot more)
+      ((and start-string-test end-string-test end-string-offset)
+        ;; we know that the regular expression has constant start and
+        ;; end strings and we know the end string's offset (from the
+        ;; left)
+        (insert-advance-fn
+          (advance-fn (pos)
+            (declare (fixnum end-string-offset starts-with-len)
+                     (function start-string-test end-string-test))
+            (loop
+              (unless (setq pos (funcall start-string-test pos))
+                ;; give up completely if we can't find a start string
+                ;; candidate
+                (return-from scan nil))
+              (locally
+                ;; from here we know that POS is a FIXNUM
+                (declare (fixnum pos))
+                (when (= pos (- (the fixnum *end-string-pos*) end-string-offset))
+                  ;; if we already found an end string candidate the
+                  ;; position of which matches the start string
+                  ;; candidate we're done
+                  (return-from advance-fn pos))
+                (let ((try-pos (+ pos starts-with-len)))
+                  ;; otherwise try (again) to find an end string
+                  ;; candidate which starts behind the start string
+                  ;; candidate
+                  (loop
+                    (unless (setq *end-string-pos*
+                                    (funcall end-string-test try-pos))
+                      ;; no end string candidate found, so give up
+                      (return-from scan nil))
+                    ;; NEW-POS is where we should start scanning
+                    ;; according to the end string candidate
+                    (let ((new-pos (- (the fixnum *end-string-pos*)
+                                      end-string-offset)))
+                      (declare (fixnum new-pos *end-string-pos*))
+                      (cond ((= new-pos pos)
+                              ;; if POS and NEW-POS are equal then the
+                              ;; two candidates agree so we're fine
+                              (return-from advance-fn pos))
+                            ((> new-pos pos)
+                              ;; if NEW-POS is further to the right we
+                              ;; advance POS and try again, i.e. we go
+                              ;; back to the start of the outer LOOP
+                              (setq pos new-pos)
+                              ;; this means "return from inner LOOP"
+                              (return))
+                            (t
+                              ;; otherwise NEW-POS is smaller than POS,
+                              ;; so we have to redo the inner LOOP to
+                              ;; find another end string candidate
+                              ;; further to the right
+                              (setq try-pos (1+ *end-string-pos*))))))))))))
+      ((and starts-with-everything end-string-test end-string-offset)
+        ;; we know that the regular expression starts with ".*" (which
+        ;; is not in single-line-mode, see CREATE-SCANNER-AUX) and ends
+        ;; with a constant end string and we know the end string's
+        ;; offset (from the left)
+        (insert-advance-fn
+          (advance-fn (pos)
+            (declare (fixnum end-string-offset)
+                     (function end-string-test))
+            (loop
+              (unless (setq pos (newline-skipper pos))
+                ;; if we can't find a #\Newline we give up immediately
+                (return-from scan nil))
+              (locally
+                ;; from here we know that POS is a FIXNUM
+                (declare (fixnum pos))
+                (when (= pos (- (the fixnum *end-string-pos*) end-string-offset))
+                  ;; if we already found an end string candidate the
+                  ;; position of which matches the place behind the
+                  ;; #\Newline we're done
+                  (return-from advance-fn pos))
+                (let ((try-pos pos))
+                  ;; otherwise try (again) to find an end string
+                  ;; candidate which starts behind the #\Newline
+                  (loop
+                    (unless (setq *end-string-pos*
+                                    (funcall end-string-test try-pos))
+                      ;; no end string candidate found, so we give up
+                      (return-from scan nil))
+                    ;; NEW-POS is where we should start scanning
+                    ;; according to the end string candidate
+                    (let ((new-pos (- (the fixnum *end-string-pos*)
+                                      end-string-offset)))
+                      (declare (fixnum new-pos *end-string-pos*))
+                      (cond ((= new-pos pos)
+                              ;; if POS and NEW-POS are equal then the
+                              ;; the end string candidate agrees with
+                              ;; the #\Newline so we're fine
+                              (return-from advance-fn pos))
+                            ((> new-pos pos)
+                              ;; if NEW-POS is further to the right we
+                              ;; advance POS and try again, i.e. we go
+                              ;; back to the start of the outer LOOP
+                              (setq pos new-pos)
+                              ;; this means "return from inner LOOP"
+                              (return))
+                            (t
+                              ;; otherwise NEW-POS is smaller than POS,
+                              ;; so we have to redo the inner LOOP to
+                              ;; find another end string candidate
+                              ;; further to the right
+                              (setq try-pos (1+ *end-string-pos*))))))))))))
+      ((and start-string-test end-string-test)
+        ;; we know that the regular expression has constant start and
+        ;; end strings; similar to the first case but we only need to
+        ;; check for the end string, it doesn't provide enough
+        ;; information to advance POS
+        (insert-advance-fn
+          (advance-fn (pos)
+            (declare (function start-string-test end-string-test))
+            (unless (setq pos (funcall start-string-test pos))
+              (return-from scan nil))
+            (if (<= (the fixnum pos)
+                    (the fixnum *end-string-pos*))
+              (return-from advance-fn pos))
+            (unless (setq *end-string-pos* (funcall end-string-test pos))
+              (return-from scan nil))
+            pos)))
+      ((and starts-with-everything end-string-test)
+        ;; we know that the regular expression starts with ".*" (which
+        ;; is not in single-line-mode, see CREATE-SCANNER-AUX) and ends
+        ;; with a constant end string; similar to the second case but we
+        ;; only need to check for the end string, it doesn't provide
+        ;; enough information to advance POS
+        (insert-advance-fn
+          (advance-fn (pos)
+            (declare (function end-string-test))
+            (unless (setq pos (newline-skipper pos))
+              (return-from scan nil))
+            (if (<= (the fixnum pos)
+                    (the fixnum *end-string-pos*))
+              (return-from advance-fn pos))
+            (unless (setq *end-string-pos* (funcall end-string-test pos))
+              (return-from scan nil))
+            pos)))
+      (start-string-test
+        ;; just check for constant start string candidate
+        (insert-advance-fn
+          (advance-fn (pos)
+            (declare (function start-string-test))
+            (unless (setq pos (funcall start-string-test pos))
+              (return-from scan nil))
+            pos)))
+      (starts-with-everything
+        ;; just advance POS with NEWLINE-SKIPPER
+        (insert-advance-fn
+          (advance-fn (pos)
+            (unless (setq pos (newline-skipper pos))
+              (return-from scan nil))
+            pos)))
+      (end-string-test
+        ;; just check for the next end string candidate if POS has
+        ;; advanced beyond the last one
+        (insert-advance-fn
+          (advance-fn (pos)
+            (declare (function end-string-test))
+            (if (<= (the fixnum pos)
+                    (the fixnum *end-string-pos*))
+              (return-from advance-fn pos))
+            (unless (setq *end-string-pos* (funcall end-string-test pos))
+              (return-from scan nil))
+            pos)))
+      (t
+        ;; not enough optimization information about the regular
+        ;; expression to optimize so we just return POS
+        (insert-advance-fn
+          (advance-fn (pos)
+            pos))))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/specials.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/specials.lisp
new file mode 100644
index 0000000..b03c42c
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/specials.lisp
@@ -0,0 +1,172 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/specials.lisp,v 1.43 2009/10/28 07:36:15 edi Exp $
+
+;;; globally declared special variables
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+;;; special variables used to effect declarations
+
+(defvar *standard-optimize-settings*
+  '(optimize
+    speed
+    (space 0)
+    (debug 1)
+    (compilation-speed 0))
+  "The standard optimize settings used by most declaration expressions.")
+
+(defvar *special-optimize-settings*
+  '(optimize speed space)
+  "Special optimize settings used only by a few declaration expressions.")
+
+;;; special variables used by the lexer/parser combo
+
+(defvar *extended-mode-p* nil
+  "Whether the parser will start in extended mode.")
+(declaim (boolean *extended-mode-p*))
+
+;;; special variables used by the SCAN function and the matchers
+
+(defvar *regex-char-code-limit* char-code-limit
+  "The upper exclusive bound on the char-codes of characters which can
+occur in character classes.  Change this value BEFORE creating
+scanners if you don't need the \(full) Unicode support of
+implementations like AllegroCL, CLISP, LispWorks, or SBCL.")
+(declaim (fixnum *regex-char-code-limit*))
+  
+(defvar *string* (make-sequence #+:lispworks 'lw:simple-text-string
+                                #-:lispworks 'simple-string
+                                0)
+  "The string which is currently scanned by SCAN.
+Will always be coerced to a SIMPLE-STRING.")
+#+:lispworks
+(declaim (lw:simple-text-string *string*))
+#-:lispworks
+(declaim (simple-string *string*))
+
+(defvar *start-pos* 0
+  "Where to start scanning within *STRING*.")
+(declaim (fixnum *start-pos*))
+
+(defvar *real-start-pos* nil
+  "The real start of *STRING*. This is for repeated scans and is only used internally.")
+(declaim (type (or null fixnum) *real-start-pos*))
+
+(defvar *end-pos* 0
+  "Where to stop scanning within *STRING*.")
+(declaim (fixnum *end-pos*))
+
+(defvar *reg-starts* (make-array 0)
+  "An array which holds the start positions
+of the current register candidates.")
+(declaim (simple-vector *reg-starts*))
+  
+(defvar *regs-maybe-start* (make-array 0)
+  "An array which holds the next start positions
+of the current register candidates.")
+(declaim (simple-vector *regs-maybe-start*))
+
+(defvar *reg-ends* (make-array 0)
+  "An array which holds the end positions
+of the current register candidates.")
+(declaim (simple-vector *reg-ends*))
+
+(defvar *end-string-pos* nil
+  "Start of the next possible end-string candidate.")
+
+(defvar *rep-num* 0
+  "Counts the number of \"complicated\" repetitions while the matchers
+are built.")
+(declaim (fixnum *rep-num*))
+
+(defvar *zero-length-num* 0
+  "Counts the number of repetitions the inner regexes of which may
+have zero-length while the matchers are built.")
+(declaim (fixnum *zero-length-num*))
+
+(defvar *repeat-counters* (make-array 0
+                                      :initial-element 0
+                                      :element-type 'fixnum)
+  "An array to keep track of how often
+repetitive patterns have been tested already.")
+(declaim (type (array fixnum (*)) *repeat-counters*))
+
+(defvar *last-pos-stores* (make-array 0)
+  "An array to keep track of the last positions
+where we saw repetitive patterns.
+Only used for patterns which might have zero length.")
+(declaim (simple-vector *last-pos-stores*))
+
+(defvar *use-bmh-matchers* nil
+  "Whether the scanners created by CREATE-SCANNER should use the \(fast
+but large) Boyer-Moore-Horspool matchers.")
+
+(defvar *optimize-char-classes* nil
+  "Whether character classes should be compiled into look-ups into
+O\(1) data structures.  This is usually fast but will be costly in
+terms of scanner creation time and might be costly in terms of size if
+*REGEX-CHAR-CODE-LIMIT* is high.  This value will be used as the :KIND
+keyword argument to CREATE-OPTIMIZED-TEST-FUNCTION - see there for the
+possible non-NIL values.")
+
+(defvar *property-resolver* nil
+  "Should be NIL or a designator for a function which accepts strings
+and returns unary character test functions or NIL.  This 'resolver' is
+intended to handle `character properties' like \\p{IsAlpha}.  If
+*PROPERTY-RESOLVER* is NIL, then the parser will simply treat \\p and
+\\P as #\\p and #\\P as in older versions of CL-PPCRE.")
+
+(defvar *allow-quoting* nil
+  "Whether the parser should support Perl's \\Q and \\E.")
+
+(defvar *allow-named-registers* nil
+  "Whether the parser should support AllegroCL's named registers
+\(?<name>\"<regex>\") and back-reference \\k<name> syntax.")
+
+(pushnew :cl-ppcre *features*)
+
+;; stuff for Nikodemus Siivola's HYPERDOC
+;; see <http://common-lisp.net/project/hyperdoc/>
+;; and <http://www.cliki.net/hyperdoc>
+;; also used by LW-ADD-ONS
+
+(defvar *hyperdoc-base-uri* "http://weitz.de/cl-ppcre/")
+
+(let ((exported-symbols-alist
+       (loop for symbol being the external-symbols of :cl-ppcre
+             collect (cons symbol
+                           (concatenate 'string
+                                        "#"
+                                        (string-downcase symbol))))))
+  (defun hyperdoc-lookup (symbol type)
+    (declare (ignore type))
+    (cdr (assoc symbol
+                exported-symbols-alist
+                :test #'eq))))
+               
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/packages.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/packages.lisp
new file mode 100644
index 0000000..6337071
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/packages.lisp
@@ -0,0 +1,37 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/test/packages.lisp,v 1.4 2009/09/17 19:17:36 edi Exp $
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-user)
+
+(defpackage :cl-ppcre-test
+  #+genera (:shadowing-import-from :common-lisp :lambda)
+  (:use #-:genera :cl #+:genera :future-common-lisp :cl-ppcre)
+  (:import-from :cl-ppcre :*standard-optimize-settings*
+                          :string-list-to-simple-string)
+  (:export :run-all-tests :unicode-test))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/perl-tests.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/perl-tests.lisp
new file mode 100644
index 0000000..f714c8c
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/perl-tests.lisp
@@ -0,0 +1,150 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE-TEST; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/test/perl-tests.lisp,v 1.8 2009/09/17 19:17:36 edi Exp $
+
+;;; The tests in this file test CL-PPCRE against testdata generated by
+;;; the Perl program `perltest.pl' from the input file `testinput' in
+;;; order to check compatibility with Perl and correctness of the
+;;; regex engine.
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre-test)
+
+(defvar *tests-to-skip* '(636 638 662 790 1439)
+  "Some tests we skip because the testdata is generated by a Perl
+program and CL-PPCRE differs from Perl for these tests - on purpose.")
+
+(defun create-string-from-input (input)
+  "Converts INPUT to a string which can be used in TEST below.  The
+input file `testdata' encodes strings containing non-printable
+characters as lists where those characters are represented by their
+character code."
+  (etypecase input
+    ((or null string) input)
+    (list (string-list-to-simple-string
+           (loop for element in input
+                 if (stringp element)
+                 collect element
+                 else
+                 collect (string (code-char element)))))))
+
+(defun perl-test (&key (file-name 
+                        (make-pathname :name "perltestdata"
+                                       :type nil :version nil
+                                       :defaults *this-file*)
+                        file-name-provided-p)
+                       (external-format '(:latin-1 :eol-style :lf))
+                       verbose)
+  "Loops through all test cases in FILE-NAME and prints a report if
+VERBOSE is true.  EXTERNAL-FORMAT is the FLEXI-STREAMS external format
+which is used to read the file.  Returns a true value if all tests
+succeeded.
+
+For the syntax of the tests in FILE-NAME refer to the source code of
+this function and to the Perl script perltest.pl which generates such
+test files."
+  (declare #.*standard-optimize-settings*)
+  (with-open-file (binary-stream file-name :element-type 'flex:octet)
+    (let ((stream (flex:make-flexi-stream binary-stream :external-format external-format))
+          ;; the standard Perl tests don't need full Unicode support
+          (*regex-char-code-limit* (if file-name-provided-p *regex-char-code-limit* 256))
+          ;; we need this for the standard test suite or otherwise we
+          ;; might get stack overflows
+          (*optimize-char-classes* (if file-name-provided-p *optimize-char-classes* :charmap))
+          ;; we only check for correctness and don't care about speed
+          ;; that match (but rather about space constraints of the
+          ;; trial versions)
+          (*use-bmh-matchers* (if file-name-provided-p *use-bmh-matchers* nil))
+          ;; some tests in the Perl suite explicitly check for this
+          (*allow-quoting* (if file-name-provided-p *allow-quoting* t)))
+      (do-tests ((format nil "Running tests in file ~S" (file-namestring file-name))
+                 (not verbose))
+        (let ((input-line (or (read stream nil) (done)))
+              errors)
+          (destructuring-bind (counter
+                               info-string%
+                               regex%
+                               case-insensitive-mode
+                               multi-line-mode
+                               single-line-mode
+                               extended-mode
+                               target%
+                               perl-error
+                               expected-result%
+                               expected-registers)
+              input-line
+            (destructuring-bind (info-string regex target expected-result)
+                (mapcar 'create-string-from-input
+                        (list info-string% regex% target% expected-result%))
+              (setq expected-registers (mapcar 'create-string-from-input expected-registers))
+              (unless (find counter *tests-to-skip* :test #'=)
+                (when verbose
+                  (format t "~&~4D: ~S" counter info-string))                  
+                (block inner-test-block
+                  (let ((scanner
+                         (handler-bind ((error (lambda (condition)
+                                                 (declare (ignore condition))
+                                                 (when perl-error
+                                                   ;; we expected an
+                                                   ;; error, so we can
+                                                   ;; signal success
+                                                   (return-from inner-test-block)))))
+                           (create-scanner regex
+                                           :case-insensitive-mode case-insensitive-mode
+                                           :multi-line-mode multi-line-mode
+                                           :single-line-mode single-line-mode
+                                           :extended-mode extended-mode))))
+                    (multiple-value-bind (start end reg-starts reg-ends)                        
+                        (scan scanner target)
+                      (cond (perl-error
+                             (push (format nil "expected an error but got a result.")
+                                   errors))
+                            (t
+                             (when (not (eq start expected-result))
+                               (if start
+                                   (let ((result (subseq target start end)))
+                                     (unless (string= result expected-result)
+                                       (push (format nil "expected ~S but got ~S."
+                                                     expected-result result)
+                                             errors))
+                                     (setq reg-starts (coerce reg-starts 'list)
+                                           reg-ends (coerce reg-ends 'list))
+                                     (loop for i from 0
+                                        for expected-register in expected-registers
+                                        for reg-start = (nth i reg-starts)
+                                        for reg-end = (nth i reg-ends)
+                                        for register = (if (and reg-start reg-end)
+                                                           (subseq target reg-start reg-end)
+                                                           nil)
+                                        unless (string= expected-register register)
+                                        do (push (format nil "\\~A: expected ~S but got ~S."
+                                                         (1+ i) expected-register register)
+                                                 errors)))
+                                   (push (format nil "expected ~S but got ~S."
+                                                 expected-result start)
+                                         errors))))))
+                    errors))))))))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/perltest.pl b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/perltest.pl
new file mode 100644
index 0000000..b49d973
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/perltest.pl
@@ -0,0 +1,160 @@
+#!/usr/bin/perl
+# $Header: /usr/local/cvsrep/cl-ppcre/test/perltest.pl,v 1.1 2008/07/06 21:24:39 edi Exp $
+
+# This is a heavily modified version of the file 'perltest' which
+# comes with the PCRE library package, which is open source software,
+# written by Philip Hazel, and copyright by the University of
+# Cambridge, England.
+
+# The PCRE library package is available from
+# <ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/>
+
+sub string_for_lisp {
+  my(@a, $t, $in_string, $switch);
+
+  my $string = shift;
+  $string =~ s/\\/\\\\/g;
+  $string =~ s/"/\\"/g;
+
+  return "\"$string\""
+    if $string =~ /^[\n\x20-\x7f]*$/;
+
+  $in_string = 1;
+  foreach $c (split(//, $string)) {
+    if (ord $c >= 32 and ord $c < 127) {
+      if ($in_string) {
+        $t .= $c;
+      } else {
+        $in_string = 1;
+        $t = $c;
+      }
+    } else {
+      if ($in_string) {
+        push @a, "\"$t\"";
+        $in_string = 0;
+        $switch = 1;
+      }
+      push @a, ord $c;
+    }
+  }
+  if ($switch) {
+    if ($in_string) {
+      push @a, "\"$t\"";
+    }
+    '(' . (join ' ', @a) . ')';
+  } else {
+    "\"$t\"";
+  }
+}
+
+NEXT_RE: while (1) {
+  last
+    if !($_ = <>);
+  next
+    if $_ eq "";
+
+  $pattern = $_;
+
+  while ($pattern !~ /^\s*(.).*\1/s) {
+    last
+      if !($_ = <>);
+    $pattern .= $_;
+  }
+
+  chomp($pattern);
+  $pattern =~ s/\s+$//;
+  $pattern =~ s/\+(?=[a-z]*$)//;
+
+  $multi_line_mode = ($pattern =~ /m[a-z]*$/) ? 't' : 'nil';
+  $single_line_mode = ($pattern =~ /s[a-z]*$/) ? 't' : 'nil';
+  $extended_mode = ($pattern =~ /x[a-z]*$/) ? 't' : 'nil';
+  $case_insensitive_mode = ($pattern =~ /i[a-z]*$/) ? 't' : 'nil';
+  $pattern =~ s/^(.*)g([a-z]*)$/\1\2/;
+
+  $pattern_for_lisp = $pattern;
+  $pattern_for_lisp =~ s/[a-z]*$//;
+  $pattern_for_lisp =~ s/^\s*(.)(.*)\1/$2/s;
+  $pattern_for_lisp =~ s/\\/\\\\/g;
+  $pattern_for_lisp =~ s/"/\\"/g;
+
+  $pattern = "/(?#)/$2"
+    if ($pattern =~ /^(.)\1(.*)$/);
+
+  while (1) {
+    last NEXT_RE
+      if !($_ = <>);
+
+    chomp;
+
+    s/\s+$//;
+    s/^\s+//;
+
+    last
+      if ($_ eq "");
+
+    $info_string = string_for_lisp "\"$_\" =~ $pattern";
+    $x = eval "\"$_\"";
+
+    @subs = ();
+
+    eval <<"END";
+if (\$x =~ ${pattern}) {
+  push \@subs,\$&;
+  push \@subs,\$1;
+  push \@subs,\$2;
+  push \@subs,\$3;
+  push \@subs,\$4;
+  push \@subs,\$5;
+  push \@subs,\$6;
+  push \@subs,\$7;
+  push \@subs,\$8;
+  push \@subs,\$9;
+  push \@subs,\$10;
+  push \@subs,\$11;
+  push \@subs,\$12;
+  push \@subs,\$13;
+  push \@subs,\$14;
+  push \@subs,\$15;
+  push \@subs,\$16;
+}
+
+\$test = sub {
+  my \$times = shift;
+
+  my \$start = time;
+  for (my \$i = 0; \$i < \$times; \$i++) {
+    \$x =~ ${pattern};
+  }
+  return time - \$start;
+};
+END
+
+    $counter++;
+    print STDERR "$counter\n";
+
+    if ($@) {
+      $error = 't';
+    } else {
+      $error = 'nil';
+    }
+
+    print "($counter $info_string \"$pattern_for_lisp\" $case_insensitive_mode $multi_line_mode $single_line_mode $extended_mode " . string_for_lisp($x) . " $error ";
+    if (!@subs) {
+      print 'nil nil';
+    } else {
+      print string_for_lisp($subs[0]) . ' (';
+      undef $not_first;
+      for ($i = 1; $i <= 16; $i++) {
+        print ' '
+          unless $i == 1;
+        if (defined $subs[$i]) {
+          print string_for_lisp $subs[$i];
+        } else {
+          print 'nil';
+        }
+      }
+      print ')';
+    }
+    print ")\n";
+  }
+}
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/perltestdata b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/perltestdata
new file mode 100644
index 0000000..1b52320
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/perltestdata
@@ -0,0 +1,14292 @@
+(1 "\"the quick brown fox\" =~ /the quick brown fox/" "the quick brown fox" nil nil nil nil "the quick brown fox" nil "the quick brown fox" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(2 "\"The quick brown FOX\" =~ /the quick brown fox/" "the quick brown fox" nil nil nil nil "The quick brown FOX" nil nil nil)
+(3 "\"What do you know about the quick brown fox?\" =~ /the quick brown fox/" "the quick brown fox" nil nil nil nil "What do you know about the quick brown fox?" nil "the quick brown fox" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(4 "\"What do you know about THE QUICK BROWN FOX?\" =~ /the quick brown fox/" "the quick brown fox" nil nil nil nil "What do you know about THE QUICK BROWN FOX?" nil nil nil)
+(5 "\"the quick brown fox\" =~ /The quick brown fox/i" "The quick brown fox" t nil nil nil "the quick brown fox" nil "the quick brown fox" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(6 "\"The quick brown FOX\" =~ /The quick brown fox/i" "The quick brown fox" t nil nil nil "The quick brown FOX" nil "The quick brown FOX" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(7 "\"What do you know about the quick brown fox?\" =~ /The quick brown fox/i" "The quick brown fox" t nil nil nil "What do you know about the quick brown fox?" nil "the quick brown fox" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(8 "\"What do you know about THE QUICK BROWN FOX?\" =~ /The quick brown fox/i" "The quick brown fox" t nil nil nil "What do you know about THE QUICK BROWN FOX?" nil "THE QUICK BROWN FOX" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(9 "\"abcd\\t\\n\\r\\f\\a\\e9;\\$\\\\?caxyz\" =~ /abcd\\t\\n\\r\\f\\a\\e\\071\\x3b\\$\\\\\\?caxyz/" "abcd\\t\\n\\r\\f\\a\\e\\071\\x3b\\$\\\\\\?caxyz" nil nil nil nil ("abcd" 9 10 13 12 7 27 "9;$\\?caxyz") nil ("abcd" 9 10 13 12 7 27 "9;$\\?caxyz") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(10 "\"abxyzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "abxyzpqrrrabbxyyyypqAzz" nil "abxyzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(11 "\"abxyzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "abxyzpqrrrabbxyyyypqAzz" nil "abxyzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(12 "\"aabxyzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aabxyzpqrrrabbxyyyypqAzz" nil "aabxyzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(13 "\"aaabxyzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaabxyzpqrrrabbxyyyypqAzz" nil "aaabxyzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(14 "\"aaaabxyzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaaabxyzpqrrrabbxyyyypqAzz" nil "aaaabxyzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(15 "\"abcxyzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "abcxyzpqrrrabbxyyyypqAzz" nil "abcxyzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(16 "\"aabcxyzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aabcxyzpqrrrabbxyyyypqAzz" nil "aabcxyzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(17 "\"aaabcxyzpqrrrabbxyyyypAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaabcxyzpqrrrabbxyyyypAzz" nil "aaabcxyzpqrrrabbxyyyypAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(18 "\"aaabcxyzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaabcxyzpqrrrabbxyyyypqAzz" nil "aaabcxyzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(19 "\"aaabcxyzpqrrrabbxyyyypqqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaabcxyzpqrrrabbxyyyypqqAzz" nil "aaabcxyzpqrrrabbxyyyypqqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(20 "\"aaabcxyzpqrrrabbxyyyypqqqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaabcxyzpqrrrabbxyyyypqqqAzz" nil "aaabcxyzpqrrrabbxyyyypqqqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(21 "\"aaabcxyzpqrrrabbxyyyypqqqqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaabcxyzpqrrrabbxyyyypqqqqAzz" nil "aaabcxyzpqrrrabbxyyyypqqqqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(22 "\"aaabcxyzpqrrrabbxyyyypqqqqqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaabcxyzpqrrrabbxyyyypqqqqqAzz" nil "aaabcxyzpqrrrabbxyyyypqqqqqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(23 "\"aaabcxyzpqrrrabbxyyyypqqqqqqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaabcxyzpqrrrabbxyyyypqqqqqqAzz" nil "aaabcxyzpqrrrabbxyyyypqqqqqqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(24 "\"aaaabcxyzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaaabcxyzpqrrrabbxyyyypqAzz" nil "aaaabcxyzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(25 "\"abxyzzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "abxyzzpqrrrabbxyyyypqAzz" nil "abxyzzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(26 "\"aabxyzzzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aabxyzzzpqrrrabbxyyyypqAzz" nil "aabxyzzzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(27 "\"aaabxyzzzzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaabxyzzzzpqrrrabbxyyyypqAzz" nil "aaabxyzzzzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(28 "\"aaaabxyzzzzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaaabxyzzzzpqrrrabbxyyyypqAzz" nil "aaaabxyzzzzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(29 "\"abcxyzzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "abcxyzzpqrrrabbxyyyypqAzz" nil "abcxyzzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(30 "\"aabcxyzzzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aabcxyzzzpqrrrabbxyyyypqAzz" nil "aabcxyzzzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(31 "\"aaabcxyzzzzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaabcxyzzzzpqrrrabbxyyyypqAzz" nil "aaabcxyzzzzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(32 "\"aaaabcxyzzzzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaaabcxyzzzzpqrrrabbxyyyypqAzz" nil "aaaabcxyzzzzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(33 "\"aaaabcxyzzzzpqrrrabbbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaaabcxyzzzzpqrrrabbbxyyyypqAzz" nil "aaaabcxyzzzzpqrrrabbbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(34 "\"aaaabcxyzzzzpqrrrabbbxyyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaaabcxyzzzzpqrrrabbbxyyyyypqAzz" nil "aaaabcxyzzzzpqrrrabbbxyyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(35 "\"aaabcxyzpqrrrabbxyyyypABzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaabcxyzpqrrrabbxyyyypABzz" nil "aaabcxyzpqrrrabbxyyyypABzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(36 "\"aaabcxyzpqrrrabbxyyyypABBzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaabcxyzpqrrrabbxyyyypABBzz" nil "aaabcxyzpqrrrabbxyyyypABBzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(37 "\">>>aaabxyzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil ">>>aaabxyzpqrrrabbxyyyypqAzz" nil "aaabxyzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(38 "\">aaaabxyzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil ">aaaabxyzpqrrrabbxyyyypqAzz" nil "aaaabxyzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(39 "\">>>>abcxyzpqrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil ">>>>abcxyzpqrrrabbxyyyypqAzz" nil "abcxyzpqrrrabbxyyyypqAzz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(40 "\"abxyzpqrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "abxyzpqrrabbxyyyypqAzz" nil nil nil)
+(41 "\"abxyzpqrrrrabbxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "abxyzpqrrrrabbxyyyypqAzz" nil nil nil)
+(42 "\"abxyzpqrrrabxyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "abxyzpqrrrabxyyyypqAzz" nil nil nil)
+(43 "\"aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz" nil nil nil)
+(44 "\"aaaabcxyzzzzpqrrrabbbxyyypqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaaabcxyzzzzpqrrrabbbxyyypqAzz" nil nil nil)
+(45 "\"aaabcxyzpqrrrabbxyyyypqqqqqqqAzz\" =~ /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/" "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz" nil nil nil nil "aaabcxyzpqrrrabbxyyyypqqqqqqqAzz" nil nil nil)
+(46 "\"abczz\" =~ /^(abc){1,2}zz/" "^(abc){1,2}zz" nil nil nil nil "abczz" nil "abczz" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(47 "\"abcabczz\" =~ /^(abc){1,2}zz/" "^(abc){1,2}zz" nil nil nil nil "abcabczz" nil "abcabczz" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(48 "\"zz\" =~ /^(abc){1,2}zz/" "^(abc){1,2}zz" nil nil nil nil "zz" nil nil nil)
+(49 "\"abcabcabczz\" =~ /^(abc){1,2}zz/" "^(abc){1,2}zz" nil nil nil nil "abcabcabczz" nil nil nil)
+(50 "\">>abczz\" =~ /^(abc){1,2}zz/" "^(abc){1,2}zz" nil nil nil nil ">>abczz" nil nil nil)
+(51 "\"bc\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "bc" nil "bc" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(52 "\"bbc\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "bbc" nil "bbc" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(53 "\"bbbc\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "bbbc" nil "bbbc" ("bb" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(54 "\"bac\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "bac" nil "bac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(55 "\"bbac\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "bbac" nil "bbac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(56 "\"aac\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "aac" nil "aac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(57 "\"abbbbbbbbbbbc\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "abbbbbbbbbbbc" nil "abbbbbbbbbbbc" ("bbbbbbbbbbb" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(58 "\"bbbbbbbbbbbac\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "bbbbbbbbbbbac" nil "bbbbbbbbbbbac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(59 "\"aaac\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "aaac" nil nil nil)
+(60 "\"abbbbbbbbbbbac\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "abbbbbbbbbbbac" nil nil nil)
+(61 "\"bc\" =~ /^(b+|a){1,2}c/" "^(b+|a){1,2}c" nil nil nil nil "bc" nil "bc" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(62 "\"bbc\" =~ /^(b+|a){1,2}c/" "^(b+|a){1,2}c" nil nil nil nil "bbc" nil "bbc" ("bb" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(63 "\"bbbc\" =~ /^(b+|a){1,2}c/" "^(b+|a){1,2}c" nil nil nil nil "bbbc" nil "bbbc" ("bbb" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(64 "\"bac\" =~ /^(b+|a){1,2}c/" "^(b+|a){1,2}c" nil nil nil nil "bac" nil "bac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(65 "\"bbac\" =~ /^(b+|a){1,2}c/" "^(b+|a){1,2}c" nil nil nil nil "bbac" nil "bbac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(66 "\"aac\" =~ /^(b+|a){1,2}c/" "^(b+|a){1,2}c" nil nil nil nil "aac" nil "aac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(67 "\"abbbbbbbbbbbc\" =~ /^(b+|a){1,2}c/" "^(b+|a){1,2}c" nil nil nil nil "abbbbbbbbbbbc" nil "abbbbbbbbbbbc" ("bbbbbbbbbbb" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(68 "\"bbbbbbbbbbbac\" =~ /^(b+|a){1,2}c/" "^(b+|a){1,2}c" nil nil nil nil "bbbbbbbbbbbac" nil "bbbbbbbbbbbac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(69 "\"aaac\" =~ /^(b+|a){1,2}c/" "^(b+|a){1,2}c" nil nil nil nil "aaac" nil nil nil)
+(70 "\"abbbbbbbbbbbac\" =~ /^(b+|a){1,2}c/" "^(b+|a){1,2}c" nil nil nil nil "abbbbbbbbbbbac" nil nil nil)
+(71 "\"bbc\" =~ /^(b+|a){1,2}?bc/" "^(b+|a){1,2}?bc" nil nil nil nil "bbc" nil "bbc" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(72 "\"babc\" =~ /^(b*|ba){1,2}?bc/" "^(b*|ba){1,2}?bc" nil nil nil nil "babc" nil "babc" ("ba" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(73 "\"bbabc\" =~ /^(b*|ba){1,2}?bc/" "^(b*|ba){1,2}?bc" nil nil nil nil "bbabc" nil "bbabc" ("ba" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(74 "\"bababc\" =~ /^(b*|ba){1,2}?bc/" "^(b*|ba){1,2}?bc" nil nil nil nil "bababc" nil "bababc" ("ba" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(75 "\"bababbc\" =~ /^(b*|ba){1,2}?bc/" "^(b*|ba){1,2}?bc" nil nil nil nil "bababbc" nil nil nil)
+(76 "\"babababc\" =~ /^(b*|ba){1,2}?bc/" "^(b*|ba){1,2}?bc" nil nil nil nil "babababc" nil nil nil)
+(77 "\"babc\" =~ /^(ba|b*){1,2}?bc/" "^(ba|b*){1,2}?bc" nil nil nil nil "babc" nil "babc" ("ba" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(78 "\"bbabc\" =~ /^(ba|b*){1,2}?bc/" "^(ba|b*){1,2}?bc" nil nil nil nil "bbabc" nil "bbabc" ("ba" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(79 "\"bababc\" =~ /^(ba|b*){1,2}?bc/" "^(ba|b*){1,2}?bc" nil nil nil nil "bababc" nil "bababc" ("ba" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(80 "\"bababbc\" =~ /^(ba|b*){1,2}?bc/" "^(ba|b*){1,2}?bc" nil nil nil nil "bababbc" nil nil nil)
+(81 "\"babababc\" =~ /^(ba|b*){1,2}?bc/" "^(ba|b*){1,2}?bc" nil nil nil nil "babababc" nil nil nil)
+(82 "\"\\x01\\x01\\e;z\" =~ /^\\ca\\cA\\c[\\c{\\c:/" "^\\ca\\cA\\c[\\c{\\c:" nil nil nil nil ("" 1 1 27 ";z") nil ("" 1 1 27 ";z") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(83 "\"athing\" =~ /^[ab\\]cde]/" "^[ab\\]cde]" nil nil nil nil "athing" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(84 "\"bthing\" =~ /^[ab\\]cde]/" "^[ab\\]cde]" nil nil nil nil "bthing" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(85 "\"]thing\" =~ /^[ab\\]cde]/" "^[ab\\]cde]" nil nil nil nil "]thing" nil "]" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(86 "\"cthing\" =~ /^[ab\\]cde]/" "^[ab\\]cde]" nil nil nil nil "cthing" nil "c" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(87 "\"dthing\" =~ /^[ab\\]cde]/" "^[ab\\]cde]" nil nil nil nil "dthing" nil "d" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(88 "\"ething\" =~ /^[ab\\]cde]/" "^[ab\\]cde]" nil nil nil nil "ething" nil "e" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(89 "\"fthing\" =~ /^[ab\\]cde]/" "^[ab\\]cde]" nil nil nil nil "fthing" nil nil nil)
+(90 "\"[thing\" =~ /^[ab\\]cde]/" "^[ab\\]cde]" nil nil nil nil "[thing" nil nil nil)
+(91 "\"\\\\thing\" =~ /^[ab\\]cde]/" "^[ab\\]cde]" nil nil nil nil "\\thing" nil nil nil)
+(92 "\"]thing\" =~ /^[]cde]/" "^[]cde]" nil nil nil nil "]thing" nil "]" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(93 "\"cthing\" =~ /^[]cde]/" "^[]cde]" nil nil nil nil "cthing" nil "c" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(94 "\"dthing\" =~ /^[]cde]/" "^[]cde]" nil nil nil nil "dthing" nil "d" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(95 "\"ething\" =~ /^[]cde]/" "^[]cde]" nil nil nil nil "ething" nil "e" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(96 "\"athing\" =~ /^[]cde]/" "^[]cde]" nil nil nil nil "athing" nil nil nil)
+(97 "\"fthing\" =~ /^[]cde]/" "^[]cde]" nil nil nil nil "fthing" nil nil nil)
+(98 "\"fthing\" =~ /^[^ab\\]cde]/" "^[^ab\\]cde]" nil nil nil nil "fthing" nil "f" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(99 "\"[thing\" =~ /^[^ab\\]cde]/" "^[^ab\\]cde]" nil nil nil nil "[thing" nil "[" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(100 "\"\\\\thing\" =~ /^[^ab\\]cde]/" "^[^ab\\]cde]" nil nil nil nil "\\thing" nil "\\" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(101 "\"athing\" =~ /^[^ab\\]cde]/" "^[^ab\\]cde]" nil nil nil nil "athing" nil nil nil)
+(102 "\"bthing\" =~ /^[^ab\\]cde]/" "^[^ab\\]cde]" nil nil nil nil "bthing" nil nil nil)
+(103 "\"]thing\" =~ /^[^ab\\]cde]/" "^[^ab\\]cde]" nil nil nil nil "]thing" nil nil nil)
+(104 "\"cthing\" =~ /^[^ab\\]cde]/" "^[^ab\\]cde]" nil nil nil nil "cthing" nil nil nil)
+(105 "\"dthing\" =~ /^[^ab\\]cde]/" "^[^ab\\]cde]" nil nil nil nil "dthing" nil nil nil)
+(106 "\"ething\" =~ /^[^ab\\]cde]/" "^[^ab\\]cde]" nil nil nil nil "ething" nil nil nil)
+(107 "\"athing\" =~ /^[^]cde]/" "^[^]cde]" nil nil nil nil "athing" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(108 "\"fthing\" =~ /^[^]cde]/" "^[^]cde]" nil nil nil nil "fthing" nil "f" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(109 "\"]thing\" =~ /^[^]cde]/" "^[^]cde]" nil nil nil nil "]thing" nil nil nil)
+(110 "\"cthing\" =~ /^[^]cde]/" "^[^]cde]" nil nil nil nil "cthing" nil nil nil)
+(111 "\"dthing\" =~ /^[^]cde]/" "^[^]cde]" nil nil nil nil "dthing" nil nil nil)
+(112 "\"ething\" =~ /^[^]cde]/" "^[^]cde]" nil nil nil nil "ething" nil nil nil)
+(113 ("\"" 129 "\" =~ /^\\" 129 "/") "^\\�" nil nil nil nil ("" 129) nil ("" 129) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(114 ("\"" 255 "\" =~ /^" 255 "/") "^�" nil nil nil nil ("" 255) nil ("" 255) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(115 "\"0\" =~ /^[0-9]+$/" "^[0-9]+$" nil nil nil nil "0" nil "0" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(116 "\"1\" =~ /^[0-9]+$/" "^[0-9]+$" nil nil nil nil "1" nil "1" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(117 "\"2\" =~ /^[0-9]+$/" "^[0-9]+$" nil nil nil nil "2" nil "2" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(118 "\"3\" =~ /^[0-9]+$/" "^[0-9]+$" nil nil nil nil "3" nil "3" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(119 "\"4\" =~ /^[0-9]+$/" "^[0-9]+$" nil nil nil nil "4" nil "4" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(120 "\"5\" =~ /^[0-9]+$/" "^[0-9]+$" nil nil nil nil "5" nil "5" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(121 "\"6\" =~ /^[0-9]+$/" "^[0-9]+$" nil nil nil nil "6" nil "6" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(122 "\"7\" =~ /^[0-9]+$/" "^[0-9]+$" nil nil nil nil "7" nil "7" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(123 "\"8\" =~ /^[0-9]+$/" "^[0-9]+$" nil nil nil nil "8" nil "8" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(124 "\"9\" =~ /^[0-9]+$/" "^[0-9]+$" nil nil nil nil "9" nil "9" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(125 "\"10\" =~ /^[0-9]+$/" "^[0-9]+$" nil nil nil nil "10" nil "10" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(126 "\"100\" =~ /^[0-9]+$/" "^[0-9]+$" nil nil nil nil "100" nil "100" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(127 "\"abc\" =~ /^[0-9]+$/" "^[0-9]+$" nil nil nil nil "abc" nil nil nil)
+(128 "\"enter\" =~ /^.*nter/" "^.*nter" nil nil nil nil "enter" nil "enter" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(129 "\"inter\" =~ /^.*nter/" "^.*nter" nil nil nil nil "inter" nil "inter" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(130 "\"uponter\" =~ /^.*nter/" "^.*nter" nil nil nil nil "uponter" nil "uponter" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(131 "\"xxx0\" =~ /^xxx[0-9]+$/" "^xxx[0-9]+$" nil nil nil nil "xxx0" nil "xxx0" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(132 "\"xxx1234\" =~ /^xxx[0-9]+$/" "^xxx[0-9]+$" nil nil nil nil "xxx1234" nil "xxx1234" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(133 "\"xxx\" =~ /^xxx[0-9]+$/" "^xxx[0-9]+$" nil nil nil nil "xxx" nil nil nil)
+(134 "\"x123\" =~ /^.+[0-9][0-9][0-9]$/" "^.+[0-9][0-9][0-9]$" nil nil nil nil "x123" nil "x123" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(135 "\"xx123\" =~ /^.+[0-9][0-9][0-9]$/" "^.+[0-9][0-9][0-9]$" nil nil nil nil "xx123" nil "xx123" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(136 "\"123456\" =~ /^.+[0-9][0-9][0-9]$/" "^.+[0-9][0-9][0-9]$" nil nil nil nil "123456" nil "123456" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(137 "\"123\" =~ /^.+[0-9][0-9][0-9]$/" "^.+[0-9][0-9][0-9]$" nil nil nil nil "123" nil nil nil)
+(138 "\"x1234\" =~ /^.+[0-9][0-9][0-9]$/" "^.+[0-9][0-9][0-9]$" nil nil nil nil "x1234" nil "x1234" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(139 "\"x123\" =~ /^.+?[0-9][0-9][0-9]$/" "^.+?[0-9][0-9][0-9]$" nil nil nil nil "x123" nil "x123" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(140 "\"xx123\" =~ /^.+?[0-9][0-9][0-9]$/" "^.+?[0-9][0-9][0-9]$" nil nil nil nil "xx123" nil "xx123" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(141 "\"123456\" =~ /^.+?[0-9][0-9][0-9]$/" "^.+?[0-9][0-9][0-9]$" nil nil nil nil "123456" nil "123456" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(142 "\"123\" =~ /^.+?[0-9][0-9][0-9]$/" "^.+?[0-9][0-9][0-9]$" nil nil nil nil "123" nil nil nil)
+(143 "\"x1234\" =~ /^.+?[0-9][0-9][0-9]$/" "^.+?[0-9][0-9][0-9]$" nil nil nil nil "x1234" nil "x1234" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(144 "\"abc!pqr=apquxz.ixr.zzz.ac.uk\" =~ /^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$/" "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$" nil nil nil nil "abc!pqr=apquxz.ixr.zzz.ac.uk" nil "abc!pqr=apquxz.ixr.zzz.ac.uk" ("abc" "pqr" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(145 "\"!pqr=apquxz.ixr.zzz.ac.uk\" =~ /^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$/" "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$" nil nil nil nil "!pqr=apquxz.ixr.zzz.ac.uk" nil nil nil)
+(146 "\"abc!=apquxz.ixr.zzz.ac.uk\" =~ /^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$/" "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$" nil nil nil nil "abc!=apquxz.ixr.zzz.ac.uk" nil nil nil)
+(147 "\"abc!pqr=apquxz:ixr.zzz.ac.uk\" =~ /^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$/" "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$" nil nil nil nil "abc!pqr=apquxz:ixr.zzz.ac.uk" nil nil nil)
+(148 "\"abc!pqr=apquxz.ixr.zzz.ac.ukk\" =~ /^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$/" "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$" nil nil nil nil "abc!pqr=apquxz.ixr.zzz.ac.ukk" nil nil nil)
+(149 "\"Well, we need a colon: somewhere\" =~ /:/" ":" nil nil nil nil "Well, we need a colon: somewhere" nil ":" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(150 "\"Fail if we don't\" =~ /:/" ":" nil nil nil nil "Fail if we don't" nil nil nil)
+(151 "\"0abc\" =~ /([\\da-f:]+)$/i" "([\\da-f:]+)$" t nil nil nil "0abc" nil "0abc" ("0abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(152 "\"abc\" =~ /([\\da-f:]+)$/i" "([\\da-f:]+)$" t nil nil nil "abc" nil "abc" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(153 "\"fed\" =~ /([\\da-f:]+)$/i" "([\\da-f:]+)$" t nil nil nil "fed" nil "fed" ("fed" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(154 "\"E\" =~ /([\\da-f:]+)$/i" "([\\da-f:]+)$" t nil nil nil "E" nil "E" ("E" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(155 "\"::\" =~ /([\\da-f:]+)$/i" "([\\da-f:]+)$" t nil nil nil "::" nil "::" ("::" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(156 "\"5f03:12C0::932e\" =~ /([\\da-f:]+)$/i" "([\\da-f:]+)$" t nil nil nil "5f03:12C0::932e" nil "5f03:12C0::932e" ("5f03:12C0::932e" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(157 "\"fed def\" =~ /([\\da-f:]+)$/i" "([\\da-f:]+)$" t nil nil nil "fed def" nil "def" ("def" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(158 "\"Any old stuff\" =~ /([\\da-f:]+)$/i" "([\\da-f:]+)$" t nil nil nil "Any old stuff" nil "ff" ("ff" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(159 "\"0zzz\" =~ /([\\da-f:]+)$/i" "([\\da-f:]+)$" t nil nil nil "0zzz" nil nil nil)
+(160 "\"gzzz\" =~ /([\\da-f:]+)$/i" "([\\da-f:]+)$" t nil nil nil "gzzz" nil nil nil)
+(161 "\"fed\\x20\" =~ /([\\da-f:]+)$/i" "([\\da-f:]+)$" t nil nil nil "fed " nil nil nil)
+(162 "\"Any old rubbish\" =~ /([\\da-f:]+)$/i" "([\\da-f:]+)$" t nil nil nil "Any old rubbish" nil nil nil)
+(163 "\".1.2.3\" =~ /^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$/" "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$" nil nil nil nil ".1.2.3" nil ".1.2.3" ("1" "2" "3" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(164 "\"A.12.123.0\" =~ /^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$/" "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$" nil nil nil nil "A.12.123.0" nil "A.12.123.0" ("12" "123" "0" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(165 "\".1.2.3333\" =~ /^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$/" "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$" nil nil nil nil ".1.2.3333" nil nil nil)
+(166 "\"1.2.3\" =~ /^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$/" "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$" nil nil nil nil "1.2.3" nil nil nil)
+(167 "\"1234.2.3\" =~ /^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$/" "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$" nil nil nil nil "1234.2.3" nil nil nil)
+(168 "\"1 IN SOA non-sp1 non-sp2(\" =~ /^(\\d+)\\s+IN\\s+SOA\\s+(\\S+)\\s+(\\S+)\\s*\\(\\s*$/" "^(\\d+)\\s+IN\\s+SOA\\s+(\\S+)\\s+(\\S+)\\s*\\(\\s*$" nil nil nil nil "1 IN SOA non-sp1 non-sp2(" nil "1 IN SOA non-sp1 non-sp2(" ("1" "non-sp1" "non-sp2" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(169 "\"1    IN    SOA    non-sp1    non-sp2   (\" =~ /^(\\d+)\\s+IN\\s+SOA\\s+(\\S+)\\s+(\\S+)\\s*\\(\\s*$/" "^(\\d+)\\s+IN\\s+SOA\\s+(\\S+)\\s+(\\S+)\\s*\\(\\s*$" nil nil nil nil "1    IN    SOA    non-sp1    non-sp2   (" nil "1    IN    SOA    non-sp1    non-sp2   (" ("1" "non-sp1" "non-sp2" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(170 "\"1IN SOA non-sp1 non-sp2(\" =~ /^(\\d+)\\s+IN\\s+SOA\\s+(\\S+)\\s+(\\S+)\\s*\\(\\s*$/" "^(\\d+)\\s+IN\\s+SOA\\s+(\\S+)\\s+(\\S+)\\s*\\(\\s*$" nil nil nil nil "1IN SOA non-sp1 non-sp2(" nil nil nil)
+(171 "\"a.\" =~ /^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$/" "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$" nil nil nil nil "a." nil "a." (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(172 "\"Z.\" =~ /^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$/" "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$" nil nil nil nil "Z." nil "Z." (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(173 "\"2.\" =~ /^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$/" "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$" nil nil nil nil "2." nil "2." (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(174 "\"ab-c.pq-r.\" =~ /^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$/" "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$" nil nil nil nil "ab-c.pq-r." nil "ab-c.pq-r." (".pq-r" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(175 "\"sxk.zzz.ac.uk.\" =~ /^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$/" "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$" nil nil nil nil "sxk.zzz.ac.uk." nil "sxk.zzz.ac.uk." (".uk" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(176 "\"x-.y-.\" =~ /^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$/" "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$" nil nil nil nil "x-.y-." nil "x-.y-." (".y-" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(177 "\"-abc.peq.\" =~ /^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$/" "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$" nil nil nil nil "-abc.peq." nil nil nil)
+(178 "\"*.a\" =~ /^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$/" "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$" nil nil nil nil "*.a" nil "*.a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(179 "\"*.b0-a\" =~ /^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$/" "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$" nil nil nil nil "*.b0-a" nil "*.b0-a" ("0-a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(180 "\"*.c3-b.c\" =~ /^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$/" "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$" nil nil nil nil "*.c3-b.c" nil "*.c3-b.c" ("3-b" ".c" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(181 "\"*.c-a.b-c\" =~ /^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$/" "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$" nil nil nil nil "*.c-a.b-c" nil "*.c-a.b-c" ("-a" ".b-c" "-c" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(182 "\"*.0\" =~ /^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$/" "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$" nil nil nil nil "*.0" nil nil nil)
+(183 "\"*.a-\" =~ /^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$/" "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$" nil nil nil nil "*.a-" nil nil nil)
+(184 "\"*.a-b.c-\" =~ /^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$/" "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$" nil nil nil nil "*.a-b.c-" nil nil nil)
+(185 "\"*.c-a.0-c\" =~ /^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$/" "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$" nil nil nil nil "*.c-a.0-c" nil nil nil)
+(186 "\"abde\" =~ /^(?=ab(de))(abd)(e)/" "^(?=ab(de))(abd)(e)" nil nil nil nil "abde" nil "abde" ("de" "abd" "e" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(187 "\"abdf\" =~ /^(?!(ab)de|x)(abd)(f)/" "^(?!(ab)de|x)(abd)(f)" nil nil nil nil "abdf" nil "abdf" (nil "abd" "f" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(188 "\"abcd\" =~ /^(?=(ab(cd)))(ab)/" "^(?=(ab(cd)))(ab)" nil nil nil nil "abcd" nil "ab" ("abcd" "cd" "ab" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(189 "\"a.b.c.d\" =~ /^[\\da-f](\\.[\\da-f])*$/i" "^[\\da-f](\\.[\\da-f])*$" t nil nil nil "a.b.c.d" nil "a.b.c.d" (".d" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(190 "\"A.B.C.D\" =~ /^[\\da-f](\\.[\\da-f])*$/i" "^[\\da-f](\\.[\\da-f])*$" t nil nil nil "A.B.C.D" nil "A.B.C.D" (".D" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(191 "\"a.b.c.1.2.3.C\" =~ /^[\\da-f](\\.[\\da-f])*$/i" "^[\\da-f](\\.[\\da-f])*$" t nil nil nil "a.b.c.1.2.3.C" nil "a.b.c.1.2.3.C" (".C" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(192 "\"\\\"1234\\\"\" =~ /^\\\".*\\\"\\s*(;.*)?$/" "^\\\".*\\\"\\s*(;.*)?$" nil nil nil nil "\"1234\"" nil "\"1234\"" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(193 "\"\\\"abcd\\\" ;\" =~ /^\\\".*\\\"\\s*(;.*)?$/" "^\\\".*\\\"\\s*(;.*)?$" nil nil nil nil "\"abcd\" ;" nil "\"abcd\" ;" (";" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(194 "\"\\\"\\\" ; rhubarb\" =~ /^\\\".*\\\"\\s*(;.*)?$/" "^\\\".*\\\"\\s*(;.*)?$" nil nil nil nil "\"\" ; rhubarb" nil "\"\" ; rhubarb" ("; rhubarb" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(195 "\"\\\"1234\\\" : things\" =~ /^\\\".*\\\"\\s*(;.*)?$/" "^\\\".*\\\"\\s*(;.*)?$" nil nil nil nil "\"1234\" : things" nil nil nil)
+(196 "\"\\\" =~ /^$/" "^$" nil nil nil nil "" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(197 "\"ab c\" =~ /   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)/x" "   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)" nil nil nil t "ab c" nil "ab c" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(198 "\"abc\" =~ /   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)/x" "   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)" nil nil nil t "abc" nil nil nil)
+(199 "\"ab cde\" =~ /   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)/x" "   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)" nil nil nil t "ab cde" nil nil nil)
+(200 "\"ab c\" =~ /(?x)   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)/" "(?x)   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)" nil nil nil nil "ab c" nil "ab c" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(201 "\"abc\" =~ /(?x)   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)/" "(?x)   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)" nil nil nil nil "abc" nil nil nil)
+(202 "\"ab cde\" =~ /(?x)   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)/" "(?x)   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)" nil nil nil nil "ab cde" nil nil nil)
+(203 "\"a bcd\" =~ /^   a\\ b[c ]d       $/x" "^   a\\ b[c ]d       $" nil nil nil t "a bcd" nil "a bcd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(204 "\"a b d\" =~ /^   a\\ b[c ]d       $/x" "^   a\\ b[c ]d       $" nil nil nil t "a b d" nil "a b d" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(205 "\"abcd\" =~ /^   a\\ b[c ]d       $/x" "^   a\\ b[c ]d       $" nil nil nil t "abcd" nil nil nil)
+(206 "\"ab d\" =~ /^   a\\ b[c ]d       $/x" "^   a\\ b[c ]d       $" nil nil nil t "ab d" nil nil nil)
+(207 "\"abcdefhijklm\" =~ /^(a(b(c)))(d(e(f)))(h(i(j)))(k(l(m)))$/" "^(a(b(c)))(d(e(f)))(h(i(j)))(k(l(m)))$" nil nil nil nil "abcdefhijklm" nil "abcdefhijklm" ("abc" "bc" "c" "def" "ef" "f" "hij" "ij" "j" "klm" "lm" "m" nil nil nil nil))
+(208 "\"abcdefhijklm\" =~ /^(?:a(b(c)))(?:d(e(f)))(?:h(i(j)))(?:k(l(m)))$/" "^(?:a(b(c)))(?:d(e(f)))(?:h(i(j)))(?:k(l(m)))$" nil nil nil nil "abcdefhijklm" nil "abcdefhijklm" ("bc" "c" "ef" "f" "ij" "j" "lm" "m" nil nil nil nil nil nil nil nil))
+(209 "\"a+ Z0+\\x08\\n\\x1d\\x12\" =~ /^[\\w][\\W][\\s][\\S][\\d][\\D][\\b][\\n][\\c]][\\022]/" "^[\\w][\\W][\\s][\\S][\\d][\\D][\\b][\\n][\\c]][\\022]" nil nil nil nil ("a+ Z0+" 8 10 29 18) nil ("a+ Z0+" 8 10 29 18) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(210 "\".^\\$(*+)|{?,?}\" =~ /^[.^$|()*+?{,}]+/" "^[.^$|()*+?{,}]+" nil nil nil nil ".^$(*+)|{?,?}" nil ".^$(*+)|{?,?}" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(211 "\"z\" =~ /^a*\\w/" "^a*\\w" nil nil nil nil "z" nil "z" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(212 "\"az\" =~ /^a*\\w/" "^a*\\w" nil nil nil nil "az" nil "az" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(213 "\"aaaz\" =~ /^a*\\w/" "^a*\\w" nil nil nil nil "aaaz" nil "aaaz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(214 "\"a\" =~ /^a*\\w/" "^a*\\w" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(215 "\"aa\" =~ /^a*\\w/" "^a*\\w" nil nil nil nil "aa" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(216 "\"aaaa\" =~ /^a*\\w/" "^a*\\w" nil nil nil nil "aaaa" nil "aaaa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(217 "\"a+\" =~ /^a*\\w/" "^a*\\w" nil nil nil nil "a+" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(218 "\"aa+\" =~ /^a*\\w/" "^a*\\w" nil nil nil nil "aa+" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(219 "\"z\" =~ /^a*?\\w/" "^a*?\\w" nil nil nil nil "z" nil "z" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(220 "\"az\" =~ /^a*?\\w/" "^a*?\\w" nil nil nil nil "az" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(221 "\"aaaz\" =~ /^a*?\\w/" "^a*?\\w" nil nil nil nil "aaaz" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(222 "\"a\" =~ /^a*?\\w/" "^a*?\\w" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(223 "\"aa\" =~ /^a*?\\w/" "^a*?\\w" nil nil nil nil "aa" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(224 "\"aaaa\" =~ /^a*?\\w/" "^a*?\\w" nil nil nil nil "aaaa" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(225 "\"a+\" =~ /^a*?\\w/" "^a*?\\w" nil nil nil nil "a+" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(226 "\"aa+\" =~ /^a*?\\w/" "^a*?\\w" nil nil nil nil "aa+" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(227 "\"az\" =~ /^a+\\w/" "^a+\\w" nil nil nil nil "az" nil "az" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(228 "\"aaaz\" =~ /^a+\\w/" "^a+\\w" nil nil nil nil "aaaz" nil "aaaz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(229 "\"aa\" =~ /^a+\\w/" "^a+\\w" nil nil nil nil "aa" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(230 "\"aaaa\" =~ /^a+\\w/" "^a+\\w" nil nil nil nil "aaaa" nil "aaaa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(231 "\"aa+\" =~ /^a+\\w/" "^a+\\w" nil nil nil nil "aa+" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(232 "\"az\" =~ /^a+?\\w/" "^a+?\\w" nil nil nil nil "az" nil "az" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(233 "\"aaaz\" =~ /^a+?\\w/" "^a+?\\w" nil nil nil nil "aaaz" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(234 "\"aa\" =~ /^a+?\\w/" "^a+?\\w" nil nil nil nil "aa" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(235 "\"aaaa\" =~ /^a+?\\w/" "^a+?\\w" nil nil nil nil "aaaa" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(236 "\"aa+\" =~ /^a+?\\w/" "^a+?\\w" nil nil nil nil "aa+" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(237 "\"1234567890\" =~ /^\\d{8}\\w{2,}/" "^\\d{8}\\w{2,}" nil nil nil nil "1234567890" nil "1234567890" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(238 "\"12345678ab\" =~ /^\\d{8}\\w{2,}/" "^\\d{8}\\w{2,}" nil nil nil nil "12345678ab" nil "12345678ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(239 "\"12345678__\" =~ /^\\d{8}\\w{2,}/" "^\\d{8}\\w{2,}" nil nil nil nil "12345678__" nil "12345678__" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(240 "\"1234567\" =~ /^\\d{8}\\w{2,}/" "^\\d{8}\\w{2,}" nil nil nil nil "1234567" nil nil nil)
+(241 "\"uoie\" =~ /^[aeiou\\d]{4,5}$/" "^[aeiou\\d]{4,5}$" nil nil nil nil "uoie" nil "uoie" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(242 "\"1234\" =~ /^[aeiou\\d]{4,5}$/" "^[aeiou\\d]{4,5}$" nil nil nil nil "1234" nil "1234" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(243 "\"12345\" =~ /^[aeiou\\d]{4,5}$/" "^[aeiou\\d]{4,5}$" nil nil nil nil "12345" nil "12345" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(244 "\"aaaaa\" =~ /^[aeiou\\d]{4,5}$/" "^[aeiou\\d]{4,5}$" nil nil nil nil "aaaaa" nil "aaaaa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(245 "\"123456\" =~ /^[aeiou\\d]{4,5}$/" "^[aeiou\\d]{4,5}$" nil nil nil nil "123456" nil nil nil)
+(246 "\"uoie\" =~ /^[aeiou\\d]{4,5}?/" "^[aeiou\\d]{4,5}?" nil nil nil nil "uoie" nil "uoie" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(247 "\"1234\" =~ /^[aeiou\\d]{4,5}?/" "^[aeiou\\d]{4,5}?" nil nil nil nil "1234" nil "1234" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(248 "\"12345\" =~ /^[aeiou\\d]{4,5}?/" "^[aeiou\\d]{4,5}?" nil nil nil nil "12345" nil "1234" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(249 "\"aaaaa\" =~ /^[aeiou\\d]{4,5}?/" "^[aeiou\\d]{4,5}?" nil nil nil nil "aaaaa" nil "aaaa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(250 "\"123456\" =~ /^[aeiou\\d]{4,5}?/" "^[aeiou\\d]{4,5}?" nil nil nil nil "123456" nil "1234" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(251 "\"abc=abcabc\" =~ /\\A(abc|def)=(\\1){2,3}\\Z/" "\\A(abc|def)=(\\1){2,3}\\Z" nil nil nil nil "abc=abcabc" nil "abc=abcabc" ("abc" "abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(252 "\"def=defdefdef\" =~ /\\A(abc|def)=(\\1){2,3}\\Z/" "\\A(abc|def)=(\\1){2,3}\\Z" nil nil nil nil "def=defdefdef" nil "def=defdefdef" ("def" "def" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(253 "\"abc=defdef\" =~ /\\A(abc|def)=(\\1){2,3}\\Z/" "\\A(abc|def)=(\\1){2,3}\\Z" nil nil nil nil "abc=defdef" nil nil nil)
+(254 "\"abcdefghijkcda2\" =~ /^(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11*(\\3\\4)\\1(?#)2$/" "^(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11*(\\3\\4)\\1(?#)2$" nil nil nil nil "abcdefghijkcda2" nil "abcdefghijkcda2" ("a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "cd" nil nil nil nil))
+(255 "\"abcdefghijkkkkcda2\" =~ /^(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11*(\\3\\4)\\1(?#)2$/" "^(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11*(\\3\\4)\\1(?#)2$" nil nil nil nil "abcdefghijkkkkcda2" nil "abcdefghijkkkkcda2" ("a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "cd" nil nil nil nil))
+(256 "\"cataract cataract23\" =~ /(cat(a(ract|tonic)|erpillar)) \\1()2(3)/" "(cat(a(ract|tonic)|erpillar)) \\1()2(3)" nil nil nil nil "cataract cataract23" nil "cataract cataract23" ("cataract" "aract" "ract" "" "3" nil nil nil nil nil nil nil nil nil nil nil))
+(257 "\"catatonic catatonic23\" =~ /(cat(a(ract|tonic)|erpillar)) \\1()2(3)/" "(cat(a(ract|tonic)|erpillar)) \\1()2(3)" nil nil nil nil "catatonic catatonic23" nil "catatonic catatonic23" ("catatonic" "atonic" "tonic" "" "3" nil nil nil nil nil nil nil nil nil nil nil))
+(258 "\"caterpillar caterpillar23\" =~ /(cat(a(ract|tonic)|erpillar)) \\1()2(3)/" "(cat(a(ract|tonic)|erpillar)) \\1()2(3)" nil nil nil nil "caterpillar caterpillar23" nil "caterpillar caterpillar23" ("caterpillar" "erpillar" nil "" "3" nil nil nil nil nil nil nil nil nil nil nil))
+(259 "\"From abcd  Mon Sep 01 12:33:02 1997\" =~ 
+/^From +([^ ]+) +[a-zA-Z][a-zA-Z][a-zA-Z] +[a-zA-Z][a-zA-Z][a-zA-Z] +[0-9]?[0-9] +[0-9][0-9]:[0-9][0-9]/" "^From +([^ ]+) +[a-zA-Z][a-zA-Z][a-zA-Z] +[a-zA-Z][a-zA-Z][a-zA-Z] +[0-9]?[0-9] +[0-9][0-9]:[0-9][0-9]" nil nil nil nil "From abcd  Mon Sep 01 12:33:02 1997" nil "From abcd  Mon Sep 01 12:33" ("abcd" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(260 "\"From abcd  Mon Sep 01 12:33:02 1997\" =~ /^From\\s+\\S+\\s+([a-zA-Z]{3}\\s+){2}\\d{1,2}\\s+\\d\\d:\\d\\d/" "^From\\s+\\S+\\s+([a-zA-Z]{3}\\s+){2}\\d{1,2}\\s+\\d\\d:\\d\\d" nil nil nil nil "From abcd  Mon Sep 01 12:33:02 1997" nil "From abcd  Mon Sep 01 12:33" ("Sep " nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(261 "\"From abcd  Mon Sep  1 12:33:02 1997\" =~ /^From\\s+\\S+\\s+([a-zA-Z]{3}\\s+){2}\\d{1,2}\\s+\\d\\d:\\d\\d/" "^From\\s+\\S+\\s+([a-zA-Z]{3}\\s+){2}\\d{1,2}\\s+\\d\\d:\\d\\d" nil nil nil nil "From abcd  Mon Sep  1 12:33:02 1997" nil "From abcd  Mon Sep  1 12:33" ("Sep  " nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(262 "\"From abcd  Sep 01 12:33:02 1997\" =~ /^From\\s+\\S+\\s+([a-zA-Z]{3}\\s+){2}\\d{1,2}\\s+\\d\\d:\\d\\d/" "^From\\s+\\S+\\s+([a-zA-Z]{3}\\s+){2}\\d{1,2}\\s+\\d\\d:\\d\\d" nil nil nil nil "From abcd  Sep 01 12:33:02 1997" nil nil nil)
+(263 "\"12\\n34\" =~ /^12.34/s" "^12.34" nil nil t nil "12
+34" nil "12
+34" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(264 "\"12\\r34\" =~ /^12.34/s" "^12.34" nil nil t nil ("12" 13 "34") nil ("12" 13 "34") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(265 "\"the quick brown\\t fox\" =~ /\\w+(?=\\t)/" "\\w+(?=\\t)" nil nil nil nil ("the quick brown" 9 " fox") nil "brown" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(266 "\"foobar is foolish see?\" =~ /foo(?!bar)(.*)/" "foo(?!bar)(.*)" nil nil nil nil "foobar is foolish see?" nil "foolish see?" ("lish see?" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(267 "\"foobar crowbar etc\" =~ /(?:(?!foo)...|^.{0,2})bar(.*)/" "(?:(?!foo)...|^.{0,2})bar(.*)" nil nil nil nil "foobar crowbar etc" nil "rowbar etc" (" etc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(268 "\"barrel\" =~ /(?:(?!foo)...|^.{0,2})bar(.*)/" "(?:(?!foo)...|^.{0,2})bar(.*)" nil nil nil nil "barrel" nil "barrel" ("rel" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(269 "\"2barrel\" =~ /(?:(?!foo)...|^.{0,2})bar(.*)/" "(?:(?!foo)...|^.{0,2})bar(.*)" nil nil nil nil "2barrel" nil "2barrel" ("rel" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(270 "\"A barrel\" =~ /(?:(?!foo)...|^.{0,2})bar(.*)/" "(?:(?!foo)...|^.{0,2})bar(.*)" nil nil nil nil "A barrel" nil "A barrel" ("rel" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(271 "\"abc456\" =~ /^(\\D*)(?=\\d)(?!123)/" "^(\\D*)(?=\\d)(?!123)" nil nil nil nil "abc456" nil "abc" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(272 "\"abc123\" =~ /^(\\D*)(?=\\d)(?!123)/" "^(\\D*)(?=\\d)(?!123)" nil nil nil nil "abc123" nil nil nil)
+(273 "\"1234\" =~ /^1234(?# test newlines
+  inside)/" "^1234(?# test newlines
+  inside)" nil nil nil nil "1234" nil "1234" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(274 "\"1234\" =~ /^1234 #comment in extended re
+  /x" "^1234 #comment in extended re
+  " nil nil nil t "1234" nil "1234" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(275 "\"abcd\" =~ /#rhubarb
+  abcd/x" "#rhubarb
+  abcd" nil nil nil t "abcd" nil "abcd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(276 "\"abcd\" =~ /^abcd#rhubarb/x" "^abcd#rhubarb" nil nil nil t "abcd" nil "abcd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(277 "\"aaab\" =~ /^(a)\\1{2,3}(.)/" "^(a)\\1{2,3}(.)" nil nil nil nil "aaab" nil "aaab" ("a" "b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(278 "\"aaaab\" =~ /^(a)\\1{2,3}(.)/" "^(a)\\1{2,3}(.)" nil nil nil nil "aaaab" nil "aaaab" ("a" "b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(279 "\"aaaaab\" =~ /^(a)\\1{2,3}(.)/" "^(a)\\1{2,3}(.)" nil nil nil nil "aaaaab" nil "aaaaa" ("a" "a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(280 "\"aaaaaab\" =~ /^(a)\\1{2,3}(.)/" "^(a)\\1{2,3}(.)" nil nil nil nil "aaaaaab" nil "aaaaa" ("a" "a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(281 "\"the abc\" =~ /(?!^)abc/" "(?!^)abc" nil nil nil nil "the abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(282 "\"abc\" =~ /(?!^)abc/" "(?!^)abc" nil nil nil nil "abc" nil nil nil)
+(283 "\"abc\" =~ /(?=^)abc/" "(?=^)abc" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(284 "\"the abc\" =~ /(?=^)abc/" "(?=^)abc" nil nil nil nil "the abc" nil nil nil)
+(285 "\"aabbbbb\" =~ /^[ab]{1,3}(ab*|b)/" "^[ab]{1,3}(ab*|b)" nil nil nil nil "aabbbbb" nil "aabb" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(286 "\"aabbbbb\" =~ /^[ab]{1,3}?(ab*|b)/" "^[ab]{1,3}?(ab*|b)" nil nil nil nil "aabbbbb" nil "aabbbbb" ("abbbbb" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(287 "\"aabbbbb\" =~ /^[ab]{1,3}?(ab*?|b)/" "^[ab]{1,3}?(ab*?|b)" nil nil nil nil "aabbbbb" nil "aa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(288 "\"aabbbbb\" =~ /^[ab]{1,3}(ab*?|b)/" "^[ab]{1,3}(ab*?|b)" nil nil nil nil "aabbbbb" nil "aabb" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(289 "\"Alan Other <user\\@dom.ain>\" =~ /  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+/x" "  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+" nil nil nil t "Alan Other <user@dom.ain>" nil "Alan Other <user@dom.ain>" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(290 "\"<user\\@dom.ain>\" =~ /  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+/x" "  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+" nil nil nil t "<user@dom.ain>" nil "user@dom.ain" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(291 "\"user\\@dom.ain\" =~ /  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+/x" "  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+" nil nil nil t "user@dom.ain" nil "user@dom.ain" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(292 "\"\\\"A. Other\\\" <user.1234\\@dom.ain> (a comment)\" =~ /  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+/x" "  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+" nil nil nil t "\"A. Other\" <user.1234@dom.ain> (a comment)" nil "\"A. Other\" <user.1234@dom.ain> (a comment)" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(293 "\"A. Other <user.1234\\@dom.ain> (a comment)\" =~ /  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+/x" "  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+" nil nil nil t "A. Other <user.1234@dom.ain> (a comment)" nil " Other <user.1234@dom.ain> (a comment)" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(294 "\"\\\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\\\"\\@x400-re.lay\" =~ /  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+/x" "  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+" nil nil nil t "\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay" nil "\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(295 "\"A missing angle <user\\@some.where\" =~ /  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+/x" "  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+" nil nil nil t "A missing angle <user@some.where" nil "user@some.where" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(296 "\"The quick brown fox\" =~ /  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+/x" "  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                          # optional leading comment
+(?:    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...
+\\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)       |  # comments, or...
+
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+# quoted strings
+)*
+<  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                     # leading <
+(?:  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  ,  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  )? #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)                    # initial word
+(?:  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\" (?:                      # opening quote...
+[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote
+|                     #    or
+\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)
+)* \"  # closing quote
+)  )* # further okay, if led by a period
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  @  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*    (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  \\.                        # if led by a period...
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*   (?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|   \\[                         # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*    #    stuff
+\\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*  > #                  trailing >
+# name and address
+)  (?: [\\040\\t] |  \\(
+(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*
+\\)  )*                       # optional trailing comment
+" nil nil nil t "The quick brown fox" nil nil nil)
+(297 "\"Alan Other <user\\@dom.ain>\" =~ /[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+/x" "[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+" nil nil nil t "Alan Other <user@dom.ain>" nil "Alan Other <user@dom.ain>" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(298 "\"<user\\@dom.ain>\" =~ /[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+/x" "[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+" nil nil nil t "<user@dom.ain>" nil "user@dom.ain" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(299 "\"user\\@dom.ain\" =~ /[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+/x" "[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+" nil nil nil t "user@dom.ain" nil "user@dom.ain" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(300 "\"\\\"A. Other\\\" <user.1234\\@dom.ain> (a comment)\" =~ /[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+/x" "[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+" nil nil nil t "\"A. Other\" <user.1234@dom.ain> (a comment)" nil "\"A. Other\" <user.1234@dom.ain>" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(301 "\"A. Other <user.1234\\@dom.ain> (a comment)\" =~ /[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+/x" "[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+" nil nil nil t "A. Other <user.1234@dom.ain> (a comment)" nil " Other <user.1234@dom.ain>" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(302 "\"\\\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\\\"\\@x400-re.lay\" =~ /[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+/x" "[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+" nil nil nil t "\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay" nil "\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(303 "\"A missing angle <user\\@some.where\" =~ /[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+/x" "[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+" nil nil nil t "A missing angle <user@some.where" nil "user@some.where" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(304 "\"The quick brown fox\" =~ /[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+/x" "[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+# leading word
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces
+(?:
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+|
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+) # \"special\" comment or quoted string
+[^()<>@,;:\".\\\\\\[\\]\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"
+)*
+<
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+\"                                     # \"
+[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal
+(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*
+\"                                     #        \"
+# Quoted string
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\\.
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]+    # some number of atom characters...
+(?![^(\\040)<>@,;:\".\\\\\\[\\]\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom
+|
+\\[                            # [
+(?: [^\\\\\\x80-\\xff\\n\\015\\[\\]] |  \\\\ [^\\x80-\\xff]  )*     #    stuff
+\\]                           #           ]
+)
+[\\040\\t]*                    # Nab whitespace.
+(?:
+\\(                              #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\\\ [^\\x80-\\xff]  |
+\\(                            #  (
+[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*
+(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*
+\\)                           #                       )
+)    #         special
+[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*
+)*                                  #            )*
+\\)                             #                )
+[\\040\\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+" nil nil nil t "The quick brown fox" nil nil nil)
+(305 "\"abc\\0def\\00pqr\\000xyz\\0000AB\" =~ /abc\\0def\\00pqr\\000xyz\\0000AB/" "abc\\0def\\00pqr\\000xyz\\0000AB" nil nil nil nil ("abc" 0 "def" 0 "pqr" 0 "xyz" 0 "0AB") nil ("abc" 0 "def" 0 "pqr" 0 "xyz" 0 "0AB") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(306 "\"abc456 abc\\0def\\00pqr\\000xyz\\0000ABCDE\" =~ /abc\\0def\\00pqr\\000xyz\\0000AB/" "abc\\0def\\00pqr\\000xyz\\0000AB" nil nil nil nil ("abc456 abc" 0 "def" 0 "pqr" 0 "xyz" 0 "0ABCDE") nil ("abc" 0 "def" 0 "pqr" 0 "xyz" 0 "0AB") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(307 "\"abc\\x0def\\x00pqr\\x000xyz\\x0000AB\" =~ /abc\\x0def\\x00pqr\\x000xyz\\x0000AB/" "abc\\x0def\\x00pqr\\x000xyz\\x0000AB" nil nil nil nil ("abc" 13 "ef" 0 "pqr" 0 "0xyz" 0 "00AB") nil ("abc" 13 "ef" 0 "pqr" 0 "0xyz" 0 "00AB") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(308 "\"abc456 abc\\x0def\\x00pqr\\x000xyz\\x0000ABCDE\" =~ /abc\\x0def\\x00pqr\\x000xyz\\x0000AB/" "abc\\x0def\\x00pqr\\x000xyz\\x0000AB" nil nil nil nil ("abc456 abc" 13 "ef" 0 "pqr" 0 "0xyz" 0 "00ABCDE") nil ("abc" 13 "ef" 0 "pqr" 0 "0xyz" 0 "00AB") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(309 "\"\\0A\" =~ /^[\\000-\\037]/" "^[\\000-\\037]" nil nil nil nil ("" 0 "A") nil ("" 0) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(310 "\"\\01B\" =~ /^[\\000-\\037]/" "^[\\000-\\037]" nil nil nil nil ("" 1 "B") nil ("" 1) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(311 "\"\\037C\" =~ /^[\\000-\\037]/" "^[\\000-\\037]" nil nil nil nil ("" 31 "C") nil ("" 31) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(312 "\"\\0\\0\\0\\0\" =~ /\\0*/" "\\0*" nil nil nil nil ("" 0 0 0 0) nil ("" 0 0 0 0) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(313 "\"The A\\x0\\x0Z\" =~ /A\\x0{2,3}Z/" "A\\x0{2,3}Z" nil nil nil nil ("The A" 0 0 "Z") nil ("A" 0 0 "Z") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(314 "\"An A\\0\\x0\\0Z\" =~ /A\\x0{2,3}Z/" "A\\x0{2,3}Z" nil nil nil nil ("An A" 0 0 0 "Z") nil ("A" 0 0 0 "Z") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(315 "\"A\\0Z\" =~ /A\\x0{2,3}Z/" "A\\x0{2,3}Z" nil nil nil nil ("A" 0 "Z") nil nil nil)
+(316 "\"A\\0\\x0\\0\\x0Z\" =~ /A\\x0{2,3}Z/" "A\\x0{2,3}Z" nil nil nil nil ("A" 0 0 0 0 "Z") nil nil nil)
+(317 "\"cowcowbell\" =~ /^(cow|)\\1(bell)/" "^(cow|)\\1(bell)" nil nil nil nil "cowcowbell" nil "cowcowbell" ("cow" "bell" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(318 "\"bell\" =~ /^(cow|)\\1(bell)/" "^(cow|)\\1(bell)" nil nil nil nil "bell" nil "bell" ("" "bell" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(319 "\"cowbell\" =~ /^(cow|)\\1(bell)/" "^(cow|)\\1(bell)" nil nil nil nil "cowbell" nil nil nil)
+(320 "\"\\040abc\" =~ /^\\s/" "^\\s" nil nil nil nil " abc" nil " " (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(321 "\"\\x0cabc\" =~ /^\\s/" "^\\s" nil nil nil nil ("" 12 "abc") nil ("" 12) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(322 "\"\\nabc\" =~ /^\\s/" "^\\s" nil nil nil nil "
+abc" nil "
+" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(323 "\"\\rabc\" =~ /^\\s/" "^\\s" nil nil nil nil ("" 13 "abc") nil ("" 13) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(324 "\"\\tabc\" =~ /^\\s/" "^\\s" nil nil nil nil ("" 9 "abc") nil ("" 9) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(325 "\"abc\" =~ /^\\s/" "^\\s" nil nil nil nil "abc" nil nil nil)
+(326 ("\"abc\" =~ /^a" 9 "b" 10 "  " 13 "  " 12 "  c/x") "^a	b
+  
    c" nil nil nil t "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(327 "\"ab\" =~ /^(a|)\\1*b/" "^(a|)\\1*b" nil nil nil nil "ab" nil "ab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(328 "\"aaaab\" =~ /^(a|)\\1*b/" "^(a|)\\1*b" nil nil nil nil "aaaab" nil "aaaab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(329 "\"b\" =~ /^(a|)\\1*b/" "^(a|)\\1*b" nil nil nil nil "b" nil "b" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(330 "\"acb\" =~ /^(a|)\\1*b/" "^(a|)\\1*b" nil nil nil nil "acb" nil nil nil)
+(331 "\"aab\" =~ /^(a|)\\1+b/" "^(a|)\\1+b" nil nil nil nil "aab" nil "aab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(332 "\"aaaab\" =~ /^(a|)\\1+b/" "^(a|)\\1+b" nil nil nil nil "aaaab" nil "aaaab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(333 "\"b\" =~ /^(a|)\\1+b/" "^(a|)\\1+b" nil nil nil nil "b" nil "b" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(334 "\"ab\" =~ /^(a|)\\1+b/" "^(a|)\\1+b" nil nil nil nil "ab" nil nil nil)
+(335 "\"ab\" =~ /^(a|)\\1?b/" "^(a|)\\1?b" nil nil nil nil "ab" nil "ab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(336 "\"aab\" =~ /^(a|)\\1?b/" "^(a|)\\1?b" nil nil nil nil "aab" nil "aab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(337 "\"b\" =~ /^(a|)\\1?b/" "^(a|)\\1?b" nil nil nil nil "b" nil "b" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(338 "\"acb\" =~ /^(a|)\\1?b/" "^(a|)\\1?b" nil nil nil nil "acb" nil nil nil)
+(339 "\"aaab\" =~ /^(a|)\\1{2}b/" "^(a|)\\1{2}b" nil nil nil nil "aaab" nil "aaab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(340 "\"b\" =~ /^(a|)\\1{2}b/" "^(a|)\\1{2}b" nil nil nil nil "b" nil "b" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(341 "\"ab\" =~ /^(a|)\\1{2}b/" "^(a|)\\1{2}b" nil nil nil nil "ab" nil nil nil)
+(342 "\"aab\" =~ /^(a|)\\1{2}b/" "^(a|)\\1{2}b" nil nil nil nil "aab" nil nil nil)
+(343 "\"aaaab\" =~ /^(a|)\\1{2}b/" "^(a|)\\1{2}b" nil nil nil nil "aaaab" nil nil nil)
+(344 "\"aaab\" =~ /^(a|)\\1{2,3}b/" "^(a|)\\1{2,3}b" nil nil nil nil "aaab" nil "aaab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(345 "\"aaaab\" =~ /^(a|)\\1{2,3}b/" "^(a|)\\1{2,3}b" nil nil nil nil "aaaab" nil "aaaab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(346 "\"b\" =~ /^(a|)\\1{2,3}b/" "^(a|)\\1{2,3}b" nil nil nil nil "b" nil "b" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(347 "\"ab\" =~ /^(a|)\\1{2,3}b/" "^(a|)\\1{2,3}b" nil nil nil nil "ab" nil nil nil)
+(348 "\"aab\" =~ /^(a|)\\1{2,3}b/" "^(a|)\\1{2,3}b" nil nil nil nil "aab" nil nil nil)
+(349 "\"aaaaab\" =~ /^(a|)\\1{2,3}b/" "^(a|)\\1{2,3}b" nil nil nil nil "aaaaab" nil nil nil)
+(350 "\"abbbbc\" =~ /ab{1,3}bc/" "ab{1,3}bc" nil nil nil nil "abbbbc" nil "abbbbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(351 "\"abbbc\" =~ /ab{1,3}bc/" "ab{1,3}bc" nil nil nil nil "abbbc" nil "abbbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(352 "\"abbc\" =~ /ab{1,3}bc/" "ab{1,3}bc" nil nil nil nil "abbc" nil "abbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(353 "\"abc\" =~ /ab{1,3}bc/" "ab{1,3}bc" nil nil nil nil "abc" nil nil nil)
+(354 "\"abbbbbc\" =~ /ab{1,3}bc/" "ab{1,3}bc" nil nil nil nil "abbbbbc" nil nil nil)
+(355 "\"track1.title:TBlah blah blah\" =~ /([^.]*)\\.([^:]*):[T ]+(.*)/" "([^.]*)\\.([^:]*):[T ]+(.*)" nil nil nil nil "track1.title:TBlah blah blah" nil "track1.title:TBlah blah blah" ("track1" "title" "Blah blah blah" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(356 "\"track1.title:TBlah blah blah\" =~ /([^.]*)\\.([^:]*):[T ]+(.*)/i" "([^.]*)\\.([^:]*):[T ]+(.*)" t nil nil nil "track1.title:TBlah blah blah" nil "track1.title:TBlah blah blah" ("track1" "title" "Blah blah blah" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(357 "\"track1.title:TBlah blah blah\" =~ /([^.]*)\\.([^:]*):[t ]+(.*)/i" "([^.]*)\\.([^:]*):[t ]+(.*)" t nil nil nil "track1.title:TBlah blah blah" nil "track1.title:TBlah blah blah" ("track1" "title" "Blah blah blah" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(358 "\"WXY_^abc\" =~ /^[W-c]+$/" "^[W-c]+$" nil nil nil nil "WXY_^abc" nil "WXY_^abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(359 "\"wxy\" =~ /^[W-c]+$/" "^[W-c]+$" nil nil nil nil "wxy" nil nil nil)
+(360 "\"WXY_^abc\" =~ /^[W-c]+$/i" "^[W-c]+$" t nil nil nil "WXY_^abc" nil "WXY_^abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(361 "\"wxy_^ABC\" =~ /^[W-c]+$/i" "^[W-c]+$" t nil nil nil "wxy_^ABC" nil "wxy_^ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(362 "\"WXY_^abc\" =~ /^[\\x3f-\\x5F]+$/i" "^[\\x3f-\\x5F]+$" t nil nil nil "WXY_^abc" nil "WXY_^abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(363 "\"wxy_^ABC\" =~ /^[\\x3f-\\x5F]+$/i" "^[\\x3f-\\x5F]+$" t nil nil nil "wxy_^ABC" nil "wxy_^ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(364 "\"abc\" =~ /^abc$/m" "^abc$" nil t nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(365 "\"qqq\\nabc\" =~ /^abc$/m" "^abc$" nil t nil nil "qqq
+abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(366 "\"abc\\nzzz\" =~ /^abc$/m" "^abc$" nil t nil nil "abc
+zzz" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(367 "\"qqq\\nabc\\nzzz\" =~ /^abc$/m" "^abc$" nil t nil nil "qqq
+abc
+zzz" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(368 "\"abc\" =~ /^abc$/" "^abc$" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(369 "\"qqq\\nabc\" =~ /^abc$/" "^abc$" nil nil nil nil "qqq
+abc" nil nil nil)
+(370 "\"abc\\nzzz\" =~ /^abc$/" "^abc$" nil nil nil nil "abc
+zzz" nil nil nil)
+(371 "\"qqq\\nabc\\nzzz\" =~ /^abc$/" "^abc$" nil nil nil nil "qqq
+abc
+zzz" nil nil nil)
+(372 "\"abc\" =~ /\\Aabc\\Z/m" "\\Aabc\\Z" nil t nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(373 "\"abc\\n\" =~ /\\Aabc\\Z/m" "\\Aabc\\Z" nil t nil nil "abc
+" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(374 "\"qqq\\nabc\" =~ /\\Aabc\\Z/m" "\\Aabc\\Z" nil t nil nil "qqq
+abc" nil nil nil)
+(375 "\"abc\\nzzz\" =~ /\\Aabc\\Z/m" "\\Aabc\\Z" nil t nil nil "abc
+zzz" nil nil nil)
+(376 "\"qqq\\nabc\\nzzz\" =~ /\\Aabc\\Z/m" "\\Aabc\\Z" nil t nil nil "qqq
+abc
+zzz" nil nil nil)
+(377 "\"abc\\ndef\" =~ /\\A(.)*\\Z/s" "\\A(.)*\\Z" nil nil t nil "abc
+def" nil "abc
+def" ("f" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(378 "\"abc\\ndef\" =~ /\\A(.)*\\Z/m" "\\A(.)*\\Z" nil t nil nil "abc
+def" nil nil nil)
+(379 "\"b::c\" =~ /(?:b)|(?::+)/" "(?:b)|(?::+)" nil nil nil nil "b::c" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(380 "\"c::b\" =~ /(?:b)|(?::+)/" "(?:b)|(?::+)" nil nil nil nil "c::b" nil "::" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(381 "\"az-\" =~ /[-az]+/" "[-az]+" nil nil nil nil "az-" nil "az-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(382 "\"b\" =~ /[-az]+/" "[-az]+" nil nil nil nil "b" nil nil nil)
+(383 "\"za-\" =~ /[az-]+/" "[az-]+" nil nil nil nil "za-" nil "za-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(384 "\"b\" =~ /[az-]+/" "[az-]+" nil nil nil nil "b" nil nil nil)
+(385 "\"a-z\" =~ /[a\\-z]+/" "[a\\-z]+" nil nil nil nil "a-z" nil "a-z" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(386 "\"b\" =~ /[a\\-z]+/" "[a\\-z]+" nil nil nil nil "b" nil nil nil)
+(387 "\"abcdxyz\" =~ /[a-z]+/" "[a-z]+" nil nil nil nil "abcdxyz" nil "abcdxyz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(388 "\"12-34\" =~ /[\\d-]+/" "[\\d-]+" nil nil nil nil "12-34" nil "12-34" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(389 "\"aaa\" =~ /[\\d-]+/" "[\\d-]+" nil nil nil nil "aaa" nil nil nil)
+(390 "\"12-34z\" =~ /[\\d-z]+/" "[\\d-z]+" nil nil nil nil "12-34z" nil "12-34z" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(391 "\"aaa\" =~ /[\\d-z]+/" "[\\d-z]+" nil nil nil nil "aaa" nil nil nil)
+(392 "\"\\\\\" =~ /\\x5c/" "\\x5c" nil nil nil nil "\\" nil "\\" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(393 "\"the Zoo\" =~ /\\x20Z/" "\\x20Z" nil nil nil nil "the Zoo" nil " Z" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(394 "\"Zulu\" =~ /\\x20Z/" "\\x20Z" nil nil nil nil "Zulu" nil nil nil)
+(395 "\"abcabc\" =~ /(abc)\\1/i" "(abc)\\1" t nil nil nil "abcabc" nil "abcabc" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(396 "\"ABCabc\" =~ /(abc)\\1/i" "(abc)\\1" t nil nil nil "ABCabc" nil "ABCabc" ("ABC" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(397 "\"abcABC\" =~ /(abc)\\1/i" "(abc)\\1" t nil nil nil "abcABC" nil "abcABC" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(398 "\"ab{3cd\" =~ /ab{3cd/" "ab{3cd" nil nil nil nil "ab{3cd" nil "ab{3cd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(399 "\"ab{3,cd\" =~ /ab{3,cd/" "ab{3,cd" nil nil nil nil "ab{3,cd" nil "ab{3,cd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(400 "\"ab{3,4a}cd\" =~ /ab{3,4a}cd/" "ab{3,4a}cd" nil nil nil nil "ab{3,4a}cd" nil "ab{3,4a}cd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(401 "\"{4,5a}bc\" =~ /{4,5a}bc/" "{4,5a}bc" nil nil nil nil "{4,5a}bc" nil "{4,5a}bc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(402 "\"a\\rb\" =~ /^a.b/" "^a.b" nil nil nil nil ("a" 13 "b") nil ("a" 13 "b") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(403 "\"a\\nb\" =~ /^a.b/" "^a.b" nil nil nil nil "a
+b" nil nil nil)
+(404 "\"abc\" =~ /abc$/" "abc$" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(405 "\"abc\\n\" =~ /abc$/" "abc$" nil nil nil nil "abc
+" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(406 "\"abc\\ndef\" =~ /abc$/" "abc$" nil nil nil nil "abc
+def" nil nil nil)
+(407 "\"abc\\x53\" =~ /(abc)\\123/" "(abc)\\123" nil nil nil nil "abcS" nil "abcS" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(408 "\"abc\\x93\" =~ /(abc)\\223/" "(abc)\\223" nil nil nil nil ("abc" 147) nil ("abc" 147) ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(409 "\"abc\\xd3\" =~ /(abc)\\323/" "(abc)\\323" nil nil nil nil ("abc" 211) nil ("abc" 211) ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(410 "\"abc\\x40\" =~ /(abc)\\500/" "(abc)\\500" nil nil nil nil "abc@" nil "abc@" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(411 "\"abc\\100\" =~ /(abc)\\500/" "(abc)\\500" nil nil nil nil "abc@" nil "abc@" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(412 "\"abc\\x400\" =~ /(abc)\\5000/" "(abc)\\5000" nil nil nil nil "abc@0" nil "abc@0" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(413 "\"abc\\x40\\x30\" =~ /(abc)\\5000/" "(abc)\\5000" nil nil nil nil "abc@0" nil "abc@0" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(414 "\"abc\\1000\" =~ /(abc)\\5000/" "(abc)\\5000" nil nil nil nil "abc@0" nil "abc@0" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(415 "\"abc\\100\\x30\" =~ /(abc)\\5000/" "(abc)\\5000" nil nil nil nil "abc@0" nil "abc@0" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(416 "\"abc\\100\\060\" =~ /(abc)\\5000/" "(abc)\\5000" nil nil nil nil "abc@0" nil "abc@0" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(417 "\"abc\\100\\60\" =~ /(abc)\\5000/" "(abc)\\5000" nil nil nil nil "abc@0" nil "abc@0" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(418 "\"abc\\081\" =~ /abc\\81/" "abc\\81" nil nil nil nil ("abc" 0 "81") nil ("abc" 0 "81") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(419 "\"abc\\0\\x38\\x31\" =~ /abc\\81/" "abc\\81" nil nil nil nil ("abc" 0 "81") nil ("abc" 0 "81") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(420 "\"abc\\091\" =~ /abc\\91/" "abc\\91" nil nil nil nil ("abc" 0 "91") nil ("abc" 0 "91") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(421 "\"abc\\0\\x39\\x31\" =~ /abc\\91/" "abc\\91" nil nil nil nil ("abc" 0 "91") nil ("abc" 0 "91") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(422 "\"abcdefghijkllS\" =~ /(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\\12\\123/" "(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\\12\\123" nil nil nil nil "abcdefghijkllS" nil "abcdefghijkllS" ("a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" nil nil nil nil))
+(423 "\"abcdefghijk\\12S\" =~ /(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\12\\123/" "(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\12\\123" nil nil nil nil "abcdefghijk
+S" nil "abcdefghijk
+S" ("a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" nil nil nil nil nil))
+(424 "\"abgdef\" =~ /ab\\gdef/" "ab\\gdef" nil nil nil nil "abgdef" nil "abgdef" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(425 "\"bc\" =~ /a{0}bc/" "a{0}bc" nil nil nil nil "bc" nil "bc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(426 "\"xyz\" =~ /(a|(bc)){0,0}?xyz/" "(a|(bc)){0,0}?xyz" nil nil nil nil "xyz" nil "xyz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(427 "\"abc\\010de\" =~ /abc[\\10]de/" "abc[\\10]de" nil nil nil nil ("abc" 8 "de") nil ("abc" 8 "de") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(428 "\"abc\\1de\" =~ /abc[\\1]de/" "abc[\\1]de" nil nil nil nil ("abc" 1 "de") nil ("abc" 1 "de") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(429 "\"abc\\1de\" =~ /(abc)[\\1]de/" "(abc)[\\1]de" nil nil nil nil ("abc" 1 "de") nil ("abc" 1 "de") ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(430 "\"a\\nb\" =~ /a.b(?s)/" "a.b(?s)" nil nil nil nil "a
+b" nil nil nil)
+(431 "\"baNOTccccd\" =~ /^([^a])([^\\b])([^c]*)([^d]{3,4})/" "^([^a])([^\\b])([^c]*)([^d]{3,4})" nil nil nil nil "baNOTccccd" nil "baNOTcccc" ("b" "a" "NOT" "cccc" nil nil nil nil nil nil nil nil nil nil nil nil))
+(432 "\"baNOTcccd\" =~ /^([^a])([^\\b])([^c]*)([^d]{3,4})/" "^([^a])([^\\b])([^c]*)([^d]{3,4})" nil nil nil nil "baNOTcccd" nil "baNOTccc" ("b" "a" "NOT" "ccc" nil nil nil nil nil nil nil nil nil nil nil nil))
+(433 "\"baNOTccd\" =~ /^([^a])([^\\b])([^c]*)([^d]{3,4})/" "^([^a])([^\\b])([^c]*)([^d]{3,4})" nil nil nil nil "baNOTccd" nil "baNOTcc" ("b" "a" "NO" "Tcc" nil nil nil nil nil nil nil nil nil nil nil nil))
+(434 "\"bacccd\" =~ /^([^a])([^\\b])([^c]*)([^d]{3,4})/" "^([^a])([^\\b])([^c]*)([^d]{3,4})" nil nil nil nil "bacccd" nil "baccc" ("b" "a" "" "ccc" nil nil nil nil nil nil nil nil nil nil nil nil))
+(435 "\"anything\" =~ /^([^a])([^\\b])([^c]*)([^d]{3,4})/" "^([^a])([^\\b])([^c]*)([^d]{3,4})" nil nil nil nil "anything" nil nil nil)
+(436 "\"b\\bc\" =~ /^([^a])([^\\b])([^c]*)([^d]{3,4})/" "^([^a])([^\\b])([^c]*)([^d]{3,4})" nil nil nil nil ("b" 8 "c") nil nil nil)
+(437 "\"baccd\" =~ /^([^a])([^\\b])([^c]*)([^d]{3,4})/" "^([^a])([^\\b])([^c]*)([^d]{3,4})" nil nil nil nil "baccd" nil nil nil)
+(438 "\"Abc\" =~ /[^a]/" "[^a]" nil nil nil nil "Abc" nil "A" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(439 "\"Abc\" =~ /[^a]/i" "[^a]" t nil nil nil "Abc" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(440 "\"AAAaAbc\" =~ /[^a]+/" "[^a]+" nil nil nil nil "AAAaAbc" nil "AAA" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(441 "\"AAAaAbc\" =~ /[^a]+/i" "[^a]+" t nil nil nil "AAAaAbc" nil "bc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(442 "\"bbb\\nccc\" =~ /[^a]+/" "[^a]+" nil nil nil nil "bbb
+ccc" nil "bbb
+ccc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(443 "\"abc\" =~ /[^k]$/" "[^k]$" nil nil nil nil "abc" nil "c" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(444 "\"abk\" =~ /[^k]$/" "[^k]$" nil nil nil nil "abk" nil nil nil)
+(445 "\"abc\" =~ /[^k]{2,3}$/" "[^k]{2,3}$" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(446 "\"kbc\" =~ /[^k]{2,3}$/" "[^k]{2,3}$" nil nil nil nil "kbc" nil "bc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(447 "\"kabc\" =~ /[^k]{2,3}$/" "[^k]{2,3}$" nil nil nil nil "kabc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(448 "\"abk\" =~ /[^k]{2,3}$/" "[^k]{2,3}$" nil nil nil nil "abk" nil nil nil)
+(449 "\"akb\" =~ /[^k]{2,3}$/" "[^k]{2,3}$" nil nil nil nil "akb" nil nil nil)
+(450 "\"akk\" =~ /[^k]{2,3}$/" "[^k]{2,3}$" nil nil nil nil "akk" nil nil nil)
+(451 "\"12345678\\@a.b.c.d\" =~ /^\\d{8,}\\@.+[^k]$/" "^\\d{8,}\\@.+[^k]$" nil nil nil nil "12345678@a.b.c.d" nil "12345678@a.b.c.d" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(452 "\"123456789\\@x.y.z\" =~ /^\\d{8,}\\@.+[^k]$/" "^\\d{8,}\\@.+[^k]$" nil nil nil nil "123456789@x.y.z" nil "123456789@x.y.z" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(453 "\"12345678\\@x.y.uk\" =~ /^\\d{8,}\\@.+[^k]$/" "^\\d{8,}\\@.+[^k]$" nil nil nil nil "12345678@x.y.uk" nil nil nil)
+(454 "\"1234567\\@a.b.c.d\" =~ /^\\d{8,}\\@.+[^k]$/" "^\\d{8,}\\@.+[^k]$" nil nil nil nil "1234567@a.b.c.d" nil nil nil)
+(455 "\"aaaaaaaaa\" =~ /(a)\\1{8,}/" "(a)\\1{8,}" nil nil nil nil "aaaaaaaaa" nil "aaaaaaaaa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(456 "\"aaaaaaaaaa\" =~ /(a)\\1{8,}/" "(a)\\1{8,}" nil nil nil nil "aaaaaaaaaa" nil "aaaaaaaaaa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(457 "\"aaaaaaa\" =~ /(a)\\1{8,}/" "(a)\\1{8,}" nil nil nil nil "aaaaaaa" nil nil nil)
+(458 "\"aaaabcd\" =~ /[^a]/" "[^a]" nil nil nil nil "aaaabcd" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(459 "\"aaAabcd\" =~ /[^a]/" "[^a]" nil nil nil nil "aaAabcd" nil "A" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(460 "\"aaaabcd\" =~ /[^a]/i" "[^a]" t nil nil nil "aaaabcd" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(461 "\"aaAabcd\" =~ /[^a]/i" "[^a]" t nil nil nil "aaAabcd" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(462 "\"aaaabcd\" =~ /[^az]/" "[^az]" nil nil nil nil "aaaabcd" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(463 "\"aaAabcd\" =~ /[^az]/" "[^az]" nil nil nil nil "aaAabcd" nil "A" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(464 "\"aaaabcd\" =~ /[^az]/i" "[^az]" t nil nil nil "aaaabcd" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(465 "\"aaAabcd\" =~ /[^az]/i" "[^az]" t nil nil nil "aaAabcd" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(466 "\"\\000\\001\\002\\003\\004\\005\\006\\007\\010\\011\\012\\013\\014\\015\\016\\017\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037\\040\\041\\042\\043\\044\\045\\046\\047\\050\\051\\052\\053\\054\\055\\056\\057\\060\\061\\062\\063\\064\\065\\066\\067\\070\\071\\072\\073\\074\\075\\076\\077\\100\\101\\102\\103\\104\\105\\106\\107\\110\\111\\112\\113\\114\\115\\116\\117\\120\\121\\122\\123\\124\\125\\126\\127\\130\\131\\132\\133\\134\\135\\136\\137\\140\\141\\142\\143\\144\\145\\146\\147\\150\\151\\152\\153\\154\\155\\156\\157\\160\\161\\162\\163\\164\\165\\166\\167\\170\\171\\172\\173\\174\\175\\176\\177\\200\\201\\202\\203\\204\\205\\206\\207\\210\\211\\212\\213\\214\\215\\216\\217\\220\\221\\222\\223\\224\\225\\226\\227\\230\\231\\232\\233\\234\\235\\236\\237\\240\\241\\242\\243\\244\\245\\246\\247\\250\\251\\252\\253\\254\\255\\256\\257\\260\\261\\262\\263\\264\\265\\266\\267\\270\\271\\272\\273\\274\\275\\276\\277\\300\\301\\302\\303\\304\\305\\306\\307\\310\\311\\312\\313\\314\\315\\316\\317\\320\\321\\322\\323\\324\\325\\326\\327\\330\\331\\332\\333\\334\\335\\336\\337\\340\\341\\342\\343\\344\\345\\346\\347\\350\\351\\352\\353\\354\\355\\356\\357\\360\\361\\362\\363\\364\\365\\366\\367\\370\\371\\372\\373\\374\\375\\376\\377\" =~ /\\000\\001\\002\\003\\004\\005\\006\\007\\010\\011\\012\\013\\014\\015\\016\\017\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037\\040\\041\\042\\043\\044\\045\\046\\047\\050\\051\\052\\053\\054\\055\\056\\057\\060\\061\\062\\063\\064\\065\\066\\067\\070\\071\\072\\073\\074\\075\\076\\077\\100\\101\\102\\103\\104\\105\\106\\107\\110\\111\\112\\113\\114\\115\\116\\117\\120\\121\\122\\123\\124\\125\\126\\127\\130\\131\\132\\133\\134\\135\\136\\137\\140\\141\\142\\143\\144\\145\\146\\147\\150\\151\\152\\153\\154\\155\\156\\157\\160\\161\\162\\163\\164\\165\\166\\167\\170\\171\\172\\173\\174\\175\\176\\177\\200\\201\\202\\203\\204\\205\\206\\207\\210\\211\\212\\213\\214\\215\\216\\217\\220\\221\\222\\223\\224\\225\\226\\227\\230\\231\\232\\233\\234\\235\\236\\237\\240\\241\\242\\243\\244\\245\\246\\247\\250\\251\\252\\253\\254\\255\\256\\257\\260\\261\\262\\263\\264\\265\\266\\267\\270\\271\\272\\273\\274\\275\\276\\277\\300\\301\\302\\303\\304\\305\\306\\307\\310\\311\\312\\313\\314\\315\\316\\317\\320\\321\\322\\323\\324\\325\\326\\327\\330\\331\\332\\333\\334\\335\\336\\337\\340\\341\\342\\343\\344\\345\\346\\347\\350\\351\\352\\353\\354\\355\\356\\357\\360\\361\\362\\363\\364\\365\\366\\367\\370\\371\\372\\373\\374\\375\\376\\377/" "\\000\\001\\002\\003\\004\\005\\006\\007\\010\\011\\012\\013\\014\\015\\016\\017\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037\\040\\041\\042\\043\\044\\045\\046\\047\\050\\051\\052\\053\\054\\055\\056\\057\\060\\061\\062\\063\\064\\065\\066\\067\\070\\071\\072\\073\\074\\075\\076\\077\\100\\101\\102\\103\\104\\105\\106\\107\\110\\111\\112\\113\\114\\115\\116\\117\\120\\121\\122\\123\\124\\125\\126\\127\\130\\131\\132\\133\\134\\135\\136\\137\\140\\141\\142\\143\\144\\145\\146\\147\\150\\151\\152\\153\\154\\155\\156\\157\\160\\161\\162\\163\\164\\165\\166\\167\\170\\171\\172\\173\\174\\175\\176\\177\\200\\201\\202\\203\\204\\205\\206\\207\\210\\211\\212\\213\\214\\215\\216\\217\\220\\221\\222\\223\\224\\225\\226\\227\\230\\231\\232\\233\\234\\235\\236\\237\\240\\241\\242\\243\\244\\245\\246\\247\\250\\251\\252\\253\\254\\255\\256\\257\\260\\261\\262\\263\\264\\265\\266\\267\\270\\271\\272\\273\\274\\275\\276\\277\\300\\301\\302\\303\\304\\305\\306\\307\\310\\311\\312\\313\\314\\315\\316\\317\\320\\321\\322\\323\\324\\325\\326\\327\\330\\331\\332\\333\\334\\335\\336\\337\\340\\341\\342\\343\\344\\345\\346\\347\\350\\351\\352\\353\\354\\355\\356\\357\\360\\361\\362\\363\\364\\365\\366\\367\\370\\371\\372\\373\\374\\375\\376\\377" nil nil nil nil ("" 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~" 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255) nil ("" 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~" 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(467 "\"xxxxxxxxxxxPSTAIREISLLxxxxxxxxx\" =~ /P[^*]TAIRE[^*]{1,6}?LL/" "P[^*]TAIRE[^*]{1,6}?LL" nil nil nil nil "xxxxxxxxxxxPSTAIREISLLxxxxxxxxx" nil "PSTAIREISLL" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(468 "\"xxxxxxxxxxxPSTAIREISLLxxxxxxxxx\" =~ /P[^*]TAIRE[^*]{1,}?LL/" "P[^*]TAIRE[^*]{1,}?LL" nil nil nil nil "xxxxxxxxxxxPSTAIREISLLxxxxxxxxx" nil "PSTAIREISLL" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(469 "\"1.230003938\" =~ /(\\.\\d\\d[1-9]?)\\d+/" "(\\.\\d\\d[1-9]?)\\d+" nil nil nil nil "1.230003938" nil ".230003938" (".23" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(470 "\"1.875000282\" =~ /(\\.\\d\\d[1-9]?)\\d+/" "(\\.\\d\\d[1-9]?)\\d+" nil nil nil nil "1.875000282" nil ".875000282" (".875" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(471 "\"1.235\" =~ /(\\.\\d\\d[1-9]?)\\d+/" "(\\.\\d\\d[1-9]?)\\d+" nil nil nil nil "1.235" nil ".235" (".23" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(472 "\"1.230003938\" =~ /(\\.\\d\\d((?=0)|\\d(?=\\d)))/" "(\\.\\d\\d((?=0)|\\d(?=\\d)))" nil nil nil nil "1.230003938" nil ".23" (".23" "" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(473 "\"1.875000282\" =~ /(\\.\\d\\d((?=0)|\\d(?=\\d)))/" "(\\.\\d\\d((?=0)|\\d(?=\\d)))" nil nil nil nil "1.875000282" nil ".875" (".875" "5" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(474 "\"1.235\" =~ /(\\.\\d\\d((?=0)|\\d(?=\\d)))/" "(\\.\\d\\d((?=0)|\\d(?=\\d)))" nil nil nil nil "1.235" nil nil nil)
+(475 "\"ab\" =~ /a(?)b/" "a(?)b" nil nil nil nil "ab" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(476 "\"Food is on the foo table\" =~ /\\b(foo)\\s+(\\w+)/i" "\\b(foo)\\s+(\\w+)" t nil nil nil "Food is on the foo table" nil "foo table" ("foo" "table" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(477 "\"The food is under the bar in the barn.\" =~ /foo(.*)bar/" "foo(.*)bar" nil nil nil nil "The food is under the bar in the barn." nil "food is under the bar in the bar" ("d is under the bar in the " nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(478 "\"The food is under the bar in the barn.\" =~ /foo(.*?)bar/" "foo(.*?)bar" nil nil nil nil "The food is under the bar in the barn." nil "food is under the bar" ("d is under the " nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(479 "\"I have 2 numbers: 53147\" =~ /(.*)(\\d*)/" "(.*)(\\d*)" nil nil nil nil "I have 2 numbers: 53147" nil "I have 2 numbers: 53147" ("I have 2 numbers: 53147" "" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(480 "\"I have 2 numbers: 53147\" =~ /(.*)(\\d+)/" "(.*)(\\d+)" nil nil nil nil "I have 2 numbers: 53147" nil "I have 2 numbers: 53147" ("I have 2 numbers: 5314" "7" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(481 "\"I have 2 numbers: 53147\" =~ /(.*?)(\\d*)/" "(.*?)(\\d*)" nil nil nil nil "I have 2 numbers: 53147" nil "" ("" "" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(482 "\"I have 2 numbers: 53147\" =~ /(.*?)(\\d+)/" "(.*?)(\\d+)" nil nil nil nil "I have 2 numbers: 53147" nil "I have 2" ("I have " "2" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(483 "\"I have 2 numbers: 53147\" =~ /(.*)(\\d+)$/" "(.*)(\\d+)$" nil nil nil nil "I have 2 numbers: 53147" nil "I have 2 numbers: 53147" ("I have 2 numbers: 5314" "7" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(484 "\"I have 2 numbers: 53147\" =~ /(.*?)(\\d+)$/" "(.*?)(\\d+)$" nil nil nil nil "I have 2 numbers: 53147" nil "I have 2 numbers: 53147" ("I have 2 numbers: " "53147" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(485 "\"I have 2 numbers: 53147\" =~ /(.*)\\b(\\d+)$/" "(.*)\\b(\\d+)$" nil nil nil nil "I have 2 numbers: 53147" nil "I have 2 numbers: 53147" ("I have 2 numbers: " "53147" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(486 "\"I have 2 numbers: 53147\" =~ /(.*\\D)(\\d+)$/" "(.*\\D)(\\d+)$" nil nil nil nil "I have 2 numbers: 53147" nil "I have 2 numbers: 53147" ("I have 2 numbers: " "53147" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(487 "\"ABC123\" =~ /^\\D*(?!123)/" "^\\D*(?!123)" nil nil nil nil "ABC123" nil "AB" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(488 "\"ABC445\" =~ /^(\\D*)(?=\\d)(?!123)/" "^(\\D*)(?=\\d)(?!123)" nil nil nil nil "ABC445" nil "ABC" ("ABC" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(489 "\"ABC123\" =~ /^(\\D*)(?=\\d)(?!123)/" "^(\\D*)(?=\\d)(?!123)" nil nil nil nil "ABC123" nil nil nil)
+(490 "\"W46]789\" =~ /^[W-]46]/" "^[W-]46]" nil nil nil nil "W46]789" nil "W46]" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(491 "\"-46]789\" =~ /^[W-]46]/" "^[W-]46]" nil nil nil nil "-46]789" nil "-46]" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(492 "\"Wall\" =~ /^[W-]46]/" "^[W-]46]" nil nil nil nil "Wall" nil nil nil)
+(493 "\"Zebra\" =~ /^[W-]46]/" "^[W-]46]" nil nil nil nil "Zebra" nil nil nil)
+(494 "\"42\" =~ /^[W-]46]/" "^[W-]46]" nil nil nil nil "42" nil nil nil)
+(495 "\"[abcd]\" =~ /^[W-]46]/" "^[W-]46]" nil nil nil nil "[abcd]" nil nil nil)
+(496 "\"]abcd[\" =~ /^[W-]46]/" "^[W-]46]" nil nil nil nil "]abcd[" nil nil nil)
+(497 "\"W46]789\" =~ /^[W-\\]46]/" "^[W-\\]46]" nil nil nil nil "W46]789" nil "W" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(498 "\"Wall\" =~ /^[W-\\]46]/" "^[W-\\]46]" nil nil nil nil "Wall" nil "W" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(499 "\"Zebra\" =~ /^[W-\\]46]/" "^[W-\\]46]" nil nil nil nil "Zebra" nil "Z" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(500 "\"Xylophone\" =~ /^[W-\\]46]/" "^[W-\\]46]" nil nil nil nil "Xylophone" nil "X" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(501 "\"42\" =~ /^[W-\\]46]/" "^[W-\\]46]" nil nil nil nil "42" nil "4" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(502 "\"[abcd]\" =~ /^[W-\\]46]/" "^[W-\\]46]" nil nil nil nil "[abcd]" nil "[" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(503 "\"]abcd[\" =~ /^[W-\\]46]/" "^[W-\\]46]" nil nil nil nil "]abcd[" nil "]" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(504 "\"\\\\backslash\" =~ /^[W-\\]46]/" "^[W-\\]46]" nil nil nil nil "\\backslash" nil "\\" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(505 "\"-46]789\" =~ /^[W-\\]46]/" "^[W-\\]46]" nil nil nil nil "-46]789" nil nil nil)
+(506 "\"well\" =~ /^[W-\\]46]/" "^[W-\\]46]" nil nil nil nil "well" nil nil nil)
+(507 "\"01/01/2000\" =~ /\\d\\d\\/\\d\\d\\/\\d\\d\\d\\d/" "\\d\\d\\/\\d\\d\\/\\d\\d\\d\\d" nil nil nil nil "01/01/2000" nil "01/01/2000" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(508 "\"word cat dog elephant mussel cow horse canary baboon snake shark otherword\" =~ /word (?:[a-zA-Z0-9]+ ){0,10}otherword/" "word (?:[a-zA-Z0-9]+ ){0,10}otherword" nil nil nil nil "word cat dog elephant mussel cow horse canary baboon snake shark otherword" nil "word cat dog elephant mussel cow horse canary baboon snake shark otherword" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(509 "\"word cat dog elephant mussel cow horse canary baboon snake shark\" =~ /word (?:[a-zA-Z0-9]+ ){0,10}otherword/" "word (?:[a-zA-Z0-9]+ ){0,10}otherword" nil nil nil nil "word cat dog elephant mussel cow horse canary baboon snake shark" nil nil nil)
+(510 "\"word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope\" =~ /word (?:[a-zA-Z0-9]+ ){0,300}otherword/" "word (?:[a-zA-Z0-9]+ ){0,300}otherword" nil nil nil nil "word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope" nil nil nil)
+(511 "\"bcd\" =~ /^(a){0,0}/" "^(a){0,0}" nil nil nil nil "bcd" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(512 "\"abc\" =~ /^(a){0,0}/" "^(a){0,0}" nil nil nil nil "abc" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(513 "\"aab\" =~ /^(a){0,0}/" "^(a){0,0}" nil nil nil nil "aab" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(514 "\"bcd\" =~ /^(a){0,1}/" "^(a){0,1}" nil nil nil nil "bcd" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(515 "\"abc\" =~ /^(a){0,1}/" "^(a){0,1}" nil nil nil nil "abc" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(516 "\"aab\" =~ /^(a){0,1}/" "^(a){0,1}" nil nil nil nil "aab" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(517 "\"bcd\" =~ /^(a){0,2}/" "^(a){0,2}" nil nil nil nil "bcd" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(518 "\"abc\" =~ /^(a){0,2}/" "^(a){0,2}" nil nil nil nil "abc" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(519 "\"aab\" =~ /^(a){0,2}/" "^(a){0,2}" nil nil nil nil "aab" nil "aa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(520 "\"bcd\" =~ /^(a){0,3}/" "^(a){0,3}" nil nil nil nil "bcd" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(521 "\"abc\" =~ /^(a){0,3}/" "^(a){0,3}" nil nil nil nil "abc" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(522 "\"aab\" =~ /^(a){0,3}/" "^(a){0,3}" nil nil nil nil "aab" nil "aa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(523 "\"aaa\" =~ /^(a){0,3}/" "^(a){0,3}" nil nil nil nil "aaa" nil "aaa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(524 "\"bcd\" =~ /^(a){0,}/" "^(a){0,}" nil nil nil nil "bcd" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(525 "\"abc\" =~ /^(a){0,}/" "^(a){0,}" nil nil nil nil "abc" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(526 "\"aab\" =~ /^(a){0,}/" "^(a){0,}" nil nil nil nil "aab" nil "aa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(527 "\"aaa\" =~ /^(a){0,}/" "^(a){0,}" nil nil nil nil "aaa" nil "aaa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(528 "\"aaaaaaaa\" =~ /^(a){0,}/" "^(a){0,}" nil nil nil nil "aaaaaaaa" nil "aaaaaaaa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(529 "\"bcd\" =~ /^(a){1,1}/" "^(a){1,1}" nil nil nil nil "bcd" nil nil nil)
+(530 "\"abc\" =~ /^(a){1,1}/" "^(a){1,1}" nil nil nil nil "abc" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(531 "\"aab\" =~ /^(a){1,1}/" "^(a){1,1}" nil nil nil nil "aab" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(532 "\"bcd\" =~ /^(a){1,2}/" "^(a){1,2}" nil nil nil nil "bcd" nil nil nil)
+(533 "\"abc\" =~ /^(a){1,2}/" "^(a){1,2}" nil nil nil nil "abc" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(534 "\"aab\" =~ /^(a){1,2}/" "^(a){1,2}" nil nil nil nil "aab" nil "aa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(535 "\"bcd\" =~ /^(a){1,3}/" "^(a){1,3}" nil nil nil nil "bcd" nil nil nil)
+(536 "\"abc\" =~ /^(a){1,3}/" "^(a){1,3}" nil nil nil nil "abc" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(537 "\"aab\" =~ /^(a){1,3}/" "^(a){1,3}" nil nil nil nil "aab" nil "aa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(538 "\"aaa\" =~ /^(a){1,3}/" "^(a){1,3}" nil nil nil nil "aaa" nil "aaa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(539 "\"bcd\" =~ /^(a){1,}/" "^(a){1,}" nil nil nil nil "bcd" nil nil nil)
+(540 "\"abc\" =~ /^(a){1,}/" "^(a){1,}" nil nil nil nil "abc" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(541 "\"aab\" =~ /^(a){1,}/" "^(a){1,}" nil nil nil nil "aab" nil "aa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(542 "\"aaa\" =~ /^(a){1,}/" "^(a){1,}" nil nil nil nil "aaa" nil "aaa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(543 "\"aaaaaaaa\" =~ /^(a){1,}/" "^(a){1,}" nil nil nil nil "aaaaaaaa" nil "aaaaaaaa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(544 "\"borfle\\nbib.gif\\nno\" =~ /.*\\.gif/" ".*\\.gif" nil nil nil nil "borfle
+bib.gif
+no" nil "bib.gif" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(545 "\"borfle\\nbib.gif\\nno\" =~ /.{0,}\\.gif/" ".{0,}\\.gif" nil nil nil nil "borfle
+bib.gif
+no" nil "bib.gif" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(546 "\"borfle\\nbib.gif\\nno\" =~ /.*\\.gif/m" ".*\\.gif" nil t nil nil "borfle
+bib.gif
+no" nil "bib.gif" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(547 "\"borfle\\nbib.gif\\nno\" =~ /.*\\.gif/s" ".*\\.gif" nil nil t nil "borfle
+bib.gif
+no" nil "borfle
+bib.gif" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(548 "\"borfle\\nbib.gif\\nno\" =~ /.*\\.gif/ms" ".*\\.gif" nil t t nil "borfle
+bib.gif
+no" nil "borfle
+bib.gif" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(549 "\"borfle\\nbib.gif\\nno\" =~ /.*$/" ".*$" nil nil nil nil "borfle
+bib.gif
+no" nil "no" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(550 "\"borfle\\nbib.gif\\nno\" =~ /.*$/m" ".*$" nil t nil nil "borfle
+bib.gif
+no" nil "borfle" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(551 "\"borfle\\nbib.gif\\nno\" =~ /.*$/s" ".*$" nil nil t nil "borfle
+bib.gif
+no" nil "borfle
+bib.gif
+no" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(552 "\"borfle\\nbib.gif\\nno\" =~ /.*$/ms" ".*$" nil t t nil "borfle
+bib.gif
+no" nil "borfle
+bib.gif
+no" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(553 "\"borfle\\nbib.gif\\nno\\n\" =~ /.*$/" ".*$" nil nil nil nil "borfle
+bib.gif
+no
+" nil "no" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(554 "\"borfle\\nbib.gif\\nno\\n\" =~ /.*$/m" ".*$" nil t nil nil "borfle
+bib.gif
+no
+" nil "borfle" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(555 "\"borfle\\nbib.gif\\nno\\n\" =~ /.*$/s" ".*$" nil nil t nil "borfle
+bib.gif
+no
+" nil "borfle
+bib.gif
+no
+" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(556 "\"borfle\\nbib.gif\\nno\\n\" =~ /.*$/ms" ".*$" nil t t nil "borfle
+bib.gif
+no
+" nil "borfle
+bib.gif
+no
+" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(557 "\"abcde\\n1234Xyz\" =~ /(.*X|^B)/" "(.*X|^B)" nil nil nil nil "abcde
+1234Xyz" nil "1234X" ("1234X" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(558 "\"BarFoo\" =~ /(.*X|^B)/" "(.*X|^B)" nil nil nil nil "BarFoo" nil "B" ("B" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(559 "\"abcde\\nBar\" =~ /(.*X|^B)/" "(.*X|^B)" nil nil nil nil "abcde
+Bar" nil nil nil)
+(560 "\"abcde\\n1234Xyz\" =~ /(.*X|^B)/m" "(.*X|^B)" nil t nil nil "abcde
+1234Xyz" nil "1234X" ("1234X" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(561 "\"BarFoo\" =~ /(.*X|^B)/m" "(.*X|^B)" nil t nil nil "BarFoo" nil "B" ("B" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(562 "\"abcde\\nBar\" =~ /(.*X|^B)/m" "(.*X|^B)" nil t nil nil "abcde
+Bar" nil "B" ("B" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(563 "\"abcde\\n1234Xyz\" =~ /(.*X|^B)/s" "(.*X|^B)" nil nil t nil "abcde
+1234Xyz" nil "abcde
+1234X" ("abcde
+1234X" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(564 "\"BarFoo\" =~ /(.*X|^B)/s" "(.*X|^B)" nil nil t nil "BarFoo" nil "B" ("B" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(565 "\"abcde\\nBar\" =~ /(.*X|^B)/s" "(.*X|^B)" nil nil t nil "abcde
+Bar" nil nil nil)
+(566 "\"abcde\\n1234Xyz\" =~ /(.*X|^B)/ms" "(.*X|^B)" nil t t nil "abcde
+1234Xyz" nil "abcde
+1234X" ("abcde
+1234X" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(567 "\"BarFoo\" =~ /(.*X|^B)/ms" "(.*X|^B)" nil t t nil "BarFoo" nil "B" ("B" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(568 "\"abcde\\nBar\" =~ /(.*X|^B)/ms" "(.*X|^B)" nil t t nil "abcde
+Bar" nil "B" ("B" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(569 "\"abcde\\n1234Xyz\" =~ /(?s)(.*X|^B)/" "(?s)(.*X|^B)" nil nil nil nil "abcde
+1234Xyz" nil "abcde
+1234X" ("abcde
+1234X" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(570 "\"BarFoo\" =~ /(?s)(.*X|^B)/" "(?s)(.*X|^B)" nil nil nil nil "BarFoo" nil "B" ("B" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(571 "\"abcde\\nBar\" =~ /(?s)(.*X|^B)/" "(?s)(.*X|^B)" nil nil nil nil "abcde
+Bar" nil nil nil)
+(572 "\"abcde\\n1234Xyz\" =~ /(?s:.*X|^B)/" "(?s:.*X|^B)" nil nil nil nil "abcde
+1234Xyz" nil "abcde
+1234X" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(573 "\"BarFoo\" =~ /(?s:.*X|^B)/" "(?s:.*X|^B)" nil nil nil nil "BarFoo" nil "B" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(574 "\"abcde\\nBar\" =~ /(?s:.*X|^B)/" "(?s:.*X|^B)" nil nil nil nil "abcde
+Bar" nil nil nil)
+(575 "\"abc\\nB\" =~ /^.*B/" "^.*B" nil nil nil nil "abc
+B" nil nil nil)
+(576 "\"abc\\nB\" =~ /(?s)^.*B/" "(?s)^.*B" nil nil nil nil "abc
+B" nil "abc
+B" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(577 "\"abc\\nB\" =~ /(?m)^.*B/" "(?m)^.*B" nil nil nil nil "abc
+B" nil "B" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(578 "\"abc\\nB\" =~ /(?ms)^.*B/" "(?ms)^.*B" nil nil nil nil "abc
+B" nil "abc
+B" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(579 "\"abc\\nB\" =~ /(?ms)^B/" "(?ms)^B" nil nil nil nil "abc
+B" nil "B" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(580 "\"B\\n\" =~ /(?s)B$/" "(?s)B$" nil nil nil nil "B
+" nil "B" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(581 "\"123456654321\" =~ /^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]/" "^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]" nil nil nil nil "123456654321" nil "123456654321" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(582 "\"123456654321\" =~ /^\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d/" "^\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d" nil nil nil nil "123456654321" nil "123456654321" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(583 "\"123456654321\" =~ /^[\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d]/" "^[\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d]" nil nil nil nil "123456654321" nil "123456654321" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(584 "\"abcabcabcabc\" =~ /^[abc]{12}/" "^[abc]{12}" nil nil nil nil "abcabcabcabc" nil "abcabcabcabc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(585 "\"abcabcabcabc\" =~ /^[a-c]{12}/" "^[a-c]{12}" nil nil nil nil "abcabcabcabc" nil "abcabcabcabc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(586 "\"abcabcabcabc\" =~ /^(a|b|c){12}/" "^(a|b|c){12}" nil nil nil nil "abcabcabcabc" nil "abcabcabcabc" ("c" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(587 "\"n\" =~ /^[abcdefghijklmnopqrstuvwxy0123456789]/" "^[abcdefghijklmnopqrstuvwxy0123456789]" nil nil nil nil "n" nil "n" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(588 "\"z\" =~ /^[abcdefghijklmnopqrstuvwxy0123456789]/" "^[abcdefghijklmnopqrstuvwxy0123456789]" nil nil nil nil "z" nil nil nil)
+(589 "\"abcd\" =~ /abcde{0,0}/" "abcde{0,0}" nil nil nil nil "abcd" nil "abcd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(590 "\"abce\" =~ /abcde{0,0}/" "abcde{0,0}" nil nil nil nil "abce" nil nil nil)
+(591 "\"abe\" =~ /ab[cd]{0,0}e/" "ab[cd]{0,0}e" nil nil nil nil "abe" nil "abe" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(592 "\"abcde\" =~ /ab[cd]{0,0}e/" "ab[cd]{0,0}e" nil nil nil nil "abcde" nil nil nil)
+(593 "\"abd\" =~ /ab(c){0,0}d/" "ab(c){0,0}d" nil nil nil nil "abd" nil "abd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(594 "\"abcd\" =~ /ab(c){0,0}d/" "ab(c){0,0}d" nil nil nil nil "abcd" nil nil nil)
+(595 "\"a\" =~ /a(b*)/" "a(b*)" nil nil nil nil "a" nil "a" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(596 "\"ab\" =~ /a(b*)/" "a(b*)" nil nil nil nil "ab" nil "ab" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(597 "\"abbbb\" =~ /a(b*)/" "a(b*)" nil nil nil nil "abbbb" nil "abbbb" ("bbbb" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(598 "\"bbbbb\" =~ /a(b*)/" "a(b*)" nil nil nil nil "bbbbb" nil nil nil)
+(599 "\"abe\" =~ /ab\\d{0}e/" "ab\\d{0}e" nil nil nil nil "abe" nil "abe" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(600 "\"ab1e\" =~ /ab\\d{0}e/" "ab\\d{0}e" nil nil nil nil "ab1e" nil nil nil)
+(601 "\"the \\\"quick\\\" brown fox\" =~ /\"([^\\\\\"]+|\\\\.)*\"/" "\"([^\\\\\"]+|\\\\.)*\"" nil nil nil nil "the \"quick\" brown fox" nil "\"quick\"" ("quick" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(602 "\"\\\"the \\\\\\\"quick\\\\\\\" brown fox\\\"\" =~ /\"([^\\\\\"]+|\\\\.)*\"/" "\"([^\\\\\"]+|\\\\.)*\"" nil nil nil nil "\"the \\\"quick\\\" brown fox\"" nil "\"the \\\"quick\\\" brown fox\"" (" brown fox" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(603 "\"abc\" =~ /.*?/" ".*?" nil nil nil nil "abc" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(604 "\"abc\" =~ /\\b/" "\\b" nil nil nil nil "abc" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(605 "\"abc\" =~ /\\b/" "\\b" nil nil nil nil "abc" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(606 "\"abc\" =~ /(?#)/" "" nil nil nil nil "abc" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(607 "\"<TR BGCOLOR='#DBE9E9'><TD align=left valign=top>43.<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)</a></TD><TD align=left valign=top>Lega lstaff.com</TD><TD align=left valign=top>CA - Statewide</TD></TR>\" =~ /<tr([\\w\\W\\s\\d][^<>]{0,})><TD([\\w\\W\\s\\d][^<>]{0,})>([\\d]{0,}\\.)(.*)((<BR>([\\w\\W\\s\\d][^<>]{0,})|[\\s]{0,}))<\\/a><\\/TD><TD([\\w\\W\\s\\d][^<>]{0,})>([\\w\\W\\s\\d][^<>]{0,})<\\/TD><TD([\\w\\W\\s\\d][^<>]{0,})>([\\w\\W\\s\\d][^<>]{0,})<\\/TD><\\/TR>/is" "<tr([\\w\\W\\s\\d][^<>]{0,})><TD([\\w\\W\\s\\d][^<>]{0,})>([\\d]{0,}\\.)(.*)((<BR>([\\w\\W\\s\\d][^<>]{0,})|[\\s]{0,}))<\\/a><\\/TD><TD([\\w\\W\\s\\d][^<>]{0,})>([\\w\\W\\s\\d][^<>]{0,})<\\/TD><TD([\\w\\W\\s\\d][^<>]{0,})>([\\w\\W\\s\\d][^<>]{0,})<\\/TD><\\/TR>" t nil t nil "<TR BGCOLOR='#DBE9E9'><TD align=left valign=top>43.<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)</a></TD><TD align=left valign=top>Lega lstaff.com</TD><TD align=left valign=top>CA - Statewide</TD></TR>" nil "<TR BGCOLOR='#DBE9E9'><TD align=left valign=top>43.<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)</a></TD><TD align=left valign=top>Lega lstaff.com</TD><TD align=left valign=top>CA - Statewide</TD></TR>" (" BGCOLOR='#DBE9E9'" " align=left valign=top" "43." "<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)" "" "" nil " align=left valign=top" "Lega lstaff.com" " align=left valign=top" "CA - Statewide" nil nil nil nil nil))
+(608 "\"acb\" =~ /a[^a]b/" "a[^a]b" nil nil nil nil "acb" nil "acb" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(609 "\"a\\nb\" =~ /a[^a]b/" "a[^a]b" nil nil nil nil "a
+b" nil "a
+b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(610 "\"acb\" =~ /a.b/" "a.b" nil nil nil nil "acb" nil "acb" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(611 "\"a\\nb\" =~ /a.b/" "a.b" nil nil nil nil "a
+b" nil nil nil)
+(612 "\"acb\" =~ /a[^a]b/s" "a[^a]b" nil nil t nil "acb" nil "acb" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(613 "\"a\\nb\" =~ /a[^a]b/s" "a[^a]b" nil nil t nil "a
+b" nil "a
+b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(614 "\"acb\" =~ /a.b/s" "a.b" nil nil t nil "acb" nil "acb" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(615 "\"a\\nb\" =~ /a.b/s" "a.b" nil nil t nil "a
+b" nil "a
+b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(616 "\"bac\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "bac" nil "bac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(617 "\"bbac\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "bbac" nil "bbac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(618 "\"bbbac\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "bbbac" nil "bbbac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(619 "\"bbbbac\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "bbbbac" nil "bbbbac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(620 "\"bbbbbac\" =~ /^(b+?|a){1,2}?c/" "^(b+?|a){1,2}?c" nil nil nil nil "bbbbbac" nil "bbbbbac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(621 "\"bac\" =~ /^(b+|a){1,2}?c/" "^(b+|a){1,2}?c" nil nil nil nil "bac" nil "bac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(622 "\"bbac\" =~ /^(b+|a){1,2}?c/" "^(b+|a){1,2}?c" nil nil nil nil "bbac" nil "bbac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(623 "\"bbbac\" =~ /^(b+|a){1,2}?c/" "^(b+|a){1,2}?c" nil nil nil nil "bbbac" nil "bbbac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(624 "\"bbbbac\" =~ /^(b+|a){1,2}?c/" "^(b+|a){1,2}?c" nil nil nil nil "bbbbac" nil "bbbbac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(625 "\"bbbbbac\" =~ /^(b+|a){1,2}?c/" "^(b+|a){1,2}?c" nil nil nil nil "bbbbbac" nil "bbbbbac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(626 "\"x\\nb\\n\" =~ /(?!\\A)x/m" "(?!\\A)x" nil t nil nil "x
+b
+" nil nil nil)
+(627 "\"a\\bx\\n\" =~ /(?!\\A)x/m" "(?!\\A)x" nil t nil nil ("a" 8 "x" 10) nil "x" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(628 "\"\\0{ab}\" =~ /\\x0{ab}/" "\\x0{ab}" nil nil nil nil ("" 0 "{ab}") nil ("" 0 "{ab}") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(629 "\"CD\" =~ /(A|B)*?CD/" "(A|B)*?CD" nil nil nil nil "CD" nil "CD" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(630 "\"CD\" =~ /(A|B)*CD/" "(A|B)*CD" nil nil nil nil "CD" nil "CD" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(631 "\"ABABAB\" =~ /(AB)*?\\1/" "(AB)*?\\1" nil nil nil nil "ABABAB" nil "ABAB" ("AB" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(632 "\"ABABAB\" =~ /(AB)*\\1/" "(AB)*\\1" nil nil nil nil "ABABAB" nil "ABABAB" ("AB" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(633 "\"doesn't matter\" =~ /(/" "(" nil nil nil nil "doesn't matter" t nil nil)
+(634 "\"doesn't matter\" =~ /(x)\\2/" "(x)\\2" nil nil nil nil "doesn't matter" t nil nil)
+(635 "\"aaaaaaaaaac\" =~ /((a{0,5}){0,5}){0,5}[c]/" "((a{0,5}){0,5}){0,5}[c]" nil nil nil nil "aaaaaaaaaac" nil "aaaaaaaaaac" ("" "" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(636 "\"aaaaaaaaaa\" =~ /((a{0,5}){0,5}){0,5}[c]/" "((a{0,5}){0,5}){0,5}[c]" nil nil nil nil "aaaaaaaaaa" nil nil nil)
+(637 "\"aaaaaaaaaac\" =~ /((a{0,5}){0,5})*[c]/" "((a{0,5}){0,5})*[c]" nil nil nil nil "aaaaaaaaaac" nil "aaaaaaaaaac" ("" "" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(638 "\"aaaaaaaaaa\" =~ /((a{0,5}){0,5})*[c]/" "((a{0,5}){0,5})*[c]" nil nil nil nil "aaaaaaaaaa" nil nil nil)
+(639 "\"a\" =~ /(\\b)*a/" "(\\b)*a" nil nil nil nil "a" nil "a" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(640 "\"ab\" =~ /(a)*b/" "(a)*b" nil nil nil nil "ab" nil "ab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(641 "\"ab\" =~ /(a|)*b/" "(a|)*b" nil nil nil nil "ab" nil "ab" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(642 "\"b\" =~ /(a|)*b/" "(a|)*b" nil nil nil nil "b" nil "b" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(643 "\"x\" =~ /(a|)*b/" "(a|)*b" nil nil nil nil "x" nil nil nil)
+(644 "\"abab\" =~ /^(?:(a)|(b))*\\1\\2$/" "^(?:(a)|(b))*\\1\\2$" nil nil nil nil "abab" nil "abab" ("a" "b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(645 "\"abcxabcydef\" =~ /abc[^x]def/" "abc[^x]def" nil nil nil nil "abcxabcydef" nil "abcydef" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(646 "\"aax\" =~ /^(a|\\1x)*$/" "^(a|\\1x)*$" nil nil nil nil "aax" nil "aax" ("ax" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(647 "\"aaxa\" =~ /^(a|\\1x)*$/" "^(a|\\1x)*$" nil nil nil nil "aaxa" nil "aaxa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(648 "\"@{['']}\" =~ /(?#)/" "" nil nil nil nil "" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(649 "\"ab\" =~ /^(?:(a)|(b))*$/" "^(?:(a)|(b))*$" nil nil nil nil "ab" nil "ab" ("a" "b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(650 "\"a\" =~ /[\\0]/" "[\\0]" nil nil nil nil "a" nil nil nil)
+(651 "\"\\0\" =~ /[\\0]/" "[\\0]" nil nil nil nil ("" 0) nil ("" 0) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(652 "\"a\" =~ /[\\1]/" "[\\1]" nil nil nil nil "a" nil nil nil)
+(653 "\"\\1\" =~ /[\\1]/" "[\\1]" nil nil nil nil ("" 1) nil ("" 1) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(654 "\"doesn't matter\" =~ /\\10()()()()()()()()()/" "\\10()()()()()()()()()" nil nil nil nil "doesn't matter" nil nil nil)
+(655 "\"a\" =~ /\\10()()()()()()()()()()/" "\\10()()()()()()()()()()" nil nil nil nil "a" nil nil nil)
+(656 "\"ab\" =~ /a(?<)b/" "a(?<)b" nil nil nil nil "ab" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(657 "\"doesn't matter\" =~ /[]/" "[]" nil nil nil nil "doesn't matter" t nil nil)
+(658 "\"doesn't matter\" =~ /[\\]/" "[\\]" nil nil nil nil "doesn't matter" t nil nil)
+(659 "\"a\" =~ /()/" "()" nil nil nil nil "a" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(660 "\"x\" =~ /[\\x]/" "[\\x]" nil nil nil nil "x" nil nil nil)
+(661 "\"\\0\" =~ /[\\x]/" "[\\x]" nil nil nil nil ("" 0) nil ("" 0) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(662 "\"a\" =~ /((a)*)*/" "((a)*)*" nil nil nil nil "a" nil "a" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(663 "\"a\" =~ /()a\\1/" "()a\\1" nil nil nil nil "a" nil "a" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(664 "\"a\" =~ /a\\1()/" "a\\1()" nil nil nil nil "a" nil nil nil)
+(665 "\"aaa\" =~ /a(?i)a(?-i)a/" "a(?i)a(?-i)a" nil nil nil nil "aaa" nil "aaa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(666 "\"aAa\" =~ /a(?i)a(?-i)a/" "a(?i)a(?-i)a" nil nil nil nil "aAa" nil "aAa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(667 "\"aAA\" =~ /a(?i)a(?-i)a/" "a(?i)a(?-i)a" nil nil nil nil "aAA" nil nil nil)
+(668 "\"aaaaa\" =~ /a(?i)a(?-i)a(?i)a(?-i)a/" "a(?i)a(?-i)a(?i)a(?-i)a" nil nil nil nil "aaaaa" nil "aaaaa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(669 "\"aAaAa\" =~ /a(?i)a(?-i)a(?i)a(?-i)a/" "a(?i)a(?-i)a(?i)a(?-i)a" nil nil nil nil "aAaAa" nil "aAaAa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(670 "\"AaAaA\" =~ /a(?i)a(?-i)a(?i)a(?-i)a/" "a(?i)a(?-i)a(?i)a(?-i)a" nil nil nil nil "AaAaA" nil nil nil)
+(671 "\"aAAAa\" =~ /a(?i)a(?-i)a(?i)a(?-i)a/" "a(?i)a(?-i)a(?i)a(?-i)a" nil nil nil nil "aAAAa" nil nil nil)
+(672 "\"AaaaA\" =~ /a(?i)a(?-i)a(?i)a(?-i)a/" "a(?i)a(?-i)a(?i)a(?-i)a" nil nil nil nil "AaaaA" nil nil nil)
+(673 "\"AAAAA\" =~ /a(?i)a(?-i)a(?i)a(?-i)a/" "a(?i)a(?-i)a(?i)a(?-i)a" nil nil nil nil "AAAAA" nil nil nil)
+(674 "\"aaAAA\" =~ /a(?i)a(?-i)a(?i)a(?-i)a/" "a(?i)a(?-i)a(?i)a(?-i)a" nil nil nil nil "aaAAA" nil nil nil)
+(675 "\"AAaaa\" =~ /a(?i)a(?-i)a(?i)a(?-i)a/" "a(?i)a(?-i)a(?i)a(?-i)a" nil nil nil nil "AAaaa" nil nil nil)
+(676 "\"a\" =~ /\\x/" "\\x" nil nil nil nil "a" nil nil nil)
+(677 "\"X\" =~ /\\x/" "\\x" nil nil nil nil "X" nil nil nil)
+(678 "\"\\0\" =~ /\\x/" "\\x" nil nil nil nil ("" 0) nil ("" 0) (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(679 "\"a\" =~ /[a-c-e]/" "[a-c-e]" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(680 "\"b\" =~ /[a-c-e]/" "[a-c-e]" nil nil nil nil "b" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(681 "\"d\" =~ /[a-c-e]/" "[a-c-e]" nil nil nil nil "d" nil nil nil)
+(682 "\"-\" =~ /[a-c-e]/" "[a-c-e]" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(683 "\"b\" =~ /[b-\\d]/" "[b-\\d]" nil nil nil nil "b" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(684 "\"c\" =~ /[b-\\d]/" "[b-\\d]" nil nil nil nil "c" nil nil nil)
+(685 "\"d\" =~ /[b-\\d]/" "[b-\\d]" nil nil nil nil "d" nil nil nil)
+(686 "\"-\" =~ /[b-\\d]/" "[b-\\d]" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(687 "\"1\" =~ /[b-\\d]/" "[b-\\d]" nil nil nil nil "1" nil "1" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(688 "\"d\" =~ /[\\d-f]/" "[\\d-f]" nil nil nil nil "d" nil nil nil)
+(689 "\"e\" =~ /[\\d-f]/" "[\\d-f]" nil nil nil nil "e" nil nil nil)
+(690 "\"f\" =~ /[\\d-f]/" "[\\d-f]" nil nil nil nil "f" nil "f" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(691 "\"-\" =~ /[\\d-f]/" "[\\d-f]" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(692 "\"1\" =~ /[\\d-f]/" "[\\d-f]" nil nil nil nil "1" nil "1" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(693 "\"doesn't matter\" =~ /[/" "[" nil nil nil nil "doesn't matter" t nil nil)
+(694 "\"]\" =~ /]/" "]" nil nil nil nil "]" nil "]" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(695 "\"a\" =~ /]/" "]" nil nil nil nil "a" nil nil nil)
+(696 "\"doesn't matter\" =~ /[]/" "[]" nil nil nil nil "doesn't matter" t nil nil)
+(697 "\"-\" =~ /[-a-c]/" "[-a-c]" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(698 "\"a\" =~ /[-a-c]/" "[-a-c]" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(699 "\"b\" =~ /[-a-c]/" "[-a-c]" nil nil nil nil "b" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(700 "\"d\" =~ /[-a-c]/" "[-a-c]" nil nil nil nil "d" nil nil nil)
+(701 "\"-\" =~ /[a-c-]/" "[a-c-]" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(702 "\"a\" =~ /[a-c-]/" "[a-c-]" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(703 "\"b\" =~ /[a-c-]/" "[a-c-]" nil nil nil nil "b" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(704 "\"d\" =~ /[a-c-]/" "[a-c-]" nil nil nil nil "d" nil nil nil)
+(705 "\"a\" =~ /[-]/" "[-]" nil nil nil nil "a" nil nil nil)
+(706 "\"-\" =~ /[-]/" "[-]" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(707 "\"a\" =~ /[--]/" "[--]" nil nil nil nil "a" nil nil nil)
+(708 "\"-\" =~ /[--]/" "[--]" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(709 "\"a\" =~ /[---]/" "[---]" nil nil nil nil "a" nil nil nil)
+(710 "\"-\" =~ /[---]/" "[---]" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(711 "\"-\" =~ /[--b]/" "[--b]" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(712 "\"a\" =~ /[--b]/" "[--b]" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(713 "\"c\" =~ /[--b]/" "[--b]" nil nil nil nil "c" nil nil nil)
+(714 "\"doesn't matter\" =~ /[b--]/" "[b--]" nil nil nil nil "doesn't matter" t nil nil)
+(715 "\"a{\" =~ /a{/" "a{" nil nil nil nil "a{" nil "a{" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(716 "\"a{}\" =~ /a{}/" "a{}" nil nil nil nil "a{}" nil "a{}" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(717 "\"a{3\" =~ /a{3/" "a{3" nil nil nil nil "a{3" nil "a{3" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(718 "\"a{3,\" =~ /a{3,/" "a{3," nil nil nil nil "a{3," nil "a{3," (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(719 "\"a{3,3}\" =~ /a{3, 3}/" "a{3, 3}" nil nil nil nil "a{3,3}" nil nil nil)
+(720 "\"a{3, 3}\" =~ /a{3, 3}/" "a{3, 3}" nil nil nil nil "a{3, 3}" nil "a{3, 3}" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(721 "\"aaa\" =~ /a{3, 3}/" "a{3, 3}" nil nil nil nil "aaa" nil nil nil)
+(722 "\"a{3,3}\" =~ /a{3, 3}/x" "a{3, 3}" nil nil nil t "a{3,3}" nil "a{3,3}" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(723 "\"a{3, 3}\" =~ /a{3, 3}/x" "a{3, 3}" nil nil nil t "a{3, 3}" nil nil nil)
+(724 "\"aaa\" =~ /a{3, 3}/x" "a{3, 3}" nil nil nil t "aaa" nil nil nil)
+(725 "\"a{3,}\" =~ /a{3, }/" "a{3, }" nil nil nil nil "a{3,}" nil nil nil)
+(726 "\"a{3, }\" =~ /a{3, }/" "a{3, }" nil nil nil nil "a{3, }" nil "a{3, }" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(727 "\"aaa\" =~ /a{3, }/" "a{3, }" nil nil nil nil "aaa" nil nil nil)
+(728 "\"a{3,}\" =~ /a{3, }/x" "a{3, }" nil nil nil t "a{3,}" nil "a{3,}" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(729 "\"a{3, }\" =~ /a{3, }/x" "a{3, }" nil nil nil t "a{3, }" nil nil nil)
+(730 "\"aaa\" =~ /a{3, }/x" "a{3, }" nil nil nil t "aaa" nil nil nil)
+(731 "\"\\0 x\" =~ /\\x x/" "\\x x" nil nil nil nil ("" 0 " x") nil ("" 0 " x") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(732 "\"\\0x\" =~ /\\x x/" "\\x x" nil nil nil nil ("" 0 "x") nil nil nil)
+(733 "\"\\0 x\" =~ /\\x x/x" "\\x x" nil nil nil t ("" 0 " x") nil nil nil)
+(734 "\"\\0x\" =~ /\\x x/x" "\\x x" nil nil nil t ("" 0 "x") nil ("" 0 "x") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(735 "\"\\0003\" =~ /\\x 3/" "\\x 3" nil nil nil nil ("" 0 "3") nil nil nil)
+(736 "\"\\000 3\" =~ /\\x 3/" "\\x 3" nil nil nil nil ("" 0 " 3") nil ("" 0 " 3") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(737 "\"x3\" =~ /\\x 3/" "\\x 3" nil nil nil nil "x3" nil nil nil)
+(738 "\"x 3\" =~ /\\x 3/" "\\x 3" nil nil nil nil "x 3" nil nil nil)
+(739 "\"\\0003\" =~ /\\x 3/x" "\\x 3" nil nil nil t ("" 0 "3") nil ("" 0 "3") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(740 "\"\\000 3\" =~ /\\x 3/x" "\\x 3" nil nil nil t ("" 0 " 3") nil nil nil)
+(741 "\"x3\" =~ /\\x 3/x" "\\x 3" nil nil nil t "x3" nil nil nil)
+(742 "\"x 3\" =~ /\\x 3/x" "\\x 3" nil nil nil t "x 3" nil nil nil)
+(743 "\"a\" =~ /^a{ 1}$/" "^a{ 1}$" nil nil nil nil "a" nil nil nil)
+(744 "\"a{ 1}\" =~ /^a{ 1}$/" "^a{ 1}$" nil nil nil nil "a{ 1}" nil "a{ 1}" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(745 "\"a{1}\" =~ /^a{ 1}$/" "^a{ 1}$" nil nil nil nil "a{1}" nil nil nil)
+(746 "\"a\" =~ /^a{ 1}$/x" "^a{ 1}$" nil nil nil t "a" nil nil nil)
+(747 "\"a{ 1}\" =~ /^a{ 1}$/x" "^a{ 1}$" nil nil nil t "a{ 1}" nil nil nil)
+(748 "\"a{1}\" =~ /^a{ 1}$/x" "^a{ 1}$" nil nil nil t "a{1}" nil "a{1}" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(749 "\"{}\" =~ /{}/" "{}" nil nil nil nil "{}" nil "{}" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(750 "\"a\" =~ /{}/" "{}" nil nil nil nil "a" nil nil nil)
+(751 "\"doesn't matter\" =~ /{1}/" "{1}" nil nil nil nil "doesn't matter" t nil nil)
+(752 "\"doesn't matter\" =~ /*/" "*" nil nil nil nil "doesn't matter" t nil nil)
+(753 "\"x\" =~ /|/" "|" nil nil nil nil "x" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(754 "\"\\0000\" =~ /\\0000/" "\\0000" nil nil nil nil ("" 0 "0") nil ("" 0 "0") (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(755 "\"ab\" =~ /a(?<)b/" "a(?<)b" nil nil nil nil "ab" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(756 "\"ab\" =~ /a(?i)b/" "a(?i)b" nil nil nil nil "ab" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(757 "\"aB\" =~ /a(?i)b/" "a(?i)b" nil nil nil nil "aB" nil "aB" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(758 "\"Ab\" =~ /a(?i)b/" "a(?i)b" nil nil nil nil "Ab" nil nil nil)
+(759 "\"doesn't matter\" =~ /a(?i=a)/" "a(?i=a)" nil nil nil nil "doesn't matter" t nil nil)
+(760 "\"aa\" =~ /a(?<=a){3000}a/" "a(?<=a){3000}a" nil nil nil nil "aa" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(761 "\"xa\" =~ /a(?<=a){3000}a/" "a(?<=a){3000}a" nil nil nil nil "xa" nil nil nil)
+(762 "\"ax\" =~ /a(?<=a){3000}a/" "a(?<=a){3000}a" nil nil nil nil "ax" nil nil nil)
+(763 "\"aa\" =~ /a(?!=a){3000}a/" "a(?!=a){3000}a" nil nil nil nil "aa" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(764 "\"ax\" =~ /a(?!=a){3000}a/" "a(?!=a){3000}a" nil nil nil nil "ax" nil nil nil)
+(765 "\"xa\" =~ /a(?!=a){3000}a/" "a(?!=a){3000}a" nil nil nil nil "xa" nil nil nil)
+(766 "\"aa\" =~ /a(){3000}a/" "a(){3000}a" nil nil nil nil "aa" nil "aa" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(767 "\"ax\" =~ /a(){3000}a/" "a(){3000}a" nil nil nil nil "ax" nil nil nil)
+(768 "\"xa\" =~ /a(){3000}a/" "a(){3000}a" nil nil nil nil "xa" nil nil nil)
+(769 "\"aa\" =~ /a(?:){3000}a/" "a(?:){3000}a" nil nil nil nil "aa" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(770 "\"ax\" =~ /a(?:){3000}a/" "a(?:){3000}a" nil nil nil nil "ax" nil nil nil)
+(771 "\"aa\" =~ /a(?<=a)*a/" "a(?<=a)*a" nil nil nil nil "aa" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(772 "\"ax\" =~ /a(?<=a)*a/" "a(?<=a)*a" nil nil nil nil "ax" nil nil nil)
+(773 "\"xa\" =~ /a(?<=a)*a/" "a(?<=a)*a" nil nil nil nil "xa" nil nil nil)
+(774 "\"aa\" =~ /a(?!=a)*a/" "a(?!=a)*a" nil nil nil nil "aa" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(775 "\"ax\" =~ /a(?!=a)*a/" "a(?!=a)*a" nil nil nil nil "ax" nil nil nil)
+(776 "\"xa\" =~ /a(?!=a)*a/" "a(?!=a)*a" nil nil nil nil "xa" nil nil nil)
+(777 "\"aa\" =~ /a()*a/" "a()*a" nil nil nil nil "aa" nil "aa" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(778 "\"ax\" =~ /a()*a/" "a()*a" nil nil nil nil "ax" nil nil nil)
+(779 "\"xa\" =~ /a()*a/" "a()*a" nil nil nil nil "xa" nil nil nil)
+(780 "\"aa\" =~ /a(?:)*a/" "a(?:)*a" nil nil nil nil "aa" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(781 "\"ax\" =~ /a(?:)*a/" "a(?:)*a" nil nil nil nil "ax" nil nil nil)
+(782 "\"xa\" =~ /a(?:)*a/" "a(?:)*a" nil nil nil nil "xa" nil nil nil)
+(783 "\"aa\" =~ /x(?<=a)*a/" "x(?<=a)*a" nil nil nil nil "aa" nil nil nil)
+(784 "\"xa\" =~ /x(?<=a)*a/" "x(?<=a)*a" nil nil nil nil "xa" nil "xa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(785 "\"ax\" =~ /x(?<=a)*a/" "x(?<=a)*a" nil nil nil nil "ax" nil nil nil)
+(786 "\"aa\" =~ /a(?<=(a))*\\1/" "a(?<=(a))*\\1" nil nil nil nil "aa" nil "aa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(787 "\"aa\" =~ /a(?<=(a))*?\\1/" "a(?<=(a))*?\\1" nil nil nil nil "aa" nil "aa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(788 "\"aa\" =~ /(?=(a)\\1)*aa/" "(?=(a)\\1)*aa" nil nil nil nil "aa" nil "aa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(789 "\"aaaaabbbbb\" =~ /^((a|b){2,5}){2}$/" "^((a|b){2,5}){2}$" nil nil nil nil "aaaaabbbbb" nil "aaaaabbbbb" ("bbbbb" "b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(790 "\"babc\" =~ /^(b*|ba){1,2}bc/" "^(b*|ba){1,2}bc" nil nil nil nil "babc" nil "babc" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(791 "\"bbabc\" =~ /^(b*|ba){1,2}bc/" "^(b*|ba){1,2}bc" nil nil nil nil "bbabc" nil "bbabc" ("ba" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(792 "\"bababc\" =~ /^(b*|ba){1,2}bc/" "^(b*|ba){1,2}bc" nil nil nil nil "bababc" nil "bababc" ("ba" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(793 "\"bababbc\" =~ /^(b*|ba){1,2}bc/" "^(b*|ba){1,2}bc" nil nil nil nil "bababbc" nil nil nil)
+(794 "\"babababc\" =~ /^(b*|ba){1,2}bc/" "^(b*|ba){1,2}bc" nil nil nil nil "babababc" nil nil nil)
+(795 "\"aaaaac\" =~ /^a{4,5}(?:c|a)c$/" "^a{4,5}(?:c|a)c$" nil nil nil nil "aaaaac" nil "aaaaac" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(796 "\"aaaaaac\" =~ /^a{4,5}(?:c|a)c$/" "^a{4,5}(?:c|a)c$" nil nil nil nil "aaaaaac" nil "aaaaaac" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(797 "\"aaaaac\" =~ /^(a|){4,5}(?:c|a)c$/" "^(a|){4,5}(?:c|a)c$" nil nil nil nil "aaaaac" nil "aaaaac" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(798 "\"aaaaaac\" =~ /^(a|){4,5}(?:c|a)c$/" "^(a|){4,5}(?:c|a)c$" nil nil nil nil "aaaaaac" nil "aaaaaac" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(799 "\"eeexabc\" =~ /(?m:^).abc$/" "(?m:^).abc$" nil nil nil nil "eeexabc" nil nil nil)
+(800 "\"eee\\nxabc\" =~ /(?m:^).abc$/" "(?m:^).abc$" nil nil nil nil "eee
+xabc" nil "xabc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(801 "\"abc\" =~ /(?m:^)abc/" "(?m:^)abc" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(802 "\"\\nabc\" =~ /(?m:^)abc/" "(?m:^)abc" nil nil nil nil "
+abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(803 "\"abc\" =~ 
+/^abc/" "^abc" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(804 "\"\\nabc\" =~ 
+/^abc/" "^abc" nil nil nil nil "
+abc" nil nil nil)
+(805 "\"abc\" =~ /\\Aabc/" "\\Aabc" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(806 "\"\\nabc\" =~ /\\Aabc/" "\\Aabc" nil nil nil nil "
+abc" nil nil nil)
+(807 "\"foo\" =~ /(?<!bar)foo/" "(?<!bar)foo" nil nil nil nil "foo" nil "foo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(808 "\"catfood\" =~ /(?<!bar)foo/" "(?<!bar)foo" nil nil nil nil "catfood" nil "foo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(809 "\"arfootle\" =~ /(?<!bar)foo/" "(?<!bar)foo" nil nil nil nil "arfootle" nil "foo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(810 "\"rfoosh\" =~ /(?<!bar)foo/" "(?<!bar)foo" nil nil nil nil "rfoosh" nil "foo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(811 "\"barfoo\" =~ /(?<!bar)foo/" "(?<!bar)foo" nil nil nil nil "barfoo" nil nil nil)
+(812 "\"towbarfoo\" =~ /(?<!bar)foo/" "(?<!bar)foo" nil nil nil nil "towbarfoo" nil nil nil)
+(813 "\"catfood\" =~ /\\w{3}(?<!bar)foo/" "\\w{3}(?<!bar)foo" nil nil nil nil "catfood" nil "catfoo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(814 "\"foo\" =~ /\\w{3}(?<!bar)foo/" "\\w{3}(?<!bar)foo" nil nil nil nil "foo" nil nil nil)
+(815 "\"barfoo\" =~ /\\w{3}(?<!bar)foo/" "\\w{3}(?<!bar)foo" nil nil nil nil "barfoo" nil nil nil)
+(816 "\"towbarfoo\" =~ /\\w{3}(?<!bar)foo/" "\\w{3}(?<!bar)foo" nil nil nil nil "towbarfoo" nil nil nil)
+(817 "\"fooabar\" =~ /(?<=(foo)a)bar/" "(?<=(foo)a)bar" nil nil nil nil "fooabar" nil "bar" ("foo" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(818 "\"bar\" =~ /(?<=(foo)a)bar/" "(?<=(foo)a)bar" nil nil nil nil "bar" nil nil nil)
+(819 "\"foobbar\" =~ /(?<=(foo)a)bar/" "(?<=(foo)a)bar" nil nil nil nil "foobbar" nil nil nil)
+(820 "\"abc\" =~ /\\Aabc\\z/m" "\\Aabc\\z" nil t nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(821 "\"abc\\n\" =~ /\\Aabc\\z/m" "\\Aabc\\z" nil t nil nil "abc
+" nil nil nil)
+(822 "\"qqq\\nabc\" =~ /\\Aabc\\z/m" "\\Aabc\\z" nil t nil nil "qqq
+abc" nil nil nil)
+(823 "\"abc\\nzzz\" =~ /\\Aabc\\z/m" "\\Aabc\\z" nil t nil nil "abc
+zzz" nil nil nil)
+(824 "\"qqq\\nabc\\nzzz\" =~ /\\Aabc\\z/m" "\\Aabc\\z" nil t nil nil "qqq
+abc
+zzz" nil nil nil)
+(825 "\"/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/it/you/see/\" =~ \"(?>.*/)foo\"" "(?>.*/)foo" nil nil nil nil "/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/it/you/see/" nil nil nil)
+(826 "\"/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo\" =~ \"(?>.*/)foo\"" "(?>.*/)foo" nil nil nil nil "/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo" nil "/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(827 "\"1.230003938\" =~ /(?>(\\.\\d\\d[1-9]?))\\d+/" "(?>(\\.\\d\\d[1-9]?))\\d+" nil nil nil nil "1.230003938" nil ".230003938" (".23" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(828 "\"1.875000282\" =~ /(?>(\\.\\d\\d[1-9]?))\\d+/" "(?>(\\.\\d\\d[1-9]?))\\d+" nil nil nil nil "1.875000282" nil ".875000282" (".875" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(829 "\"1.235\" =~ /(?>(\\.\\d\\d[1-9]?))\\d+/" "(?>(\\.\\d\\d[1-9]?))\\d+" nil nil nil nil "1.235" nil nil nil)
+(830 "\"now is the time for all good men to come to the aid of the party\" =~ /^((?>\\w+)|(?>\\s+))*$/" "^((?>\\w+)|(?>\\s+))*$" nil nil nil nil "now is the time for all good men to come to the aid of the party" nil "now is the time for all good men to come to the aid of the party" ("party" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(831 "\"this is not a line with only words and spaces!\" =~ /^((?>\\w+)|(?>\\s+))*$/" "^((?>\\w+)|(?>\\s+))*$" nil nil nil nil "this is not a line with only words and spaces!" nil nil nil)
+(832 "\"12345a\" =~ /(\\d+)(\\w)/" "(\\d+)(\\w)" nil nil nil nil "12345a" nil "12345a" ("12345" "a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(833 "\"12345+\" =~ /(\\d+)(\\w)/" "(\\d+)(\\w)" nil nil nil nil "12345+" nil "12345" ("1234" "5" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(834 "\"12345a\" =~ /((?>\\d+))(\\w)/" "((?>\\d+))(\\w)" nil nil nil nil "12345a" nil "12345a" ("12345" "a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(835 "\"12345+\" =~ /((?>\\d+))(\\w)/" "((?>\\d+))(\\w)" nil nil nil nil "12345+" nil nil nil)
+(836 "\"aaab\" =~ /(?>a+)b/" "(?>a+)b" nil nil nil nil "aaab" nil "aaab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(837 "\"aaab\" =~ /((?>a+)b)/" "((?>a+)b)" nil nil nil nil "aaab" nil "aaab" ("aaab" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(838 "\"aaab\" =~ /(?>(a+))b/" "(?>(a+))b" nil nil nil nil "aaab" nil "aaab" ("aaa" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(839 "\"aaabbbccc\" =~ /(?>b)+/" "(?>b)+" nil nil nil nil "aaabbbccc" nil "bbb" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(840 "\"aaabbbbccccd\" =~ /(?>a+|b+|c+)*c/" "(?>a+|b+|c+)*c" nil nil nil nil "aaabbbbccccd" nil "aaabbbbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(841 "\"((abc(ade)ufh()()x\" =~ /((?>[^()]+)|\\([^()]*\\))+/" "((?>[^()]+)|\\([^()]*\\))+" nil nil nil nil "((abc(ade)ufh()()x" nil "abc(ade)ufh()()x" ("x" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(842 "\"(abc)\" =~ /\\(((?>[^()]+)|\\([^()]+\\))+\\)/" "\\(((?>[^()]+)|\\([^()]+\\))+\\)" nil nil nil nil "(abc)" nil "(abc)" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(843 "\"(abc(def)xyz)\" =~ /\\(((?>[^()]+)|\\([^()]+\\))+\\)/" "\\(((?>[^()]+)|\\([^()]+\\))+\\)" nil nil nil nil "(abc(def)xyz)" nil "(abc(def)xyz)" ("xyz" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(844 "\"((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" =~ /\\(((?>[^()]+)|\\([^()]+\\))+\\)/" "\\(((?>[^()]+)|\\([^()]+\\))+\\)" nil nil nil nil "((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" nil nil nil)
+(845 "\"ab\" =~ /a(?-i)b/i" "a(?-i)b" t nil nil nil "ab" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(846 "\"Ab\" =~ /a(?-i)b/i" "a(?-i)b" t nil nil nil "Ab" nil "Ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(847 "\"aB\" =~ /a(?-i)b/i" "a(?-i)b" t nil nil nil "aB" nil nil nil)
+(848 "\"AB\" =~ /a(?-i)b/i" "a(?-i)b" t nil nil nil "AB" nil nil nil)
+(849 "\"a bcd e\" =~ /(a (?x)b c)d e/" "(a (?x)b c)d e" nil nil nil nil "a bcd e" nil "a bcd e" ("a bc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(850 "\"a b cd e\" =~ /(a (?x)b c)d e/" "(a (?x)b c)d e" nil nil nil nil "a b cd e" nil nil nil)
+(851 "\"abcd e\" =~ /(a (?x)b c)d e/" "(a (?x)b c)d e" nil nil nil nil "abcd e" nil nil nil)
+(852 "\"a bcde\" =~ /(a (?x)b c)d e/" "(a (?x)b c)d e" nil nil nil nil "a bcde" nil nil nil)
+(853 "\"a bcde f\" =~ /(a b(?x)c d (?-x)e f)/" "(a b(?x)c d (?-x)e f)" nil nil nil nil "a bcde f" nil "a bcde f" ("a bcde f" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(854 "\"abcdef\" =~ /(a b(?x)c d (?-x)e f)/" "(a b(?x)c d (?-x)e f)" nil nil nil nil "abcdef" nil nil nil)
+(855 "\"abc\" =~ /(a(?i)b)c/" "(a(?i)b)c" nil nil nil nil "abc" nil "abc" ("ab" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(856 "\"aBc\" =~ /(a(?i)b)c/" "(a(?i)b)c" nil nil nil nil "aBc" nil "aBc" ("aB" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(857 "\"abC\" =~ /(a(?i)b)c/" "(a(?i)b)c" nil nil nil nil "abC" nil nil nil)
+(858 "\"aBC\" =~ /(a(?i)b)c/" "(a(?i)b)c" nil nil nil nil "aBC" nil nil nil)
+(859 "\"Abc\" =~ /(a(?i)b)c/" "(a(?i)b)c" nil nil nil nil "Abc" nil nil nil)
+(860 "\"ABc\" =~ /(a(?i)b)c/" "(a(?i)b)c" nil nil nil nil "ABc" nil nil nil)
+(861 "\"ABC\" =~ /(a(?i)b)c/" "(a(?i)b)c" nil nil nil nil "ABC" nil nil nil)
+(862 "\"AbC\" =~ /(a(?i)b)c/" "(a(?i)b)c" nil nil nil nil "AbC" nil nil nil)
+(863 "\"abc\" =~ /a(?i:b)c/" "a(?i:b)c" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(864 "\"aBc\" =~ /a(?i:b)c/" "a(?i:b)c" nil nil nil nil "aBc" nil "aBc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(865 "\"ABC\" =~ /a(?i:b)c/" "a(?i:b)c" nil nil nil nil "ABC" nil nil nil)
+(866 "\"abC\" =~ /a(?i:b)c/" "a(?i:b)c" nil nil nil nil "abC" nil nil nil)
+(867 "\"aBC\" =~ /a(?i:b)c/" "a(?i:b)c" nil nil nil nil "aBC" nil nil nil)
+(868 "\"aBc\" =~ /a(?i:b)*c/" "a(?i:b)*c" nil nil nil nil "aBc" nil "aBc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(869 "\"aBBc\" =~ /a(?i:b)*c/" "a(?i:b)*c" nil nil nil nil "aBBc" nil "aBBc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(870 "\"aBC\" =~ /a(?i:b)*c/" "a(?i:b)*c" nil nil nil nil "aBC" nil nil nil)
+(871 "\"aBBC\" =~ /a(?i:b)*c/" "a(?i:b)*c" nil nil nil nil "aBBC" nil nil nil)
+(872 "\"abcd\" =~ /a(?=b(?i)c)\\w\\wd/" "a(?=b(?i)c)\\w\\wd" nil nil nil nil "abcd" nil "abcd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(873 "\"abCd\" =~ /a(?=b(?i)c)\\w\\wd/" "a(?=b(?i)c)\\w\\wd" nil nil nil nil "abCd" nil "abCd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(874 "\"aBCd\" =~ /a(?=b(?i)c)\\w\\wd/" "a(?=b(?i)c)\\w\\wd" nil nil nil nil "aBCd" nil nil nil)
+(875 "\"abcD\" =~ /a(?=b(?i)c)\\w\\wd/" "a(?=b(?i)c)\\w\\wd" nil nil nil nil "abcD" nil nil nil)
+(876 "\"more than million\" =~ /(?s-i:more.*than).*million/i" "(?s-i:more.*than).*million" t nil nil nil "more than million" nil "more than million" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(877 "\"more than MILLION\" =~ /(?s-i:more.*than).*million/i" "(?s-i:more.*than).*million" t nil nil nil "more than MILLION" nil "more than MILLION" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(878 "\"more \\n than Million\" =~ /(?s-i:more.*than).*million/i" "(?s-i:more.*than).*million" t nil nil nil "more 
+ than Million" nil "more 
+ than Million" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(879 "\"MORE THAN MILLION\" =~ /(?s-i:more.*than).*million/i" "(?s-i:more.*than).*million" t nil nil nil "MORE THAN MILLION" nil nil nil)
+(880 "\"more \\n than \\n million\" =~ /(?s-i:more.*than).*million/i" "(?s-i:more.*than).*million" t nil nil nil "more 
+ than 
+ million" nil nil nil)
+(881 "\"more than million\" =~ /(?:(?s-i)more.*than).*million/i" "(?:(?s-i)more.*than).*million" t nil nil nil "more than million" nil "more than million" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(882 "\"more than MILLION\" =~ /(?:(?s-i)more.*than).*million/i" "(?:(?s-i)more.*than).*million" t nil nil nil "more than MILLION" nil "more than MILLION" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(883 "\"more \\n than Million\" =~ /(?:(?s-i)more.*than).*million/i" "(?:(?s-i)more.*than).*million" t nil nil nil "more 
+ than Million" nil "more 
+ than Million" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(884 "\"MORE THAN MILLION\" =~ /(?:(?s-i)more.*than).*million/i" "(?:(?s-i)more.*than).*million" t nil nil nil "MORE THAN MILLION" nil nil nil)
+(885 "\"more \\n than \\n million\" =~ /(?:(?s-i)more.*than).*million/i" "(?:(?s-i)more.*than).*million" t nil nil nil "more 
+ than 
+ million" nil nil nil)
+(886 "\"abc\" =~ /(?>a(?i)b+)+c/" "(?>a(?i)b+)+c" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(887 "\"aBbc\" =~ /(?>a(?i)b+)+c/" "(?>a(?i)b+)+c" nil nil nil nil "aBbc" nil "aBbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(888 "\"aBBc\" =~ /(?>a(?i)b+)+c/" "(?>a(?i)b+)+c" nil nil nil nil "aBBc" nil "aBBc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(889 "\"Abc\" =~ /(?>a(?i)b+)+c/" "(?>a(?i)b+)+c" nil nil nil nil "Abc" nil nil nil)
+(890 "\"abAb\" =~ /(?>a(?i)b+)+c/" "(?>a(?i)b+)+c" nil nil nil nil "abAb" nil nil nil)
+(891 "\"abbC\" =~ /(?>a(?i)b+)+c/" "(?>a(?i)b+)+c" nil nil nil nil "abbC" nil nil nil)
+(892 "\"abc\" =~ /(?=a(?i)b)\\w\\wc/" "(?=a(?i)b)\\w\\wc" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(893 "\"aBc\" =~ /(?=a(?i)b)\\w\\wc/" "(?=a(?i)b)\\w\\wc" nil nil nil nil "aBc" nil "aBc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(894 "\"Ab\" =~ /(?=a(?i)b)\\w\\wc/" "(?=a(?i)b)\\w\\wc" nil nil nil nil "Ab" nil nil nil)
+(895 "\"abC\" =~ /(?=a(?i)b)\\w\\wc/" "(?=a(?i)b)\\w\\wc" nil nil nil nil "abC" nil nil nil)
+(896 "\"aBC\" =~ /(?=a(?i)b)\\w\\wc/" "(?=a(?i)b)\\w\\wc" nil nil nil nil "aBC" nil nil nil)
+(897 "\"abxxc\" =~ /(?<=a(?i)b)(\\w\\w)c/" "(?<=a(?i)b)(\\w\\w)c" nil nil nil nil "abxxc" nil "xxc" ("xx" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(898 "\"aBxxc\" =~ /(?<=a(?i)b)(\\w\\w)c/" "(?<=a(?i)b)(\\w\\w)c" nil nil nil nil "aBxxc" nil "xxc" ("xx" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(899 "\"Abxxc\" =~ /(?<=a(?i)b)(\\w\\w)c/" "(?<=a(?i)b)(\\w\\w)c" nil nil nil nil "Abxxc" nil nil nil)
+(900 "\"ABxxc\" =~ /(?<=a(?i)b)(\\w\\w)c/" "(?<=a(?i)b)(\\w\\w)c" nil nil nil nil "ABxxc" nil nil nil)
+(901 "\"abxxC\" =~ /(?<=a(?i)b)(\\w\\w)c/" "(?<=a(?i)b)(\\w\\w)c" nil nil nil nil "abxxC" nil nil nil)
+(902 "\"aA\" =~ /(?:(a)|b)(?(1)A|B)/" "(?:(a)|b)(?(1)A|B)" nil nil nil nil "aA" nil "aA" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(903 "\"bB\" =~ /(?:(a)|b)(?(1)A|B)/" "(?:(a)|b)(?(1)A|B)" nil nil nil nil "bB" nil "bB" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(904 "\"aB\" =~ /(?:(a)|b)(?(1)A|B)/" "(?:(a)|b)(?(1)A|B)" nil nil nil nil "aB" nil nil nil)
+(905 "\"bA\" =~ /(?:(a)|b)(?(1)A|B)/" "(?:(a)|b)(?(1)A|B)" nil nil nil nil "bA" nil nil nil)
+(906 "\"aa\" =~ /^(a)?(?(1)a|b)+$/" "^(a)?(?(1)a|b)+$" nil nil nil nil "aa" nil "aa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(907 "\"b\" =~ /^(a)?(?(1)a|b)+$/" "^(a)?(?(1)a|b)+$" nil nil nil nil "b" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(908 "\"bb\" =~ /^(a)?(?(1)a|b)+$/" "^(a)?(?(1)a|b)+$" nil nil nil nil "bb" nil "bb" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(909 "\"ab\" =~ /^(a)?(?(1)a|b)+$/" "^(a)?(?(1)a|b)+$" nil nil nil nil "ab" nil nil nil)
+(910 "\"abc:\" =~ /^(?(?=abc)\\w{3}:|\\d\\d)$/" "^(?(?=abc)\\w{3}:|\\d\\d)$" nil nil nil nil "abc:" nil "abc:" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(911 "\"12\" =~ /^(?(?=abc)\\w{3}:|\\d\\d)$/" "^(?(?=abc)\\w{3}:|\\d\\d)$" nil nil nil nil "12" nil "12" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(912 "\"123\" =~ /^(?(?=abc)\\w{3}:|\\d\\d)$/" "^(?(?=abc)\\w{3}:|\\d\\d)$" nil nil nil nil "123" nil nil nil)
+(913 "\"xyz\" =~ /^(?(?=abc)\\w{3}:|\\d\\d)$/" "^(?(?=abc)\\w{3}:|\\d\\d)$" nil nil nil nil "xyz" nil nil nil)
+(914 "\"abc:\" =~ /^(?(?!abc)\\d\\d|\\w{3}:)$/" "^(?(?!abc)\\d\\d|\\w{3}:)$" nil nil nil nil "abc:" nil "abc:" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(915 "\"12\" =~ /^(?(?!abc)\\d\\d|\\w{3}:)$/" "^(?(?!abc)\\d\\d|\\w{3}:)$" nil nil nil nil "12" nil "12" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(916 "\"123\" =~ /^(?(?!abc)\\d\\d|\\w{3}:)$/" "^(?(?!abc)\\d\\d|\\w{3}:)$" nil nil nil nil "123" nil nil nil)
+(917 "\"xyz\" =~ /^(?(?!abc)\\d\\d|\\w{3}:)$/" "^(?(?!abc)\\d\\d|\\w{3}:)$" nil nil nil nil "xyz" nil nil nil)
+(918 "\"foobar\" =~ /(?(?<=foo)bar|cat)/" "(?(?<=foo)bar|cat)" nil nil nil nil "foobar" nil "bar" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(919 "\"cat\" =~ /(?(?<=foo)bar|cat)/" "(?(?<=foo)bar|cat)" nil nil nil nil "cat" nil "cat" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(920 "\"fcat\" =~ /(?(?<=foo)bar|cat)/" "(?(?<=foo)bar|cat)" nil nil nil nil "fcat" nil "cat" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(921 "\"focat\" =~ /(?(?<=foo)bar|cat)/" "(?(?<=foo)bar|cat)" nil nil nil nil "focat" nil "cat" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(922 "\"foocat\" =~ /(?(?<=foo)bar|cat)/" "(?(?<=foo)bar|cat)" nil nil nil nil "foocat" nil nil nil)
+(923 "\"foobar\" =~ /(?(?<!foo)cat|bar)/" "(?(?<!foo)cat|bar)" nil nil nil nil "foobar" nil "bar" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(924 "\"cat\" =~ /(?(?<!foo)cat|bar)/" "(?(?<!foo)cat|bar)" nil nil nil nil "cat" nil "cat" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(925 "\"fcat\" =~ /(?(?<!foo)cat|bar)/" "(?(?<!foo)cat|bar)" nil nil nil nil "fcat" nil "cat" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(926 "\"focat\" =~ /(?(?<!foo)cat|bar)/" "(?(?<!foo)cat|bar)" nil nil nil nil "focat" nil "cat" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(927 "\"foocat\" =~ /(?(?<!foo)cat|bar)/" "(?(?<!foo)cat|bar)" nil nil nil nil "foocat" nil nil nil)
+(928 "\"abcd\" =~ /( \\( )? [^()]+ (?(1) \\) |) /x" "( \\( )? [^()]+ (?(1) \\) |) " nil nil nil t "abcd" nil "abcd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(929 "\"(abcd)\" =~ /( \\( )? [^()]+ (?(1) \\) |) /x" "( \\( )? [^()]+ (?(1) \\) |) " nil nil nil t "(abcd)" nil "(abcd)" ("(" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(930 "\"the quick (abcd) fox\" =~ /( \\( )? [^()]+ (?(1) \\) |) /x" "( \\( )? [^()]+ (?(1) \\) |) " nil nil nil t "the quick (abcd) fox" nil "the quick " (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(931 "\"(abcd\" =~ /( \\( )? [^()]+ (?(1) \\) |) /x" "( \\( )? [^()]+ (?(1) \\) |) " nil nil nil t "(abcd" nil "abcd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(932 "\"abcd\" =~ /( \\( )? [^()]+ (?(1) \\) ) /x" "( \\( )? [^()]+ (?(1) \\) ) " nil nil nil t "abcd" nil "abcd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(933 "\"(abcd)\" =~ /( \\( )? [^()]+ (?(1) \\) ) /x" "( \\( )? [^()]+ (?(1) \\) ) " nil nil nil t "(abcd)" nil "(abcd)" ("(" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(934 "\"the quick (abcd) fox\" =~ /( \\( )? [^()]+ (?(1) \\) ) /x" "( \\( )? [^()]+ (?(1) \\) ) " nil nil nil t "the quick (abcd) fox" nil "the quick " (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(935 "\"(abcd\" =~ /( \\( )? [^()]+ (?(1) \\) ) /x" "( \\( )? [^()]+ (?(1) \\) ) " nil nil nil t "(abcd" nil "abcd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(936 "\"12\" =~ /^(?(2)a|(1)(2))+$/" "^(?(2)a|(1)(2))+$" nil nil nil nil "12" nil "12" ("1" "2" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(937 "\"12a\" =~ /^(?(2)a|(1)(2))+$/" "^(?(2)a|(1)(2))+$" nil nil nil nil "12a" nil "12a" ("1" "2" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(938 "\"12aa\" =~ /^(?(2)a|(1)(2))+$/" "^(?(2)a|(1)(2))+$" nil nil nil nil "12aa" nil "12aa" ("1" "2" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(939 "\"1234\" =~ /^(?(2)a|(1)(2))+$/" "^(?(2)a|(1)(2))+$" nil nil nil nil "1234" nil nil nil)
+(940 "\"blah blah\" =~ /((?i)blah)\\s+\\1/" "((?i)blah)\\s+\\1" nil nil nil nil "blah blah" nil "blah blah" ("blah" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(941 "\"BLAH BLAH\" =~ /((?i)blah)\\s+\\1/" "((?i)blah)\\s+\\1" nil nil nil nil "BLAH BLAH" nil "BLAH BLAH" ("BLAH" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(942 "\"Blah Blah\" =~ /((?i)blah)\\s+\\1/" "((?i)blah)\\s+\\1" nil nil nil nil "Blah Blah" nil "Blah Blah" ("Blah" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(943 "\"blaH blaH\" =~ /((?i)blah)\\s+\\1/" "((?i)blah)\\s+\\1" nil nil nil nil "blaH blaH" nil "blaH blaH" ("blaH" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(944 "\"blah BLAH\" =~ /((?i)blah)\\s+\\1/" "((?i)blah)\\s+\\1" nil nil nil nil "blah BLAH" nil nil nil)
+(945 "\"Blah blah\" =~ /((?i)blah)\\s+\\1/" "((?i)blah)\\s+\\1" nil nil nil nil "Blah blah" nil nil nil)
+(946 "\"blaH blah\" =~ /((?i)blah)\\s+\\1/" "((?i)blah)\\s+\\1" nil nil nil nil "blaH blah" nil nil nil)
+(947 "\"blah blah\" =~ /((?i)blah)\\s+(?i:\\1)/" "((?i)blah)\\s+(?i:\\1)" nil nil nil nil "blah blah" nil "blah blah" ("blah" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(948 "\"BLAH BLAH\" =~ /((?i)blah)\\s+(?i:\\1)/" "((?i)blah)\\s+(?i:\\1)" nil nil nil nil "BLAH BLAH" nil "BLAH BLAH" ("BLAH" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(949 "\"Blah Blah\" =~ /((?i)blah)\\s+(?i:\\1)/" "((?i)blah)\\s+(?i:\\1)" nil nil nil nil "Blah Blah" nil "Blah Blah" ("Blah" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(950 "\"blaH blaH\" =~ /((?i)blah)\\s+(?i:\\1)/" "((?i)blah)\\s+(?i:\\1)" nil nil nil nil "blaH blaH" nil "blaH blaH" ("blaH" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(951 "\"blah BLAH\" =~ /((?i)blah)\\s+(?i:\\1)/" "((?i)blah)\\s+(?i:\\1)" nil nil nil nil "blah BLAH" nil "blah BLAH" ("blah" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(952 "\"Blah blah\" =~ /((?i)blah)\\s+(?i:\\1)/" "((?i)blah)\\s+(?i:\\1)" nil nil nil nil "Blah blah" nil "Blah blah" ("Blah" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(953 "\"blaH blah\" =~ /((?i)blah)\\s+(?i:\\1)/" "((?i)blah)\\s+(?i:\\1)" nil nil nil nil "blaH blah" nil "blaH blah" ("blaH" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(954 "\"a\" =~ /(?>a*)*/" "(?>a*)*" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(955 "\"aa\" =~ /(?>a*)*/" "(?>a*)*" nil nil nil nil "aa" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(956 "\"aaaa\" =~ /(?>a*)*/" "(?>a*)*" nil nil nil nil "aaaa" nil "aaaa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(957 "\"abc\" =~ /(abc|)+/" "(abc|)+" nil nil nil nil "abc" nil "abc" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(958 "\"abcabc\" =~ /(abc|)+/" "(abc|)+" nil nil nil nil "abcabc" nil "abcabc" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(959 "\"abcabcabc\" =~ /(abc|)+/" "(abc|)+" nil nil nil nil "abcabcabc" nil "abcabcabc" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(960 "\"xyz\" =~ /(abc|)+/" "(abc|)+" nil nil nil nil "xyz" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(961 "\"a\" =~ /([a]*)*/" "([a]*)*" nil nil nil nil "a" nil "a" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(962 "\"aaaaa\" =~ /([a]*)*/" "([a]*)*" nil nil nil nil "aaaaa" nil "aaaaa" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(963 "\"a\" =~ /([ab]*)*/" "([ab]*)*" nil nil nil nil "a" nil "a" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(964 "\"b\" =~ /([ab]*)*/" "([ab]*)*" nil nil nil nil "b" nil "b" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(965 "\"ababab\" =~ /([ab]*)*/" "([ab]*)*" nil nil nil nil "ababab" nil "ababab" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(966 "\"aaaabcde\" =~ /([ab]*)*/" "([ab]*)*" nil nil nil nil "aaaabcde" nil "aaaab" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(967 "\"bbbb\" =~ /([ab]*)*/" "([ab]*)*" nil nil nil nil "bbbb" nil "bbbb" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(968 "\"b\" =~ /([^a]*)*/" "([^a]*)*" nil nil nil nil "b" nil "b" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(969 "\"bbbb\" =~ /([^a]*)*/" "([^a]*)*" nil nil nil nil "bbbb" nil "bbbb" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(970 "\"aaa\" =~ /([^a]*)*/" "([^a]*)*" nil nil nil nil "aaa" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(971 "\"cccc\" =~ /([^ab]*)*/" "([^ab]*)*" nil nil nil nil "cccc" nil "cccc" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(972 "\"abab\" =~ /([^ab]*)*/" "([^ab]*)*" nil nil nil nil "abab" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(973 "\"a\" =~ /([a]*?)*/" "([a]*?)*" nil nil nil nil "a" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(974 "\"aaaa\" =~ /([a]*?)*/" "([a]*?)*" nil nil nil nil "aaaa" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(975 "\"a\" =~ /([ab]*?)*/" "([ab]*?)*" nil nil nil nil "a" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(976 "\"b\" =~ /([ab]*?)*/" "([ab]*?)*" nil nil nil nil "b" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(977 "\"abab\" =~ /([ab]*?)*/" "([ab]*?)*" nil nil nil nil "abab" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(978 "\"baba\" =~ /([ab]*?)*/" "([ab]*?)*" nil nil nil nil "baba" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(979 "\"b\" =~ /([^a]*?)*/" "([^a]*?)*" nil nil nil nil "b" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(980 "\"bbbb\" =~ /([^a]*?)*/" "([^a]*?)*" nil nil nil nil "bbbb" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(981 "\"aaa\" =~ /([^a]*?)*/" "([^a]*?)*" nil nil nil nil "aaa" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(982 "\"c\" =~ /([^ab]*?)*/" "([^ab]*?)*" nil nil nil nil "c" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(983 "\"cccc\" =~ /([^ab]*?)*/" "([^ab]*?)*" nil nil nil nil "cccc" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(984 "\"baba\" =~ /([^ab]*?)*/" "([^ab]*?)*" nil nil nil nil "baba" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(985 "\"a\" =~ /(?>a*)*/" "(?>a*)*" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(986 "\"aaabcde\" =~ /(?>a*)*/" "(?>a*)*" nil nil nil nil "aaabcde" nil "aaa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(987 "\"aaaaa\" =~ /((?>a*))*/" "((?>a*))*" nil nil nil nil "aaaaa" nil "aaaaa" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(988 "\"aabbaa\" =~ /((?>a*))*/" "((?>a*))*" nil nil nil nil "aabbaa" nil "aa" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(989 "\"aaaaa\" =~ /((?>a*?))*/" "((?>a*?))*" nil nil nil nil "aaaaa" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(990 "\"aabbaa\" =~ /((?>a*?))*/" "((?>a*?))*" nil nil nil nil "aabbaa" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(991 "\"12-sep-98\" =~ /(?(?=[^a-z]+[a-z])  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} ) /x" "(?(?=[^a-z]+[a-z])  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} ) " nil nil nil t "12-sep-98" nil "12-sep-98" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(992 "\"12-09-98\" =~ /(?(?=[^a-z]+[a-z])  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} ) /x" "(?(?=[^a-z]+[a-z])  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} ) " nil nil nil t "12-09-98" nil "12-09-98" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(993 "\"sep-12-98\" =~ /(?(?=[^a-z]+[a-z])  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} ) /x" "(?(?=[^a-z]+[a-z])  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} ) " nil nil nil t "sep-12-98" nil nil nil)
+(994 "\"foobarfoo\" =~ /(?<=(foo))bar\\1/" "(?<=(foo))bar\\1" nil nil nil nil "foobarfoo" nil "barfoo" ("foo" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(995 "\"foobarfootling\" =~ /(?<=(foo))bar\\1/" "(?<=(foo))bar\\1" nil nil nil nil "foobarfootling" nil "barfoo" ("foo" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(996 "\"foobar\" =~ /(?<=(foo))bar\\1/" "(?<=(foo))bar\\1" nil nil nil nil "foobar" nil nil nil)
+(997 "\"barfoo\" =~ /(?<=(foo))bar\\1/" "(?<=(foo))bar\\1" nil nil nil nil "barfoo" nil nil nil)
+(998 "\"saturday\" =~ /(?i:saturday|sunday)/" "(?i:saturday|sunday)" nil nil nil nil "saturday" nil "saturday" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(999 "\"sunday\" =~ /(?i:saturday|sunday)/" "(?i:saturday|sunday)" nil nil nil nil "sunday" nil "sunday" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1000 "\"Saturday\" =~ /(?i:saturday|sunday)/" "(?i:saturday|sunday)" nil nil nil nil "Saturday" nil "Saturday" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1001 "\"Sunday\" =~ /(?i:saturday|sunday)/" "(?i:saturday|sunday)" nil nil nil nil "Sunday" nil "Sunday" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1002 "\"SATURDAY\" =~ /(?i:saturday|sunday)/" "(?i:saturday|sunday)" nil nil nil nil "SATURDAY" nil "SATURDAY" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1003 "\"SUNDAY\" =~ /(?i:saturday|sunday)/" "(?i:saturday|sunday)" nil nil nil nil "SUNDAY" nil "SUNDAY" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1004 "\"SunDay\" =~ /(?i:saturday|sunday)/" "(?i:saturday|sunday)" nil nil nil nil "SunDay" nil "SunDay" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1005 "\"abcx\" =~ /(a(?i)bc|BB)x/" "(a(?i)bc|BB)x" nil nil nil nil "abcx" nil "abcx" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1006 "\"aBCx\" =~ /(a(?i)bc|BB)x/" "(a(?i)bc|BB)x" nil nil nil nil "aBCx" nil "aBCx" ("aBC" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1007 "\"bbx\" =~ /(a(?i)bc|BB)x/" "(a(?i)bc|BB)x" nil nil nil nil "bbx" nil "bbx" ("bb" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1008 "\"BBx\" =~ /(a(?i)bc|BB)x/" "(a(?i)bc|BB)x" nil nil nil nil "BBx" nil "BBx" ("BB" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1009 "\"abcX\" =~ /(a(?i)bc|BB)x/" "(a(?i)bc|BB)x" nil nil nil nil "abcX" nil nil nil)
+(1010 "\"aBCX\" =~ /(a(?i)bc|BB)x/" "(a(?i)bc|BB)x" nil nil nil nil "aBCX" nil nil nil)
+(1011 "\"bbX\" =~ /(a(?i)bc|BB)x/" "(a(?i)bc|BB)x" nil nil nil nil "bbX" nil nil nil)
+(1012 "\"BBX\" =~ /(a(?i)bc|BB)x/" "(a(?i)bc|BB)x" nil nil nil nil "BBX" nil nil nil)
+(1013 "\"ac\" =~ /^([ab](?i)[cd]|[ef])/" "^([ab](?i)[cd]|[ef])" nil nil nil nil "ac" nil "ac" ("ac" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1014 "\"aC\" =~ /^([ab](?i)[cd]|[ef])/" "^([ab](?i)[cd]|[ef])" nil nil nil nil "aC" nil "aC" ("aC" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1015 "\"bD\" =~ /^([ab](?i)[cd]|[ef])/" "^([ab](?i)[cd]|[ef])" nil nil nil nil "bD" nil "bD" ("bD" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1016 "\"elephant\" =~ /^([ab](?i)[cd]|[ef])/" "^([ab](?i)[cd]|[ef])" nil nil nil nil "elephant" nil "e" ("e" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1017 "\"Europe\" =~ /^([ab](?i)[cd]|[ef])/" "^([ab](?i)[cd]|[ef])" nil nil nil nil "Europe" nil "E" ("E" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1018 "\"frog\" =~ /^([ab](?i)[cd]|[ef])/" "^([ab](?i)[cd]|[ef])" nil nil nil nil "frog" nil "f" ("f" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1019 "\"France\" =~ /^([ab](?i)[cd]|[ef])/" "^([ab](?i)[cd]|[ef])" nil nil nil nil "France" nil "F" ("F" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1020 "\"Africa\" =~ /^([ab](?i)[cd]|[ef])/" "^([ab](?i)[cd]|[ef])" nil nil nil nil "Africa" nil nil nil)
+(1021 "\"ab\" =~ /^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)/" "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)" nil nil nil nil "ab" nil "ab" ("ab" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1022 "\"aBd\" =~ /^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)/" "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)" nil nil nil nil "aBd" nil "aBd" ("aBd" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1023 "\"xy\" =~ /^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)/" "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)" nil nil nil nil "xy" nil "xy" ("xy" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1024 "\"xY\" =~ /^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)/" "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)" nil nil nil nil "xY" nil "xY" ("xY" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1025 "\"zebra\" =~ /^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)/" "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)" nil nil nil nil "zebra" nil "z" ("z" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1026 "\"Zambesi\" =~ /^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)/" "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)" nil nil nil nil "Zambesi" nil "Z" ("Z" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1027 "\"aCD\" =~ /^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)/" "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)" nil nil nil nil "aCD" nil nil nil)
+(1028 "\"XY\" =~ /^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)/" "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)" nil nil nil nil "XY" nil nil nil)
+(1029 "\"foo\\nbar\" =~ /(?<=foo\\n)^bar/m" "(?<=foo\\n)^bar" nil t nil nil "foo
+bar" nil "bar" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1030 "\"bar\" =~ /(?<=foo\\n)^bar/m" "(?<=foo\\n)^bar" nil t nil nil "bar" nil nil nil)
+(1031 "\"baz\\nbar\" =~ /(?<=foo\\n)^bar/m" "(?<=foo\\n)^bar" nil t nil nil "baz
+bar" nil nil nil)
+(1032 "\"barbaz\" =~ /(?<=(?<!foo)bar)baz/" "(?<=(?<!foo)bar)baz" nil nil nil nil "barbaz" nil "baz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1033 "\"barbarbaz\" =~ /(?<=(?<!foo)bar)baz/" "(?<=(?<!foo)bar)baz" nil nil nil nil "barbarbaz" nil "baz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1034 "\"koobarbaz\" =~ /(?<=(?<!foo)bar)baz/" "(?<=(?<!foo)bar)baz" nil nil nil nil "koobarbaz" nil "baz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1035 "\"baz\" =~ /(?<=(?<!foo)bar)baz/" "(?<=(?<!foo)bar)baz" nil nil nil nil "baz" nil nil nil)
+(1036 "\"foobarbaz\" =~ /(?<=(?<!foo)bar)baz/" "(?<=(?<!foo)bar)baz" nil nil nil nil "foobarbaz" nil nil nil)
+(1037 "\"a\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "a" nil nil nil)
+(1038 "\"aa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aa" nil nil nil)
+(1039 "\"aaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaa" nil nil nil)
+(1040 "\"aaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaa" nil "aaaa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1041 "\"aaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaa" nil "aaaaa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1042 "\"aaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaa" nil "aaaaaa" ("aa" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1043 "\"aaaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaaa" nil "aaaaaaa" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1044 "\"aaaaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaaaa" nil nil nil)
+(1045 "\"aaaaaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaaaaa" nil nil nil)
+(1046 "\"aaaaaaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaaaaaa" nil "aaaaaaaaaa" ("aaaa" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1047 "\"aaaaaaaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaaaaaaa" nil nil nil)
+(1048 "\"aaaaaaaaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaaaaaaaa" nil nil nil)
+(1049 "\"aaaaaaaaaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaaaaaaaaa" nil nil nil)
+(1050 "\"aaaaaaaaaaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaaaaaaaaaa" nil nil nil)
+(1051 "\"aaaaaaaaaaaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaaaaaaaaaaa" nil nil nil)
+(1052 "\"aaaaaaaaaaaaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaaaaaaaaaaaa" nil nil nil)
+(1053 "\"a\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "a" nil nil nil)
+(1054 "\"aa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aa" nil nil nil)
+(1055 "\"aaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaa" nil nil nil)
+(1056 "\"aaaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaaa" nil "aaaa" ("a" "a" "a" "a" nil nil nil nil nil nil nil nil nil nil nil nil))
+(1057 "\"aaaaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaaaa" nil "aaaaa" ("a" "aa" "a" "a" nil nil nil nil nil nil nil nil nil nil nil nil))
+(1058 "\"aaaaaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaaaaa" nil "aaaaaa" ("a" "aa" "a" "aa" nil nil nil nil nil nil nil nil nil nil nil nil))
+(1059 "\"aaaaaaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaaaaaa" nil "aaaaaaa" ("a" "aa" "aaa" "a" nil nil nil nil nil nil nil nil nil nil nil nil))
+(1060 "\"aaaaaaaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaaaaaaa" nil nil nil)
+(1061 "\"aaaaaaaaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaaaaaaaa" nil nil nil)
+(1062 "\"aaaaaaaaaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaaaaaaaaa" nil "aaaaaaaaaa" ("a" "aa" "aaa" "aaaa" nil nil nil nil nil nil nil nil nil nil nil nil))
+(1063 "\"aaaaaaaaaaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaaaaaaaaaa" nil nil nil)
+(1064 "\"aaaaaaaaaaaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaaaaaaaaaaa" nil nil nil)
+(1065 "\"aaaaaaaaaaaaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaaaaaaaaaaaa" nil nil nil)
+(1066 "\"aaaaaaaaaaaaaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaaaaaaaaaaaaa" nil nil nil)
+(1067 "\"aaaaaaaaaaaaaaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaaaaaaaaaaaaaa" nil nil nil)
+(1068 "\"aaaaaaaaaaaaaaaa\" =~ /^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$/" "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$" nil nil nil nil "aaaaaaaaaaaaaaaa" nil nil nil)
+(1069 "\"abc\" =~ /abc/" "abc" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1070 "\"xabcy\" =~ /abc/" "abc" nil nil nil nil "xabcy" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1071 "\"ababc\" =~ /abc/" "abc" nil nil nil nil "ababc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1072 "\"xbc\" =~ /abc/" "abc" nil nil nil nil "xbc" nil nil nil)
+(1073 "\"axc\" =~ /abc/" "abc" nil nil nil nil "axc" nil nil nil)
+(1074 "\"abx\" =~ /abc/" "abc" nil nil nil nil "abx" nil nil nil)
+(1075 "\"abc\" =~ /ab*c/" "ab*c" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1076 "\"abc\" =~ /ab*bc/" "ab*bc" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1077 "\"abbc\" =~ /ab*bc/" "ab*bc" nil nil nil nil "abbc" nil "abbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1078 "\"abbbbc\" =~ /ab*bc/" "ab*bc" nil nil nil nil "abbbbc" nil "abbbbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1079 "\"abbbbc\" =~ /.{1}/" ".{1}" nil nil nil nil "abbbbc" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1080 "\"abbbbc\" =~ /.{3,4}/" ".{3,4}" nil nil nil nil "abbbbc" nil "abbb" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1081 "\"abbbbc\" =~ /ab{0,}bc/" "ab{0,}bc" nil nil nil nil "abbbbc" nil "abbbbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1082 "\"abbc\" =~ /ab+bc/" "ab+bc" nil nil nil nil "abbc" nil "abbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1083 "\"abc\" =~ /ab+bc/" "ab+bc" nil nil nil nil "abc" nil nil nil)
+(1084 "\"abq\" =~ /ab+bc/" "ab+bc" nil nil nil nil "abq" nil nil nil)
+(1085 "\"abbbbc\" =~ /ab+bc/" "ab+bc" nil nil nil nil "abbbbc" nil "abbbbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1086 "\"abbbbc\" =~ /ab{1,}bc/" "ab{1,}bc" nil nil nil nil "abbbbc" nil "abbbbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1087 "\"abbbbc\" =~ /ab{1,3}bc/" "ab{1,3}bc" nil nil nil nil "abbbbc" nil "abbbbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1088 "\"abbbbc\" =~ /ab{3,4}bc/" "ab{3,4}bc" nil nil nil nil "abbbbc" nil "abbbbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1089 "\"abq\" =~ /ab{4,5}bc/" "ab{4,5}bc" nil nil nil nil "abq" nil nil nil)
+(1090 "\"abbbbc\" =~ /ab{4,5}bc/" "ab{4,5}bc" nil nil nil nil "abbbbc" nil nil nil)
+(1091 "\"abbc\" =~ /ab?bc/" "ab?bc" nil nil nil nil "abbc" nil "abbc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1092 "\"abc\" =~ /ab?bc/" "ab?bc" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1093 "\"abc\" =~ /ab{0,1}bc/" "ab{0,1}bc" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1094 "\"abc\" =~ /ab?c/" "ab?c" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1095 "\"abc\" =~ /ab{0,1}c/" "ab{0,1}c" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1096 "\"abc\" =~ /^abc$/" "^abc$" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1097 "\"abbbbc\" =~ /^abc$/" "^abc$" nil nil nil nil "abbbbc" nil nil nil)
+(1098 "\"abcc\" =~ /^abc$/" "^abc$" nil nil nil nil "abcc" nil nil nil)
+(1099 "\"abcc\" =~ /^abc/" "^abc" nil nil nil nil "abcc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1100 "\"aabc\" =~ /abc$/" "abc$" nil nil nil nil "aabc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1101 "\"aabc\" =~ /abc$/" "abc$" nil nil nil nil "aabc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1102 "\"aabcd\" =~ /abc$/" "abc$" nil nil nil nil "aabcd" nil nil nil)
+(1103 "\"abc\" =~ /^/" "^" nil nil nil nil "abc" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1104 "\"abc\" =~ /$/" "$" nil nil nil nil "abc" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1105 "\"abc\" =~ /a.c/" "a.c" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1106 "\"axc\" =~ /a.c/" "a.c" nil nil nil nil "axc" nil "axc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1107 "\"axyzc\" =~ /a.*c/" "a.*c" nil nil nil nil "axyzc" nil "axyzc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1108 "\"abd\" =~ /a[bc]d/" "a[bc]d" nil nil nil nil "abd" nil "abd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1109 "\"axyzd\" =~ /a[bc]d/" "a[bc]d" nil nil nil nil "axyzd" nil nil nil)
+(1110 "\"abc\" =~ /a[bc]d/" "a[bc]d" nil nil nil nil "abc" nil nil nil)
+(1111 "\"ace\" =~ /a[b-d]e/" "a[b-d]e" nil nil nil nil "ace" nil "ace" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1112 "\"aac\" =~ /a[b-d]/" "a[b-d]" nil nil nil nil "aac" nil "ac" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1113 "\"a-\" =~ /a[-b]/" "a[-b]" nil nil nil nil "a-" nil "a-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1114 "\"a-\" =~ /a[b-]/" "a[b-]" nil nil nil nil "a-" nil "a-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1115 "\"a]\" =~ /a]/" "a]" nil nil nil nil "a]" nil "a]" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1116 "\"a]b\" =~ /a[]]b/" "a[]]b" nil nil nil nil "a]b" nil "a]b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1117 "\"aed\" =~ /a[^bc]d/" "a[^bc]d" nil nil nil nil "aed" nil "aed" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1118 "\"abd\" =~ /a[^bc]d/" "a[^bc]d" nil nil nil nil "abd" nil nil nil)
+(1119 "\"abd\" =~ /a[^bc]d/" "a[^bc]d" nil nil nil nil "abd" nil nil nil)
+(1120 "\"adc\" =~ /a[^-b]c/" "a[^-b]c" nil nil nil nil "adc" nil "adc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1121 "\"adc\" =~ /a[^]b]c/" "a[^]b]c" nil nil nil nil "adc" nil "adc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1122 "\"a-c\" =~ /a[^]b]c/" "a[^]b]c" nil nil nil nil "a-c" nil "a-c" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1123 "\"a]c\" =~ /a[^]b]c/" "a[^]b]c" nil nil nil nil "a]c" nil nil nil)
+(1124 "\"a-\" =~ /\\ba\\b/" "\\ba\\b" nil nil nil nil "a-" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1125 "\"-a\" =~ /\\ba\\b/" "\\ba\\b" nil nil nil nil "-a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1126 "\"-a-\" =~ /\\ba\\b/" "\\ba\\b" nil nil nil nil "-a-" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1127 "\"xy\" =~ /\\by\\b/" "\\by\\b" nil nil nil nil "xy" nil nil nil)
+(1128 "\"yz\" =~ /\\by\\b/" "\\by\\b" nil nil nil nil "yz" nil nil nil)
+(1129 "\"xyz\" =~ /\\by\\b/" "\\by\\b" nil nil nil nil "xyz" nil nil nil)
+(1130 "\"a-\" =~ /\\Ba\\B/" "\\Ba\\B" nil nil nil nil "a-" nil nil nil)
+(1131 "\"-a\" =~ /\\Ba\\B/" "\\Ba\\B" nil nil nil nil "-a" nil nil nil)
+(1132 "\"-a-\" =~ /\\Ba\\B/" "\\Ba\\B" nil nil nil nil "-a-" nil nil nil)
+(1133 "\"xy\" =~ /\\By\\b/" "\\By\\b" nil nil nil nil "xy" nil "y" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1134 "\"yz\" =~ /\\by\\B/" "\\by\\B" nil nil nil nil "yz" nil "y" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1135 "\"xyz\" =~ /\\By\\B/" "\\By\\B" nil nil nil nil "xyz" nil "y" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1136 "\"a\" =~ /\\w/" "\\w" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1137 "\"-\" =~ /\\W/" "\\W" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1138 "\"-\" =~ /\\W/" "\\W" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1139 "\"a\" =~ /\\W/" "\\W" nil nil nil nil "a" nil nil nil)
+(1140 "\"a b\" =~ /a\\sb/" "a\\sb" nil nil nil nil "a b" nil "a b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1141 "\"a-b\" =~ /a\\Sb/" "a\\Sb" nil nil nil nil "a-b" nil "a-b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1142 "\"a-b\" =~ /a\\Sb/" "a\\Sb" nil nil nil nil "a-b" nil "a-b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1143 "\"a b\" =~ /a\\Sb/" "a\\Sb" nil nil nil nil "a b" nil nil nil)
+(1144 "\"1\" =~ /\\d/" "\\d" nil nil nil nil "1" nil "1" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1145 "\"-\" =~ /\\D/" "\\D" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1146 "\"-\" =~ /\\D/" "\\D" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1147 "\"1\" =~ /\\D/" "\\D" nil nil nil nil "1" nil nil nil)
+(1148 "\"a\" =~ /[\\w]/" "[\\w]" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1149 "\"-\" =~ /[\\W]/" "[\\W]" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1150 "\"-\" =~ /[\\W]/" "[\\W]" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1151 "\"a\" =~ /[\\W]/" "[\\W]" nil nil nil nil "a" nil nil nil)
+(1152 "\"a b\" =~ /a[\\s]b/" "a[\\s]b" nil nil nil nil "a b" nil "a b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1153 "\"a-b\" =~ /a[\\S]b/" "a[\\S]b" nil nil nil nil "a-b" nil "a-b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1154 "\"a-b\" =~ /a[\\S]b/" "a[\\S]b" nil nil nil nil "a-b" nil "a-b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1155 "\"a b\" =~ /a[\\S]b/" "a[\\S]b" nil nil nil nil "a b" nil nil nil)
+(1156 "\"1\" =~ /[\\d]/" "[\\d]" nil nil nil nil "1" nil "1" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1157 "\"-\" =~ /[\\D]/" "[\\D]" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1158 "\"-\" =~ /[\\D]/" "[\\D]" nil nil nil nil "-" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1159 "\"1\" =~ /[\\D]/" "[\\D]" nil nil nil nil "1" nil nil nil)
+(1160 "\"abc\" =~ /ab|cd/" "ab|cd" nil nil nil nil "abc" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1161 "\"abcd\" =~ /ab|cd/" "ab|cd" nil nil nil nil "abcd" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1162 "\"def\" =~ /()ef/" "()ef" nil nil nil nil "def" nil "ef" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1163 "\"a(b\" =~ /a\\(b/" "a\\(b" nil nil nil nil "a(b" nil "a(b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1164 "\"ab\" =~ /a\\(*b/" "a\\(*b" nil nil nil nil "ab" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1165 "\"a((b\" =~ /a\\(*b/" "a\\(*b" nil nil nil nil "a((b" nil "a((b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1166 "\"a\\b\" =~ /a\\\\b/" "a\\\\b" nil nil nil nil ("a" 8) nil nil nil)
+(1167 "\"abc\" =~ /((a))/" "((a))" nil nil nil nil "abc" nil "a" ("a" "a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1168 "\"abc\" =~ /(a)b(c)/" "(a)b(c)" nil nil nil nil "abc" nil "abc" ("a" "c" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1169 "\"aabbabc\" =~ /a+b+c/" "a+b+c" nil nil nil nil "aabbabc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1170 "\"aabbabc\" =~ /a{1,}b{1,}c/" "a{1,}b{1,}c" nil nil nil nil "aabbabc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1171 "\"abcabc\" =~ /a.+?c/" "a.+?c" nil nil nil nil "abcabc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1172 "\"ab\" =~ /(a+|b)*/" "(a+|b)*" nil nil nil nil "ab" nil "ab" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1173 "\"ab\" =~ /(a+|b){0,}/" "(a+|b){0,}" nil nil nil nil "ab" nil "ab" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1174 "\"ab\" =~ /(a+|b)+/" "(a+|b)+" nil nil nil nil "ab" nil "ab" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1175 "\"ab\" =~ /(a+|b){1,}/" "(a+|b){1,}" nil nil nil nil "ab" nil "ab" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1176 "\"ab\" =~ /(a+|b)?/" "(a+|b)?" nil nil nil nil "ab" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1177 "\"ab\" =~ /(a+|b){0,1}/" "(a+|b){0,1}" nil nil nil nil "ab" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1178 "\"cde\" =~ /[^ab]*/" "[^ab]*" nil nil nil nil "cde" nil "cde" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1179 "\"b\" =~ /abc/" "abc" nil nil nil nil "b" nil nil nil)
+(1180 "\"abbbcd\" =~ 
+/([abc])*d/" "([abc])*d" nil nil nil nil "abbbcd" nil "abbbcd" ("c" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1181 "\"abcd\" =~ /([abc])*bcd/" "([abc])*bcd" nil nil nil nil "abcd" nil "abcd" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1182 "\"e\" =~ /a|b|c|d|e/" "a|b|c|d|e" nil nil nil nil "e" nil "e" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1183 "\"ef\" =~ /(a|b|c|d|e)f/" "(a|b|c|d|e)f" nil nil nil nil "ef" nil "ef" ("e" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1184 "\"abcdefg\" =~ /abcd*efg/" "abcd*efg" nil nil nil nil "abcdefg" nil "abcdefg" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1185 "\"xabyabbbz\" =~ /ab*/" "ab*" nil nil nil nil "xabyabbbz" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1186 "\"xayabbbz\" =~ /ab*/" "ab*" nil nil nil nil "xayabbbz" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1187 "\"abcde\" =~ /(ab|cd)e/" "(ab|cd)e" nil nil nil nil "abcde" nil "cde" ("cd" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1188 "\"hij\" =~ /[abhgefdc]ij/" "[abhgefdc]ij" nil nil nil nil "hij" nil "hij" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1189 "\"abcdef\" =~ /(abc|)ef/" "(abc|)ef" nil nil nil nil "abcdef" nil "ef" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1190 "\"abcd\" =~ /(a|b)c*d/" "(a|b)c*d" nil nil nil nil "abcd" nil "bcd" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1191 "\"abc\" =~ /(ab|ab*)bc/" "(ab|ab*)bc" nil nil nil nil "abc" nil "abc" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1192 "\"abc\" =~ /a([bc]*)c*/" "a([bc]*)c*" nil nil nil nil "abc" nil "abc" ("bc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1193 "\"abcd\" =~ /a([bc]*)(c*d)/" "a([bc]*)(c*d)" nil nil nil nil "abcd" nil "abcd" ("bc" "d" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1194 "\"abcd\" =~ /a([bc]+)(c*d)/" "a([bc]+)(c*d)" nil nil nil nil "abcd" nil "abcd" ("bc" "d" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1195 "\"abcd\" =~ /a([bc]*)(c+d)/" "a([bc]*)(c+d)" nil nil nil nil "abcd" nil "abcd" ("b" "cd" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1196 "\"adcdcde\" =~ /a[bcd]*dcdcde/" "a[bcd]*dcdcde" nil nil nil nil "adcdcde" nil "adcdcde" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1197 "\"abcde\" =~ /a[bcd]+dcdcde/" "a[bcd]+dcdcde" nil nil nil nil "abcde" nil nil nil)
+(1198 "\"adcdcde\" =~ /a[bcd]+dcdcde/" "a[bcd]+dcdcde" nil nil nil nil "adcdcde" nil nil nil)
+(1199 "\"abc\" =~ /(ab|a)b*c/" "(ab|a)b*c" nil nil nil nil "abc" nil "abc" ("ab" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1200 "\"abcd\" =~ /((a)(b)c)(d)/" "((a)(b)c)(d)" nil nil nil nil "abcd" nil "abcd" ("abc" "a" "b" "d" nil nil nil nil nil nil nil nil nil nil nil nil))
+(1201 "\"alpha\" =~ /[a-zA-Z_][a-zA-Z0-9_]*/" "[a-zA-Z_][a-zA-Z0-9_]*" nil nil nil nil "alpha" nil "alpha" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1202 "\"abh\" =~ /^a(bc+|b[eh])g|.h$/" "^a(bc+|b[eh])g|.h$" nil nil nil nil "abh" nil "bh" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1203 "\"effgz\" =~ /(bc+d$|ef*g.|h?i(j|k))/" "(bc+d$|ef*g.|h?i(j|k))" nil nil nil nil "effgz" nil "effgz" ("effgz" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1204 "\"ij\" =~ /(bc+d$|ef*g.|h?i(j|k))/" "(bc+d$|ef*g.|h?i(j|k))" nil nil nil nil "ij" nil "ij" ("ij" "j" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1205 "\"reffgz\" =~ /(bc+d$|ef*g.|h?i(j|k))/" "(bc+d$|ef*g.|h?i(j|k))" nil nil nil nil "reffgz" nil "effgz" ("effgz" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1206 "\"effg\" =~ /(bc+d$|ef*g.|h?i(j|k))/" "(bc+d$|ef*g.|h?i(j|k))" nil nil nil nil "effg" nil nil nil)
+(1207 "\"bcdd\" =~ /(bc+d$|ef*g.|h?i(j|k))/" "(bc+d$|ef*g.|h?i(j|k))" nil nil nil nil "bcdd" nil nil nil)
+(1208 "\"a\" =~ /((((((((((a))))))))))/" "((((((((((a))))))))))" nil nil nil nil "a" nil "a" ("a" "a" "a" "a" "a" "a" "a" "a" "a" "a" nil nil nil nil nil nil))
+(1209 "\"aa\" =~ /((((((((((a))))))))))\\10/" "((((((((((a))))))))))\\10" nil nil nil nil "aa" nil "aa" ("a" "a" "a" "a" "a" "a" "a" "a" "a" "a" nil nil nil nil nil nil))
+(1210 "\"a\" =~ /(((((((((a)))))))))/" "(((((((((a)))))))))" nil nil nil nil "a" nil "a" ("a" "a" "a" "a" "a" "a" "a" "a" "a" nil nil nil nil nil nil nil))
+(1211 "\"aa\" =~ /multiple words of text/" "multiple words of text" nil nil nil nil "aa" nil nil nil)
+(1212 "\"uh-uh\" =~ /multiple words of text/" "multiple words of text" nil nil nil nil "uh-uh" nil nil nil)
+(1213 "\"multiple words, yeah\" =~ /multiple words/" "multiple words" nil nil nil nil "multiple words, yeah" nil "multiple words" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1214 "\"abcde\" =~ /(.*)c(.*)/" "(.*)c(.*)" nil nil nil nil "abcde" nil "abcde" ("ab" "de" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1215 "\"(a, b)\" =~ /\\((.*), (.*)\\)/" "\\((.*), (.*)\\)" nil nil nil nil "(a, b)" nil "(a, b)" ("a" "b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1216 "\"abcd\" =~ /abcd/" "abcd" nil nil nil nil "abcd" nil "abcd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1217 "\"abcd\" =~ /a(bc)d/" "a(bc)d" nil nil nil nil "abcd" nil "abcd" ("bc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1218 "\"ac\" =~ /a[-]?c/" "a[-]?c" nil nil nil nil "ac" nil "ac" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1219 "\"abcabc\" =~ /(abc)\\1/" "(abc)\\1" nil nil nil nil "abcabc" nil "abcabc" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1220 "\"abcabc\" =~ /([a-c]*)\\1/" "([a-c]*)\\1" nil nil nil nil "abcabc" nil "abcabc" ("abc" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1221 "\"a\" =~ /(a)|\\1/" "(a)|\\1" nil nil nil nil "a" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1222 "\"ab\" =~ /(a)|\\1/" "(a)|\\1" nil nil nil nil "ab" nil "a" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1223 "\"x\" =~ /(a)|\\1/" "(a)|\\1" nil nil nil nil "x" nil nil nil)
+(1224 "\"ababbbcbc\" =~ /(([a-c])b*?\\2)*/" "(([a-c])b*?\\2)*" nil nil nil nil "ababbbcbc" nil "ababb" ("bb" "b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1225 "\"ababbbcbc\" =~ /(([a-c])b*?\\2){3}/" "(([a-c])b*?\\2){3}" nil nil nil nil "ababbbcbc" nil "ababbbcbc" ("cbc" "c" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1226 "\"aaaxabaxbaaxbbax\" =~ /((\\3|b)\\2(a)x)+/" "((\\3|b)\\2(a)x)+" nil nil nil nil "aaaxabaxbaaxbbax" nil "bbax" ("bbax" "b" "a" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1227 "\"bbaababbabaaaaabbaaaabba\" =~ /((\\3|b)\\2(a)){2,}/" "((\\3|b)\\2(a)){2,}" nil nil nil nil "bbaababbabaaaaabbaaaabba" nil "bbaaaabba" ("bba" "b" "a" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1228 "\"ABC\" =~ /abc/i" "abc" t nil nil nil "ABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1229 "\"XABCY\" =~ /abc/i" "abc" t nil nil nil "XABCY" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1230 "\"ABABC\" =~ /abc/i" "abc" t nil nil nil "ABABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1231 "\"aaxabxbaxbbx\" =~ /abc/i" "abc" t nil nil nil "aaxabxbaxbbx" nil nil nil)
+(1232 "\"XBC\" =~ /abc/i" "abc" t nil nil nil "XBC" nil nil nil)
+(1233 "\"AXC\" =~ /abc/i" "abc" t nil nil nil "AXC" nil nil nil)
+(1234 "\"ABX\" =~ /abc/i" "abc" t nil nil nil "ABX" nil nil nil)
+(1235 "\"ABC\" =~ /ab*c/i" "ab*c" t nil nil nil "ABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1236 "\"ABC\" =~ /ab*bc/i" "ab*bc" t nil nil nil "ABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1237 "\"ABBC\" =~ /ab*bc/i" "ab*bc" t nil nil nil "ABBC" nil "ABBC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1238 "\"ABBBBC\" =~ /ab*?bc/i" "ab*?bc" t nil nil nil "ABBBBC" nil "ABBBBC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1239 "\"ABBBBC\" =~ /ab{0,}?bc/i" "ab{0,}?bc" t nil nil nil "ABBBBC" nil "ABBBBC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1240 "\"ABBC\" =~ /ab+?bc/i" "ab+?bc" t nil nil nil "ABBC" nil "ABBC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1241 "\"ABC\" =~ /ab+bc/i" "ab+bc" t nil nil nil "ABC" nil nil nil)
+(1242 "\"ABQ\" =~ /ab+bc/i" "ab+bc" t nil nil nil "ABQ" nil nil nil)
+(1243 "\"ABBBBC\" =~ /ab+bc/i" "ab+bc" t nil nil nil "ABBBBC" nil "ABBBBC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1244 "\"ABBBBC\" =~ /ab{1,}?bc/i" "ab{1,}?bc" t nil nil nil "ABBBBC" nil "ABBBBC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1245 "\"ABBBBC\" =~ /ab{1,3}?bc/i" "ab{1,3}?bc" t nil nil nil "ABBBBC" nil "ABBBBC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1246 "\"ABBBBC\" =~ /ab{3,4}?bc/i" "ab{3,4}?bc" t nil nil nil "ABBBBC" nil "ABBBBC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1247 "\"ABQ\" =~ /ab{4,5}?bc/i" "ab{4,5}?bc" t nil nil nil "ABQ" nil nil nil)
+(1248 "\"ABBBBC\" =~ /ab{4,5}?bc/i" "ab{4,5}?bc" t nil nil nil "ABBBBC" nil nil nil)
+(1249 "\"ABBC\" =~ /ab??bc/i" "ab??bc" t nil nil nil "ABBC" nil "ABBC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1250 "\"ABC\" =~ /ab??bc/i" "ab??bc" t nil nil nil "ABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1251 "\"ABC\" =~ /ab{0,1}?bc/i" "ab{0,1}?bc" t nil nil nil "ABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1252 "\"ABC\" =~ /ab??c/i" "ab??c" t nil nil nil "ABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1253 "\"ABC\" =~ /ab{0,1}?c/i" "ab{0,1}?c" t nil nil nil "ABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1254 "\"ABC\" =~ /^abc$/i" "^abc$" t nil nil nil "ABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1255 "\"ABBBBC\" =~ /^abc$/i" "^abc$" t nil nil nil "ABBBBC" nil nil nil)
+(1256 "\"ABCC\" =~ /^abc$/i" "^abc$" t nil nil nil "ABCC" nil nil nil)
+(1257 "\"ABCC\" =~ /^abc/i" "^abc" t nil nil nil "ABCC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1258 "\"AABC\" =~ /abc$/i" "abc$" t nil nil nil "AABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1259 "\"ABC\" =~ /^/i" "^" t nil nil nil "ABC" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1260 "\"ABC\" =~ /$/i" "$" t nil nil nil "ABC" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1261 "\"ABC\" =~ /a.c/i" "a.c" t nil nil nil "ABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1262 "\"AXC\" =~ /a.c/i" "a.c" t nil nil nil "AXC" nil "AXC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1263 "\"AXYZC\" =~ /a.*?c/i" "a.*?c" t nil nil nil "AXYZC" nil "AXYZC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1264 "\"AABC\" =~ /a.*c/i" "a.*c" t nil nil nil "AABC" nil "AABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1265 "\"AXYZD\" =~ /a.*c/i" "a.*c" t nil nil nil "AXYZD" nil nil nil)
+(1266 "\"ABD\" =~ /a[bc]d/i" "a[bc]d" t nil nil nil "ABD" nil "ABD" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1267 "\"ACE\" =~ /a[b-d]e/i" "a[b-d]e" t nil nil nil "ACE" nil "ACE" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1268 "\"ABC\" =~ /a[b-d]e/i" "a[b-d]e" t nil nil nil "ABC" nil nil nil)
+(1269 "\"ABD\" =~ /a[b-d]e/i" "a[b-d]e" t nil nil nil "ABD" nil nil nil)
+(1270 "\"AAC\" =~ /a[b-d]/i" "a[b-d]" t nil nil nil "AAC" nil "AC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1271 "\"A-\" =~ /a[-b]/i" "a[-b]" t nil nil nil "A-" nil "A-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1272 "\"A-\" =~ /a[b-]/i" "a[b-]" t nil nil nil "A-" nil "A-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1273 "\"A]\" =~ /a]/i" "a]" t nil nil nil "A]" nil "A]" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1274 "\"A]B\" =~ /a[]]b/i" "a[]]b" t nil nil nil "A]B" nil "A]B" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1275 "\"AED\" =~ /a[^bc]d/i" "a[^bc]d" t nil nil nil "AED" nil "AED" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1276 "\"ADC\" =~ /a[^-b]c/i" "a[^-b]c" t nil nil nil "ADC" nil "ADC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1277 "\"ABD\" =~ /a[^-b]c/i" "a[^-b]c" t nil nil nil "ABD" nil nil nil)
+(1278 "\"A-C\" =~ /a[^-b]c/i" "a[^-b]c" t nil nil nil "A-C" nil nil nil)
+(1279 "\"ADC\" =~ /a[^]b]c/i" "a[^]b]c" t nil nil nil "ADC" nil "ADC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1280 "\"ABC\" =~ /ab|cd/i" "ab|cd" t nil nil nil "ABC" nil "AB" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1281 "\"ABCD\" =~ /ab|cd/i" "ab|cd" t nil nil nil "ABCD" nil "AB" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1282 "\"DEF\" =~ /()ef/i" "()ef" t nil nil nil "DEF" nil "EF" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1283 "\"A]C\" =~ /$b/i" "$b" t nil nil nil "A]C" nil nil nil)
+(1284 "\"B\" =~ /$b/i" "$b" t nil nil nil "B" nil nil nil)
+(1285 "\"A(B\" =~ /a\\(b/i" "a\\(b" t nil nil nil "A(B" nil "A(B" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1286 "\"AB\" =~ /a\\(*b/i" "a\\(*b" t nil nil nil "AB" nil "AB" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1287 "\"A((B\" =~ /a\\(*b/i" "a\\(*b" t nil nil nil "A((B" nil "A((B" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1288 "\"A\\B\" =~ /a\\\\b/i" "a\\\\b" t nil nil nil "AB" nil nil nil)
+(1289 "\"ABC\" =~ /((a))/i" "((a))" t nil nil nil "ABC" nil "A" ("A" "A" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1290 "\"ABC\" =~ /(a)b(c)/i" "(a)b(c)" t nil nil nil "ABC" nil "ABC" ("A" "C" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1291 "\"AABBABC\" =~ /a+b+c/i" "a+b+c" t nil nil nil "AABBABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1292 "\"AABBABC\" =~ /a{1,}b{1,}c/i" "a{1,}b{1,}c" t nil nil nil "AABBABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1293 "\"ABCABC\" =~ /a.+?c/i" "a.+?c" t nil nil nil "ABCABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1294 "\"ABCABC\" =~ /a.*?c/i" "a.*?c" t nil nil nil "ABCABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1295 "\"ABCABC\" =~ /a.{0,5}?c/i" "a.{0,5}?c" t nil nil nil "ABCABC" nil "ABC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1296 "\"AB\" =~ /(a+|b)*/i" "(a+|b)*" t nil nil nil "AB" nil "AB" ("B" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1297 "\"AB\" =~ /(a+|b){0,}/i" "(a+|b){0,}" t nil nil nil "AB" nil "AB" ("B" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1298 "\"AB\" =~ /(a+|b)+/i" "(a+|b)+" t nil nil nil "AB" nil "AB" ("B" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1299 "\"AB\" =~ /(a+|b){1,}/i" "(a+|b){1,}" t nil nil nil "AB" nil "AB" ("B" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1300 "\"AB\" =~ /(a+|b)?/i" "(a+|b)?" t nil nil nil "AB" nil "A" ("A" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1301 "\"AB\" =~ /(a+|b){0,1}/i" "(a+|b){0,1}" t nil nil nil "AB" nil "A" ("A" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1302 "\"AB\" =~ /(a+|b){0,1}?/i" "(a+|b){0,1}?" t nil nil nil "AB" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1303 "\"CDE\" =~ /[^ab]*/i" "[^ab]*" t nil nil nil "CDE" nil "CDE" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1304 "\"ABBBCD\" =~ 
+/([abc])*d/i" "([abc])*d" t nil nil nil "ABBBCD" nil "ABBBCD" ("C" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1305 "\"ABCD\" =~ /([abc])*bcd/i" "([abc])*bcd" t nil nil nil "ABCD" nil "ABCD" ("A" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1306 "\"E\" =~ /a|b|c|d|e/i" "a|b|c|d|e" t nil nil nil "E" nil "E" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1307 "\"EF\" =~ /(a|b|c|d|e)f/i" "(a|b|c|d|e)f" t nil nil nil "EF" nil "EF" ("E" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1308 "\"ABCDEFG\" =~ /abcd*efg/i" "abcd*efg" t nil nil nil "ABCDEFG" nil "ABCDEFG" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1309 "\"XABYABBBZ\" =~ /ab*/i" "ab*" t nil nil nil "XABYABBBZ" nil "AB" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1310 "\"XAYABBBZ\" =~ /ab*/i" "ab*" t nil nil nil "XAYABBBZ" nil "A" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1311 "\"ABCDE\" =~ /(ab|cd)e/i" "(ab|cd)e" t nil nil nil "ABCDE" nil "CDE" ("CD" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1312 "\"HIJ\" =~ /[abhgefdc]ij/i" "[abhgefdc]ij" t nil nil nil "HIJ" nil "HIJ" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1313 "\"ABCDE\" =~ /^(ab|cd)e/i" "^(ab|cd)e" t nil nil nil "ABCDE" nil nil nil)
+(1314 "\"ABCDEF\" =~ /(abc|)ef/i" "(abc|)ef" t nil nil nil "ABCDEF" nil "EF" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1315 "\"ABCD\" =~ /(a|b)c*d/i" "(a|b)c*d" t nil nil nil "ABCD" nil "BCD" ("B" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1316 "\"ABC\" =~ /(ab|ab*)bc/i" "(ab|ab*)bc" t nil nil nil "ABC" nil "ABC" ("A" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1317 "\"ABC\" =~ /a([bc]*)c*/i" "a([bc]*)c*" t nil nil nil "ABC" nil "ABC" ("BC" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1318 "\"ABCD\" =~ /a([bc]*)(c*d)/i" "a([bc]*)(c*d)" t nil nil nil "ABCD" nil "ABCD" ("BC" "D" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1319 "\"ABCD\" =~ /a([bc]+)(c*d)/i" "a([bc]+)(c*d)" t nil nil nil "ABCD" nil "ABCD" ("BC" "D" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1320 "\"ABCD\" =~ /a([bc]*)(c+d)/i" "a([bc]*)(c+d)" t nil nil nil "ABCD" nil "ABCD" ("B" "CD" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1321 "\"ADCDCDE\" =~ /a[bcd]*dcdcde/i" "a[bcd]*dcdcde" t nil nil nil "ADCDCDE" nil "ADCDCDE" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1322 "\"ABC\" =~ /(ab|a)b*c/i" "(ab|a)b*c" t nil nil nil "ABC" nil "ABC" ("AB" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1323 "\"ABCD\" =~ /((a)(b)c)(d)/i" "((a)(b)c)(d)" t nil nil nil "ABCD" nil "ABCD" ("ABC" "A" "B" "D" nil nil nil nil nil nil nil nil nil nil nil nil))
+(1324 "\"ALPHA\" =~ /[a-zA-Z_][a-zA-Z0-9_]*/i" "[a-zA-Z_][a-zA-Z0-9_]*" t nil nil nil "ALPHA" nil "ALPHA" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1325 "\"ABH\" =~ /^a(bc+|b[eh])g|.h$/i" "^a(bc+|b[eh])g|.h$" t nil nil nil "ABH" nil "BH" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1326 "\"EFFGZ\" =~ /(bc+d$|ef*g.|h?i(j|k))/i" "(bc+d$|ef*g.|h?i(j|k))" t nil nil nil "EFFGZ" nil "EFFGZ" ("EFFGZ" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1327 "\"IJ\" =~ /(bc+d$|ef*g.|h?i(j|k))/i" "(bc+d$|ef*g.|h?i(j|k))" t nil nil nil "IJ" nil "IJ" ("IJ" "J" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1328 "\"REFFGZ\" =~ /(bc+d$|ef*g.|h?i(j|k))/i" "(bc+d$|ef*g.|h?i(j|k))" t nil nil nil "REFFGZ" nil "EFFGZ" ("EFFGZ" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1329 "\"ADCDCDE\" =~ /(bc+d$|ef*g.|h?i(j|k))/i" "(bc+d$|ef*g.|h?i(j|k))" t nil nil nil "ADCDCDE" nil nil nil)
+(1330 "\"EFFG\" =~ /(bc+d$|ef*g.|h?i(j|k))/i" "(bc+d$|ef*g.|h?i(j|k))" t nil nil nil "EFFG" nil nil nil)
+(1331 "\"BCDD\" =~ /(bc+d$|ef*g.|h?i(j|k))/i" "(bc+d$|ef*g.|h?i(j|k))" t nil nil nil "BCDD" nil nil nil)
+(1332 "\"A\" =~ /((((((((((a))))))))))/i" "((((((((((a))))))))))" t nil nil nil "A" nil "A" ("A" "A" "A" "A" "A" "A" "A" "A" "A" "A" nil nil nil nil nil nil))
+(1333 "\"AA\" =~ /((((((((((a))))))))))\\10/i" "((((((((((a))))))))))\\10" t nil nil nil "AA" nil "AA" ("A" "A" "A" "A" "A" "A" "A" "A" "A" "A" nil nil nil nil nil nil))
+(1334 "\"A\" =~ /(((((((((a)))))))))/i" "(((((((((a)))))))))" t nil nil nil "A" nil "A" ("A" "A" "A" "A" "A" "A" "A" "A" "A" nil nil nil nil nil nil nil))
+(1335 "\"A\" =~ /(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))/i" "(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))" t nil nil nil "A" nil "A" ("A" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1336 "\"C\" =~ /(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))/i" "(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))" t nil nil nil "C" nil "C" ("C" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1337 "\"AA\" =~ /multiple words of text/i" "multiple words of text" t nil nil nil "AA" nil nil nil)
+(1338 "\"UH-UH\" =~ /multiple words of text/i" "multiple words of text" t nil nil nil "UH-UH" nil nil nil)
+(1339 "\"MULTIPLE WORDS, YEAH\" =~ /multiple words/i" "multiple words" t nil nil nil "MULTIPLE WORDS, YEAH" nil "MULTIPLE WORDS" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1340 "\"ABCDE\" =~ /(.*)c(.*)/i" "(.*)c(.*)" t nil nil nil "ABCDE" nil "ABCDE" ("AB" "DE" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1341 "\"(A, B)\" =~ /\\((.*), (.*)\\)/i" "\\((.*), (.*)\\)" t nil nil nil "(A, B)" nil "(A, B)" ("A" "B" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1342 "\"ABCD\" =~ /abcd/i" "abcd" t nil nil nil "ABCD" nil "ABCD" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1343 "\"ABCD\" =~ /a(bc)d/i" "a(bc)d" t nil nil nil "ABCD" nil "ABCD" ("BC" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1344 "\"AC\" =~ /a[-]?c/i" "a[-]?c" t nil nil nil "AC" nil "AC" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1345 "\"ABCABC\" =~ /(abc)\\1/i" "(abc)\\1" t nil nil nil "ABCABC" nil "ABCABC" ("ABC" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1346 "\"ABCABC\" =~ /([a-c]*)\\1/i" "([a-c]*)\\1" t nil nil nil "ABCABC" nil "ABCABC" ("ABC" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1347 "\"abad\" =~ /a(?!b)./" "a(?!b)." nil nil nil nil "abad" nil "ad" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1348 "\"abad\" =~ /a(?=d)./" "a(?=d)." nil nil nil nil "abad" nil "ad" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1349 "\"abad\" =~ /a(?=c|d)./" "a(?=c|d)." nil nil nil nil "abad" nil "ad" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1350 "\"ace\" =~ /a(?:b|c|d)(.)/" "a(?:b|c|d)(.)" nil nil nil nil "ace" nil "ace" ("e" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1351 "\"ace\" =~ /a(?:b|c|d)*(.)/" "a(?:b|c|d)*(.)" nil nil nil nil "ace" nil "ace" ("e" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1352 "\"ace\" =~ /a(?:b|c|d)+?(.)/" "a(?:b|c|d)+?(.)" nil nil nil nil "ace" nil "ace" ("e" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1353 "\"acdbcdbe\" =~ /a(?:b|c|d)+?(.)/" "a(?:b|c|d)+?(.)" nil nil nil nil "acdbcdbe" nil "acd" ("d" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1354 "\"acdbcdbe\" =~ /a(?:b|c|d)+(.)/" "a(?:b|c|d)+(.)" nil nil nil nil "acdbcdbe" nil "acdbcdbe" ("e" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1355 "\"acdbcdbe\" =~ /a(?:b|c|d){2}(.)/" "a(?:b|c|d){2}(.)" nil nil nil nil "acdbcdbe" nil "acdb" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1356 "\"acdbcdbe\" =~ /a(?:b|c|d){4,5}(.)/" "a(?:b|c|d){4,5}(.)" nil nil nil nil "acdbcdbe" nil "acdbcdb" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1357 "\"acdbcdbe\" =~ /a(?:b|c|d){4,5}?(.)/" "a(?:b|c|d){4,5}?(.)" nil nil nil nil "acdbcdbe" nil "acdbcd" ("d" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1358 "\"foobar\" =~ /((foo)|(bar))*/" "((foo)|(bar))*" nil nil nil nil "foobar" nil "foobar" ("bar" "foo" "bar" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1359 "\"acdbcdbe\" =~ /a(?:b|c|d){6,7}(.)/" "a(?:b|c|d){6,7}(.)" nil nil nil nil "acdbcdbe" nil "acdbcdbe" ("e" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1360 "\"acdbcdbe\" =~ /a(?:b|c|d){6,7}?(.)/" "a(?:b|c|d){6,7}?(.)" nil nil nil nil "acdbcdbe" nil "acdbcdbe" ("e" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1361 "\"acdbcdbe\" =~ /a(?:b|c|d){5,6}(.)/" "a(?:b|c|d){5,6}(.)" nil nil nil nil "acdbcdbe" nil "acdbcdbe" ("e" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1362 "\"acdbcdbe\" =~ /a(?:b|c|d){5,6}?(.)/" "a(?:b|c|d){5,6}?(.)" nil nil nil nil "acdbcdbe" nil "acdbcdb" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1363 "\"acdbcdbe\" =~ /a(?:b|c|d){5,7}(.)/" "a(?:b|c|d){5,7}(.)" nil nil nil nil "acdbcdbe" nil "acdbcdbe" ("e" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1364 "\"acdbcdbe\" =~ /a(?:b|c|d){5,7}?(.)/" "a(?:b|c|d){5,7}?(.)" nil nil nil nil "acdbcdbe" nil "acdbcdb" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1365 "\"ace\" =~ /a(?:b|(c|e){1,2}?|d)+?(.)/" "a(?:b|(c|e){1,2}?|d)+?(.)" nil nil nil nil "ace" nil "ace" ("c" "e" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1366 "\"AB\" =~ /^(.+)?B/" "^(.+)?B" nil nil nil nil "AB" nil "AB" ("A" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1367 "\".\" =~ /^([^a-z])|(\\^)$/" "^([^a-z])|(\\^)$" nil nil nil nil "." nil "." ("." nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1368 "\"<&OUT\" =~ /^[<>]&/" "^[<>]&" nil nil nil nil "<&OUT" nil "<&" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1369 "\"aaaaaaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaaaaaa" nil "aaaaaaaaaa" ("aaaa" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1370 "\"AB\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "AB" nil nil nil)
+(1371 "\"aaaaaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaaaaa" nil nil nil)
+(1372 "\"aaaaaaaaaaa\" =~ /^(a\\1?){4}$/" "^(a\\1?){4}$" nil nil nil nil "aaaaaaaaaaa" nil nil nil)
+(1373 "\"aaaaaaaaaa\" =~ /^(a(?(1)\\1)){4}$/" "^(a(?(1)\\1)){4}$" nil nil nil nil "aaaaaaaaaa" nil "aaaaaaaaaa" ("aaaa" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1374 "\"aaaaaaaaa\" =~ /^(a(?(1)\\1)){4}$/" "^(a(?(1)\\1)){4}$" nil nil nil nil "aaaaaaaaa" nil nil nil)
+(1375 "\"aaaaaaaaaaa\" =~ /^(a(?(1)\\1)){4}$/" "^(a(?(1)\\1)){4}$" nil nil nil nil "aaaaaaaaaaa" nil nil nil)
+(1376 "\"foobar\" =~ /(?:(f)(o)(o)|(b)(a)(r))*/" "(?:(f)(o)(o)|(b)(a)(r))*" nil nil nil nil "foobar" nil "foobar" ("f" "o" "o" "b" "a" "r" nil nil nil nil nil nil nil nil nil nil))
+(1377 "\"ab\" =~ /(?<=a)b/" "(?<=a)b" nil nil nil nil "ab" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1378 "\"cb\" =~ /(?<=a)b/" "(?<=a)b" nil nil nil nil "cb" nil nil nil)
+(1379 "\"b\" =~ /(?<=a)b/" "(?<=a)b" nil nil nil nil "b" nil nil nil)
+(1380 "\"ab\" =~ /(?<!c)b/" "(?<!c)b" nil nil nil nil "ab" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1381 "\"b\" =~ /(?<!c)b/" "(?<!c)b" nil nil nil nil "b" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1382 "\"b\" =~ /(?<!c)b/" "(?<!c)b" nil nil nil nil "b" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1383 "\"aba\" =~ /(?:..)*a/" "(?:..)*a" nil nil nil nil "aba" nil "aba" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1384 "\"aba\" =~ /(?:..)*?a/" "(?:..)*?a" nil nil nil nil "aba" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1385 "\"abc\" =~ /^(?:b|a(?=(.)))*\\1/" "^(?:b|a(?=(.)))*\\1" nil nil nil nil "abc" nil "ab" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1386 "\"abc\" =~ /^(){3,5}/" "^(){3,5}" nil nil nil nil "abc" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1387 "\"aax\" =~ /^(a+)*ax/" "^(a+)*ax" nil nil nil nil "aax" nil "aax" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1388 "\"aax\" =~ /^((a|b)+)*ax/" "^((a|b)+)*ax" nil nil nil nil "aax" nil "aax" ("a" "a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1389 "\"aax\" =~ /^((a|bc)+)*ax/" "^((a|bc)+)*ax" nil nil nil nil "aax" nil "aax" ("a" "a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1390 "\"cab\" =~ /(a|x)*ab/" "(a|x)*ab" nil nil nil nil "cab" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1391 "\"cab\" =~ /(a)*ab/" "(a)*ab" nil nil nil nil "cab" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1392 "\"ab\" =~ /(?:(?i)a)b/" "(?:(?i)a)b" nil nil nil nil "ab" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1393 "\"ab\" =~ /((?i)a)b/" "((?i)a)b" nil nil nil nil "ab" nil "ab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1394 "\"Ab\" =~ /(?:(?i)a)b/" "(?:(?i)a)b" nil nil nil nil "Ab" nil "Ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1395 "\"Ab\" =~ /((?i)a)b/" "((?i)a)b" nil nil nil nil "Ab" nil "Ab" ("A" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1396 "\"cb\" =~ /(?:(?i)a)b/" "(?:(?i)a)b" nil nil nil nil "cb" nil nil nil)
+(1397 "\"aB\" =~ /(?:(?i)a)b/" "(?:(?i)a)b" nil nil nil nil "aB" nil nil nil)
+(1398 "\"ab\" =~ /(?i:a)b/" "(?i:a)b" nil nil nil nil "ab" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1399 "\"ab\" =~ /((?i:a))b/" "((?i:a))b" nil nil nil nil "ab" nil "ab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1400 "\"Ab\" =~ /(?i:a)b/" "(?i:a)b" nil nil nil nil "Ab" nil "Ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1401 "\"Ab\" =~ /((?i:a))b/" "((?i:a))b" nil nil nil nil "Ab" nil "Ab" ("A" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1402 "\"aB\" =~ /(?i:a)b/" "(?i:a)b" nil nil nil nil "aB" nil nil nil)
+(1403 "\"aB\" =~ /(?i:a)b/" "(?i:a)b" nil nil nil nil "aB" nil nil nil)
+(1404 "\"ab\" =~ /(?:(?-i)a)b/i" "(?:(?-i)a)b" t nil nil nil "ab" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1405 "\"ab\" =~ /((?-i)a)b/i" "((?-i)a)b" t nil nil nil "ab" nil "ab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1406 "\"aB\" =~ /(?:(?-i)a)b/i" "(?:(?-i)a)b" t nil nil nil "aB" nil "aB" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1407 "\"aB\" =~ /((?-i)a)b/i" "((?-i)a)b" t nil nil nil "aB" nil "aB" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1408 "\"aB\" =~ /(?:(?-i)a)b/i" "(?:(?-i)a)b" t nil nil nil "aB" nil "aB" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1409 "\"Ab\" =~ /(?:(?-i)a)b/i" "(?:(?-i)a)b" t nil nil nil "Ab" nil nil nil)
+(1410 "\"aB\" =~ /(?:(?-i)a)b/i" "(?:(?-i)a)b" t nil nil nil "aB" nil "aB" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1411 "\"aB\" =~ /((?-i)a)b/i" "((?-i)a)b" t nil nil nil "aB" nil "aB" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1412 "\"Ab\" =~ /(?:(?-i)a)b/i" "(?:(?-i)a)b" t nil nil nil "Ab" nil nil nil)
+(1413 "\"AB\" =~ /(?:(?-i)a)b/i" "(?:(?-i)a)b" t nil nil nil "AB" nil nil nil)
+(1414 "\"ab\" =~ /(?-i:a)b/i" "(?-i:a)b" t nil nil nil "ab" nil "ab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1415 "\"ab\" =~ /((?-i:a))b/i" "((?-i:a))b" t nil nil nil "ab" nil "ab" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1416 "\"aB\" =~ /(?-i:a)b/i" "(?-i:a)b" t nil nil nil "aB" nil "aB" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1417 "\"aB\" =~ /((?-i:a))b/i" "((?-i:a))b" t nil nil nil "aB" nil "aB" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1418 "\"AB\" =~ /(?-i:a)b/i" "(?-i:a)b" t nil nil nil "AB" nil nil nil)
+(1419 "\"Ab\" =~ /(?-i:a)b/i" "(?-i:a)b" t nil nil nil "Ab" nil nil nil)
+(1420 "\"aB\" =~ /(?-i:a)b/i" "(?-i:a)b" t nil nil nil "aB" nil "aB" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1421 "\"aB\" =~ /((?-i:a))b/i" "((?-i:a))b" t nil nil nil "aB" nil "aB" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1422 "\"Ab\" =~ /(?-i:a)b/i" "(?-i:a)b" t nil nil nil "Ab" nil nil nil)
+(1423 "\"AB\" =~ /(?-i:a)b/i" "(?-i:a)b" t nil nil nil "AB" nil nil nil)
+(1424 "\"AB\" =~ /((?-i:a.))b/i" "((?-i:a.))b" t nil nil nil "AB" nil nil nil)
+(1425 "\"a\\nB\" =~ /((?-i:a.))b/i" "((?-i:a.))b" t nil nil nil "a
+B" nil nil nil)
+(1426 "\"a\\nB\" =~ /((?s-i:a.))b/i" "((?s-i:a.))b" t nil nil nil "a
+B" nil "a
+B" ("a
+" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1427 "\"cabbbb\" =~ /(?:c|d)(?:)(?:a(?:)(?:b)(?:b(?:))(?:b(?:)(?:b)))/" "(?:c|d)(?:)(?:a(?:)(?:b)(?:b(?:))(?:b(?:)(?:b)))" nil nil nil nil "cabbbb" nil "cabbbb" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1428 "\"caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\" =~ /(?:c|d)(?:)(?:aaaaaaaa(?:)(?:bbbbbbbb)(?:bbbbbbbb(?:))(?:bbbbbbbb(?:)(?:bbbbbbbb)))/" "(?:c|d)(?:)(?:aaaaaaaa(?:)(?:bbbbbbbb)(?:bbbbbbbb(?:))(?:bbbbbbbb(?:)(?:bbbbbbbb)))" nil nil nil nil "caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" nil "caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1429 "\"Ab4ab\" =~ /(ab)\\d\\1/i" "(ab)\\d\\1" t nil nil nil "Ab4ab" nil "Ab4ab" ("Ab" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1430 "\"ab4Ab\" =~ /(ab)\\d\\1/i" "(ab)\\d\\1" t nil nil nil "ab4Ab" nil "ab4Ab" ("ab" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1431 "\"foobar1234baz\" =~ /foo\\w*\\d{4}baz/" "foo\\w*\\d{4}baz" nil nil nil nil "foobar1234baz" nil "foobar1234baz" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1432 "\"x~~\" =~ /x(~~)*(?:(?:F)?)?/" "x(~~)*(?:(?:F)?)?" nil nil nil nil "x~~" nil "x~~" ("~~" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1433 "\"aaac\" =~ /^a(?#xxx){3}c/" "^a(?#xxx){3}c" nil nil nil nil "aaac" nil "aaac" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1434 "\"aaac\" =~ /^a(?#xxx)(?#xxx){3}c/" "^a(?#xxx)(?#xxx){3}c" nil nil nil nil "aaac" nil "aaac" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1435 "\"aaac\" =~ /^a (?#xxx) (?#yyy) {3}c/x" "^a (?#xxx) (?#yyy) {3}c" nil nil nil t "aaac" nil "aaac" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1436 "\"B\\nB\" =~ /(?<![cd])b/" "(?<![cd])b" nil nil nil nil "B
+B" nil nil nil)
+(1437 "\"dbcb\" =~ /(?<![cd])b/" "(?<![cd])b" nil nil nil nil "dbcb" nil nil nil)
+(1438 "\"dbaacb\" =~ /(?<![cd])[ab]/" "(?<![cd])[ab]" nil nil nil nil "dbaacb" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1439 "\"dbaacb\" =~ /(?<!(c|d))[ab]/" "(?<!(c|d))[ab]" nil nil nil nil "dbaacb" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1440 "\"cdaccb\" =~ /(?<!cd)[ab]/" "(?<!cd)[ab]" nil nil nil nil "cdaccb" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1441 "\"dbcb\" =~ /^(?:a?b?)*$/" "^(?:a?b?)*$" nil nil nil nil "dbcb" nil nil nil)
+(1442 "\"a--\" =~ /^(?:a?b?)*$/" "^(?:a?b?)*$" nil nil nil nil "a--" nil nil nil)
+(1443 "\"a\\nb\\nc\\n\" =~ /((?s)^a(.))((?m)^b$)/" "((?s)^a(.))((?m)^b$)" nil nil nil nil "a
+b
+c
+" nil "a
+b" ("a
+" "
+" "b" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1444 "\"a\\nb\\nc\\n\" =~ /((?m)^b$)/" "((?m)^b$)" nil nil nil nil "a
+b
+c
+" nil "b" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1445 "\"a\\nb\\n\" =~ /(?m)^b/" "(?m)^b" nil nil nil nil "a
+b
+" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1446 "\"a\\nb\\n\" =~ /(?m)^(b)/" "(?m)^(b)" nil nil nil nil "a
+b
+" nil "b" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1447 "\"a\\nb\\n\" =~ /((?m)^b)/" "((?m)^b)" nil nil nil nil "a
+b
+" nil "b" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1448 "\"a\\nb\\n\" =~ /\\n((?m)^b)/" "\\n((?m)^b)" nil nil nil nil "a
+b
+" nil "
+b" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1449 "\"a\\nb\\nc\\n\" =~ /((?s).)c(?!.)/" "((?s).)c(?!.)" nil nil nil nil "a
+b
+c
+" nil "
+c" ("
+" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1450 "\"a\\nb\\nc\\n\" =~ /((?s).)c(?!.)/" "((?s).)c(?!.)" nil nil nil nil "a
+b
+c
+" nil "
+c" ("
+" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1451 "\"a\\nb\\nc\\n\" =~ /((?s)b.)c(?!.)/" "((?s)b.)c(?!.)" nil nil nil nil "a
+b
+c
+" nil "b
+c" ("b
+" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1452 "\"a\\nb\\nc\\n\" =~ /((?s)b.)c(?!.)/" "((?s)b.)c(?!.)" nil nil nil nil "a
+b
+c
+" nil "b
+c" ("b
+" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1453 "\"a\\nb\\nc\\n\" =~ /()^b/" "()^b" nil nil nil nil "a
+b
+c
+" nil nil nil)
+(1454 "\"a\\nb\\nc\\n\" =~ /()^b/" "()^b" nil nil nil nil "a
+b
+c
+" nil nil nil)
+(1455 "\"a\\nb\\nc\\n\" =~ /((?m)^b)/" "((?m)^b)" nil nil nil nil "a
+b
+c
+" nil "b" ("b" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1456 "\"a\" =~ /(?(1)b|a)/" "(?(1)b|a)" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1457 "\"a\" =~ /(x)?(?(1)a|b)/" "(x)?(?(1)a|b)" nil nil nil nil "a" nil nil nil)
+(1458 "\"a\" =~ /(x)?(?(1)a|b)/" "(x)?(?(1)a|b)" nil nil nil nil "a" nil nil nil)
+(1459 "\"a\" =~ /(x)?(?(1)b|a)/" "(x)?(?(1)b|a)" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1460 "\"a\" =~ /()?(?(1)b|a)/" "()?(?(1)b|a)" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1461 "\"a\" =~ /()?(?(1)a|b)/" "()?(?(1)a|b)" nil nil nil nil "a" nil "a" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1462 "\"(blah)\" =~ /^(\\()?blah(?(1)(\\)))$/" "^(\\()?blah(?(1)(\\)))$" nil nil nil nil "(blah)" nil "(blah)" ("(" ")" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1463 "\"blah\" =~ /^(\\()?blah(?(1)(\\)))$/" "^(\\()?blah(?(1)(\\)))$" nil nil nil nil "blah" nil "blah" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1464 "\"a\" =~ /^(\\()?blah(?(1)(\\)))$/" "^(\\()?blah(?(1)(\\)))$" nil nil nil nil "a" nil nil nil)
+(1465 "\"blah)\" =~ /^(\\()?blah(?(1)(\\)))$/" "^(\\()?blah(?(1)(\\)))$" nil nil nil nil "blah)" nil nil nil)
+(1466 "\"(blah\" =~ /^(\\()?blah(?(1)(\\)))$/" "^(\\()?blah(?(1)(\\)))$" nil nil nil nil "(blah" nil nil nil)
+(1467 "\"(blah)\" =~ /^(\\(+)?blah(?(1)(\\)))$/" "^(\\(+)?blah(?(1)(\\)))$" nil nil nil nil "(blah)" nil "(blah)" ("(" ")" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1468 "\"blah\" =~ /^(\\(+)?blah(?(1)(\\)))$/" "^(\\(+)?blah(?(1)(\\)))$" nil nil nil nil "blah" nil "blah" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1469 "\"blah)\" =~ /^(\\(+)?blah(?(1)(\\)))$/" "^(\\(+)?blah(?(1)(\\)))$" nil nil nil nil "blah)" nil nil nil)
+(1470 "\"(blah\" =~ /^(\\(+)?blah(?(1)(\\)))$/" "^(\\(+)?blah(?(1)(\\)))$" nil nil nil nil "(blah" nil nil nil)
+(1471 "\"a\" =~ /(?(?!a)b|a)/" "(?(?!a)b|a)" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1472 "\"a\" =~ /(?(?=a)b|a)/" "(?(?=a)b|a)" nil nil nil nil "a" nil nil nil)
+(1473 "\"a\" =~ /(?(?=a)b|a)/" "(?(?=a)b|a)" nil nil nil nil "a" nil nil nil)
+(1474 "\"a\" =~ /(?(?=a)a|b)/" "(?(?=a)a|b)" nil nil nil nil "a" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1475 "\"aaab\" =~ /(?=(a+?))(\\1ab)/" "(?=(a+?))(\\1ab)" nil nil nil nil "aaab" nil "aab" ("a" "aab" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1476 "\"one:\" =~ /(\\w+:)+/" "(\\w+:)+" nil nil nil nil "one:" nil "one:" ("one:" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1477 "\"a\" =~ /$(?<=^(a))/" "$(?<=^(a))" nil nil nil nil "a" nil "" ("a" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1478 "\"aaab\" =~ /(?=(a+?))(\\1ab)/" "(?=(a+?))(\\1ab)" nil nil nil nil "aaab" nil "aab" ("a" "aab" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1479 "\"aaab\" =~ /^(?=(a+?))\\1ab/" "^(?=(a+?))\\1ab" nil nil nil nil "aaab" nil nil nil)
+(1480 "\"aaab\" =~ /^(?=(a+?))\\1ab/" "^(?=(a+?))\\1ab" nil nil nil nil "aaab" nil nil nil)
+(1481 "\"abcd\" =~ /([\\w:]+::)?(\\w+)$/" "([\\w:]+::)?(\\w+)$" nil nil nil nil "abcd" nil "abcd" (nil "abcd" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1482 "\"xy:z:::abcd\" =~ /([\\w:]+::)?(\\w+)$/" "([\\w:]+::)?(\\w+)$" nil nil nil nil "xy:z:::abcd" nil "xy:z:::abcd" ("xy:z:::" "abcd" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1483 "\"aexycd\" =~ /^[^bcd]*(c+)/" "^[^bcd]*(c+)" nil nil nil nil "aexycd" nil "aexyc" ("c" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1484 "\"caab\" =~ /(a*)b+/" "(a*)b+" nil nil nil nil "caab" nil "aab" ("aa" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1485 "\"abcd\" =~ /([\\w:]+::)?(\\w+)$/" "([\\w:]+::)?(\\w+)$" nil nil nil nil "abcd" nil "abcd" (nil "abcd" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1486 "\"xy:z:::abcd\" =~ /([\\w:]+::)?(\\w+)$/" "([\\w:]+::)?(\\w+)$" nil nil nil nil "xy:z:::abcd" nil "xy:z:::abcd" ("xy:z:::" "abcd" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1487 "\"abcd:\" =~ /([\\w:]+::)?(\\w+)$/" "([\\w:]+::)?(\\w+)$" nil nil nil nil "abcd:" nil nil nil)
+(1488 "\"abcd:\" =~ /([\\w:]+::)?(\\w+)$/" "([\\w:]+::)?(\\w+)$" nil nil nil nil "abcd:" nil nil nil)
+(1489 "\"aexycd\" =~ /^[^bcd]*(c+)/" "^[^bcd]*(c+)" nil nil nil nil "aexycd" nil "aexyc" ("c" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1490 "\"aaab\" =~ /(?>a+)b/" "(?>a+)b" nil nil nil nil "aaab" nil "aaab" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1491 "\"a:[b]:\" =~ /([[:]+)/" "([[:]+)" nil nil nil nil "a:[b]:" nil ":[" (":[" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1492 "\"a=[b]=\" =~ /([[=]+)/" "([[=]+)" nil nil nil nil "a=[b]=" nil "=[" ("=[" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1493 "\"a.[b].\" =~ /([[.]+)/" "([[.]+)" nil nil nil nil "a.[b]." nil ".[" (".[" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1494 "\"aaab\" =~ /((?>a+)b)/" "((?>a+)b)" nil nil nil nil "aaab" nil "aaab" ("aaab" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1495 "\"aaab\" =~ /(?>(a+))b/" "(?>(a+))b" nil nil nil nil "aaab" nil "aaab" ("aaa" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1496 "\"((abc(ade)ufh()()x\" =~ /((?>[^()]+)|\\([^()]*\\))+/" "((?>[^()]+)|\\([^()]*\\))+" nil nil nil nil "((abc(ade)ufh()()x" nil "abc(ade)ufh()()x" ("x" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1497 "\"aaab\" =~ /a\\Z/" "a\\Z" nil nil nil nil "aaab" nil nil nil)
+(1498 "\"a\\nb\\n\" =~ /a\\Z/" "a\\Z" nil nil nil nil "a
+b
+" nil nil nil)
+(1499 "\"a\\nb\\n\" =~ /b\\Z/" "b\\Z" nil nil nil nil "a
+b
+" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1500 "\"a\\nb\" =~ /b\\Z/" "b\\Z" nil nil nil nil "a
+b" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1501 "\"a\\nb\" =~ /b\\z/" "b\\z" nil nil nil nil "a
+b" nil "b" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1502 "\"a\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "a" nil "a" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1503 "\"abc\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "abc" nil "abc" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1504 "\"a-b\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "a-b" nil "a-b" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1505 "\"0-9\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "0-9" nil "0-9" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1506 "\"a.b\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "a.b" nil "a.b" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1507 "\"5.6.7\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "5.6.7" nil "5.6.7" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1508 "\"the.quick.brown.fox\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "the.quick.brown.fox" nil "the.quick.brown.fox" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1509 "\"a100.b200.300c\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "a100.b200.300c" nil "a100.b200.300c" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1510 "\"12-ab.1245\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "12-ab.1245" nil "12-ab.1245" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1511 "\"\\\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "" nil nil nil)
+(1512 "\".a\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil ".a" nil nil nil)
+(1513 "\"-a\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "-a" nil nil nil)
+(1514 "\"a-\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "a-" nil nil nil)
+(1515 "\"a.\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "a." nil nil nil)
+(1516 "\"a_b\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "a_b" nil nil nil)
+(1517 "\"a.-\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "a.-" nil nil nil)
+(1518 "\"a..\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "a.." nil nil nil)
+(1519 "\"ab..bc\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "ab..bc" nil nil nil)
+(1520 "\"the.quick.brown.fox-\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "the.quick.brown.fox-" nil nil nil)
+(1521 "\"the.quick.brown.fox.\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "the.quick.brown.fox." nil nil nil)
+(1522 "\"the.quick.brown.fox_\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "the.quick.brown.fox_" nil nil nil)
+(1523 "\"the.quick.brown.fox+\" =~ /^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$/" "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$" nil nil nil nil "the.quick.brown.fox+" nil nil nil)
+(1524 "\"alphabetabcd\" =~ /(?>.*)(?<=(abcd|wxyz))/" "(?>.*)(?<=(abcd|wxyz))" nil nil nil nil "alphabetabcd" nil "alphabetabcd" ("abcd" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1525 "\"endingwxyz\" =~ /(?>.*)(?<=(abcd|wxyz))/" "(?>.*)(?<=(abcd|wxyz))" nil nil nil nil "endingwxyz" nil "endingwxyz" ("wxyz" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1526 "\"a rather long string that doesn't end with one of them\" =~ /(?>.*)(?<=(abcd|wxyz))/" "(?>.*)(?<=(abcd|wxyz))" nil nil nil nil "a rather long string that doesn't end with one of them" nil nil nil)
+(1527 "\"word cat dog elephant mussel cow horse canary baboon snake shark otherword\" =~ /word (?>(?:(?!otherword)[a-zA-Z0-9]+ ){0,30})otherword/" "word (?>(?:(?!otherword)[a-zA-Z0-9]+ ){0,30})otherword" nil nil nil nil "word cat dog elephant mussel cow horse canary baboon snake shark otherword" nil "word cat dog elephant mussel cow horse canary baboon snake shark otherword" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1528 "\"word cat dog elephant mussel cow horse canary baboon snake shark\" =~ /word (?>(?:(?!otherword)[a-zA-Z0-9]+ ){0,30})otherword/" "word (?>(?:(?!otherword)[a-zA-Z0-9]+ ){0,30})otherword" nil nil nil nil "word cat dog elephant mussel cow horse canary baboon snake shark" nil nil nil)
+(1529 "\"word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope\" =~ /word (?>[a-zA-Z0-9]+ ){0,30}otherword/" "word (?>[a-zA-Z0-9]+ ){0,30}otherword" nil nil nil nil "word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope" nil nil nil)
+(1530 "\"999foo\" =~ /(?<=\\d{3}(?!999))foo/" "(?<=\\d{3}(?!999))foo" nil nil nil nil "999foo" nil "foo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1531 "\"123999foo\" =~ /(?<=\\d{3}(?!999))foo/" "(?<=\\d{3}(?!999))foo" nil nil nil nil "123999foo" nil "foo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1532 "\"123abcfoo\" =~ /(?<=\\d{3}(?!999))foo/" "(?<=\\d{3}(?!999))foo" nil nil nil nil "123abcfoo" nil nil nil)
+(1533 "\"999foo\" =~ /(?<=(?!...999)\\d{3})foo/" "(?<=(?!...999)\\d{3})foo" nil nil nil nil "999foo" nil "foo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1534 "\"123999foo\" =~ /(?<=(?!...999)\\d{3})foo/" "(?<=(?!...999)\\d{3})foo" nil nil nil nil "123999foo" nil "foo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1535 "\"123abcfoo\" =~ /(?<=(?!...999)\\d{3})foo/" "(?<=(?!...999)\\d{3})foo" nil nil nil nil "123abcfoo" nil nil nil)
+(1536 "\"123abcfoo\" =~ /(?<=\\d{3}(?!999)...)foo/" "(?<=\\d{3}(?!999)...)foo" nil nil nil nil "123abcfoo" nil "foo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1537 "\"123456foo\" =~ /(?<=\\d{3}(?!999)...)foo/" "(?<=\\d{3}(?!999)...)foo" nil nil nil nil "123456foo" nil "foo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1538 "\"123999foo\" =~ /(?<=\\d{3}(?!999)...)foo/" "(?<=\\d{3}(?!999)...)foo" nil nil nil nil "123999foo" nil nil nil)
+(1539 "\"123abcfoo\" =~ /(?<=\\d{3}...)(?<!999)foo/" "(?<=\\d{3}...)(?<!999)foo" nil nil nil nil "123abcfoo" nil "foo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1540 "\"123456foo\" =~ /(?<=\\d{3}...)(?<!999)foo/" "(?<=\\d{3}...)(?<!999)foo" nil nil nil nil "123456foo" nil "foo" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1541 "\"123999foo\" =~ /(?<=\\d{3}...)(?<!999)foo/" "(?<=\\d{3}...)(?<!999)foo" nil nil nil nil "123999foo" nil nil nil)
+(1542 "\"<a href=abcd xyz\" =~ /<a[\\s]+href[\\s]*=[\\s]*          # find <a href=
+ ([\\\"\\'])?                       # find single or double quote
+ (?(1) (.*?)\\1 | ([^\\s]+))       # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+/isx" "<a[\\s]+href[\\s]*=[\\s]*          # find <a href=
+ ([\\\"\\'])?                       # find single or double quote
+ (?(1) (.*?)\\1 | ([^\\s]+))       # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+" t nil t t "<a href=abcd xyz" nil "<a href=abcd" (nil nil "abcd" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1543 "\"<a href=\\\"abcd xyz pqr\\\" cats\" =~ /<a[\\s]+href[\\s]*=[\\s]*          # find <a href=
+ ([\\\"\\'])?                       # find single or double quote
+ (?(1) (.*?)\\1 | ([^\\s]+))       # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+/isx" "<a[\\s]+href[\\s]*=[\\s]*          # find <a href=
+ ([\\\"\\'])?                       # find single or double quote
+ (?(1) (.*?)\\1 | ([^\\s]+))       # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+" t nil t t "<a href=\"abcd xyz pqr\" cats" nil "<a href=\"abcd xyz pqr\"" ("\"" "abcd xyz pqr" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1544 "\"<a href=\\'abcd xyz pqr\\' cats\" =~ /<a[\\s]+href[\\s]*=[\\s]*          # find <a href=
+ ([\\\"\\'])?                       # find single or double quote
+ (?(1) (.*?)\\1 | ([^\\s]+))       # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+/isx" "<a[\\s]+href[\\s]*=[\\s]*          # find <a href=
+ ([\\\"\\'])?                       # find single or double quote
+ (?(1) (.*?)\\1 | ([^\\s]+))       # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+" t nil t t "<a href='abcd xyz pqr' cats" nil "<a href='abcd xyz pqr'" ("'" "abcd xyz pqr" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1545 "\"<a href=abcd xyz\" =~ /<a\\s+href\\s*=\\s*                # find <a href=
+ ([\"'])?                         # find single or double quote
+ (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+/isx" "<a\\s+href\\s*=\\s*                # find <a href=
+ ([\"'])?                         # find single or double quote
+ (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+" t nil t t "<a href=abcd xyz" nil "<a href=abcd" (nil nil "abcd" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1546 "\"<a href=\\\"abcd xyz pqr\\\" cats\" =~ /<a\\s+href\\s*=\\s*                # find <a href=
+ ([\"'])?                         # find single or double quote
+ (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+/isx" "<a\\s+href\\s*=\\s*                # find <a href=
+ ([\"'])?                         # find single or double quote
+ (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+" t nil t t "<a href=\"abcd xyz pqr\" cats" nil "<a href=\"abcd xyz pqr\"" ("\"" "abcd xyz pqr" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1547 "\"<a href       =       \\'abcd xyz pqr\\' cats\" =~ /<a\\s+href\\s*=\\s*                # find <a href=
+ ([\"'])?                         # find single or double quote
+ (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+/isx" "<a\\s+href\\s*=\\s*                # find <a href=
+ ([\"'])?                         # find single or double quote
+ (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+" t nil t t "<a href       =       'abcd xyz pqr' cats" nil "<a href       =       'abcd xyz pqr'" ("'" "abcd xyz pqr" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1548 "\"<a href=abcd xyz\" =~ /<a\\s+href(?>\\s*)=(?>\\s*)        # find <a href=
+ ([\"'])?                         # find single or double quote
+ (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+/isx" "<a\\s+href(?>\\s*)=(?>\\s*)        # find <a href=
+ ([\"'])?                         # find single or double quote
+ (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+" t nil t t "<a href=abcd xyz" nil "<a href=abcd" (nil nil "abcd" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1549 "\"<a href=\\\"abcd xyz pqr\\\" cats\" =~ /<a\\s+href(?>\\s*)=(?>\\s*)        # find <a href=
+ ([\"'])?                         # find single or double quote
+ (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+/isx" "<a\\s+href(?>\\s*)=(?>\\s*)        # find <a href=
+ ([\"'])?                         # find single or double quote
+ (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+" t nil t t "<a href=\"abcd xyz pqr\" cats" nil "<a href=\"abcd xyz pqr\"" ("\"" "abcd xyz pqr" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1550 "\"<a href       =       \\'abcd xyz pqr\\' cats\" =~ /<a\\s+href(?>\\s*)=(?>\\s*)        # find <a href=
+ ([\"'])?                         # find single or double quote
+ (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+/isx" "<a\\s+href(?>\\s*)=(?>\\s*)        # find <a href=
+ ([\"'])?                         # find single or double quote
+ (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+" t nil t t "<a href       =       'abcd xyz pqr' cats" nil "<a href       =       'abcd xyz pqr'" ("'" "abcd xyz pqr" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1551 "\"ZABCDEFG\" =~ /((Z)+|A)*/" "((Z)+|A)*" nil nil nil nil "ZABCDEFG" nil "ZA" ("A" "Z" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1552 "\"ZABCDEFG\" =~ /(Z()|A)*/" "(Z()|A)*" nil nil nil nil "ZABCDEFG" nil "ZA" ("A" "" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1553 "\"ZABCDEFG\" =~ /(Z(())|A)*/" "(Z(())|A)*" nil nil nil nil "ZABCDEFG" nil "ZA" ("A" "" "" nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1554 "\"ZABCDEFG\" =~ /((?>Z)+|A)*/" "((?>Z)+|A)*" nil nil nil nil "ZABCDEFG" nil "ZA" ("A" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1555 "\"ZABCDEFG\" =~ /((?>)+|A)*/" "((?>)+|A)*" nil nil nil nil "ZABCDEFG" nil "" ("" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1556 "\"abbab\" =~ /a*/" "a*" nil nil nil nil "abbab" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1557 "\"abcde\" =~ /^[a-\\d]/" "^[a-\\d]" nil nil nil nil "abcde" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1558 "\"-things\" =~ /^[a-\\d]/" "^[a-\\d]" nil nil nil nil "-things" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1559 "\"0digit\" =~ /^[a-\\d]/" "^[a-\\d]" nil nil nil nil "0digit" nil "0" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1560 "\"bcdef\" =~ /^[a-\\d]/" "^[a-\\d]" nil nil nil nil "bcdef" nil nil nil)
+(1561 "\"abcde\" =~ /^[\\d-a]/" "^[\\d-a]" nil nil nil nil "abcde" nil "a" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1562 "\"-things\" =~ /^[\\d-a]/" "^[\\d-a]" nil nil nil nil "-things" nil "-" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1563 "\"0digit\" =~ /^[\\d-a]/" "^[\\d-a]" nil nil nil nil "0digit" nil "0" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1564 "\"bcdef\" =~ /^[\\d-a]/" "^[\\d-a]" nil nil nil nil "bcdef" nil nil nil)
+(1565 "\"abcdef\" =~ /(?<=abc).*(?=def)/" "(?<=abc).*(?=def)" nil nil nil nil "abcdef" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1566 "\"abcxdef\" =~ /(?<=abc).*(?=def)/" "(?<=abc).*(?=def)" nil nil nil nil "abcxdef" nil "x" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1567 "\"abcxdefxdef\" =~ /(?<=abc).*(?=def)/" "(?<=abc).*(?=def)" nil nil nil nil "abcxdefxdef" nil "xdefx" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1568 "\"abcdef\" =~ /(?<=abc).*?(?=def)/" "(?<=abc).*?(?=def)" nil nil nil nil "abcdef" nil "" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1569 "\"abcxdef\" =~ /(?<=abc).*?(?=def)/" "(?<=abc).*?(?=def)" nil nil nil nil "abcxdef" nil "x" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1570 "\"abcxdefxdef\" =~ /(?<=abc).*?(?=def)/" "(?<=abc).*?(?=def)" nil nil nil nil "abcxdefxdef" nil "x" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1571 "\"abcdef\" =~ /(?<=abc).+(?=def)/" "(?<=abc).+(?=def)" nil nil nil nil "abcdef" nil nil nil)
+(1572 "\"abcxdef\" =~ /(?<=abc).+(?=def)/" "(?<=abc).+(?=def)" nil nil nil nil "abcxdef" nil "x" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1573 "\"abcxdefxdef\" =~ /(?<=abc).+(?=def)/" "(?<=abc).+(?=def)" nil nil nil nil "abcxdefxdef" nil "xdefx" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1574 "\"abcdef\" =~ /(?<=abc).+?(?=def)/" "(?<=abc).+?(?=def)" nil nil nil nil "abcdef" nil nil nil)
+(1575 "\"abcxdef\" =~ /(?<=abc).+?(?=def)/" "(?<=abc).+?(?=def)" nil nil nil nil "abcxdef" nil "x" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1576 "\"abcxdefxdef\" =~ /(?<=abc).+?(?=def)/" "(?<=abc).+?(?=def)" nil nil nil nil "abcxdefxdef" nil "x" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1577 "\"-abcdef\" =~ /(?<=\\b)(.*)/" "(?<=\\b)(.*)" nil nil nil nil "-abcdef" nil "abcdef" ("abcdef" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1578 "\"abcdef\" =~ /(?<=\\b)(.*)/" "(?<=\\b)(.*)" nil nil nil nil "abcdef" nil "abcdef" ("abcdef" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1579 "\"-abcdef\" =~ /(?<=\\B)(.*)/" "(?<=\\B)(.*)" nil nil nil nil "-abcdef" nil "-abcdef" ("-abcdef" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1580 "\"abcdef\" =~ /(?<=\\B)(.*)/" "(?<=\\B)(.*)" nil nil nil nil "abcdef" nil "bcdef" ("bcdef" nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1581 "\"'a'\" =~ /^'[ab]'/" "^'[ab]'" nil nil nil nil "'a'" nil "'a'" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1582 "\"'b'\" =~ /^'[ab]'/" "^'[ab]'" nil nil nil nil "'b'" nil "'b'" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1583 "\"x'a'\" =~ /^'[ab]'/" "^'[ab]'" nil nil nil nil "x'a'" nil nil nil)
+(1584 "\"'a'x\" =~ /^'[ab]'/" "^'[ab]'" nil nil nil nil "'a'x" nil "'a'" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1585 "\"'ab'\" =~ /^'[ab]'/" "^'[ab]'" nil nil nil nil "'ab'" nil nil nil)
+(1586 "\"'a'\" =~ /^'[ab]'$/" "^'[ab]'$" nil nil nil nil "'a'" nil "'a'" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1587 "\"'b'\" =~ /^'[ab]'$/" "^'[ab]'$" nil nil nil nil "'b'" nil "'b'" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1588 "\"x'a'\" =~ /^'[ab]'$/" "^'[ab]'$" nil nil nil nil "x'a'" nil nil nil)
+(1589 "\"'a'x\" =~ /^'[ab]'$/" "^'[ab]'$" nil nil nil nil "'a'x" nil nil nil)
+(1590 "\"'ab'\" =~ /^'[ab]'$/" "^'[ab]'$" nil nil nil nil "'ab'" nil nil nil)
+(1591 "\"'a'\" =~ /'[ab]'$/" "'[ab]'$" nil nil nil nil "'a'" nil "'a'" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1592 "\"'b'\" =~ /'[ab]'$/" "'[ab]'$" nil nil nil nil "'b'" nil "'b'" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1593 "\"x'a'\" =~ /'[ab]'$/" "'[ab]'$" nil nil nil nil "x'a'" nil "'a'" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1594 "\"'a'x\" =~ /'[ab]'$/" "'[ab]'$" nil nil nil nil "'a'x" nil nil nil)
+(1595 "\"'ab'\" =~ /'[ab]'$/" "'[ab]'$" nil nil nil nil "'ab'" nil nil nil)
+(1596 "\"'a'\" =~ /'[ab]'/" "'[ab]'" nil nil nil nil "'a'" nil "'a'" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1597 "\"'b'\" =~ /'[ab]'/" "'[ab]'" nil nil nil nil "'b'" nil "'b'" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1598 "\"x'a'\" =~ /'[ab]'/" "'[ab]'" nil nil nil nil "x'a'" nil "'a'" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1599 "\"'a'x\" =~ /'[ab]'/" "'[ab]'" nil nil nil nil "'a'x" nil "'a'" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1600 "\"'ab'\" =~ /'[ab]'/" "'[ab]'" nil nil nil nil "'ab'" nil nil nil)
+(1601 "\"abc\" =~ /abc\\E/" "abc\\E" nil nil nil nil "abc" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1602 "\"abcE\" =~ /abc\\E/" "abc\\E" nil nil nil nil "abcE" nil "abc" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1603 "\"abcx\" =~ /abc[\\Ex]/" "abc[\\Ex]" nil nil nil nil "abcx" nil "abcx" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1604 "\"abcE\" =~ /abc[\\Ex]/" "abc[\\Ex]" nil nil nil nil "abcE" nil nil nil)
+(1605 "\"a*\" =~ /^\\Qa*\\E$/" "^\\Qa*\\E$" nil nil nil nil "a*" nil "a*" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1606 "\"a\" =~ /^\\Qa*\\E$/" "^\\Qa*\\E$" nil nil nil nil "a" nil nil nil)
+(1607 "\"a*x\" =~ /\\Qa*x\\E/" "\\Qa*x\\E" nil nil nil nil "a*x" nil "a*x" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1608 "\"a*\" =~ /\\Qa*x\\E/" "\\Qa*x\\E" nil nil nil nil "a*" nil nil nil)
+(1609 "\"a*x\" =~ /\\Qa*x/" "\\Qa*x" nil nil nil nil "a*x" nil "a*x" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1610 "\"a*\" =~ /\\Qa*x/" "\\Qa*x" nil nil nil nil "a*" nil nil nil)
+(1611 "\"a*x\" =~ /\\Q\\Qa*x\\E\\E/" "\\Q\\Qa*x\\E\\E" nil nil nil nil "a*x" nil nil nil)
+(1612 "\"a\\\\*x\" =~ /\\Q\\Qa*x\\E\\E/" "\\Q\\Qa*x\\E\\E" nil nil nil nil "a\\*x" nil "a\\*x" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1613 "\"a*x\" =~ /\\Q\\Qa*x\\E/" "\\Q\\Qa*x\\E" nil nil nil nil "a*x" nil nil nil)
+(1614 "\"a\\\\*x\" =~ /\\Q\\Qa*x\\E/" "\\Q\\Qa*x\\E" nil nil nil nil "a\\*x" nil "a\\*x" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1615 "\"a[x]\" =~ /a\\Q[x\\E]/" "a\\Q[x\\E]" nil nil nil nil "a[x]" nil "a[x]" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1616 "\"ax\" =~ /a\\Q[x\\E]/" "a\\Q[x\\E]" nil nil nil nil "ax" nil nil nil)
+(1617 "\"a\" =~ /a#comment\\Q...
+{2}/x" "a#comment\\Q...
+{2}" nil nil nil t "a" nil nil nil)
+(1618 "\"aa\" =~ /a#comment\\Q...
+{2}/x" "a#comment\\Q...
+{2}" nil nil nil t "aa" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1619 "\"a\" =~ /a(?#comment\\Q...
+){2}/x" "a(?#comment\\Q...
+){2}" nil nil nil t "a" nil nil nil)
+(1620 "\"aa\" =~ /a(?#comment\\Q...
+){2}/x" "a(?#comment\\Q...
+){2}" nil nil nil t "aa" nil "aa" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1621 "\"a.\" =~ /(?x)a#\\Q
+./" "(?x)a#\\Q
+." nil nil nil nil "a." nil "a." (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1622 "\"aa\" =~ /(?x)a#\\Q
+./" "(?x)a#\\Q
+." nil nil nil nil "aa" nil nil nil)
+(1623 "\"abcdxklqj\" =~ /ab(?=.*q)cd/" "ab(?=.*q)cd" nil nil nil nil "abcdxklqj" nil "abcd" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1624 "\"ab\" =~ /a(?!.*$)b/" "a(?!.*$)b" nil nil nil nil "ab" nil nil nil)
+(1625 "\"Axi\" =~ /.{2}[a-z]/" ".{2}[a-z]" nil nil nil nil "Axi" nil "Axi" (nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1626 "\"aaaaaaaaaac\" =~ /((a{0,5}){0,5}){0,5}c/" "((a{0,5}){0,5}){0,5}c" nil nil nil nil "aaaaaaaaaac" nil "aaaaaaaaaac" ("" "" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1627 "\"aaaaaaaaaa\" =~ /((a{0,5}){0,5}){0,5}c/" "((a{0,5}){0,5}){0,5}c" nil nil nil nil "aaaaaaaaaa" nil nil nil)
+(1628 "\"aaaaaaaaaac\" =~ /((a{0,5}){0,5})*c/" "((a{0,5}){0,5})*c" nil nil nil nil "aaaaaaaaaac" nil "aaaaaaaaaac" ("" "" nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
+(1629 "\"aaaaaaaaaa\" =~ /((a{0,5}){0,5})*c/" "((a{0,5}){0,5})*c" nil nil nil nil "aaaaaaaaaa" nil nil nil)
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/perltestinput b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/perltestinput
new file mode 100644
index 0000000..1425493
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/perltestinput
@@ -0,0 +1,3956 @@
+/the quick brown fox/
+    the quick brown fox
+    The quick brown FOX
+    What do you know about the quick brown fox?
+    What do you know about THE QUICK BROWN FOX?
+
+/The quick brown fox/i
+    the quick brown fox
+    The quick brown FOX
+    What do you know about the quick brown fox?
+    What do you know about THE QUICK BROWN FOX?
+
+/abcd\t\n\r\f\a\e\071\x3b\$\\\?caxyz/
+    abcd\t\n\r\f\a\e9;\$\\?caxyz
+
+/a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/
+    abxyzpqrrrabbxyyyypqAzz
+    abxyzpqrrrabbxyyyypqAzz
+    aabxyzpqrrrabbxyyyypqAzz
+    aaabxyzpqrrrabbxyyyypqAzz
+    aaaabxyzpqrrrabbxyyyypqAzz
+    abcxyzpqrrrabbxyyyypqAzz
+    aabcxyzpqrrrabbxyyyypqAzz
+    aaabcxyzpqrrrabbxyyyypAzz
+    aaabcxyzpqrrrabbxyyyypqAzz
+    aaabcxyzpqrrrabbxyyyypqqAzz
+    aaabcxyzpqrrrabbxyyyypqqqAzz
+    aaabcxyzpqrrrabbxyyyypqqqqAzz
+    aaabcxyzpqrrrabbxyyyypqqqqqAzz
+    aaabcxyzpqrrrabbxyyyypqqqqqqAzz
+    aaaabcxyzpqrrrabbxyyyypqAzz
+    abxyzzpqrrrabbxyyyypqAzz
+    aabxyzzzpqrrrabbxyyyypqAzz
+    aaabxyzzzzpqrrrabbxyyyypqAzz
+    aaaabxyzzzzpqrrrabbxyyyypqAzz
+    abcxyzzpqrrrabbxyyyypqAzz
+    aabcxyzzzpqrrrabbxyyyypqAzz
+    aaabcxyzzzzpqrrrabbxyyyypqAzz
+    aaaabcxyzzzzpqrrrabbxyyyypqAzz
+    aaaabcxyzzzzpqrrrabbbxyyyypqAzz
+    aaaabcxyzzzzpqrrrabbbxyyyyypqAzz
+    aaabcxyzpqrrrabbxyyyypABzz
+    aaabcxyzpqrrrabbxyyyypABBzz
+    >>>aaabxyzpqrrrabbxyyyypqAzz
+    >aaaabxyzpqrrrabbxyyyypqAzz
+    >>>>abcxyzpqrrrabbxyyyypqAzz
+    abxyzpqrrabbxyyyypqAzz
+    abxyzpqrrrrabbxyyyypqAzz
+    abxyzpqrrrabxyyyypqAzz
+    aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz
+    aaaabcxyzzzzpqrrrabbbxyyypqAzz
+    aaabcxyzpqrrrabbxyyyypqqqqqqqAzz
+
+/^(abc){1,2}zz/
+    abczz
+    abcabczz
+    zz
+    abcabcabczz
+    >>abczz
+
+/^(b+?|a){1,2}?c/
+    bc
+    bbc
+    bbbc
+    bac
+    bbac
+    aac
+    abbbbbbbbbbbc
+    bbbbbbbbbbbac
+    aaac
+    abbbbbbbbbbbac
+
+/^(b+|a){1,2}c/
+    bc
+    bbc
+    bbbc
+    bac
+    bbac
+    aac
+    abbbbbbbbbbbc
+    bbbbbbbbbbbac
+    aaac
+    abbbbbbbbbbbac
+
+/^(b+|a){1,2}?bc/
+    bbc
+
+/^(b*|ba){1,2}?bc/
+    babc
+    bbabc
+    bababc
+    bababbc
+    babababc
+
+/^(ba|b*){1,2}?bc/
+    babc
+    bbabc
+    bababc
+    bababbc
+    babababc
+
+/^\ca\cA\c[\c{\c:/
+    \x01\x01\e;z
+
+/^[ab\]cde]/
+    athing
+    bthing
+    ]thing
+    cthing
+    dthing
+    ething
+    fthing
+    [thing
+    \\thing
+
+/^[]cde]/
+    ]thing
+    cthing
+    dthing
+    ething
+    athing
+    fthing
+
+/^[^ab\]cde]/
+    fthing
+    [thing
+    \\thing
+    athing
+    bthing
+    ]thing
+    cthing
+    dthing
+    ething
+
+/^[^]cde]/
+    athing
+    fthing
+    ]thing
+    cthing
+    dthing
+    ething
+
+/^\�/
+    �
+
+/^�/
+    �
+
+/^[0-9]+$/
+    0
+    1
+    2
+    3
+    4
+    5
+    6
+    7
+    8
+    9
+    10
+    100
+    abc
+
+/^.*nter/
+    enter
+    inter
+    uponter
+
+/^xxx[0-9]+$/
+    xxx0
+    xxx1234
+    xxx
+
+/^.+[0-9][0-9][0-9]$/
+    x123
+    xx123
+    123456
+    123
+    x1234
+
+/^.+?[0-9][0-9][0-9]$/
+    x123
+    xx123
+    123456
+    123
+    x1234
+
+/^([^!]+)!(.+)=apquxz\.ixr\.zzz\.ac\.uk$/
+    abc!pqr=apquxz.ixr.zzz.ac.uk
+    !pqr=apquxz.ixr.zzz.ac.uk
+    abc!=apquxz.ixr.zzz.ac.uk
+    abc!pqr=apquxz:ixr.zzz.ac.uk
+    abc!pqr=apquxz.ixr.zzz.ac.ukk
+
+/:/
+    Well, we need a colon: somewhere
+    Fail if we don't
+
+/([\da-f:]+)$/i
+    0abc
+    abc
+    fed
+    E
+    ::
+    5f03:12C0::932e
+    fed def
+    Any old stuff
+    0zzz
+    gzzz
+    fed\x20
+    Any old rubbish
+
+/^.*\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/
+    .1.2.3
+    A.12.123.0
+    .1.2.3333
+    1.2.3
+    1234.2.3
+
+/^(\d+)\s+IN\s+SOA\s+(\S+)\s+(\S+)\s*\(\s*$/
+    1 IN SOA non-sp1 non-sp2(
+    1    IN    SOA    non-sp1    non-sp2   (
+    1IN SOA non-sp1 non-sp2(
+
+/^[a-zA-Z\d][a-zA-Z\d\-]*(\.[a-zA-Z\d][a-zA-z\d\-]*)*\.$/
+    a.
+    Z.
+    2.
+    ab-c.pq-r.
+    sxk.zzz.ac.uk.
+    x-.y-.
+    -abc.peq.
+
+/^\*\.[a-z]([a-z\-\d]*[a-z\d]+)?(\.[a-z]([a-z\-\d]*[a-z\d]+)?)*$/
+    *.a
+    *.b0-a
+    *.c3-b.c
+    *.c-a.b-c
+    *.0
+    *.a-
+    *.a-b.c-
+    *.c-a.0-c
+
+/^(?=ab(de))(abd)(e)/
+    abde
+
+/^(?!(ab)de|x)(abd)(f)/
+    abdf
+
+/^(?=(ab(cd)))(ab)/
+    abcd
+
+/^[\da-f](\.[\da-f])*$/i
+    a.b.c.d
+    A.B.C.D
+    a.b.c.1.2.3.C
+
+/^\".*\"\s*(;.*)?$/
+    \"1234\"
+    \"abcd\" ;
+    \"\" ; rhubarb
+    \"1234\" : things
+
+/^$/
+    \
+
+/   ^    a   (?# begins with a)  b\sc (?# then b c) $ (?# then end)/x
+    ab c
+    abc
+    ab cde
+
+/(?x)   ^    a   (?# begins with a)  b\sc (?# then b c) $ (?# then end)/
+    ab c
+    abc
+    ab cde
+
+/^   a\ b[c ]d       $/x
+    a bcd
+    a b d
+    abcd
+    ab d
+
+/^(a(b(c)))(d(e(f)))(h(i(j)))(k(l(m)))$/
+    abcdefhijklm
+
+/^(?:a(b(c)))(?:d(e(f)))(?:h(i(j)))(?:k(l(m)))$/
+    abcdefhijklm
+
+/^[\w][\W][\s][\S][\d][\D][\b][\n][\c]][\022]/
+    a+ Z0+\x08\n\x1d\x12
+
+/^[.^$|()*+?{,}]+/
+    .^\$(*+)|{?,?}
+
+/^a*\w/
+    z
+    az
+    aaaz
+    a
+    aa
+    aaaa
+    a+
+    aa+
+
+/^a*?\w/
+    z
+    az
+    aaaz
+    a
+    aa
+    aaaa
+    a+
+    aa+
+
+/^a+\w/
+    az
+    aaaz
+    aa
+    aaaa
+    aa+
+
+/^a+?\w/
+    az
+    aaaz
+    aa
+    aaaa
+    aa+
+
+/^\d{8}\w{2,}/
+    1234567890
+    12345678ab
+    12345678__
+    1234567
+
+/^[aeiou\d]{4,5}$/
+    uoie
+    1234
+    12345
+    aaaaa
+    123456
+
+/^[aeiou\d]{4,5}?/
+    uoie
+    1234
+    12345
+    aaaaa
+    123456
+
+/\A(abc|def)=(\1){2,3}\Z/
+    abc=abcabc
+    def=defdefdef
+    abc=defdef
+
+/^(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\11*(\3\4)\1(?#)2$/
+    abcdefghijkcda2
+    abcdefghijkkkkcda2
+
+/(cat(a(ract|tonic)|erpillar)) \1()2(3)/
+    cataract cataract23
+    catatonic catatonic23
+    caterpillar caterpillar23
+
+
+/^From +([^ ]+) +[a-zA-Z][a-zA-Z][a-zA-Z] +[a-zA-Z][a-zA-Z][a-zA-Z] +[0-9]?[0-9] +[0-9][0-9]:[0-9][0-9]/
+    From abcd  Mon Sep 01 12:33:02 1997
+
+/^From\s+\S+\s+([a-zA-Z]{3}\s+){2}\d{1,2}\s+\d\d:\d\d/
+    From abcd  Mon Sep 01 12:33:02 1997
+    From abcd  Mon Sep  1 12:33:02 1997
+    From abcd  Sep 01 12:33:02 1997
+
+/^12.34/s
+    12\n34
+    12\r34
+
+/\w+(?=\t)/
+    the quick brown\t fox
+
+/foo(?!bar)(.*)/
+    foobar is foolish see?
+
+/(?:(?!foo)...|^.{0,2})bar(.*)/
+    foobar crowbar etc
+    barrel
+    2barrel
+    A barrel
+
+/^(\D*)(?=\d)(?!123)/
+    abc456
+    abc123
+
+/^1234(?# test newlines
+  inside)/
+    1234
+
+/^1234 #comment in extended re
+  /x
+    1234
+
+/#rhubarb
+  abcd/x
+    abcd
+
+/^abcd#rhubarb/x
+    abcd
+
+/^(a)\1{2,3}(.)/
+    aaab
+    aaaab
+    aaaaab
+    aaaaaab
+
+/(?!^)abc/
+    the abc
+    abc
+
+/(?=^)abc/
+    abc
+    the abc
+
+/^[ab]{1,3}(ab*|b)/
+    aabbbbb
+
+/^[ab]{1,3}?(ab*|b)/
+    aabbbbb
+
+/^[ab]{1,3}?(ab*?|b)/
+    aabbbbb
+
+/^[ab]{1,3}(ab*?|b)/
+    aabbbbb
+
+/  (?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*                          # optional leading comment
+(?:    (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+" (?:                      # opening quote...
+[^\\\x80-\xff\n\015"]                #   Anything except backslash and quote
+|                     #    or
+\\ [^\x80-\xff]           #   Escaped something (something != CR)
+)* "  # closing quote
+)                    # initial word
+(?:  (?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*  \.  (?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*   (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+" (?:                      # opening quote...
+[^\\\x80-\xff\n\015"]                #   Anything except backslash and quote
+|                     #    or
+\\ [^\x80-\xff]           #   Escaped something (something != CR)
+)* "  # closing quote
+)  )* # further okay, if led by a period
+(?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*  @  (?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*    (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|   \[                         # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
+\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*  \.                        # if led by a period...
+(?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*   (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|   \[                         # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
+\]                        #           ]
+)                     #   ...further okay
+)*
+# address
+|                     #  or
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+" (?:                      # opening quote...
+[^\\\x80-\xff\n\015"]                #   Anything except backslash and quote
+|                     #    or
+\\ [^\x80-\xff]           #   Escaped something (something != CR)
+)* "  # closing quote
+)             # one word, optionally followed by....
+(?:
+[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037]  |  # atom and space parts, or...
+\(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)       |  # comments, or...
+
+" (?:                      # opening quote...
+[^\\\x80-\xff\n\015"]                #   Anything except backslash and quote
+|                     #    or
+\\ [^\x80-\xff]           #   Escaped something (something != CR)
+)* "  # closing quote
+# quoted strings
+)*
+<  (?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*                     # leading <
+(?:  @  (?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*    (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|   \[                         # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
+\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*  \.                        # if led by a period...
+(?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*   (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|   \[                         # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
+\]                        #           ]
+)                     #   ...further okay
+)*
+
+(?:  (?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*  ,  (?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*  @  (?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*    (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|   \[                         # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
+\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*  \.                        # if led by a period...
+(?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*   (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|   \[                         # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
+\]                        #           ]
+)                     #   ...further okay
+)*
+)* # further okay, if led by comma
+:                                # closing colon
+(?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*  )? #       optional route
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+" (?:                      # opening quote...
+[^\\\x80-\xff\n\015"]                #   Anything except backslash and quote
+|                     #    or
+\\ [^\x80-\xff]           #   Escaped something (something != CR)
+)* "  # closing quote
+)                    # initial word
+(?:  (?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*  \.  (?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*   (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+" (?:                      # opening quote...
+[^\\\x80-\xff\n\015"]                #   Anything except backslash and quote
+|                     #    or
+\\ [^\x80-\xff]           #   Escaped something (something != CR)
+)* "  # closing quote
+)  )* # further okay, if led by a period
+(?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*  @  (?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*    (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|   \[                         # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
+\]                        #           ]
+)                           # initial subdomain
+(?:                                  #
+(?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*  \.                        # if led by a period...
+(?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*   (?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|   \[                         # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
+\]                        #           ]
+)                     #   ...further okay
+)*
+#       address spec
+(?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*  > #                  trailing >
+# name and address
+)  (?: [\040\t] |  \(
+(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
+\)  )*                       # optional trailing comment
+/x
+    Alan Other <user\@dom.ain>
+    <user\@dom.ain>
+    user\@dom.ain
+    \"A. Other\" <user.1234\@dom.ain> (a comment)
+    A. Other <user.1234\@dom.ain> (a comment)
+    \"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"\@x400-re.lay
+    A missing angle <user\@some.where
+    The quick brown fox
+
+/[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+# optional leading comment
+(?:
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+"                                     # "
+[^\\\x80-\xff\n\015"] *                            #   normal
+(?:  \\ [^\x80-\xff]  [^\\\x80-\xff\n\015"] * )*        #   ( special normal* )*
+"                                     #        "
+# Quoted string
+)
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+(?:
+\.
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+"                                     # "
+[^\\\x80-\xff\n\015"] *                            #   normal
+(?:  \\ [^\x80-\xff]  [^\\\x80-\xff\n\015"] * )*        #   ( special normal* )*
+"                                     #        "
+# Quoted string
+)
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[                            # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
+\]                           #           ]
+)
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\.
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[                            # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
+\]                           #           ]
+)
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+# address
+|                             #  or
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+"                                     # "
+[^\\\x80-\xff\n\015"] *                            #   normal
+(?:  \\ [^\x80-\xff]  [^\\\x80-\xff\n\015"] * )*        #   ( special normal* )*
+"                                     #        "
+# Quoted string
+)
+# leading word
+[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037] *               # "normal" atoms and or spaces
+(?:
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+|
+"                                     # "
+[^\\\x80-\xff\n\015"] *                            #   normal
+(?:  \\ [^\x80-\xff]  [^\\\x80-\xff\n\015"] * )*        #   ( special normal* )*
+"                                     #        "
+) # "special" comment or quoted string
+[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037] *            #  more "normal"
+)*
+<
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+# <
+(?:
+@
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[                            # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
+\]                           #           ]
+)
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\.
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[                            # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
+\]                           #           ]
+)
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+(?: ,
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+@
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[                            # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
+\]                           #           ]
+)
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\.
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[                            # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
+\]                           #           ]
+)
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+)*  # additional domains
+:
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)?     #       optional route
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+"                                     # "
+[^\\\x80-\xff\n\015"] *                            #   normal
+(?:  \\ [^\x80-\xff]  [^\\\x80-\xff\n\015"] * )*        #   ( special normal* )*
+"                                     #        "
+# Quoted string
+)
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+(?:
+\.
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+# Atom
+|                       #  or
+"                                     # "
+[^\\\x80-\xff\n\015"] *                            #   normal
+(?:  \\ [^\x80-\xff]  [^\\\x80-\xff\n\015"] * )*        #   ( special normal* )*
+"                                     #        "
+# Quoted string
+)
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+# additional words
+)*
+@
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[                            # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
+\]                           #           ]
+)
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+(?:
+\.
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+(?:
+[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
+|
+\[                            # [
+(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
+\]                           #           ]
+)
+[\040\t]*                    # Nab whitespace.
+(?:
+\(                              #  (
+[^\\\x80-\xff\n\015()] *                             #     normal*
+(?:                                 #       (
+(?:  \\ [^\x80-\xff]  |
+\(                            #  (
+[^\\\x80-\xff\n\015()] *                            #     normal*
+(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
+\)                           #                       )
+)    #         special
+[^\\\x80-\xff\n\015()] *                         #         normal*
+)*                                  #            )*
+\)                             #                )
+[\040\t]* )*    # If comment found, allow more spaces.
+# optional trailing comments
+)*
+#       address spec
+>                    #                 >
+# name and address
+)
+/x
+    Alan Other <user\@dom.ain>
+    <user\@dom.ain>
+    user\@dom.ain
+    \"A. Other\" <user.1234\@dom.ain> (a comment)
+    A. Other <user.1234\@dom.ain> (a comment)
+    \"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"\@x400-re.lay
+    A missing angle <user\@some.where
+    The quick brown fox
+
+/abc\0def\00pqr\000xyz\0000AB/
+    abc\0def\00pqr\000xyz\0000AB
+    abc456 abc\0def\00pqr\000xyz\0000ABCDE
+
+/abc\x0def\x00pqr\x000xyz\x0000AB/
+    abc\x0def\x00pqr\x000xyz\x0000AB
+    abc456 abc\x0def\x00pqr\x000xyz\x0000ABCDE
+
+/^[\000-\037]/
+    \0A
+    \01B
+    \037C
+
+/\0*/
+    \0\0\0\0
+
+/A\x0{2,3}Z/
+    The A\x0\x0Z
+    An A\0\x0\0Z
+    A\0Z
+    A\0\x0\0\x0Z
+
+/^(cow|)\1(bell)/
+    cowcowbell
+    bell
+    cowbell
+
+/^\s/
+    \040abc
+    \x0cabc
+    \nabc
+    \rabc
+    \tabc
+    abc
+
+/^a	b
+  
    c/x
+    abc
+
+/^(a|)\1*b/
+    ab
+    aaaab
+    b
+    acb
+
+/^(a|)\1+b/
+    aab
+    aaaab
+    b
+    ab
+
+/^(a|)\1?b/
+    ab
+    aab
+    b
+    acb
+
+/^(a|)\1{2}b/
+    aaab
+    b
+    ab
+    aab
+    aaaab
+
+/^(a|)\1{2,3}b/
+    aaab
+    aaaab
+    b
+    ab
+    aab
+    aaaaab
+
+/ab{1,3}bc/
+    abbbbc
+    abbbc
+    abbc
+    abc
+    abbbbbc
+
+/([^.]*)\.([^:]*):[T ]+(.*)/
+    track1.title:TBlah blah blah
+
+/([^.]*)\.([^:]*):[T ]+(.*)/i
+    track1.title:TBlah blah blah
+
+/([^.]*)\.([^:]*):[t ]+(.*)/i
+    track1.title:TBlah blah blah
+
+/^[W-c]+$/
+    WXY_^abc
+    wxy
+
+/^[W-c]+$/i
+    WXY_^abc
+    wxy_^ABC
+
+/^[\x3f-\x5F]+$/i
+    WXY_^abc
+    wxy_^ABC
+
+/^abc$/m
+    abc
+    qqq\nabc
+    abc\nzzz
+    qqq\nabc\nzzz
+
+/^abc$/
+    abc
+    qqq\nabc
+    abc\nzzz
+    qqq\nabc\nzzz
+
+/\Aabc\Z/m
+    abc
+    abc\n 
+    qqq\nabc
+    abc\nzzz
+    qqq\nabc\nzzz
+    
+/\A(.)*\Z/s
+    abc\ndef
+
+/\A(.)*\Z/m
+    abc\ndef
+
+/(?:b)|(?::+)/
+    b::c
+    c::b
+
+/[-az]+/
+    az-
+    b
+
+/[az-]+/
+    za-
+    b
+
+/[a\-z]+/
+    a-z
+    b
+
+/[a-z]+/
+    abcdxyz
+
+/[\d-]+/
+    12-34
+    aaa
+
+/[\d-z]+/
+    12-34z
+    aaa
+
+/\x5c/
+    \\
+
+/\x20Z/
+    the Zoo
+    Zulu
+
+/(abc)\1/i
+    abcabc
+    ABCabc
+    abcABC
+
+/ab{3cd/
+    ab{3cd
+
+/ab{3,cd/
+    ab{3,cd
+
+/ab{3,4a}cd/
+    ab{3,4a}cd
+
+/{4,5a}bc/
+    {4,5a}bc
+
+/^a.b/
+    a\rb
+    a\nb
+
+/abc$/
+    abc
+    abc\n
+    abc\ndef
+
+/(abc)\123/
+    abc\x53
+
+/(abc)\223/
+    abc\x93
+
+/(abc)\323/
+    abc\xd3
+
+/(abc)\500/
+    abc\x40
+    abc\100
+
+/(abc)\5000/
+    abc\x400
+    abc\x40\x30
+    abc\1000
+    abc\100\x30
+    abc\100\060
+    abc\100\60
+
+/abc\81/
+    abc\081
+    abc\0\x38\x31
+
+/abc\91/
+    abc\091
+    abc\0\x39\x31
+
+/(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\12\123/
+    abcdefghijkllS
+
+/(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\12\123/
+    abcdefghijk\12S
+
+/ab\gdef/
+    abgdef
+
+/a{0}bc/
+    bc
+
+/(a|(bc)){0,0}?xyz/
+    xyz
+
+/abc[\10]de/
+    abc\010de
+
+/abc[\1]de/
+    abc\1de
+
+/(abc)[\1]de/
+    abc\1de
+
+/a.b(?s)/
+    a\nb
+
+/^([^a])([^\b])([^c]*)([^d]{3,4})/
+    baNOTccccd
+    baNOTcccd
+    baNOTccd
+    bacccd
+    anything
+    b\bc   
+    baccd
+
+/[^a]/
+    Abc
+  
+/[^a]/i
+    Abc 
+
+/[^a]+/
+    AAAaAbc
+  
+/[^a]+/i
+    AAAaAbc 
+
+/[^a]+/
+    bbb\nccc
+   
+/[^k]$/
+    abc
+    abk   
+   
+/[^k]{2,3}$/
+    abc
+    kbc
+    kabc 
+    abk
+    akb
+    akk 
+
+/^\d{8,}\@.+[^k]$/
+    12345678\@a.b.c.d
+    123456789\@x.y.z
+    12345678\@x.y.uk
+    1234567\@a.b.c.d       
+
+/(a)\1{8,}/
+    aaaaaaaaa
+    aaaaaaaaaa
+    aaaaaaa   
+
+/[^a]/
+    aaaabcd
+    aaAabcd 
+
+/[^a]/i
+    aaaabcd
+    aaAabcd 
+
+/[^az]/
+    aaaabcd
+    aaAabcd 
+
+/[^az]/i
+    aaaabcd
+    aaAabcd 
+
+/\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377/
+ \000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377
+
+/P[^*]TAIRE[^*]{1,6}?LL/
+    xxxxxxxxxxxPSTAIREISLLxxxxxxxxx
+
+/P[^*]TAIRE[^*]{1,}?LL/
+    xxxxxxxxxxxPSTAIREISLLxxxxxxxxx
+
+/(\.\d\d[1-9]?)\d+/
+    1.230003938
+    1.875000282   
+    1.235  
+                  
+/(\.\d\d((?=0)|\d(?=\d)))/
+    1.230003938      
+    1.875000282
+    1.235 
+    
+/a(?)b/
+    ab 
+ 
+/\b(foo)\s+(\w+)/i
+    Food is on the foo table
+    
+/foo(.*)bar/
+    The food is under the bar in the barn.
+    
+/foo(.*?)bar/  
+    The food is under the bar in the barn.
+
+/(.*)(\d*)/
+    I have 2 numbers: 53147
+    
+/(.*)(\d+)/
+    I have 2 numbers: 53147
+ 
+/(.*?)(\d*)/
+    I have 2 numbers: 53147
+
+/(.*?)(\d+)/
+    I have 2 numbers: 53147
+
+/(.*)(\d+)$/
+    I have 2 numbers: 53147
+
+/(.*?)(\d+)$/
+    I have 2 numbers: 53147
+
+/(.*)\b(\d+)$/
+    I have 2 numbers: 53147
+
+/(.*\D)(\d+)$/
+    I have 2 numbers: 53147
+
+/^\D*(?!123)/
+    ABC123
+     
+/^(\D*)(?=\d)(?!123)/
+    ABC445
+    ABC123
+    
+/^[W-]46]/
+    W46]789 
+    -46]789
+    Wall
+    Zebra
+    42
+    [abcd] 
+    ]abcd[
+       
+/^[W-\]46]/
+    W46]789 
+    Wall
+    Zebra
+    Xylophone  
+    42
+    [abcd] 
+    ]abcd[
+    \\backslash 
+    -46]789
+    well
+    
+/\d\d\/\d\d\/\d\d\d\d/
+    01/01/2000
+
+/word (?:[a-zA-Z0-9]+ ){0,10}otherword/
+  word cat dog elephant mussel cow horse canary baboon snake shark otherword
+  word cat dog elephant mussel cow horse canary baboon snake shark
+
+/word (?:[a-zA-Z0-9]+ ){0,300}otherword/
+  word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope
+
+/^(a){0,0}/
+    bcd
+    abc
+    aab     
+
+/^(a){0,1}/
+    bcd
+    abc
+    aab  
+
+/^(a){0,2}/
+    bcd
+    abc
+    aab  
+
+/^(a){0,3}/
+    bcd
+    abc
+    aab
+    aaa   
+
+/^(a){0,}/
+    bcd
+    abc
+    aab
+    aaa
+    aaaaaaaa    
+
+/^(a){1,1}/
+    bcd
+    abc
+    aab  
+
+/^(a){1,2}/
+    bcd
+    abc
+    aab  
+
+/^(a){1,3}/
+    bcd
+    abc
+    aab
+    aaa   
+
+/^(a){1,}/
+    bcd
+    abc
+    aab
+    aaa
+    aaaaaaaa    
+
+/.*\.gif/
+    borfle\nbib.gif\nno
+
+/.{0,}\.gif/
+    borfle\nbib.gif\nno
+
+/.*\.gif/m
+    borfle\nbib.gif\nno
+
+/.*\.gif/s
+    borfle\nbib.gif\nno
+
+/.*\.gif/ms
+    borfle\nbib.gif\nno
+    
+/.*$/
+    borfle\nbib.gif\nno
+
+/.*$/m
+    borfle\nbib.gif\nno
+
+/.*$/s
+    borfle\nbib.gif\nno
+
+/.*$/ms
+    borfle\nbib.gif\nno
+    
+/.*$/
+    borfle\nbib.gif\nno\n
+
+/.*$/m
+    borfle\nbib.gif\nno\n
+
+/.*$/s
+    borfle\nbib.gif\nno\n
+
+/.*$/ms
+    borfle\nbib.gif\nno\n
+    
+/(.*X|^B)/
+    abcde\n1234Xyz
+    BarFoo 
+    abcde\nBar  
+
+/(.*X|^B)/m
+    abcde\n1234Xyz
+    BarFoo 
+    abcde\nBar  
+
+/(.*X|^B)/s
+    abcde\n1234Xyz
+    BarFoo 
+    abcde\nBar  
+
+/(.*X|^B)/ms
+    abcde\n1234Xyz
+    BarFoo 
+    abcde\nBar  
+
+/(?s)(.*X|^B)/
+    abcde\n1234Xyz
+    BarFoo 
+    abcde\nBar  
+
+/(?s:.*X|^B)/
+    abcde\n1234Xyz
+    BarFoo 
+    abcde\nBar  
+
+/^.*B/
+    abc\nB
+     
+/(?s)^.*B/
+    abc\nB
+
+/(?m)^.*B/
+    abc\nB
+     
+/(?ms)^.*B/
+    abc\nB
+
+/(?ms)^B/
+    abc\nB
+
+/(?s)B$/
+    B\n
+
+/^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]/
+    123456654321
+  
+/^\d\d\d\d\d\d\d\d\d\d\d\d/
+    123456654321 
+
+/^[\d][\d][\d][\d][\d][\d][\d][\d][\d][\d][\d][\d]/
+    123456654321
+  
+/^[abc]{12}/
+    abcabcabcabc
+    
+/^[a-c]{12}/
+    abcabcabcabc
+    
+/^(a|b|c){12}/
+    abcabcabcabc 
+
+/^[abcdefghijklmnopqrstuvwxy0123456789]/
+    n
+    z 
+
+/abcde{0,0}/
+    abcd
+    abce  
+
+/ab[cd]{0,0}e/
+    abe
+    abcde 
+    
+/ab(c){0,0}d/
+    abd
+    abcd   
+
+/a(b*)/
+    a
+    ab
+    abbbb
+    bbbbb    
+    
+/ab\d{0}e/
+    abe
+    ab1e   
+    
+/"([^\\"]+|\\.)*"/
+    the \"quick\" brown fox
+    \"the \\\"quick\\\" brown fox\" 
+
+/.*?/g+
+    abc
+  
+/\b/g+
+    abc 
+
+/\b/+g
+    abc 
+
+//g
+    abc
+
+/<tr([\w\W\s\d][^<>]{0,})><TD([\w\W\s\d][^<>]{0,})>([\d]{0,}\.)(.*)((<BR>([\w\W\s\d][^<>]{0,})|[\s]{0,}))<\/a><\/TD><TD([\w\W\s\d][^<>]{0,})>([\w\W\s\d][^<>]{0,})<\/TD><TD([\w\W\s\d][^<>]{0,})>([\w\W\s\d][^<>]{0,})<\/TD><\/TR>/is
+  <TR BGCOLOR='#DBE9E9'><TD align=left valign=top>43.<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)</a></TD><TD align=left valign=top>Lega lstaff.com</TD><TD align=left valign=top>CA - Statewide</TD></TR>
+
+/a[^a]b/
+    acb
+    a\nb
+    
+/a.b/
+    acb
+    a\nb   
+    
+/a[^a]b/s
+    acb
+    a\nb  
+    
+/a.b/s
+    acb
+    a\nb  
+
+/^(b+?|a){1,2}?c/
+    bac
+    bbac
+    bbbac
+    bbbbac
+    bbbbbac 
+
+/^(b+|a){1,2}?c/
+    bac
+    bbac
+    bbbac
+    bbbbac
+    bbbbbac 
+    
+/(?!\A)x/m
+    x\nb\n
+    a\bx\n  
+    
+/\x0{ab}/
+    \0{ab} 
+
+/(A|B)*?CD/
+    CD 
+    
+/(A|B)*CD/
+    CD 
+
+/(AB)*?\1/
+    ABABAB
+
+/(AB)*\1/
+    ABABAB
+    
+/(/
+    doesn't matter
+
+/(x)\2/
+    doesn't matter
+
+/((a{0,5}){0,5}){0,5}[c]/
+    aaaaaaaaaac
+    aaaaaaaaaa
+
+/((a{0,5}){0,5})*[c]/
+    aaaaaaaaaac
+    aaaaaaaaaa
+
+/(\b)*a/
+    a
+
+/(a)*b/
+    ab
+
+/(a|)*b/
+    ab
+    b
+    x
+
+/^(?:(a)|(b))*\1\2$/
+    abab
+
+/abc[^x]def/
+    abcxabcydef
+
+/^(a|\1x)*$/
+    aax
+    aaxa
+
+//
+    @{['']}
+
+/^(?:(a)|(b))*$/
+    ab
+
+/[\0]/
+    a
+    \0
+
+/[\1]/
+    a
+    \1
+
+/\10()()()()()()()()()/
+    doesn't matter
+
+/\10()()()()()()()()()()/
+    a
+
+/a(?<)b/
+    ab
+
+/[]/
+    doesn't matter
+
+/[\]/
+    doesn't matter
+
+/()/
+    a
+
+/[\x]/
+    x
+    \0
+
+/((a)*)*/
+    a
+
+/()a\1/
+    a
+
+/a\1()/
+    a
+
+/a(?i)a(?-i)a/
+    aaa
+    aAa
+    aAA
+
+/a(?i)a(?-i)a(?i)a(?-i)a/
+    aaaaa
+    aAaAa
+    AaAaA
+    aAAAa
+    AaaaA
+    AAAAA
+    aaAAA
+    AAaaa
+
+/\x/
+    a
+    X
+    \0
+
+/[a-c-e]/
+    a
+    b
+    d
+    -
+
+/[b-\d]/
+    b
+    c
+    d
+    -
+    1
+
+/[\d-f]/
+    d
+    e
+    f
+    -
+    1
+
+/[/
+    doesn't matter
+
+/]/
+    ]
+    a
+
+/[]/
+    doesn't matter
+
+/[-a-c]/
+    -
+    a
+    b
+    d
+
+/[a-c-]/
+    -
+    a
+    b
+    d
+
+/[-]/
+    a
+    -
+
+/[--]/
+    a
+    -
+
+/[---]/
+    a
+    -
+
+/[--b]/
+    -
+    a
+    c
+
+/[b--]/
+    doesn't matter
+
+/a{/
+    a{
+
+/a{}/
+    a{}
+
+/a{3/
+    a{3
+
+/a{3,/
+    a{3,
+
+/a{3, 3}/
+    a{3,3}
+    a{3, 3}
+    aaa
+
+/a{3, 3}/x
+    a{3,3}
+    a{3, 3}
+    aaa
+
+/a{3, }/
+    a{3,}
+    a{3, }
+    aaa
+
+/a{3, }/x
+    a{3,}
+    a{3, }
+    aaa
+
+/\x x/
+    \0 x
+    \0x
+
+/\x x/x
+    \0 x
+    \0x
+
+/\x 3/
+    \0003
+    \000 3
+    x3
+    x 3
+
+/\x 3/x
+    \0003
+    \000 3
+    x3
+    x 3
+
+/^a{ 1}$/
+    a
+    a{ 1}
+    a{1}
+
+/^a{ 1}$/x
+    a
+    a{ 1}
+    a{1}
+
+/{}/
+    {}
+    a
+
+/{1}/
+    doesn't matter
+
+/*/
+    doesn't matter
+
+/|/
+    x
+
+/\0000/
+    \0000
+
+/a(?<)b/
+    ab
+
+/a(?i)b/
+    ab
+    aB
+    Ab
+
+/a(?i=a)/
+    doesn't matter
+
+/a(?<=a){3000}a/
+  aa
+  xa
+  ax
+
+/a(?!=a){3000}a/
+  aa
+  ax
+  xa
+
+/a(){3000}a/
+  aa
+  ax
+  xa
+
+/a(?:){3000}a/
+  aa
+  ax
+
+/a(?<=a)*a/
+  aa
+  ax
+  xa
+
+/a(?!=a)*a/
+  aa
+  ax
+  xa
+
+/a()*a/
+  aa
+  ax
+  xa
+
+/a(?:)*a/
+  aa
+  ax
+  xa
+
+/x(?<=a)*a/
+  aa
+  xa
+  ax
+
+/a(?<=(a))*\1/
+  aa
+
+/a(?<=(a))*?\1/
+  aa
+
+/(?=(a)\1)*aa/
+  aa
+
+/^((a|b){2,5}){2}$/
+  aaaaabbbbb
+
+/^(b*|ba){1,2}bc/
+  babc
+  bbabc
+  bababc
+  bababbc
+  babababc
+
+/^a{4,5}(?:c|a)c$/
+  aaaaac
+  aaaaaac
+
+/^(a|){4,5}(?:c|a)c$/
+  aaaaac
+  aaaaaac
+
+/(?m:^).abc$/
+  eeexabc
+  eee\nxabc
+
+/(?m:^)abc/
+  abc
+  \nabc
+
+
+/^abc/
+  abc
+  \nabc
+
+/\Aabc/
+  abc
+  \nabc
+
+/(?<!bar)foo/
+    foo
+    catfood
+    arfootle
+    rfoosh
+    barfoo
+    towbarfoo
+
+/\w{3}(?<!bar)foo/
+    catfood
+    foo
+    barfoo
+    towbarfoo
+
+/(?<=(foo)a)bar/
+    fooabar
+    bar
+    foobbar
+      
+/\Aabc\z/m
+    abc
+    abc\n   
+    qqq\nabc
+    abc\nzzz
+    qqq\nabc\nzzz
+
+"(?>.*/)foo"
+    /this/is/a/very/long/line/in/deed/with/very/many/slashes/in/it/you/see/
+
+"(?>.*/)foo"
+    /this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo
+
+/(?>(\.\d\d[1-9]?))\d+/
+    1.230003938
+    1.875000282
+    1.235 
+
+/^((?>\w+)|(?>\s+))*$/
+    now is the time for all good men to come to the aid of the party
+    this is not a line with only words and spaces!
+    
+/(\d+)(\w)/
+    12345a
+    12345+ 
+
+/((?>\d+))(\w)/
+    12345a
+    12345+ 
+
+/(?>a+)b/
+    aaab
+
+/((?>a+)b)/
+    aaab
+
+/(?>(a+))b/
+    aaab
+
+/(?>b)+/
+    aaabbbccc
+
+/(?>a+|b+|c+)*c/
+    aaabbbbccccd
+
+/((?>[^()]+)|\([^()]*\))+/
+    ((abc(ade)ufh()()x
+    
+/\(((?>[^()]+)|\([^()]+\))+\)/ 
+    (abc)
+    (abc(def)xyz)
+    ((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa   
+
+/a(?-i)b/i
+    ab
+    Ab
+    aB
+    AB
+        
+/(a (?x)b c)d e/
+    a bcd e
+    a b cd e
+    abcd e   
+    a bcde 
+ 
+/(a b(?x)c d (?-x)e f)/
+    a bcde f
+    abcdef  
+
+/(a(?i)b)c/
+    abc
+    aBc
+    abC
+    aBC  
+    Abc
+    ABc
+    ABC
+    AbC
+    
+/a(?i:b)c/
+    abc
+    aBc
+    ABC
+    abC
+    aBC
+    
+/a(?i:b)*c/
+    aBc
+    aBBc
+    aBC
+    aBBC
+    
+/a(?=b(?i)c)\w\wd/
+    abcd
+    abCd
+    aBCd
+    abcD     
+    
+/(?s-i:more.*than).*million/i
+    more than million
+    more than MILLION
+    more \n than Million 
+    MORE THAN MILLION    
+    more \n than \n million 
+
+/(?:(?s-i)more.*than).*million/i
+    more than million
+    more than MILLION
+    more \n than Million 
+    MORE THAN MILLION    
+    more \n than \n million 
+    
+/(?>a(?i)b+)+c/ 
+    abc
+    aBbc
+    aBBc 
+    Abc
+    abAb    
+    abbC 
+    
+/(?=a(?i)b)\w\wc/
+    abc
+    aBc
+    Ab 
+    abC
+    aBC     
+    
+/(?<=a(?i)b)(\w\w)c/
+    abxxc
+    aBxxc
+    Abxxc
+    ABxxc
+    abxxC      
+
+/(?:(a)|b)(?(1)A|B)/
+    aA
+    bB
+    aB
+    bA    
+
+/^(a)?(?(1)a|b)+$/
+    aa
+    b
+    bb  
+    ab   
+
+/^(?(?=abc)\w{3}:|\d\d)$/
+    abc:
+    12
+    123
+    xyz    
+
+/^(?(?!abc)\d\d|\w{3}:)$/
+    abc:
+    12
+    123
+    xyz    
+    
+/(?(?<=foo)bar|cat)/
+    foobar
+    cat
+    fcat
+    focat   
+    foocat  
+
+/(?(?<!foo)cat|bar)/
+    foobar
+    cat
+    fcat
+    focat   
+    foocat  
+
+/( \( )? [^()]+ (?(1) \) |) /x
+    abcd
+    (abcd)
+    the quick (abcd) fox
+    (abcd   
+
+/( \( )? [^()]+ (?(1) \) ) /x
+    abcd
+    (abcd)
+    the quick (abcd) fox
+    (abcd   
+
+/^(?(2)a|(1)(2))+$/
+    12
+    12a
+    12aa
+    1234    
+
+/((?i)blah)\s+\1/
+    blah blah
+    BLAH BLAH
+    Blah Blah
+    blaH blaH
+    blah BLAH
+    Blah blah      
+    blaH blah 
+
+/((?i)blah)\s+(?i:\1)/
+    blah blah
+    BLAH BLAH
+    Blah Blah
+    blaH blaH
+    blah BLAH
+    Blah blah      
+    blaH blah 
+
+/(?>a*)*/
+    a
+    aa
+    aaaa
+    
+/(abc|)+/
+    abc
+    abcabc
+    abcabcabc
+    xyz      
+
+/([a]*)*/
+    a
+    aaaaa 
+ 
+/([ab]*)*/
+    a
+    b
+    ababab
+    aaaabcde
+    bbbb    
+ 
+/([^a]*)*/
+    b
+    bbbb
+    aaa   
+ 
+/([^ab]*)*/
+    cccc
+    abab  
+ 
+/([a]*?)*/
+    a
+    aaaa 
+ 
+/([ab]*?)*/
+    a
+    b
+    abab
+    baba   
+ 
+/([^a]*?)*/
+    b
+    bbbb
+    aaa   
+ 
+/([^ab]*?)*/
+    c
+    cccc
+    baba   
+ 
+/(?>a*)*/
+    a
+    aaabcde 
+ 
+/((?>a*))*/
+    aaaaa
+    aabbaa 
+ 
+/((?>a*?))*/
+    aaaaa
+    aabbaa 
+
+/(?(?=[^a-z]+[a-z])  \d{2}-[a-z]{3}-\d{2}  |  \d{2}-\d{2}-\d{2} ) /x
+    12-sep-98
+    12-09-98
+    sep-12-98
+        
+/(?<=(foo))bar\1/
+    foobarfoo
+    foobarfootling 
+    foobar
+    barfoo   
+
+/(?i:saturday|sunday)/
+    saturday
+    sunday
+    Saturday
+    Sunday
+    SATURDAY
+    SUNDAY
+    SunDay
+    
+/(a(?i)bc|BB)x/
+    abcx
+    aBCx
+    bbx
+    BBx
+    abcX
+    aBCX
+    bbX
+    BBX               
+
+/^([ab](?i)[cd]|[ef])/
+    ac
+    aC
+    bD
+    elephant
+    Europe 
+    frog
+    France
+    Africa     
+
+/^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)/
+    ab
+    aBd
+    xy
+    xY
+    zebra
+    Zambesi
+    aCD  
+    XY  
+
+/(?<=foo\n)^bar/m
+    foo\nbar
+    bar
+    baz\nbar   
+
+/(?<=(?<!foo)bar)baz/
+    barbaz
+    barbarbaz 
+    koobarbaz 
+    baz
+    foobarbaz 
+
+/^(a\1?){4}$/
+    a
+    aa
+    aaa
+    aaaa
+    aaaaa
+    aaaaaa
+    aaaaaaa
+    aaaaaaaa
+    aaaaaaaaa
+    aaaaaaaaaa
+    aaaaaaaaaaa
+    aaaaaaaaaaaa
+    aaaaaaaaaaaaa
+    aaaaaaaaaaaaaa
+    aaaaaaaaaaaaaaa
+    aaaaaaaaaaaaaaaa               
+
+/^(a\1?)(a\1?)(a\2?)(a\3?)$/
+    a
+    aa
+    aaa
+    aaaa
+    aaaaa
+    aaaaaa
+    aaaaaaa
+    aaaaaaaa
+    aaaaaaaaa
+    aaaaaaaaaa
+    aaaaaaaaaaa
+    aaaaaaaaaaaa
+    aaaaaaaaaaaaa
+    aaaaaaaaaaaaaa
+    aaaaaaaaaaaaaaa
+    aaaaaaaaaaaaaaaa               
+
+/abc/
+    abc
+    xabcy
+    ababc
+    xbc
+    axc
+    abx
+
+/ab*c/
+    abc
+
+/ab*bc/
+    abc
+    abbc
+    abbbbc
+
+/.{1}/
+    abbbbc
+
+/.{3,4}/
+    abbbbc
+
+/ab{0,}bc/
+    abbbbc
+
+/ab+bc/
+    abbc
+    abc
+    abq
+
+/ab{1,}bc/
+
+/ab+bc/
+    abbbbc
+
+/ab{1,}bc/
+    abbbbc
+
+/ab{1,3}bc/
+    abbbbc
+
+/ab{3,4}bc/
+    abbbbc
+
+/ab{4,5}bc/
+    abq
+    abbbbc
+
+/ab?bc/
+    abbc
+    abc
+
+/ab{0,1}bc/
+    abc
+
+/ab?bc/
+
+/ab?c/
+    abc
+
+/ab{0,1}c/
+    abc
+
+/^abc$/
+    abc
+    abbbbc
+    abcc
+
+/^abc/
+    abcc
+
+/^abc$/
+
+/abc$/
+    aabc
+    aabc
+    aabcd
+
+/^/
+    abc
+
+/$/
+    abc
+
+/a.c/
+    abc
+    axc
+
+/a.*c/
+    axyzc
+
+/a[bc]d/
+    abd
+    axyzd
+    abc
+
+/a[b-d]e/
+    ace
+
+/a[b-d]/
+    aac
+
+/a[-b]/
+    a-
+
+/a[b-]/
+    a-
+
+/a]/
+    a]
+
+/a[]]b/
+    a]b
+
+/a[^bc]d/
+    aed
+    abd
+    abd
+
+/a[^-b]c/
+    adc
+
+/a[^]b]c/
+    adc
+    a-c
+    a]c
+
+/\ba\b/
+    a-
+    -a
+    -a-
+
+/\by\b/
+    xy
+    yz
+    xyz
+
+/\Ba\B/
+    a-
+    -a
+    -a-
+
+/\By\b/
+    xy
+
+/\by\B/
+    yz
+
+/\By\B/
+    xyz
+
+/\w/
+    a
+
+/\W/
+    -
+    -
+    a
+
+/a\sb/
+    a b
+
+/a\Sb/
+    a-b
+    a-b
+    a b
+
+/\d/
+    1
+
+/\D/
+    -
+    -
+    1
+
+/[\w]/
+    a
+
+/[\W]/
+    -
+    -
+    a
+
+/a[\s]b/
+    a b
+
+/a[\S]b/
+    a-b
+    a-b
+    a b
+
+/[\d]/
+    1
+
+/[\D]/
+    -
+    -
+    1
+
+/ab|cd/
+    abc
+    abcd
+
+/()ef/
+    def
+
+/$b/
+
+/a\(b/
+    a(b
+
+/a\(*b/
+    ab
+    a((b
+
+/a\\b/
+    a\b
+
+/((a))/
+    abc
+
+/(a)b(c)/
+    abc
+
+/a+b+c/
+    aabbabc
+
+/a{1,}b{1,}c/
+    aabbabc
+
+/a.+?c/
+    abcabc
+
+/(a+|b)*/
+    ab
+
+/(a+|b){0,}/
+    ab
+
+/(a+|b)+/
+    ab
+
+/(a+|b){1,}/
+    ab
+
+/(a+|b)?/
+    ab
+
+/(a+|b){0,1}/
+    ab
+
+/[^ab]*/
+    cde
+
+/abc/
+    b
+    
+
+/a*/
+    
+
+/([abc])*d/
+    abbbcd
+
+/([abc])*bcd/
+    abcd
+
+/a|b|c|d|e/
+    e
+
+/(a|b|c|d|e)f/
+    ef
+
+/abcd*efg/
+    abcdefg
+
+/ab*/
+    xabyabbbz
+    xayabbbz
+
+/(ab|cd)e/
+    abcde
+
+/[abhgefdc]ij/
+    hij
+
+/^(ab|cd)e/
+
+/(abc|)ef/
+    abcdef
+
+/(a|b)c*d/
+    abcd
+
+/(ab|ab*)bc/
+    abc
+
+/a([bc]*)c*/
+    abc
+
+/a([bc]*)(c*d)/
+    abcd
+
+/a([bc]+)(c*d)/
+    abcd
+
+/a([bc]*)(c+d)/
+    abcd
+
+/a[bcd]*dcdcde/
+    adcdcde
+
+/a[bcd]+dcdcde/
+    abcde
+    adcdcde
+
+/(ab|a)b*c/
+    abc
+
+/((a)(b)c)(d)/
+    abcd
+
+/[a-zA-Z_][a-zA-Z0-9_]*/
+    alpha
+
+/^a(bc+|b[eh])g|.h$/
+    abh
+
+/(bc+d$|ef*g.|h?i(j|k))/
+    effgz
+    ij
+    reffgz
+    effg
+    bcdd
+
+/((((((((((a))))))))))/
+    a
+
+/((((((((((a))))))))))\10/
+    aa
+
+/(((((((((a)))))))))/
+    a
+
+/multiple words of text/
+    aa
+    uh-uh
+
+/multiple words/
+    multiple words, yeah
+
+/(.*)c(.*)/
+    abcde
+
+/\((.*), (.*)\)/
+    (a, b)
+
+/[k]/
+
+/abcd/
+    abcd
+
+/a(bc)d/
+    abcd
+
+/a[-]?c/
+    ac
+
+/(abc)\1/
+    abcabc
+
+/([a-c]*)\1/
+    abcabc
+
+/(a)|\1/
+    a
+    ab
+    x
+
+/(([a-c])b*?\2)*/
+    ababbbcbc
+
+/(([a-c])b*?\2){3}/
+    ababbbcbc
+
+/((\3|b)\2(a)x)+/
+    aaaxabaxbaaxbbax
+
+/((\3|b)\2(a)){2,}/
+    bbaababbabaaaaabbaaaabba
+
+/abc/i
+    ABC
+    XABCY
+    ABABC
+    aaxabxbaxbbx
+    XBC
+    AXC
+    ABX
+
+/ab*c/i
+    ABC
+
+/ab*bc/i
+    ABC
+    ABBC
+
+/ab*?bc/i
+    ABBBBC
+
+/ab{0,}?bc/i
+    ABBBBC
+
+/ab+?bc/i
+    ABBC
+
+/ab+bc/i
+    ABC
+    ABQ
+
+/ab{1,}bc/i
+
+/ab+bc/i
+    ABBBBC
+
+/ab{1,}?bc/i
+    ABBBBC
+
+/ab{1,3}?bc/i
+    ABBBBC
+
+/ab{3,4}?bc/i
+    ABBBBC
+
+/ab{4,5}?bc/i
+    ABQ
+    ABBBBC
+
+/ab??bc/i
+    ABBC
+    ABC
+
+/ab{0,1}?bc/i
+    ABC
+
+/ab??bc/i
+
+/ab??c/i
+    ABC
+
+/ab{0,1}?c/i
+    ABC
+
+/^abc$/i
+    ABC
+    ABBBBC
+    ABCC
+
+/^abc/i
+    ABCC
+
+/^abc$/i
+
+/abc$/i
+    AABC
+
+/^/i
+    ABC
+
+/$/i
+    ABC
+
+/a.c/i
+    ABC
+    AXC
+
+/a.*?c/i
+    AXYZC
+
+/a.*c/i
+    AABC
+    AXYZD
+
+/a[bc]d/i
+    ABD
+
+/a[b-d]e/i
+    ACE
+    ABC
+    ABD
+
+/a[b-d]/i
+    AAC
+
+/a[-b]/i
+    A-
+
+/a[b-]/i
+    A-
+
+/a]/i
+    A]
+
+/a[]]b/i
+    A]B
+
+/a[^bc]d/i
+    AED
+
+/a[^-b]c/i
+    ADC
+    ABD
+    A-C
+
+/a[^]b]c/i
+    ADC
+
+/ab|cd/i
+    ABC
+    ABCD
+
+/()ef/i
+    DEF
+
+/$b/i
+    A]C
+    B
+
+/a\(b/i
+    A(B
+
+/a\(*b/i
+    AB
+    A((B
+
+/a\\b/i
+    A\B
+
+/((a))/i
+    ABC
+
+/(a)b(c)/i
+    ABC
+
+/a+b+c/i
+    AABBABC
+
+/a{1,}b{1,}c/i
+    AABBABC
+
+/a.+?c/i
+    ABCABC
+
+/a.*?c/i
+    ABCABC
+
+/a.{0,5}?c/i
+    ABCABC
+
+/(a+|b)*/i
+    AB
+
+/(a+|b){0,}/i
+    AB
+
+/(a+|b)+/i
+    AB
+
+/(a+|b){1,}/i
+    AB
+
+/(a+|b)?/i
+    AB
+
+/(a+|b){0,1}/i
+    AB
+
+/(a+|b){0,1}?/i
+    AB
+
+/[^ab]*/i
+    CDE
+
+/abc/i
+
+/a*/i
+    
+
+/([abc])*d/i
+    ABBBCD
+
+/([abc])*bcd/i
+    ABCD
+
+/a|b|c|d|e/i
+    E
+
+/(a|b|c|d|e)f/i
+    EF
+
+/abcd*efg/i
+    ABCDEFG
+
+/ab*/i
+    XABYABBBZ
+    XAYABBBZ
+
+/(ab|cd)e/i
+    ABCDE
+
+/[abhgefdc]ij/i
+    HIJ
+
+/^(ab|cd)e/i
+    ABCDE
+
+/(abc|)ef/i
+    ABCDEF
+
+/(a|b)c*d/i
+    ABCD
+
+/(ab|ab*)bc/i
+    ABC
+
+/a([bc]*)c*/i
+    ABC
+
+/a([bc]*)(c*d)/i
+    ABCD
+
+/a([bc]+)(c*d)/i
+    ABCD
+
+/a([bc]*)(c+d)/i
+    ABCD
+
+/a[bcd]*dcdcde/i
+    ADCDCDE
+
+/a[bcd]+dcdcde/i
+
+/(ab|a)b*c/i
+    ABC
+
+/((a)(b)c)(d)/i
+    ABCD
+
+/[a-zA-Z_][a-zA-Z0-9_]*/i
+    ALPHA
+
+/^a(bc+|b[eh])g|.h$/i
+    ABH
+
+/(bc+d$|ef*g.|h?i(j|k))/i
+    EFFGZ
+    IJ
+    REFFGZ
+    ADCDCDE
+    EFFG
+    BCDD
+
+/((((((((((a))))))))))/i
+    A
+
+/((((((((((a))))))))))\10/i
+    AA
+
+/(((((((((a)))))))))/i
+    A
+
+/(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))/i
+    A
+
+/(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))/i
+    C
+
+/multiple words of text/i
+    AA
+    UH-UH
+
+/multiple words/i
+    MULTIPLE WORDS, YEAH
+
+/(.*)c(.*)/i
+    ABCDE
+
+/\((.*), (.*)\)/i
+    (A, B)
+
+/[k]/i
+
+/abcd/i
+    ABCD
+
+/a(bc)d/i
+    ABCD
+
+/a[-]?c/i
+    AC
+
+/(abc)\1/i
+    ABCABC
+
+/([a-c]*)\1/i
+    ABCABC
+
+/a(?!b)./
+    abad
+
+/a(?=d)./
+    abad
+
+/a(?=c|d)./
+    abad
+
+/a(?:b|c|d)(.)/
+    ace
+
+/a(?:b|c|d)*(.)/
+    ace
+
+/a(?:b|c|d)+?(.)/
+    ace
+    acdbcdbe
+
+/a(?:b|c|d)+(.)/
+    acdbcdbe
+
+/a(?:b|c|d){2}(.)/
+    acdbcdbe
+
+/a(?:b|c|d){4,5}(.)/
+    acdbcdbe
+
+/a(?:b|c|d){4,5}?(.)/
+    acdbcdbe
+
+/((foo)|(bar))*/
+    foobar
+
+/a(?:b|c|d){6,7}(.)/
+    acdbcdbe
+
+/a(?:b|c|d){6,7}?(.)/
+    acdbcdbe
+
+/a(?:b|c|d){5,6}(.)/
+    acdbcdbe
+
+/a(?:b|c|d){5,6}?(.)/
+    acdbcdbe
+
+/a(?:b|c|d){5,7}(.)/
+    acdbcdbe
+
+/a(?:b|c|d){5,7}?(.)/
+    acdbcdbe
+
+/a(?:b|(c|e){1,2}?|d)+?(.)/
+    ace
+
+/^(.+)?B/
+    AB
+
+/^([^a-z])|(\^)$/
+    .
+
+/^[<>]&/
+    <&OUT
+
+/^(a\1?){4}$/
+    aaaaaaaaaa
+    AB
+    aaaaaaaaa
+    aaaaaaaaaaa
+
+/^(a(?(1)\1)){4}$/
+    aaaaaaaaaa
+    aaaaaaaaa
+    aaaaaaaaaaa
+
+/(?:(f)(o)(o)|(b)(a)(r))*/
+    foobar
+
+/(?<=a)b/
+    ab
+    cb
+    b
+
+/(?<!c)b/
+    ab
+    b
+    b
+
+/(?:..)*a/
+    aba
+
+/(?:..)*?a/
+    aba
+
+/^(?:b|a(?=(.)))*\1/
+    abc
+
+/^(){3,5}/
+    abc
+
+/^(a+)*ax/
+    aax
+
+/^((a|b)+)*ax/
+    aax
+
+/^((a|bc)+)*ax/
+    aax
+
+/(a|x)*ab/
+    cab
+
+/(a)*ab/
+    cab
+
+/(?:(?i)a)b/
+    ab
+
+/((?i)a)b/
+    ab
+
+/(?:(?i)a)b/
+    Ab
+
+/((?i)a)b/
+    Ab
+
+/(?:(?i)a)b/
+    cb
+    aB
+
+/((?i)a)b/
+
+/(?i:a)b/
+    ab
+
+/((?i:a))b/
+    ab
+
+/(?i:a)b/
+    Ab
+
+/((?i:a))b/
+    Ab
+
+/(?i:a)b/
+    aB
+    aB
+
+/((?i:a))b/
+
+/(?:(?-i)a)b/i
+    ab
+
+/((?-i)a)b/i
+    ab
+
+/(?:(?-i)a)b/i
+    aB
+
+/((?-i)a)b/i
+    aB
+
+/(?:(?-i)a)b/i
+    aB
+    Ab
+
+/((?-i)a)b/i
+
+/(?:(?-i)a)b/i
+    aB
+
+/((?-i)a)b/i
+    aB
+
+/(?:(?-i)a)b/i
+    Ab
+    AB
+
+/((?-i)a)b/i
+
+/(?-i:a)b/i
+    ab
+
+/((?-i:a))b/i
+    ab
+
+/(?-i:a)b/i
+    aB
+
+/((?-i:a))b/i
+    aB
+
+/(?-i:a)b/i
+    AB
+    Ab
+
+/((?-i:a))b/i
+
+/(?-i:a)b/i
+    aB
+
+/((?-i:a))b/i
+    aB
+
+/(?-i:a)b/i
+    Ab
+    AB
+
+/((?-i:a))b/i
+
+/((?-i:a.))b/i
+    AB
+    a\nB
+
+/((?s-i:a.))b/i
+    a\nB
+
+/(?:c|d)(?:)(?:a(?:)(?:b)(?:b(?:))(?:b(?:)(?:b)))/
+    cabbbb
+
+/(?:c|d)(?:)(?:aaaaaaaa(?:)(?:bbbbbbbb)(?:bbbbbbbb(?:))(?:bbbbbbbb(?:)(?:bbbbbbbb)))/
+    caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+
+/(ab)\d\1/i
+    Ab4ab
+    ab4Ab
+
+/foo\w*\d{4}baz/
+    foobar1234baz
+
+/x(~~)*(?:(?:F)?)?/
+    x~~
+
+/^a(?#xxx){3}c/
+    aaac
+
+/^a(?#xxx)(?#xxx){3}c/
+    aaac
+
+/^a (?#xxx) (?#yyy) {3}c/x
+    aaac
+
+/(?<![cd])b/
+    B\nB
+    dbcb
+
+/(?<![cd])[ab]/
+    dbaacb
+
+/(?<!(c|d))b/
+
+/(?<!(c|d))[ab]/
+    dbaacb
+
+/(?<!cd)[ab]/
+    cdaccb
+
+/^(?:a?b?)*$/
+    dbcb
+    a--
+
+/((?s)^a(.))((?m)^b$)/
+    a\nb\nc\n
+
+/((?m)^b$)/
+    a\nb\nc\n
+
+/(?m)^b/
+    a\nb\n
+
+/(?m)^(b)/
+    a\nb\n
+
+/((?m)^b)/
+    a\nb\n
+
+/\n((?m)^b)/
+    a\nb\n
+
+/((?s).)c(?!.)/
+    a\nb\nc\n
+    a\nb\nc\n
+
+/((?s)b.)c(?!.)/
+    a\nb\nc\n
+    a\nb\nc\n
+
+/^b/
+
+/()^b/
+    a\nb\nc\n
+    a\nb\nc\n
+
+/((?m)^b)/
+    a\nb\nc\n
+
+/(?(1)a|b)/
+
+/(?(1)b|a)/
+    a
+
+/(x)?(?(1)a|b)/
+    a
+    a
+
+/(x)?(?(1)b|a)/
+    a
+
+/()?(?(1)b|a)/
+    a
+
+/()(?(1)b|a)/
+
+/()?(?(1)a|b)/
+    a
+
+/^(\()?blah(?(1)(\)))$/
+    (blah)
+    blah
+    a
+    blah)
+    (blah
+
+/^(\(+)?blah(?(1)(\)))$/
+    (blah)
+    blah
+    blah)
+    (blah
+
+/(?(?!a)a|b)/
+
+/(?(?!a)b|a)/
+    a
+
+/(?(?=a)b|a)/
+    a
+    a
+
+/(?(?=a)a|b)/
+    a
+
+/(?=(a+?))(\1ab)/
+    aaab
+
+/^(?=(a+?))\1ab/
+
+/(\w+:)+/
+    one:
+
+/$(?<=^(a))/
+    a
+
+/(?=(a+?))(\1ab)/
+    aaab
+
+/^(?=(a+?))\1ab/
+    aaab
+    aaab
+
+/([\w:]+::)?(\w+)$/
+    abcd
+    xy:z:::abcd
+
+/^[^bcd]*(c+)/
+    aexycd
+
+/(a*)b+/
+    caab
+
+/([\w:]+::)?(\w+)$/
+    abcd
+    xy:z:::abcd
+    abcd:
+    abcd:
+
+/^[^bcd]*(c+)/
+    aexycd
+
+/(>a+)ab/
+
+/(?>a+)b/
+    aaab
+
+/([[:]+)/
+    a:[b]:
+
+/([[=]+)/
+    a=[b]=
+
+/([[.]+)/
+    a.[b].
+
+/((?>a+)b)/
+    aaab
+
+/(?>(a+))b/
+    aaab
+
+/((?>[^()]+)|\([^()]*\))+/
+    ((abc(ade)ufh()()x
+
+/a\Z/
+    aaab
+    a\nb\n
+
+/b\Z/
+    a\nb\n
+
+/b\z/
+
+/b\Z/
+    a\nb
+
+/b\z/
+    a\nb
+    
+/^(?>(?(1)\.|())[^\W_](?>[a-z0-9-]*[^\W_])?)+$/
+    a
+    abc
+    a-b
+    0-9 
+    a.b
+    5.6.7  
+    the.quick.brown.fox
+    a100.b200.300c  
+    12-ab.1245 
+    \
+    .a
+    -a
+    a-
+    a.  
+    a_b 
+    a.-
+    a..  
+    ab..bc 
+    the.quick.brown.fox-
+    the.quick.brown.fox.
+    the.quick.brown.fox_
+    the.quick.brown.fox+       
+
+/(?>.*)(?<=(abcd|wxyz))/
+    alphabetabcd
+    endingwxyz
+    a rather long string that doesn't end with one of them
+
+/word (?>(?:(?!otherword)[a-zA-Z0-9]+ ){0,30})otherword/
+    word cat dog elephant mussel cow horse canary baboon snake shark otherword
+    word cat dog elephant mussel cow horse canary baboon snake shark
+  
+/word (?>[a-zA-Z0-9]+ ){0,30}otherword/
+    word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope
+
+/(?<=\d{3}(?!999))foo/
+    999foo
+    123999foo 
+    123abcfoo
+    
+/(?<=(?!...999)\d{3})foo/
+    999foo
+    123999foo 
+    123abcfoo
+
+/(?<=\d{3}(?!999)...)foo/
+    123abcfoo
+    123456foo 
+    123999foo  
+    
+/(?<=\d{3}...)(?<!999)foo/
+    123abcfoo   
+    123456foo 
+    123999foo  
+
+/<a[\s]+href[\s]*=[\s]*          # find <a href=
+ ([\"\'])?                       # find single or double quote
+ (?(1) (.*?)\1 | ([^\s]+))       # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+/isx
+    <a href=abcd xyz
+    <a href=\"abcd xyz pqr\" cats
+    <a href=\'abcd xyz pqr\' cats
+
+/<a\s+href\s*=\s*                # find <a href=
+ (["'])?                         # find single or double quote
+ (?(1) (.*?)\1 | (\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+/isx
+    <a href=abcd xyz
+    <a href=\"abcd xyz pqr\" cats
+    <a href       =       \'abcd xyz pqr\' cats
+
+/<a\s+href(?>\s*)=(?>\s*)        # find <a href=
+ (["'])?                         # find single or double quote
+ (?(1) (.*?)\1 | (\S+))          # if quote found, match up to next matching
+                                 # quote, otherwise match up to next space
+/isx
+    <a href=abcd xyz
+    <a href=\"abcd xyz pqr\" cats
+    <a href       =       \'abcd xyz pqr\' cats
+
+/((Z)+|A)*/
+    ZABCDEFG
+
+/(Z()|A)*/
+    ZABCDEFG
+
+/(Z(())|A)*/
+    ZABCDEFG
+
+/((?>Z)+|A)*/
+    ZABCDEFG
+
+/((?>)+|A)*/
+    ZABCDEFG
+
+/a*/g
+    abbab
+
+/^[a-\d]/
+    abcde
+    -things
+    0digit
+    bcdef    
+
+/^[\d-a]/
+    abcde
+    -things
+    0digit
+    bcdef
+
+/(?<=abc).*(?=def)/
+    abcdef
+    abcxdef
+    abcxdefxdef
+
+/(?<=abc).*?(?=def)/
+    abcdef
+    abcxdef
+    abcxdefxdef
+
+/(?<=abc).+(?=def)/
+    abcdef
+    abcxdef
+    abcxdefxdef
+
+/(?<=abc).+?(?=def)/
+    abcdef
+    abcxdef
+    abcxdefxdef
+
+/(?<=\b)(.*)/
+    -abcdef
+    abcdef
+
+/(?<=\B)(.*)/
+    -abcdef
+    abcdef
+
+/^'[ab]'/
+    'a'
+    'b'
+    x'a'
+    'a'x
+    'ab'
+
+/^'[ab]'$/
+    'a'
+    'b'
+    x'a'
+    'a'x
+    'ab'
+
+/'[ab]'$/
+    'a'
+    'b'
+    x'a'
+    'a'x
+    'ab'
+
+/'[ab]'/
+    'a'
+    'b'
+    x'a'
+    'a'x
+    'ab'
+
+/abc\E/
+    abc
+    abcE
+
+/abc[\Ex]/
+    abcx
+    abcE
+
+/^\Qa*\E$/
+    a*
+    a
+
+/\Qa*x\E/
+    a*x
+    a*
+
+/\Qa*x/
+    a*x
+    a*
+
+/\Q\Qa*x\E\E/
+    a*x
+    a\\*x
+
+/\Q\Qa*x\E/
+    a*x
+    a\\*x
+
+/a\Q[x\E]/
+    a[x]
+    ax
+
+/a#comment\Q...
+{2}/x
+    a
+    aa
+
+/a(?#comment\Q...
+){2}/x
+    a
+    aa
+
+/(?x)a#\Q
+./
+    a.
+    aa
+
+/ab(?=.*q)cd/
+    abcdxklqj
+
+/a(?!.*$)b/
+    ab
+
+/.{2}[a-z]/
+    Axi
+
+/((a{0,5}){0,5}){0,5}c/
+    aaaaaaaaaac
+    aaaaaaaaaa
+
+/((a{0,5}){0,5})*c/
+    aaaaaaaaaac
+    aaaaaaaaaa
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/simple b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/simple
new file mode 100644
index 0000000..2aa1446
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/simple
@@ -0,0 +1,377 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE-TEST; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/test/simple,v 1.9 2008/07/23 00:48:00 edi Exp $
+
+;;; some simple tests for CL-PPCRE - entered manually and to be read
+;;; in the CL-PPCRE-TEST package; all forms are expected to return a
+;;; true value on success when EVALuated
+
+(equalp (multiple-value-list (scan "(a)*b" "xaaabd"))
+        (list 1 5 #(3) #(4)))
+
+(equalp (multiple-value-list (scan "(a)*b" "xaaabd" :start 1))
+        (list 1 5 #(3) #(4)))
+
+(equalp (multiple-value-list (scan "(a)*b" "xaaabd" :start 2))
+        (list 2 5 #(3) #(4)))
+
+(null (scan "(a)*b" "xaaabd" :end 4))
+
+(equalp (multiple-value-list (scan '(:greedy-repetition 0 nil #\b) "bbbc"))
+        (list 0 3 #() #()))
+
+(null (scan '(:greedy-repetition 4 6 #\b) "bbbc"))
+
+(let ((s (create-scanner "(([a-c])+)x")))
+  (equalp (multiple-value-list (scan s "abcxy"))
+          (list 0 4 #(0 2) #(3 3))))
+
+(equalp (multiple-value-list (scan-to-strings "[^b]*b" "aaabd"))
+        (list "aaab" #()))
+
+(equalp (multiple-value-list (scan-to-strings "([^b])*b" "aaabd"))
+        (list "aaab" #("a")))
+
+(equalp (multiple-value-list (scan-to-strings "(([^b])*)b" "aaabd"))
+        (list "aaab" #("aaa" "a")))
+
+(equalp (register-groups-bind (first second third fourth)
+            ("((a)|(b)|(c))+" "abababc" :sharedp t)
+          (list first second third fourth))
+        (list "c" "a" "b" "c"))
+
+(equalp (register-groups-bind (nil second third fourth)
+            ("((a)|(b)|(c))()+" "abababc" :start 6)
+          (list second third fourth))
+        (list nil nil "c"))
+
+(null (register-groups-bind (first)
+          ("(a|b)+" "accc" :start 1)
+        first))
+
+(equalp (register-groups-bind (fname lname (#'parse-integer date month year))
+            ("(\\w+)\\s+(\\w+)\\s+(\\d{1,2})\\.(\\d{1,2})\\.(\\d{4})" "Frank Zappa 21.12.1940")
+          (list fname lname (encode-universal-time 0 0 0 date month year 0)))
+        (list "Frank" "Zappa" 1292889600))
+
+(flet ((foo (regex target-string &key (start 0) (end (length target-string)))
+         (let ((sum 0))
+           (do-matches (s e regex target-string nil :start start :end end)
+             (incf sum (- e s)))
+           (/ sum (- end start)))))
+  (and (= 1/3 (foo "a" "abcabcabc"))
+       (= 5/9 (foo "aa|b" "aacabcbbc"))))
+
+(labels ((crossfoot (target-string &key (start 0) (end (length target-string)))
+           (let ((sum 0))
+             (do-matches-as-strings (m :digit-class
+                                       target-string nil
+                                       :start start :end end)
+               (incf sum (parse-integer m)))
+             (if (< sum 10)
+               sum
+               (crossfoot (format nil "~A" sum))))))
+  (and (zerop (crossfoot "bar"))
+       (= 3 (crossfoot "a3x"))
+       (= 6 (crossfoot "12345"))))
+
+(let (result)
+  (do-register-groups (first second third fourth)
+      ("((a)|(b)|(c))" "abababc" nil :start 2 :sharedp t)
+    (push (list first second third fourth) result))
+  (equal (nreverse result)
+         '(("a" "a" nil nil) 
+           ("b" nil "b" nil) 
+           ("a" "a" nil nil) 
+           ("b" nil "b" nil) 
+           ("c" nil nil "c"))))
+
+(let (result)
+  (do-register-groups ((#'parse-integer n) (#'intern sign) whitespace)
+      ("(\\d+)|(\\+|-|\\*|/)|(\\s+)" "12*15 - 42/3")
+    (unless whitespace
+      (push (or n sign) result)))
+  (equal (nreverse result)
+         '(12 * 15 - 42 / 3)))
+
+(equal (all-matches "a" "foo bar baz")
+       (list 5 6 9 10))
+
+(equal (all-matches "\\w*" "foo bar baz")
+       (list 0 3 3 3 4 7 7 7 8 11 11 11))
+
+(equal (all-matches-as-strings "a" "foo bar baz")
+       (list "a" "a"))
+
+(equal (all-matches-as-strings "\\w*" "foo bar baz")
+       (list "foo" "" "bar" "" "baz" ""))
+
+(equal (split "\\s+" "foo   bar baz
+frob")
+       '("foo" "bar" "baz" "frob"))
+
+(equal (split "\\s*" "foo bar   baz")
+       '("f" "o" "o" "b" "a" "r" "b" "a" "z"))
+
+(equal (split "(\\s+)" "foo bar   baz")
+       '("foo" "bar" "baz"))
+
+(equal (split "(\\s+)" "foo bar   baz" :with-registers-p t)
+       '("foo" " " "bar" "   " "baz"))
+
+(equal (split "(\\s)(\\s*)" "foo bar   baz" :with-registers-p t)
+       '("foo" " " "" "bar" " " "  " "baz"))
+
+(equal (split "(,)|(;)" "foo,bar;baz" :with-registers-p t)
+       '("foo" "," nil "bar" nil ";" "baz"))
+
+(equal (split "(,)|(;)" "foo,bar;baz" :with-registers-p t :omit-unmatched-p t)
+       '("foo" "," "bar" ";" "baz"))
+
+(equal (split ":" "a:b:c:d:e:f:g::")
+       '("a" "b" "c" "d" "e" "f" "g"))
+
+(equal (split ":" "a:b:c:d:e:f:g::" :limit 1)
+       '("a:b:c:d:e:f:g::"))
+
+(equal (split ":" "a:b:c:d:e:f:g::" :limit 2)
+       '("a" "b:c:d:e:f:g::"))
+
+(equal (split ":" "a:b:c:d:e:f:g::" :limit 3)
+       '("a" "b" "c:d:e:f:g::"))
+
+(equal (split ":" "a:b:c:d:e:f:g::" :limit 1000)
+       '("a" "b" "c" "d" "e" "f" "g" "" ""))
+
+(equal (split ":" "a:b:c:d:e:f:g::" :limit -1)
+       '("a" "b" "c" "d" "e" "f" "g" "" ""))
+
+(equal (multiple-value-list (regex-replace "fo+" "foo bar" "frob"))
+       (list "frob bar" t))
+
+(equal (multiple-value-list (regex-replace "fo+" "FOO bar" "frob"))
+       (list "FOO bar" nil))
+
+(equal (multiple-value-list (regex-replace "(?i)fo+" "FOO bar" "frob"))
+       (list "frob bar" t))
+
+(equal (multiple-value-list (regex-replace "(?i)fo+" "FOO bar" "frob" :preserve-case t))
+       (list "FROB bar" t))
+
+(equal (multiple-value-list (regex-replace "(?i)fo+" "Foo bar" "frob" :preserve-case t))
+       (list "Frob bar" t))
+
+(equal (multiple-value-list (regex-replace "bar" "foo bar baz" "[frob (was '\\&' between '\\`' and '\\'')]"))
+       (list "foo [frob (was 'bar' between 'foo ' and ' baz')] baz" t))
+
+(equal (multiple-value-list
+        (regex-replace "bar" "foo bar baz"
+                       '("[frob (was '" :match "' between '" :before-match "' and '" :after-match "')]")))
+       (list "foo [frob (was 'bar' between 'foo ' and ' baz')] baz" t))
+
+(equal (multiple-value-list (regex-replace "(be)(nev)(o)(lent)"
+                                           "benevolent: adj. generous, kind"
+                                           (lambda (match &rest registers)
+                                             (format nil "~A [~{~A~^.~}]" match registers))
+                                           :simple-calls t))
+       (list "benevolent [be.nev.o.lent]: adj. generous, kind" t))
+
+(equal (multiple-value-list (regex-replace-all "(?i)fo+" "foo Fooo FOOOO bar" "frob" :preserve-case t))
+       (list "frob Frob FROB bar" t))
+
+(string= (regex-replace-all "(?i)f(o+)" "foo Fooo FOOOO bar" "fr\\1b" :preserve-case t)
+         "froob Frooob FROOOOB bar")
+
+(let ((qp-regex (create-scanner "[\\x80-\\xff]")))
+  (flet ((encode-quoted-printable (string)
+           "Converts 8-bit string to quoted-printable representation."
+           ;; won't work for Corman Lisp because non-ASCII characters aren't 8-bit there
+           (flet ((convert (target-string start end match-start match-end reg-starts reg-ends)
+                    (declare (ignore start end match-end reg-starts reg-ends))
+                    (format nil "=~:@(~2,'0x~)" (char-code (char target-string match-start)))))
+             (regex-replace-all qp-regex string #'convert))))
+    (string= (encode-quoted-printable "F�te S�rensen na�ve H�hner Stra�e")
+             "F=EAte S=F8rensen na=EFve H=FChner Stra=DFe")))
+
+(let ((url-regex (create-scanner "[^a-zA-Z0-9_\\-.]")))
+  (flet ((url-encode (string)
+           "URL-encodes a string."
+           ;; won't work for Corman Lisp because non-ASCII characters aren't 8-bit there
+           (flet ((convert (target-string start end match-start match-end reg-starts reg-ends)
+                    (declare (ignore start end match-end reg-starts reg-ends))
+                    (format nil "%~:@(~2,'0x~)" (char-code (char target-string match-start)))))
+             (regex-replace-all url-regex string #'convert))))
+    (string= (url-encode "F�te S�rensen na�ve H�hner Stra�e")
+             "F%EAte%20S%F8rensen%20na%EFve%20H%FChner%20Stra%DFe")))
+
+(flet ((how-many (target-string start end match-start match-end reg-starts reg-ends)
+         (declare (ignore target-string start end match-start match-end))
+         (format nil "~A" (- (svref reg-ends 0)
+                             (svref reg-starts 0)))))
+  (string= (regex-replace-all "{(.+?)}"
+                              "foo{...}bar{.....}{..}baz{....}frob"
+                              (list "[" #'how-many " dots]"))
+           "foo[3 dots]bar[5 dots][2 dots]baz[4 dots]frob"))
+
+(let ((qp-regex (create-scanner "[\\x80-\\xff]")))
+  (flet ((encode-quoted-printable (string)
+           "Converts 8-bit string to quoted-printable representation.
+Version using SIMPLE-CALLS keyword argument."
+           ;; ;; won't work for Corman Lisp because non-ASCII characters aren't 8-bit there
+           (flet ((convert (match)
+                    (format nil "=~:@(~2,'0x~)" (char-code (char match 0)))))
+             (regex-replace-all qp-regex string #'convert
+                                :simple-calls t))))
+    (string= (encode-quoted-printable "F�te S�rensen na�ve H�hner Stra�e")
+             "F=EAte S=F8rensen na=EFve H=FChner Stra=DFe")))
+
+(flet ((how-many (match first-register)
+         (declare (ignore match))
+         (format nil "~A" (length first-register))))
+  (string= (regex-replace-all "{(.+?)}"
+                              "foo{...}bar{.....}{..}baz{....}frob"
+                              (list "[" #'how-many " dots]")
+                              :simple-calls t)
+           "foo[3 dots]bar[5 dots][2 dots]baz[4 dots]frob"))
+
+(flet ((my-repetition (char min)
+         `(:greedy-repetition ,min nil ,char)))
+  (setf (parse-tree-synonym 'a*) (my-repetition #\a 0)
+        (parse-tree-synonym 'b+) (my-repetition #\b 1))
+  (unwind-protect
+      (let ((scanner (create-scanner '(:sequence a* b+))))
+        (equal (mapcar (lambda (target)
+                         (scan scanner target))
+                       '("ab" "b" "aab" "a" "x"))
+               (list 0 0 0 nil nil)))
+    (setf (parse-tree-synonym 'a*) nil
+          (parse-tree-synonym 'b+) nil)))
+
+(null (scan "^a+$" "a+"))
+
+(let ((*allow-quoting* t))
+  ;;we use CREATE-SCANNER because of Lisps like SBCL that don't have an interpreter
+  (equalp (multiple-value-list (scan (create-scanner "^\\Qa+\\E$") "a+"))
+          (list 0 2 #() #())))
+
+(string= (parse-string "\\k<reg>") "k<reg>")
+
+(let ((*allow-named-registers* t))
+  (equal (nth-value 1 (create-scanner "((?<small>[a-z]*)(?<big>[A-Z]*))"))
+         (list nil "small" "big")))
+
+(let ((*allow-named-registers* t))
+  (equal (nth-value 1 (create-scanner '(:register
+                                        (:sequence
+                                         (:named-register "small"
+                                          (:greedy-repetition 0 nil (:char-class (:range #\a #\z))))
+                                         (:named-register "big"
+                                          (:greedy-repetition 0 nil (:char-class (:range #\a #\z))))))))
+         (list nil "small" "big")))
+
+(let ((*allow-named-registers* t))
+  (equalp (multiple-value-list (scan (create-scanner "((?<small>[a-z]*)(?<big>[A-Z]*))") "aaaBBB"))
+          (list 0 6 #(0 0 3) #(6 3 6))))
+
+(let ((*allow-named-registers* t))
+  ;; multiple-choice back-reference
+  (equalp (multiple-value-list (scan (create-scanner "^(?<reg>[ab])(?<reg>[12])\\k<reg>\\k<reg>$") "a1aa"))
+          (list 0 4 #(0 1) #(1 2))))
+
+(let ((*allow-named-registers* t))
+  (equalp (multiple-value-list (scan (create-scanner "^(?<reg>[ab])(?<reg>[12])\\k<reg>\\k<reg>$") "a22a"))
+          (list 0 4 #(0 1) #(1 2))))
+
+(let ((*allow-named-registers* t))
+  ;; demonstrating most-recently-seen-register-first property of back-reference;
+  ;; "greedy" regex (analogous to "aa?")
+  (equalp (multiple-value-list (scan (create-scanner "^(?<reg>)(?<reg>a)(\\k<reg>)") "a"))
+          (list 0 1 #(0 0 1) #(0 1 1))))
+
+(let ((*allow-named-registers* t))
+  (equalp (multiple-value-list (scan (create-scanner "^(?<reg>)(?<reg>a)(\\k<reg>)") "aa"))
+          (list 0 2 #(0 0 1) #(0 1 2))))
+
+(let ((*allow-named-registers* t))
+  ;; switched groups
+  ;; "lazy" regex (analogous to "aa??")
+  (equalp (multiple-value-list (scan (create-scanner "^(?<reg>a)(?<reg>)(\\k<reg>)") "a"))
+          (list 0 1 #(0 1 1) #(1 1 1))))
+
+(let ((*allow-named-registers* t))
+  ;; scanner ignores the second "a"
+  (equalp (multiple-value-list (scan (create-scanner "^(?<reg>a)(?<reg>)(\\k<reg>)") "aa"))
+          (list 0 1 #(0 1 1) #(1 1 1))))
+
+(let ((*allow-named-registers* t))
+  ;; "aa" will be matched only when forced by adding "$" at the end
+  (equalp (multiple-value-list (scan (create-scanner "^(?<reg>a)(?<reg>)(\\k<reg>)$") "aa"))
+          (list 0 2 #(0 1 1) #(1 1 2))))
+
+(string= (quote-meta-chars "[a-z]*") "\\[a\\-z\\]\\*")
+
+(string= (handler-case
+             (create-scanner "foo**x")
+           (ppcre-syntax-error (condition)
+             (with-standard-io-syntax
+               (format nil "Houston, we've got a problem with the string ~S:  Looks like something went wrong at position ~A.  The last message we received was \"~?\"."
+                       (ppcre-syntax-error-string condition)
+                       (ppcre-syntax-error-pos condition)
+                       (simple-condition-format-control condition)
+                       (simple-condition-format-arguments condition)))))
+         "Houston, we've got a problem with the string \"foo**x\":  Looks like something went wrong at position 4.  The last message we received was \"Quantifier '*' not allowed.\".")
+
+(flet ((my-weird-filter (pos)
+         "Only match at this point if either pos is odd and the
+character we're looking at is lowercase or if pos is even and the next
+two characters we're looking at are uppercase. Consume these
+characters if there's a match."
+         (cond ((and (oddp pos)
+                     (< pos cl-ppcre::*end-pos*)
+                     (lower-case-p (char cl-ppcre::*string* pos)))
+                (1+ pos))
+               ((and (evenp pos)
+                     (< (1+ pos) cl-ppcre::*end-pos*)
+                     (upper-case-p (char cl-ppcre::*string* pos))
+                     (upper-case-p (char cl-ppcre::*string* (1+ pos))))
+                (+ pos 2))
+               (t nil))))
+  (let ((weird-regex `(:sequence "+" (:filter ,#'my-weird-filter) "+")))
+    (equalp (multiple-value-list (scan weird-regex "+A++a+AA+"))
+            (list 5 9 #() #()))))
+
+(let ((a "\\E*"))
+  (equalp (multiple-value-list (scan (concatenate 'string "(?:" (quote-meta-chars a) "){2}") "\\E*\\E*"))
+          (list 0 6 #() #())))
+
+(let ((a "\\E*"))
+  (equalp (multiple-value-list (scan `(:greedy-repetition 2 2 ,a) "\\E*\\E*"))
+          (list 0 6 #() #())))
+
+(loop for *optimize-char-classes* in '(:hash-table :hash-table* :charset :charset* :charmap)
+      for s = (create-scanner "(([a-c])+)x")
+      always (equalp (multiple-value-list (scan s "abcxy"))
+                     (list 0 4 #(0 2) #(3 3))))
+
+(labels ((char-code-odd-p (char)
+           (oddp (char-code char)))
+         (char-code-even-p (char)
+           (evenp (char-code char)))
+         (resolver (name)
+           (cond ((string= name "odd") #'char-code-odd-p)
+                 ((string= name "even") #'char-code-even-p)
+                 ((string= name "true") (constantly t))
+                 (t (error "Can't resolve ~S." name)))))
+  (equalp
+   (let ((*property-resolver* #'resolver))
+     (list (regex-replace-all (create-scanner "\\p{odd}") "abcd" "+")
+           (regex-replace-all (create-scanner "\\p{even}") "abcd" "+")
+           (regex-replace-all (create-scanner "\\p{true}") "abcd" "+")))
+   '("+b+d" "a+c+" "++++")))
+
+(macrolet ((z () "(a)*b"))
+  (equalp (multiple-value-list (scan (z) "xaaabd"))
+          (list 1 5 #(3) #(4))))
+
+(macrolet ((z () "[^b]*b"))
+  (equalp (multiple-value-list (scan-to-strings (z)  "aaabd"))
+          (list "aaab" #())))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/tests.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/tests.lisp
new file mode 100644
index 0000000..ae8ec04
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/tests.lisp
@@ -0,0 +1,159 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE-TEST; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/test/tests.lisp,v 1.13 2009/09/17 19:17:36 edi Exp $
+
+;;; The tests in this file test CL-PPCRE against testdata generated by
+;;; the Perl program `perltest.pl' from the input file `testinput' in
+;;; order to check compatibility with Perl and correctness of the
+;;; regex engine.
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre-test)
+
+(defvar *this-file* (load-time-value
+                     (or #.*compile-file-pathname* *load-pathname*))
+  "The location of this source file.")
+
+(defmacro do-tests ((name &optional show-progress-p) &body body)
+  "Helper macro which repeatedly executes BODY until the code in body
+calls the function DONE.  It is assumed that each invocation of BODY
+will be the execution of one test which returns NIL in case of success
+and list of string describing errors otherwise.
+
+The macro prints a simple progress indicator \(one dots for ten tests)
+to *STANDARD-OUTPUT* unless SHOW-PROGRESS-P is NIL and returns a true
+value iff all tests succeeded.  Errors in BODY are caught and reported
+\(and counted as failures)."
+  `(let ((successp t)
+         (testcount 1))
+     (block test-block
+       (flet ((done ()
+                (return-from test-block successp)))
+         (format t "~&Test: ~A~%" ,name)
+         (loop
+          (when (and ,show-progress-p (zerop (mod testcount 10)))
+            (format t ".")
+            (when (zerop (mod testcount 100))
+              (terpri))
+            (force-output))
+          (let ((errors
+                 (handler-case
+                     (progn ,@body)
+                   (error (msg)
+                     (list (format nil "~&got an unexpected error: ~A" msg))))))
+            (setq successp (and successp (null errors)))
+            (when errors
+              (format t "~&~4@A:~{~&   ~A~}~%" testcount errors))
+            (incf testcount)))))
+     successp))
+
+(defun simple-tests (&key (file-name
+                           (make-pathname :name "simple"
+                                          :type nil :version nil
+                                          :defaults *this-file*))
+                          (external-format '(:latin-1 :eol-style :lf))
+                          verbose)
+  "Loops through all the forms in the file FILE-NAME and executes each
+of them using EVAL.  It is assumed that each FORM specifies a test
+which returns a true value iff it succeeds.  Prints each test form to
+*STANDARD-OUTPUT* if VERBOSE is true and shows a simple progress
+indicator otherwise.  EXTERNAL-FORMAT is the FLEXI-STREAMS external
+format which is used to read the file.  Returns a true value iff all
+tests succeeded."
+  (with-open-file (binary-stream file-name :element-type 'flex:octet)
+    (let ((stream (flex:make-flexi-stream binary-stream :external-format external-format))
+          (*package* (find-package :cl-ppcre-test)))
+      (do-tests ((format nil "Simple tests from file ~S" (file-namestring file-name))
+                 (not verbose))
+        (let ((form (or (read stream nil) (done))))
+          (when verbose
+            (format t "~&~S" form))
+          (cond ((eval form) nil)
+                (t (list (format nil "~S returned NIL" form)))))))))
+
+(defun random-test-function (probability)
+  "Returns a random character test function which contains each
+character with probability PROBABILITY."
+  (let ((hash-table (make-hash-table)))
+    (dotimes (code char-code-limit)
+      (let ((char (code-char code)))
+        (when (and char (< (random 1.0d0) probability))
+          (setf (gethash (code-char code) hash-table) t))))
+    (lambda (char)
+      (gethash char hash-table))))
+
+(defun test-optimized-test-functions% (probability)
+  "Creates a random test function with probability PROBABILITY and six
+\(one for each possible \"kind\") corresponding optimized test
+functions, then checks for each character in turn that all functions
+agree on it."
+  (let* ((test-function (random-test-function probability))
+         (optimized-functions (loop for kind in '(nil
+                                                  :hash-table
+                                                  :hash-table*
+                                                  :charset
+                                                  :charset*
+                                                  :charmap)
+                                    collect (create-optimized-test-function test-function :kind kind))))
+    (loop for code below char-code-limit
+          for char = (code-char code)
+          for expected-result = (and char (funcall test-function char))
+          always (or (null char)
+                     (loop for optimized-function in optimized-functions
+                           always (eq (not (funcall optimized-function char))
+                                      (not expected-result)))))))
+
+(defun test-optimized-test-functions (&key verbose)
+  "Runs TEST-OPTIMIZED-TEST-FUNCTIONS% with different probabilities."
+  (let ((probabilities '(0 .001 .01 .1 1)))
+    (do-tests ("Optimized test functions - this might take some time..." (not verbose))
+      (let ((probability (or (pop probabilities) (done))))
+        (when verbose
+          (format t "~&Probability is ~A" probability))
+        (not (test-optimized-test-functions% probability))))))
+
+(defun run-all-tests (&key more-tests verbose)
+  "Runs all tests for CL-PPCRE and returns a true value iff all tests
+succeeded.  VERBOSE is interpreted by the individual test suites.
+MORE-TESTS can be a list of function designators designating
+additional tests to run.  This facility is used by the tests for
+CL-PPCRE-UNICODE."
+  (let ((successp t))
+    (macrolet ((run-test-suite (&body body)
+                 `(unless (progn ,@body)
+                    (setq successp nil))))
+      ;; run the automatically generated Perl tests
+      (run-test-suite (perl-test :verbose verbose))
+      (run-test-suite (test-optimized-test-functions :verbose verbose))
+      (run-test-suite (simple-tests :verbose verbose))
+      (when more-tests
+        (unless (listp more-tests)
+          (setq more-tests (list more-tests))
+          (dolist (test more-tests)
+            (run-test-suite (funcall test :verbose verbose))))))
+    (format t "~2&~:[Some tests failed~;All tests passed~]." successp)
+    successp))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/unicode-tests.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/unicode-tests.lisp
new file mode 100644
index 0000000..7058405
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/unicode-tests.lisp
@@ -0,0 +1,80 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE-TEST; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/test/unicode-tests.lisp,v 1.8 2008/07/23 00:17:53 edi Exp $
+
+;;; Copyright (c) 2008, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre-test)
+
+(defun unicode-test (&key (file-name 
+                           (make-pathname :name "unicodetestdata"
+                                          :type nil :version nil
+                                          :defaults *this-file*)
+                           file-name-provided-p)
+                          verbose)
+  "Loops through all test cases in FILE-NAME and prints a report if
+VERBOSE is true.  Returns a true value if all tests succeeded.
+
+For the syntax of the tests in FILE-NAME refer to CL-UNICODE."
+  (with-open-file (stream file-name)
+    (let ((*regex-char-code-limit* (if file-name-provided-p *regex-char-code-limit* char-code-limit))
+          (*optimize-char-classes* (if file-name-provided-p *optimize-char-classes* nil))
+          ;; we only check for correctness and don't care about speed
+          ;; that match (but rather about space constraints of the
+          ;; trial versions)
+          (*use-bmh-matchers* (if file-name-provided-p *use-bmh-matchers* nil)))
+      (do-tests ((format nil "Running Unicode tests in file ~S" (file-namestring file-name))
+                 (not verbose))
+        (let ((input-line (or (read stream nil) (done)))
+              errors)
+          (destructuring-bind (char-code property-name expected-result)
+              input-line
+            (let ((char (and (< char-code char-code-limit) (code-char char-code))))
+              (when char
+                (when verbose
+                  (format t "~&~A: #x~X" property-name char-code))
+                (let* ((string (string char))
+                       (result-1 (scan (format nil "\\p{~A}" property-name) string))
+                       (result-2 (scan (format nil "[\\p{~A}]" property-name) string))
+                       (inverted-result-1 (scan (format nil "\\P{~A}" property-name) string))
+                       (inverted-result-2 (scan (format nil "[\\P{~A}]" property-name) string)))
+                  (unless (eq expected-result (not (not result-1)))
+                    (push (format nil "\(code-char #x~X) should ~:[not ~;~]have matched \"\\p{~A}\""
+                                  char-code expected-result property-name)
+                          errors))
+                  (unless (eq expected-result (not (not result-2)))
+                    (push (format nil "\(code-char #x~X) should ~:[not ~;~]have matched \"[\\p{~A}]\""
+                                  char-code expected-result property-name)
+                          errors))
+                  (unless (eq expected-result (not inverted-result-1))
+                    (push (format nil "\(code-char #x~X) should ~:[~;not ~]have matched \"\\P{~A}\""
+                                  char-code expected-result property-name)
+                          errors))
+                  (unless (eq expected-result (not inverted-result-2))
+                    (push (format nil "\(code-char #x~X) should ~:[~;not ~]have matched \"[\\P{~A}]\""
+                                  char-code expected-result property-name)
+                          errors)))
+                errors))))))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/unicodetestdata b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/unicodetestdata
new file mode 100644
index 0000000..6db1f25
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/test/unicodetestdata
@@ -0,0 +1,107 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/test/unicodetestdata,v 1.10 2008/07/22 14:00:35 edi Exp $
+
+;;; some arbitrary test data for Unicode properties - stolen from CL-UNICODE
+
+(#x0001 "ASCII" t)
+(#x0100 "ASCII" nil)
+(#x000A "Alphabetic" nil)
+(#x0061 "Alphabetic" t)
+(#x0061 "Ll" t)
+(#x0041 "Alphabetic" t)
+(#x0041 "alphabetic" t)
+(#x0041 "IsAlphabetic" t)
+(#x02E4 "Alphabetic" t)
+(#x0970 "Alphabetic" nil)
+(#x030D "BidiClass:NonspacingMark" t)
+(#x030D "NonspacingMark" t)
+(#x030D "nonspacing mark" t)
+(#xE0146 "BidiClass:NonspacingMark" t)
+(#x000D "BidiClass:WhiteSpace" nil)
+(#x0020 "BidiClass:WhiteSpace" t)
+(#x2006 "BidiClass:WhiteSpace" t)
+(#x12470 "Cuneiform" t)
+(#x12470 "IsCuneiform" t)
+(#x12470 "CuneiformNumbersAndPunctuation" t)
+(#x12470 "Block:CuneiformNumbersAndPunctuation" t)
+(#x12470 "InCuneiformNumbersAndPunctuation" t)
+(#x12470 "Script:Cuneiform" t)
+(#x0041 "Block:Hebrew" nil)
+(#x0593 "Block:Hebrew" t)
+(#x0593 "InHebrew" t)
+(#x040D "Block:Cyrillic" t)
+(#x040D "InCyrillic" t)
+(#x0042 "Block:Cyrillic" nil)
+(#x2011 "Dash" t)
+(#x2011 "IsDash" t)
+(#xFF0D "Dash" t)
+(#x003D "Dash" nil)
+(#x00F0 "Lowercase" t)
+(#x00F0 "IsLowercase" t)
+(#x00F0 "lowercase" t)
+(#x00F0 "Ll" t)
+(#x0067 "Lowercase" t)
+(#x010A "Lowercase" nil)
+(#x1D6C1 "Lowercase" nil)
+(#x0023 "CurrencySymbol" nil)
+(#x0024 "CurrencySymbol" t)
+(#x0024 "IsCurrencySymbol" t)
+(#x0024 "currency symbol" t)
+(#x20AC "CurrencySymbol" t)
+(#xFFE6 "CurrencySymbol" t)
+(#x002B "Sm" t)
+(#x002B "Math" t)
+(#x002B "IsMath" t)
+(#x002B "math" t)
+(#x211C "Math" t)
+(#x1D7D2 "Math" t)
+(#x002A "Math" nil)
+(#x25C9 "Math" nil)
+(#x0000 "NonCharacterCodePoint" nil)
+(#xFDD0 "NonCharacterCodePoint" t)
+(#xFDD0 "Non-Character-Code-Point" t)
+(#xFDD0 "non-character-code-point" t)
+(#xFFFFF "NonCharacterCodePoint" t)
+(#x0043 "Arabic" nil)
+(#x0606 "Arabic" t)
+(#x0606 "arabic" t)
+(#x0606 "IsArabic" t)
+(#x0606 "Script:Arabic" t)
+(#x0044 "IsVariationSelector" nil)
+(#x0044 "VariationSelector" nil)
+(#x180B "VariationSelector" t)
+(#x180B "Variation_Selector" t)
+(#x180B "Variation-Selector" t)
+(#x180B "variationselector" t)
+(#x180B "variation selector" t)
+(#x180B "IsVariationSelector" t)
+(#x00B5 "XIDContinue" t)
+(#x00B5 "IsXIDContinue" t)
+(#x00B5 "IsXID_Continue" t)
+(#x00B5 "Is_XID_Continue" t)
+(#x00B5 "XID_Continue" t)
+(#x33FF "Unified_Ideograph" nil)
+(#x33FF "Ideographic" nil)
+(#x3400 "Unified_Ideograph" t)
+(#x3400 "Ideographic" t)
+(#x3400 "Han" t)
+(#x3400 "OtherLetter" t)
+(#x3400 "Alphabetic" t)
+(#x3400 "Common" nil)
+(#x3400 "Assigned" t)
+(#x3400 "Any" t)
+(#x0378 "Cn" t)
+(#x0378 "Unassigned" t)
+(#x0377 "Cn" nil)
+(#x0377 "Unassigned" nil)
+(#x2800 "Braille" t)
+(#x2800 "Script:Braille" t)
+(#x2800 "OtherSymbol" t)
+(#x0027 "QuotationMark" t)
+(#x201C "QuotationMark" t)
+(#x201C "OtherNeutral" t)
+(#x201C "PatternSyntax" t)
+(#x0028 "Bidi_Mirrored" t)
+(#x0028 "BidiMirrored" t)
+(#x0028 "IsBidiMirrored" t)
+(#x0027 "Bidi_Mirrored" nil)
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/util.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/util.lisp
new file mode 100644
index 0000000..8dd5fd2
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-ppcre-20190521-git/util.lisp
@@ -0,0 +1,201 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/util.lisp,v 1.48 2009/10/28 07:36:15 edi Exp $
+
+;;; Utility functions and constants dealing with the character sets we
+;;; use to encode character classes
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defmacro defconstant (name value &optional doc)
+  "Make sure VALUE is evaluated only once \(to appease SBCL)."
+  `(cl:defconstant ,name (if (boundp ',name) (symbol-value ',name) ,value)
+     ,@(when doc (list doc))))
+
+#+:lispworks
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (import 'lw:with-unique-names))
+
+#-:lispworks
+(defmacro with-unique-names ((&rest bindings) &body body)
+  "Syntax: WITH-UNIQUE-NAMES ( { var | (var x) }* ) declaration* form*
+
+Executes a series of forms with each VAR bound to a fresh,
+uninterned symbol. The uninterned symbol is as if returned by a call
+to GENSYM with the string denoted by X - or, if X is not supplied, the
+string denoted by VAR - as argument.
+
+The variable bindings created are lexical unless special declarations
+are specified. The scopes of the name bindings and declarations do not
+include the Xs.
+
+The forms are evaluated in order, and the values of all but the last
+are discarded \(that is, the body is an implicit PROGN)."
+  ;; reference implementation posted to comp.lang.lisp as
+  ;; <cy3bshuf30f.fsf@ljosa.com> by Vebjorn Ljosa - see also
+  ;; <http://www.cliki.net/Common%20Lisp%20Utilities>
+  `(let ,(mapcar #'(lambda (binding)
+                     (check-type binding (or cons symbol))
+                     (if (consp binding)
+                       (destructuring-bind (var x) binding
+                         (check-type var symbol)
+                         `(,var (gensym ,(etypecase x
+                                          (symbol (symbol-name x))
+                                          (character (string x))
+                                          (string x)))))
+                       `(,binding (gensym ,(symbol-name binding)))))
+                 bindings)
+         ,@body))
+
+#+:lispworks
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (setf (macro-function 'with-rebinding)
+          (macro-function 'lw:rebinding)))
+
+#-:lispworks
+(defmacro with-rebinding (bindings &body body)
+  "WITH-REBINDING ( { var | (var prefix) }* ) form*
+
+Evaluates a series of forms in the lexical environment that is
+formed by adding the binding of each VAR to a fresh, uninterned
+symbol, and the binding of that fresh, uninterned symbol to VAR's
+original value, i.e., its value in the current lexical environment.
+
+The uninterned symbol is created as if by a call to GENSYM with the
+string denoted by PREFIX - or, if PREFIX is not supplied, the string
+denoted by VAR - as argument.
+
+The forms are evaluated in order, and the values of all but the last
+are discarded \(that is, the body is an implicit PROGN)."
+  ;; reference implementation posted to comp.lang.lisp as
+  ;; <cy3wv0fya0p.fsf@ljosa.com> by Vebjorn Ljosa - see also
+  ;; <http://www.cliki.net/Common%20Lisp%20Utilities>
+  (loop for binding in bindings
+        for var = (if (consp binding) (car binding) binding)
+        for name = (gensym)
+        collect `(,name ,var) into renames
+        collect ``(,,var ,,name) into temps
+        finally (return `(let ,renames
+                          (with-unique-names ,bindings
+                            `(let (,,@temps)
+                              ,,@body))))))
+
+(declaim (inline digit-char-p))  
+(defun digit-char-p (chr)
+  (declare #.*standard-optimize-settings*)
+  "Tests whether a character is a decimal digit, i.e. the same as
+Perl's [\\d].  Note that this function shadows the standard Common
+Lisp function CL:DIGIT-CHAR-P."
+  (char<= #\0 chr #\9))
+
+(declaim (inline word-char-p))  
+(defun word-char-p (chr)
+  (declare #.*standard-optimize-settings*)
+  "Tests whether a character is a \"word\" character.  In the ASCII
+charset this is equivalent to a-z, A-Z, 0-9, or _, i.e. the same as
+Perl's [\\w]."
+  (or (alphanumericp chr)
+      (char= chr #\_)))
+
+(defconstant +whitespace-char-string+
+  (coerce '(#\Space #\Tab #\Linefeed #\Return #\Page) 'string)
+  "A string of all characters which are considered to be whitespace.
+Same as Perl's [\\s].")
+
+(defun whitespacep (chr)
+  (declare #.*special-optimize-settings*)
+  "Tests whether a character is whitespace, i.e. whether it would
+match [\\s] in Perl."
+  (find chr +whitespace-char-string+ :test #'char=))
+
+(defmacro maybe-coerce-to-simple-string (string)
+  "Coerces STRING to a simple STRING unless it already is one."
+  (with-unique-names (=string=)
+    `(let ((,=string= ,string))
+      (cond (#+:lispworks
+             (lw:simple-text-string-p ,=string=)
+             #-:lispworks
+             (simple-string-p ,=string=)
+              ,=string=)
+            (t
+             (coerce ,=string=
+                     #+:lispworks 'lw:simple-text-string
+                     #-:lispworks 'simple-string))))))
+
+(declaim (inline nsubseq))
+(defun nsubseq (sequence start &optional (end (length sequence)))
+  "Returns a subsequence by pointing to location in original sequence."
+  (make-array (- end start)
+              :element-type (array-element-type sequence)
+              :displaced-to sequence
+              :displaced-index-offset start))
+
+(defun normalize-var-list (var-list)
+  "Utility function for REGISTER-GROUPS-BIND and DO-REGISTER-GROUPS.
+Creates the long form \(a list of \(FUNCTION VAR) entries) out of the
+short form of VAR-LIST."
+  (loop for element in var-list
+        if (consp element)
+          nconc (loop for var in (rest element)
+                      collect (list (first element) var))
+        else
+          collect (list '(function identity) element)))
+
+(defun string-list-to-simple-string (string-list)
+  "Concatenates a list of strings to one simple-string."
+  (declare #.*standard-optimize-settings*)
+  ;; this function provided by JP Massar; note that we can't use APPLY
+  ;; with CONCATENATE here because of CALL-ARGUMENTS-LIMIT
+  (let ((total-size 0))
+    (declare (fixnum total-size))
+    (dolist (string string-list)
+      #-:genera (declare (string string))
+      (incf total-size (length string)))
+    (let ((result-string (make-sequence #-:lispworks 'simple-string
+                                        #+:lispworks 'lw:simple-text-string
+                                        total-size))
+          (curr-pos 0))
+      (declare (fixnum curr-pos))
+      (dolist (string string-list)
+        #-:genera (declare (string string))
+        (replace result-string string :start1 curr-pos)
+        (incf curr-pos (length string)))
+      result-string)))
+
+(defun complement* (test-function)
+  "Like COMPLEMENT but optimized for unary functions."
+  (declare #.*standard-optimize-settings*)
+  (typecase test-function
+    (function
+     (lambda (char)
+       (declare (character char))
+       (not (funcall (the function test-function) char))))
+    (otherwise
+     (lambda (char)
+       (declare (character char))
+       (not (funcall test-function char))))))
\ No newline at end of file
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/.gitignore b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/.gitignore
new file mode 100644
index 0000000..7b4ffca
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/.gitignore
@@ -0,0 +1,9 @@
+*.fasl
+*.dx32fsl
+*.dx64fsl
+*.lx32fsl
+*.lx64fsl
+*.x86f
+
+t/cl-project-sample
+t/cl-project-caveman
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/.travis.yml b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/.travis.yml
new file mode 100644
index 0000000..d8216c5
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/.travis.yml
@@ -0,0 +1,18 @@
+language: common-lisp
+sudo: false
+
+env:
+  global:
+    - PATH=~/.roswell/bin:$PATH
+    - ROSWELL_INSTALL_DIR=$HOME/.roswell
+  matrix:
+    - LISP=sbcl-bin
+    - LISP=ccl-bin
+
+install:
+  # Install Roswell
+  - curl -L https://raw.githubusercontent.com/roswell/roswell/release/scripts/install-for-ci.sh | sh
+  - ros install prove
+
+script:
+  - run-prove cl-project-test.asd
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/README.markdown b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/README.markdown
new file mode 100644
index 0000000..0c4dc37
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/README.markdown
@@ -0,0 +1,61 @@
+# CL-Project - Generate modern project skeletons
+
+[![Build Status](https://travis-ci.org/fukamachi/cl-project.svg?branch=master)](https://travis-ci.org/fukamachi/cl-project)
+[![Quicklisp dist](http://quickdocs.org/badge/cl-project.svg)](http://quickdocs.org/cl-project/)
+
+## Usage
+
+```common-lisp
+(cl-project:make-project #p"lib/cl-sample/"
+  :author "Eitaro Fukamachi"
+  :email "e.arrows@gmail.com"
+  :license "LLGPL"
+  :depends-on '(:clack :cl-annot))
+;-> writing /Users/fukamachi/Programs/lib/cl-sample/.gitignore
+;   writing /Users/fukamachi/Programs/lib/cl-sample/README.markdown
+;   writing /Users/fukamachi/Programs/lib/cl-sample/cl-sample-test.asd
+;   writing /Users/fukamachi/Programs/lib/cl-sample/cl-sample.asd
+;   writing /Users/fukamachi/Programs/lib/cl-sample/src/hogehoge.lisp
+;   writing /Users/fukamachi/Programs/lib/cl-sample/t/hogehoge.lisp
+;=> T
+```
+
+## What's the difference from other generators?
+
+### 1. Flexible templates
+
+CL-Project supports more parameters to embed, by using [CL-EMB](http://common-lisp.net/project/cl-emb/) to represent the skeleton files (See "cl-project/skeleton/").
+
+### 2. One package per file style (Modern)
+
+A modern CL project should be in accordance with [some rules](http://labs.ariel-networks.com/cl-style-guide.html). For instance, one file must have one package in it.
+
+### 3. Recommends unit testing
+
+Modern projects should have some unit tests. CL-Project generates a system for unit testing, so you can begin writing unit tests as soon as the project is generated.
+
+## Parameters
+
+All parameters are optional.
+
+* `:name`: Project name. If this key isn't specified, the directory name will be used.
+* `:description`: Short description for the new project.
+* `:author`: Your name.
+* `:email`: Your e-mail address.
+* `:license`: License of the new project.
+* `:depends-on`: A list of dependencies.
+
+## See Also
+- [Rove](https://github.com/fukamachi/rove) - Testing framework
+
+## Author
+
+* Eitaro Fukamachi (e.arrows@gmail.com)
+
+## Copyright
+
+Copyright (c) 2011 Eitaro Fukamachi (e.arrows@gmail.com)
+
+## License
+
+Licensed under the LLGPL License.
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/cl-project-test.asd b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/cl-project-test.asd
new file mode 100644
index 0000000..6daee8f
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/cl-project-test.asd
@@ -0,0 +1,17 @@
+#|
+  This file is a part of CL-Project project.
+  Copyright (c) 2011 Eitaro Fukamachi (e.arrows@gmail.com)
+|#
+
+(defsystem "cl-project-test"
+  :defsystem-depends-on ("prove-asdf")
+  :author "Eitaro Fukamachi"
+  :license "LLGPL"
+  :depends-on ("cl-project"
+               "prove"
+               "caveman2"
+               "uiop")
+  :components ((:module "tests"
+                :components
+                ((:test-file "cl-project"))))
+  :perform (test-op (op c) (symbol-call :prove-asdf :run-test-system c)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/cl-project.asd b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/cl-project.asd
new file mode 100644
index 0000000..ab18ba7
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/cl-project.asd
@@ -0,0 +1,33 @@
+#|
+  This file is a part of CL-Project package.
+  URL: http://github.com/fukamachi/cl-project
+  Copyright (c) 2011 Eitaro Fukamachi <e.arrows@gmail.com>
+
+  CL-Project is freely distributable under the LLGPL License.
+|#
+
+#|
+  Generate a skeleton for modern project
+
+  Author: Eitaro Fukamachi (e.arrows@gmail.com)
+|#
+
+(defsystem "cl-project"
+  :version "0.3.1"
+  :author "Eitaro Fukamachi"
+  :license "LLGPL"
+  :depends-on ("cl-emb"
+               "uiop"
+               "cl-ppcre"
+               "local-time"
+               "prove")
+  :components ((:module "src"
+                :components
+                ((:file "cl-project" :depends-on ("specials" "file" "skeleton"))
+                 (:file "file" :depends-on ("specials" "io"))
+                 (:file "skeleton" :depends-on ("specials" "file" "middleware"))
+                 (:file "io" :depends-on ("specials"))
+                 (:file "middleware" :depends-on ("file"))
+                 (:file "specials"))))
+  :description "Generate a skeleton for modern project"
+  :in-order-to ((test-op (test-op "cl-project-test"))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/roswell/make-project.ros b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/roswell/make-project.ros
new file mode 100644
index 0000000..996b91a
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/roswell/make-project.ros
@@ -0,0 +1,62 @@
+#!/bin/sh
+#|-*- mode:lisp -*-|#
+#|
+exec ros -Q -- $0 "$@"
+|#
+
+#|
+A command-line interface for cl-project:make-project.
+|#
+
+(ql:quickload '(:uiop :alexandria) :silent t)
+
+(import 'alexandria:starts-with-subseq)
+(import 'alexandria:ensure-list)
+
+(defun help ()
+  (format t "~&Usage:
+    make-project /home/user/common-lisp/sample --name sample --description \"sample project.\" --author \"Your name\" --license LLGPL --depends-on alexandria split-sequence~%"))
+
+(defun terminate (&optional message args)
+  (when message
+    (format *error-output* "~&Error: ~A~%"
+            (apply #'format nil (princ-to-string message) (ensure-list args))))
+  (uiop:quit -1))
+
+(defun parse-args (args)
+  (flet ((keyp (string)
+           (starts-with-subseq "--" string))
+         (parse-value (value)
+           (or (ignore-errors
+                (let ((read-value (read-from-string value)))
+                  (if (and (symbolp read-value)
+                           (not (keywordp read-value)))
+                      value
+                      read-value)))
+               value)))
+    (let ((path (pop args)))
+      (when (starts-with-subseq "--" path)
+        (terminate "No path given."))
+      (cons (pathname path)
+            (loop for index from 0 below (length args)
+                  for first = (elt args index)
+                  for rest = (subseq args (incf index))
+                  for key = (or (when (not (keyp first))
+                                  (terminate "Invalid option: ~S" first))
+                                (intern (string-upcase (subseq first 2)) :keyword))
+                  for value = (if (eql key :depends-on)
+                                  (loop for (item . rest) on rest
+                                        collecting item
+                                        until (keyp (car rest))
+                                        do (incf index))
+                                  (parse-value (car rest)))
+                  nconc (list key (parse-value value)))))))
+
+(defun main (&rest args)
+  (unless args
+    (help)
+    (terminate))
+
+  (ql:quickload :cl-project :silent t)
+
+  (apply (intern (string :make-project) :cl-project) (parse-args args)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/.gitignore b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/.gitignore
new file mode 100644
index 0000000..86123b5
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/.gitignore
@@ -0,0 +1,8 @@
+*.fasl
+*.dx32fsl
+*.dx64fsl
+*.lx32fsl
+*.lx64fsl
+*.x86f
+*~
+.#*
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/README.markdown b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/README.markdown
new file mode 100644
index 0000000..6038b8e
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/README.markdown
@@ -0,0 +1,21 @@
+# <%= (string-capitalize (getf env :name)) %><% @if description %> - <% @var description %><% @endif %>
+
+## Usage
+
+## Installation
+<%- @if author %>
+
+## Author
+
+* <% @var author %><% @if email %> (<% @var email %>)<% @endif %>
+
+## Copyright
+
+Copyright (c) <%= (local-time:timestamp-year (local-time:now)) %> <% @var author %><% @if email %> (<% @var email %>)<% @endif %>
+<%- @endif %>
+<%- @if license %>
+
+## License
+
+Licensed under the <% @var license %> License.
+<%- @endif %>
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/README.org b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/README.org
new file mode 100644
index 0000000..3fc0b09
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/README.org
@@ -0,0 +1,21 @@
+* <%= (string-capitalize (getf env :name)) %> <% @if description %> - <% @var description %><% @endif %>
+
+** Usage
+
+** Installation
+<%- @if author %>
+
+** Author
+
++ <% @var author %><% @if email %> (<% @var email %>)<% @endif %>
+
+** Copyright
+
+Copyright (c) <%= (local-time:timestamp-year (local-time:now)) %> <% @var author %><% @if email %> (<% @var email %>)<% @endif %>
+<%- @endif %>
+<%- @if license %>
+
+** License
+
+Licensed under the <% @var license %> License.
+<%- @endif %>
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/skeleton.asd b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/skeleton.asd
new file mode 100644
index 0000000..92ddf85
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/skeleton.asd
@@ -0,0 +1,24 @@
+(defsystem "<% @var name %>"
+  :version "0.1.0"
+  :author "<% @var author %>"
+  :license "<% @var license %>"
+  :depends-on (<% (format t "~{\"~(~A~)\"~^~%               ~}"
+                          (getf env :depends-on)) %>)
+  :components ((:module "src"
+                :components
+                ((:file "main"))))
+  :description "<% @var description %>"
+  <%- @unless without-tests %>
+  :in-order-to ((test-op (test-op "<% @var name %>/tests")))
+  <%- @endunless %>)
+
+(defsystem "<% @var name %>/tests"
+  :author "<% @var author %>"
+  :license "<% @var license %>"
+  :depends-on ("<% @var name %>"
+               "rove")
+  :components ((:module "tests"
+                :components
+                ((:file "main"))))
+  :description "Test system for <% @var name %>"
+  :perform (test-op (op c) (symbol-call :rove :run c)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/src/main.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/src/main.lisp
new file mode 100644
index 0000000..377e4ae
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/src/main.lisp
@@ -0,0 +1,5 @@
+(defpackage <% @var name %>
+  (:use :cl))
+(in-package :<% @var name %>)
+
+;; blah blah blah.
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/tests/main.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/tests/main.lisp
new file mode 100644
index 0000000..6d73ac4
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/skeleton/tests/main.lisp
@@ -0,0 +1,11 @@
+(defpackage <% @var name %>/tests/main
+  (:use :cl
+        :<% @var name %>
+        :rove))
+(in-package :<% @var name %>/tests/main)
+
+;; NOTE: To run this test file, execute `(asdf:test-system :<% @var name %>)' in your Lisp.
+
+(deftest test-target-1
+  (testing "should (= 1 1) to be true"
+    (ok (= 1 1))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/cl-project.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/cl-project.lisp
new file mode 100644
index 0000000..af8645b
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/cl-project.lisp
@@ -0,0 +1,40 @@
+(in-package :cl-user)
+(defpackage cl-project
+  (:use #:cl)
+  (:import-from #:cl-project.specials
+                #:*skeleton-directory*
+                #:*skeleton-parameters*)
+  (:import-from #:cl-project.skeleton
+                #:make-skeleton-from-directory)
+  (:import-from #:cl-project.file
+                #:generate)
+  (:export #:*skeleton-directory*
+           #:make-project
+           #:generate-skeleton))
+(in-package :cl-project)
+
+(defun make-project (path &rest params &key name description author email license depends-on (without-tests nil) &allow-other-keys)
+  "Generate a skeleton."
+  (declare (ignore name description author email license depends-on without-tests))
+  (check-type path pathname)
+
+  ;; Ensure `path' ends with a slash(/).
+  (setf path (uiop:ensure-directory-pathname path))
+
+  (unless (getf params :name)
+    (setf (getf params :name)
+          (car (last (pathname-directory path)))))
+  (let ((files (generate-skeleton
+                *skeleton-directory*
+                path
+                :env params)))
+    (dolist (file files)
+      (when (string= (pathname-type file) "asd")
+        (let ((dir (make-pathname :name nil :type nil :defaults file)))
+          (push dir asdf:*central-registry*)))))
+  t)
+
+(defun generate-skeleton (source-dir target-dir &key env)
+  "General skeleton generator."
+  (let ((*skeleton-parameters* env))
+    (generate (make-skeleton-from-directory source-dir) target-dir)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/file.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/file.lisp
new file mode 100644
index 0000000..1502cd7
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/file.lisp
@@ -0,0 +1,37 @@
+(in-package :cl-user)
+(defpackage cl-project.file
+  (:use #:cl
+        #:cl-project.specials)
+  (:import-from #:cl-project.io
+                #:copy-file-to-file)
+  (:import-from #:cl-ppcre
+                #:regex-replace-all)
+  (:export #:template-file
+           #:template-file-path
+           #:make-template-file
+           #:generate))
+(in-package :cl-project.file)
+
+(defclass template-file ()
+  ((path :type pathname
+         :initarg :path
+         :accessor template-file-path)))
+
+(defun make-template-file (path)
+  (make-instance 'template-file :path path))
+
+(defgeneric generate (file target-dir)
+  (:method ((file template-file) target-dir)
+    (let ((target-path
+            (merge-pathnames (template-file-path file) target-dir)))
+      (when (search "skeleton" (pathname-name target-path))
+        (setf target-path
+              (make-pathname :name
+                             (regex-replace-all "skeleton"
+                                                (pathname-name target-path)
+                                                (getf *skeleton-parameters* :name))
+                             :defaults target-path)))
+      (copy-file-to-file (merge-pathnames (template-file-path file)
+                                          *skeleton-directory*)
+                         target-path)
+      (list target-path))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/io.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/io.lisp
new file mode 100644
index 0000000..71e4f18
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/io.lisp
@@ -0,0 +1,17 @@
+(in-package :cl-user)
+(defpackage cl-project.io
+  (:use #:cl
+        #:cl-project.specials)
+  (:import-from #:cl-emb
+                #:execute-emb)
+  (:export #:copy-file-to-file))
+(in-package :cl-project.io)
+
+(defun copy-file-to-file (source-path target-path)
+  "Copy a file `source-path` to the `target-path`."
+  (format t "~&writing ~A~%" target-path)
+  (ensure-directories-exist target-path)
+  (with-open-file (stream target-path :direction :output :if-exists :supersede)
+    (write-sequence
+     (cl-emb:execute-emb source-path :env *skeleton-parameters*)
+     stream)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/middleware.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/middleware.lisp
new file mode 100644
index 0000000..f7dac0e
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/middleware.lisp
@@ -0,0 +1,21 @@
+(in-package :cl-user)
+(defpackage cl-project.middleware
+  (:use #:cl)
+  (:import-from #:cl-project.file
+                #:template-file-path)
+  (:export #:*without-tests*))
+(in-package :cl-project.middleware)
+
+(defparameter *without-tests*
+  (lambda (app &key
+            (test-asd "skeleton-test.asd")
+            (test-directory #P"t/"))
+    (lambda (file)
+      (unless (or
+               ;; Skip test ASD file
+               (string= (file-namestring (template-file-path file))
+                        test-asd)
+               ;; Skip test files
+               (eql 0 (search (namestring test-directory)
+                              (namestring (template-file-path file)))))
+        (funcall app file)))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/skeleton.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/skeleton.lisp
new file mode 100644
index 0000000..1ba90e1
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/skeleton.lisp
@@ -0,0 +1,63 @@
+(in-package :cl-user)
+(defpackage cl-project.skeleton
+  (:use #:cl
+        #:cl-project.specials)
+  (:import-from #:cl-project.file
+                #:make-template-file
+                #:template-file-path
+                #:generate)
+  (:export #:skeleton
+           #:make-skeleton
+           #:make-skeleton-from-directory))
+(in-package :cl-project.skeleton)
+
+(defclass skeleton ()
+  ((path :type pathname
+         :initarg :path
+         :accessor skeleton-path)
+   (children :type list
+             :initarg :children
+             :initform '()
+             :accessor skeleton-children)))
+
+(defun make-skeleton (path children)
+  (make-instance 'skeleton :path path :children children))
+
+(defmethod generate ((skeleton skeleton) target-dir)
+  (let ((app (lambda (file)
+               (generate file target-dir))))
+    (when (getf *skeleton-parameters* :without-tests)
+      (setf app
+            (funcall cl-project.middleware:*without-tests*
+                     app)))
+    (mapcan app (skeleton-children skeleton))))
+
+(defun maptree (fn path)
+  (flet ((directory-files (path)
+           ;; Older ASDF/UIOP's uiop:directory-files returns also directories on Linux.
+           ;; The bug had been fixed at ASDF 3.1.0.64 (https://bugs.launchpad.net/asdf/+bug/1276748), however, it's safe to filter directories anyway.
+           ;; ref. https://github.com/fukamachi/cl-project/pull/17
+           (set-difference (uiop:directory-files path)
+                           (uiop:subdirectories path)
+                           :test #'equal)))
+    (if (uiop:file-pathname-p path)
+        ;; file
+        (list (funcall fn path))
+        ;; directory
+        (append
+          (mapcar fn (directory-files path))
+          (mapcan (lambda (subdir)
+                    (maptree fn subdir))
+                  (uiop:subdirectories path))))))
+
+(defun make-skeleton-from-directory (directory)
+  (flet ((relative-path (path)
+           (pathname
+            (subseq
+             (namestring path)
+             (length (namestring directory))))))
+    (make-skeleton
+     directory
+     (maptree (lambda (file)
+                (make-template-file (relative-path file)))
+              directory))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/specials.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/specials.lisp
new file mode 100644
index 0000000..8187601
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/src/specials.lisp
@@ -0,0 +1,15 @@
+(in-package :cl-user)
+(defpackage cl-project.specials
+  (:use #:cl)
+  (:export #:*default-skeleton-directory*
+           #:*skeleton-directory*
+           #:*skeleton-parameters*))
+(in-package :cl-project.specials)
+
+(defparameter *default-skeleton-directory*
+  (asdf:system-relative-pathname :cl-project #P"skeleton/"))
+
+(defvar *skeleton-directory*
+  *default-skeleton-directory*)
+
+(defvar *skeleton-parameters* nil)
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/tests/cl-project.lisp b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/tests/cl-project.lisp
new file mode 100644
index 0000000..5987f89
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/cl-project-20190521-git/tests/cl-project.lisp
@@ -0,0 +1,46 @@
+#|
+  This file is a part of CL-Project project.
+  Copyright (c) 2011 Eitaro Fukamachi (e.arrows@gmail.com)
+|#
+
+(in-package :cl-user)
+(defpackage cl-project-test
+  (:use :cl
+        :cl-project
+        :prove))
+(in-package :cl-project-test)
+
+(plan 2)
+
+(defvar *sample-project-directory*
+    (asdf:system-relative-pathname
+     :cl-project
+     #p"t/cl-project-sample/"))
+
+(uiop:delete-directory-tree *sample-project-directory* :validate t :if-does-not-exist :ignore)
+
+(subtest "normal case"
+  (cl-project:make-project *sample-project-directory*)
+  (ok (uiop:directory-exists-p *sample-project-directory*)
+      "Sample project was generated")
+  (ok (asdf:load-system :cl-project-sample)
+      "Can load the new project"))
+
+(defvar *sample-caveman-directory*
+  (asdf:system-relative-pathname
+   :cl-project
+   #P"t/cl-project-caveman/"))
+
+(uiop:delete-directory-tree *sample-caveman-directory* :validate t :if-does-not-exist :ignore)
+
+(subtest "Caveman2"
+  (caveman2:make-project *sample-caveman-directory*)
+  (ok (uiop:directory-exists-p *sample-caveman-directory*)
+      "Sample project was generated")
+  #+quicklisp
+  (ok (ql:quickload :cl-project-caveman)
+      "Can load the new project")
+  #-quicklisp
+  (skip 1 "Can load the new project"))
+
+(finalize)
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/.gitignore b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/.gitignore
new file mode 100644
index 0000000..b997f75
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/.gitignore
@@ -0,0 +1,4 @@
+*.fasl
+*~
+unit-tests/test-results/
+README.html
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/LICENSE_1_0.txt b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/LICENSE_1_0.txt
new file mode 100644
index 0000000..36b7cd9
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/LICENSE_1_0.txt
@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/README.org b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/README.org
new file mode 100644
index 0000000..c6c5b8f
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/README.org
@@ -0,0 +1,194 @@
+#+TITLE: =let+=: destructuring extension of =let*=
+#+AUTHOR: Tamás K. Papp
+
+This library implements the =let+= macro, which is a dectructuring
+extension of =let*=.
+
+* Highlights
+
+- clean, consistent syntax and small implementation (less than 300 LOC, not counting tests)
+
+- placeholder macros allow editor hints and syntax highlighting
+
+- =&ign= for ignored values (in forms where that makes sense)
+
+- very easy to extend
+
+* Similar libraries
+
+This library was inspired by Gary King's excellent [[http://common-lisp.net/project/metabang-bind/][metabang-bind]].  I
+have been using the latter for years now, but at some point I decided
+to write a library of my own, aiming for a cleaner syntax, more
+concise implementation and a more consistent interface (whether I have
+succeeded is of course a matter of judgement --- try [[http://common-lisp.net/project/metabang-bind/][metabang-bind]] to
+see if you like it better).
+
+In my opinion the main advantages of this library, compared to
+[[http://common-lisp.net/project/metabang-bind/][metabang-bind]], are the placeholder macros which provide editor hints
+and the more consistent syntax of destructuring forms.  In particular,
+when both read-write and read-only forms are available the latter
+always have the =-r/o= suffix, =&flet= and =&labels= resemble the
+Common Lisp syntax more closely, and the library should be easier to
+extend.
+
+You can find other pattern matching libraries on [[http://www.cliki.net/pattern%20matching][cliki]].
+
+* Syntax
+
+#+BEGIN_SRC lisp
+let+ ({binding}*) body*
+#+END_SRC
+where
+#+BEGIN_SRC lisp
+binding ::= symbol || (form [init-form])
+#+END_SRC
+
+=LET+= is recursive: each binding is in the scope of the previous
+ones.  Forms ignore =&ign= variables (where applicable).
+
+** Built-in forms
+
+Forms which provide both read-write and read-only access are available as =&form= and =&form-r/o=.  The first one always uses symbol macros, so you can use =setf=.  The second one reads the values at the beginning of the list from value: you can change these variables after that without having any effect on the original value.  Read-only forms may also provide a slight increase in speed, and promote good style --- you can use them to signal that you will not change the original structure.
+
+The following forms are defined:
+
+- =var=, =(var)=, =(var value)= :: These behave just like they do in =let*=.
+
+- =(list value)= :: When =list= is not recognized as any of the forms below, it is simply destructured using =destructuring-bind=.  =&ign= are ignored.  Example:
+#+BEGIN_SRC lisp
+(let+ (((a (b &optional (c 3)) &ign &key (d 1 d?)) '(1 (2) 7 :d 4)))
+  (list a b c d d?))  ; => (1 2 3 4 T)
+#+END_SRC
+
+- =((&slots slot*) value)=, also =&slots-r/o= :: Similarly to =with-slots=, each =slot= has the syntax =variable= or =(variable)= (for these, the variable name is also used for the slot name) or =(variable slot-name)=.  =&slots-r/o= provides read-only bindings.
+
+     Example:
+#+BEGIN_SRC lisp
+(defclass foo-class ()
+  ((a :accessor a :initarg :a)
+   (b :accessor b-accessor :initarg :b)))
+
+(let+ (((&slots a (my-b b)) (make-instance 'foo-class :a 1 :b 2)))
+  (list a my-b))  ; => (1 2)
+#+END_SRC
+
+- =((&accessors accessor*) value)=, also =&accessors-r/o= :: Syntax similar to =&slots=, but uses accessors.  Continuing the example above:
+#+BEGIN_SRC lisp
+(let+ (((&accessors a (b b-accessor)) (make-instance 'foo-class :a 1 :b 2)))
+  (list a b))  ; => (1 2)
+#+END_SRC
+
+- =((&structure conc-name slot*) value)=, also =&structure-r/o= :: Slot access for structures.  =Conc-name= is prepended to the accessors (you need to include the =-= if there is one).  Example:
+#+BEGIN_SRC lisp
+(defstruct foo-struct c d)
+(let+ (((&structure foo-struct- c (my-d d)) (make-foo-struct :c 3 :d 4)))
+  (list c my-d))  ; => (3 4)
+#+END_SRC
+
+- =((&values value*) form)= :: Similar to =multiple-value-bind=.  =&ign= are ignored.  Example:
+#+BEGIN_SRC lisp
+(let+ (((&values a &ign b) (values 1 2 3)))
+  (list a b))  ; => (1 3)
+#+END_SRC
+
+- =(array value)= (only read-only version) :: The array is
+     destructured to the given elements, =&ign= are ignored.  Indexes
+     use row-major access, determined at macroexpansion time.
+     Example:
+#+BEGIN_SRC lisp
+(let+ ((#(a &ign b) (vector 1 2 3)))
+  (list a b))  ; => (1 3)
+#+END_SRC
+
+- =((&array-elements (variable subscript*)*) value)=, also =&array-elements-r/o= :: Array elements with given subscripts are assigned to the variables.  Example:
+#+BEGIN_SRC lisp
+(let+ (((&array-elements (a 0 1)
+                         (b 2 0))
+        #2A((0 1)
+            (2 3)
+            (4 5))))
+  (list a b))  ; => (1 4)
+#+END_SRC
+
+- =((&flet name lambda-list forms*))=, also =&labels= :: Function bindings.  These have no value form. =&labels= allows the function to refer to itself -- note that since =let+= is always recursive, this is the only difference between the two forms.  Example:
+#+BEGIN_SRC lisp
+(let+ (((&flet add2 (x)
+          (+ x 2))))
+  (add2 5))  ; => 7
+#+END_SRC
+
+- =((&plist (variable key [default])*)=, also =&plist-r/o= :: Access to property lists.  When =key= is not given, =variable= is used instead, and =default= is used if the element does not exist in the value (note that default may be evaluated multiple times when using the read-write form which uses =symbol-macrolet=).  Example:
+#+BEGIN_SRC lisp
+(let+ (((&plist a (my-b b) (c nil 3)) '(a 1 b 2)))
+  (list a my-b c))  ; => (1 2 3)
+#+END_SRC
+
+- =(((&hash-table (variable key [default])*)=, also =&hash-table-r/o= :: Access to the elements of hash tables, the semantics is the same as =&plist=.
+
+- =(&complex real imaginary)= :: Destructures complex numbers.
+
+** Nesting
+
+You can nest =let+= expressions when it makes sense (it doesn't always, especially for read/write slots, the read only form should work).  For example,
+#+BEGIN_SRC lisp
+(let+ ((#((&complex a b)) (vector (complex 1 2))))
+  (list a b))
+#+END_SRC
+should destructure the complex number that is the single element in the vector.
+
+If you find that =let+= does not nest properly, please report it as a bug.
+
+** Convenience macros
+
+- =(defun+ name (argument*) form*)=, also =(lambda (argument*) form*)= :: Work like =defun= and =lambda=, but arguments are destructured using =let+=.  Example:
+#+BEGIN_SRC lisp
+(defun+ foo ((&plist a b c) #(d e))
+  (list a b c d e))
+
+(foo '(a 1 b 2 c 3) #(4 5))  ; => (1 2 3 4 5)
+#+END_SRC
+See also =&labels+= and =&lambda+=.
+
+- =define-structure-let+= :: Can be used to provide destructuring forms for structures.
+
+** Other forms
+
+- =(&once-only symbols ...)= and =(&with-gensyms symbols)= are useful for writing macros.
+
+* Extensions
+
+Extending =let-plus= is very easy: if you want to use a form that
+resembles a list, you just have to define a method for
+=let+-expansion-for-list=.  There is a macro that helps you with that,
+called =define-let+-expansion=.  If the library didn't have
+=&complex=, we could define destructuring for the form like this:
+
+#+BEGIN_SRC lisp
+(define-let+-expansion (&complex (x y))
+  "Access real and imaginary part of the value.  Read-only."
+  `(let ((,x (realpart ,value))
+         (,y (imagpart ,value)))
+     ,@body))
+#+END_SRC
+Some highlights:
+
+- this macro defines a "placeholder" macro =&complex= that should
+  help with editor hints, but has no other purpose (it is not used in
+  the expansion),
+- the macro is anaphoric, capturing =value= (the value form) and
+  =body= (the body inside the =let+= form), you can customize both of
+  this using keyword arguments,
+- unless required otherwise, =value= is wrapped in =once-only=
+  preventing multiple evaluations of the same form.  See the arguments =:uses-value?= and =:once-only?= for =define-let+-expansion=.
+
+If you want to extend =let+= with forms that are not lists (eg like
+the array syntax above), have a look at =let+-expansion=.
+
+* Reporting bugs
+
+Please open an [[https://github.com/sharplispers/let-plus/issues][issue]] on Github for bugs.  Extensions are also welcome,
+either as forks or small code snippets submitted as issues.  Wishlist
+items are also welcome!
+
+I ask you not to report bugs via e-mail if you can avoid it.  Tracking
+bugs on Github makes it less likely that they get lost.
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/extensions.lisp b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/extensions.lisp
new file mode 100644
index 0000000..b53be6f
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/extensions.lisp
@@ -0,0 +1,90 @@
+;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; Coding:utf-8 -*-
+
+(in-package #:let-plus)
+
+(defun destructured-lambda-list-forms (lambda-list body)
+  "Return a list that can be spliced into function definitions (eg DEFUN, LAMBDA, FLET, LABELS).
+
+The list starts with a lambda list, and is followed by a docstring (when provided), then a LET+ form that wraps declarations (when provided) and BODY.
+
+Used internally, not exported."
+  (let+ (((&values body declarations documentation)
+          (parse-body body :documentation t))
+         ((&values arguments bindings ignores)
+          (loop :for parameter :in lambda-list
+             :for argument = (gensym)
+             :collect argument :into arguments
+             :if (eq parameter '&ign) :collect argument :into ignores
+             :else :collect (list parameter argument) :into bindings
+             :finally (return (values arguments bindings ignores)))))
+    `(,arguments
+      ,@(when documentation `(,documentation))
+      ,@(when ignores `((declare (ignore ,@ignores))))
+      (let+ ,bindings
+        ,@declarations
+        ,@body))))
+
+(define-let+-expansion (&flet+ (function-name lambda-list
+                                              &body function-body)
+                           :uses-value? nil)
+  "&FLET that destructures its arguments using LET+."
+  `(let+ (((&flet ,function-name
+               ,@(destructured-lambda-list-forms lambda-list function-body))))
+     ,@body))
+
+(define-let+-expansion (&labels+ (function-name lambda-list
+                                                &body function-body)
+                               :uses-value? nil)
+  "&LABELS that destructures its arguments using LET+."
+  `(let+ (((&labels ,function-name
+               ,@(destructured-lambda-list-forms lambda-list function-body))))
+     ,@body))
+
+(defmacro lambda+ (lambda-list &body body)
+  "LAMBDA that destructures its arguments using LET+."
+  `(lambda ,@(destructured-lambda-list-forms lambda-list body)))
+
+(defmacro defun+ (name lambda-list &body body)
+  "DEFUN that destructures its arguments using LET+."
+  `(defun ,name ,@(destructured-lambda-list-forms lambda-list body)))
+
+(defmacro define-structure-let+ ((name
+                                  &key (conc-name (symbolicate name #\-))
+                                       (r/w (symbolicate #\& name))
+                                       (r/o (symbolicate #\& name '#:-r/o)))
+                                 &rest slot-names)
+  "Define a LET+ expansion for accessing slots of a structure in a fixed order."
+  (let ((variable-name-pairs
+         (loop for slot-name in slot-names collect
+               ``(,,slot-name ,',slot-name))))
+    `(eval-when (:compile-toplevel :load-toplevel :execute)
+       (define-let+-expansion (,r/w (,@slot-names))
+         ,(format nil "LET+ form for slots of the structure ~A." name)
+         `(let+ (((&structure ,',conc-name ,,@variable-name-pairs) ,value))
+            ,@body))
+       (define-let+-expansion (,r/o (,@slot-names))
+         ,(format nil "LET+ form for slots of the structure ~A.  Read-only."
+                  name)
+         `(let+ (((&structure-r/o ,',conc-name ,,@variable-name-pairs)
+                  ,value))
+            ,@body)))))
+
+(define-let+-expansion (&fwrap (name))
+  "Wrap closure in the local function NAME.  Calls to NAME will call the closure."
+  `(let+ (((&flet ,name (&rest arguments)
+             (apply ,value arguments))))
+     ,@body))
+
+(define-let+-expansion (&once-only specs :uses-value? nil)
+  "Expand to (ONCE-ONLY SPECS ...)."
+  `(once-only ,specs ,@body))
+
+(define-let+-expansion (&with-gensyms names :uses-value? nil)
+  "Expand to (WITH-GENSYMS NAMES ...)."
+  `(with-gensyms ,names ,@body))
+
+(define-let+-expansion (&complex (x y))
+  "Access real and imaginary part of the value.  Read-only."
+  `(let ((,x (realpart ,value))
+         (,y (imagpart ,value)))
+     ,@body))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/let-plus.asd b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/let-plus.asd
new file mode 100644
index 0000000..fc4ed95
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/let-plus.asd
@@ -0,0 +1,25 @@
+(defsystem "let-plus"
+  :description "Destructuring extension of LET*."
+  :author "Tamas K. Papp <tkpapp@gmail.com>."
+  :maintainer "Sharp Lispers <sharplispers@googlegroups.com>"
+  :license "Boost Software License - Version 1.0"
+  :version "0.2"
+  :serial t
+  :components ((:file "package")
+               (:file "let-plus")
+               (:file "extensions"))
+  :depends-on ("alexandria"
+               "anaphora")
+  :in-order-to ((test-op (test-op "let-plus/tests"))))
+
+(defsystem "let-plus/tests"
+  :description "Tests for the LET-PLUS library."
+  :author "Tamas K. Papp <tkpapp@gmail.com>."
+  :maintainer "Sharp Lispers <sharplispers@googlegroups.com>"
+  :license "Same as LET-PLUS -- this is part of the latter."
+  :serial t
+  :components ((:file "tests"))
+  :depends-on ("lift"
+               "let-plus")
+  :perform (test-op (operation component)
+             (uiop:symbol-call '#:let-plus-tests '#:run)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/let-plus.lisp b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/let-plus.lisp
new file mode 100644
index 0000000..f6104f4
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/let-plus.lisp
@@ -0,0 +1,336 @@
+;;;; let-plus.lisp
+
+(in-package #:let-plus)
+
+;;; LET+ recognizes three general kinds of syntax for accessing elements in
+;;; some structure (in the abstract sense):
+;;;
+;;; 1. "slots", of the form (VARIABLE &optional (SLOT VARIABLE)) SLOT is used
+;;;    in the general sense, it can also be an accessor.  This is similar to
+;;;    the syntax of WITH-SLOTS etc.
+;;;
+;;; 2. "entries", of the form (VARIABLE &optional (KEY VARIABLE) DEFAULT),
+;;;    which allows a default value.  This is used for hash tables, property
+;;;    lists, etc.  If KEY is NIL, VARIABLE is used instead, if another
+;;;    symbol, it is quoted.
+;;;
+;;; 3. array-like reference (VARIABLE &rest SUBSCRIPTS).  This is used for
+;;;    array elements.
+;;;
+;;; If a single symbol is given, it is used as a variable for entries and
+;;; slots.
+
+;;; Ignored variables
+;;;
+;;; The preferred method is expanding into LET+ forms which handle ignored
+;;; values automatically -- LET+ just ignores these variables.  Use
+;;; REPLACE-IGNORED only when this is not feasible or desirable (eg using
+;;; destructuring provided by CL).
+
+(defun ignored? (symbol)
+  "Return a boolean determining if a variable is to be ignored.
+
+NOTE: It is unlikely that you need to used this function, see the note above its definition."
+  (eq symbol '&ign))
+
+(defun replace-ignored (tree)
+  "Replace ignored variables in TREE with a gensym, return a list of these as the second value.
+
+NOTE: It is unlikely that you need to used this function, see the note above its definition."
+  (let (ignored)
+    (labels ((traverse (tree)
+               (if (atom tree)
+                   (if (ignored? tree)
+                       (aprog1 (gensym)
+                         (push it ignored))
+                       tree)
+                   (cons (traverse (car tree))
+                         (awhen (cdr tree) (traverse it))))))
+      (values (traverse tree) (nreverse ignored)))))
+
+;;; LET+ uses generic functions for expansion.  They are dispatched on the
+;;; FORM, and further on the first element if it is a list.  LET+-EXPANSION
+;;; should wrap BODY in the desired forms, implementing the expansion.  The
+;;; recursive expansion of multiple forms is done by the LET+ macro.
+;;;
+;;; LET+ forms start with & (except for those expanding into LET(*) and
+;;; DESTRUCTURING-BIND), although this convention is not enfored.
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (defun &-symbol? (symbol)
+    "Test whether the symbol's name starts with a & character."
+    (char= (aref (symbol-name symbol) 0) #\&)))
+
+(defgeneric let+-expansion (form value body)
+  (:documentation "Return an expansion for a LET+ form.")
+  (:method (form value body)
+    (declare (ignore value body))
+    (error "LET+ could not recognize ~A." form))
+  (:method ((variable null) value body)
+    `(destructuring-bind nil ,value
+       ,@body))
+  (:method ((variable symbol) value body)
+    (cond
+      ((ignored? variable) `(locally ,@body))
+      ((&-symbol? variable)
+       (warn "Possibly left out one level of nesting in LET+ form (~A ~A)."
+             variable value))
+      (t `(let ((,variable ,@(when value `(,value))))
+            ,@body))))
+  (:method ((form list) value body)
+    (let+-expansion-for-list (first form) (rest form) value body)))
+
+(defgeneric let+-expansion-for-list (first rest value body)
+  (:documentation "LET+-EXPANSION calls this for lists, see the latter for semantics of returned values.")
+  (:method (first rest value body)
+    ;; forms not recognized as anything else are destructured
+    (when (and (symbolp first) (not (ignored? first)) (&-symbol? first)
+               (not (find first lambda-list-keywords)))
+      (warn "~A looks like a LET+ keyword, but it has no expansion method defined.  Treating it as a lambda list." first))
+    (let ((form (cons first rest)))
+      (multiple-value-bind (form ignored) (replace-ignored form)
+        `(destructuring-bind ,form ,value
+           (declare (ignore ,@ignored))
+           ,@body)))))
+
+(defmacro let+ (bindings &body body)
+  "Destructuring bindings.  See the documentation of the LET-PLUS library.  Most accepted forms start with &."
+  (labels ((expand (bindings)
+             (destructuring-bind (binding &rest other-bindings) bindings
+               (destructuring-bind (form &optional value)
+                   (ensure-list binding)
+                 (let+-expansion form value (aif other-bindings
+                                                 (list (expand it))
+                                                 body))))))
+    (if bindings
+        (expand bindings)
+        `(locally ,@body))))
+
+(defmacro define-let+-expansion ((name arguments &key
+                                       (value-var 'value)
+                                       (body-var 'body)
+                                       (uses-value? t)
+                                       (once-only? uses-value?))
+                                 &body body)
+  "Define an expansion for LET+ forms which are lists, starting with NAME.  ARGUMENTS is destructured if a list.  A placeholder macro is defined with NAME, using DOCSTRING and ARGUMENTS.  The value form is bound to VALUE-VAR (wrapped in ONCE-ONLY when ONCE-ONLY?), while the body is bound to BODY-VAR.  USES-VALUE? determines if the form uses a value, and generates the appropriate checks."
+  (let ((arguments-var (gensym "ARGUMENTS"))
+        (arguments (if (listp arguments)
+                       arguments
+                       `(&rest ,arguments)))
+        (whole (gensym "WHOLE")))
+    (multiple-value-bind (remaining-forms declarations docstring)
+        (parse-body body :documentation t)
+      (sunless docstring (setf it (format nil "LET+ form ~A." name)))
+      `(progn
+         (defmacro ,name (&whole ,whole ,@arguments)
+           ,docstring
+           (declare (ignore
+                     ,@(remove-if (lambda (symbol)
+                                    (or (not symbol)
+                                        (not (symbolp symbol))
+                                        (keywordp symbol)
+                                        (find symbol lambda-list-keywords)
+                                        (&-symbol? symbol)))
+                                  (flatten arguments))))
+           ,@declarations
+           ,whole)
+         (defmethod let+-expansion-for-list ((first (eql ',name))
+                                             ,arguments-var ,value-var
+                                             ,body-var)
+           ,(if uses-value?
+                `(assert ,value-var () "Missing value form in ~A." ',name)
+                `(assert (not ,value-var) ()
+                         "~A forms don't take a value." ',name))
+           ,(let ((core `(destructuring-bind ,arguments ,arguments-var
+                           ,@declarations
+                           ,@remaining-forms)))
+              (if once-only? ; basically once-only, with ignorable value
+                  (with-unique-names (value-once-var)
+                    `(let ((,value-once-var (gensym "VALUE")))
+                       `(let ((,,value-once-var ,,value-var))
+                          (declare (ignorable ,,value-once-var))
+                          ,(let ((,value-var ,value-once-var))
+                             ,core))))
+                  core)))))))
+
+;;; Definitions for particular LET+ forms.
+;;;
+;;; When both read only and read/write forms make sense, the former should
+;;; have the suffix -r/o and the latter should be without the suffix in order
+;;; to maintain a consistent naming scheme.
+
+;;; helper functions
+
+(defun expand-slot-forms (slots accessor-generator)
+  "Return a list of expanded bindings, calling (ACCESSOR-GENERATOR KEY)"
+  (let (bindings)
+    (loop for entry :in slots do
+      (destructuring-bind (variable &optional (key variable))
+          (ensure-list entry)
+        (when variable
+          (push `(,variable ,(funcall accessor-generator key)) bindings))))
+    (nreverse bindings)))
+
+
+(defun expand-entry-forms (entries accessor-generator)
+  "Return a list of expanded bindings from ENTRIES, calling (ACESSOR-GENERATOR KEY DEFAULT).  Each entry is (VARIABLE &OPTIONAL KEY DEFAULT).  When KEY is NIL, VARIABLE is used."
+  (mapcar (lambda (entry)
+            (destructuring-bind (variable &optional key default)
+                (ensure-list entry)
+              `(,variable ,(funcall accessor-generator
+                                    (typecase key
+                                      (null `',variable)
+                                      (symbol `',key)
+                                      (t key))
+                                    default))))
+          entries))
+
+(defun expand-array-elements (value array-elements &optional (accessor 'aref))
+  "Expand a list of (BINDING &REST SUBSCRIPTS) forms to a list of bindings of the form (ACCESSOR VALUE SUBSCRIPTS)."
+  (mapcar (lambda (array-element)
+            `(,(first array-element)
+               (,accessor ,value ,@(rest array-element))))
+          array-elements))
+
+(define-let+-expansion (&accessors accessors)
+  "LET+ form, similar to WITH-ACCESSORS."
+  `(symbol-macrolet ,(expand-slot-forms accessors (lambda (accessor)
+                                                    `(,accessor ,value)))
+     ,@body))
+
+(define-let+-expansion (&accessors-r/o accessors)
+  "LET+ form, similar to WITH-ACCESSORS, but read-only."
+  `(let+ ,(expand-slot-forms accessors (lambda (accessor)
+                                         `(,accessor ,value)))
+     ,@body))
+
+(define-let+-expansion (&slots slots :once-only? nil)
+  "LET+ form, similar to WITH-SLOTS."
+  `(with-slots ,slots ,value
+     ,@body))
+
+(define-let+-expansion (&slots-r/o slots)
+  "LET+ form, similar to WITH-SLOTS but read-only."
+  `(let+ ,(expand-slot-forms slots
+                             (lambda (slot) `(slot-value ,value ',slot)))
+     ,@body))
+
+(define-let+-expansion (&structure (conc-name &rest slots))
+  "LET+ form for slots of a structure, with accessors generated using CONC-NAME."
+  (check-type conc-name symbol)
+  `(symbol-macrolet
+       ,(expand-slot-forms slots
+                           (lambda (slot) `(,(symbolicate conc-name slot)
+                                            ,value)))
+     ,@body))
+
+(define-let+-expansion (&structure-r/o (conc-name &rest slots))
+  "LET+ form for slots of a structure, with accessors generated using CONC-NAME.  Read-only version."
+  (check-type conc-name symbol)
+  `(let+ ,(expand-slot-forms slots
+                             (lambda (slot)
+                               `(,(symbolicate conc-name slot) ,value)))
+     ,@body))
+
+(define-let+-expansion (&values values :once-only? nil)
+  "LET+ form for multiple values."
+  (let ((values-and-temps (mapcar (lambda (v) (list v (gensym))) values)))
+    `(multiple-value-bind ,(mapcar #'second values-and-temps) ,value
+       (declare (ignore ,@(loop for (v g) in values-and-temps
+                                when (ignored? v)
+                                  collect g)))
+       (let+ ,(remove-if (compose #'ignored? #'car) values-and-temps)
+         ,@body))))
+
+(defmethod let+-expansion ((array array) value body)
+  "LET+ expansion for mapping array elements to variables."
+  (let (bindings
+        (value-var (gensym "VALUE")))
+    (dotimes (row-major-index (array-total-size array))
+      (let ((variable (row-major-aref array row-major-index)))
+        (unless (ignored? variable)
+          (push `(,variable
+                  (row-major-aref ,value-var ,row-major-index))
+                bindings))))
+    `(let ((,value-var ,value))
+       (assert (equal (array-dimensions ,value-var)
+                      ',(array-dimensions array)))
+       (let+ ,(nreverse bindings)
+         ,@body))))
+
+
+
+(define-let+-expansion (&array-elements array-elements)
+  "LET+ form, mapping (variable &rest subscripts) specifications to array-elements.  VARIABLE is an accessor, which can be used for reading and writing array elements."
+  `(symbol-macrolet ,(expand-array-elements value array-elements)
+     ,@body))
+
+(define-let+-expansion (&array-elements-r/o array-elements)
+  "LET+ form, mapping (variable &rest subscripts) specifications to array-elements.  Read-only accessor, values assigned to VARIABLEs."
+  (once-only (value)
+    `(let+ ,(expand-array-elements value array-elements)
+       ,@body)))
+
+(define-let+-expansion (&flet (function-name lambda-list
+                                             &body function-body)
+                           :uses-value? nil)
+  "LET+ form for function definitions.  Expands into an FLET."
+  `(flet ((,function-name ,lambda-list ,@function-body))
+     ,@body))
+
+(defmacro mergable-labels (bindings &body body)
+  `(labels ,bindings ,@body))
+
+(define-let+-expansion (&labels (function-name lambda-list
+                                               &body function-body)
+                                :uses-value? nil)
+  "LET+ form for function definitions.  Expands into an LABELS, thus allowing recursive functions."
+  (if (typep (first body) '(cons (eql mergable-labels)))
+      (destructuring-bind (bindings &rest first-body) (rest (first body))
+        (assert (null (rest body)))
+        `(mergable-labels ((,function-name ,lambda-list ,@function-body)
+                           ,@bindings)
+           ,@first-body
+           ,@(rest body)))
+      `(mergable-labels ((,function-name ,lambda-list ,@function-body))
+         ,@body)))
+
+(define-let+-expansion (&macrolet (macro-name lambda-list  &body macro-body)
+                           :uses-value? nil)
+  "LET+ form for local macro definitions.  Expands into an MACROLET."
+  `(macrolet ((,macro-name ,lambda-list ,@macro-body))
+     ,@body))
+
+(define-let+-expansion (&symbol-macrolet (symbol expansion) :uses-value? nil)
+  "LET+ form for local symbol macros.  Expands into a SYMBOL-MACROLET."
+  `(symbol-macrolet ((,symbol ,expansion))
+     ,@body))
+
+(define-let+-expansion (&plist entries)
+  "LET+ form for property lists.  Each entry is (variable &optional key default)."
+  `(symbol-macrolet
+       ,(expand-entry-forms entries
+                            (lambda (key default)
+                              `(getf ,value ,key ,default)))
+     ,@body))
+
+(define-let+-expansion (&plist-r/o entries)
+  "LET+ form for property lists, read only version.  Each entry is (variable &optional key default)."
+  `(let* ,(expand-entry-forms entries
+                              (lambda (key default)
+                                `(getf ,value ,key ,default)))
+     ,@body))
+
+(define-let+-expansion (&hash-table entries)
+  "LET+ form for hash tables.  Each entry is (variable &optional key default)."
+  `(symbol-macrolet
+       ,(expand-entry-forms entries
+                            (lambda (key default)
+                              `(gethash ,key ,value ,default)))
+     ,@body))
+
+(define-let+-expansion (&hash-table-r/o entries)
+  "LET+ form for hash tables.  Each entry is (variable &optional key default).  Read only version."
+  `(let+ ,(expand-entry-forms entries
+                              (lambda (key default) `(gethash ,key ,value ,default)))
+     ,@body))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/package.lisp b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/package.lisp
new file mode 100644
index 0000000..ef06bed
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/package.lisp
@@ -0,0 +1,37 @@
+;;;; package.lisp
+
+(defpackage #:let-plus
+  (:use #:cl #:alexandria #:anaphora)
+  (:export ; basic user interface
+   #:let+
+   #:&ign
+   #:&accessors
+   #:&accessors-r/o
+   #:&slots
+   #:&slots-r/o
+   #:&structure
+   #:&structure-r/o
+   #:&values
+   #:&array-elements
+   #:&array-elements-r/o
+   #:&flet #:&labels
+   #:&macrolet
+   #:&symbol-macrolet
+   #:&plist
+   #:&plist-r/o
+   #:&hash-table
+   #:&hash-table-r/o)
+  (:export ; defining new forms
+   #:let+-expansion
+   #:let+-expansion-for-list
+   #:define-let+-expansion)
+  (:export ; extensions
+   #:&flet+
+   #:&labels+
+   #:lambda+
+   #:defun+
+   #:define-structure-let+
+   #:&fwrap
+   #:&once-only
+   #:&with-gensyms
+   #:&complex))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/tests.lisp b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/tests.lisp
new file mode 100644
index 0000000..65f6005
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/let-plus-20191130-git/tests.lisp
@@ -0,0 +1,290 @@
+;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; Coding:utf-8 -*-
+
+(defpackage #:let-plus-tests
+  (:use #:cl #:alexandria #:lift #:let-plus)
+  (:export #:run))
+
+(in-package #:let-plus-tests)
+
+(deftestsuite let-plus-tests () ())
+
+(defun run ()
+  "Run all the tests for LET-PLUS."
+  (run-tests :suite 'let-plus-tests))
+
+(defmacro test-r/o-and-r/w (init-form bindings r/o-form r/w-form
+                            &key (add 7)
+                            (modified-variable (caar bindings)))
+  "Macro for autogenerating tests for testing read-only and read-write access.
+INIT-FORM is evaluated and bound to a value, which is then bound using LET+
+with r/o-form (for read only access) and r/w-form for (read and write access).
+Values are compared to bindings (which are of the form (VARIABLE VALUE), where
+value should be numeric.  MODIFIED-VARIABLE is modified, by adding ADD and
+checked for consistency (r/o form should not modify value, while r/w form
+should)."
+  (with-unique-names (object)
+    (once-only (add)
+      `(let ((,object ,init-form))
+         (let+ ((,r/o-form ,object))
+           ,@(loop for (var value) in bindings
+                   collect `(ensure-same ,var ,value))
+           (incf ,modified-variable ,add))
+         (let+ ((,r/w-form ,object))
+           ,@(loop for (var value) in bindings
+                   collect `(ensure-same ,var ,value))
+           (incf ,modified-variable ,add))
+         (let+ ((,r/o-form ,object))
+           (ensure-same ,(caar bindings) (+ ,add ,(cadar bindings))))))))
+
+(addtest (let-plus-tests)
+  test-let*-compatibility
+  (let+ (a
+         (b 1)
+         (c (+ b 3)))
+    (ensure-same a nil)
+    (ensure-same b 1)
+    (ensure-same c 4)))
+
+(addtest (let-plus-tests)
+  test-unrecognized-form
+  (ensure-warning (macroexpand '(let+ (((&does-not-exist a b) '(1 2 3)))))))
+
+(defclass foo ()
+  ((bar :accessor bar :initarg :bar)
+   (baz :accessor baz-acc :initarg :baz))
+  (:documentation "Class for testing purposes."))
+
+(addtest (let-plus-tests)
+  test-slots
+  (test-r/o-and-r/w (make-instance 'foo :bar 1 :baz 2)
+                    ((bar 1) (baz2 2))
+                    (&slots-r/o bar (baz2 baz))
+                    (&slots bar (baz2 baz))))
+
+(addtest (let-plus-tests)
+  test-accessors
+  (test-r/o-and-r/w (make-instance 'foo :bar 1 :baz 2)
+                    ((bar 1) (baz 2))
+                    (&accessors-r/o bar (baz baz-acc))
+                    (&accessors bar (baz baz-acc))))
+
+(defstruct foo2
+  "Structure for testing purposes."
+  bar baz)
+
+(addtest (let-plus-tests)
+  test-structure
+  (test-r/o-and-r/w (make-foo2 :bar 1 :baz 2)
+                    ((bar 1) (baz 2))
+                    (&structure-r/o foo2- bar (baz baz))
+                    (&structure foo2- bar (baz baz))))
+
+(addtest (let-plus-tests)
+  test-values
+  (let+ (((&values a &ign c) (values 1 2 3)))
+    (ensure-same a 1)
+    (ensure-same c 3)))
+
+(addtest (let-plus-tests)
+  test-values-recursive
+  (let+ (((&values (a b) &ign c) (values '(1 4) 2 3)))
+    (ensure-same a 1)
+    (ensure-same b 4)
+    (ensure-same c 3)))
+
+(declaim (notinline two-element-vector))
+(defun two-element-vector ()
+  #(1 2))
+
+(addtest (let-plus-tests)
+  test-array
+  (let+ ((#2A((a &ign) (b c)) #2A((1 2) (3 4))))
+    (ensure-same a 1)
+    (ensure-same b 3)
+    (ensure-same c 4))
+  (ensure-error (let+ ((#(a b c) (two-element-vector))))))
+
+(addtest (let-plus-tests)
+  test-array-elements
+  (test-r/o-and-r/w (make-array '(2 2) :initial-contents '((1 2) (3 4)))
+                    ((a 1) (b 3) (c 4))
+                    (&array-elements-r/o (a 0 0)
+                                         (b 1 0)
+                                         (c 1 1))
+                    (&array-elements (a 0 0)
+                                     (b 1 0)
+                                     (c 1 1))))
+
+(addtest (let-plus-tests)
+  test-flet
+  (let+ (((&flet add1 (x)
+            (1+ x)) ))
+    (ensure-same (add1 2) 3)))
+
+(addtest (let-plus-tests)
+  test-labels
+  (let+ (((&labels my-factorial (x)
+            (if (<= 2 x)
+                (* x (my-factorial (1- x)))
+                1))))
+    (ensure-same (my-factorial 4) 24)))
+
+(addtest (let-plus-tests)
+  test-labels/mutual-recursion
+  (let+ (((&labels my-even? (x)
+            (cond
+              ((zerop x)
+               t)
+              ((plusp x)
+               (my-odd? (1- x)))
+              (t
+               nil))))
+         ((&labels my-odd? (x)
+            (my-even? (1- x)))))
+    (ensure-same (my-odd?  4) nil)
+    (ensure-same (my-even? 4) t)
+    (ensure-same (my-odd?  5) t)
+    (ensure-same (my-even? 5) nil)))
+
+(defun labels-test-function ()
+  10)
+
+(addtest (let-plus-tests)
+  test-labels/dont-splice
+  (ensure-same (let+ (((&labels foo () (labels-test-function))))
+                 (labels ((labels-test-function () 5))
+                   (labels-test-function))
+                 (foo))
+               10)
+  (ensure-same (let+ (((&labels foo () (labels-test-function))))
+                 (labels ((labels-test-function () 5))
+                   (values (foo) (labels-test-function))))
+               (values 10 5))
+  (ensure-same (let+ (((&labels foo () (labels-test-function))))
+                 (let+ (((&labels labels-test-function () 5)))
+                   (values (foo) (labels-test-function))))
+               (values 10 5)))
+
+(addtest (let-plus-tests)
+  test-plist
+  (test-r/o-and-r/w (list 'a 1 :b 2 'c '3)
+                    ((a 1) (b 2) (c 3) (d 4))
+                    (&plist-r/o a (b :b) (c nil) (d nil 4))
+                    (&plist a (b :b) (c nil) (d nil 4))))
+
+(addtest (let-plus-tests)
+  test-hash-table
+  (test-r/o-and-r/w (let ((table (make-hash-table)))
+                      (setf (gethash 'a table) 1
+                            (gethash :b table) 2
+                            (gethash 'c table) 3)
+                      table)
+                    ((a 1) (b 2) (c 3) (d 4))
+                    (&hash-table-r/o a (b :b) (c nil) (d nil 4))
+                    (&hash-table a (b :b) (c nil) (d nil 4))))
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (defstruct ab
+      "A structure for testing defstruct+."
+    a b)
+  (define-structure-let+ (ab) a b))
+
+(addtest (let-plus-tests)
+  test-defstruct+
+  (test-r/o-and-r/w (make-ab :a 3 :b 7)
+                    ((aa 3) (bb 7))
+                    (&ab-r/o aa bb)
+                    (&ab aa bb)))
+
+(addtest (let-plus-tests)
+  test-fwrap
+  (let+ (((&fwrap add) (lambda (a b &key (c 0)) (+ a b c))))
+    (ensure-same (add 1 2) 3)
+    (ensure-same (add 1 2 :c 3) 6)))
+
+(addtest (let-plus-tests)
+  test-flet+
+  (ensure-same (let+ (((&flet+ add3 (#(a b c))
+                         (+ a b c))))
+                 (add3 #(1 2 3)))
+               6))
+
+(addtest (let-plus-tests)
+  test-labels+
+  (let+ (((&labels+ foo ((a . b))
+            (if a
+                (foo (cons (cdr a) (cons (car a) b)))
+                b))))
+    (ensure-same (foo '((1 2 3) . nil)) '(3 2 1)))
+
+  (ensure-no-warning
+    (compile nil '(lambda (x)
+                    (let+ (((&labels+ foo (&ign)))) (foo x))))))
+
+(addtest (let-plus-tests)
+  test-defun+
+  (defun+ foo ((a . b))
+    "bar"
+    (+ a b))
+  (ensure-same (foo '(1 . 2)) 3)
+  (ensure-same (documentation 'foo 'function) "bar" :test #'string=)
+  (let ((expansion (macroexpand-1
+                    '(defun+ foo ((a . b))
+                      "foo docstring"
+                      (declare (type integer a b))
+                      (+ a b)))))
+    (ensure-same 'defun (first expansion))
+    (ensure-same 'foo (second expansion))
+    (ensure-same "foo docstring" (fourth expansion))
+    (let ((let+-expansion (fifth expansion)))
+      (ensure-same 'let+ (first let+-expansion))
+      (ensure-same '(declare (type integer a b)) (third let+-expansion))
+      (ensure-same '(+ a b) (fourth let+-expansion)))))
+
+(addtest (let-plus-tests)
+  test-&warning
+  (ensure-warning
+    (macroexpand '(let+ ((&foo 1)) &foo)))
+  (ensure-warning
+    (macroexpand '(let+ ((&foo)) &foo)))
+  (ensure-warning
+    (macroexpand '(let+ (&foo) &foo))))
+
+(addtest (let-plus-tests)
+  test-empty-let+
+  (ensure-same (let+ nil 1) 1 :test #'eql))
+
+(addtest (let-plus-tests)
+  test-recursive-let+
+  (ensure-same (let+ ((#((a . b)) (vector (cons 1 2))))
+                 (values a b))
+               (values 1 2))
+  ;; (ensure-same (let+ (((#(a) #(b c)) (cons #(1) #(2 3))))
+  ;;                (values a b c))
+  ;;              (values 1 2 3))
+  )
+
+(addtest (let-plus-tests)
+  test-complex
+  (let ((c #C(3 5)))
+    (let+ (((&complex x y) c))
+      (ensure-same x 3)
+      (ensure-same y 5))))
+
+(addtest (let-plus-tests)
+  test-nil
+  (ensure (let+ ((() '())) t))
+  (ensure-error (let+ ((() '(1)))))
+  ;; (ensure-error (let+ ((() 1))))
+)
+
+(addtest (let-plus-tests)
+  test-empty-let+-with-declaration
+  (ensure-same (let+ ()
+                 (declare (optimize speed))
+                 t)
+               t)
+  (ensure-same (let+ ((&ign 1))
+                 (declare (optimize speed))
+                 t)
+               t))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/.gitignore b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/.gitignore
new file mode 100644
index 0000000..0cd96de
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/.gitignore
@@ -0,0 +1,22 @@
+*.*fas*
+*.fasl
+*.dfsl
+*.ppcf
+*.x86f
+*.fas
+*.lib
+doc/manual/
+doc/*.vr
+doc/*.tp
+doc/*.tps
+doc/*.toc
+doc/*.pg
+doc/*.log
+doc/*.ky
+doc/*.it
+doc/*.info
+doc/*.fn
+doc/*.fns
+doc/*.cp
+doc/*.cps
+doc/*.aux
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/COPYING b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/COPYING
new file mode 100644
index 0000000..63a1be3
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/COPYING
@@ -0,0 +1,20 @@
+local-time Copyright (c) 2005-2012 by Daniel Lowe
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/CREDITS b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/CREDITS
new file mode 100644
index 0000000..99575f8
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/CREDITS
@@ -0,0 +1,17 @@
+Thanks to those of you who have helped me make LOCAL-TIME an engaging
+and worthwhile project!
+
+    * Matthew Danish <mdanish@andrew.cmu.edu>
+    * The #lisp crew on irc.freenode.net
+    * Vladimir Sekissov <svg@surnet.ru>
+    * Attila Lendvai <attila.lendvai@gmail.com>
+    * Tomi Borbely <tomi.borbely@gmail.com>
+    * Denys Rtveliashvili <rtvd@mail.ru>
+    * Levente Meszaros <levente.meszaros@gmail.com>
+    * Arjan Wekking <arjan@streamtech.nl>
+
+------------------------------------------------------------------------
+Apologies to anyone I didn't mention (please let me know).
+
+Daniel Lowe
+<dlowe@dlowe.net>
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/INSTALL b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/INSTALL
new file mode 100644
index 0000000..2363580
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/INSTALL
@@ -0,0 +1,40 @@
+# Installation
+
+## Using Quicklisp
+
+1. Install quicklisp
+2. Use quicklisp to install local-time
+
+      (ql:quickload :local-time)
+
+## Manual Installation
+
+1. Make sure the ASDF library is loaded.  In SBCL, this involves:
+
+      (require :asdf)
+
+2. Add the path to the directory containing local-time.asd to
+   asdf:*central-registry*.  If you've installed this package using
+   asdf-install, this shouldn't be necessary.
+
+      (push "/my/local-time/directory/" asdf:*central-registry*)
+
+3. Load local-time using ASDF:
+
+      (asdf:oos 'asdf:load-op 'local-time)
+
+4. In your own projects, you can direct asdf to automatically load
+   LOCAL-TIME with the :depends-on asdf:defsystem directive.
+
+      (defsystem myproject
+          :depends-on (local-time)
+          ...)
+
+## Testing
+
+local-time uses Stefil for testing. To run the Stefil test suite, do
+the following:-
+
+    (ql:quickload :local-time.test)
+    (in-suite test)
+    (test)
\ No newline at end of file
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/README b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/README
new file mode 100644
index 0000000..c5e6c4b
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/README
@@ -0,0 +1,18 @@
+							  LOCAL-TIME
+
+See the "COPYING" file for information about legal issues of copying
+and using this library.
+
+See the "INSTALL" file for information about building and installing
+this library.
+
+The LOCAL-TIME library is a Common Lisp library for the manipulation
+of dates and times.  It is based almost entirely upon Erik Naggum's
+paper "The Long Painful History of Time".
+
+Related projects of interest:
+ * https://github.com/enaeher/local-time-duration
+ * http://common-lisp.net/projects/cl-l10n/
+
+See the manual/ directory for more information and/or the website at
+http://common-lisp.net/project/local-time/
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/TODO b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/TODO
new file mode 100644
index 0000000..e5b0f42
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/TODO
@@ -0,0 +1,104 @@
+-*- mode: org; coding: utf-8-unix -*-
+
+* Basic Outline
+** A more human friendly parser
+
+   PARSE-TIMESTRING works fine, but we need a more human-friendly parser that
+   can handle stuff like "08/03/2006 1:54pm CST". or maybe not? see
+   http://chaitanyagupta.com/lisp/chronicity/
+
+** Support for other notational systems than the Gregorian
+
+** Ideally, local-time should have everything that the ruby Date class does
+
+  Also, the time functions in the venerable and honored clsql library.
+  This may be a tall order.
+
+** Integrate local-time with http://common-lisp.net/project/cl-l10n/
+   Also drop time/timezone related functionality from cl-l10n.
+
+** Make local-time work with olson timezone rules
+  http://www.twinsun.com/tz/tz-link.htm
+  Right now, we're using zic compiled files, which have a limited
+  scope.  They may also be larger than the corresponding rule files.
+
+* Attila:
+Many of the operations currently defined on timestamps should not
+really be defined on timestamps at all. i think this is due to some
+heritage from the times when a timestamp value also had a timezone
+value attached to it.
+
+Examples of such bogus operations are timestamp+, timestamp-, all
+adjust-timestamp variants that operate on the components of a date
+value, etc.
+
+* Nomenclature
+** timestamp: a sharp cut on the continuous t axis (as in physics) of time
+   It is mostly unrelated to timezones and different calendar systems
+   (e.g. Julian, Gregorian), which are just ways to denote a timestamp in
+   a way humans can easily deal with.
+
+** interval: a range on the time axis denoted by two timestamps
+
+** date-time: contains the fields defined by the calendar system
+   Some date-time fields may be left undefined.
+
+** calendar: a converter to and from a particular date-time type
+   A method defining how to denote a timestamp using a set of numbers
+   (called year, month, day, etc). there are various such encodings
+   like the Gregorian calendar, or the Julian calendar (which was in
+   effect in Russia until 1922!). wikipedia has loads of info about
+   these.  We'll default to a naive Gregorian calendar
+
+** duration: a value representing a delta between date-times
+
+
+* Timestamp Operations
+** basic arithmetic
+   essentially arithmetic on numbers denoting seconds. operations that
+   would expose the epoch chosen by the implementation are not allowed
+   (e.g. adding two timestamps), but things like adding/subbing
+   literals and substracting two timestamps are valid.
+
+** convert to/from date
+   (only in the mandatory context of a calendar system, which most of
+   the time includes a timezone, too.)
+
+** create an interval given two timestamps
+
+** comparison predicates
+
+* Interval Operations
+  There's a project implementing intervals at:
+  https://github.com/enaeher/local-time-duration
+
+** Arithmetic with timestamps
+** Arithmetic with intervals
+** convert to a duration with a calendar
+** Intersection with a timestamp
+** Overlap with another intervals
+
+* Date-time operations
+** parse from string representation
+   , e.g. an rfc3339 string. note that such a date-time does not
+   necessarily describe a timestamp completely. it only does so when
+   it contains all the components needed by the calendar system to
+   denote a sharp cut on the t axis.
+
+** set/offset any component of it,
+   although what those operations mean potentially depend on the
+   calendar system and its parameters (e.g. the optional timezone
+   value in it). also note that some operations are potentially
+   undefined and signal an error with certain illegal values
+   (e.g. instantiating a date using an illegal or contradictory
+   combination of its parameters; setting a field to an illegal value
+   like february 29 in leap years...)
+
+** convert to/from a timestamp
+   (strictly in the context of a calendar system and a timezone)
+
+** comparison functions
+
+* Duration operations
+** Arithmetic with date-times
+** Arithmetic with durations
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/cl-postgres+local-time.asd b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/cl-postgres+local-time.asd
new file mode 100644
index 0000000..80b1913
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/cl-postgres+local-time.asd
@@ -0,0 +1,9 @@
+(defsystem #:cl-postgres+local-time
+  :name "cl-postgres+local-time"
+  :version "1.0.6"
+  :author "Daniel Lowe <dlowe@dlowe.net>"
+  :description "Integration between cl-postgres and local-time"
+  :depends-on (:cl-postgres :local-time)
+  :components ((:module "src"
+                :components ((:module "integration"
+                              :components ((:file "cl-postgres")))))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/Makefile b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/Makefile
new file mode 100644
index 0000000..72cf5e9
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/Makefile
@@ -0,0 +1,16 @@
+# -*- Mode: Makefile; tab-width: 4; indent-tabs-mode: t -*-
+
+all: docs
+
+docs:
+	sh gendocs.sh -o manual --html "--css-include=style.css" local-time "The local-time Manual"
+
+clean:
+	find . \( -name "*.info" -o -name "*.it" -o -name "*.aux" -o -name "*.cp" -o -name "*.fn" -o -name "*.fns" -o -name "*.ky" -o -name "*.log" -o -name "*.pg" -o -name "*.toc" -o -name "*.tp" -o -name "*.vr" -o -name "*.dvi" -o -name "*.cps" -o -name "*.vrs" \) -exec rm {} \;
+	rm -rf manual
+
+upload-docs:
+	rsync -av --delete -e ssh manual common-lisp.net:/project/local-time/public_html/
+#	scp -r manual spec common-lisp.net:/project/local-time/public_html/
+
+# vim: ft=make ts=4 noet
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/gendocs.sh b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/gendocs.sh
new file mode 100644
index 0000000..d27da69
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/gendocs.sh
@@ -0,0 +1,285 @@
+#!/bin/sh
+# gendocs.sh -- generate a GNU manual in many formats.  This script is
+#   mentioned in maintain.texi.  See the help message below for usage details.
+# $Id: gendocs.sh,v 1.17 2006/05/19 00:07:52 karl Exp $
+# 
+# Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, you can either send email to this
+# program's maintainer or write to: The Free Software Foundation,
+# Inc.; 51 Franklin Street, Fifth Floor; Boston, MA 02110-1301, USA.
+#
+# Original author: Mohit Agarwal.
+# Send bug reports and any other correspondence to bug-texinfo@gnu.org.
+
+prog=`basename "$0"`
+srcdir=`pwd`
+
+scripturl="http://savannah.gnu.org/cgi-bin/viewcvs/~checkout~/texinfo/texinfo/util/gendocs.sh"
+templateurl="http://savannah.gnu.org/cgi-bin/viewcvs/~checkout~/texinfo/texinfo/util/gendocs_template"
+
+: ${MAKEINFO="makeinfo"}
+: ${TEXI2DVI="texi2dvi -t @finalout"}
+: ${DVIPS="dvips"}
+: ${DOCBOOK2TXT="docbook2txt"}
+: ${DOCBOOK2HTML="docbook2html"}
+: ${DOCBOOK2PDF="docbook2pdf"}
+: ${DOCBOOK2PS="docbook2ps"}
+: ${GENDOCS_TEMPLATE_DIR="."}
+unset CDPATH
+
+rcs_revision='$Revision: 1.17 $'
+rcs_version=`set - $rcs_revision; echo $2`
+program=`echo "$0" | sed -e 's!.*/!!'`
+version="gendocs.sh $rcs_version
+
+Copyright (C) 2006 Free Software Foundation, Inc.
+There is NO warranty.  You may redistribute this software
+under the terms of the GNU General Public License.
+For more information about these matters, see the files named COPYING."
+
+usage="Usage: $prog [OPTION]... PACKAGE MANUAL-TITLE
+
+Generate various output formats from PACKAGE.texinfo (or .texi or .txi) source.
+See the GNU Maintainers document for a more extensive discussion:
+  http://www.gnu.org/prep/maintain_toc.html
+
+Options:
+  -o OUTDIR   write files into OUTDIR, instead of manual/.
+  --docbook   convert to DocBook too (xml, txt, html, pdf and ps).
+  --html ARG  pass indicated ARG to makeinfo for HTML targets.
+  --help      display this help and exit successfully.
+  --version   display version information and exit successfully.
+
+Simple example: $prog emacs \"GNU Emacs Manual\"
+
+Typical sequence:
+  cd YOURPACKAGESOURCE/doc
+  wget \"$scripturl\"
+  wget \"$templateurl\"
+  $prog YOURMANUAL \"GNU YOURMANUAL - One-line description\"
+
+Output will be in a new subdirectory \"manual\" (by default, use -o OUTDIR
+to override).  Move all the new files into your web CVS tree, as
+explained in the Web Pages node of maintain.texi.
+
+MANUAL-TITLE is included as part of the HTML <title> of the overall
+manual/index.html file.  It should include the name of the package being
+documented.  manual/index.html is created by substitution from the file
+$GENDOCS_TEMPLATE_DIR/gendocs_template.  (Feel free to modify the
+generic template for your own purposes.)
+
+If you have several manuals, you'll need to run this script several
+times with different YOURMANUAL values, specifying a different output
+directory with -o each time.  Then write (by hand) an overall index.html
+with links to them all.
+
+You can set the environment variables MAKEINFO, TEXI2DVI, and DVIPS to
+control the programs that get executed, and GENDOCS_TEMPLATE_DIR to
+control where the gendocs_template file is looked for.
+
+Email bug reports or enhancement requests to bug-texinfo@gnu.org.
+"
+
+calcsize()
+{
+  size=`ls -ksl $1 | awk '{print $1}'`
+  echo $size
+}
+
+outdir=manual
+html=
+PACKAGE=
+MANUAL_TITLE=
+
+while test $# -gt 0; do
+  case $1 in
+    --help) echo "$usage"; exit 0;;
+    --version) echo "$version"; exit 0;;
+    -o) shift; outdir=$1;;
+    --docbook) docbook=yes;;
+    --html) shift; html=$1;;
+    -*)
+      echo "$0: Unknown or ambiguous option \`$1'." >&2
+      echo "$0: Try \`--help' for more information." >&2
+      exit 1;;
+    *)
+      if test -z "$PACKAGE"; then
+        PACKAGE=$1
+      elif test -z "$MANUAL_TITLE"; then
+        MANUAL_TITLE=$1
+      else
+        echo "$0: extra non-option argument \`$1'." >&2
+        exit 1
+      fi;;
+  esac
+  shift
+done
+
+if test -s "$srcdir/$PACKAGE.texinfo"; then
+  srcfile=$srcdir/$PACKAGE.texinfo
+elif test -s "$srcdir/$PACKAGE.texi"; then
+  srcfile=$srcdir/$PACKAGE.texi
+elif test -s "$srcdir/$PACKAGE.txi"; then
+  srcfile=$srcdir/$PACKAGE.txi
+else
+  echo "$0: cannot find .texinfo or .texi or .txi for $PACKAGE in $srcdir." >&2
+  exit 1
+fi
+
+if test ! -r $GENDOCS_TEMPLATE_DIR/gendocs_template; then
+  echo "$0: cannot read $GENDOCS_TEMPLATE_DIR/gendocs_template." >&2
+  echo "$0: it is available from $templateurl." >&2
+  exit 1
+fi
+
+echo Generating output formats for $srcfile
+
+cmd="${MAKEINFO} -o $PACKAGE.info \"$srcfile\""
+echo "Generating info files... ($cmd)"
+eval "$cmd"
+mkdir -p $outdir/
+tar czf $outdir/$PACKAGE.info.tar.gz $PACKAGE.info*
+info_tgz_size=`calcsize $outdir/$PACKAGE.info.tar.gz`
+# do not mv the info files, there's no point in having them available
+# separately on the web.
+
+cmd="${TEXI2DVI} \"$srcfile\""
+echo "Generating dvi ... ($cmd)"
+eval "$cmd"
+
+# now, before we compress dvi:
+echo Generating postscript...
+${DVIPS} $PACKAGE -o
+gzip -f -9 $PACKAGE.ps
+ps_gz_size=`calcsize $PACKAGE.ps.gz`
+mv $PACKAGE.ps.gz $outdir/
+
+# compress/finish dvi:
+gzip -f -9 $PACKAGE.dvi
+dvi_gz_size=`calcsize $PACKAGE.dvi.gz`
+mv $PACKAGE.dvi.gz $outdir/
+
+cmd="${TEXI2DVI} --pdf \"$srcfile\""
+echo "Generating pdf ... ($cmd)"
+eval "$cmd"
+pdf_size=`calcsize $PACKAGE.pdf`
+mv $PACKAGE.pdf $outdir/
+
+cmd="${MAKEINFO} -o $PACKAGE.txt --no-split --no-headers \"$srcfile\""
+echo "Generating ASCII... ($cmd)"
+eval "$cmd"
+ascii_size=`calcsize $PACKAGE.txt`
+gzip -f -9 -c $PACKAGE.txt >$outdir/$PACKAGE.txt.gz
+ascii_gz_size=`calcsize $outdir/$PACKAGE.txt.gz`
+mv $PACKAGE.txt $outdir/
+
+cmd="${MAKEINFO} --no-split --html -o $PACKAGE.html $html \"$srcfile\""
+echo "Generating monolithic html... ($cmd)"
+rm -rf $PACKAGE.html  # in case a directory is left over
+eval "$cmd"
+html_mono_size=`calcsize $PACKAGE.html`
+gzip -f -9 -c $PACKAGE.html >$outdir/$PACKAGE.html.gz
+html_mono_gz_size=`calcsize $outdir/$PACKAGE.html.gz`
+mv $PACKAGE.html $outdir/
+
+cmd="${MAKEINFO} --html -o $PACKAGE.html $html \"$srcfile\""
+echo "Generating html by node... ($cmd)"
+eval "$cmd"
+split_html_dir=$PACKAGE.html
+(
+  cd ${split_html_dir} || exit 1
+  tar -czf ../$outdir/${PACKAGE}.html_node.tar.gz -- *.html
+)
+html_node_tgz_size=`calcsize $outdir/${PACKAGE}.html_node.tar.gz`
+rm -f $outdir/html_node/*.html
+mkdir -p $outdir/html_node/
+mv ${split_html_dir}/*.html $outdir/html_node/
+rmdir ${split_html_dir}
+
+echo Making .tar.gz for sources...
+srcfiles=`ls *.texinfo *.texi *.txi *.eps 2>/dev/null`
+tar cvzfh $outdir/$PACKAGE.texi.tar.gz $srcfiles
+texi_tgz_size=`calcsize $outdir/$PACKAGE.texi.tar.gz`
+
+if test -n "$docbook"; then
+  cmd="${MAKEINFO} -o - --docbook \"$srcfile\" > ${srcdir}/$PACKAGE-db.xml"
+  echo "Generating docbook XML... $(cmd)"
+  eval "$cmd"
+  docbook_xml_size=`calcsize $PACKAGE-db.xml`
+  gzip -f -9 -c $PACKAGE-db.xml >$outdir/$PACKAGE-db.xml.gz
+  docbook_xml_gz_size=`calcsize $outdir/$PACKAGE-db.xml.gz`
+  mv $PACKAGE-db.xml $outdir/
+
+  cmd="${DOCBOOK2HTML} -o $split_html_db_dir ${outdir}/$PACKAGE-db.xml"
+  echo "Generating docbook HTML... ($cmd)"
+  eval "$cmd"
+  split_html_db_dir=html_node_db
+  (
+    cd ${split_html_db_dir} || exit 1
+    tar -czf ../$outdir/${PACKAGE}.html_node_db.tar.gz -- *.html
+  )
+  html_node_db_tgz_size=`calcsize $outdir/${PACKAGE}.html_node_db.tar.gz`
+  rm -f $outdir/html_node_db/*.html
+  mkdir -p $outdir/html_node_db
+  mv ${split_html_db_dir}/*.html $outdir/html_node_db/
+  rmdir ${split_html_db_dir}
+
+  cmd="${DOCBOOK2TXT} ${outdir}/$PACKAGE-db.xml"
+  echo "Generating docbook ASCII... ($cmd)"
+  eval "$cmd"
+  docbook_ascii_size=`calcsize $PACKAGE-db.txt`
+  mv $PACKAGE-db.txt $outdir/
+
+  cmd="${DOCBOOK2PS} ${outdir}/$PACKAGE-db.xml"
+  echo "Generating docbook PS... $(cmd)"
+  eval "$cmd"
+  gzip -f -9 -c $PACKAGE-db.ps >$outdir/$PACKAGE-db.ps.gz
+  docbook_ps_gz_size=`calcsize $outdir/$PACKAGE-db.ps.gz`
+  mv $PACKAGE-db.ps $outdir/
+
+  cmd="${DOCBOOK2PDF} ${outdir}/$PACKAGE-db.xml"
+  echo "Generating docbook PDF... ($cmd)"
+  eval "$cmd"
+  docbook_pdf_size=`calcsize $PACKAGE-db.pdf`
+  mv $PACKAGE-db.pdf $outdir/
+fi
+
+echo Writing index file...
+curdate=`date '+%B %d, %Y'`
+sed \
+   -e "s!%%TITLE%%!$MANUAL_TITLE!g" \
+   -e "s!%%DATE%%!$curdate!g" \
+   -e "s!%%PACKAGE%%!$PACKAGE!g" \
+   -e "s!%%HTML_MONO_SIZE%%!$html_mono_size!g" \
+   -e "s!%%HTML_MONO_GZ_SIZE%%!$html_mono_gz_size!g" \
+   -e "s!%%HTML_NODE_TGZ_SIZE%%!$html_node_tgz_size!g" \
+   -e "s!%%INFO_TGZ_SIZE%%!$info_tgz_size!g" \
+   -e "s!%%DVI_GZ_SIZE%%!$dvi_gz_size!g" \
+   -e "s!%%PDF_SIZE%%!$pdf_size!g" \
+   -e "s!%%PS_GZ_SIZE%%!$ps_gz_size!g" \
+   -e "s!%%ASCII_SIZE%%!$ascii_size!g" \
+   -e "s!%%ASCII_GZ_SIZE%%!$ascii_gz_size!g" \
+   -e "s!%%TEXI_TGZ_SIZE%%!$texi_tgz_size!g" \
+   -e "s!%%DOCBOOK_HTML_NODE_TGZ_SIZE%%!$html_node_db_tgz_size!g" \
+   -e "s!%%DOCBOOK_ASCII_SIZE%%!$docbook_ascii_size!g" \
+   -e "s!%%DOCBOOK_PS_GZ_SIZE%%!$docbook_ps_gz_size!g" \
+   -e "s!%%DOCBOOK_PDF_SIZE%%!$docbook_pdf_size!g" \
+   -e "s!%%DOCBOOK_XML_SIZE%%!$docbook_xml_size!g" \
+   -e "s!%%DOCBOOK_XML_GZ_SIZE%%!$docbook_xml_gz_size!g" \
+   -e "s,%%SCRIPTURL%%,$scripturl,g" \
+   -e "s!%%SCRIPTNAME%%!$prog!g" \
+$GENDOCS_TEMPLATE_DIR/gendocs_template >$outdir/index.html
+
+echo "Done!  See $outdir/ subdirectory for new files."
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/gendocs_template b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/gendocs_template
new file mode 100644
index 0000000..e08a2cc
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/gendocs_template
@@ -0,0 +1,260 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<!-- $Id: gendocs_template,v 1.7 2005/05/15 00:00:08 karl Exp $ -->
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+
+<!--
+
+ This template was adapted from Texinfo:
+ http://savannah.gnu.org/cgi-bin/viewcvs/texinfo/texinfo/util/gendocs_template
+
+-->
+
+
+<head>
+<title>%%TITLE%%</title>
+<meta http-equiv="content-type" content='text/html; charset=utf-8' />
+<!-- <link rel="stylesheet" type="text/css" href="/gnu.css" /> -->
+<!-- <link rev="made" href="webmasters@gnu.org" /> -->
+<style>
+/* CSS style taken from http://gnu.org/gnu.css */
+
+html, body {
+	background-color: #FFFFFF;
+	color: #000000;
+	font-family: sans-serif;
+}
+
+a:link {
+ 	color: #1f00ff;
+	background-color: transparent;
+	text-decoration: underline;
+ 	}
+
+a:visited {
+ 	color: #9900dd;
+	background-color: transparent;
+	text-decoration: underline;
+ 	}
+
+a:hover {
+ 	color: #9900dd;
+	background-color: transparent;
+	text-decoration: none;
+ 	}
+
+.center {
+	text-align: center;
+}
+
+.italic {
+ 	font-style: italic;
+ 	}
+
+.bold {
+        font-weight: bold;
+        }
+
+.quote {
+	margin-left: 40px;
+	margin-right: 40px;
+}
+
+.hrsmall {
+	width: 80px;
+	height: 1px;
+	margin-left: 20px;
+}
+
+.td_title {
+	border-color: #3366cc;
+	border-style: solid;
+	border-width: thin;
+	color: #3366cc;
+	background-color : #f2f2f9;
+	font-weight: bold;
+}
+
+.td_con {
+	padding-top: 3px;
+	padding-left: 8px;
+	padding-bottom: 3px;
+	color : #303030;
+	background-color : #fefefe;
+	font-size: smaller;
+}
+
+.translations {
+	background-color: transparent;
+	color: black;
+	font-family: serif;
+	font-size: smaller;
+}
+
+.fsflink {
+	font-size: smaller;
+	font-family: monospace;
+	color : #000000;
+	border-left: #3366cc thin solid;
+	border-bottom: #3366cc thin solid;
+	padding-left: 5px;
+	padding-bottom: 5px;
+}
+
+/*
+ * rtl stands for right-to-left layout, as in farsi/persian,
+ * arabic, etc. See also trans_rtl.
+ */
+.fsflink_rtl {
+	font-size: smaller;
+	font-family: monospace;
+	color : #000000;
+	border-right: #3366cc thin solid;
+	border-bottom: #3366cc thin solid;
+	padding-right: 5px;
+	padding-bottom: 5px;
+}
+
+.trans {
+	font-size: smaller;
+	color : #000000;
+	border-left: #3366cc thin solid;
+	padding-left: 20px;
+}
+
+.trans_rtl {
+	font-size: smaller;
+	color : #000000;
+	border-right: #3366cc thin solid;
+	padding-right: 20px;
+}
+
+img {
+	border: none 0;
+}
+
+td.side {
+	color: #3366cc;
+/*	background: #f2f2f9;
+	border-color: #3366cc;
+	border-style: solid;
+	border-width: thin; */
+	border-color: white;
+	border-style: none;
+	vertical-align: top;
+	width: 150px;
+}
+
+div.copyright {
+	font-size: 80%;
+	border: 2px solid #3366cc;
+	padding: 4px;
+	background: #f2f2f9;
+	border-style: solid;
+	border-width: thin;
+}
+
+.footnoteref {
+	font-size: smaller;
+	vertical-align: text-top;
+}
+</style>
+</head>
+
+<!-- This document is in XML, and xhtml 1.0 -->
+<!-- Please make sure to properly nest your tags -->
+<!-- and ensure that your final document validates -->
+<!-- consistent with W3C xhtml 1.0 and CSS standards -->
+<!-- See validator.w3.org -->
+
+<body>
+
+<h3>%%TITLE%%</h3>
+
+<!-- <address>Free Software Foundation</address> -->
+<address>last updated %%DATE%%</address>
+
+<!--
+<p>
+<a href="/graphics/gnu-head.jpg">
+	<img src="/graphics/gnu-head-sm.jpg"
+	alt=" [image of the head of a GNU] "
+	width="129" height="122" />
+</a>
+<a href="/philosophy/gif.html">(no gifs due to patent problems)</a>
+</p>
+-->
+
+<hr />
+
+<p>This document <!--(%%PACKAGE%%)--> is available in the following formats:</p>
+
+<ul>
+  <li><a href="%%PACKAGE%%.html">HTML
+      (%%HTML_MONO_SIZE%%K characters)</a> - entirely on one web page.</li>
+  <li><a href="html_node/index.html">HTML</a> - with one web page per
+      node.</li>
+  <li><a href="%%PACKAGE%%.html.gz">HTML compressed
+      (%%HTML_MONO_GZ_SIZE%%K gzipped characters)</a> - entirely on
+      one web page.</li>
+  <li><a href="%%PACKAGE%%.html_node.tar.gz">HTML compressed
+      (%%HTML_NODE_TGZ_SIZE%%K gzipped tar file)</a> -
+      with one web page per node.</li>
+  <li><a href="%%PACKAGE%%.info.tar.gz">Info document
+      (%%INFO_TGZ_SIZE%%K characters gzipped tar file)</a>.</li>
+  <li><a href="%%PACKAGE%%.txt">ASCII text
+      (%%ASCII_SIZE%%K characters)</a>.</li>
+  <li><a href="%%PACKAGE%%.txt.gz">ASCII text compressed
+      (%%ASCII_GZ_SIZE%%K gzipped characters)</a>.</li>
+  <li><a href="%%PACKAGE%%.dvi.gz">TeX dvi file
+      (%%DVI_GZ_SIZE%%K characters gzipped)</a>.</li>
+  <li><a href="%%PACKAGE%%.ps.gz">PostScript file
+      (%%PS_GZ_SIZE%%K characters gzipped)</a>.</li>
+  <li><a href="%%PACKAGE%%.pdf">PDF file
+      (%%PDF_SIZE%%K characters)</a>.</li>
+  <li><a href="%%PACKAGE%%.texi.tar.gz">Texinfo source
+      (%%TEXI_TGZ_SIZE%%K characters gzipped tar file)</a></li>
+</ul>
+
+<p>(This page was generated by the <a href="%%SCRIPTURL%%">%%SCRIPTNAME%%
+script</a>.)</p>
+
+<div class="copyright">
+<p>
+Return to <a href="/project/local-time/">local-time's home page</a>.
+</p>
+
+<!--
+<p>
+Please send FSF &amp; GNU inquiries to
+<a href="mailto:gnu@gnu.org"><em>gnu@gnu.org</em></a>.
+There are also <a href="/home.html#ContactInfo">other ways to contact</a>
+the FSF.
+<br />
+Please send broken links and other corrections (or suggestions) to
+<a href="mailto:webmasters@gnu.org"><em>webmasters@gnu.org</em></a>.
+</p>
+-->
+
+<p>
+<!--
+Copyright (C) 2008
+Daniel Lowe &lt;dlowe dlowe.net&gt
+Attila Lendvai  &lt;attila.lendvai gmail.com&gt;
+<br />
+Verbatim copying and distribution of this entire article is
+permitted in any medium, provided this notice is preserved.
+-->
+</p>
+
+<p>
+Updated: %%DATE%%
+<!-- timestamp start -->
+<!-- $Date: 2005/05/15 00:00:08 $ $Author: karl $ -->
+<!-- timestamp end -->
+</p>
+</div>
+
+</body>
+</html>
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/local-time.texinfo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/local-time.texinfo
new file mode 100644
index 0000000..37eda5f
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/local-time.texinfo
@@ -0,0 +1,774 @@
+\input texinfo   @c -*- Mode: Texinfo; Mode: auto-fill -*-
+@c %**start of header
+@setfilename local-time.info
+@settitle The local-time Manual
+@exampleindent 2
+
+@c @documentencoding utf-8
+
+@macro name {}
+@code{local-time}
+@end macro
+
+@macro mathx {tex, non-tex}
+@iftex
+@math{\tex\}
+@end iftex
+@ifnottex
+@emph{\non-tex\}
+@end ifnottex
+@end macro
+
+@macro impnote {text}
+@quotation Implementor's note
+@emph{\text\}
+@end quotation
+@end macro
+
+@c Set ROMANCOMMENTS to get comments in roman font.
+@ifset ROMANCOMMENTS
+@alias lispcmt = r
+@end ifset
+@ifclear ROMANCOMMENTS
+@alias lispcmt = asis
+@end ifclear
+
+@c Index for public api.
+@defindex it
+
+@macro pub {name}
+@itindex \name\
+@c
+@end macro
+
+@macro k {what}
+@code{\what\}
+@end macro
+
+@iftex
+@alias v = asis
+@alias cl = code
+@end iftex
+
+@ifnottex
+@alias v = var
+@alias cl = strong
+@end ifnottex
+
+@c Show variables, clauses, and concepts in the same index.
+@syncodeindex it cp
+@syncodeindex vr cp
+
+@copying
+Copyright @copyright{} 2012 Daniel Lowe <dlowe dlowe.net> @*
+Copyright @copyright{} 2012 Attila Lendvai <attila.lendvai gmail.com> @*
+
+@quotation
+This manual describes the @name{} Common Lisp library which is
+based on Erik Naggum's  @emph{The Long, Painful History of Time}
+[NaggumPaper] paper.
+
+@end quotation
+@end copying
+@c %**end of header
+
+@titlepage
+@title The @name{} Manual
+@subtitle Version 1.0.0
+@author Daniel Lowe
+@author Attila Lendvai
+
+@page
+@vskip 0pt plus 1filll
+@insertcopying
+@end titlepage
+
+@contents
+
+@ifnottex
+@node Top
+@top @name{}
+@insertcopying
+@end ifnottex
+
+@menu
+* Introduction::
+* Public API::
+* Other Features::
+* References::
+* Comprehensive Index::
+@end menu
+
+@c ===================================================================
+@node Introduction
+@chapter Introduction
+
+@menu
+* Portability::
+@end menu
+
+The @name{} library is a Common Lisp library for the manipulation of
+dates, times and intervals. It was originally based almost entirely
+upon Erik Naggum's paper @emph{The Long Painful History of Time}
+[NaggumPaper].  Many of the core concepts originated from this paper,
+such as the seperation of days and seconds, the choice of 2000-03-01
+as the standard epoch, and the timestring format.
+
+@c ===================================================================
+@node Portability
+@section Portability
+
+This implementation assumes that time zone information is stored in
+the tzfile format. The default timezone is loaded from
+/etc/localtime. On non-POSIX systems, this will certainly give
+different results than the system time handling.
+
+local-time currently supports sub-second precision clocks with ABCL,
+Allegro, CMUCL, CCL, SBCL, and LispWorks for Linux or Darwin.  All
+others will be able to retrieve the time with second precision using
+@code{get-universal-time}. You may add support for your own
+implementation by implementing the clock generic protocol documented
+here.
+
+@c ===================================================================
+@node Public API
+@chapter Public API
+
+@menu
+* Types::
+* Timezones::
+* Creating timestamp Objects::
+* Querying timestamp Objects::
+* Manipulating Date and Time Values::
+* Parsing and Formatting::
+* Clocks::
+@end menu
+
+@c ===================================================================
+@node Types
+@section Types
+
+It's a good idea to treat all values as immutable objects. @name{}
+will not modify any object it was given unless explicitly asked to by
+the @code{:into} keyword argument.
+
+@itindex timestamp
+@deftp Class timestamp day sec nsec
+
+@code{timestamp} values can represent either a @emph{date},
+a @emph{daytime} or a @emph{time} value. It has the following slots:
+
+@lisp
+(defclass timestamp ()
+  ((day :type integer)
+   (sec :type integer)
+   (nsec :type (integer 0 999999999))))
+@end lisp
+
+The following constraints apply to the specific types:
+@itemize
+
+@item
+@emph{date}: must have a @var{+utc-zone+} timezone and the @var{sec}
+slot must be the first second of a day; In other words, the time
+elements of the @code{timestamp} value must have their least possible
+values.
+
+@item
+@emph{time}: the @var{day} slot must be zero.
+
+@end itemize
+@end deftp
+
+@deftp Struct timezone path name loaded
+
+@code{timezone} objects represent timezones - local and political
+modifications to the time representation.  Timezones are responsible
+for storing offsets from GMT, abbreviations for different
+sub-timezones, and the times each sub-timezone is to be in effect.
+
+@end deftp
+
+@c ===================================================================
+@node Timezones
+@section Timezones
+
+@itindex *default-timezone*
+@defvr Default *default-timezone*
+
+The variable @var{*default-timezone*} contains the timezone that will
+be used by default if none is specified.  It is loaded from
+@emph{/etc/localtime} when the library is loaded.  If
+@emph{/etc/localtime} is not present, it will default to UTC.
+
+@end defvr
+
+@itindex +utc-zone+
+@defvr Constant +utc-zone+
+
+The variable @var{+utc-zone+} contains a timezone corresponding to
+UTC.
+
+@end defvr
+
+
+@itindex define-timezone
+@defmac define-timezone zone-name zone-file &key (load nil)
+
+Define @var{zone-name} (a symbol or a string) as a new timezone,
+lazy-loaded from @var{zone-file} (a pathname designator relative to
+the zoneinfo directory on this system.  If @var{load} is true, load
+immediately.
+
+@end defmac
+
+@itindex find-timezone-by-location-name
+@defun find-timezone-by-location-name name
+
+Returns the timezone found at the location name (such as
+@code{US/Eastern}).  @code{reread-timezone-repository} must be called
+before this function is used.
+
+@end defun
+
+@itindex reread-timezone-repository
+@defun reread-timezone-repository &key (timezone-repository *default-timezone-repository-path*)
+
+Walks the current repository, reading all tzinfo files updating
+indexes.  The default timezone repository is set to the zoneinfo/
+directory of the local-time system.
+
+@end defun
+
+@c ===================================================================
+@node Creating timestamp Objects
+@section Creating @code{timestamp} Objects
+
+@itindex universal-to-timestamp
+@defun universal-to-timestamp universal &key (nsec 0)
+
+Produces a @code{timestamp} instance from the provided universal time
+@var{universal}.  Universal time is defined in the Common Lisp
+Specification as the number of seconds since 1900-01-01T00:00:00Z.
+@end defun
+
+
+@itindex unix-to-timestamp
+@defun unix-to-timestamp unix &key (nsec 0)
+
+Produces a @code{timestamp} instance from the provided unix time
+@var{unix}.  Unix time is defined by POSIX as the number of seconds
+since 1970-01-01T00:00:00Z.
+@end defun
+
+
+@itindex now
+@defun now
+
+Produces a @code{timestamp} instance with the current time.  With
+Allegro, CMUCL, CCL, SBCL, and LispWorks for Linux or Darwin, the new
+timestamp will be precise to the microsecond (usec); with ABCL, to the
+millisecond (ms).  Otherwise, the precision is limited to the second.
+@end defun
+
+
+@itindex today
+@defun today
+
+Produces a @code{timestamp} instance that corresponds to today's
+date, which is the midnight of the current day in the UTC zone.
+@end defun
+
+
+@itindex encode-timestamp
+@defun encode-timestamp nsec sec minute hour day month year &key timezone offset into
+
+Returns a new @code{timestamp} instance corresponding to the specified
+time elements.  The @var{offset} is the number of seconds offset from
+UTC of the locale.  If @var{offset} is not specified, the offset will
+be guessed from the @var{timezone}.  If a @code{timestamp} is passed
+as the @var{into} argument, its value will be set and that
+@code{timestamp} will be returned.  Otherwise, a new @code{timestamp}
+is created.
+@end defun
+
+
+@itindex make-timestamp
+@defmac make-timestamp &key :day :sec :nsec
+
+Expands to an expression that creates an instance of a
+@code{timestamp} exactly as specified.
+@end defmac
+
+
+@itindex clone-timestamp
+@defmac clone-timestamp timestamp
+
+Expands to an expression that creates another copy of @var{timestamp}
+that is @code{timestamp=} to it.
+@end defmac
+
+
+@c ===================================================================
+@node Querying timestamp Objects
+@section Querying @code{timestamp} Objects
+
+@itindex day-of
+@defun day-of timestamp
+
+Returns the day component of @var{timestamp}.  Although Naggum's paper
+specifies that the day should be a signed fixnum, it is left unbounded
+for flexibility reasons.
+@end defun
+
+@itindex sec-of
+@defun sec-of timestamp
+
+Returns the 'seconds' component of the time.  Valid values for the
+seconds range from 0 to 86399.
+@end defun
+
+@itindex nsec-of
+@defun nsec-of timestamp
+
+Returns the 'microseconds' component of the time.  Valid values for
+the nanoseconds range from 0 to 999999999.
+@end defun
+
+@itindex timestamp-to-universal
+@defun timestamp-to-universal timestamp
+
+This returns the date/time specified in @var{timestamp} encoded as
+the number of seconds since January 1st, 1900 12:00am UTC.
+@end defun
+
+@itindex timestamp-to-unix
+@defun timestamp-to-unix timestamp
+
+This returns the date/time specified in @var{timestamp} encoded as
+the number of seconds since January 1st, 1970 12:00am UTC.  It
+corresponds with the time received from the POSIX call @code{time()}.
+@end defun
+
+@itindex timestamp-subtimezone
+@defun timestamp-subtimezone timestamp timezone
+
+Returns as multiple values the time zone applicable at the given time
+as the number of seconds east of UTC, a boolean daylight-saving-p, and
+the customary abbreviation of the timezone.
+@end defun
+
+
+@itindex with-decoded-timestamp
+@defmac with-decoded-timestamp (&key nsec sec minute hour day month year day-of-week daylight-p timezone) timestamp &body body
+
+This macro binds variables to the decoded elements of @var{timestamp}.
+The timezone argument is used for decoding the timestamp, and is not
+bound by the macro. The value of @var{day-of-week} starts from 0 which
+means Sunday.
+@end defmac
+
+
+@itindex decode-timestamp
+@defun decode-timestamp timestamp
+
+Returns the decoded time as @code{(values ns ss mm hh day month
+year day-of-week daylight-saving-time-p timezone-offset timezone-abbreviation)}.
+@end defun
+
+
+@itindex timestamp<
+@itindex timestamp<=
+@itindex timestamp>
+@itindex timestamp>=
+@itindex timestamp=
+@itindex timestamp/=
+@defun timestamp< time-a time-b
+@defunx timestamp<= time-a time-b
+@defunx timestamp> time-a time-b
+@defunx timestamp>= time-a time-b
+@defunx timestamp= time-a time-b
+@defunx timestamp/= time-a time-b
+
+These comparison functions act like their string and char counterparts.
+@end defun
+
+
+@itindex timestamp-minimum
+@defun timestamp-minimum timestamp &rest timestamps
+
+Returns the earliest timestamp passed to it.
+@end defun
+
+
+@itindex timestamp-maximum
+@defun timestamp-maximum timestamp &rest timestamps
+
+Returns the latest timestamp passed to it.
+@end defun
+
+
+@itindex timestamp-day-of-week
+@defun timestamp-day-of-week timestamp
+
+This returns the index of the day of the week,
+starting at 0 which means Sunday.
+@quotation Note
+''Day of the week'' is ambigous and locale dependent.
+@end quotation
+@end defun
+
+
+@itindex universal-to-timestamp
+@defun universal-to-timestamp timestamp
+
+Returns the UNIVERSAL-TIME corresponding to @var{timestamp}.
+@quotation Note
+Subsecond precision is not preserved.
+@end quotation
+@end defun
+
+
+@itindex timestamp-millennium
+@itindex timestamp-century
+@itindex timestamp-decade
+@defun timestamp-millennium timestamp &key timezone
+@defunx timestamp-century timestamp &key timezone
+@defunx timestamp-decade timestamp &key timezone
+
+Returns the ordinal millennium, century or decade upon which the
+timestamp falls.  Ordinal time values start at 1, so the
+(timestamp-century (now)) will return 21.
+
+@end defun
+
+@itindex timestamp-year
+@itindex timestamp-month
+@itindex timestamp-day
+@itindex timestamp-hour
+@itindex timestamp-minute
+@itindex timestamp-second
+@itindex timestamp-millisecond
+@itindex timestamp-microsecond
+@defun timestamp-year timestamp &key timezone
+@defunx timestamp-month timestamp &key timezone
+@defunx timestamp-day timestamp &key timezone
+@defunx timestamp-hour timestamp &key timezone
+@defunx timestamp-minute timestamp &key timezone
+@defunx timestamp-second timestamp &key timezone
+@defunx timestamp-millisecond timestamp &key timezone
+@defunx timestamp-microsecond timestamp &key timezone
+@defunx timestamp-microsecond timestamp &key timezone
+
+Returns the decoded part of the timestamp.
+@end defun
+
+
+@c ===================================================================
+@node Manipulating Date and Time Values
+@section Manipulating Date and Time Values
+
+@itindex timestamp+
+@itindex timestamp-
+@defun timestamp+ time amount unit
+@defunx timestamp- time amount unit
+
+Add or subtract the @var{amount} to the @var{time} using the specified
+@var{unit}.  @var{unit} may be one of ( @code{:nsec} @code{:sec}
+@code{:minute} @code{:hour} @code{:day} @code{:month} @code{:year}).
+The value of the parts of the timestamp of higher resolution than the
+UNIT will never be touched.  If you want a precise number of seconds
+from a time, you should specify the offset in seconds.
+@end defun
+
+@itindex timestamp-maximize-part
+@defun timestamp-maximize-part timestamp part &key offset timezone into
+
+Returns a timestamp with its parts maximized up to @var{part}.  @var{part} can be
+any of (:nsec :sec :min :hour :day :month).  If @var{into} is specified, it
+will be modified and returned, otherwise a new timestamp will be
+created.
+@end defun
+
+
+@itindex timestamp-minimize-part
+@defun timestamp-minimize-part timestamp part &key offset timezone into
+
+Returns a timestamp with its parts minimized up to @var{part}.  @var{part} can be
+any of (:nsec :sec :min :hour :day :month).  If @var{into} is specified, it
+will be modified and returned, otherwise a new timestamp will be
+created.
+@end defun
+
+
+@itindex adjust-timestamp
+@defmac adjust-timestamp timestamp &body changes
+
+Alters various parts of @var{timestamp}, given a list of changes.  The
+changes are in the format @code{(offset part value)} and @code{(set
+part value)}.
+
+@lisp
+;; Return a new @code{timestamp} value that points to the Monday in
+;; the week of @code{(today)}
+(adjust-timestamp (today) (offset :day-of-week :monday))
+
+;; Return a new @code{timestamp} value that points three days ahead from now
+(adjust-timestamp (today) (offset :day 3))
+@end lisp
+
+Keep in mind that @code{adjust-timestamp} is not a mere setter for
+fields but instead it handles overflows and timezone conversions as
+expected. Also note that it's possible to specify multiple commands.
+
+The list of possible places to manipulate are: @code{:nsec}
+@code{:sec} @code{:sec-of-day} @code{:minute} @code{:hour}
+@code{:day} @code{:day-of-month} @code{:month} @code{:year}.
+@end defmac
+
+
+@itindex adjust-timestamp!
+@defmac adjust-timestamp! timestamp &body changes
+
+Just like @code{adjust-timestamp}, but instead of returning a freshly
+constructed value, it alters the provided @var{timestamp} value (and
+returns it).
+@end defmac
+
+
+@itindex timestamp-whole-year-difference
+@defun timestamp-whole-year-difference time-a time-b
+
+Returns the number of whole years elapsed between @var{time-a} and @var{time-b}.
+@quotation Note
+This is useful for calculating anniversaries and birthdays.
+@end quotation
+@end defun
+
+
+@itindex days-in-month
+@defun days-in-month month year
+
+Returns the number of days in a given month of the specified year.
+@end defun
+
+
+@c ===================================================================
+@node Parsing and Formatting
+@section Parsing and Formatting
+
+
+@itindex +iso-8601-format+
+@defvr Constant +iso-8601-format+
+
+The constant @var{+iso-8601-format+} is bound to a description of the ISO 8601 format.  An output with this format will look like this: @samp{2008-03-01T19:42:34.608506+01:00}.  This is the default format for the @code{format-timestring} function.
+
+@end defvr
+
+@itindex +asctime-format+
+@defvr Constant +asctime-format+
+
+The constant @var{+asctime-format+} is bound to a format mirroring the output of the POSIX asctime() function.  An output with this format will look like this: @samp{Sat Mar  1 19:42:34 2008}.
+
+@end defvr
+
+@itindex +rfc-1123-format+
+@defvr Constant +rfc-1123-format+
+
+The constant @var{+rfc-1123-format+} is bound to a description of the format defined in RFC 1123 for Internet timestamps.  An output with this format will look like this: @samp{Sat, 01 Mar 2008 19:42:34 -0500}.
+
+@end defvr
+
+@itindex +iso-week-date-format+
+@defvr Constant +iso-week-date-format+
+
+The constant @var{+iso-week-date-format+} is bound to a description of the ISO 8601 Week Date format.  An output with this format will look like this: @samp{2009-W53-5}.
+
+@end defvr
+
+@itindex parse-timestring
+@defun parse-timestring timestring &key (start 0) end (fail-on-error t) (offset 0)
+
+Parses a timestring and returns the corresponding @code{timestamp}.
+Parsing begins at @var{start} and stops at the @var{end}
+position. If there are invalid characters within @code{timestring}
+and @var{fail-on-error} is @code{T}, then an @code{invalid-timestring}
+error is signaled, otherwise @code{NIL} is returned.
+
+If there is no timezone specified in @code{timestring} then
+@var{offset} is used as the default timezone offset (in seconds).
+@end defun
+
+
+@itindex format-timestring
+@defun format-timestring (destination timestamp &key (format +iso-8601-format+) (timezone *default-timezone*))
+
+Constructs a string representation of TIMESTAMP according to FORMAT and returns it.  If destination is @code{T}, the string is written to @code{*standard-output*}.  If destination is a stream, the string is written to the stream.
+
+FORMAT is a list containing one or more of strings, characters, and keywords.  Strings and characters are output literally, while keywords are replaced by the values here:
+
+@table @code
+@item :year
+*year
+@item :month
+*numeric month
+@item :day
+*day of month
+@item :weekday
+*numeric day of week, starting from 0 which means Sunday
+@item :hour
+*hour
+@item :min
+*minutes
+@item :sec
+*seconds
+@item :msec
+*milliseconds
+@item :usec
+*microseconds
+@item :nsec
+*nanoseconds
+@item :iso-week-year
+*year for ISO week date (can be different from regular calendar year)
+@item :iso-week-number
+*ISO week number (i.e. 1 through 53)
+@item :iso-week-day
+*ISO compatible weekday number (i.e. monday=1, sunday=7)
+@item :ordinal-day
+day of month as an ordinal (e.g. 1st, 23rd)
+@item :long-weekday
+long form of weekday (e.g. Sunday, Monday)
+@item :short-weekday
+short form of weekday (e.g. Sun, Mon)
+@item :minimal-weekday
+minimal form of weekday (e.g. Su, Mo)
+@item :short-year
+short form of year (last 2 digits, e.g. 41, 42 instead of 2041, 2042)
+@item :long-month
+long form of month (e.g. January, February)
+@item :short-month
+short form of month (e.g. Jan, Feb)
+@item :hour12
+hour on a 12-hour clock
+@item :ampm
+am/pm marker in lowercase
+@item :gmt-offset
+the gmt-offset of the time, in +00:00 form
+@item :gmt-offset-or-z
+like :gmt-offset, but is Z when UTC
+@item :gmt-offset-hhmm
+like :gmt-offset, but in +0000 form
+@item :timezone
+timezone abbrevation for the time
+@end table
+
+Elements marked by * can be placed in a list in the form:
+@lisp
+(:keyword padding &optional (padchar #\0))
+@end lisp
+The string representation of the value will be padded with the padchar.
+
+You can see examples by examining the values in @var{+iso-8601-format+}, @var{+asctime-format+}, and @var{+rfc-1123-format+}.
+
+Produces on @var{stream} the timestring corresponding to the @var{timestamp} with
+the given options.  If @var{stream} is @code{nil}, only returns a string containing what
+would have been the output.  If @var{stream} is @code{t}, prints the string to
+@var{*standard-output*}.
+
+Example output:
+@lisp
+LOCAL-TIME> (format-timestring nil (now))
+"2008-03-01T19:42:34.608506+01:00"
+@end lisp
+@end defun
+
+
+@itindex format-rfc3339-timestring
+@defun format-rfc3339-timestring (destination timestamp &key omit-date-part omit-time-part omit-timezone-part (use-zulu t))
+
+Formats the time like format-timestring, but in RFC 3339 format. The options control valid options in the RFC.
+@end defun
+
+
+@itindex format-rfc1123-timestring
+@defun format-rfc1123-timestring (destination timestamp &key (timezone *default-timezone*))
+
+Formats the time like format-timestring, but in RFC 1123 format.
+@end defun
+
+@c ===================================================================
+@node Clocks
+@section Clocks
+
+@defvr Default *clock*
+
+The *clock* special variable and the following generic functions are
+exposed so that applications may re-define the current time or date as
+required.  This can be used for testing or to support alternate clocks.
+
+The currently supported values are:
+
+@itemize
+@item @code{t} - Use the standard system clock with no adjustments
+@item @code{leap-second-adjusted} - The system clock, adjusted for leap seconds using the information in *default-timezone*.
+@end itemize
+
+@end defvr
+
+@defun clock-now (clock)
+
+Specialize this generic function to re-define the present moment
+@end defun
+
+@defun clock-today (clock)
+
+Specialize this generic function to re-define the present day
+@end defun
+
+@c ===================================================================
+@node Other Features
+@chapter Other Features
+
+@section Reader Macros
+
+@itindex enable-read-macros
+@defun enable-read-macros
+
+Adds @@TIMESTRING and #@@UNIVERSAL-TIME as reader macros.
+@end defun
+
+
+@section Support for non-Gregorian Calendars
+
+@itindex astronomical-julian-date
+@defun astronomical-julian-date timestamp
+
+Returns the julian date of the date portion of @var{timestamp}.
+@end defun
+
+
+@itindex modified-julian-date
+@defun astronomical-julian-date timestamp
+
+Returns the modified julian date of the date portion of @var{timestamp}.
+@end defun
+
+@c ===================================================================
+@node References
+@chapter References
+
+@itemize
+
+@item
+[NaggumPaper] Erik Naggum. @emph{The Long Painful History of Time}
+@url{http://naggum.no/lugm-time.html}, 1999.
+
+@end itemize
+
+
+@c ===================================================================
+@node Comprehensive Index
+@unnumbered Index
+@printindex cp
+
+@bye
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/style.css b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/style.css
new file mode 100644
index 0000000..1499f5f
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/doc/style.css
@@ -0,0 +1,48 @@
+body {font-family: century schoolbook, serif;
+      line-height: 1.3;
+      padding-left: 5em; padding-right: 1em;
+      padding-bottom: 1em; max-width: 60em;}
+table {border-collapse: collapse}
+span.roman { font-family: century schoolbook, serif; font-weight: normal; }
+h1, h2, h3, h4, h5, h6 {font-family:  Helvetica, sans-serif}
+/*h4 {padding-top: 0.75em;}*/
+dfn {font-family: inherit; font-variant: italic; font-weight: bolder }
+kbd {font-family: monospace; text-decoration: underline}
+/*var {font-family: Helvetica, sans-serif; font-variant: slanted}*/
+var {font-variant: slanted;}
+td  {padding-right: 1em; padding-left: 1em}
+sub {font-size: smaller}
+.node {padding: 0; margin: 0}
+
+.lisp { font-family: monospace;
+        background-color: #F4F4F4; border: 1px solid #AAA;
+        padding-top: 0.5em; padding-bottom: 0.5em; }
+
+/* coloring */
+
+.lisp-bg { background-color: #F4F4F4 ; color: black; }
+.lisp-bg:hover { background-color: #F4F4F4 ; color: black; }
+
+.symbol { font-weight: bold; color: #770055; background-color : transparent; border: 0px; margin: 0px;}
+a.symbol:link { font-weight: bold; color : #229955; background-color : transparent; text-decoration: none; border: 0px; margin: 0px; }
+a.symbol:active { font-weight: bold; color : #229955; background-color : transparent; text-decoration: none; border: 0px; margin: 0px; }
+a.symbol:visited { font-weight: bold; color : #229955; background-color : transparent; text-decoration: none; border: 0px; margin: 0px; }
+a.symbol:hover { font-weight: bold; color : #229955; background-color : transparent; text-decoration: none; border: 0px; margin: 0px; }
+.special { font-weight: bold; color: #FF5000; background-color: inherit; }
+.keyword { font-weight: bold; color: #770000; background-color: inherit; }
+.comment { font-weight: normal; color: #007777; background-color: inherit; }
+.string  { font-weight: bold; color: #777777; background-color: inherit; }
+.character   { font-weight: bold; color: #0055AA; background-color: inherit; }
+.syntaxerror { font-weight: bold; color: #FF0000; background-color: inherit; }
+span.paren1 { font-weight: bold; color: #777777; }
+span.paren1:hover { color: #777777; background-color: #BAFFFF; }
+span.paren2 { color: #777777; }
+span.paren2:hover { color: #777777; background-color: #FFCACA; }
+span.paren3 { color: #777777; }
+span.paren3:hover { color: #777777; background-color: #FFFFBA; }
+span.paren4 { color: #777777; }
+span.paren4:hover { color: #777777; background-color: #CACAFF; }
+span.paren5 { color: #777777; }
+span.paren5:hover { color: #777777; background-color: #CAFFCA; }
+span.paren6 { color: #777777; }
+span.paren6:hover { color: #777777; background-color: #FFBAFF; }
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/local-time.asd b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/local-time.asd
new file mode 100644
index 0000000..922f583
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/local-time.asd
@@ -0,0 +1,29 @@
+(defsystem "local-time"
+  :version "1.0.6"
+  :license "BSD"
+  :author "Daniel Lowe <dlowe@dlowe.net>"
+  :description "A library for manipulating dates and times, based on a paper by Erik Naggum"
+  :depends-on (:cl-fad)
+  :in-order-to ((test-op (test-op "local-time/test")))
+  :components ((:module "src"
+                        :serial t
+                        :components ((:file "package")
+                                     (:file "local-time")))))
+
+(defsystem "local-time/test"
+  :version "1.0.6"
+  :author "Daniel Lowe <dlowe@dlowe.net>"
+  :description "Testing code for the local-time library"
+  :depends-on (:stefil
+               :local-time)
+  :perform (test-op (o s) (uiop:symbol-call '#:stefil
+                                            '#:funcall-test-with-feedback-message
+                                            (uiop:find-symbol* '#:test '#:local-time.test)))
+  :components ((:module "test"
+                :serial t
+                :components ((:file "package")
+                             (:file "simple")
+                             (:file "comparison")
+                             (:file "formatting")
+                             (:file "parsing")
+                             (:file "timezone")))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/src/integration/cl-postgres.lisp b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/src/integration/cl-postgres.lisp
new file mode 100644
index 0000000..972709f
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/src/integration/cl-postgres.lisp
@@ -0,0 +1,46 @@
+(in-package :local-time)
+
+(export 'set-local-time-cl-postgres-readers :local-time)
+
+;; Postgresql days are measured from 2000-01-01, whereas local-time
+;; uses 2000-03-01. We expect the database server to be in the UTC timezone.
+(defconstant +postgres-day-offset-to-local-time+ -60)
+
+(defun set-local-time-cl-postgres-readers (&optional (table cl-postgres:*sql-readtable*))
+  (flet ((timestamp-reader (usecs)
+           (multiple-value-bind (days usecs)
+               (floor usecs +usecs-per-day+)
+             (multiple-value-bind (secs usecs)
+                 (floor usecs 1000000)
+               (local-time:make-timestamp :nsec (* usecs 1000)
+                                          :sec secs
+                                          :day (+ days +postgres-day-offset-to-local-time+))))))
+    (cl-postgres:set-sql-datetime-readers
+     :table table
+     :date (lambda (days)
+             (local-time:make-timestamp
+              :nsec 0 :sec 0
+              :day (+ days +postgres-day-offset-to-local-time+)))
+     :timestamp #'timestamp-reader
+     :timestamp-with-timezone #'timestamp-reader
+     :interval
+     (lambda (months days usecs)
+       (declare (ignore months days usecs))
+       (error "Intervals are not yet supported"))
+     :time
+     (lambda (usecs)
+       (multiple-value-bind (days usecs)
+           (floor usecs +usecs-per-day+)
+         (assert (= days 0))
+         (multiple-value-bind (secs usecs)
+             (floor usecs 1000000)
+           (let ((time-of-day (local-time:make-timestamp
+                               :nsec (* usecs 1000)
+                               :sec secs
+                               :day 0)))
+             (check-type time-of-day time-of-day)
+             time-of-day)))))))
+
+(defmethod cl-postgres:to-sql-string ((arg local-time:timestamp))
+  (format nil "'~a'"
+          (local-time:format-rfc3339-timestring nil arg :timezone +utc-zone+)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/src/local-time.lisp b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/src/local-time.lisp
new file mode 100644
index 0000000..99b9af0
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/src/local-time.lisp
@@ -0,0 +1,1906 @@
+(in-package #:local-time)
+
+;;; Types
+
+(defclass timestamp ()
+  ((day :accessor day-of :initarg :day :initform 0 :type integer)
+   (sec :accessor sec-of :initarg :sec :initform 0 :type integer)
+   (nsec :accessor nsec-of :initarg :nsec :initform 0 :type (integer 0 999999999))))
+
+(defstruct subzone
+  (abbrev nil)
+  (offset nil)
+  (daylight-p nil))
+
+(defstruct timezone
+  (transitions #(0) :type simple-vector)
+  (indexes #(0) :type simple-vector)
+  (subzones #() :type simple-vector)
+  (leap-seconds nil :type list)
+  (path nil)
+  (name "anonymous" :type string)
+  (loaded nil :type boolean))
+
+(deftype timezone-offset ()
+  '(integer -43200 50400))
+
+(defun %valid-time-of-day? (timestamp)
+  (zerop (day-of timestamp)))
+
+(deftype time-of-day ()
+  '(and timestamp
+        (satisfies %valid-time-of-day?)))
+
+(defun %valid-date? (timestamp)
+  (and (zerop (sec-of timestamp))
+       (zerop (nsec-of timestamp))))
+
+(deftype date ()
+  '(and timestamp
+        (satisfies %valid-date?)))
+
+(define-condition invalid-timezone-file (error)
+  ((path :accessor path-of :initarg :path))
+  (:report (lambda (condition stream)
+             (format stream "The file at ~a is not a timezone file."
+                     (path-of condition)))))
+
+(define-condition invalid-time-specification (error)
+  ()
+  (:report "The time specification is invalid"))
+
+(define-condition invalid-timestring (error)
+  ((timestring :accessor timestring-of :initarg :timestring)
+   (failure :accessor failure-of :initarg :failure))
+  (:report (lambda (condition stream)
+             (format stream "Failed to parse ~S as an rfc3339 time: ~S"
+                     (timestring-of condition)
+                     (failure-of condition)))))
+
+(defmethod make-load-form ((self timestamp) &optional environment)
+  (make-load-form-saving-slots self :environment environment))
+
+;;; Declaims
+
+(declaim (inline now format-timestring %get-current-time
+                 format-rfc3339-timestring to-rfc3339-timestring
+                 format-rfc1123-timestring to-rfc1123-timestring)
+         (ftype (function (&rest t) string) format-rfc3339-timestring)
+         (ftype (function (&rest t) string) format-timestring)
+         (ftype (function (&rest t) fixnum) local-timezone)
+         (ftype (function (&rest t) (values
+                                     timezone-offset
+                                     boolean
+                                     string)) timestamp-subzone)
+         (ftype (function (timestamp &key (:timezone timezone) (:offset (or null integer)))
+                          (values (integer 0 999999999)
+                                  (integer 0 59)
+                                  (integer 0 59)
+                                  (integer 0 23)
+                                  (integer 1 31)
+                                  (integer 1 12)
+                                  (integer -1000000 1000000)
+                                  (integer 0 6)
+                                  t
+                                  timezone-offset
+                                  simple-string))
+                decode-timestamp))
+
+;;; Variables
+
+(defvar *default-timezone*)
+
+(defparameter *default-timezone-repository-path*
+  (flet ((try (project-home-directory)
+           (when project-home-directory
+             (ignore-errors
+               (truename
+                (merge-pathnames "zoneinfo/"
+                                 (make-pathname :directory (pathname-directory project-home-directory))))))))
+    (or (when (find-package "ASDF")
+          (let ((path (eval (read-from-string
+                             "(let ((system (asdf:find-system :local-time nil)))
+                                (when system
+                                  (asdf:component-pathname system)))"))))
+            (try path)))
+        (let ((path (or #.*compile-file-truename*
+                        *load-truename*)))
+          (when path
+            (try (merge-pathnames "../" path)))))))
+
+;;; Month information
+(defparameter +month-names+
+  #("" "January" "February" "March" "April" "May" "June" "July" "August"
+    "September" "October" "November" "December"))
+(defparameter +short-month-names+
+  #("" "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov"
+    "Dec"))
+(defparameter +day-names+
+  #("Sunday" "Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday"))
+(defparameter +day-names-as-keywords+
+  #(:sunday :monday :tuesday :wednesday :thursday :friday :saturday))
+(defparameter +short-day-names+
+  #("Sun" "Mon" "Tue" "Wed" "Thu" "Fri" "Sat"))
+(defparameter +minimal-day-names+
+  #("Su" "Mo" "Tu" "We" "Th" "Fr" "Sa"))
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (defconstant +months-per-year+ 12)
+  (defconstant +days-per-week+ 7)
+  (defconstant +hours-per-day+ 24)
+  (defconstant +minutes-per-day+ 1440)
+  (defconstant +minutes-per-hour+ 60)
+  (defconstant +seconds-per-day+ 86400)
+  (defconstant +seconds-per-hour+ 3600)
+  (defconstant +seconds-per-minute+ 60)
+  (defconstant +usecs-per-day+ 86400000000))
+
+(defparameter +iso-8601-date-format+
+  '((:year 4) #\- (:month 2) #\- (:day 2)))
+
+(defparameter +iso-8601-time-format+
+  '((:hour 2) #\: (:min 2) #\: (:sec 2) #\. (:usec 6)))
+
+(defparameter +iso-8601-format+
+  ;; 2008-11-18T02:32:00.586931+01:00
+  (append +iso-8601-date-format+ (list #\T) +iso-8601-time-format+ (list :gmt-offset-or-z)))
+
+(defparameter +rfc3339-format+ +iso-8601-format+)
+
+(defparameter +rfc3339-format/date-only+
+  '((:year 4) #\- (:month 2) #\- (:day 2)))
+
+(defparameter +asctime-format+
+  '(:short-weekday #\space :short-month #\space (:day 2 #\space) #\space
+    (:hour 2) #\: (:min 2) #\: (:sec 2) #\space
+    (:year 4)))
+
+(defparameter +rfc-1123-format+
+  ;; Sun, 06 Nov 1994 08:49:37 GMT
+  '(:short-weekday ", " (:day 2) #\space :short-month #\space (:year 4) #\space
+    (:hour 2) #\: (:min 2) #\: (:sec 2) #\space :gmt-offset-hhmm)
+  "See the RFC 1123 for the details about the possible values of the timezone field.")
+
+(defparameter +iso-week-date-format+
+  ;; 2009-W53-5
+  '((:iso-week-year 4) #\- #\W (:iso-week-number 2) #\- (:iso-week-day 1)))
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (defparameter +rotated-month-days-without-leap-day+
+    #.(coerce #(31 30 31 30 31 31 30 31 30 31 31 28)
+              '(simple-array fixnum (*))))
+
+  (defparameter +rotated-month-offsets-without-leap-day+
+    (coerce
+     (cons 0
+           (loop with sum = 0
+                 for days :across +rotated-month-days-without-leap-day+
+                 collect (incf sum days)))
+     '(simple-array fixnum (*)))))
+
+;; The astronomical julian date offset is the number of days between
+;; the current date and -4713-01-01T00:00:00+00:00
+(defparameter +astronomical-julian-date-offset+ -2451605)
+
+;; The modified julian date is the number of days between the current
+;; date and 1858-11-17T12:00:00+00:00. TODO: For the sake of simplicity,
+;; we currently just do the date arithmetic and don't adjust for the
+;; time of day.
+(defparameter +modified-julian-date-offset+ -51604)
+
+(defun %guess-offset (seconds days &optional timezone)
+  ;; try converting the local time to a timestamp using each available
+  ;; subtimezone, until we find one where the offset matches the offset that
+  ;; applies at that time (according to the transition table).
+  ;;
+  ;; Consequence for ambiguous cases:
+  ;; Whichever subtimezone is listed first in the tzinfo database will be
+  ;; the one that we pick to resolve ambiguous local time representations.
+  (let* ((zone (%realize-timezone (or timezone *default-timezone*)))
+         (unix-time (timestamp-values-to-unix seconds days))
+         (subzone-idx (if (zerop (length (timezone-indexes zone)))
+                          0
+                          (elt (timezone-indexes zone)
+                               (transition-position unix-time
+                                                    (timezone-transitions zone)))))
+         (subzone (elt (timezone-subzones zone) subzone-idx)))
+    (subzone-offset subzone)))
+
+(defun %read-binary-integer (stream byte-count &optional (signed nil))
+  "Read BYTE-COUNT bytes from the binary stream STREAM, and return an integer which is its representation in network byte order (MSB).  If SIGNED is true, interprets the most significant bit as a sign indicator."
+  (loop
+    :with result = 0
+    :for offset :from (* (1- byte-count) 8) :downto 0 :by 8
+    :do (setf (ldb (byte 8 offset) result) (read-byte stream))
+    :finally (if signed
+                 (let ((high-bit (* byte-count 8)))
+                   (if (logbitp (1- high-bit) result)
+                       (return (- result (ash 1 high-bit)))
+                       (return result)))
+                 (return result))))
+
+(defun %string-from-unsigned-byte-vector (vector offset)
+  "Returns a string created from the vector of unsigned bytes VECTOR starting at OFFSET which is terminated by a 0."
+  (declare (type (vector (unsigned-byte 8)) vector))
+  (let* ((null-pos (or (position 0 vector :start offset) (length vector)))
+         (result (make-string (- null-pos offset))))
+    (loop for input-index :from offset :upto (1- null-pos)
+          for output-index :upfrom 0
+          do (setf (aref result output-index) (code-char (aref vector input-index))))
+    result))
+
+(defun %find-first-std-offset (timezone-indexes timestamp-info)
+  (let ((subzone-idx (find-if 'subzone-daylight-p
+                              timezone-indexes
+                              :key (lambda (x) (aref timestamp-info x)))))
+    (subzone-offset (aref timestamp-info (or subzone-idx 0)))))
+
+(defun %tz-verify-magic-number (inf zone)
+  ;; read and verify magic number
+  (let ((magic-buf (make-array 4 :element-type 'unsigned-byte)))
+    (read-sequence magic-buf inf :start 0 :end 4)
+    (when (string/= (map 'string #'code-char magic-buf) "TZif" :end1 4)
+      (error 'invalid-timezone-file :path (timezone-path zone))))
+  ;; skip 16 bytes for "future use"
+  (let ((ignore-buf (make-array 16 :element-type 'unsigned-byte)))
+    (read-sequence ignore-buf inf :start 0 :end 16)))
+
+(defun %tz-read-header (inf)
+  `(:utc-count ,(%read-binary-integer inf 4)
+    :wall-count ,(%read-binary-integer inf 4)
+    :leap-count ,(%read-binary-integer inf 4)
+    :transition-count ,(%read-binary-integer inf 4)
+    :type-count ,(%read-binary-integer inf 4)
+    :abbrev-length ,(%read-binary-integer inf 4)))
+
+(defun %tz-read-transitions (inf count)
+  (make-array count
+              :initial-contents
+              (loop for idx from 1 upto count
+                 collect (%read-binary-integer inf 4 t))))
+
+(defun %tz-read-indexes (inf count)
+  (make-array count
+              :initial-contents
+              (loop for idx from 1 upto count
+                 collect (%read-binary-integer inf 1))))
+
+(defun %tz-read-subzone (inf count)
+  (loop for idx from 1 upto count
+     collect (list (%read-binary-integer inf 4 t)
+                   (%read-binary-integer inf 1)
+                   (%read-binary-integer inf 1))))
+
+(defun leap-seconds-sec (leap-seconds)
+  (car leap-seconds))
+(defun leap-seconds-adjustment (leap-seconds)
+  (cdr leap-seconds))
+
+(defun %tz-read-leap-seconds (inf count)
+  (when (plusp count)
+    (loop for idx from 1 upto count
+          collect (%read-binary-integer inf 4) into sec
+          collect (%read-binary-integer inf 4) into adjustment
+          finally (return (cons (make-array count :initial-contents sec)
+                                (make-array count :initial-contents adjustment))))))
+
+(defun %tz-read-abbrevs (inf length)
+  (let ((a (make-array length :element-type '(unsigned-byte 8))))
+    (read-sequence a inf
+                   :start 0
+                   :end length)
+    a))
+
+(defun %tz-read-indicators (inf length)
+  ;; read standard/wall indicators
+  (let ((buf (make-array length :element-type '(unsigned-byte 8))))
+    (read-sequence buf inf
+                   :start 0
+                   :end length)
+    (make-array length
+                :element-type 'bit
+                :initial-contents buf)))
+
+(defun %tz-make-subzones (raw-info abbrevs gmt-indicators std-indicators)
+  (declare (ignore gmt-indicators std-indicators))
+  ;; TODO: handle TZ environment variables, which use the gmt and std
+  ;; indicators
+  (make-array (length raw-info)
+              :element-type 'subzone
+              :initial-contents
+              (loop for info in raw-info collect
+                   (make-subzone
+                    :offset (first info)
+                    :daylight-p (/= (second info) 0)
+                    :abbrev (%string-from-unsigned-byte-vector abbrevs (third info))))))
+
+(defun %realize-timezone (zone &optional reload)
+  "If timezone has not already been loaded or RELOAD is non-NIL, loads the timezone information from its associated unix file.  If the file is not a valid timezone file, the condition INVALID-TIMEZONE-FILE will be signaled."
+  (when (or reload (not (timezone-loaded zone)))
+    (with-open-file (inf (timezone-path zone)
+                         :direction :input
+                         :element-type 'unsigned-byte)
+      (%tz-verify-magic-number inf zone)
+
+      ;; read header values
+      (let* ((header (%tz-read-header inf))
+             (timezone-transitions (%tz-read-transitions inf (getf header :transition-count)))
+             (subzone-indexes (%tz-read-indexes inf (getf header :transition-count)))
+             (subzone-raw-info (%tz-read-subzone inf (getf header :type-count)))
+             (abbreviation-buf (%tz-read-abbrevs inf (getf header :abbrev-length)))
+             (leap-second-info (%tz-read-leap-seconds inf (getf header :leap-count)))
+             (std-indicators (%tz-read-indicators inf (getf header :wall-count)))
+             (gmt-indicators (%tz-read-indicators inf (getf header :utc-count)))
+             (subzone-info (%tz-make-subzones subzone-raw-info
+                                              abbreviation-buf
+                                              gmt-indicators
+                                              std-indicators)))
+
+        (setf (timezone-transitions zone) timezone-transitions)
+        (setf (timezone-indexes zone) subzone-indexes)
+        (setf (timezone-subzones zone) subzone-info)
+        (setf (timezone-leap-seconds zone) leap-second-info))
+      (setf (timezone-loaded zone) t)))
+  zone)
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (defun %make-simple-timezone (name abbrev offset)
+    (let ((subzone (local-time::make-subzone :offset offset
+                                           :daylight-p nil
+                                           :abbrev abbrev)))
+    (local-time::make-timezone
+     :subzones (make-array 1 :initial-contents (list subzone))
+     :path nil
+     :name name
+     :loaded t)))
+
+  ;; to be used as #+#.(local-time::package-with-symbol? "SB-EXT" "GET-TIME-OF-DAY")
+  (defun package-with-symbol? (package name)
+    (if (and (find-package package)
+             (find-symbol name package))
+        '(:and)
+        '(:or))))
+
+(defparameter +utc-zone+ (%make-simple-timezone "Coordinated Universal Time" "UTC" 0))
+
+(defparameter +gmt-zone+ (%make-simple-timezone "Greenwich Mean Time" "GMT" 0))
+
+(defparameter +none-zone+ (%make-simple-timezone "Explicit Offset Given" "NONE" 0))
+
+(defmacro define-timezone (zone-name zone-file &key (load nil))
+  "Define zone-name (a symbol or a string) as a new timezone, lazy-loaded from zone-file (a pathname designator relative to the zoneinfo directory on this system.  If load is true, load immediately."
+  (declare (type (or string symbol) zone-name))
+  (let ((zone-sym (if (symbolp zone-name) zone-name (intern zone-name))))
+    `(prog1
+      (defparameter ,zone-sym (make-timezone :path ,zone-file
+                                             :name ,(if (symbolp zone-name)
+                                                        (string-downcase (symbol-name zone-name))
+                                                        zone-name)))
+      ,@(when load
+              `((%realize-timezone ,zone-sym))))))
+
+(eval-when (:load-toplevel :execute)
+  (let ((default-timezone-file #p"/etc/localtime"))
+    (handler-case
+        (define-timezone *default-timezone* default-timezone-file :load t)
+      (t ()
+        (setf *default-timezone* +utc-zone+)))))
+
+(defparameter *location-name->timezone* (make-hash-table :test 'equal)
+  "A hashtable with entries like \"Europe/Budapest\" -> timezone-instance")
+
+(defparameter *abbreviated-subzone-name->timezone-list* (make-hash-table :test 'equal)
+  "A hashtable of \"CEST\" -> list of timezones with \"CEST\" subzone")
+
+(defun find-timezone-by-location-name (name)
+  (when (zerop (hash-table-count *location-name->timezone*))
+    (error "Seems like the timezone repository has not yet been loaded. Hint: see REREAD-TIMEZONE-REPOSITORY."))
+  (gethash name *location-name->timezone*))
+
+(defun timezone= (timezone-1 timezone-2)
+  "Return two values indicating the relationship between timezone-1 and timezone-2. The first value is whether the two timezones are equal and the second value indicates whether it is sure or not.
+
+In other words:
+\(values t t) means timezone-1 and timezone-2 are definitely equal.
+\(values nil t) means timezone-1 and timezone-2 are definitely different.
+\(values nil nil) means that it couldn't be determined."
+  (if (or (eq timezone-1 timezone-2)
+          (equalp timezone-1 timezone-2))
+      (values t t)
+      (values nil nil)))
+
+(defun reread-timezone-repository (&key (timezone-repository *default-timezone-repository-path*))
+  (check-type timezone-repository (or pathname string))
+  (let ((root-directory (fad:directory-exists-p timezone-repository)))
+    (unless root-directory
+      (error "REREAD-TIMEZONE-REPOSITORY was called with invalid PROJECT-DIRECTORY (~A)."
+             timezone-repository))
+    (let ((cutoff-position (length (princ-to-string root-directory))))
+      (flet ((visitor (file)
+               (handler-case
+                   (let* ((full-name (subseq (princ-to-string file) cutoff-position))
+                          (name (pathname-name file))
+                          (timezone (%realize-timezone (make-timezone :path file :name name))))
+                     (setf (gethash full-name *location-name->timezone*) timezone)
+                     (map nil (lambda (subzone)
+                                (push timezone (gethash (subzone-abbrev subzone)
+                                                        *abbreviated-subzone-name->timezone-list*)))
+                          (timezone-subzones timezone)))
+                 (invalid-timezone-file () nil))))
+        (setf *location-name->timezone* (make-hash-table :test 'equal))
+        (setf *abbreviated-subzone-name->timezone-list* (make-hash-table :test 'equal))
+        (cl-fad:walk-directory root-directory #'visitor :directories nil
+                               :test (lambda (file)
+                                       (not (find "Etc" (pathname-directory file) :test #'string=)))
+                               :follow-symlinks nil)
+        (cl-fad:walk-directory (merge-pathnames "Etc/" root-directory) #'visitor :directories nil)))))
+
+(defmacro make-timestamp (&rest args)
+  `(make-instance 'timestamp ,@args))
+
+(defun clone-timestamp (timestamp)
+  (make-instance 'timestamp
+                 :nsec (nsec-of timestamp)
+                 :sec (sec-of timestamp)
+                 :day (day-of timestamp)))
+
+(defun transition-position (needle haystack)
+  (declare (type integer needle)
+           (type (simple-array integer (*)) haystack))
+  (loop
+     with start = 0
+     with end = (1- (length haystack))
+     for middle = (floor (+ end start) 2)
+     while (and (< start end)
+                (/= needle (elt haystack middle)))
+     do (cond
+          ((> needle (elt haystack middle))
+           (setf start (1+ middle)))
+          (t
+           (setf end (1- middle))))
+     finally
+       (return (max 0 (cond
+                        ((minusp end)
+                         0)
+                        ((= needle (elt haystack middle))
+                         middle)
+                        ((>= needle (elt haystack end))
+                         end)
+                        (t
+                         (1- end)))))))
+
+(defun timestamp-subtimezone (timestamp timezone)
+  "Return as multiple values the time zone as the number of seconds east of UTC, a boolean daylight-saving-p, and the customary abbreviation of the timezone."
+  (declare (type timestamp timestamp)
+           (type (or null timezone) timezone))
+  (let* ((zone (%realize-timezone (or timezone *default-timezone*)))
+         (unix-time (timestamp-to-unix timestamp))
+         (subzone-idx (if (zerop (length (timezone-indexes zone)))
+                          0
+                          (elt (timezone-indexes zone)
+                               (transition-position unix-time
+                                                   (timezone-transitions zone)))))
+         (subzone (elt (timezone-subzones zone) subzone-idx)))
+    (values
+     (subzone-offset subzone)
+     (subzone-daylight-p subzone)
+     (subzone-abbrev subzone))))
+
+(defun %adjust-to-offset (sec day offset)
+  "Returns two values, the values of new DAY and SEC slots of the timestamp adjusted to the given timezone."
+  (declare (type integer sec day offset))
+  (multiple-value-bind (offset-day offset-sec)
+      (truncate offset +seconds-per-day+)
+    (let* ((new-sec (+ sec offset-sec))
+           (new-day (+ day offset-day)))
+      (cond ((minusp new-sec)
+             (incf new-sec +seconds-per-day+)
+             (decf new-day))
+            ((>= new-sec +seconds-per-day+)
+             (incf new-day)
+             (decf new-sec +seconds-per-day+)))
+      (values new-sec new-day))))
+
+(defun %adjust-to-timezone (source timezone &optional offset)
+  (%adjust-to-offset (sec-of source)
+                     (day-of source)
+                     (or offset
+                         (timestamp-subtimezone source timezone))))
+
+(defun timestamp-minimize-part (timestamp part &key
+                                (timezone *default-timezone*)
+                                into)
+  (let* ((timestamp-parts '(:nsec :sec :min :hour :day :month))
+         (part-count (position part timestamp-parts)))
+    (assert part-count nil
+            "timestamp-minimize-part called with invalid part ~a (expected one of ~a)"
+            part
+            timestamp-parts)
+    (multiple-value-bind (nsec sec min hour day month year day-of-week daylight-saving-time-p offset)
+        (decode-timestamp timestamp :timezone timezone)
+      (declare (ignore nsec day-of-week daylight-saving-time-p))
+      (encode-timestamp 0
+                        (if (> part-count 0) 0 sec)
+                        (if (> part-count 1) 0 min)
+                        (if (> part-count 2) 0 hour)
+                        (if (> part-count 3) 1 day)
+                        (if (> part-count 4) 1 month)
+                        year
+                        :offset (if timezone nil offset)
+                        :timezone timezone
+                        :into into))))
+
+(defun timestamp-maximize-part (timestamp part &key
+                                (timezone *default-timezone*)
+                                into)
+  (let* ((timestamp-parts '(:nsec :sec :min :hour :day :month))
+         (part-count (position part timestamp-parts)))
+    (assert part-count nil
+            "timestamp-maximize-part called with invalid part ~a (expected one of ~a)"
+            part
+            timestamp-parts)
+    (multiple-value-bind (nsec sec min hour day month year day-of-week daylight-saving-time-p offset)
+        (decode-timestamp timestamp :timezone timezone)
+      (declare (ignore nsec day-of-week daylight-saving-time-p))
+      (let ((month (if (> part-count 4) 12 month)))
+        (encode-timestamp 999999999
+                          (if (> part-count 0) 59 sec)
+                          (if (> part-count 1) 59 min)
+                          (if (> part-count 2) 23 hour)
+                          (if (> part-count 3) (days-in-month month year) day)
+                          month
+                          year
+                          :offset (if timezone nil offset)
+                          :timezone timezone
+                          :into into)))))
+
+(defmacro with-decoded-timestamp ((&key nsec sec minute hour day month year day-of-week daylight-p timezone offset)
+                                   timestamp &body forms)
+  "This macro binds variables to the decoded elements of TIMESTAMP. The TIMEZONE argument is used for decoding the timestamp, and is not bound by the macro. The value of DAY-OF-WEEK starts from 0 which means Sunday."
+  (let ((ignores)
+        (types)
+        (variables))
+    (macrolet ((initialize (&rest vars)
+                 `(progn
+                    ,@(loop
+                         :for var :in vars
+                         :collect `(progn
+                                     (unless ,var
+                                       (setf ,var (gensym))
+                                       (push ,var ignores))
+                                     (push ,var variables)))
+                    (setf ignores (nreverse ignores))
+                    (setf variables (nreverse variables))))
+               (declare-fixnum-type (&rest vars)
+                 `(progn
+                    ,@(loop
+                         :for var :in vars
+                         :collect `(when ,var
+                                     (push `(type fixnum ,,var) types)))
+                    (setf types (nreverse types)))))
+      (when nsec
+        (push `(type (integer 0 999999999) ,nsec) types))
+      (declare-fixnum-type sec minute hour day month year)
+      (initialize nsec sec minute hour day month year day-of-week daylight-p))
+    `(multiple-value-bind (,@variables)
+         (decode-timestamp ,timestamp :timezone ,(or timezone '*default-timezone*) :offset ,offset)
+       (declare (ignore ,@ignores) ,@types)
+       ,@forms)))
+
+(defun %normalize-month-year-pair (month year)
+  "Normalizes the month/year pair: in case month is < 1 or > 12 the month and year are corrected to handle the overflow."
+  (multiple-value-bind (year-offset month-minus-one)
+      (floor (1- month) 12)
+    (values (1+ month-minus-one)
+            (+ year year-offset))))
+
+(defun days-in-month (month year)
+  "Returns the number of days in the given month of the specified year."
+  (let ((normal-days (aref +rotated-month-days-without-leap-day+
+                           (mod (+ month 9) 12))))
+    (if (and (= month 2)
+             (or (and (zerop (mod year 4))
+                      (plusp (mod year 100)))
+                 (zerop (mod year 400))))
+        (1+ normal-days)                ; February on a leap year
+        normal-days)))
+
+;; TODO scan all uses of FIX-OVERFLOW-IN-DAYS and decide where it's ok to silently fix and where should be and error reported
+(defun %fix-overflow-in-days (day month year)
+  "In case the day number is higher than the maximal possible for the given month/year pair, returns the last day of the month."
+  (let ((max-day (days-in-month month year)))
+    (if (> day max-day)
+        max-day
+        day)))
+
+(eval-when (:compile-toplevel :load-toplevel)
+  (defun %list-length= (num list)
+    "Tests for a list of length NUM without traversing the entire list to get the length."
+    (let ((c (nthcdr (1- num) list)))
+      (and c (endp (cdr c)))))
+
+  (defun %expand-adjust-timestamp-changes (timestamp changes visitor)
+    (loop
+      :with params = ()
+      :with functions = ()
+      :for change in changes
+      :do
+         (progn
+           (assert (or
+                    (%list-length= 3 change)
+                    (and (%list-length= 2 change)
+                         (symbolp (first change))
+                         (or (string= (first change) :timezone)
+                             (string= (first change) :utc-offset)))
+                    (and (%list-length= 4 change)
+                         (symbolp (third change))
+                         (or (string= (third change) :to)
+                             (string= (third change) :by))))
+                   nil "Syntax error in expression ~S" change)
+           (let ((operation (first change))
+                 (part (second change))
+                 (value (if (%list-length= 3 change)
+                            (third change)
+                            (fourth change))))
+             (cond
+               ((string= operation :set)
+                (push `(%set-timestamp-part ,part ,value) functions))
+               ((string= operation :offset)
+                (push `(%offset-timestamp-part ,part ,value) functions))
+               ((string= operation :utc-offset)
+                (push part params)
+                (push :utc-offset params))
+               ((string= operation :timezone)
+                (push part params)
+                (push :timezone params))
+               (t (error "Unexpected operation ~S" operation)))))
+      :finally
+         (loop
+           :for (function part value) in functions
+           :do
+           (funcall visitor `(,function ,timestamp ,part ,value ,@params)))))
+
+  (defun %expand-adjust-timestamp (timestamp changes &key functional)
+    (let* ((old (gensym "OLD"))
+           (new (if functional
+                    (gensym "NEW")
+                    old))
+           (forms (list)))
+      (%expand-adjust-timestamp-changes old changes
+                                        (lambda (change)
+                                          (push
+                                           `(progn
+                                              (multiple-value-bind (nsec sec day)
+                                                  ,change
+                                                (setf (nsec-of ,new) nsec)
+                                                (setf (sec-of ,new) sec)
+                                                (setf (day-of ,new) day))
+                                              ,@(when functional
+                                                      `((setf ,old ,new))))
+                                           forms)))
+      (setf forms (nreverse forms))
+      `(let* ((,old ,timestamp)
+              ,@(when functional
+                      `((,new (clone-timestamp ,old)))))
+         ,@forms
+         ,old)))
+  )                                     ; eval-when
+
+(defmacro adjust-timestamp (timestamp &body changes)
+  (%expand-adjust-timestamp timestamp changes :functional t))
+
+(defmacro adjust-timestamp! (timestamp &body changes)
+  (%expand-adjust-timestamp timestamp changes :functional nil))
+
+(defun %set-timestamp-part (time part new-value &key (timezone *default-timezone*) utc-offset)
+  ;; TODO think about error signalling. when, how to disable if it makes sense, ...
+  (case part
+    ((:nsec :sec-of-day :day)
+     (let ((nsec (nsec-of time))
+           (sec (sec-of time))
+           (day (day-of time)))
+       (case part
+         (:nsec (setf nsec (coerce new-value '(integer 0 999999999))))
+         (:sec-of-day (setf sec (coerce new-value `(integer 0 ,+seconds-per-day+))))
+         (:day (setf day new-value)))
+       (values nsec sec day)))
+    (otherwise
+     (with-decoded-timestamp (:nsec nsec :sec sec :minute minute :hour hour
+                              :day day :month month :year year :timezone timezone :offset utc-offset)
+         time
+       (ecase part
+         (:sec (setf sec new-value))
+         (:minute (setf minute new-value))
+         (:hour (setf hour new-value))
+         (:day-of-month (setf day new-value))
+         (:month (setf month new-value)
+                 (setf day (%fix-overflow-in-days day month year)))
+         (:year (setf year new-value)
+                (setf day (%fix-overflow-in-days day month year))))
+       (encode-timestamp-into-values nsec sec minute hour day month year :timezone timezone :offset utc-offset)))))
+
+(defun %offset-timestamp-part (time part offset &key (timezone *default-timezone*) utc-offset)
+  "Returns a time adjusted by the specified OFFSET. Takes care of
+different kinds of overflows. The setting :day-of-week is possible
+using a keyword symbol name of a week-day (see
++DAY-NAMES-AS-KEYWORDS+) as value. In that case point the result to
+day given by OFFSET in the week that contains TIME."
+  (labels ((direct-adjust (part offset nsec sec day)
+             (cond ((eq part :day-of-week)
+                    (with-decoded-timestamp (:day-of-week day-of-week
+                                                          :nsec nsec :sec sec :minute minute :hour hour
+                                                          :day day :month month :year year
+                                                          :timezone timezone :offset utc-offset)
+                      time
+                      (let ((position (position offset +day-names-as-keywords+ :test #'eq)))
+                        (assert position (position) "~S is not a valid day name" offset)
+                        (let ((offset (+ (- (if (zerop day-of-week)
+                                                7
+                                                day-of-week))
+                                         position)))
+                          (incf day offset)
+                          (cond
+                            ((< day 1)
+                             (decf month)
+                             (when (< month 1)
+                               (setf month 12)
+                               (decf year))
+                             (setf day (+ (days-in-month month year) day)))
+                            ((let ((days-in-month (days-in-month month year)))
+                               (when (< days-in-month day)
+                                 (incf month)
+                                 (when (= month 13)
+                                   (setf month 1)
+                                   (incf year))
+                                 (decf day days-in-month)))))
+                          (encode-timestamp-into-values nsec sec minute hour day month year
+                                                        :timezone timezone :offset utc-offset)))))
+                   ((zerop offset)
+                    ;; The offset is zero, so just return the parts of the timestamp object
+                    (values nsec sec day))
+                   (t
+                    (let ((old-utc-offset (or utc-offset
+                                              (timestamp-subtimezone time timezone)))
+                          new-utc-offset)
+                      (tagbody
+                       top
+                         (ecase part
+                           (:nsec
+                            (multiple-value-bind (sec-offset new-nsec)
+                                (floor (+ offset nsec) 1000000000)
+                              ;; the time might need to be adjusted a bit more if q != 0
+                              (setf part :sec
+                                    offset sec-offset
+                                    nsec new-nsec)
+                              (go top)))
+                           ((:sec :minute :hour)
+                            (multiple-value-bind (days-offset new-sec)
+                                (floor (+ sec (* offset (ecase part
+                                                          (:sec 1)
+                                                          (:minute +seconds-per-minute+)
+                                                          (:hour +seconds-per-hour+))))
+                                       +seconds-per-day+)
+                              (return-from direct-adjust (values nsec new-sec (+ day days-offset)))))
+                           (:day
+                            (incf day offset)
+                            (setf new-utc-offset (or utc-offset
+                                                     (timestamp-subtimezone (make-timestamp :nsec nsec :sec sec :day day)
+                                                                            timezone)))
+                            (when (not (= old-utc-offset
+                                          new-utc-offset))
+                              ;; We hit the DST boundary. We need to restart again
+                              ;; with :sec, but this time we know both old and new
+                              ;; UTC offset will be the same, so it's safe to do
+                              (setf part :sec
+                                    offset (- old-utc-offset
+                                              new-utc-offset)
+                                    old-utc-offset new-utc-offset)
+                              (go top))
+                            (return-from direct-adjust (values nsec sec day)))))))))
+
+           (safe-adjust (part offset time)
+             (with-decoded-timestamp (:nsec nsec :sec sec :minute minute :hour hour :day day
+                                            :month month :year year :timezone timezone :offset utc-offset)
+               time
+               (multiple-value-bind (month-new year-new)
+                   (%normalize-month-year-pair
+                    (+ (ecase part
+                         (:month offset)
+                         (:year (* 12 offset)))
+                       month)
+                    year)
+                 ;; Almost there. However, it is necessary to check for
+                 ;; overflows first
+                 (encode-timestamp-into-values nsec sec minute hour
+                                               (%fix-overflow-in-days day month-new year-new)
+                                               month-new year-new
+                                               :timezone timezone :offset utc-offset)))))
+    (ecase part
+      ((:nsec :sec :minute :hour :day :day-of-week)
+       (direct-adjust part offset
+                      (nsec-of time)
+                      (sec-of time)
+                      (day-of time)))
+      ((:month :year) (safe-adjust part offset time)))))
+
+;; TODO merge this functionality into timestamp-difference
+(defun timestamp-whole-year-difference (time-a time-b)
+  "Returns the number of whole years elapsed between time-a and time-b (hint: anniversaries)."
+  (declare (type timestamp time-b time-a))
+  (multiple-value-bind (nsec-b sec-b minute-b hour-b day-b month-b year-b day-of-week-b daylight-p-b offset-b)
+      (decode-timestamp time-b)
+    (declare (ignore day-of-week-b daylight-p-b))
+    (multiple-value-bind (nsec-a sec-a minute-a hour-a day-a month-a year-a)
+        (decode-timestamp time-a)
+      (declare (ignore nsec-a sec-a minute-a hour-a day-a month-a))
+      (let ((year-difference (- year-a year-b)))
+        (if (timestamp<= (encode-timestamp nsec-b sec-b minute-b hour-b
+                                           (if (= month-b 2)
+                                               (min 28 day-b)
+                                               day-b)
+                                           month-b
+                                           (+ year-difference year-b)
+                                           :offset offset-b)
+                         time-a)
+            year-difference
+            (1- year-difference))))))
+
+(defun timestamp-difference (time-a time-b)
+  "Returns the difference between TIME-A and TIME-B in seconds"
+  (let ((nsec (- (nsec-of time-a) (nsec-of time-b)))
+        (second (- (sec-of time-a) (sec-of time-b)))
+        (day (- (day-of time-a) (day-of time-b))))
+    (when (minusp nsec)
+      (decf second)
+      (incf nsec 1000000000))
+    (when (minusp second)
+      (decf day)
+      (incf second +seconds-per-day+))
+    (let ((result (+ (* day +seconds-per-day+)
+                     second)))
+      (unless (zerop nsec)
+        ;; this incf turns the result into a float, so only do this when necessary
+        (incf result (/ nsec 1000000000d0)))
+      result)))
+
+(defun timestamp+ (time amount unit &optional (timezone *default-timezone*) offset)
+  (multiple-value-bind (nsec sec day)
+      (%offset-timestamp-part time unit amount :timezone timezone :utc-offset offset)
+    (make-timestamp :nsec nsec
+                    :sec sec
+                    :day day)))
+
+(defun timestamp- (time amount unit &optional (timezone *default-timezone*) offset)
+  (timestamp+ time (- amount) unit timezone offset))
+
+(defun timestamp-day-of-week (timestamp &key (timezone *default-timezone*) offset)
+  (mod (+ 3 (nth-value 1 (%adjust-to-timezone timestamp timezone offset))) 7))
+
+;; TODO read
+;; http://java.sun.com/j2se/1.4.2/docs/api/java/util/GregorianCalendar.html
+;; (or something else, sorry :) this scheme only works back until
+;; 1582, the start of the gregorian calendar.  see also
+;; DECODE-TIMESTAMP when fixing if fixing is desired at all.
+(defun valid-timestamp-p (nsec sec minute hour day month year)
+  "Returns T if the time values refer to a valid time, otherwise returns NIL."
+  (and (<= 0 nsec 999999999)
+       (<= 0 sec 59)
+       (<= 0 minute 59)
+       (<= 0 hour 23)
+       (<= 1 month 12)
+       (<= 1 day (days-in-month month year))
+       (/= year 0)))
+
+(defun encode-timestamp-into-values (nsec sec minute hour day month year
+                                     &key (timezone *default-timezone*) offset)
+  "Returns (VALUES NSEC SEC DAY ZONE) ready to be used for
+instantiating a new timestamp object.  If the specified time is
+invalid, the condition INVALID-TIME-SPECIFICATION is raised."
+  ;; If the user provided an explicit offset, we use that.  Otherwise,
+  (declare (type integer nsec sec minute hour day month year)
+           (type (or integer null) offset))
+  (unless (valid-timestamp-p nsec sec minute hour day month year)
+    (error 'invalid-time-specification))
+  (let* ((0-based-rotated-month (if (>= month 3)
+                                    (- month 3)
+                                    (+ month 9)))
+         (internal-year (if (< month 3)
+                            (- year 2001)
+                            (- year 2000)))
+         (years-as-days (years-to-days internal-year))
+         (sec (+ (* hour +seconds-per-hour+)
+                 (* minute +seconds-per-minute+)
+                 sec))
+         (days-from-zero-point (+ years-as-days
+                                  (aref +rotated-month-offsets-without-leap-day+ 0-based-rotated-month)
+                                  (1- day)))
+         (used-offset (or offset
+                          (%guess-offset sec
+                                         days-from-zero-point
+                                         timezone))))
+    (multiple-value-bind (utc-sec utc-day)
+        (%adjust-to-offset sec days-from-zero-point (- used-offset))
+      (values nsec utc-sec utc-day))))
+
+(defun encode-timestamp (nsec sec minute hour day month year
+                         &key (timezone *default-timezone*) offset into)
+  "Return a new TIMESTAMP instance corresponding to the specified time
+elements."
+  (declare (type integer nsec sec minute hour day month year))
+  (multiple-value-bind (nsec sec day)
+      (encode-timestamp-into-values nsec sec minute hour day month year
+                                    :timezone timezone :offset offset)
+    (if into
+        (progn
+          (setf (nsec-of into) nsec)
+          (setf (sec-of into) sec)
+          (setf (day-of into) day)
+          into)
+        (make-timestamp
+         :nsec nsec
+         :sec sec
+         :day day))))
+
+(defun universal-to-timestamp (universal &key (nsec 0))
+  "Returns a timestamp corresponding to the given universal time."
+  ;; universal time is seconds from 1900-01-01T00:00:00Z.
+  (let ((adjusted-universal (- universal #.(encode-universal-time 0 0 0 1 3 2000 0))))
+    (multiple-value-bind (day second)
+        (floor adjusted-universal +seconds-per-day+)
+      (make-timestamp :day day :sec second :nsec nsec))))
+
+(defun timestamp-to-universal (timestamp)
+  "Return the UNIVERSAL-TIME corresponding to the TIMESTAMP"
+  ;; universal time is seconds from 1900-01-01T00:00:00Z
+  (+ (* (day-of timestamp) +seconds-per-day+)
+     (sec-of timestamp)
+     #.(encode-universal-time 0 0 0 1 3 2000 0)))
+
+(defun unix-to-timestamp (unix &key (nsec 0))
+  "Return a TIMESTAMP corresponding to UNIX, which is the number of seconds since the unix epoch, 1970-01-01T00:00:00Z."
+  (multiple-value-bind (days secs)
+      (floor unix +seconds-per-day+)
+    (make-timestamp :day (- days 11017) :sec secs :nsec nsec)))
+
+(defun timestamp-values-to-unix (seconds day)
+  "Return the Unix time correspondint to the values used to encode a TIMESTAMP"
+  (+ (* (+ day 11017) +seconds-per-day+) seconds))
+
+(defun timestamp-to-unix (timestamp)
+  "Return the Unix time corresponding to the TIMESTAMP"
+  (declare (type timestamp timestamp))
+  (timestamp-values-to-unix (sec-of timestamp) (day-of timestamp)))
+
+#+(and allegro (not os-windows))
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  ;; Allegro common lisp requires some toplevel hoops through which to
+  ;; jump in order to call unix's gettimeofday properly.
+  (ff:def-foreign-type timeval
+      (:struct (tv_sec :long)
+               (tv_usec :long)))
+
+  (ff:def-foreign-call
+      (allegro-ffi-gettimeofday "gettimeofday")
+      ((timeval (* timeval))
+       ;; and do this to allow a 0 for NULL
+       (timezone :foreign-address))
+    :returning (:int fixnum)))
+
+#+(and allegro os-windows)
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  ;; Allegro common lisp requires some toplevel hoops through which to
+  ;; jump in order to call unix's gettimeofday properly.
+  (ff:def-foreign-type filetime
+      (:struct (|dwLowDateTime| :int)
+               (|dwHighDateTime| :int)))
+
+  (ff:def-foreign-call
+      (allegro-ffi-get-system-time-as-file-time "GetSystemTimeAsFileTime")
+      ((filetime (* filetime)))
+    :returning :void))
+
+#+(or (and allegro os-windows)
+      (and ccl windows))
+(defun filetime-to-current-time (low high)
+  "Convert a Windows time into (values sec nano-sec)."
+  (let* ((unix-epoch-filetime 116444736000000000)
+         (filetime (logior low (ash high 32)))
+         (filetime (- filetime unix-epoch-filetime)))
+    (multiple-value-bind (secs 100ns-periods)
+        (floor filetime #.(round 1e7))
+      (values secs (* 100ns-periods 100)))))
+
+#+(and lispworks (or linux darwin))
+(progn
+  (fli:define-c-typedef time-t :long)
+  (fli:define-c-typedef suseconds-t #+linux :long
+                                    #+darwin :int)
+
+  (fli:define-c-struct timeval
+    (tv-sec time-t)
+    (tv-usec suseconds-t))
+
+  (fli:define-foreign-function (gettimeofday/ffi "gettimeofday")
+      ((tv (:pointer (:struct timeval)))
+       (tz :pointer))
+    :result-type :int)
+
+  (defun lispworks-gettimeofday ()
+    (declare (optimize speed (safety 1)))
+    (fli:with-dynamic-foreign-objects ((tv (:struct timeval)))
+      (let ((ret (gettimeofday/ffi tv fli:*null-pointer*)))
+        (assert (zerop ret) nil "gettimeofday failed")
+        (let ((secs
+                (fli:foreign-slot-value tv 'tv-sec
+                                        :type 'time-t
+                                        :object-type '(:struct timeval)))
+              (usecs
+                (fli:foreign-slot-value tv 'tv-usec
+                                        :type 'suseconds-t
+                                        :object-type '(:struct timeval))))
+          (values secs (* 1000 usecs)))))))
+
+(defun %get-current-time ()
+  "Cross-implementation abstraction to get the current time measured from the unix epoch (1/1/1970). Should return (values sec nano-sec)."
+  #+(and allegro (not os-windows))
+  (flet ((allegro-gettimeofday ()
+           (let ((tv (ff:allocate-fobject 'timeval :c)))
+             (allegro-ffi-gettimeofday tv 0)
+             (let ((sec (ff:fslot-value-typed 'timeval :c tv 'tv_sec))
+                   (usec (ff:fslot-value-typed 'timeval :c tv 'tv_usec)))
+               (ff:free-fobject tv)
+               (values sec usec)))))
+    (multiple-value-bind (sec usec) (allegro-gettimeofday)
+      (values sec (* 1000 usec))))
+  #+(and allegro os-windows)
+  (let* ((ft (ff:allocate-fobject 'filetime :c)))
+    (allegro-ffi-get-system-time-as-file-time ft)
+    (let* ((low (ff:fslot-value-typed 'filetime :c ft '|dwLowDateTime|))
+           (high (ff:fslot-value-typed 'filetime :c ft '|dwHighDateTime|)))
+      (filetime-to-current-time low high)))
+  #+cmu
+  (multiple-value-bind (success? sec usec) (unix:unix-gettimeofday)
+    (assert success? () "unix:unix-gettimeofday reported failure?!")
+    (values sec (* 1000 usec)))
+  #+sbcl
+  (progn
+    #+#.(local-time::package-with-symbol? "SB-EXT" "GET-TIME-OF-DAY") ; available from sbcl 1.0.28.66
+    (multiple-value-bind (sec nsec) (sb-ext:get-time-of-day)
+      (values sec (* 1000 nsec)))
+    #-#.(local-time::package-with-symbol? "SB-EXT" "GET-TIME-OF-DAY") ; obsolete, scheduled to be deleted at the end of 2009
+    (multiple-value-bind (success? sec nsec) (sb-unix:unix-gettimeofday)
+      (assert success? () "sb-unix:unix-gettimeofday reported failure?!")
+      (values sec (* 1000 nsec))))
+  #+(and ccl (not windows))
+  (ccl:rlet ((tv :timeval))
+    (let ((err (ccl:external-call "gettimeofday" :address tv :address (ccl:%null-ptr) :int)))
+      (assert (zerop err) nil "gettimeofday failed")
+      (values (ccl:pref tv :timeval.tv_sec) (* 1000 (ccl:pref tv :timeval.tv_usec)))))
+  #+(and ccl windows)
+  (ccl:rlet ((time :<lpfiletime>))
+    (ccl:external-call "GetSystemTimeAsFileTime" :<lpfiletime> time :void)
+    (let* ((low (ccl:%get-unsigned-long time (/ 0 8)))
+           (high (ccl:%get-unsigned-long time (/ 32 8))))
+      (filetime-to-current-time low high)))
+  #+abcl
+  (multiple-value-bind (sec millis)
+      (truncate (java:jstatic "currentTimeMillis" "java.lang.System") 1000)
+    (values sec (* millis 1000000)))
+  #+(and lispworks (or linux darwin))
+  (lispworks-gettimeofday)
+  #-(or allegro cmu sbcl abcl ccl (and lispworks (or linux darwin)))
+  (values (- (get-universal-time)
+             ;; CL's get-universal-time uses an epoch of 1/1/1900, so adjust the result to the Unix epoch
+             #.(encode-universal-time 0 0 0 1 1 1970 0))
+          0))
+
+(defvar *clock* t
+  "Use the `*clock*' special variable if you need to define your own idea of the current time.
+
+The value of this variable should have the methods `local-time::clock-now', and
+`local-time::clock-today'. The currently supported values in local-time are:
+  t - use the standard clock
+  local-time:leap-second-adjusted - use a clock which adjusts for leap seconds using the information in *default-timezone*.")
+
+(defun now ()
+  "Returns a timestamp representing the present moment."
+  (clock-now *clock*))
+
+(defun today ()
+  "Returns a timestamp representing the present day."
+  (clock-today *clock*))
+
+(defgeneric clock-now (clock)
+  (:documentation "Returns a timestamp for the current time given a clock."))
+
+(defgeneric clock-today (clock)
+  (:documentation "Returns a timestamp for the current date given a
+  clock.  The date is encoded by convention as a timestamp with the
+  time set to 00:00:00UTC."))
+
+(defun %leap-seconds-offset (leap-seconds sec)
+  "Find the latest leap second adjustment effective at SEC system time."
+  (elt (leap-seconds-adjustment leap-seconds)
+       (transition-position sec (leap-seconds-sec leap-seconds))))
+
+(defun %adjust-sec-for-leap-seconds (sec)
+  "Ajdust SEC from system time to Unix time (on systems those clock does not jump back over leap seconds)."
+  (let ((leap-seconds (timezone-leap-seconds (%realize-timezone *default-timezone*))))
+    (when leap-seconds
+      (decf sec (%leap-seconds-offset leap-seconds sec))))
+  sec)
+
+(defmethod clock-now ((clock (eql 'leap-second-adjusted)))
+  (multiple-value-bind (sec nsec) (%get-current-time)
+    (unix-to-timestamp (%adjust-sec-for-leap-seconds sec)
+                       :nsec nsec)))
+
+(defmethod clock-now (clock)
+  (declare (ignore clock))
+  (multiple-value-bind (sec nsec) (%get-current-time)
+    (unix-to-timestamp sec :nsec nsec)))
+
+(defmethod clock-today (clock)
+  (declare (ignore clock))
+  ;; TODO should return a date value, anyhow we will decide to represent it eventually
+  (let ((result (now)))
+    (setf (sec-of result) 0)
+    (setf (nsec-of result) 0)
+    result))
+
+(defmacro %defcomparator (name &body body)
+  (let ((pair-comparator-name (intern (concatenate 'string "%" (string name)))))
+    `(progn
+      (declaim (inline ,pair-comparator-name))
+      (defun ,pair-comparator-name (time-a time-b)
+        (assert (typep time-a 'timestamp)
+                nil
+                'type-error
+                :datum time-a
+                :expected-type 'timestamp)
+        (assert (typep time-b 'timestamp)
+                nil
+                'type-error
+                :datum time-b
+                :expected-type 'timestamp)
+        ,@body)
+      (defun ,name (&rest times)
+        (declare (dynamic-extent times))
+        (loop for head on times
+              while (cdr head)
+              always (,pair-comparator-name (first head) (second head))))
+      (define-compiler-macro ,name (&rest times)
+        (let ((vars (loop
+                      :for i :upfrom 0 :below (length times)
+                      :collect (gensym (concatenate 'string "TIME-" (princ-to-string i) "-")))))
+          `(let (,@(loop
+                     :for var :in vars
+                     :for time :in times
+                     :collect (list var time)))
+            ;; we could evaluate comparisons of timestamp literals here
+            (and ,@(loop
+                     :for (time-a time-b) :on vars
+                     :while time-b
+                     :collect `(,',pair-comparator-name ,time-a ,time-b)))))))))
+
+(defun %timestamp-compare (time-a time-b)
+  "Returns the symbols <, >, or =, describing the relationship between TIME-A and TIME-b."
+  (declare (type timestamp time-a time-b))
+  (cond
+    ((< (day-of time-a) (day-of time-b)) '<)
+    ((> (day-of time-a) (day-of time-b)) '>)
+    ((< (sec-of time-a) (sec-of time-b)) '<)
+    ((> (sec-of time-a) (sec-of time-b)) '>)
+    ((< (nsec-of time-a) (nsec-of time-b)) '<)
+    ((> (nsec-of time-a) (nsec-of time-b)) '>)
+    (t '=)))
+
+(%defcomparator timestamp<
+  (eql (%timestamp-compare time-a time-b) '<))
+
+(%defcomparator timestamp<=
+  (not (null (member (%timestamp-compare time-a time-b) '(< =)))))
+
+(%defcomparator timestamp>
+  (eql (%timestamp-compare time-a time-b) '>))
+
+(%defcomparator timestamp>=
+  (not (null (member (%timestamp-compare time-a time-b) '(> =)))))
+
+(%defcomparator timestamp=
+  (eql (%timestamp-compare time-a time-b) '=))
+
+(defun timestamp/= (&rest timestamps)
+  "Returns T if no pair of timestamps is equal. Otherwise return NIL."
+  (declare (dynamic-extent timestamps))
+  (loop for ts-head on timestamps do
+       (loop for ts in (rest ts-head) do
+            (when (timestamp= (car ts-head) ts)
+              (return-from timestamp/= nil))))
+  t)
+
+(defun contest (test list)
+  "Applies TEST to pairs of elements in list, keeping the element which last tested T.  Returns the winning element."
+  (reduce (lambda (a b) (if (funcall test a b) a b)) list))
+
+(defun timestamp-minimum (time &rest times)
+  "Returns the earliest timestamp"
+  (contest #'timestamp< (cons time times)))
+
+(defun timestamp-maximum (time &rest times)
+  "Returns the latest timestamp"
+  (contest #'timestamp> (cons time times)))
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (defun years-to-days (years)
+    "Given a number of years, returns the number of days in those years."
+    (let* ((days (* years 365))
+           (l1 (floor years 4))
+           (l2 (floor years 100))
+           (l3 (floor years 400)))
+      (+ days l1 (- l2) l3))))
+
+(defun days-to-years (days)
+  "Given a number of days, returns the number of years and the remaining days in that year."
+  (let ((remaining-days days))
+    (multiple-value-bind (400-years remaining-days)
+        (floor remaining-days #.(years-to-days 400))
+      (let* ((100-years (min (floor remaining-days #.(years-to-days 100)) 3))
+             (remaining-days (- remaining-days
+                                (* 100-years #.(years-to-days 100)))))
+        (multiple-value-bind (4-years remaining-days)
+            (floor remaining-days #.(years-to-days 4))
+          (let ((years (min 3 (floor remaining-days #.(years-to-days 1)))))
+            (values (+ (* 400-years 400)
+                       (* 100-years 100)
+                       (* 4-years 4)
+                       years)
+                    (- remaining-days (* years 365))))))))
+  ;; the above is the macroexpansion of the following. uses metabang BIND, but kept for clarity because the expansion is unreadable.
+  #+nil
+  (bind ((remaining-days days)
+         ((values 400-years remaining-days) (floor remaining-days #.(years-to-days 400)))
+         (100-years (min (floor remaining-days #.(years-to-days 100))
+                         3))
+         (remaining-days (- remaining-days
+                            (* 100-years
+                               #.(years-to-days 100))))
+         ((values 4-years remaining-days) (floor remaining-days #.(years-to-days 4)))
+         (years (min (floor remaining-days 365)
+                     3)))
+        (values (+ (* 400-years 400)
+                   (* 100-years 100)
+                   (* 4-years 4)
+                   years)
+                (- remaining-days (* years 365)))))
+
+(defun %timestamp-decode-date (days)
+  "Returns the year, month, and day, given the number of days from the epoch."
+  (declare (type integer days))
+  (multiple-value-bind (years remaining-days)
+      (days-to-years days)
+    (let* ((leap-day-p (= remaining-days 365))
+           (rotated-1-based-month (if leap-day-p
+                                      12 ; march is the first month and february is the last
+                                      (position remaining-days +rotated-month-offsets-without-leap-day+ :test #'<)))
+           (1-based-month (if (>= rotated-1-based-month 11)
+                              (- rotated-1-based-month 10)
+                              (+ rotated-1-based-month 2)))
+           (1-based-day (if leap-day-p
+                            29
+                            (1+ (- remaining-days (aref +rotated-month-offsets-without-leap-day+
+                                                        (1- rotated-1-based-month)))))))
+      (values
+       (+ years
+          (if (>= rotated-1-based-month 11) ; january is in the next year
+              2001
+              2000))
+       1-based-month
+       1-based-day))))
+
+(defun %timestamp-decode-iso-week (timestamp)
+  "Returns the year, week number, and day of week components of an ISO week date."
+  ;; Algorithm from http://en.wikipedia.org/wiki/Talk:ISO_week_date#Algorithms
+  (let* ((dn (timestamp-day-of-week timestamp))
+         (day-of-week (if (zerop dn) 7 dn)) ; ISO weekdays are Monday=1 and Sunday=7
+         (nearest-thursday (timestamp+ timestamp (- 4 day-of-week) :day))
+         (year (timestamp-year nearest-thursday))
+         (month (timestamp-month nearest-thursday))
+         (day (timestamp-day nearest-thursday))
+         (ordinal-day (- (day-of (encode-timestamp 0 0 0 0 day month year :timezone +utc-zone+))
+                         (day-of (encode-timestamp 0 0 0 0 1 1 year :timezone +utc-zone+)))))
+    (values year
+            (1+ (floor ordinal-day 7))
+            day-of-week)))
+
+(defun %timestamp-decode-time (seconds)
+  "Returns the hours, minutes, and seconds, given the number of seconds since midnight."
+  (declare (type integer seconds))
+  (multiple-value-bind (hours hour-remainder)
+      (floor seconds +seconds-per-hour+)
+    (multiple-value-bind (minutes seconds)
+        (floor hour-remainder +seconds-per-minute+)
+      (values
+       hours
+       minutes
+       seconds))))
+
+(defun decode-timestamp (timestamp &key (timezone *default-timezone*) offset)
+  "Returns the decoded time as multiple values: nsec, ss, mm, hh, day, month, year, day-of-week"
+  (declare (type timestamp timestamp))
+  (let ((timezone (if offset (the timezone +none-zone+) timezone)))
+    (multiple-value-bind (offset* daylight-p abbreviation)
+        (timestamp-subtimezone timestamp timezone)
+      (multiple-value-bind (adjusted-secs adjusted-days)
+          (%adjust-to-timezone timestamp timezone offset)
+        (multiple-value-bind (hours minutes seconds)
+            (%timestamp-decode-time adjusted-secs)
+          (multiple-value-bind (year month day)
+              (%timestamp-decode-date adjusted-days)
+            (values
+             (nsec-of timestamp)
+             seconds minutes hours
+             day month year
+             (timestamp-day-of-week timestamp :timezone timezone :offset offset)
+             daylight-p
+             (or offset offset*)
+             abbreviation)))))))
+
+(defun timestamp-year (timestamp &key (timezone *default-timezone*))
+  "Returns the cardinal year upon which the timestamp falls."
+  (nth-value 0
+             (%timestamp-decode-date
+              (nth-value 1 (%adjust-to-timezone timestamp timezone)))))
+
+(defun timestamp-century (timestamp &key (timezone *default-timezone*))
+  "Returns the ordinal century upon which the timestamp falls."
+  (let* ((year (timestamp-year timestamp :timezone timezone))
+         (sign (signum year)))
+    (+ sign
+       (* sign
+          (truncate (1- (abs year)) 100)))))
+
+(defun timestamp-millennium (timestamp &key (timezone *default-timezone*))
+  "Returns the ordinal millennium upon which the timestamp falls."
+  (let* ((year (timestamp-year timestamp :timezone timezone))
+         (sign (signum year)))
+    (+ sign
+       (* sign
+          (truncate (1- (abs year)) 1000)))))
+
+(defun timestamp-decade (timestamp &key (timezone *default-timezone*))
+  "Returns the cardinal decade upon which the timestamp falls."
+  (truncate (timestamp-year timestamp :timezone timezone) 10))
+
+(defun timestamp-month (timestamp &key (timezone *default-timezone*))
+  "Returns the month upon which the timestamp falls."
+  (nth-value 1
+             (%timestamp-decode-date
+              (nth-value 1 (%adjust-to-timezone timestamp timezone)))))
+
+(defun timestamp-day (timestamp &key (timezone *default-timezone*))
+  "Returns the day of the month upon which the timestamp falls."
+  (nth-value 2
+             (%timestamp-decode-date
+              (nth-value 1 (%adjust-to-timezone timestamp timezone)))))
+
+(defun timestamp-hour (timestamp &key (timezone *default-timezone*))
+  (nth-value 0
+             (%timestamp-decode-time
+              (nth-value 0 (%adjust-to-timezone timestamp timezone)))))
+
+(defun timestamp-minute (timestamp &key (timezone *default-timezone*))
+  (nth-value 1
+             (%timestamp-decode-time
+              (nth-value 0 (%adjust-to-timezone timestamp timezone)))))
+
+(defun timestamp-second (timestamp &key (timezone *default-timezone*))
+  (nth-value 2
+             (%timestamp-decode-time
+              (nth-value 0 (%adjust-to-timezone timestamp timezone)))))
+
+(defun timestamp-microsecond (timestamp)
+  (floor (nsec-of timestamp) 1000))
+
+(defun timestamp-millisecond (timestamp)
+  (floor (nsec-of timestamp) 1000000))
+
+(defun split-timestring (str &rest args)
+  (declare (inline))
+  (apply #'%split-timestring (coerce str 'simple-string) args))
+
+(defun %split-timestring (time-string &key
+                          (start 0)
+                          (end (length time-string))
+                          (fail-on-error t) (time-separator #\:)
+                          (date-separator #\-)
+                          (date-time-separator #\T)
+                          (allow-missing-elements t)
+                          (allow-missing-date-part allow-missing-elements)
+                          (allow-missing-time-part allow-missing-elements)
+                          (allow-missing-timezone-part allow-missing-time-part))
+  "Based on http://www.ietf.org/rfc/rfc3339.txt including the function names used. Returns (values year month day hour minute second nsec offset-hour offset-minute). On parsing failure, signals INVALID-TIMESTRING if FAIL-ON-ERROR is NIL, otherwise returns NIL."
+  (declare (type character date-time-separator time-separator date-separator)
+           (type simple-string time-string)
+           (optimize (speed 3)))
+  (the list
+    (let (year month day hour minute second nsec offset-hour offset-minute)
+      (declare (type (or null fixnum) start end year month day hour minute second offset-hour offset-minute)
+               (type (or null (signed-byte 32)) nsec))
+      (macrolet ((passert (expression)
+                   `(unless ,expression
+                     (parse-error ',expression)))
+                 (parse-integer-into (start-end place &optional low-limit high-limit)
+                   (let ((entry (gensym "ENTRY"))
+                         (value (gensym "VALUE"))
+                         (pos (gensym "POS"))
+                         (start (gensym "START"))
+                         (end (gensym "END")))
+                     `(let ((,entry ,start-end))
+                       (if ,entry
+                           (let ((,start (car ,entry))
+                                 (,end (cdr ,entry)))
+                             (multiple-value-bind (,value ,pos) (parse-integer time-string :start ,start :end ,end :junk-allowed t)
+                               (passert (= ,pos ,end))
+                               (setf ,place ,value)
+                               ,(if (and low-limit high-limit)
+                                    `(passert (<= ,low-limit ,place ,high-limit))
+                                    (values))
+                               (values)))
+                           (progn
+                             (passert allow-missing-elements)
+                             (values))))))
+                 (with-parts-and-count ((start end split-chars) &body body)
+                   `(multiple-value-bind (parts count) (split ,start ,end ,split-chars)
+                     (declare (ignorable count) (type fixnum count)
+                      ;;(type #1=(cons (cons fixnum fixnum) (or null #1#)) parts)
+                      (type list parts))
+                     ,@body)))
+        (labels ((split (start end chars)
+                   (declare (type fixnum start end))
+                   (unless (consp chars)
+                     (setf chars (list chars)))
+                   (loop with last-match = start
+                         with match-count of-type (integer 0 #.most-positive-fixnum) = 0
+                         for index of-type fixnum upfrom start
+                         while (< index end)
+                         when (member (aref time-string index) chars :test #'char-equal)
+                         collect (prog1 (if (< last-match index)
+                                            (cons last-match index)
+                                            nil)
+                                   (incf match-count)
+                                   (setf last-match (1+ index)))
+                                 into result
+                         finally (return (values (if (zerop (- index last-match))
+                                                     result
+                                                     (prog1
+                                                         (nconc result (list (cons last-match index)))
+                                                       (incf match-count)))
+                                                 match-count))))
+                 (parse ()
+                   (with-parts-and-count (start end date-time-separator)
+                     (cond ((= count 2)
+                            (if (first parts)
+                                (full-date (first parts))
+                                (passert allow-missing-date-part))
+                            (if (second parts)
+                                (full-time (second parts))
+                                (passert allow-missing-time-part))
+                            (done))
+                           ((and (= count 1)
+                                 allow-missing-date-part
+                                 (find time-separator time-string
+                                       :start (car (first parts))
+                                       :end (cdr (first parts))))
+                            (full-time (first parts))
+                            (done))
+                           ((and (= count 1)
+                                 allow-missing-time-part
+                                 (find date-separator time-string
+                                       :start (car (first parts))
+                                       :end (cdr (first parts))))
+                            (full-date (first parts))
+                            (done)))
+                     (parse-error nil)))
+                 (full-date (start-end)
+                   (let ((parts (split (car start-end) (cdr start-end) date-separator)))
+                     (passert (%list-length= 3 parts))
+                     (date-fullyear (first parts))
+                     (date-month (second parts))
+                     (date-mday (third parts))))
+                 (date-fullyear (start-end)
+                   (parse-integer-into start-end year))
+                 (date-month (start-end)
+                   (parse-integer-into start-end month 1 12))
+                 (date-mday (start-end)
+                   (parse-integer-into start-end day 1 31))
+                 (full-time (start-end)
+                   (let ((start (car start-end))
+                         (end (cdr start-end)))
+                     (with-parts-and-count (start end (list #\Z #\- #\+))
+                       (let* ((zulup (find #\Z time-string :test #'char-equal :start start :end end))
+                              (sign (unless zulup
+                                      (if (find #\+ time-string :test #'char-equal :start start :end end)
+                                          1
+                                          -1))))
+                         (passert (<= 1 count 2))
+                         (unless (and (eq (first parts) nil)
+                                      (not (rest parts)))
+                           ;; not a single #\Z
+                           (partial-time (first parts)))
+                         (when zulup
+                           (setf offset-hour 0
+                                 offset-minute 0))
+                         (if (= count 1)
+                             (passert (or zulup allow-missing-timezone-part))
+                             (let* ((entry (second parts))
+                                    (start (car entry))
+                                    (end (cdr entry)))
+                               (declare (type fixnum start end))
+                               (passert (or zulup
+                                            (not (zerop (- end start)))))
+                               (unless zulup
+                                 (time-offset (second parts) sign))))))))
+                 (partial-time (start-end)
+                   (with-parts-and-count ((car start-end) (cdr start-end) time-separator)
+                     (passert (eql count 3))
+                     (time-hour (first parts))
+                     (time-minute (second parts))
+                     (time-second (third parts))))
+                 (time-hour (start-end)
+                   (parse-integer-into start-end hour 0 23))
+                 (time-minute (start-end)
+                   (parse-integer-into start-end minute 0 59))
+                 (time-second (start-end)
+                   (with-parts-and-count ((car start-end) (cdr start-end) '(#\. #\,))
+                     (passert (<= 1 count 2))
+                     (let ((*read-eval* nil))
+                       (parse-integer-into (first parts) second 0 59)
+                       (if (> count 1)
+                           (let* ((start (car (second parts)))
+                                  (end (cdr (second parts))))
+                             (declare (type (integer 0 #.array-dimension-limit) start end))
+                             (passert (<= (- end start) 9))
+                             (let ((new-end (position #\0 time-string
+                                                      :test-not #'eql
+                                                      :start start
+                                                      :end end
+                                                      :from-end t)))
+                               (when new-end
+                                 (setf end (min (1+ new-end)))))
+                             (setf nsec (* (the (integer 0 999999999) (parse-integer time-string :start start :end end))
+                                           (aref #.(coerce #(1000000000 100000000 10000000
+                                                             1000000 100000 10000 1000 100 10 1)
+                                                           '(simple-array (signed-byte 32) (10)))
+                                                 (- end start)))))
+                           (setf nsec 0)))))
+                 (time-offset (start-end sign)
+                   (with-parts-and-count ((car start-end) (cdr start-end) time-separator)
+                     (passert (or (and allow-missing-timezone-part (zerop count))
+                                  (= count 1)
+                                  (= count 2)))
+
+                     (cond
+                       ((= count 2)
+                        ;; hh:mm offset
+                        (parse-integer-into (first parts) offset-hour 0 23)
+                        (parse-integer-into (second parts) offset-minute 0 59))
+                       ((= (- (cdar parts) (caar parts)) 4)
+                        ;; hhmm offset
+                        (parse-integer-into (cons (caar parts)
+                                                  (+ (caar parts) 2))
+                                            offset-hour 0 23)
+                        (parse-integer-into (cons (+ (caar parts) 2)
+                                                  (+ (caar parts) 4))
+                                            offset-minute 0 59))
+                       ((= (- (cdar parts) (caar parts)) 2)
+                        ;; hh offset
+                        (parse-integer-into (cons (caar parts)
+                                                  (+ (caar parts) 2))
+                                            offset-hour 0 23)
+                        (setf offset-minute 0)))
+
+                     (setf offset-hour (* offset-hour sign)
+                           offset-minute (* offset-minute sign))))
+                 (parse-error (failure)
+                   (if fail-on-error
+                       (error 'invalid-timestring :timestring time-string :failure failure)
+                       (return-from %split-timestring nil)))
+                 (done ()
+                   (return-from %split-timestring (list year month day hour minute second nsec offset-hour offset-minute))))
+          (parse))))))
+
+(defun parse-rfc3339-timestring (timestring &key (fail-on-error t)
+                                            (allow-missing-time-part nil))
+  (parse-timestring timestring :fail-on-error fail-on-error
+                    :allow-missing-timezone-part nil
+                    :allow-missing-time-part allow-missing-time-part
+                    :allow-missing-date-part nil))
+
+(defun parse-timestring (timestring &key
+                         start
+                         end
+                         (fail-on-error t)
+                         (time-separator #\:)
+                         (date-separator #\-)
+                         (date-time-separator #\T)
+                         (allow-missing-elements t)
+                         (allow-missing-date-part allow-missing-elements)
+                         (allow-missing-time-part allow-missing-elements)
+                         (allow-missing-timezone-part allow-missing-elements)
+                         (offset 0))
+  "Parse a timestring and return the corresponding TIMESTAMP.
+See split-timestring for details. Unspecified fields in the
+timestring are initialized to their lowest possible value,
+and timezone offset is 0 (UTC) unless explicitly specified
+in the input string."
+  (let ((parts (%split-timestring (coerce timestring 'simple-string)
+                                  :start (or start 0)
+                                  :end (or end (length timestring))
+                                  :fail-on-error fail-on-error
+                                  :time-separator time-separator
+                                  :date-separator date-separator
+                                  :date-time-separator date-time-separator
+                                  :allow-missing-elements allow-missing-elements
+                                  :allow-missing-date-part allow-missing-date-part
+                                  :allow-missing-time-part allow-missing-time-part
+                                  :allow-missing-timezone-part allow-missing-timezone-part)))
+    (when parts
+      (destructuring-bind (year month day hour minute second nsec offset-hour offset-minute)
+          parts
+        (encode-timestamp
+         (or nsec 0)
+         (or second 0)
+         (or minute 0)
+         (or hour 0)
+         (or day 1)
+         (or month 3)
+         (or year 2000)
+         :offset (if offset-hour
+                     (+ (* offset-hour 3600)
+                        (* (or offset-minute 0) 60))
+                     offset))))))
+
+(defun ordinalize (day)
+  "Return an ordinal string representing the position
+of DAY in a sequence (1st, 2nd, 3rd, 4th, etc)."
+  (declare (type (integer 1 31) day))
+  (format nil "~d~a" day
+          (if (<= 11 day 13)
+              "th"
+              (case (mod day 10)
+                (1 "st")
+                (2 "nd")
+                (3 "rd")
+                (t "th")))))
+
+(defun %construct-timestring (timestamp format timezone)
+  "Constructs a string representing TIMESTAMP given the FORMAT
+of the string and the TIMEZONE.
+See the documentation of FORMAT-TIMESTRING for the structure of FORMAT."
+  (declare (type timestamp timestamp)
+           (optimize (speed 3)))
+  (multiple-value-bind (nsec sec minute hour day month year weekday daylight-p offset abbrev)
+      (decode-timestamp timestamp :timezone timezone)
+    (declare (ignore daylight-p))
+    (multiple-value-bind (iso-year iso-week iso-weekday)
+        (%timestamp-decode-iso-week timestamp)
+      (let ((*print-pretty* nil)
+            (*print-circle* nil))
+        (with-output-to-string (result nil)
+          (dolist (fmt format)
+            (cond
+              ((member fmt '(:gmt-offset :gmt-offset-or-z :gmt-offset-hhmm))
+               (multiple-value-bind (offset-hours offset-secs)
+                   (floor offset +seconds-per-hour+)
+                 (declare (fixnum offset-hours offset-secs))
+                 (if (and (eql fmt :gmt-offset-or-z) (zerop offset))
+                     (princ #\Z result)
+                     (format result "~c~2,'0d~:[:~;~]~2,'0d"
+                             (if (minusp offset-hours) #\- #\+)
+                             (abs offset-hours)
+                             (eql fmt :gmt-offset-hhmm)
+                             (truncate (abs offset-secs)
+                                       +seconds-per-minute+)))))
+              ((eql fmt :short-year)
+               (princ (mod year 100) result))
+              ((eql fmt :long-month)
+               (princ (aref +month-names+ month) result))
+              ((eql fmt :short-month)
+               (princ (aref +short-month-names+ month) result))
+              ((eql fmt :long-weekday)
+               (princ (aref +day-names+ weekday) result))
+              ((eql fmt :short-weekday)
+               (princ (aref +short-day-names+ weekday) result))
+              ((eql fmt :minimal-weekday)
+               (princ (aref +minimal-day-names+ weekday) result))
+              ((eql fmt :timezone)
+               (princ abbrev result))
+              ((eql fmt :ampm)
+               (princ (if (< hour 12) "am" "pm") result))
+              ((eql fmt :ordinal-day)
+               (princ (ordinalize day) result))
+              ((or (stringp fmt) (characterp fmt))
+               (princ fmt result))
+              (t
+               (let ((val (ecase (if (consp fmt) (car fmt) fmt)
+                            (:nsec nsec)
+                            (:usec (floor nsec 1000))
+                            (:msec (floor nsec 1000000))
+                            (:sec sec)
+                            (:min minute)
+                            (:hour hour)
+                            (:hour12 (1+ (mod (1- hour) 12)))
+                            (:day day)
+                            (:weekday weekday)
+                            (:month month)
+                            (:year year)
+                            (:iso-week-year iso-year)
+                            (:iso-week-number iso-week)
+                            (:iso-week-day iso-weekday))))
+                 (cond
+                   ((atom fmt)
+                    (princ val result))
+                   ((minusp val)
+                    (format result "-~v,vd"
+                            (second fmt)
+                            (or (third fmt) #\0)
+                            (abs val)))
+                   (t
+                    (format result "~v,vd"
+                            (second fmt)
+                            (or (third fmt) #\0)
+                            val))))))))))))
+
+(defun format-timestring (destination timestamp &key
+                          (format +iso-8601-format+)
+                          (timezone *default-timezone*))
+  "Constructs a string representation of TIMESTAMP according
+to FORMAT and returns it.
+If destination is T, the string is written to *standard-output*.
+If destination is a stream, the string is written to the stream.
+
+FORMAT is a list containing one or more of strings, characters,
+and keywords. Strings and characters are output literally,
+while keywords are replaced by the values here:
+
+  :YEAR              *year
+  :MONTH             *numeric month
+  :DAY               *day of month
+  :HOUR              *hour
+  :MIN               *minutes
+  :SEC               *seconds
+  :WEEKDAY           *numeric day of week starting from index 0, which means Sunday
+  :MSEC              *milliseconds
+  :USEC              *microseconds
+  :NSEC              *nanoseconds
+  :ISO-WEEK-YEAR     *year for ISO week date (can be different from regular calendar year)
+  :ISO-WEEK-NUMBER   *ISO week number (i.e. 1 through 53)
+  :ISO-WEEK-DAY      *ISO compatible weekday number (monday=1, sunday=7)
+  :LONG-WEEKDAY      long form of weekday (e.g. Sunday, Monday)
+  :SHORT-WEEKDAY     short form of weekday (e.g. Sun, Mon)
+  :MINIMAL-WEEKDAY   minimal form of weekday (e.g. Su, Mo)
+  :SHORT-YEAR        short form of year (last 2 digits, e.g. 41, 42 instead of 2041, 2042)
+  :LONG-MONTH        long form of month (e.g. January, February)
+  :SHORT-MONTH       short form of month (e.g. Jan, Feb)
+  :HOUR12            *hour on a 12-hour clock
+  :AMPM              am/pm marker in lowercase
+  :GMT-OFFSET        the gmt-offset of the time, in +00:00 form
+  :GMT-OFFSET-OR-Z   like :GMT-OFFSET, but is Z when UTC
+  :GMT-OFFSET-HHMM   like :GMT-OFFSET, but in +0000 form
+  :TIMEZONE          timezone abbrevation for the time
+
+Elements marked by * can be placed in a list in the form
+  \(:keyword padding &optional \(padchar #\\0))
+
+The string representation of the value will be padded with the padchar.
+
+You can see examples in +ISO-8601-FORMAT+, +ASCTIME-FORMAT+, and +RFC-1123-FORMAT+."
+  (declare (type (or boolean stream) destination))
+  (let ((result (%construct-timestring timestamp format timezone)))
+    (when destination
+      (write-string result (if (eq t destination) *standard-output* destination)))
+    result))
+
+(defun format-rfc1123-timestring (destination timestamp &key
+                                  (timezone *default-timezone*))
+  (format-timestring destination timestamp
+                     :format +rfc-1123-format+
+                     :timezone timezone))
+
+(defun to-rfc1123-timestring (timestamp)
+  (format-rfc1123-timestring nil timestamp))
+
+(defun format-rfc3339-timestring (destination timestamp &key
+                                  omit-date-part
+                                  omit-time-part
+                                  (omit-timezone-part omit-time-part)
+                                  (use-zulu t)
+                                  (timezone *default-timezone*))
+  "Formats a timestring in the RFC 3339 format, a restricted form of the ISO-8601 timestring specification for Internet timestamps."
+  (let ((rfc3339-format
+         (if (and use-zulu
+                  (not omit-date-part)
+                  (not omit-time-part)
+                  (not omit-timezone-part))
+             +rfc3339-format+ ; micro optimization
+             (append
+              (unless omit-date-part
+                '((:year 4) #\-
+                  (:month 2) #\-
+                  (:day 2)))
+              (unless (or omit-date-part
+                          omit-time-part)
+                '(#\T))
+              (unless omit-time-part
+                '((:hour 2) #\:
+                  (:min 2) #\:
+                  (:sec 2) #\.
+                  (:usec 6)))
+              (unless omit-timezone-part
+                (if use-zulu
+                    '(:gmt-offset-or-z)
+                    '(:gmt-offset)))))))
+    (format-timestring destination timestamp :format rfc3339-format :timezone timezone)))
+
+(defun to-rfc3339-timestring (timestamp)
+  (format-rfc3339-timestring nil timestamp))
+
+(defun %read-timestring (stream char)
+  (declare (ignore char))
+  (parse-timestring
+   (with-output-to-string (str)
+     (loop for c = (read-char stream nil)
+        while (and c (or (digit-char-p c) (member c '(#\: #\T #\t #\: #\- #\+ #\Z #\.))))
+        do (princ c str)
+        finally (when c (unread-char c stream))))
+   :allow-missing-elements t))
+
+(defun %read-universal-time (stream char arg)
+  (declare (ignore char arg))
+  (universal-to-timestamp
+              (parse-integer
+               (with-output-to-string (str)
+                 (loop for c = (read-char stream nil)
+                       while (and c (digit-char-p c))
+                       do (princ c str)
+                       finally (when c (unread-char c stream)))))))
+
+(defun enable-read-macros ()
+  "Enables the local-time reader macros for literal timestamps and universal time."
+  (set-macro-character #\@ '%read-timestring)
+  (set-dispatch-macro-character #\# #\@ '%read-universal-time)
+  (values))
+
+(defvar *debug-timestamp* nil)
+
+(defmethod print-object ((object timestamp) stream)
+  "Print the TIMESTAMP object using the standard reader notation"
+  (cond
+    (*debug-timestamp*
+       (print-unreadable-object (object stream :type t)
+         (format stream "~d/~d/~d"
+                 (day-of object)
+                 (sec-of object)
+                 (nsec-of object))))
+    (t
+     (when *print-escape*
+       (write-char #\@ stream))
+     (format-rfc3339-timestring stream object))))
+
+(defmethod print-object ((object timezone) stream)
+  "Print the TIMEZONE object in a reader-rejected manner."
+  (print-unreadable-object (object stream :type t)
+    (format stream "~:[UNLOADED~;~{~a~^ ~}~]"
+            (timezone-loaded object)
+            (map 'list #'subzone-abbrev (timezone-subzones object)))))
+
+(defun astronomical-julian-date (timestamp)
+  "Returns the astronomical julian date referred to by the timestamp."
+  (- (day-of timestamp) +astronomical-julian-date-offset+))
+
+(defun modified-julian-date (timestamp)
+  "Returns the modified julian date referred to by the timestamp."
+  (- (day-of timestamp) +modified-julian-date-offset+))
+
+(declaim (notinline format-timestring))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/src/package.lisp b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/src/package.lisp
new file mode 100644
index 0000000..ee03a97
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/src/package.lisp
@@ -0,0 +1,91 @@
+(defpackage #:local-time
+  (:use #:cl)
+  (:export #:timestamp
+           #:date
+           #:time-of-day
+           #:make-timestamp
+           #:clone-timestamp
+           #:day-of
+           #:sec-of
+           #:nsec-of
+           #:timestamp<
+           #:timestamp<=
+           #:timestamp>
+           #:timestamp>=
+           #:timestamp=
+           #:timestamp/=
+           #:timestamp-maximum
+           #:timestamp-minimum
+           #:adjust-timestamp
+           #:adjust-timestamp!
+           #:timestamp-whole-year-difference
+           #:days-in-month
+           #:timestamp-
+           #:timestamp+
+           #:timestamp-difference
+           #:timestamp-minimize-part
+           #:timestamp-maximize-part
+           #:with-decoded-timestamp
+           #:decode-timestamp
+           #:timestamp-century
+           #:timestamp-day
+           #:timestamp-day-of-week
+           #:timestamp-decade
+           #:timestamp-hour
+           #:timestamp-microsecond
+           #:timestamp-millennium
+           #:timestamp-millisecond
+           #:timestamp-minute
+           #:timestamp-month
+           #:timestamp-second
+           #:timestamp-week
+           #:timestamp-year
+           #:parse-timestring
+           #:format-timestring
+           #:format-rfc1123-timestring
+           #:to-rfc1123-timestring
+           #:format-rfc3339-timestring
+           #:to-rfc3339-timestring
+           #:encode-timestamp
+           #:parse-rfc3339-timestring
+           #:universal-to-timestamp
+           #:timestamp-to-universal
+           #:unix-to-timestamp
+           #:timestamp-to-unix
+           #:timestamp-subtimezone
+           #:define-timezone
+           #:*default-timezone*
+           #:*clock*
+           #:leap-second-adjusted
+           #:clock-now
+           #:clock-today
+           #:find-timezone-by-location-name
+           #:reread-timezone-repository
+           #:now
+           #:today
+           #:enable-read-macros
+           #:+utc-zone+
+           #:+gmt-zone+
+           #:+month-names+
+           #:+short-month-names+
+           #:+day-names+
+           #:+short-day-names+
+           #:+seconds-per-day+
+           #:+seconds-per-hour+
+           #:+seconds-per-minute+
+           #:+minutes-per-day+
+           #:+minutes-per-hour+
+           #:+hours-per-day+
+           #:+days-per-week+
+           #:+months-per-year+
+           #:+iso-8601-format+
+           #:+iso-8601-date-format+
+           #:+iso-8601-time-format+
+           #:+rfc3339-format+
+           #:+rfc3339-format/date-only+
+           #:+asctime-format+
+           #:+rfc-1123-format+
+           #:+iso-week-date-format+
+           #:astronomical-julian-date
+           #:modified-julian-date
+           #:astronomical-modified-julian-date))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/comparison.lisp b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/comparison.lisp
new file mode 100644
index 0000000..4aa89c9
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/comparison.lisp
@@ -0,0 +1,128 @@
+(in-package #:local-time.test)
+
+(defsuite* (comparison :in simple))
+
+(defmacro defcmptest (comparator-name &body args)
+  `(deftest ,(symbolicate 'test/simple/comparison/ comparator-name) ()
+    (flet ((make (day &optional (sec 0) (nsec 0))
+             (make-timestamp :day day :sec sec :nsec nsec)))
+      ,@(loop
+          :for entry :in args
+          :when (= (length entry) 1)
+            :do (push 'is entry)
+          :else
+            :do (if (member (car entry) '(t true is) :test #'eq)
+                    'is
+                    'is)
+          collect (let ((body `(,comparator-name (make ,@(second entry))
+                                                 (make ,@(third entry)))))
+                    (cond
+                      ((eq (car entry) 'true)
+                       `(is ,body))
+                      ((eq (car entry) 'false)
+                       `(is (not ,body)))
+                      (t (error "Don't know how to interpret ~S" entry))))))))
+
+(defcmptest timestamp<
+  (true (1 0 0)
+        (2 0 0))
+  (true (0 1 0)
+        (0 2 0))
+  (true (0 0 1)
+        (0 0 2))
+
+  (false (2 0 0)
+         (1 0 0))
+  (false (0 2 0)
+         (0 1 0))
+  (false (0 0 2)
+         (0 0 1)))
+
+(defcmptest timestamp<=
+  (true (1 0 0)
+        (2 0 0))
+  (true (0 1 0)
+        (0 2 0))
+  (true (0 0 1)
+        (0 0 2))
+  (true (1 0 0)
+        (1 0 0))
+  (true (1 1 0)
+        (1 1 0))
+  (true (1 1 1)
+        (1 1 1))
+
+  (false (2 0 0)
+         (1 0 0))
+  (false (0 2 0)
+         (0 1 0))
+  (false (0 0 2)
+         (0 0 1)))
+
+(defcmptest timestamp>
+  (true (2 0 0)
+        (1 0 0))
+  (true (0 2 0)
+        (0 1 0))
+  (true (0 0 2)
+        (0 0 1))
+
+  (false (1 0 0)
+         (2 0 0))
+  (false (0 1 0)
+         (0 2 0))
+  (false (0 0 1)
+         (0 0 2)))
+
+(defcmptest timestamp>=
+  (true (2 0 0)
+        (1 0 0))
+  (true (0 2 0)
+        (0 1 0))
+  (true (0 0 2)
+        (0 0 1))
+  (true (1 0 0)
+        (1 0 0))
+  (true (1 1 0)
+        (1 1 0))
+  (true (1 1 1)
+        (1 1 1))
+
+  (false (1 0 0)
+         (2 0 0))
+  (false (0 1 0)
+         (0 2 0))
+  (false (0 0 1)
+         (0 0 2)))
+
+(defcmptest timestamp=
+  (true (1 0 0)
+        (1 0 0))
+  (true (1 1 0)
+        (1 1 0))
+  (true (1 1 1)
+        (1 1 1))
+
+  (false (1 0 0)
+         (2 0 0))
+  (false (0 1 0)
+         (0 2 0))
+  (false (0 0 1)
+         (0 0 2)))
+
+(deftest test/simple/comparison/timestamp=/2 ()
+  (is (timestamp= (make-timestamp) (make-timestamp)))
+  (is (not (timestamp= (make-timestamp) (make-timestamp :nsec 1)))))
+
+(deftest test/simple/comparison/timestamp=/3 ()
+  (is (eql (handler-case
+               (timestamp= (make-timestamp) nil)
+             (type-error ()
+               :correct-error))
+           :correct-error)))
+
+(deftest test/simple/comparison/timestamp/= ()
+  (is (timestamp/= (make-timestamp :nsec 1) (make-timestamp :nsec 2)))
+  (is (timestamp/= (make-timestamp :nsec 1) (make-timestamp :nsec 2) (make-timestamp :nsec 3)))
+  (is (not (timestamp/= (make-timestamp :nsec 1) (make-timestamp :nsec 2) (make-timestamp :nsec 1))))
+  (is (not (timestamp/= (make-timestamp) (make-timestamp)))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/formatting.lisp b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/formatting.lisp
new file mode 100644
index 0000000..e4c3bb4
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/formatting.lisp
@@ -0,0 +1,97 @@
+(in-package #:local-time.test)
+
+(defsuite* (formatting :in test))
+
+(deftest test/formatting/format-timestring/1 ()
+  (let ((*default-timezone* local-time:+utc-zone+)
+        (test-timestamp (encode-timestamp 1000 2 3 4 5 6 2008 :offset 0)))
+    (macrolet ((frob (&rest args)
+                 `(progn
+                    ,@(loop
+                        :for (a b) :on args :by #'cddr
+                        :collect `(is (string= ,a ,b))))))
+      (frob
+       "2008-06-05T04:03:02.000001Z"
+       (format-timestring nil test-timestamp)
+
+       "2008-06-05T04:03:02.000001-05:00"
+       (let ((utc-5 (local-time::%make-simple-timezone "UTC-5" "UTC-5" -18000)))
+         (format-timestring nil (encode-timestamp 1000 2 3 4 5 6 2008
+                                                  :offset (* 3600 -5))
+                            :timezone utc-5))
+
+       "Thu Jun  5 04:03:02 2008"
+       (format-timestring nil test-timestamp :format +asctime-format+)
+
+       "Thu, 05 Jun 2008 04:03:02 +0000"
+       (format-timestring nil test-timestamp :format +rfc-1123-format+)
+
+       ""
+       (format-timestring nil test-timestamp
+                          :format nil)
+
+       "04"
+       (format-timestring nil test-timestamp
+                          :format '((:hour 2)))
+
+       "04:03"
+       (format-timestring nil test-timestamp
+                          :format '((:hour 2) #\: (:min 2)))
+
+       "5th"
+       (format-timestring nil test-timestamp
+                          :format '(:ordinal-day))
+
+       "2004-W53-6"
+       (format-timestring nil (encode-timestamp 0 0 0 0 1 1 2005)
+                          :format +iso-week-date-format+)
+
+       "2004-W53-7"
+       (format-timestring nil (encode-timestamp 0 0 0 0 2 1 2005)
+                          :format +iso-week-date-format+)
+
+       "2005-W52-6"
+       (format-timestring nil (encode-timestamp 0 0 0 0 31 12 2005)
+                          :format +iso-week-date-format+)
+
+       "2007-W01-1"
+       (format-timestring nil (encode-timestamp 0 0 0 0 1 1 2007)
+                          :format +iso-week-date-format+)
+
+       "2007-W52-7"
+       (format-timestring nil (encode-timestamp 0 0 0 0 30 12 2007)
+                          :format +iso-week-date-format+)
+
+       "2008-W01-1"
+       (format-timestring nil (encode-timestamp 0 0 0 0 31 12 2007)
+                          :format +iso-week-date-format+)
+
+       "2009-W53-5"
+       (format-timestring nil (encode-timestamp 0 0 0 0 1 1 2010)
+                          :format +iso-week-date-format+)
+
+       "2009-W01-3"
+       (format-timestring nil (encode-timestamp 0 0 0 0 31 12 2008)
+                          :format +iso-week-date-format+)))))
+
+(deftest test/formatting/format-timestring/2 ()
+  (with-output-to-string (*standard-output*)
+    (let ((*default-timezone* (find-timezone-by-location-name "UTC")))
+      (finishes (print (now))))))
+
+(deftest test/formatting/ordinals ()
+  (flet ((format-ordinal (day)
+           (format-timestring nil (encode-timestamp 0 0 0 0 day 1 2008)
+                              :format '(:ordinal-day))))
+    (string= "31st" (format-ordinal 31))
+    (string= "11th" (format-ordinal 11))
+    (string= "22nd" (format-ordinal 22))
+    (string= "3rd"  (format-ordinal 3))))
+
+(deftest test/formatting/bug/1 ()
+  (let ((*default-timezone* (find-timezone-by-location-name "Pacific/Auckland")))
+    (finishes (format-timestring nil (now)))))
+
+(deftest test/formatting/leap-year ()
+  (let ((timestamp (parse-timestring "2004-02-29")))
+    (is (timestamp= timestamp (parse-timestring (format-timestring nil timestamp))))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/package.lisp b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/package.lisp
new file mode 100644
index 0000000..88a1f87
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/package.lisp
@@ -0,0 +1,13 @@
+(cl:in-package :cl-user)
+
+(defpackage :local-time.test
+  (:use :alexandria
+        :common-lisp
+        :stefil
+        :local-time))
+
+(in-package :local-time.test)
+
+(defsuite* (test :in root-suite) ()
+  (local-time::reread-timezone-repository)
+  (run-child-tests))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/parsing.lisp b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/parsing.lisp
new file mode 100644
index 0000000..2473367
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/parsing.lisp
@@ -0,0 +1,79 @@
+(in-package #:local-time.test)
+
+(defsuite* (parsing :in test))
+
+(deftest test/parsing/parse-format-consistency/range (&key (start-day -100000) (end-day 100000))
+  (declare (optimize debug))
+  (without-test-progress-printing
+    (loop
+      :with time = (make-timestamp)
+      :for day :from start-day :upto end-day
+      :for index :upfrom 0 :do
+        (setf (day-of time) day)
+        (when (zerop (mod index 10000))
+          (print time))
+        (let ((parsed (parse-timestring (format-timestring nil time))))
+          (is (timestamp= parsed time))))))
+
+(deftest test/parsing/parse-format-consistency ()
+  (flet ((compare (nsec sec min hour day mon year str
+                        &key start end offset
+                        (allow-missing-elements t))
+           (let* ((timestamp-a (encode-timestamp nsec sec min hour
+                                                 day mon year :offset offset))
+                  (used-offset (or offset
+                                   (local-time::%guess-offset (sec-of timestamp-a)
+                                                              (day-of timestamp-a))))
+                  (timestamp-b (parse-timestring str
+                                                 :start start
+                                                 :end end
+                                                 :allow-missing-elements
+                                                 allow-missing-elements
+                                                 :offset used-offset)))
+             (is (timestamp= timestamp-a timestamp-b)))))
+    (let ((timestamp (now)))
+      (is (timestamp= timestamp
+                      (parse-timestring
+                       (format-timestring nil timestamp)))))
+
+    (let* ((*default-timezone* (find-timezone-by-location-name "Europe/Budapest")))
+      (compare 0 0 0 0 1 1 1 "0001-01-01T00:00:00,0"))
+
+    (compare 0 0 0 0 1 1 1 "0001-01-01T00:00:00Z" :offset 0)
+
+    (compare 0 0 0 0 1 1 2006 "2006-01-01T00:00:00,0")
+    (compare 0 0 0 0 1 1 2006 "xxxx 2006-01-01T00:00:00,0 xxxx"
+             :start 5
+             :end 15)
+
+    (is (eql (day-of (parse-timestring "2006-06-06TZ")) 2288))
+
+    (compare 20000000 3 4 5 6 7 2008 "2008-07-06T05:04:03,02")
+    (compare 0 2 0 0 23 3 2000 "--23T::02" :allow-missing-elements t)
+    (compare 80000000 7 6 5 1 3 2000 "T05:06:07,08" :allow-missing-elements t)
+    (compare 940703000 28 56 16 20 2 2008 "2008-02-20T16:56:28.940703Z"
+             :offset 0)))
+
+(deftest test/parsing/split ()
+  (is (equal (local-time::%split-timestring "2006-01-02T03:04:05,6-05")
+             '(2006 1 2 3 4 5 600000000 -5 0)))
+  (is (equal (local-time::%split-timestring "2006-01-02T03:04:05,6-0515")
+             '(2006 1 2 3 4 5 600000000 -5 -15)))
+  (is (equal (local-time::%split-timestring "2006-01-02T03:04:05,6-05:15")
+             '(2006 1 2 3 4 5 600000000 -5 -15))))
+
+
+(deftest test/parsing/reader ()
+  (let ((now (now)))
+    (setf (nsec-of now) 123456000)
+    (is (timestamp= now
+                     (with-input-from-string (ins (format-timestring nil now))
+                       (local-time::%read-timestring ins #\@))))))
+
+(deftest test/parsing/read-universal-time ()
+  (let ((now (now)))
+    (setf (nsec-of now) 0)
+    (is (timestamp= now
+                     (with-input-from-string (ins (princ-to-string (timestamp-to-universal now)))
+                       (local-time::%read-universal-time ins #\@ nil))))))
+
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/simple.lisp b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/simple.lisp
new file mode 100644
index 0000000..89b38a9
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/simple.lisp
@@ -0,0 +1,284 @@
+(in-package #:local-time.test)
+
+(defsuite* (simple :in test))
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (local-time::define-timezone eastern-tz
+      (merge-pathnames #p"US/Eastern" local-time::*default-timezone-repository-path*))
+  (local-time::define-timezone amsterdam-tz
+      (merge-pathnames #p"Europe/Amsterdam" local-time::*default-timezone-repository-path*)))
+
+(deftest test/simple/make-timestamp ()
+  (let ((timestamp (make-timestamp :nsec 1 :sec 2 :day 3)))
+    (is (= (nsec-of timestamp) 1))
+    (is (= (sec-of timestamp) 2))
+    (is (= (day-of timestamp) 3))))
+
+(deftest test/simple/read-binary-integer ()
+  (let ((tmp-file-path #p"/tmp/local-time-test"))
+    (with-open-file (ouf tmp-file-path
+                         :direction :output
+                         :element-type 'unsigned-byte
+                         :if-exists :supersede)
+      (dotimes (i 14)
+        (write-byte 200 ouf)))
+  (with-open-file (inf tmp-file-path :element-type 'unsigned-byte)
+    (is (eql (local-time::%read-binary-integer inf 1) 200))
+    (is (eql (local-time::%read-binary-integer inf 1 t) -56))
+    (is (eql (local-time::%read-binary-integer inf 2) 51400))
+    (is (eql (local-time::%read-binary-integer inf 2 t) -14136))
+    (is (eql (local-time::%read-binary-integer inf 4) 3368601800))
+    (is (eql (local-time::%read-binary-integer inf 4 t) -926365496)))))
+
+(deftest test/simple/encode-timestamp ()
+  (macrolet ((entry ((&rest encode-timestamp-args)
+                     day sec nsec)
+               `(let ((timestamp (encode-timestamp ,@encode-timestamp-args)))
+                  (is (= (day-of timestamp) ,day))
+                  (is (= (sec-of timestamp) ,sec))
+                  (is (= (nsec-of timestamp) ,nsec)))))
+    (entry (0 0 0 0 1 3 2000 :offset 0)
+           0 0 0)
+    (entry (0 0 0 0 29 2 2000 :offset 0)
+           -1 0 0)
+    (entry (0 0 0 0 2 3 2000 :offset 0)
+           1 0 0)
+    (entry (0 0 0 0 1 1 2000 :offset 0)
+           -60 0 0)
+    (entry (0 0 0 0 1 3 2001 :offset 0)
+           365 0 0)))
+
+(defmacro encode-decode-test (args &body body)
+  `(let ((timestamp (encode-timestamp ,@(subseq args 0 7) :offset 0)))
+    (is (equal '(,@args ,@(let ((stars nil))
+                               (dotimes (n (- 7 (length args)))
+                                 (push '* stars))
+                               stars))
+               (multiple-value-list
+                (decode-timestamp timestamp :timezone local-time:+utc-zone+))))
+    ,@body))
+
+(deftest test/simple/encode-decode-consistency/1 ()
+  (encode-decode-test (5 5 5 5 5 5 1990 6 nil 0 "UTC"))
+  (encode-decode-test (0 0 0 0 1 3 2001 4 nil 0 "UTC"))
+  (encode-decode-test (0 0 0 0 1 3 1998 0 nil 0 "UTC"))
+  (encode-decode-test (1 2 3 4 5 6 2008 4 nil 0 "UTC"))
+  (encode-decode-test (0 0 0 0 1 1 1 1 nil 0 "UTC")))
+
+(deftest test/simple/encode-decode-consistency/random ()
+  (loop :repeat 1000 :do
+    (let ((timestamp (make-timestamp :day (- (random 65535) 36767)
+                                     :sec (random 86400)
+                                     :nsec (random 1000000000))))
+      (multiple-value-bind (ns ss mm hh day month year)
+          (decode-timestamp timestamp :timezone local-time:+utc-zone+)
+        (is (timestamp= timestamp
+                        (encode-timestamp ns ss mm hh day month year :offset 0)))))))
+
+;;;;;;
+;;; TODO the rest is uncategorized, just simply converted from the old 5am suite
+
+(deftest test/timestamp-conversions ()
+  (is (eql 0 (timestamp-to-unix
+              (encode-timestamp 0 0 0 0 1 1 1970 :offset 0))))
+  (is (equal (values 2 3 4 5 6 2008 3 * *)
+             (decode-universal-time
+              (timestamp-to-universal
+               (encode-timestamp 1 2 3 4 5 6 2008 :offset 0)) 0)))
+  (let ((now (now)))
+    (setf (nsec-of now) 0)
+    (is (timestamp= now
+                     (unix-to-timestamp (timestamp-to-unix now)))))
+  (let ((now (get-universal-time)))
+    (is (equal now
+               (timestamp-to-universal (universal-to-timestamp now))))))
+
+(deftest test/year-difference ()
+  (let ((a (parse-timestring "2006-01-01T00:00:00"))
+        (b (parse-timestring "2001-01-01T00:00:00")))
+    (is (= 5 (timestamp-whole-year-difference a b))))
+
+  (let ((a (parse-timestring "2006-01-01T00:00:00"))
+        (b (parse-timestring "2001-01-02T00:00:00")))
+    (is (= 4 (timestamp-whole-year-difference a b))))
+  
+  (let* ((local-time::*default-timezone* amsterdam-tz)
+         (a (parse-timestring "1978-10-01")))
+    (is (= 0 (timestamp-whole-year-difference a a)))))
+
+(deftest test/adjust-timestamp/day-of-week/basic ()
+  (let ((sunday (parse-timestring "2020-09-13T00:00:00"))
+        (saturday (parse-timestring "2020-09-19T00:00:00"))
+        (base (parse-timestring "2020-09-15T00:00:00")))
+    (loop for dow in '(:sunday :monday :tuesday)
+       do (let ((modified (adjust-timestamp base (timezone +utc-zone+) (offset :day-of-week dow))))
+            (is (and (timestamp>= modified sunday) (timestamp<= modified base)))))
+    (loop for dow in '(:wednesday :thursday :friday :saturday)
+       do (let ((modified (adjust-timestamp base (timezone +utc-zone+) (offset :day-of-week dow))))
+            (is (and (timestamp> modified base) (timestamp<= modified saturday)))))))
+
+(deftest test/adjust-timestamp/bug1 ()
+  (let* ((timestamp (parse-timestring "2006-01-01T00:00:00Z"))
+         (modified-timestamp (adjust-timestamp timestamp (timezone +utc-zone+) (offset :year 1))))
+    (is (timestamp= (parse-timestring "2007-01-01T00:00:00Z") modified-timestamp))))
+
+(deftest test/adjust-timestamp/bug2 ()
+  (let* ((timestamp (parse-timestring "2009-03-01T01:00:00.000000+00:00"))
+         (modified-timestamp (adjust-timestamp timestamp (timezone +utc-zone+) (offset :month 1))))
+    (is (timestamp= (parse-timestring "2009-04-01T01:00:00.000000+00:00") modified-timestamp))))
+
+(deftest test/adjust-timestamp/bug3 ()
+  (let* ((timestamp (parse-timestring "2009-03-01T01:00:00.000000+00:00"))
+         (modified-timestamp (adjust-timestamp timestamp (timezone +utc-zone+) (offset :day-of-week :monday))))
+    (is (timestamp= (parse-timestring "2009-02-23T01:00:00.000000+00:00") modified-timestamp)))
+  (let* ((timestamp (parse-timestring "2009-03-04T01:00:00.000000+00:00"))
+         (modified-timestamp (adjust-timestamp timestamp (timezone +utc-zone+) (offset :day-of-week :monday))))
+    (is (timestamp= (parse-timestring "2009-03-02T01:00:00.000000+00:00") modified-timestamp))))
+
+(deftest test/adjust-timestamp/bug4 ()
+  (let* ((timestamp (parse-timestring "2013-04-30T00:00:00.000000+00:00"))
+         (modified-timestamp (adjust-timestamp timestamp (timezone +utc-zone+) (offset :day-of-week :wednesday))))
+    (is (timestamp= (parse-timestring "2013-05-01T00:00:00.000000+00:00") modified-timestamp)))
+  (let* ((timestamp (parse-timestring "2013-12-31T00:00:00.000000+00:00"))
+         (modified-timestamp (adjust-timestamp timestamp (timezone +utc-zone+) (offset :day-of-week :wednesday))))
+    (is (timestamp= (parse-timestring "2014-01-01T00:00:00.000000+00:00") modified-timestamp))))
+
+#+nil
+(deftest test/adjust-days ()
+  (let ((sunday (parse-timestring "2006-12-17T01:02:03Z")))
+    (is (timestamp= (parse-timestring "2006-12-11T01:02:03Z")
+                     (adjust-timestamp sunday (offset :day-of-week :monday))))
+    (is (timestamp= (parse-timestring "2006-12-20T01:02:03Z")
+                     (adjust-timestamp sunday (offset :day 3))))))
+
+(deftest test/decode-date ()
+  (loop
+    :for (total-day year month day) :in '((-1 2000 02 29)
+                                          (0 2000 03 01)
+                                          (1 2000 03 02)
+                                          (364 2001 02 28)
+                                          (365 2001 03 01)
+                                          (366 2001 03 02)
+                                          (#.(* 2 365) 2002 03 01)
+                                          (#.(* 4 365) 2004 02 29)
+                                          (#.(1+ (* 4 365)) 2004 03 01))
+    :do (multiple-value-bind (year* month* day*)
+            (local-time::%timestamp-decode-date total-day)
+          (is (= year year*))
+          (is (= month month*))
+          (is (= day day*)))))
+
+(deftest test/timestamp-decoding-readers ()
+  (let ((*default-timezone* +utc-zone+))
+    (dolist (year '(1900 1975 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010))
+      (dolist (month '(1 2 3 4 5 6 7 8 9 10 11 12))
+        (dolist (day '(1 2 3 27 28 29 30 31))
+          (when (valid-date-tuple? year month day)
+            (let ((hour (random 24))
+                  (min (random 60))
+                  (sec (random 60))
+                  (nsec (random 1000000000)))
+              (let ((time (encode-timestamp nsec sec min hour day month year :offset 0)))
+                (is (= (floor year 10) (timestamp-decade time)))
+                (is (= year (timestamp-year time)))
+                (is (= month (timestamp-month time)))
+                (is (= day (timestamp-day time)))
+                (is (= hour (timestamp-hour time)))
+                (is (= min (timestamp-minute time)))
+                (is (= sec (timestamp-second time)))
+                (is (= (floor nsec 1000000)
+                       (timestamp-millisecond time)))
+                (is (= (floor nsec 1000)
+                       (timestamp-microsecond time)))))))))))
+
+(deftest test/timestamp-century ()
+  (let ((*default-timezone* +utc-zone+))
+    (dolist (year-data '((-101 -2)
+                         (-100 -1)
+                         (-1 -1)
+                         (1 1)
+                         (100 1)
+                         (101 2)
+                         (1999 20)
+                         (2000 20)
+                         (2001 21)))
+      (let ((time (encode-timestamp 0 0 0 0 1 1 (first year-data) :offset 0)))
+        (is (= (second year-data) (timestamp-century time)))))))
+
+(deftest test/timestamp-millennium ()
+  (let ((*default-timezone* +utc-zone+))
+    (dolist (year-data '((-101 -1)
+                         (-100 -1)
+                         (-1 -1)
+                         (1 1)
+                         (100 1)
+                         (101 1)
+                         (1001 2)
+                         (1999 2)
+                         (2000 2)
+                         (2001 3)))
+      (let ((time (encode-timestamp 0 0 0 0 1 1 (first year-data) :offset 0)))
+        (is (= (second year-data) (timestamp-millennium time)))))))
+
+(defun valid-date-tuple? (year month day)
+  ;; it works only on the gregorian calendar
+  (let ((month-days #(31 28 31 30 31 30 31 31 30 31 30 31)))
+    (and (<= 1 month 12)
+         (<= 1 day (+ (aref month-days (1- month))
+                      (if (and (= month 2)
+                               (zerop (mod year 4))
+                               (not (zerop (mod year 100)))
+                               (zerop (mod year 400)))
+                          1
+                          0))))))
+
+(deftest test/encode-decode-timestamp ()
+  (let ((*default-timezone* +utc-zone+))
+    (loop for year :in '(1900 1975 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010) do
+          (loop for month :from 1 :to 12 do
+                (loop for day :in '(1 2 3 27 28 29 30 31) do
+                      (when (valid-date-tuple? year month day)
+                        (multiple-value-bind (nsec sec minute hour day* month* year* day-of-week)
+                            (decode-timestamp (encode-timestamp 0 0 0 0 day month year :offset 0))
+                          (declare (ignore nsec sec minute day-of-week))
+                          (is (= hour 0))
+                          (is (= year year*))
+                          (is (= month month*))
+                          (is (= day day*)))))))))
+
+(deftest test/timestamp-maximize-part ()
+  (timestamp= (timestamp-maximize-part
+               (encode-timestamp 0 49 26 13 9 12 2010 :offset -18000)
+               :min)
+              (encode-timestamp 999999999 59 59 13 9 12 2010 :offset -18000)))
+
+(deftest test/timestamp-minimize-part ()
+  (timestamp= (timestamp-minimize-part
+               (encode-timestamp 0 49 26 13 9 12 2010 :offset -18000)
+               :min)
+              (encode-timestamp 0 0 0 13 9 12 2010 :offset -18000)))
+
+(deftest test/decode-iso-week ()
+  (dolist (*default-timezone* (list eastern-tz +utc-zone+ amsterdam-tz))
+    (dolist (testcase '((2005 01 01 2004 53 6)
+                        (2005 01 02 2004 53 7)
+                        (2005 12 31 2005 52 6)
+                        (2007 01 01 2007 1 1)
+                        (2007 12 30 2007 52 7)
+                        (2007 12 31 2008 1 1)
+                        (2008 01 01 2008 1 2)
+                        (2008 12 28 2008 52 7)
+                        (2008 12 29 2009 1 1)
+                        (2008 12 30 2009 1 2)
+                        (2008 12 31 2009 1 3)
+                        (2009 01 01 2009 1 4)
+                        (2009 12 31 2009 53 4)
+                        (2010 01 01 2009 53 5)
+                        (2010 01 02 2009 53 6)
+                        (2010 01 03 2009 53 7)
+                        (2016 01 04 2016 1 1)))
+      (destructuring-bind (year month day iso-year iso-week iso-dow)
+          testcase
+        (let ((ts (encode-timestamp 0 0 0 12 day month year)))
+          (is (equal (list iso-year iso-week iso-dow)
+                     (multiple-value-list (local-time::%timestamp-decode-iso-week ts)))))))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/timezone.lisp b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/timezone.lisp
new file mode 100644
index 0000000..f2a1c68
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/test/timezone.lisp
@@ -0,0 +1,106 @@
+(in-package #:local-time.test)
+
+(defsuite* (timezone :in test))
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (local-time::define-timezone eastern-tz
+      (merge-pathnames #p"EST5EDT" local-time::*default-timezone-repository-path*))
+  (local-time::define-timezone utc-leaps
+      (merge-pathnames #p"../zoneinfo-leaps/UTC" local-time::*default-timezone-repository-path*)))
+
+
+
+(deftest transition-position/correct-position ()
+  (let ((cases '((0 #(1 2 3 4 5) 0)
+                 (1 #(1 2 3 4 5) 0)
+                 (2 #(1 2 3 4 5) 1)
+                 (3 #(1 2 3 4 5) 2)
+                 (4 #(1 2 3 4 5) 3)
+                 (5 #(1 2 3 4 5) 4)
+                 (1 #(1 3 5) 0)
+                 (2 #(1 3 5) 0)
+                 (3 #(1 3 5) 1)
+                 (4 #(1 3 5) 1)
+                 (5 #(1 3 5) 2)
+                 (6 #(1 3 5) 2)
+                 (1 #(1 3 5 7) 0)
+                 (2 #(1 3 5 7) 0)
+                 (3 #(1 3 5 7) 1)
+                 (4 #(1 3 5 7) 1)
+                 (5 #(1 3 5 7) 2)
+                 (6 #(1 3 5 7) 2)
+                 (7 #(1 3 5 7) 3)
+                 (8 #(1 3 5 7) 3)
+                 )))
+    (dolist (case cases)
+      (destructuring-bind (needle haystack want)
+          case
+        (let ((got (local-time::transition-position needle haystack)))
+          (is (= got want)
+              "(transition-position ~a ~a) got ~a, want ~a"
+              needle haystack got want))))))
+
+(deftest test/timezone/decode-timestamp-dst ()
+  ;; Testing DST calculation with a known timezone
+  (let ((test-cases '(
+                      ;; Spring forward
+                      ((2008 3 9 6 58) (2008 3 9 1 58))
+                      ((2008 3 9 6 59) (2008 3 9 1 59))
+                      ((2008 3 9 7  0) (2008 3 9 3  0))
+                      ((2008 3 9 7  1) (2008 3 9 3  1))
+                      ;; Fall back
+                      ((2008 11 2 5 59) (2008 11 2 1 59))
+                      ((2008 11 2 6  0) (2008 11 2 1  0))
+                      ((2008 11 2 6  1) (2008 11 2 1  1)))))
+    (dolist (test-case test-cases)
+      (is (equal 
+         (let ((timestamp
+                (apply 'local-time:encode-timestamp
+                       `(0 0 ,@(reverse (first test-case)) :offset 0))))
+           (local-time:decode-timestamp timestamp :timezone eastern-tz))
+         (apply 'values `(0 0 ,@(reverse (second test-case)))))))))
+
+(deftest test/timezone/adjust-across-dst-by-days ()
+  (let* ((old (parse-timestring "2014-03-09T01:00:00.000000-05:00"))
+         (new (timestamp+ old 1 :day eastern-tz)))
+    (is (= (* 23 60 60) (timestamp-difference new old)))))
+
+(deftest test/timezone/adjust-across-dst-by-hours ()
+  (let* ((old (parse-timestring "2014-03-09T01:00:00.000000-05:00"))
+         (new (timestamp+ old 24 :hour eastern-tz)))
+    (is (= (* 24 60 60) (timestamp-difference new old)))))
+
+(deftest test/timezone/timestamp-minimize-part ()
+  (is (timestamp=
+       (timestamp-minimize-part
+	(encode-timestamp 999999999 59 59 1 14 3 2010 :timezone eastern-tz)
+	:month
+	:timezone eastern-tz)
+       (encode-timestamp 0 0 0 0 1 1 2010 :timezone eastern-tz)))
+  (is (timestamp=
+       (timestamp-minimize-part
+	(encode-timestamp 0 0 0 2 14 3 2010 :timezone eastern-tz)
+	:month
+	:timezone eastern-tz)
+       (encode-timestamp 0 0 0 0 1 1 2010 :timezone eastern-tz))))
+
+(deftest test/timezone/timestamp-maximize-part ()
+  (is (timestamp=
+       (timestamp-maximize-part
+	(encode-timestamp 999999999 59 59 1 7 11 2010 :timezone eastern-tz)
+	:month
+	:timezone eastern-tz)
+       (encode-timestamp 999999999 59 59 23 31 12 2010 :timezone eastern-tz)))
+  (is (timestamp=
+       (timestamp-maximize-part
+	(encode-timestamp 0 0 0 2 7 11 2010 :timezone eastern-tz)
+	:month
+	:timezone eastern-tz)
+       (encode-timestamp 999999999 59 59 23 31 12 2010 :timezone eastern-tz))))
+
+(deftest test/leaps/tai-to-utc ()
+  (let ((*default-timezone* utc-leaps))
+    (is (= 1435708799
+           (local-time::%adjust-sec-for-leap-seconds 1435708824)
+           (local-time::%adjust-sec-for-leap-seconds 1435708825)))
+    (is (= 1435708800
+           (local-time::%adjust-sec-for-leap-seconds 1435708826)))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo-leaps/UTC b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo-leaps/UTC
new file mode 100644
index 0000000..009856a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo-leaps/UTC differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Abidjan b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Abidjan
new file mode 100644
index 0000000..65d19ec
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Abidjan differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Accra b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Accra
new file mode 100644
index 0000000..8c473ed
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Accra differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Addis_Ababa b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Addis_Ababa
new file mode 100644
index 0000000..5a95ab6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Addis_Ababa differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Algiers b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Algiers
new file mode 100644
index 0000000..c888831
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Algiers differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Asmara b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Asmara
new file mode 100644
index 0000000..d1e876e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Asmara differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Asmera b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Asmera
new file mode 100644
index 0000000..d1e876e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Asmera differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Bamako b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Bamako
new file mode 100644
index 0000000..a9259a6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Bamako differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Bangui b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Bangui
new file mode 100644
index 0000000..883e597
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Bangui differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Banjul b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Banjul
new file mode 100644
index 0000000..a85a7d8
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Banjul differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Bissau b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Bissau
new file mode 100644
index 0000000..ab4a195
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Bissau differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Blantyre b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Blantyre
new file mode 100644
index 0000000..2972580
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Blantyre differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Brazzaville b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Brazzaville
new file mode 100644
index 0000000..abb0c08
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Brazzaville differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Bujumbura b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Bujumbura
new file mode 100644
index 0000000..cac5652
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Bujumbura differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Cairo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Cairo
new file mode 100644
index 0000000..39caffb
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Cairo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Casablanca b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Casablanca
new file mode 100644
index 0000000..379f93a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Casablanca differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Ceuta b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Ceuta
new file mode 100644
index 0000000..c9b0c08
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Ceuta differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Conakry b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Conakry
new file mode 100644
index 0000000..45bcce1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Conakry differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Dakar b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Dakar
new file mode 100644
index 0000000..3110413
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Dakar differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Dar_es_Salaam b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Dar_es_Salaam
new file mode 100644
index 0000000..05643e9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Dar_es_Salaam differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Djibouti b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Djibouti
new file mode 100644
index 0000000..297d93a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Djibouti differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Douala b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Douala
new file mode 100644
index 0000000..8627f2e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Douala differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/El_Aaiun b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/El_Aaiun
new file mode 100644
index 0000000..3275161
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/El_Aaiun differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Freetown b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Freetown
new file mode 100644
index 0000000..720b8e3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Freetown differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Gaborone b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Gaborone
new file mode 100644
index 0000000..ffc7795
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Gaborone differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Harare b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Harare
new file mode 100644
index 0000000..258b393
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Harare differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Johannesburg b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Johannesburg
new file mode 100644
index 0000000..d1bec73
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Johannesburg differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Kampala b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Kampala
new file mode 100644
index 0000000..1afbe23
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Kampala differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Khartoum b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Khartoum
new file mode 100644
index 0000000..6f62fd7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Khartoum differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Kigali b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Kigali
new file mode 100644
index 0000000..c9623c5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Kigali differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Kinshasa b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Kinshasa
new file mode 100644
index 0000000..e8481f3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Kinshasa differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Lagos b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Lagos
new file mode 100644
index 0000000..cbdc045
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Lagos differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Libreville b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Libreville
new file mode 100644
index 0000000..d7691ae
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Libreville differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Lome b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Lome
new file mode 100644
index 0000000..297ec5d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Lome differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Luanda b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Luanda
new file mode 100644
index 0000000..576b204
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Luanda differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Lubumbashi b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Lubumbashi
new file mode 100644
index 0000000..d3fab52
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Lubumbashi differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Lusaka b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Lusaka
new file mode 100644
index 0000000..87d7a95
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Lusaka differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Malabo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Malabo
new file mode 100644
index 0000000..c70de1f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Malabo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Maputo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Maputo
new file mode 100644
index 0000000..31cfad7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Maputo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Maseru b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Maseru
new file mode 100644
index 0000000..117006e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Maseru differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Mbabane b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Mbabane
new file mode 100644
index 0000000..be6ed60
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Mbabane differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Mogadishu b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Mogadishu
new file mode 100644
index 0000000..9ce97a6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Mogadishu differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Monrovia b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Monrovia
new file mode 100644
index 0000000..bd2fa4e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Monrovia differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Nairobi b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Nairobi
new file mode 100644
index 0000000..e557234
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Nairobi differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Ndjamena b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Ndjamena
new file mode 100644
index 0000000..8779590
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Ndjamena differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Niamey b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Niamey
new file mode 100644
index 0000000..799381c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Niamey differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Nouakchott b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Nouakchott
new file mode 100644
index 0000000..10ca866
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Nouakchott differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Ouagadougou b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Ouagadougou
new file mode 100644
index 0000000..df782a4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Ouagadougou differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Porto-Novo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Porto-Novo
new file mode 100644
index 0000000..600a30d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Porto-Novo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Sao_Tome b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Sao_Tome
new file mode 100644
index 0000000..ddf7fb4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Sao_Tome differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Timbuktu b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Timbuktu
new file mode 100644
index 0000000..a9259a6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Timbuktu differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Tripoli b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Tripoli
new file mode 100644
index 0000000..943f9a3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Tripoli differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Tunis b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Tunis
new file mode 100644
index 0000000..94d01da
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Tunis differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Windhoek b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Windhoek
new file mode 100644
index 0000000..6f22b0a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Africa/Windhoek differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Adak b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Adak
new file mode 100644
index 0000000..391ec98
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Adak differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Anchorage b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Anchorage
new file mode 100644
index 0000000..d147350
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Anchorage differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Anguilla b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Anguilla
new file mode 100644
index 0000000..20bc946
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Anguilla differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Antigua b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Antigua
new file mode 100644
index 0000000..608b635
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Antigua differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Araguaina b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Araguaina
new file mode 100644
index 0000000..34d9caf
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Araguaina differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Buenos_Aires b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Buenos_Aires
new file mode 100644
index 0000000..4bd3b2c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Buenos_Aires differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Catamarca b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Catamarca
new file mode 100644
index 0000000..e46272f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Catamarca differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/ComodRivadavia b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/ComodRivadavia
new file mode 100644
index 0000000..e46272f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/ComodRivadavia differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Cordoba b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Cordoba
new file mode 100644
index 0000000..1a335d4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Cordoba differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Jujuy b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Jujuy
new file mode 100644
index 0000000..45b806b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Jujuy differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/La_Rioja b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/La_Rioja
new file mode 100644
index 0000000..7546d5f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/La_Rioja differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Mendoza b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Mendoza
new file mode 100644
index 0000000..7ebf85e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Mendoza differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Rio_Gallegos b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Rio_Gallegos
new file mode 100644
index 0000000..d95ae41
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Rio_Gallegos differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/San_Juan b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/San_Juan
new file mode 100644
index 0000000..37f7b5d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/San_Juan differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/San_Luis b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/San_Luis
new file mode 100644
index 0000000..0fa7a41
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/San_Luis differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Tucuman b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Tucuman
new file mode 100644
index 0000000..93dc0dc
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Tucuman differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Ushuaia b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Ushuaia
new file mode 100644
index 0000000..5222e4c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Argentina/Ushuaia differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Aruba b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Aruba
new file mode 100644
index 0000000..73bb7ea
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Aruba differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Asuncion b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Asuncion
new file mode 100644
index 0000000..492d943
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Asuncion differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Atikokan b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Atikokan
new file mode 100644
index 0000000..c63a32a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Atikokan differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Atka b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Atka
new file mode 100644
index 0000000..391ec98
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Atka differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Bahia b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Bahia
new file mode 100644
index 0000000..34b2d7a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Bahia differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Barbados b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Barbados
new file mode 100644
index 0000000..63ca138
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Barbados differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Belem b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Belem
new file mode 100644
index 0000000..9c37b6a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Belem differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Belize b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Belize
new file mode 100644
index 0000000..a18cd39
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Belize differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Blanc-Sablon b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Blanc-Sablon
new file mode 100644
index 0000000..8526259
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Blanc-Sablon differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Boa_Vista b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Boa_Vista
new file mode 100644
index 0000000..cb15afb
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Boa_Vista differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Bogota b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Bogota
new file mode 100644
index 0000000..9df037e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Bogota differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Boise b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Boise
new file mode 100644
index 0000000..441afe5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Boise differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Buenos_Aires b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Buenos_Aires
new file mode 100644
index 0000000..4bd3b2c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Buenos_Aires differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cambridge_Bay b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cambridge_Bay
new file mode 100644
index 0000000..9aa642b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cambridge_Bay differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Campo_Grande b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Campo_Grande
new file mode 100644
index 0000000..4d95b68
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Campo_Grande differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cancun b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cancun
new file mode 100644
index 0000000..3d56e51
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cancun differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Caracas b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Caracas
new file mode 100644
index 0000000..a214413
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Caracas differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Catamarca b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Catamarca
new file mode 100644
index 0000000..e46272f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Catamarca differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cayenne b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cayenne
new file mode 100644
index 0000000..7109a98
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cayenne differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cayman b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cayman
new file mode 100644
index 0000000..a4095d3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cayman differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Chicago b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Chicago
new file mode 100644
index 0000000..e932c6d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Chicago differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Chihuahua b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Chihuahua
new file mode 100644
index 0000000..8758bab
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Chihuahua differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Coral_Harbour b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Coral_Harbour
new file mode 100644
index 0000000..c63a32a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Coral_Harbour differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cordoba b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cordoba
new file mode 100644
index 0000000..1a335d4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cordoba differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Costa_Rica b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Costa_Rica
new file mode 100644
index 0000000..2029eb6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Costa_Rica differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cuiaba b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cuiaba
new file mode 100644
index 0000000..0b12246
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Cuiaba differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Curacao b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Curacao
new file mode 100644
index 0000000..6733d24
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Curacao differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Danmarkshavn b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Danmarkshavn
new file mode 100644
index 0000000..9feacfb
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Danmarkshavn differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Dawson b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Dawson
new file mode 100644
index 0000000..fab0609
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Dawson differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Dawson_Creek b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Dawson_Creek
new file mode 100644
index 0000000..01ed535
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Dawson_Creek differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Denver b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Denver
new file mode 100644
index 0000000..f8908fe
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Denver differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Detroit b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Detroit
new file mode 100644
index 0000000..da53d46
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Detroit differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Dominica b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Dominica
new file mode 100644
index 0000000..7783831
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Dominica differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Edmonton b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Edmonton
new file mode 100644
index 0000000..ba6dbb4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Edmonton differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Eirunepe b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Eirunepe
new file mode 100644
index 0000000..bc6558f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Eirunepe differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/El_Salvador b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/El_Salvador
new file mode 100644
index 0000000..ac774e8
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/El_Salvador differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Ensenada b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Ensenada
new file mode 100644
index 0000000..1bf00cd
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Ensenada differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Fort_Wayne b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Fort_Wayne
new file mode 100644
index 0000000..aa3dfc4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Fort_Wayne differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Fortaleza b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Fortaleza
new file mode 100644
index 0000000..2598c53
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Fortaleza differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Glace_Bay b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Glace_Bay
new file mode 100644
index 0000000..199f0b0
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Glace_Bay differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Godthab b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Godthab
new file mode 100644
index 0000000..85623ce
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Godthab differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Goose_Bay b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Goose_Bay
new file mode 100644
index 0000000..07c88e5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Goose_Bay differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Grand_Turk b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Grand_Turk
new file mode 100644
index 0000000..733c179
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Grand_Turk differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Grenada b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Grenada
new file mode 100644
index 0000000..df1b689
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Grenada differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Guadeloupe b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Guadeloupe
new file mode 100644
index 0000000..15c0f1f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Guadeloupe differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Guatemala b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Guatemala
new file mode 100644
index 0000000..6118b5c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Guatemala differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Guayaquil b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Guayaquil
new file mode 100644
index 0000000..e6de7f8
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Guayaquil differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Guyana b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Guyana
new file mode 100644
index 0000000..5f98c4a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Guyana differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Halifax b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Halifax
new file mode 100644
index 0000000..b98c3a7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Halifax differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Havana b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Havana
new file mode 100644
index 0000000..2139d1f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Havana differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Hermosillo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Hermosillo
new file mode 100644
index 0000000..08ce31c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Hermosillo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Indianapolis b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Indianapolis
new file mode 100644
index 0000000..aa3dfc4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Indianapolis differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Knox b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Knox
new file mode 100644
index 0000000..6e66a41
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Knox differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Marengo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Marengo
new file mode 100644
index 0000000..255b739
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Marengo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Petersburg b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Petersburg
new file mode 100644
index 0000000..c611106
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Petersburg differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Tell_City b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Tell_City
new file mode 100644
index 0000000..de7b730
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Tell_City differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Vevay b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Vevay
new file mode 100644
index 0000000..de6167c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Vevay differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Vincennes b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Vincennes
new file mode 100644
index 0000000..b79f672
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Vincennes differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Winamac b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Winamac
new file mode 100644
index 0000000..b2611e7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indiana/Winamac differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indianapolis b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indianapolis
new file mode 100644
index 0000000..aa3dfc4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Indianapolis differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Inuvik b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Inuvik
new file mode 100644
index 0000000..c17af37
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Inuvik differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Iqaluit b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Iqaluit
new file mode 100644
index 0000000..a8640e5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Iqaluit differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Jamaica b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Jamaica
new file mode 100644
index 0000000..09e3eb9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Jamaica differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Jujuy b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Jujuy
new file mode 100644
index 0000000..45b806b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Jujuy differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Juneau b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Juneau
new file mode 100644
index 0000000..7ca47f6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Juneau differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Kentucky/Louisville b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Kentucky/Louisville
new file mode 100644
index 0000000..65e7e19
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Kentucky/Louisville differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Kentucky/Monticello b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Kentucky/Monticello
new file mode 100644
index 0000000..fc2f1b0
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Kentucky/Monticello differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Knox_IN b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Knox_IN
new file mode 100644
index 0000000..6e66a41
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Knox_IN differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/La_Paz b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/La_Paz
new file mode 100644
index 0000000..2a5a15e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/La_Paz differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Lima b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Lima
new file mode 100644
index 0000000..a37eeff
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Lima differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Los_Angeles b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Los_Angeles
new file mode 100644
index 0000000..3b7ce1d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Los_Angeles differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Louisville b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Louisville
new file mode 100644
index 0000000..65e7e19
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Louisville differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Maceio b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Maceio
new file mode 100644
index 0000000..b5201e8
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Maceio differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Managua b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Managua
new file mode 100644
index 0000000..54c8237
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Managua differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Manaus b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Manaus
new file mode 100644
index 0000000..1129211
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Manaus differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Marigot b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Marigot
new file mode 100644
index 0000000..15c0f1f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Marigot differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Martinique b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Martinique
new file mode 100644
index 0000000..c223ef5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Martinique differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Mazatlan b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Mazatlan
new file mode 100644
index 0000000..6486aa1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Mazatlan differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Mendoza b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Mendoza
new file mode 100644
index 0000000..7ebf85e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Mendoza differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Menominee b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Menominee
new file mode 100644
index 0000000..c07a950
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Menominee differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Merida b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Merida
new file mode 100644
index 0000000..38c794c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Merida differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Mexico_City b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Mexico_City
new file mode 100644
index 0000000..1434ab0
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Mexico_City differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Miquelon b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Miquelon
new file mode 100644
index 0000000..52cd391
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Miquelon differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Moncton b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Moncton
new file mode 100644
index 0000000..3312575
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Moncton differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Monterrey b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Monterrey
new file mode 100644
index 0000000..7dc5057
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Monterrey differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Montevideo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Montevideo
new file mode 100644
index 0000000..40fc865
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Montevideo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Montreal b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Montreal
new file mode 100644
index 0000000..0ddffb2
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Montreal differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Montserrat b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Montserrat
new file mode 100644
index 0000000..ee5043a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Montserrat differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Nassau b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Nassau
new file mode 100644
index 0000000..aff956c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Nassau differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/New_York b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/New_York
new file mode 100644
index 0000000..b2c2377
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/New_York differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Nipigon b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Nipigon
new file mode 100644
index 0000000..fced633
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Nipigon differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Nome b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Nome
new file mode 100644
index 0000000..b682bfd
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Nome differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Noronha b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Noronha
new file mode 100644
index 0000000..c602390
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Noronha differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/North_Dakota/Center b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/North_Dakota/Center
new file mode 100644
index 0000000..786ba17
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/North_Dakota/Center differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/North_Dakota/New_Salem b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/North_Dakota/New_Salem
new file mode 100644
index 0000000..3488e46
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/North_Dakota/New_Salem differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Panama b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Panama
new file mode 100644
index 0000000..3a4ff2a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Panama differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Pangnirtung b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Pangnirtung
new file mode 100644
index 0000000..bb42847
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Pangnirtung differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Paramaribo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Paramaribo
new file mode 100644
index 0000000..6f889cc
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Paramaribo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Phoenix b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Phoenix
new file mode 100644
index 0000000..6758902
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Phoenix differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Port-au-Prince b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Port-au-Prince
new file mode 100644
index 0000000..cd10479
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Port-au-Prince differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Port_of_Spain b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Port_of_Spain
new file mode 100644
index 0000000..bdedd1b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Port_of_Spain differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Porto_Acre b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Porto_Acre
new file mode 100644
index 0000000..edd9a57
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Porto_Acre differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Porto_Velho b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Porto_Velho
new file mode 100644
index 0000000..1277479
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Porto_Velho differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Puerto_Rico b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Puerto_Rico
new file mode 100644
index 0000000..eada37a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Puerto_Rico differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Rainy_River b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Rainy_River
new file mode 100644
index 0000000..a5288ed
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Rainy_River differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Rankin_Inlet b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Rankin_Inlet
new file mode 100644
index 0000000..cbc3499
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Rankin_Inlet differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Recife b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Recife
new file mode 100644
index 0000000..0903a77
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Recife differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Regina b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Regina
new file mode 100644
index 0000000..fa9c6ee
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Regina differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Resolute b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Resolute
new file mode 100644
index 0000000..49dea46
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Resolute differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Rio_Branco b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Rio_Branco
new file mode 100644
index 0000000..edd9a57
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Rio_Branco differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Rosario b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Rosario
new file mode 100644
index 0000000..1a335d4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Rosario differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Santiago b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Santiago
new file mode 100644
index 0000000..9ca7c1f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Santiago differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Santo_Domingo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Santo_Domingo
new file mode 100644
index 0000000..23ace9a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Santo_Domingo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Sao_Paulo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Sao_Paulo
new file mode 100644
index 0000000..846caab
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Sao_Paulo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Scoresbysund b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Scoresbysund
new file mode 100644
index 0000000..fae3757
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Scoresbysund differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Shiprock b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Shiprock
new file mode 100644
index 0000000..f8908fe
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Shiprock differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Barthelemy b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Barthelemy
new file mode 100644
index 0000000..15c0f1f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Barthelemy differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Johns b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Johns
new file mode 100644
index 0000000..4842874
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Johns differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Kitts b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Kitts
new file mode 100644
index 0000000..911d222
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Kitts differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Lucia b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Lucia
new file mode 100644
index 0000000..b37a1cf
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Lucia differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Thomas b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Thomas
new file mode 100644
index 0000000..482f0b5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Thomas differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Vincent b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Vincent
new file mode 100644
index 0000000..e553af7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/St_Vincent differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Swift_Current b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Swift_Current
new file mode 100644
index 0000000..8224028
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Swift_Current differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Tegucigalpa b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Tegucigalpa
new file mode 100644
index 0000000..477e939
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Tegucigalpa differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Thule b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Thule
new file mode 100644
index 0000000..2969ebe
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Thule differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Thunder_Bay b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Thunder_Bay
new file mode 100644
index 0000000..34f750b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Thunder_Bay differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Tijuana b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Tijuana
new file mode 100644
index 0000000..1bf00cd
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Tijuana differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Toronto b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Toronto
new file mode 100644
index 0000000..b126bc6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Toronto differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Tortola b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Tortola
new file mode 100644
index 0000000..6f9d932
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Tortola differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Vancouver b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Vancouver
new file mode 100644
index 0000000..b69358c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Vancouver differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Virgin b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Virgin
new file mode 100644
index 0000000..482f0b5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Virgin differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Whitehorse b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Whitehorse
new file mode 100644
index 0000000..15216d5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Whitehorse differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Winnipeg b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Winnipeg
new file mode 100644
index 0000000..5f9e35c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Winnipeg differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Yakutat b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Yakutat
new file mode 100644
index 0000000..8071602
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Yakutat differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Yellowknife b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Yellowknife
new file mode 100644
index 0000000..947bec9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/America/Yellowknife differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Casey b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Casey
new file mode 100644
index 0000000..19bc896
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Casey differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Davis b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Davis
new file mode 100644
index 0000000..79932d3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Davis differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/DumontDUrville b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/DumontDUrville
new file mode 100644
index 0000000..5ea18e6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/DumontDUrville differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Mawson b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Mawson
new file mode 100644
index 0000000..bda4421
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Mawson differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/McMurdo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/McMurdo
new file mode 100644
index 0000000..62ac42f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/McMurdo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Palmer b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Palmer
new file mode 100644
index 0000000..614c9b9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Palmer differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Rothera b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Rothera
new file mode 100644
index 0000000..b5dc735
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Rothera differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/South_Pole b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/South_Pole
new file mode 100644
index 0000000..62ac42f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/South_Pole differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Syowa b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Syowa
new file mode 100644
index 0000000..ba6e5f3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Syowa differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Vostok b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Vostok
new file mode 100644
index 0000000..e19e2b7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Antarctica/Vostok differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Arctic/Longyearbyen b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Arctic/Longyearbyen
new file mode 100644
index 0000000..6326961
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Arctic/Longyearbyen differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Aden b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Aden
new file mode 100644
index 0000000..5aa5a32
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Aden differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Almaty b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Almaty
new file mode 100644
index 0000000..52f941e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Almaty differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Amman b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Amman
new file mode 100644
index 0000000..befc1e2
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Amman differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Anadyr b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Anadyr
new file mode 100644
index 0000000..ddbdac3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Anadyr differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Aqtau b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Aqtau
new file mode 100644
index 0000000..31195d7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Aqtau differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Aqtobe b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Aqtobe
new file mode 100644
index 0000000..3683be2
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Aqtobe differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ashgabat b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ashgabat
new file mode 100644
index 0000000..589dbc1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ashgabat differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ashkhabad b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ashkhabad
new file mode 100644
index 0000000..589dbc1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ashkhabad differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Baghdad b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Baghdad
new file mode 100644
index 0000000..3ad3614
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Baghdad differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Bahrain b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Bahrain
new file mode 100644
index 0000000..d87b7ce
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Bahrain differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Baku b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Baku
new file mode 100644
index 0000000..72ae96e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Baku differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Bangkok b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Bangkok
new file mode 100644
index 0000000..44a1018
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Bangkok differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Beirut b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Beirut
new file mode 100644
index 0000000..c1270bc
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Beirut differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Bishkek b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Bishkek
new file mode 100644
index 0000000..fc827d8
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Bishkek differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Brunei b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Brunei
new file mode 100644
index 0000000..d6e713d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Brunei differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Calcutta b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Calcutta
new file mode 100644
index 0000000..bc909c9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Calcutta differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Choibalsan b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Choibalsan
new file mode 100644
index 0000000..043b7ed
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Choibalsan differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Chongqing b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Chongqing
new file mode 100644
index 0000000..8a7a28a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Chongqing differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Chungking b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Chungking
new file mode 100644
index 0000000..8a7a28a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Chungking differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Colombo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Colombo
new file mode 100644
index 0000000..e5aa06d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Colombo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dacca b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dacca
new file mode 100644
index 0000000..2e4ce78
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dacca differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Damascus b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Damascus
new file mode 100644
index 0000000..d7e1bb2
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Damascus differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dhaka b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dhaka
new file mode 100644
index 0000000..2e4ce78
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dhaka differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dili b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dili
new file mode 100644
index 0000000..b7ac96e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dili differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dubai b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dubai
new file mode 100644
index 0000000..53f70d5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dubai differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dushanbe b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dushanbe
new file mode 100644
index 0000000..c65ff2a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Dushanbe differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Gaza b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Gaza
new file mode 100644
index 0000000..02aa4c8
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Gaza differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Harbin b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Harbin
new file mode 100644
index 0000000..292bcb2
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Harbin differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ho_Chi_Minh b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ho_Chi_Minh
new file mode 100644
index 0000000..e8dc806
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ho_Chi_Minh differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Hong_Kong b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Hong_Kong
new file mode 100644
index 0000000..426f8c0
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Hong_Kong differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Hovd b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Hovd
new file mode 100644
index 0000000..27fab05
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Hovd differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Irkutsk b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Irkutsk
new file mode 100644
index 0000000..617621f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Irkutsk differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Istanbul b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Istanbul
new file mode 100644
index 0000000..a7c16e7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Istanbul differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Jakarta b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Jakarta
new file mode 100644
index 0000000..a4cbe0c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Jakarta differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Jayapura b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Jayapura
new file mode 100644
index 0000000..af227c0
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Jayapura differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Jerusalem b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Jerusalem
new file mode 100644
index 0000000..f64f3af
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Jerusalem differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kabul b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kabul
new file mode 100644
index 0000000..7392c04
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kabul differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kamchatka b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kamchatka
new file mode 100644
index 0000000..4e53daa
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kamchatka differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Karachi b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Karachi
new file mode 100644
index 0000000..5b8eced
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Karachi differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kashgar b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kashgar
new file mode 100644
index 0000000..25e6494
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kashgar differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Katmandu b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Katmandu
new file mode 100644
index 0000000..65c7b63
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Katmandu differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kolkata b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kolkata
new file mode 100644
index 0000000..bc909c9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kolkata differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Krasnoyarsk b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Krasnoyarsk
new file mode 100644
index 0000000..9b2fb8e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Krasnoyarsk differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kuala_Lumpur b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kuala_Lumpur
new file mode 100644
index 0000000..41bba37
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kuala_Lumpur differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kuching b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kuching
new file mode 100644
index 0000000..272f465
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kuching differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kuwait b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kuwait
new file mode 100644
index 0000000..1dab31c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Kuwait differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Macao b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Macao
new file mode 100644
index 0000000..7c93779
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Macao differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Macau b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Macau
new file mode 100644
index 0000000..7c93779
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Macau differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Magadan b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Magadan
new file mode 100644
index 0000000..7b3d505
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Magadan differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Makassar b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Makassar
new file mode 100644
index 0000000..736a25b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Makassar differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Manila b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Manila
new file mode 100644
index 0000000..efef03e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Manila differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Muscat b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Muscat
new file mode 100644
index 0000000..729d95e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Muscat differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Nicosia b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Nicosia
new file mode 100644
index 0000000..f7f10ab
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Nicosia differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Novosibirsk b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Novosibirsk
new file mode 100644
index 0000000..806ca1a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Novosibirsk differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Omsk b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Omsk
new file mode 100644
index 0000000..77b82ed
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Omsk differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Oral b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Oral
new file mode 100644
index 0000000..8da2a1d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Oral differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Phnom_Penh b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Phnom_Penh
new file mode 100644
index 0000000..b9768b1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Phnom_Penh differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Pontianak b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Pontianak
new file mode 100644
index 0000000..3e882dc
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Pontianak differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Pyongyang b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Pyongyang
new file mode 100644
index 0000000..e072692
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Pyongyang differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Qatar b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Qatar
new file mode 100644
index 0000000..49668c2
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Qatar differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Qyzylorda b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Qyzylorda
new file mode 100644
index 0000000..fc3bf46
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Qyzylorda differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Rangoon b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Rangoon
new file mode 100644
index 0000000..efae261
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Rangoon differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Riyadh b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Riyadh
new file mode 100644
index 0000000..6ebe393
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Riyadh differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Riyadh87 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Riyadh87
new file mode 100644
index 0000000..2edb566
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Riyadh87 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Riyadh88 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Riyadh88
new file mode 100644
index 0000000..0dac63b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Riyadh88 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Riyadh89 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Riyadh89
new file mode 100644
index 0000000..daba1e7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Riyadh89 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Saigon b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Saigon
new file mode 100644
index 0000000..e8dc806
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Saigon differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Sakhalin b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Sakhalin
new file mode 100644
index 0000000..b1fda9a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Sakhalin differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Samarkand b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Samarkand
new file mode 100644
index 0000000..191c07c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Samarkand differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Seoul b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Seoul
new file mode 100644
index 0000000..1c3c15f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Seoul differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Shanghai b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Shanghai
new file mode 100644
index 0000000..240c4c6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Shanghai differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Singapore b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Singapore
new file mode 100644
index 0000000..a6f2db8
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Singapore differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Taipei b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Taipei
new file mode 100644
index 0000000..9063636
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Taipei differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tashkent b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tashkent
new file mode 100644
index 0000000..5bc8062
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tashkent differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tbilisi b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tbilisi
new file mode 100644
index 0000000..6cca2d4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tbilisi differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tehran b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tehran
new file mode 100644
index 0000000..9166940
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tehran differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tel_Aviv b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tel_Aviv
new file mode 100644
index 0000000..f64f3af
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tel_Aviv differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Thimbu b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Thimbu
new file mode 100644
index 0000000..90294ae
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Thimbu differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Thimphu b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Thimphu
new file mode 100644
index 0000000..90294ae
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Thimphu differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tokyo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tokyo
new file mode 100644
index 0000000..058c1e9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Tokyo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ujung_Pandang b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ujung_Pandang
new file mode 100644
index 0000000..736a25b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ujung_Pandang differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ulaanbaatar b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ulaanbaatar
new file mode 100644
index 0000000..39bdd89
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ulaanbaatar differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ulan_Bator b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ulan_Bator
new file mode 100644
index 0000000..39bdd89
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Ulan_Bator differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Urumqi b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Urumqi
new file mode 100644
index 0000000..f46ff38
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Urumqi differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Vientiane b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Vientiane
new file mode 100644
index 0000000..9352adf
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Vientiane differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Vladivostok b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Vladivostok
new file mode 100644
index 0000000..8f880ce
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Vladivostok differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Yakutsk b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Yakutsk
new file mode 100644
index 0000000..5887a10
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Yakutsk differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Yekaterinburg b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Yekaterinburg
new file mode 100644
index 0000000..106477e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Yekaterinburg differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Yerevan b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Yerevan
new file mode 100644
index 0000000..3b4fb19
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Asia/Yerevan differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Azores b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Azores
new file mode 100644
index 0000000..19e4004
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Azores differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Bermuda b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Bermuda
new file mode 100644
index 0000000..54dd33d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Bermuda differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Canary b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Canary
new file mode 100644
index 0000000..972388b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Canary differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Cape_Verde b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Cape_Verde
new file mode 100644
index 0000000..5238ac8
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Cape_Verde differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Faeroe b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Faeroe
new file mode 100644
index 0000000..4dab7ef
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Faeroe differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Faroe b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Faroe
new file mode 100644
index 0000000..4dab7ef
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Faroe differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Jan_Mayen b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Jan_Mayen
new file mode 100644
index 0000000..6326961
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Jan_Mayen differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Madeira b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Madeira
new file mode 100644
index 0000000..2175096
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Madeira differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Reykjavik b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Reykjavik
new file mode 100644
index 0000000..e97f13a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Reykjavik differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/South_Georgia b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/South_Georgia
new file mode 100644
index 0000000..ab2c823
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/South_Georgia differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/St_Helena b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/St_Helena
new file mode 100644
index 0000000..d365e3d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/St_Helena differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Stanley b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Stanley
new file mode 100644
index 0000000..33a6bbe
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Atlantic/Stanley differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/ACT b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/ACT
new file mode 100644
index 0000000..d95c245
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/ACT differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Adelaide b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Adelaide
new file mode 100644
index 0000000..b350cb6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Adelaide differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Brisbane b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Brisbane
new file mode 100644
index 0000000..3e899a1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Brisbane differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Broken_Hill b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Broken_Hill
new file mode 100644
index 0000000..d8f3155
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Broken_Hill differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Canberra b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Canberra
new file mode 100644
index 0000000..d95c245
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Canberra differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Currie b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Currie
new file mode 100644
index 0000000..43ca1e4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Currie differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Darwin b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Darwin
new file mode 100644
index 0000000..c44512f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Darwin differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Eucla b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Eucla
new file mode 100644
index 0000000..e78c2d4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Eucla differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Hobart b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Hobart
new file mode 100644
index 0000000..c4604e5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Hobart differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/LHI b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/LHI
new file mode 100644
index 0000000..1f542d3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/LHI differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Lindeman b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Lindeman
new file mode 100644
index 0000000..05c3c1c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Lindeman differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Lord_Howe b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Lord_Howe
new file mode 100644
index 0000000..1f542d3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Lord_Howe differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Melbourne b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Melbourne
new file mode 100644
index 0000000..af3152f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Melbourne differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/NSW b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/NSW
new file mode 100644
index 0000000..d95c245
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/NSW differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/North b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/North
new file mode 100644
index 0000000..c44512f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/North differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Perth b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Perth
new file mode 100644
index 0000000..1c7ebb7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Perth differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Queensland b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Queensland
new file mode 100644
index 0000000..3e899a1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Queensland differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/South b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/South
new file mode 100644
index 0000000..b350cb6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/South differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Sydney b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Sydney
new file mode 100644
index 0000000..d95c245
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Sydney differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Tasmania b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Tasmania
new file mode 100644
index 0000000..c4604e5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Tasmania differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Victoria b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Victoria
new file mode 100644
index 0000000..af3152f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Victoria differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/West b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/West
new file mode 100644
index 0000000..1c7ebb7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/West differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Yancowinna b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Yancowinna
new file mode 100644
index 0000000..d8f3155
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Australia/Yancowinna differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Brazil/Acre b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Brazil/Acre
new file mode 100644
index 0000000..edd9a57
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Brazil/Acre differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Brazil/DeNoronha b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Brazil/DeNoronha
new file mode 100644
index 0000000..c602390
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Brazil/DeNoronha differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Brazil/East b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Brazil/East
new file mode 100644
index 0000000..846caab
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Brazil/East differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Brazil/West b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Brazil/West
new file mode 100644
index 0000000..1129211
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Brazil/West differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/CET b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/CET
new file mode 100644
index 0000000..28650ac
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/CET differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/CST6CDT b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/CST6CDT
new file mode 100644
index 0000000..5c8a1d9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/CST6CDT differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Atlantic b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Atlantic
new file mode 100644
index 0000000..b98c3a7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Atlantic differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Central b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Central
new file mode 100644
index 0000000..5f9e35c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Central differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/East-Saskatchewan b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/East-Saskatchewan
new file mode 100644
index 0000000..fa9c6ee
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/East-Saskatchewan differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Eastern b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Eastern
new file mode 100644
index 0000000..b126bc6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Eastern differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Mountain b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Mountain
new file mode 100644
index 0000000..ba6dbb4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Mountain differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Newfoundland b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Newfoundland
new file mode 100644
index 0000000..4842874
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Newfoundland differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Pacific b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Pacific
new file mode 100644
index 0000000..b69358c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Pacific differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Saskatchewan b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Saskatchewan
new file mode 100644
index 0000000..fa9c6ee
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Saskatchewan differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Yukon b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Yukon
new file mode 100644
index 0000000..15216d5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Canada/Yukon differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Chile/Continental b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Chile/Continental
new file mode 100644
index 0000000..9ca7c1f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Chile/Continental differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Chile/EasterIsland b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Chile/EasterIsland
new file mode 100644
index 0000000..a13f178
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Chile/EasterIsland differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Cuba b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Cuba
new file mode 100644
index 0000000..2139d1f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Cuba differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/EET b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/EET
new file mode 100644
index 0000000..beb273a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/EET differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/EST b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/EST
new file mode 100644
index 0000000..074a4fc
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/EST differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/EST5EDT b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/EST5EDT
new file mode 100644
index 0000000..54541fc
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/EST5EDT differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Egypt b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Egypt
new file mode 100644
index 0000000..39caffb
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Egypt differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT
new file mode 100644
index 0000000..2ee1429
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+0 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+0
new file mode 100644
index 0000000..2ee1429
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+0 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+1 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+1
new file mode 100644
index 0000000..67b88c9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+1 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+10 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+10
new file mode 100644
index 0000000..d564b28
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+10 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+11 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+11
new file mode 100644
index 0000000..52eb573
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+11 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+12 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+12
new file mode 100644
index 0000000..c54cead
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+12 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+2 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+2
new file mode 100644
index 0000000..e43b63f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+2 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+3 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+3
new file mode 100644
index 0000000..f029bac
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+3 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+4 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+4
new file mode 100644
index 0000000..0ad0ee3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+4 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+5 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+5
new file mode 100644
index 0000000..e53f3fe
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+5 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+6 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+6
new file mode 100644
index 0000000..b411496
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+6 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+7 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+7
new file mode 100644
index 0000000..32fa6dc
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+7 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+8 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+8
new file mode 100644
index 0000000..512578c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+8 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+9 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+9
new file mode 100644
index 0000000..d3e47e7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT+9 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-0 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-0
new file mode 100644
index 0000000..2ee1429
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-0 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-1 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-1
new file mode 100644
index 0000000..9a6adeb
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-1 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-10 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-10
new file mode 100644
index 0000000..37b93fb
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-10 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-11 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-11
new file mode 100644
index 0000000..f1af0e2
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-11 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-12 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-12
new file mode 100644
index 0000000..0fa4a8d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-12 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-13 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-13
new file mode 100644
index 0000000..0a5dbe1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-13 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-14 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-14
new file mode 100644
index 0000000..41c6a1d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-14 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-2 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-2
new file mode 100644
index 0000000..9f63268
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-2 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-3 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-3
new file mode 100644
index 0000000..38ccd8a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-3 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-4 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-4
new file mode 100644
index 0000000..43badfb
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-4 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-5 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-5
new file mode 100644
index 0000000..c88cf21
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-5 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-6 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-6
new file mode 100644
index 0000000..c1a0634
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-6 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-7 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-7
new file mode 100644
index 0000000..bc152ef
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-7 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-8 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-8
new file mode 100644
index 0000000..2c0de20
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-8 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-9 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-9
new file mode 100644
index 0000000..8a3bd45
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT-9 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT0 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT0
new file mode 100644
index 0000000..2ee1429
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/GMT0 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/Greenwich b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/Greenwich
new file mode 100644
index 0000000..2ee1429
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/Greenwich differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/UCT b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/UCT
new file mode 100644
index 0000000..a88c4b6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/UCT differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/UTC b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/UTC
new file mode 100644
index 0000000..5583f5b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/UTC differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/Universal b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/Universal
new file mode 100644
index 0000000..5583f5b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/Universal differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/Zulu b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/Zulu
new file mode 100644
index 0000000..5583f5b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Etc/Zulu differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Amsterdam b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Amsterdam
new file mode 100644
index 0000000..30ca324
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Amsterdam differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Andorra b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Andorra
new file mode 100644
index 0000000..cf9533a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Andorra differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Athens b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Athens
new file mode 100644
index 0000000..726e56c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Athens differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Belfast b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Belfast
new file mode 100644
index 0000000..fe63ff7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Belfast differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Belgrade b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Belgrade
new file mode 100644
index 0000000..b817364
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Belgrade differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Berlin b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Berlin
new file mode 100644
index 0000000..95ae6f9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Berlin differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Bratislava b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Bratislava
new file mode 100644
index 0000000..9ab78e9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Bratislava differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Brussels b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Brussels
new file mode 100644
index 0000000..2791ede
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Brussels differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Bucharest b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Bucharest
new file mode 100644
index 0000000..de2a5f0
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Bucharest differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Budapest b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Budapest
new file mode 100644
index 0000000..2806529
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Budapest differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Chisinau b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Chisinau
new file mode 100644
index 0000000..983cc70
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Chisinau differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Copenhagen b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Copenhagen
new file mode 100644
index 0000000..af7e926
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Copenhagen differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Dublin b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Dublin
new file mode 100644
index 0000000..3dec026
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Dublin differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Gibraltar b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Gibraltar
new file mode 100644
index 0000000..f3dbeb6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Gibraltar differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Guernsey b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Guernsey
new file mode 100644
index 0000000..fe63ff7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Guernsey differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Helsinki b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Helsinki
new file mode 100644
index 0000000..97229f3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Helsinki differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Isle_of_Man b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Isle_of_Man
new file mode 100644
index 0000000..fe63ff7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Isle_of_Man differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Istanbul b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Istanbul
new file mode 100644
index 0000000..a7c16e7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Istanbul differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Jersey b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Jersey
new file mode 100644
index 0000000..fe63ff7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Jersey differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Kaliningrad b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Kaliningrad
new file mode 100644
index 0000000..98ebee9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Kaliningrad differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Kiev b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Kiev
new file mode 100644
index 0000000..075cc02
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Kiev differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Lisbon b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Lisbon
new file mode 100644
index 0000000..168accf
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Lisbon differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Ljubljana b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Ljubljana
new file mode 100644
index 0000000..b817364
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Ljubljana differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/London b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/London
new file mode 100644
index 0000000..fe63ff7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/London differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Luxembourg b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Luxembourg
new file mode 100644
index 0000000..6c194a5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Luxembourg differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Madrid b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Madrid
new file mode 100644
index 0000000..9311959
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Madrid differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Malta b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Malta
new file mode 100644
index 0000000..5f518a1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Malta differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Mariehamn b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Mariehamn
new file mode 100644
index 0000000..97229f3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Mariehamn differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Minsk b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Minsk
new file mode 100644
index 0000000..6a45115
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Minsk differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Monaco b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Monaco
new file mode 100644
index 0000000..664f616
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Monaco differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Moscow b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Moscow
new file mode 100644
index 0000000..eb7619c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Moscow differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Nicosia b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Nicosia
new file mode 100644
index 0000000..f7f10ab
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Nicosia differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Oslo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Oslo
new file mode 100644
index 0000000..6326961
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Oslo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Paris b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Paris
new file mode 100644
index 0000000..fd8ea7d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Paris differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Podgorica b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Podgorica
new file mode 100644
index 0000000..b817364
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Podgorica differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Prague b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Prague
new file mode 100644
index 0000000..9ab78e9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Prague differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Riga b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Riga
new file mode 100644
index 0000000..abea45d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Riga differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Rome b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Rome
new file mode 100644
index 0000000..28ddffe
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Rome differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Samara b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Samara
new file mode 100644
index 0000000..196bd1d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Samara differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/San_Marino b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/San_Marino
new file mode 100644
index 0000000..28ddffe
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/San_Marino differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Sarajevo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Sarajevo
new file mode 100644
index 0000000..b817364
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Sarajevo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Simferopol b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Simferopol
new file mode 100644
index 0000000..ebb63b4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Simferopol differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Skopje b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Skopje
new file mode 100644
index 0000000..b817364
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Skopje differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Sofia b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Sofia
new file mode 100644
index 0000000..2ae3559
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Sofia differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Stockholm b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Stockholm
new file mode 100644
index 0000000..3bc6dbd
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Stockholm differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Tallinn b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Tallinn
new file mode 100644
index 0000000..4ba4424
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Tallinn differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Tirane b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Tirane
new file mode 100644
index 0000000..0b86017
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Tirane differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Tiraspol b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Tiraspol
new file mode 100644
index 0000000..983cc70
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Tiraspol differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Uzhgorod b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Uzhgorod
new file mode 100644
index 0000000..7032ab9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Uzhgorod differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Vaduz b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Vaduz
new file mode 100644
index 0000000..c4e20db
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Vaduz differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Vatican b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Vatican
new file mode 100644
index 0000000..28ddffe
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Vatican differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Vienna b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Vienna
new file mode 100644
index 0000000..8025ba5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Vienna differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Vilnius b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Vilnius
new file mode 100644
index 0000000..b6545b2
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Vilnius differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Volgograd b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Volgograd
new file mode 100644
index 0000000..6580758
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Volgograd differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Warsaw b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Warsaw
new file mode 100644
index 0000000..3797b1c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Warsaw differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Zagreb b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Zagreb
new file mode 100644
index 0000000..b817364
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Zagreb differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Zaporozhye b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Zaporozhye
new file mode 100644
index 0000000..2ccf899
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Zaporozhye differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Zurich b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Zurich
new file mode 100644
index 0000000..1f0c3da
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Europe/Zurich differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/GMT b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/GMT
new file mode 100644
index 0000000..2ee1429
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/GMT differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Greenwich b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Greenwich
new file mode 100644
index 0000000..2ee1429
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Greenwich differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/HST b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/HST
new file mode 100644
index 0000000..616c31b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/HST differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Hongkong b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Hongkong
new file mode 100644
index 0000000..426f8c0
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Hongkong differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Iceland b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Iceland
new file mode 100644
index 0000000..e97f13a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Iceland differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Antananarivo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Antananarivo
new file mode 100644
index 0000000..ef6e745
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Antananarivo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Chagos b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Chagos
new file mode 100644
index 0000000..864d3e2
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Chagos differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Christmas b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Christmas
new file mode 100644
index 0000000..686d5b3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Christmas differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Cocos b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Cocos
new file mode 100644
index 0000000..6f7d869
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Cocos differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Comoro b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Comoro
new file mode 100644
index 0000000..297c6db
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Comoro differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Kerguelen b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Kerguelen
new file mode 100644
index 0000000..1f42bbc
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Kerguelen differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Mahe b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Mahe
new file mode 100644
index 0000000..d048242
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Mahe differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Maldives b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Maldives
new file mode 100644
index 0000000..65e7eee
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Maldives differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Mauritius b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Mauritius
new file mode 100644
index 0000000..b2848b5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Mauritius differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Mayotte b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Mayotte
new file mode 100644
index 0000000..8401a37
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Mayotte differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Reunion b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Reunion
new file mode 100644
index 0000000..9b3830e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Indian/Reunion differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Iran b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Iran
new file mode 100644
index 0000000..9166940
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Iran differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Israel b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Israel
new file mode 100644
index 0000000..f64f3af
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Israel differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Jamaica b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Jamaica
new file mode 100644
index 0000000..09e3eb9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Jamaica differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Japan b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Japan
new file mode 100644
index 0000000..058c1e9
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Japan differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Kwajalein b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Kwajalein
new file mode 100644
index 0000000..b572372
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Kwajalein differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Libya b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Libya
new file mode 100644
index 0000000..943f9a3
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Libya differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/MET b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/MET
new file mode 100644
index 0000000..fee1909
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/MET differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/MST b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/MST
new file mode 100644
index 0000000..da3e926
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/MST differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/MST7MDT b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/MST7MDT
new file mode 100644
index 0000000..726a7e5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/MST7MDT differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mexico/BajaNorte b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mexico/BajaNorte
new file mode 100644
index 0000000..1bf00cd
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mexico/BajaNorte differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mexico/BajaSur b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mexico/BajaSur
new file mode 100644
index 0000000..6486aa1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mexico/BajaSur differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mexico/General b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mexico/General
new file mode 100644
index 0000000..1434ab0
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mexico/General differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mideast/Riyadh87 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mideast/Riyadh87
new file mode 100644
index 0000000..2edb566
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mideast/Riyadh87 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mideast/Riyadh88 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mideast/Riyadh88
new file mode 100644
index 0000000..0dac63b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mideast/Riyadh88 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mideast/Riyadh89 b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mideast/Riyadh89
new file mode 100644
index 0000000..daba1e7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Mideast/Riyadh89 differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Navajo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Navajo
new file mode 100644
index 0000000..f8908fe
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Navajo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/PST8PDT b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/PST8PDT
new file mode 100644
index 0000000..6242ac0
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/PST8PDT differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Apia b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Apia
new file mode 100644
index 0000000..b8d5890
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Apia differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Auckland b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Auckland
new file mode 100644
index 0000000..a40767d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Auckland differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Chatham b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Chatham
new file mode 100644
index 0000000..6329e4f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Chatham differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Easter b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Easter
new file mode 100644
index 0000000..a13f178
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Easter differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Efate b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Efate
new file mode 100644
index 0000000..c46154a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Efate differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Enderbury b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Enderbury
new file mode 100644
index 0000000..69e75d7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Enderbury differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Fakaofo b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Fakaofo
new file mode 100644
index 0000000..b3991ee
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Fakaofo differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Fiji b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Fiji
new file mode 100644
index 0000000..2a762c2
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Fiji differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Funafuti b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Funafuti
new file mode 100644
index 0000000..66cf5e1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Funafuti differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Galapagos b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Galapagos
new file mode 100644
index 0000000..7504cc6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Galapagos differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Gambier b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Gambier
new file mode 100644
index 0000000..fc49c03
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Gambier differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Guadalcanal b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Guadalcanal
new file mode 100644
index 0000000..3a4ec12
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Guadalcanal differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Guam b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Guam
new file mode 100644
index 0000000..a05292f
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Guam differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Honolulu b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Honolulu
new file mode 100644
index 0000000..9297d8c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Honolulu differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Johnston b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Johnston
new file mode 100644
index 0000000..616c31b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Johnston differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Kiritimati b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Kiritimati
new file mode 100644
index 0000000..7131453
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Kiritimati differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Kosrae b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Kosrae
new file mode 100644
index 0000000..6cac75a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Kosrae differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Kwajalein b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Kwajalein
new file mode 100644
index 0000000..b572372
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Kwajalein differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Majuro b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Majuro
new file mode 100644
index 0000000..eab93a2
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Majuro differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Marquesas b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Marquesas
new file mode 100644
index 0000000..cd2d5b0
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Marquesas differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Midway b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Midway
new file mode 100644
index 0000000..8889a26
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Midway differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Nauru b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Nauru
new file mode 100644
index 0000000..1d8179b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Nauru differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Niue b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Niue
new file mode 100644
index 0000000..b9f18a5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Niue differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Norfolk b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Norfolk
new file mode 100644
index 0000000..2e989c2
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Norfolk differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Noumea b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Noumea
new file mode 100644
index 0000000..ae9e138
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Noumea differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Pago_Pago b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Pago_Pago
new file mode 100644
index 0000000..fa084ba
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Pago_Pago differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Palau b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Palau
new file mode 100644
index 0000000..efc556b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Palau differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Pitcairn b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Pitcairn
new file mode 100644
index 0000000..51f01c6
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Pitcairn differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Ponape b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Ponape
new file mode 100644
index 0000000..f175ea5
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Ponape differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Port_Moresby b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Port_Moresby
new file mode 100644
index 0000000..8d4d12c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Port_Moresby differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Rarotonga b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Rarotonga
new file mode 100644
index 0000000..5812997
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Rarotonga differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Saipan b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Saipan
new file mode 100644
index 0000000..519c86e
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Saipan differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Samoa b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Samoa
new file mode 100644
index 0000000..fa084ba
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Samoa differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Tahiti b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Tahiti
new file mode 100644
index 0000000..22f8697
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Tahiti differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Tarawa b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Tarawa
new file mode 100644
index 0000000..065dcd8
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Tarawa differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Tongatapu b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Tongatapu
new file mode 100644
index 0000000..01ab6b8
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Tongatapu differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Truk b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Truk
new file mode 100644
index 0000000..4bb15e1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Truk differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Wake b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Wake
new file mode 100644
index 0000000..f89c528
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Wake differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Wallis b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Wallis
new file mode 100644
index 0000000..9aaf558
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Wallis differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Yap b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Yap
new file mode 100644
index 0000000..4bb15e1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Pacific/Yap differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Poland b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Poland
new file mode 100644
index 0000000..3797b1c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Poland differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Portugal b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Portugal
new file mode 100644
index 0000000..168accf
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Portugal differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Singapore b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Singapore
new file mode 100644
index 0000000..a6f2db8
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Singapore differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Turkey b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Turkey
new file mode 100644
index 0000000..a7c16e7
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Turkey differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Alaska b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Alaska
new file mode 100644
index 0000000..d147350
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Alaska differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Aleutian b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Aleutian
new file mode 100644
index 0000000..391ec98
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Aleutian differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Arizona b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Arizona
new file mode 100644
index 0000000..6758902
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Arizona differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Central b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Central
new file mode 100644
index 0000000..e932c6d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Central differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/East-Indiana b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/East-Indiana
new file mode 100644
index 0000000..aa3dfc4
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/East-Indiana differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Eastern b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Eastern
new file mode 100644
index 0000000..b2c2377
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Eastern differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Hawaii b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Hawaii
new file mode 100644
index 0000000..9297d8c
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Hawaii differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Indiana-Starke b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Indiana-Starke
new file mode 100644
index 0000000..6e66a41
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Indiana-Starke differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Michigan b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Michigan
new file mode 100644
index 0000000..da53d46
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Michigan differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Mountain b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Mountain
new file mode 100644
index 0000000..f8908fe
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Mountain differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Pacific b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Pacific
new file mode 100644
index 0000000..3b7ce1d
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Pacific differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Samoa b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Samoa
new file mode 100644
index 0000000..fa084ba
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/US/Samoa differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/UTC b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/UTC
new file mode 100644
index 0000000..5583f5b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/UTC differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Universal b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Universal
new file mode 100644
index 0000000..5583f5b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Universal differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/WET b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/WET
new file mode 100644
index 0000000..444a193
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/WET differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Zulu b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Zulu
new file mode 100644
index 0000000..5583f5b
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/local-time-20190710-git/zoneinfo/Zulu differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/.gitignore b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/.gitignore
new file mode 100644
index 0000000..3ba6dec
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/.gitignore
@@ -0,0 +1,3 @@
+*.fasl
+*.dx32fsl
+*.dx64fsl
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/.travis.yml b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/.travis.yml
new file mode 100644
index 0000000..026e237
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/.travis.yml
@@ -0,0 +1,50 @@
+language: common-lisp
+sudo: false
+
+env:
+  global:
+    - PATH=~/.roswell/bin:$PATH
+    - ROSWELL_BRANCH=release
+    - ROSWELL_INSTALL_DIR=$HOME/.roswell
+  matrix:
+    - LISP=sbcl-bin
+    - LISP=ccl-bin
+    - LISP=ecl
+    - LISP=abcl
+    - LISP=allegro
+    - LISP=cmucl
+    - LISP=clisp
+
+matrix:
+  allow_failures:
+    # there is some issue with clisp,
+    # roswell installs ASDF3, but clisp doesn't see it
+    - env: LISP=clisp
+
+addons:
+  apt:
+    packages:
+      # it is required for some reason
+      # to install allegrocl and cmucl
+      - libc6-i386
+      
+install:
+  - curl -L https://raw.githubusercontent.com/snmsts/roswell/$ROSWELL_BRANCH/scripts/install-for-ci.sh | sh
+
+before_script:
+  - ros --version
+  - ros config
+  - ros -e '(princ (lisp-implementation-type))
+            (terpri)
+            (princ (lisp-implementation-version))
+            (terpri)
+            (princ *features*)
+            (terpri)'
+
+
+script:
+  # prove-asdf must be independent.
+  - ros +Q -e '(require "asdf")' -l prove-asdf.asd -e '(asdf:load-system :prove-asdf)'
+  - ros -l prove.asd -e '(ql:quickload :prove)'
+  - ros -l cl-test-more.asd -e '(ql:quickload :cl-test-more)'
+  - ros -e '(ql:quickload :prove) (uiop:quit (if (prove:run-test-system :prove-test) 0 1))'
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/README.markdown b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/README.markdown
new file mode 100644
index 0000000..358c1e9
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/README.markdown
@@ -0,0 +1,369 @@
+# prove
+
+_This project was originally called 'CL-TEST-MORE'._
+
+'prove' is yet another unit testing framework for Common Lisp.
+
+The advantages of 'prove' are:
+
+* Various simple functions for testing and informative error messages
+* [ASDF integration](#asdf-integration)
+* [Extensible test reporters](#reporters)
+* Colorizes the report if it's available ([note for SLIME](#colorize-test-reports-on-slime))
+* Reports test durations
+
+## Quickstart
+
+### 1. Writing a test file
+
+```common-lisp
+(in-package :cl-user)
+(defpackage my-test
+  (:use :cl
+        :prove))
+(in-package :my-test)
+
+(plan 3)
+
+(ok (not (find 4 '(1 2 3))))
+(is 4 4)
+(isnt 1 #\1)
+
+(finalize)
+```
+
+### 2. Run a test file
+
+```common-lisp
+(prove:run #P"myapp/tests/my-test.lisp")
+(prove:run #P"myapp/tests/my-test.lisp" :reporter :list)
+```
+
+See also: [ASDF integration](#asdf-integration), [Reporters](#reporters)
+
+### 3. Get a report
+
+![](images/passed.png)
+
+![](images/failed.png)
+
+## Installation
+
+You can install 'prove' via [Quicklisp](http://www.quicklisp.org/beta/).
+
+```common-lisp
+(ql:quickload :prove)
+```
+
+## Testing functions
+
+### (ok test &optional desc)
+
+Checks if `test` is true (non-NIL).
+
+```common-lisp
+(ok 1)
+;->  ✓ 1 is expected to be T
+```
+
+### (is got expected &rest test-args)
+
+Checks if `got` is equivalent to `expected`.
+
+```common-lisp
+(is 1 1)
+;->  ✓ 1 is expected to be 1
+
+(is #(1 2 3) #(1 2 3))
+;->  × #(1 2 3) is expected to be #(1 2 3)
+
+(is #(1 2 3) #(1 2 3) :test #'equalp)
+;->  ✓ #(1 2 3) is expected to be #(1 2 3)
+
+;; with description
+(is 1 #\1 "Integer = Character ?")
+;->  × Integer = Character ?
+```
+
+### (isnt got expected &rest test-args)
+
+Checks if `got` is _not_ equivalent to `expected`.
+
+```common-lisp
+(isnt 1 1)
+;->  × 1 is not expected to be 1
+
+(isnt #(1 2 3) #(1 2 3))
+;->  ✓ #(1 2 3) is not expected to be #(1 2 3)
+```
+
+### (is-values got expected &rest test-args)
+
+Checks if the multiple values of `got` is equivalent to `expected`. This is same to `(is (multiple-value-list got) expected)`.
+
+```common-lisp
+(defvar *person* (make-hash-table))
+
+(is-values (gethash :name *person*) '("Eitaro" T))
+;->  × (NIL NIL) is expected to be ("Eitaro" T)
+
+(setf (gethash :name *person*) "Eitaro")
+
+(is-values (gethash :name *person*) '("Eitaro" T))
+;->  ✓ ("Eitaro" T) is expected to be ("Eitaro" T)
+```
+
+### (is-type got expected-type &optional desc)
+
+Checks if `got` is a type of `expected-type`.
+
+```common-lisp
+(is-type #(1 2 3) 'simple-vector)
+;->  ✓ #(1 2 3) is expected to be a type of SIMPLE-VECTOR (got (SIMPLE-VECTOR 3))
+
+(is-type (make-array 0 :adjustable t) 'simple-vector)
+;->  × #() is expected to be a type of SIMPLE-VECTOR (got (VECTOR T 0))
+```
+
+### (like got regex &optional desc)
+
+Checks if `got` matches a regular expression `regex`.
+
+```common-lisp
+(like "Hatsune 39" "\\d")
+;->  ✓ "Hatsune 39" is expected to be like "\\d"
+
+(like "初音ミク" "\\d")
+;->  × "初音ミク" is expected to be like "\\d"
+```
+
+### (is-print got expected &optional desc)
+
+Checks if `got` outputs `expected` to `*standard-output*`
+
+```common-lisp
+(is-print (princ "Hi, there") "Hi, there")
+;->  ✓ (PRINC "Hi, there") is expected to output "Hi, there" (got "Hi, there")
+```
+
+### (is-error form condition &optional desc)
+
+Checks if `form` raises a condition and that is a subtype of `condition`.
+
+```common-lisp
+(is-error (error "Something wrong") 'simple-error)
+;->  ✓ (ERROR "Something wrong") is expected to raise a condition SIMPLE-ERROR (got #<SIMPLE-ERROR "Something wrong" {100628FE53}>)
+
+(define-condition my-error (simple-error) ())
+
+(is-error (error "Something wrong") 'my-error)
+;->  × (ERROR "Something wrong") is expected to raise a condition MY-ERROR (got #<SIMPLE-ERROR "Something wrong" {100648E553}>)
+```
+
+### (is-expand got expected &optional desc)
+
+Checks if `got` will be `macroexpand`ed to `expected`.
+
+```common-lisp
+(is-expand (when T (princ "Hi")) (if T (progn (princ "Hi"))))
+;->  ✓ (WHEN T (PRINC "Hi")) is expected to be expanded to (IF T
+;                                                          (PROGN (PRINC "Hi"))) (got (IF T
+;                                                                                         (PROGN
+;                                                                                          (PRINC
+;                                                                                           "Hi"))
+;                                                                                         NIL))
+```
+
+If a symbol that starts with "$" is contained, it will be treated as a gensym.
+
+### (pass desc)
+
+This will always be passed. This is convenient if the test case is complicated and hard to test with `ok`.
+
+```common-lisp
+(pass "Looks good")
+;->  ✓ Looks good
+```
+
+### (fail desc)
+
+This will always be failed. This is convenient if the test case is complicated and hard to test with `ok`.
+
+```common-lisp
+(fail "Hopeless")
+;->  × Hopeless
+```
+
+### (skip how-many why)
+
+Skip a number of `how-many` tests and mark them passed.
+
+```common-lisp
+(skip 3 "No need to test these on Mac OS X")
+;->  ✓ No need to test these on Mac OS X (Skipped)
+;    ✓ No need to test these on Mac OS X (Skipped)
+;    ✓ No need to test these on Mac OS X (Skipped)
+```
+
+### (subtest desc &body body)
+
+Run tests of `body` in a new sub test suite.
+
+```common-lisp
+(subtest "Testing integers"
+  (is 1 1)
+  (is-type 1 'bit)
+  (is-type 10 'fixnum))
+;->      ✓ 1 is expected to be 1
+;        ✓ 1 is expected to be a type of BIT (got BIT)
+;        ✓ 10 is expected to be a type of FIXNUM (got (INTEGER 0 4611686018427387903))
+;->  ✓ Testing integers
+```
+
+## Other functions
+
+### (diag desc)
+
+Outputs `desc` to a `*test-result-output*`.
+
+```common-lisp
+(diag "Gonna run tests")
+;-> # Gonna run tests
+```
+
+### (plan num)
+
+Declares a number of `num` tests are going to run. If `finalize` is called with no `plan`, a warning message will be output. `num` is allows to be `NIL` if you have no plan yet.
+
+### (finalize)
+
+Finalizes the current test suite and outputs the test reports.
+
+### (slow-threshold milliseconds)
+
+Set the threshold of slow test durations for the current test suite. The default threshold value is `prove:*default-slow-threshold*`.
+
+```common-lisp
+(slow-threshold 150)
+```
+
+## Reporters
+
+You can change the test report formats by setting `prove:*default-reporter*` to `:list`, `:dot`, `:tap` or `:fiveam`. The default value is `:list`.
+
+`prove:run` also takes a keyword argument `:reporter`.
+
+### List (Default)
+
+The `:list` repoter outputs test results list as test cases pass or fail.
+
+![](images/list.png)
+
+### Dot
+
+The `:dot` reporter outputs a series of dots that represent test cases, failures highlight in red, skipping in cyan.
+
+![](images/dot.png)
+
+### FiveAM
+
+The `:fiveam` reporter outputs test results like [FiveAM](http://common-lisp.net/project/fiveam/) does.
+
+![](images/fiveam.png)
+
+### TAP
+
+The `:tap` reporter outputs in [Test Anything Protocol](http://testanything.org) format.
+
+![](images/tap.png)
+
+## Tips
+
+### Debugging with CL debugger
+
+Set `prove:*debug-on-error*` T for invoking CL debugger whenever getting an error during running tests.
+
+### Colorize test reports on SLIME
+
+SLIME doesn't support to color with ANSI colors in the REPL buffer officially.
+
+You can add the feature by using [slime-repl-ansi-color.el](https://github.com/enriquefernandez/slime-repl-ansi-color).
+
+After installing it, set `prove:*enable-colors*` to `T` before running tests.
+
+```common-lisp
+;; A part of my ~/.sbclrc
+(ql:quickload :prove)
+(setf prove:*enable-colors* t)
+```
+
+The following snippet is a little bit complicated, however it would be better if you don't like to load `prove` in all sessions.
+
+```common-lisp
+(defmethod asdf:perform :after ((op asdf:load-op) (c (eql (asdf:find-system :prove))))
+  (setf (symbol-value (intern (string :*enable-colors*) :prove)) t))
+```
+
+### ASDF integration
+
+Add `:defsystem-depends-on (:prove-asdf)` to your testing ASDF system to enable `:test-file` in the `:components`.
+
+`:test-file` is same as `:file` except it will be loaded only when `asdf:test-system`.
+
+```common-lisp
+;; Main ASDF system
+(defsystem my-app
+
+  ;; ...
+
+  :in-order-to ((test-op (test-op my-app-test))))
+
+;; Testing ASDF system
+(defsystem my-app-test
+  :depends-on (:my-app
+               :prove)
+  :defsystem-depends-on (:prove-asdf)
+  :components
+  ((:test-file "my-app"))
+  :perform (test-op :after (op c)
+                    (funcall (intern #.(string :run) :prove) c)))
+```
+
+To run tests, execute `asdf:test-system` or `prove:run` in your REPL.
+
+```common-lisp
+(asdf:test-system :my-app)
+(asdf:test-system :my-app-test)
+
+;; Same as 'asdf:test-system' except it returns T or NIL as the result of tests.
+(prove:run :my-app-test)
+```
+
+### Changing default test function
+
+Test functions like `is` uses `prove:*default-test-function*` for testing if no `:test` argument is specified. The default value is `#'equal`.
+
+### Changing output stream
+
+Test reports will be output to `prove:*test-result-output*`. The default value is `T`, which means `*standard-output*`.
+
+### Running tests on Travis CI
+
+Although Common Lisp isn't supported by Travis CI officially, you can run tests by using [cl-travis](https://github.com/luismbo/cl-travis).
+
+Here's a list of `.travis.yml` from projects using `prove` on Travis CI:
+
+- [Clack](https://github.com/fukamachi/clack/blob/master/.travis.yml)
+- [CL-DBI](https://github.com/fukamachi/cl-dbi/blob/master/.travis.yml)
+- [Woo](https://github.com/fukamachi/Woo/blob/master/.travis.yml)
+- [fast-http](https://github.com/fukamachi/fast-http/blob/master/.travis.yml)
+- [defclass-std](https://github.com/EuAndreh/defclass-std/blob/master/.travis.yml)
+
+## Bugs
+
+Please report any bugs to e.arrows@gmail.com, or post an issue to [GitHub](http://github.com/fukamachi/prove/issues).
+
+## License
+
+Copyright (c) 2010-2014 Eitaro Fukamachi &lt;e.arrows@gmail.com&gt;  
+'prove' and CL-TEST-MORE is freely distributable under the MIT License (http://www.opensource.org/licenses/mit-license).
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/cl-test-more.asd b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/cl-test-more.asd
new file mode 100644
index 0000000..374db79
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/cl-test-more.asd
@@ -0,0 +1,5 @@
+(defsystem "cl-test-more"
+  :version "2.0.0"
+  :author "Eitaro Fukamachi"
+  :license "MIT"
+  :depends-on ("prove"))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/dot.png b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/dot.png
new file mode 100644
index 0000000..ca3cb6a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/dot.png differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/failed.png b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/failed.png
new file mode 100644
index 0000000..5f0abd1
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/failed.png differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/fiveam.png b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/fiveam.png
new file mode 100644
index 0000000..9ce0a03
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/fiveam.png differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/list.png b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/list.png
new file mode 100644
index 0000000..20e728a
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/list.png differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/passed.png b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/passed.png
new file mode 100644
index 0000000..0155607
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/passed.png differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/tap.png b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/tap.png
new file mode 100644
index 0000000..8f08437
Binary files /dev/null and b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/images/tap.png differ
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/prove-asdf.asd b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/prove-asdf.asd
new file mode 100644
index 0000000..ebf3d9a
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/prove-asdf.asd
@@ -0,0 +1,5 @@
+(defsystem "prove-asdf"
+  :components ((:module "src"
+                :components
+                ((:file "asdf" :depends-on ("output"))
+                 (:file "output")))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/prove-test.asd b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/prove-test.asd
new file mode 100644
index 0000000..2506bea
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/prove-test.asd
@@ -0,0 +1,15 @@
+(defsystem "prove-test"
+  :author "Eitaro Fukamachi"
+  :license "MIT"
+  :depends-on (:split-sequence
+               :alexandria
+               :prove)
+  :components ((:module "t"
+                :serial t
+                :components
+                 ((:file "utils")
+                  (:test-file "prove"))))
+  :description "Test system for Prove."
+
+  :defsystem-depends-on ("prove-asdf")
+  :perform (test-op (o c) (symbol-call :prove-asdf :run-test-system c)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/prove.asd b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/prove.asd
new file mode 100644
index 0000000..8bddb12
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/prove.asd
@@ -0,0 +1,27 @@
+(defsystem "prove"
+  :version "1.0.0"
+  :author "Eitaro Fukamachi"
+  :license "MIT"
+  :depends-on ("cl-ppcre"
+               "cl-ansi-text"
+               "cl-colors"
+               "alexandria"
+               "uiop")
+  :components ((:module "src"
+                :components
+                ((:file "prove" :depends-on ("output" "test" "suite" "asdf" "color"))
+                 (:file "test" :depends-on ("output" "report" "reporter" "suite"))
+                 (:file "report")
+                 (:file "reporter" :depends-on ("report" "output"))
+                 (:module "reporter-components"
+                  :pathname "reporter"
+                  :depends-on ("report" "reporter" "color")
+                  :components
+                  ((:file "tap")
+                   (:file "fiveam")
+                   (:file "list")
+                   (:file "dot" :depends-on ("list"))))
+                 (:file "suite" :depends-on ("output" "report" "reporter" "asdf"))
+                 (:file "asdf" :depends-on ("output" "color"))
+                 (:file "color")
+                 (:file "output")))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/roswell/run-prove.ros b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/roswell/run-prove.ros
new file mode 100644
index 0000000..4db1dc1
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/roswell/run-prove.ros
@@ -0,0 +1,58 @@
+#!/bin/sh
+#|-*- mode:lisp -*-|#
+#|
+exec ros -Q -- $0 "$@"
+|#
+
+(unless (find-package :uiop)
+  (ql:quickload :uiop :silent t))
+
+(ql:quickload :prove :silent t)
+
+(when (uiop:getenv "COVERALLS")
+  (ql:quickload '(:cl-coveralls :split-sequence) :silent t))
+
+(defun print-error (format-string &rest format-args)
+  (format *error-output* "~&[Error] ")
+  (apply #'format *error-output*
+         format-string format-args)
+  (fresh-line *error-output*)
+  (uiop:quit -1))
+
+(defun main (&rest test-files)
+  (let (reporter color)
+    (when (or (string= (first test-files) "-r")
+              (string= (first test-files) "--reporter"))
+      (setf reporter (second test-files)
+            test-files (cddr test-files)))
+    (flet ((not-color-p (arg) (or (string= "-c" arg)
+                                  (string= "--without-colors" arg))))
+      (setf color (not (loop :for a :in test-files :thereis (not-color-p a)))
+            test-files (remove-if #'not-color-p test-files)))
+    (labels ((run-tests ()
+               (not
+                (some #'null
+                      (mapcar (lambda (test-file)
+                                (unless (probe-file test-file)
+                                  (print-error "test file '~A' does not exist." test-file))
+                                (let ((prove.output:*default-reporter*
+                                        (or reporter
+                                            prove.output:*default-reporter*)))
+                                  (unless (string= (pathname-type (probe-file test-file)) "asd")
+                                    (print-error "test file '~A' is not an asd file." test-file))
+                                  (let ((test-file (probe-file test-file))
+                                        (prove:*enable-colors* color))
+                                    (#+asdf3.3 asdf::with-asdf-session
+                                     #-asdf3.3 asdf::with-asdf-cache ()
+                                      (asdf::load-asd test-file)
+                                      (prove:run-test-system (asdf:find-system (pathname-name test-file)))))))
+                              test-files)))))
+      (or #.(if (uiop:getenv "COVERALLS")
+                `(,(intern (string :with-coveralls) :coveralls)
+                  (:exclude
+                   (,(intern (string :split-sequence) :split-sequence)
+                    #\: (or (uiop:getenv "COVERAGE_EXCLUDE") "")
+                    :remove-empty-subseqs t))
+                  (run-tests))
+                '(run-tests))
+          (uiop:quit -1)))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/asdf.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/asdf.lisp
new file mode 100644
index 0000000..4cd6101
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/asdf.lisp
@@ -0,0 +1,144 @@
+(in-package :cl-user)
+(defpackage prove.asdf
+  (:nicknames :prove-asdf)
+  (:use :cl
+        :asdf)
+  (:import-from :prove.output
+                :*test-result-output*
+                :*default-reporter*)
+  (:export :test-file
+           :run-test-system
+           :run
+
+           :*last-suite-report*))
+(in-package :prove.asdf)
+
+(defvar *last-suite-report* nil)
+
+(defvar *system-test-files* (make-hash-table))
+
+(defclass test-file (asdf:cl-source-file) ())
+
+(defmethod asdf:perform ((op asdf:compile-op) (c test-file))
+  ;; do nothing
+  )
+
+#+asdf3
+(defmethod asdf::compute-action-stamp :around (plan (o asdf:operation) (c test-file) &key just-done)
+  (declare (ignore just-done))
+  (let ((*error-output* (make-broadcast-stream)))
+    (call-next-method)))
+
+(defmethod asdf:perform ((op asdf:load-op) (c test-file))
+  (pushnew c (gethash (asdf:component-system c) *system-test-files*)
+           :key #'asdf:component-pathname
+           :test #'equal))
+
+(defun run-test-system (system-designator)
+  "Runs a testing ASDF system."
+  #+quicklisp (ql:quickload (if (typep system-designator 'asdf:system)
+                                (asdf:component-name system-designator)
+                                system-designator))
+  #-quicklisp (asdf:load-system system-designator)
+  (let ((passed-files '()) (failed-files '()))
+    (restart-case
+        (dolist (c (reverse
+                    (gethash (asdf:find-system system-designator) *system-test-files*)))
+          (setf *last-suite-report* nil)
+          (format *test-result-output* "~2&Running a test file '~A'~%" (asdf:component-pathname c))
+          (restart-case
+              (progn
+                (asdf:perform 'asdf:load-source-op c)
+                (unless *last-suite-report*
+                  (warn "Test completed without 'finalize'd."))
+                (if (eql (getf *last-suite-report* :failed) 0)
+                    (push (asdf:component-pathname c) passed-files)
+                    (push (asdf:component-pathname c) failed-files)))
+            (skip-test-file ()
+              :report "Skip this test file."
+              (push (asdf:component-pathname c) failed-files))))
+      (skip-all-test-files ()
+        :report "Give up all test files."
+        nil))
+    (setf passed-files (nreverse passed-files)
+          failed-files (nreverse failed-files))
+    (format t "~2&Summary:~%")
+    (if failed-files
+        (format t "  ~D file~:*~P failed.~{~%    - ~A~}
+"
+                (length failed-files)
+                failed-files)
+        (format t "  All ~D file~:*~P passed.~%"
+                (length passed-files)))
+    (values (null failed-files)
+            passed-files
+            failed-files)))
+
+(defun test-files-in-directory (directory)
+  (check-type directory pathname)
+  (flet ((always-true (&rest args)
+           (declare (ignore args))
+           T))
+    (let ((directories '()))
+      (#+asdf3 uiop:collect-sub*directories
+       #-asdf3 asdf::collect-sub*directories
+       directory
+       #'always-true
+       #'always-true
+       (lambda (dir)
+         (push dir directories)))
+      (mapcan (lambda (dir)
+                (#+asdf3 uiop:directory-files
+                 #-asdf3 asdf::directory-files dir "*.lisp"))
+              (nreverse directories)))))
+
+(defun run (object &key (reporter *default-reporter*))
+  "Runs a test. OBJECT can be one of a file pathname, a directory pathname or an ASDF system name.
+Returns 3 multiple-values, a flag if the tests passed as T or NIL, passed test files as a list and failed test files also as a list.
+
+Example:
+  (prove:run :myapp-test)
+  (prove:run #P\"myapp/tests/\")
+  (prove:run #P\"myapp/tests/01-main.lisp\")
+"
+  (check-type reporter keyword)
+  (flet ((directory-pathname-p (path)
+           (string= (file-namestring path) "")))
+    (let ((*default-reporter* reporter))
+      (cond
+        ((and (stringp object)
+              (asdf:find-system object nil))
+         (run-test-system object))
+        ((stringp object)
+         (run (pathname object)))
+        ((and (pathnamep object)
+              (directory-pathname-p object))
+         (let ((all-passed-p T) (all-passed-files '()) (all-failed-files '()))
+           (restart-case
+               (dolist (file (test-files-in-directory object))
+                 (multiple-value-bind (passedp passed-files failed-files)
+                     (run file)
+                   (setf all-passed-files (append all-passed-files passed-files))
+                   (setf all-failed-files (append all-failed-files failed-files))
+                   (unless passedp
+                     (setf all-passed-p nil))))
+             (skip-all-test-files ()
+               :report "Give up all test files."
+               nil))
+           (values all-passed-p all-passed-files all-failed-files)))
+        ((pathnamep object)
+         (setf *last-suite-report* nil)
+         (restart-case
+             (progn
+               (load object)
+               (unless *last-suite-report*
+                 (warn "Test completed without 'finalize'd.")))
+           (skip-test-file ()
+             :report "Skip this test file."
+             nil))
+         (if (eql (getf *last-suite-report* :failed) 0)
+             (values T (list object) '())
+             (values NIL '() (list object))))
+        (T (run-test-system object))))))
+
+(import 'test-file :asdf)
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/color.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/color.lisp
new file mode 100644
index 0000000..922e30d
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/color.lisp
@@ -0,0 +1,37 @@
+(in-package :cl-user)
+(defpackage prove.color
+  (:use :cl)
+  (:import-from :cl-ansi-text
+                :generate-color-string)
+  (:import-from :cl-colors
+                :+gray+
+                :+grey+)
+  (:export :*enable-colors*
+           :with-color))
+(in-package :prove.color)
+
+(defvar *enable-colors*
+  (not (equal (uiop:getenv "EMACS") "t"))
+  "Flag whether colorize a test report. The default is T except on Emacs (SLIME).")
+
+(defmacro with-gray (stream &body body)
+  `(progn
+     (format ,stream (cl-ansi-text::generate-color-string 90))
+     (unwind-protect (progn ,@body)
+       (format ,stream (cl-ansi-text::generate-color-string 0)))))
+
+(defmacro with-color ((color &rest args) &body body)
+  (cond
+    ((or (eq color :gray)
+         (eq color :grey))
+     `(if *enable-colors*
+          (with-gray ,(or (getf args :stream) t) ,@body)
+          (progn ,@body)))
+    (T `(if *enable-colors*
+            (if (or (eq ,color :gray)
+                    (eq ,color :grey)
+                    (eq ,color cl-colors:+gray+)
+                    (eq ,color cl-colors:+grey+))
+                (with-gray ,(or (getf args :stream) t) ,@body)
+                (cl-ansi-text:with-color (,color ,@args) ,@body))
+            (progn ,@body)))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/output.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/output.lisp
new file mode 100644
index 0000000..d7d9d7a
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/output.lisp
@@ -0,0 +1,13 @@
+(in-package :cl-user)
+(defpackage prove.output
+  (:use :cl)
+  (:export :*test-result-output*
+           :test-result-output
+           :*default-reporter*))
+(in-package :prove.output)
+
+(defvar *test-result-output* (make-synonym-stream '*standard-output*))
+
+;; This should be in prove.reporter,
+;; but it's here because this will also be used in prove-asdf.
+(defvar *default-reporter* :list)
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/prove.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/prove.lisp
new file mode 100644
index 0000000..c7f0892
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/prove.lisp
@@ -0,0 +1,87 @@
+(in-package :cl-user)
+(defpackage prove
+  (:nicknames :cl-test-more :test-more)
+  (:use :cl)
+  (:import-from :prove.output
+                :*test-result-output*
+                :*default-reporter*)
+  (:import-from :prove.asdf
+                :test-file
+                :run-test-system
+                :run)
+  (:import-from :prove.test
+                :*debug-on-error*
+                :*default-test-function*
+                :ok
+                :is
+                :isnt
+                :is-values
+                :is-print
+                :is-condition
+                :is-error
+                :is-type
+                :like
+                :is-expand
+                :diag
+                :skip
+                :pass
+                :fail
+                :subtest
+                :deftest
+                :run-test
+                :run-test-package
+                :run-test-all
+                :remove-test
+                :remove-test-all
+                :*gensym-prefix*)
+  (:import-from :prove.suite
+                :*default-slow-threshold*
+                :slow-threshold
+                :plan
+                :finalize
+                :current-suite
+                :*suite*
+                :reset-suite
+                :suite
+                :package-suite)
+  (:import-from :prove.color
+                :*enable-colors*)
+  (:export :*debug-on-error*
+           :*test-result-output*
+           :*default-test-function*
+           :*default-reporter*
+           :test-file
+           :run-test-system
+           :run
+           :ok
+           :is
+           :isnt
+           :is-values
+           :is-print
+           :is-condition
+           :is-error
+           :is-type
+           :like
+           :is-expand
+           :diag
+           :skip
+           :pass
+           :fail
+           :subtest
+           :deftest
+           :run-test
+           :run-test-package
+           :run-test-all
+           :remove-test
+           :remove-test-all
+           :plan
+           :finalize
+           :*gensym-prefix*
+           :*default-slow-threshold*
+           :slow-threshold
+           :current-suite
+           :*suite*
+           :reset-suite
+           :suite
+           :package-suite
+           :*enable-colors*))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/report.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/report.lisp
new file mode 100644
index 0000000..9303d21
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/report.lisp
@@ -0,0 +1,113 @@
+(in-package :cl-user)
+(defpackage prove.report
+  (:use :cl)
+  (:export :report
+           :test-report
+           :normal-test-report
+           :passed-test-report
+           :failed-test-report
+           :error-test-report
+           :skipped-test-report
+           :comment-report
+           :composed-test-report
+
+           :test-report-p
+           :passed-report-p
+           :failed-report-p
+           :error-report-p
+           :skipped-report-p
+
+           :plan
+           :children
+           :description
+           :notp
+           :got
+           :got-form
+           :expected
+           :report-expected-label
+           :duration
+           :slow-threshold
+           :print-error-detail))
+(in-package :prove.report)
+
+(defclass report ()
+  ((description :type (or null string)
+                :initarg :description
+                :initform nil)))
+
+(defclass comment-report (report) ())
+
+(defclass test-report (report)
+  ((duration :initarg :duration
+             :initform nil)
+   (slow-threshold :initarg :slow-threshold)
+   (print-error-detail :type boolean
+                       :initarg :print-error-detail
+                       :initform t)))
+
+(defclass normal-test-report (test-report)
+  ((test-function :type (or function symbol)
+                  :initarg :test-function)
+   (notp :type boolean
+         :initarg :notp
+         :initform nil)
+   (got :initarg :got
+        :initform (error ":got is required"))
+   (got-form :initarg :got-form
+             :initform '#:unbound)
+   (expected :initarg :expected
+             :initform (error ":expected is required"))
+   (report-expected-label :type (or null string)
+                          :initarg :report-expected-label
+                          :initform nil)))
+
+(defclass composed-test-report (test-report)
+  ((plan :initarg :plan
+         :initform nil)
+   (children :initarg :children
+             :initform (make-array 0 :adjustable t :fill-pointer 0))))
+
+(defclass passed-test-report (normal-test-report) ())
+(defclass failed-test-report (normal-test-report) ())
+(defclass error-test-report (failed-test-report) ())
+(defclass skipped-test-report (normal-test-report) ())
+
+(defun test-report-p (report)
+  (typep report 'test-report))
+
+(defun passed-report-p (report)
+  (typecase report
+    (skipped-test-report nil)
+    (passed-test-report t)
+    (composed-test-report
+     (every #'passed-report-p (slot-value report 'children)))
+    (otherwise nil)))
+
+(defun failed-report-p (report)
+  (typecase report
+    (skipped-test-report nil)
+    (failed-test-report t)
+    (composed-test-report
+     (some #'failed-report-p (slot-value report 'children)))
+    (otherwise nil)))
+
+(defun error-report-p (report)
+  (typep report 'error-test-report))
+
+(defun skipped-report-p (report)
+  (typecase report
+    (skipped-test-report t)
+    (composed-test-report
+     (some #'skipped-report-p (slot-value report 'children)))
+    (otherwise nil)))
+
+(defmethod print-object ((report normal-test-report) stream)
+  (with-slots (got notp expected description) report
+    (format stream
+            "#<~A RESULT: ~S, GOT: ~S, ~:[~;NOT ~]EXPECTED: ~S~:[~;~:*, DESCRIPTION: ~A~]>"
+            (type-of report)
+            (passed-report-p report)
+            got
+            notp
+            expected
+            description)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter.lisp
new file mode 100644
index 0000000..309fcea
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter.lisp
@@ -0,0 +1,175 @@
+(in-package :cl-user)
+(defpackage prove.reporter
+  (:use :cl)
+  (:import-from :prove.report
+                :report
+                :test-report
+                :description)
+  (:import-from :prove.output
+                :*default-reporter*)
+  (:export :*indent-level*
+           :indent-space
+           :format/indent
+           :reporter
+           :format-report
+           :print-error-report
+           :print-plan-report
+           :print-finalize-report
+           :with-additional-indent))
+(in-package :prove.reporter)
+
+(defparameter *indent-level* 0
+  "Level for nested test-cases output.
+   Number of spaces, added for each indentation level
+   is described in reporter's indent-space slot.
+
+   Also, macro shift-indent could be used to slightly
+   indent content inside the main indentation level.
+
+   full-indent = indent-space * indent-level + additional-indent
+
+   Here is an example of the output:
+
+   1|  x Blah minor.
+   2|    Next line of description:
+   3|
+   4|      x Nested test.
+   5|        Also has multiline description.
+
+   In this example, indent-space is 4, that is why
+   text on lines 1 and 4 have 4 spaces between the 'x'
+   horizontally.
+
+   Outputting the first line \"  x \", reporter sets
+   *additional-indent* to 4. That is why these additional
+   4 lines are prepended to the rest lines of the main
+   test case description.
+
+   When inner testcase runs, it increments *indent-level*,
+   which shifts output to another 4 spaces (indent-space)
+   to the right, simultaneously resetting *additional-indent*
+   to zero.
+
+   For nested test, reporter writes \"  x \" and again,
+   sets *additional-indent* to 4 and every other lines now
+   shifted by 1 * 4 + 4 = 8 spaces.
+")
+
+(defparameter *additional-indent* 0
+  "Number of spaces to add to each line. see *indent-level* docstring for full description.")
+
+(defvar *debug-indentation* nil
+  "If True, then indentation will have '=' and '-' symbols for main indentaion and additional, instead of spaces.")
+
+(defun indent (space &optional (count *indent-level*))
+  "Creates a string with a number of spaces to indent new line
+of a test report."
+  (if *debug-indentation*
+      (concatenate 'string
+                   (make-string (* count space)
+                                :initial-element #\=)
+                   (make-string *additional-indent*
+                                :initial-element #\-))
+      (make-string (+ (* count space)
+                                     *additional-indent*)
+                   :initial-element #\space)))
+
+
+(defmacro with-additional-indent ((reporter stream control-string &rest format-arguments) &body body)
+  (declare (ignorable reporter stream control-string))
+  (let* ((need-new-line (ppcre:scan "^~&" control-string))
+         (string (apply #'format nil control-string format-arguments))
+         (increment (length string)))
+    `(with-slots (indent-space) reporter
+       (let* ((first-line-indent (indent indent-space))
+              (*additional-indent* ,(if need-new-line
+                                        increment
+                                        `(+ *additional-indent*
+                                            ,increment))))
+         (declare (ignorable first-line-indent))
+         ,(if need-new-line
+              `(progn (fresh-line stream)
+                      (write-string first-line-indent ,stream)
+                      ;; because we just started a new line, we
+                      ;; should use format/indent to write string
+                      ;; taking into account a main indentation level
+                      (format/indent ,reporter ,stream ,string))
+              ;; otherwise, just output our prefix
+              `(write-string ,string ,stream))
+       
+       
+         ,@body))))
+
+
+
+(defun format/indent (reporter stream control-string &rest format-arguments)
+  "Writes a text to given stream with indentation, dictated by
+*indent-level* and *additional-indent*.
+
+If first line start with ~&, then output will start from a fresh line.
+Otherwise, all lines except the first one are indented."
+  
+  (with-slots (indent-space) reporter
+    (let ((output (apply #'format nil control-string format-arguments)))
+      ;; if string starts with new line, then we have to add indentation
+      ;; otherwise we think it is already written to the stream
+      (when (ppcre:scan "^~&" control-string)
+        (fresh-line stream)
+        (format stream (indent indent-space)))
+
+      ;; if this (?!$) is indended to not insert spaces
+      ;; into empty lines, then (?m) should be inserted
+      ;; before
+      ;; TODO: make a pull-request
+      (write-string (ppcre:regex-replace-all
+                     "(\\n)(?!$)"
+                     output
+                     (format nil "\\1~A"
+                             (indent indent-space)))
+                    stream))))
+
+
+(defclass reporter ()
+  ((indent-space :initform 2)))
+
+(defun find-reporter (name)
+  (make-instance
+   (intern (format nil "~:@(~A~)-~A" name #.(string :reporter))
+           (intern (format nil "~A.~:@(~A~)"
+                           #.(string :prove.reporter)
+                           name)
+                   :keyword))))
+
+(defgeneric format-report (stream reporter report &rest args)
+  (:method (stream (reporter null) (report report) &rest args)
+    (apply #'format-report
+           stream
+           (find-reporter *default-reporter*)
+           report
+           args))
+  (:method (stream (reporter reporter) (report report) &rest args)
+    (declare (ignore args))
+    (format/indent reporter stream "~&~A~%"
+                   (slot-value report 'description))))
+
+(defgeneric print-error-report (reporter report stream)
+  (:method ((reporter reporter) (report report) stream)
+    ;; Do nothing.
+    )
+  (:method ((reporter null) (report test-report) stream)
+    (print-error-report (find-reporter *default-reporter*) report stream)))
+
+(defgeneric print-plan-report (reporter num stream)
+  (:method ((reporter null) num stream)
+    (print-plan-report (find-reporter *default-reporter*) num stream))
+  (:method ((reporter t) num stream)
+    (declare (ignore reporter num))
+    ;; Do nothing
+    ))
+
+(defgeneric print-finalize-report (reporter plan reports stream)
+  (:method ((reporter null) plan reports  stream)
+    (print-finalize-report (find-reporter *default-reporter*)
+                           plan
+                           reports
+                           stream)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter/dot.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter/dot.lisp
new file mode 100644
index 0000000..4039998
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter/dot.lisp
@@ -0,0 +1,42 @@
+(in-package :cl-user)
+(defpackage prove.reporter.dot
+  (:use :cl
+        :prove.report
+        :prove.reporter
+        :prove.reporter.list
+        :prove.color))
+(in-package :prove.reporter.dot)
+
+(defclass dot-reporter (list-reporter) ())
+
+(defmethod format-report (stream (reporter dot-reporter) (report comment-report) &rest args)
+  (declare (ignore args))
+  ;; Do nothing. This reporter doesn't support 'diag'.
+  )
+
+(defmethod format-report (stream (reporter dot-reporter) (report test-report) &rest args)
+  (declare (ignore args))
+  (when (zerop *indent-level*)
+    (if *enable-colors*
+        (with-color ((cond
+                       ((failed-report-p report) :red)
+                       ((skipped-report-p report) :cyan)
+                       (T :gray)) :stream stream)
+          (format stream (if (error-report-p report)
+                             "x"
+                             ".")))
+        (write-char (if (failed-report-p report) #\f #\.) stream))))
+
+(defmethod print-finalize-report :before ((reporter dot-reporter) plan reports stream)
+  (declare (ignore plan reports))
+  (fresh-line stream))
+
+(defmethod print-finalize-report :after ((reporter dot-reporter) plan reports stream)
+  (let ((failed-reports (remove-if-not #'failed-report-p reports))
+        (list-reporter (make-instance 'list-reporter)))
+    (when failed-reports
+      (format stream "~2&")
+      (map nil
+           (lambda (report)
+             (format-report stream list-reporter report))
+           failed-reports))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter/fiveam.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter/fiveam.lisp
new file mode 100644
index 0000000..9d17780
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter/fiveam.lisp
@@ -0,0 +1,71 @@
+(in-package :cl-user)
+(defpackage prove.reporter.fiveam
+  (:use :cl
+        :prove.report
+        :prove.reporter))
+(in-package :prove.reporter.fiveam)
+
+(defclass fiveam-reporter (reporter) ())
+
+(defmethod format-report (stream (reporter fiveam-reporter) (report comment-report) &rest args)
+  (declare (ignore stream reporter report args))
+  ;; Do nothing. This reporter doesn't support 'diag'.
+  )
+
+(defmethod format-report (stream (reporter fiveam-reporter) (report test-report) &rest args)
+  (declare (ignore args))
+  (when (zerop *indent-level*)
+    (write-char (if (failed-report-p report) #\f #\.) stream)))
+
+(defmethod print-error-report ((reporter fiveam-reporter) (report failed-test-report) stream)
+  (with-slots (description got got-form expected notp report-expected-label print-error-detail) report
+    (cond
+      (print-error-detail
+       (format/indent reporter
+                      stream "~& ~:[(no description)~;~:*~A~]:~%    ~S~:[~*~; => ~S~]~%        is ~:[~;not ~]expected to ~:[be~;~:*~A~]~%    ~S~%"
+                      description
+                      got-form
+                      (not (eq got got-form))
+                      got
+                      notp
+                      report-expected-label
+                      expected))
+      (T (format/indent reporter stream "~& ~:[(no description)~;~:*~A~]: Failed~%"
+                        description)))))
+
+(defmethod print-error-report ((reporter fiveam-reporter) (report composed-test-report) stream)
+  (with-slots (plan children description) report
+    (format/indent reporter stream "~& ~:[(no description)~;~:*~A~]:~%"
+                   description)
+    (let ((*indent-level* (1+ *indent-level*)))
+      (print-finalize-report reporter plan children stream))))
+
+(defmethod print-error-report ((reporter fiveam-reporter) (report comment-report) stream)
+  (format/indent reporter stream "~& ~A~%"
+                 (slot-value report 'description)))
+
+(defmethod print-finalize-report ((reporter fiveam-reporter) plan reports stream)
+  (let ((failed-count (count-if #'failed-report-p reports))
+        (passed-count (count-if #'passed-report-p reports))
+        (skipped-count (count-if #'skipped-report-p reports))
+        (count (count-if #'test-report-p reports)))
+    (format/indent reporter stream
+                   "~& Did ~D checks.~:[~*~; (planned ~D tests)~]~%"
+                   count
+                   (not (eql plan count))
+                   plan)
+    (unless (zerop count)
+      (format/indent reporter
+                     stream "    Pass: ~D (~3D%)~%" passed-count (round (* (/ passed-count count) 100)))
+      (unless (zerop skipped-count)
+        (format/indent reporter
+                       stream "    Skip: ~D (~3D%)~%" skipped-count (round (* (/ skipped-count count) 100))))
+      (format/indent reporter
+                     stream "    Fail: ~D (~3D%)~%" failed-count (round (* (/ failed-count count) 100))))
+    (unless (zerop failed-count)
+      (format/indent reporter
+                     stream "~2& Failure Details:~% --------------------------------~%")
+      (loop for report across reports
+            when (failed-report-p report)
+              do (print-error-report reporter report stream)
+                 (format/indent reporter stream " --------------------------------~%")))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter/list.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter/list.lisp
new file mode 100644
index 0000000..fe96982
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter/list.lisp
@@ -0,0 +1,171 @@
+(in-package :cl-user)
+(defpackage prove.reporter.list
+  (:use :cl
+        :prove.report
+        :prove.reporter)
+  (:import-from :prove.color
+                :with-color)
+  (:export :list-reporter
+           :report-expected-line))
+(in-package :prove.reporter.list)
+
+(defclass list-reporter (reporter) ())
+
+(defmethod format-report (stream (reporter list-reporter) (report comment-report) &rest args)
+  (declare (ignore args))
+  (with-additional-indent (reporter stream "~& ")
+    (with-color (:white :stream stream)
+      (format/indent reporter stream (slot-value report 'description)))
+    (terpri stream)))
+
+
+(defun omit-long-value (value)
+  (typecase value
+    (string
+     (if (< 500 (length value))
+         (format nil "\"~A ...\"" (subseq value 0 94))
+         (prin1-to-string value)))
+    (otherwise
+     (let ((value (prin1-to-string value)))
+       (if (< 500 (length value))
+           (format nil "~A ..." (subseq value 0 96))
+           value)))))
+
+
+(defgeneric report-expected-line (report)
+  (:documentation "Reports about failed or passed test.
+                   Should return a string with description of what have happened.")
+  
+  (:method ((report normal-test-report))
+    (with-slots (got got-form notp report-expected-label expected) report
+      (escape-tildes
+       (format nil "~A is ~:[~;not ~]expected to ~:[be~;~:*~A~] ~A~:[ (got ~S)~;~*~]"
+               (omit-long-value (or got-form got))
+               notp
+               report-expected-label
+               (omit-long-value expected)
+               (eq got got-form)
+               got)))))
+
+
+(defun escape-tildes (text)
+  (ppcre:regex-replace-all "~" text "~~"))
+
+
+(defun possible-report-description (report)
+  (cond
+    ((slot-value report 'description)
+     (format nil "~A~:[~; (Skipped)~]"
+             (escape-tildes (slot-value report 'description))
+             (skipped-report-p report)))
+    (T (report-expected-line report))))
+
+(defun print-duration (stream duration &optional slow-threshold)
+  (let ((color (if slow-threshold
+                   (cond
+                     ((< slow-threshold duration) :red)
+                     ((< (/ slow-threshold 2) duration) :yellow))
+                   :gray)))
+    (when color
+      (with-color (color :stream stream)
+        (format stream "(~Dms)" duration)))))
+
+(defmethod format-report (stream (reporter list-reporter) (report normal-test-report) &rest args)
+  (declare (ignore args))
+  (with-additional-indent (reporter stream "~&  ")
+    (with-color (:green :stream stream)
+      (with-additional-indent (reporter stream "✓ ")
+        (let ((description (possible-report-description report))
+              (duration (slot-value report 'duration)))
+          (when description
+            (with-color (:gray :stream stream)
+              (format/indent reporter stream description)))
+        
+          (when duration
+            (format stream " ")
+            (print-duration stream duration (slot-value report 'slow-threshold))))
+        (terpri stream)))))
+
+(defmethod format-report (stream (reporter list-reporter) (report skipped-test-report) &rest args)
+  (declare (ignore args))
+  (with-additional-indent (reporter stream "~&  ")
+    (with-color (:cyan :stream stream)
+      (with-additional-indent (reporter stream "- ")
+        (let ((description (possible-report-description report)))
+          (when description
+            (format/indent reporter stream description))))
+      (terpri stream))))
+
+(defmethod format-report (stream (reporter list-reporter) (report failed-test-report) &rest args)
+  (declare (ignore args))
+  (with-additional-indent (reporter stream "~&  ")
+    (with-color (:red :stream stream)
+      (with-additional-indent (reporter stream "× ")
+        (let ((description (possible-report-description report))
+              (duration (slot-value report 'duration)))
+          (when description
+            (format/indent reporter stream description))
+          (when duration
+            (format stream " ")
+            (print-duration stream duration (slot-value report 'slow-threshold))))
+        (when (slot-value report 'description)
+          (format/indent reporter stream
+                         (concatenate 'string "~&" (report-expected-line report)))))
+      (terpri stream))))
+
+(defmethod format-report (stream (reporter list-reporter) (report error-test-report) &rest args)
+  (declare (ignore args))
+  ;; format/indent
+  (with-additional-indent (reporter stream "~&  ")
+    (with-color (:red :stream stream)
+      (with-additional-indent (reporter stream "× ")
+        (when (slot-value report 'description)
+          (format/indent reporter stream "~A~%" (slot-value report 'description)))
+        (format/indent reporter stream "Raised an error ~A (expected: ~S)"
+                       (slot-value report 'got)
+                       (slot-value report 'expected)))))
+  (terpri stream))
+
+(defmethod format-report (stream (reporter list-reporter) (report composed-test-report) &rest args)
+  (declare (ignore args))
+  ;; Do nothing
+  )
+
+(defmethod print-plan-report ((reporter list-reporter) num stream)
+  (when (numberp num)
+    (format/indent reporter stream "~&1..~A~2%" num)))
+
+(defmethod print-finalize-report ((reporter list-reporter) plan reports stream)
+  (let ((failed-count (count-if #'failed-report-p reports))
+        (skipped-count (count-if #'skipped-report-p reports))
+        (count (count-if #'test-report-p reports)))
+    (format/indent reporter stream "~2&")
+    (cond
+      ((eq plan :unspecified)
+       (with-color (:yellow :stream stream)
+         (format/indent reporter stream
+                        "△ Tests were run but no plan was declared.~%")))
+      ((and plan
+            (not (= count plan)))
+       (with-color (:yellow :stream stream)
+         (format/indent reporter stream
+                        "△ Looks like you planned ~D test~:*~P but ran ~A.~%"
+                        plan count))))
+    (if (< 0 failed-count)
+        (with-color (:red :stream stream)
+          (format/indent reporter stream
+                         "× ~D of ~D test~:*~P failed"
+                         failed-count count))
+        (with-color (:green :stream stream)
+          (format/indent reporter stream
+                         "✓ ~D test~:*~P completed" count)))
+    (format stream " ")
+    (print-duration stream
+                    (reduce #'+
+                            (remove-if-not #'test-report-p reports)
+                            :key (lambda (report) (or (slot-value report 'duration) 0))))
+    (terpri stream)
+    (unless (zerop skipped-count)
+      (with-color (:cyan :stream stream)
+        (format/indent reporter stream "● ~D test~:*~P skipped" skipped-count))
+      (terpri stream))))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter/tap.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter/tap.lisp
new file mode 100644
index 0000000..722ba1e
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/reporter/tap.lisp
@@ -0,0 +1,70 @@
+(in-package :cl-user)
+(defpackage prove.reporter.tap
+  (:use :cl
+        :prove.report
+        :prove.reporter))
+(in-package :prove.reporter.tap)
+
+(defclass tap-reporter (reporter)
+  ((indent-space :initform 4)))
+
+(defmethod format-report (stream (reporter tap-reporter) (report comment-report) &rest args)
+  (declare (ignore args))
+  (format/indent reporter stream "~&# ~A~%"
+                 (slot-value report 'description)))
+
+(defmethod format-report (stream (reporter tap-reporter) (report test-report) &key count)
+  (with-slots (description print-error-detail) report
+    (format/indent reporter stream
+                   "~&~:[not ~;~]ok~:[~;~:* ~D~]~:[~;~:* - ~A~]~%"
+                   (or (passed-report-p report)
+                       (skipped-report-p report))
+                   count
+                   description)
+    (print-error-report reporter report stream)))
+
+(defmethod format-report (stream (reporter tap-reporter) (report skipped-test-report) &key count)
+  (format/indent reporter stream
+                 "~&ok~:[~;~:* ~D~] - skip~:[~;~:* ~A~]~%"
+                 count
+                 (slot-value report 'description)))
+
+(defmethod print-error-report ((reporter tap-reporter) (report failed-test-report) stream)
+  (with-slots (got got-form expected notp report-expected-label print-error-detail) report
+    (when print-error-detail
+      (format/indent reporter stream
+                     "~&#    got: ~S~:[~*~; => ~S~]~%#    ~:[~;not ~]expected~:[~;~:* to ~A~]: ~S~%"
+                     got-form
+                     (not (eq got got-form))
+                     got
+                     notp
+                     report-expected-label
+                     expected))))
+
+(defmethod print-plan-report ((reporter tap-reporter) num stream)
+  (when (numberp num)
+    (format-report stream
+                   reporter
+                   (make-instance 'report
+                                  :description (format nil "1..~A" num)))))
+
+(defmethod print-finalize-report ((reporter tap-reporter) plan reports stream)
+  (let ((failed-count (count-if #'failed-report-p reports))
+        (count (count-if #'test-report-p reports)))
+    (cond
+      ((eq plan :unspecified)
+       (format/indent reporter stream
+                      "~&# Tests were run but no plan was declared.~%"))
+      ((and plan
+            (not (= count plan)))
+       (format/indent reporter stream
+                      "~&# Looks like you planned ~D test~:*~P but ran ~A.~%"
+                      plan count)))
+    (fresh-line stream)
+    (if (< 0 failed-count)
+        (format/indent reporter stream
+                       "# Looks like you failed ~D test~:*~P of ~A run."
+                       failed-count count)
+        (format/indent reporter stream "# All ~D test~:*~P passed."
+                       count))
+    (terpri stream)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/suite.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/suite.lisp
new file mode 100644
index 0000000..24c7b47
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/suite.lisp
@@ -0,0 +1,92 @@
+(in-package :cl-user)
+(defpackage prove.suite
+  (:use :cl)
+  (:import-from :prove.output
+                :*test-result-output*)
+  (:import-from :prove.report
+                :report
+                :failed-report-p)
+  (:import-from :prove.reporter
+                :print-plan-report
+                :print-finalize-report)
+  (:import-from :prove.asdf
+                :*last-suite-report*)
+  (:export :*suite*
+
+           :current-suite
+
+           :suite
+           :package-suite
+           :suite-plan
+           :test-count
+           :failed
+           :reports
+           :slow-threshold
+           :*default-slow-threshold*
+
+           :add-report
+           :plan
+           :finalize))
+(in-package :prove.suite)
+
+(defparameter *suite* nil)
+(defparameter *default-slow-threshold* 75)
+
+(defclass suite ()
+  ((plan :initarg :plan
+         :initform :unspecified
+         :accessor suite-plan)
+   (slow-threshold :initarg :slow-threshold
+                   :initform *default-slow-threshold*)
+   (test-count :initform 0
+               :accessor test-count)
+   (failed :initform 0
+           :accessor failed)
+   (reports :initform (make-array 0 :adjustable t :fill-pointer 0)
+            :accessor reports)))
+
+(defun slow-threshold (&optional new-threshold)
+  (if new-threshold
+      (setf (slot-value (current-suite) 'slow-threshold) new-threshold)
+      (slot-value (current-suite) 'slow-threshold)))
+
+(defclass package-suite (suite) ())
+
+(defvar *defined-suites* (make-hash-table :test 'equal))
+
+(defun find-package-suite (package-designator)
+  (let ((package (typecase package-designator
+                   (package package-designator)
+                   (T (find-package package-designator)))))
+    (or (gethash (package-name package) *defined-suites*)
+        (setf (gethash (package-name package) *defined-suites*)
+              (make-instance 'package-suite)))))
+
+(defun current-suite ()
+  (or *suite*
+      (find-package-suite *package*)))
+
+(defun reset-suite (suite)
+  (with-slots (test-count failed reports) suite
+    (setf test-count 0)
+    (setf failed 0)
+    (setf reports (make-array 0 :adjustable t :fill-pointer 0))))
+
+(defun add-report (report suite)
+  (check-type report report)
+  (when (failed-report-p report)
+    (incf (slot-value suite 'failed)))
+  (vector-push-extend report (slot-value suite 'reports)))
+
+(defun plan (num)
+  (let ((suite (current-suite)))
+    (setf (slot-value suite 'plan) num)
+    (reset-suite suite))
+  (print-plan-report nil num *test-result-output*))
+
+(defun finalize (&optional (suite (current-suite)))
+  (with-slots (plan reports failed) suite
+    (print-finalize-report nil plan reports *test-result-output*)
+    (setf *last-suite-report*
+          (list :plan plan :failed failed))
+    (zerop failed)))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/test.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/test.lisp
new file mode 100644
index 0000000..81389a5
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/src/test.lisp
@@ -0,0 +1,366 @@
+(in-package :cl-user)
+(defpackage prove.test
+  (:use :cl)
+  (:import-from :prove.output
+                :*test-result-output*)
+  (:import-from :prove.report
+                :test-report-p
+                :passed-test-report
+                :failed-test-report
+                :error-test-report
+                :skipped-test-report
+                :comment-report
+                :composed-test-report
+                :failed-report-p
+                :duration)
+  (:import-from :prove.reporter
+                :format-report
+                :*indent-level*
+                :*additional-indent*)
+  (:import-from :prove.suite
+                :suite
+                :*suite*
+                :suite-plan
+                :test-count
+                :failed
+                :reports
+                :slow-threshold
+                :current-suite
+                :finalize
+                :add-report)
+  (:import-from :alexandria
+                :with-gensyms
+                :once-only)
+  (:export :*default-test-function*
+           :*debug-on-error*
+
+           :ok
+           :is
+           :isnt
+           :is-values
+           :is-print
+           :is-condition
+           :is-error
+           :is-type
+           :like
+           :is-expand
+           :diag
+           :skip
+           :pass
+           :fail
+           :subtest
+
+           :*gensym-prefix*
+
+           :deftest
+           :run-test
+           :run-test-package
+           :run-test-all
+           :remove-test
+           :remove-test-all))
+(in-package :prove.test)
+
+(defvar *debug-on-error* nil)
+(defvar *default-test-function* #'equal)
+
+(defun parse-description-and-test (args)
+  (if (consp args)
+      (case (length args)
+        (1 (car args))
+        (2 (if (eq :test (car args))
+               (values nil (cadr args))
+               (car args)))
+        (t (let ((k (member :test args)))
+             (case (length k)
+               ((0 1) (car args))
+               (2 (values (car args) (cadr k)))
+               (t (values (nth 2 k) (cadr k)))))))
+      args))
+
+(defun test (got expected args
+             &key notp
+               duration
+               (got-form nil got-form-supplied-p)
+               (test-fn *default-test-function*)
+               (passed-report-class 'passed-test-report)
+               (failed-report-class 'failed-test-report)
+               report-expected-label
+               (print-error-detail t)
+               (output t))
+  (multiple-value-bind (desc arg-test)
+      (parse-description-and-test args)
+    (let* ((test-function (or arg-test test-fn))
+           (result (funcall test-function got expected))
+           (result (if notp (not result) result))
+           (suite (current-suite))
+           (report (apply #'make-instance
+                          (if result
+                              passed-report-class
+                              failed-report-class)
+                          :duration duration
+                          :slow-threshold (slot-value suite 'slow-threshold)
+                          :test-function test-function
+                          :notp notp
+                          :got got
+                          :got-form (if got-form-supplied-p
+                                        got-form
+                                        got)
+                          :expected expected
+                          :description desc
+                          :print-error-detail print-error-detail
+                          (and report-expected-label
+                               (list :report-expected-label report-expected-label)))))
+      (add-report report suite)
+      (unless result
+        (incf (failed suite)))
+      (incf (test-count suite))
+      (when output
+        (format-report *test-result-output* nil report :count (test-count suite)))
+      (values result report))))
+
+(defmacro with-duration (((duration result) form) &body body)
+  (with-gensyms (start end)
+    `(let* ((,start (get-internal-real-time))
+            (,result ,form)
+            (,end (get-internal-real-time))
+            (,duration (- ,end ,start)))
+       ,@body)))
+
+(defmacro with-catching-errors ((&key description expected) &body body)
+  (with-gensyms (e suite report)
+    `(if *debug-on-error*
+         (progn ,@body)
+         (handler-case (progn ,@body)
+           (error (,e)
+             (let ((,suite (current-suite))
+                   (,report (make-instance 'error-test-report
+                                           :got ,e
+                                           :got-form ,e
+                                           :expected ,expected
+                                           :description ,description
+                                           :duration nil)))
+               (add-report ,report ,suite)
+               (incf (failed ,suite))
+               (incf (test-count ,suite))
+               (format-report *test-result-output* nil ,report :count (test-count ,suite))))))))
+
+(defmacro ok (test &optional desc)
+  (with-gensyms (duration result)
+    (once-only (test desc)
+      `(with-catching-errors (:expected T :description ,desc)
+         (with-duration ((,duration ,result) ,test)
+           (test ,result t ,desc
+                 :duration ,duration
+                 :test-fn (lambda (x y)
+                            (eq (not (null x)) y))
+                 :got-form ,test))))))
+
+(defmacro is (got expected &rest args)
+  (with-gensyms (duration result new-args desc)
+    (once-only (expected)
+      `(let* ((,new-args (list ,@args))
+              (,desc (parse-description-and-test ,new-args)))
+         (with-catching-errors (:description ,desc :expected ,expected)
+           (with-duration ((,duration ,result) ,got)
+             (test ,result ,expected ,new-args
+                   :duration ,duration)))))))
+
+(defmacro isnt (got expected &rest args)
+  (with-gensyms (duration result new-args desc)
+    (once-only (expected)
+      `(let* ((,new-args (list ,@args))
+              (,desc (parse-description-and-test ,new-args)))
+         (with-catching-errors (:description ,desc :expected ,expected)
+           (with-duration ((,duration ,result) ,got)
+             (test ,result ,expected ,new-args
+                   :notp t
+                   :duration ,duration)))))))
+
+(defmacro is-values (got expected &rest args)
+  `(is (multiple-value-list ,got) ,expected ,@args))
+
+(defmacro is-print (got expected &optional desc)
+  (with-gensyms (output duration duration-inner)
+    (once-only (expected desc)
+      `(with-catching-errors (:description ,desc :expected ,expected)
+         (let* (,duration
+                (,output (with-output-to-string (*standard-output*)
+                           (with-duration ((,duration-inner ,output) ,got)
+                             (declare (ignore ,output))
+                             (setq ,duration ,duration-inner)))))
+           (test ,output ,expected ,desc
+                 :duration ,duration
+                 :got-form ',got
+                 :test-fn #'string=
+                 :report-expected-label "output"))))))
+
+(defmacro is-condition (form condition &optional desc)
+  (with-gensyms (error duration)
+    `(with-duration ((,duration ,error) (handler-case ,form
+                                          (condition (,error) ,error)))
+       (test ,error
+             ,(if (and (listp condition) (eq 'quote (car condition)))
+                  condition
+                  `(quote ,condition))
+             ,desc
+             :duration ,duration
+             :got-form ',form
+             :test-fn #'typep
+             :report-expected-label "raise a condition"))))
+
+;;; alias is-error to is-condition
+(setf (macro-function 'is-error) (macro-function 'is-condition))
+
+(defmacro is-type (got expected-type &optional desc)
+  (with-gensyms (duration result)
+    (once-only (desc expected-type)
+      `(with-catching-errors (:description ,desc :expected ,expected-type)
+         (with-duration ((,duration ,result) ,got)
+           (test ,result ,expected-type ,desc
+                 :duration ,duration
+                 :got-form ',got
+                 :test-fn #'typep
+                 :report-expected-label "be a type of"))))))
+
+(defmacro like (got regex &optional desc)
+  (with-gensyms (duration result)
+    (once-only (regex desc)
+      `(with-catching-errors (:description ,desc :expected ,regex)
+         (with-duration ((,duration ,result) ,got)
+           (test ,result ,regex ,desc
+                 :duration ,duration
+                 :test-fn (lambda (x y) (not (null (ppcre:scan y x))))
+                 :report-expected-label "be like"))))))
+
+(defvar *gensym-prefix* "$")
+(defvar *gensym-alist* nil)
+
+(defun gensymp (val)
+  (and (symbolp val)
+       (string= (subseq (symbol-name val) 0 (length *gensym-prefix*)) *gensym-prefix*)))
+
+(defgeneric gensym-tree-equal (x y)
+  (:method (x y)
+    (if (and (gensymp y) (symbolp x))
+        (if (assoc y *gensym-alist*)
+            (eq x (cdr (assoc y *gensym-alist*)))
+            (unless (rassoc x *gensym-alist*)
+              (setf *gensym-alist* `((,y . ,x) ,@*gensym-alist*))
+              t))
+        (equal x y)))
+  (:method ((x cons) (y cons))
+    (loop for a in x for b in y
+          always (gensym-tree-equal a b))))
+
+(defmacro is-expand (got expected &optional desc)
+  (with-gensyms (duration expanded)
+    (once-only (desc)
+      `(with-duration ((,duration ,expanded) (macroexpand-1 ',got))
+         (let (*gensym-alist*)
+           (test ,expanded ',expected ,desc
+                 :duration ,duration
+                 :got-form ',got
+                 :report-expected-label "be expanded to"
+                 :test-fn #'gensym-tree-equal))))))
+
+(defun diag (desc)
+  (let ((report (make-instance 'comment-report
+                               :description desc)))
+    (add-report report (current-suite))
+    (format-report *test-result-output* nil report)))
+
+(defun skip (how-many why &rest format-args)
+  (check-type how-many integer)
+  (dotimes (i how-many)
+    (test t t (apply #'format nil why format-args)
+      :passed-report-class 'skipped-test-report)))
+
+(defun pass (desc)
+  (test t t desc))
+
+(defun fail (desc)
+  (test t nil desc
+        :print-error-detail nil))
+
+(defun %subtest (desc body-fn)
+  (diag desc)
+  (let ((report
+          (let ((*suite* (make-instance 'suite))
+                (*indent-level* (1+ *indent-level*))
+                (*additional-indent* 0))
+            (if *debug-on-error*
+                (funcall body-fn)
+                (handler-case (funcall body-fn)
+                  (error (e)
+                    (let ((error-report
+                            (make-instance 'error-test-report
+                                           :expected :non-error
+                                           :got e
+                                           :description (format nil "Aborted due to an error in subtest ~S" desc))))
+                      (add-report error-report *suite*)
+                      (format-report *test-result-output* nil error-report :count (test-count *suite*))))))
+            (make-instance 'composed-test-report
+                           :duration (reduce #'+
+                                             (remove-if-not #'test-report-p (reports *suite*))
+                                             :key (lambda (report) (or (slot-value report 'duration) 0)))
+                           :plan (suite-plan *suite*)
+                           :description desc
+                           :children (reports *suite*))))
+        (suite (current-suite)))
+    (add-report report suite)
+    (incf (test-count suite))
+    (format-report *test-result-output* nil report :count (test-count suite))))
+
+(defmacro subtest (desc &body body)
+  `(%subtest ,desc (lambda () ,@body)))
+
+(defvar *package-tests* (make-hash-table))
+
+(defmacro deftest (name &body test-forms)
+  (let ((tests (gensym "TESTS"))
+        (test (gensym "TEST"))
+        (test-fn (gensym "TEST-FN")))
+    `(progn
+       (unless (nth-value 1 (gethash *package* *package-tests*))
+         (setf (gethash *package* *package-tests*) '()))
+       (let* ((,tests (gethash *package* *package-tests*))
+              (,test (assoc ',name ,tests :test #'string=))
+              (,test-fn (lambda ()
+                          (subtest (princ-to-string ',name)
+                            ,@test-forms))))
+         (if ,test
+             (rplacd ,test ,test-fn)
+             (push (cons ',name ,test-fn) (gethash *package* *package-tests*)))
+         ',name))))
+
+(defun run-test (name)
+  (let ((test (assoc name
+                     (gethash *package* *package-tests*)
+                     :test #'string=)))
+    (unless test
+      (error "Test not found: ~S" name))
+    (funcall (cdr test))))
+
+(defun run-test-package (package-designator)
+  (let ((*package* (typecase package-designator
+                     (package package-designator)
+                     (T (find-package package-designator)))))
+    (loop for (name . test-fn) in (reverse (gethash *package* *package-tests*))
+          do (funcall test-fn))
+    (finalize)))
+
+(defun run-test-all ()
+  (maphash (lambda (package tests)
+             (declare (ignore tests))
+             (run-test-package package))
+           *package-tests*))
+
+(defun remove-test (name)
+  (setf (gethash *package* *package-tests*)
+        (delete name
+                (gethash *package* *package-tests*)
+                :key #'car
+                :test #'string=)))
+
+(defun remove-test-all ()
+  (setf (gethash *package* *package-tests*) nil))
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/t/prove.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/t/prove.lisp
new file mode 100644
index 0000000..e8ae103
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/t/prove.lisp
@@ -0,0 +1,166 @@
+(in-package :cl-user)
+(defpackage t.prove
+  (:use :cl
+        :prove
+        :prove.t.utils))
+(in-package :t.prove)
+
+(setf *default-reporter* :list)
+
+
+(plan 22)
+
+(test-assertion "Successful OK"
+                (ok t)
+                "✓ T is expected to be T")
+
+
+(test-assertion "Failed ok without description"
+                (ok nil)
+                "× NIL is expected to be T")
+
+
+(test-assertion "Failed ok with description"
+                (ok nil "This supposed to be failed")
+                "
+× This supposed to be failed 
+  NIL is expected to be T")
+
+
+(test-assertion "Simple number equality check"
+                (is 1 1)
+                "✓ 1 is expected to be 1")
+
+
+(test-assertion "String and number shouldn't be equal"
+                (is "1" 1)
+                "× \"1\" is expected to be 1")
+
+
+(test-assertion "String and number are not equal and isnt assertion returns OK"
+                (isnt "1" 1)
+                "✓ \"1\" is not expected to be 1")
+
+
+(test-assertion "Subtest with diagnostic message"
+ (subtest "Subtest"
+   (diag "in subtest")
+   (is #\a #\a)
+   (like "truth" "^true"))
+"
+Subtest
+  in subtest
+   ✓ #\\a is expected to be #\\a 
+   × \"truth\" is expected to be like \"^true\"")
+
+
+(test-assertion "Check if (is-values ...) works propertly"
+                (is-values (values 1 2 nil 3)
+                           '(1 2 nil 3))
+                "✓ (1 2 NIL 3) is expected to be (1 2 NIL 3)")
+
+
+(test-assertion "Standalone diagnostic message"
+                (diag "comment")
+                "comment")
+
+
+(test-assertion "Just a pass"
+                (pass "pass")
+                "✓ pass")
+
+
+(test-assertion "Fail"
+                (fail "fail")
+                "
+× fail
+  T is expected to be NIL")
+
+
+(test-assertion "Pass with parameter"
+                (pass "<~S>")
+                "✓ <~S>")
+
+
+(test-assertion "Equality for strings with formatting"
+                (is "<~S>" "<~S>")
+                "✓ \"<~S>\" is expected to be \"<~S>\"")
+
+
+(test-assertion "\"Skip\" with reason as control-string with arguments should substitute arguments"
+                (skip 1 "Because ~A" 42)
+                "- Because 42 (Skipped)")
+
+
+(test-assertion "\"Skip\" without reason have default message \"skipping\""
+                (skip 1 "skipping")
+                "- skipping (Skipped)")
+
+
+(test-assertion "Assert is-print compares form's output to standart-output"
+                (is-print (princ "ABCDEFGH")
+                                 "ABCDEFGHIJKLMNO")
+                "× (PRINC \"ABCDEFGH\") is expected to output \"ABCDEFGHIJKLMNO\" (got \"ABCDEFGH\")")
+
+
+(test-assertion "Type assertion fails if type mismatch"
+                (is-type 1 'string)
+                "× 1 is expected to be a type of STRING")
+
+
+(test-assertion "Assertion \"is-error\" checks if condition of given type was thrown"
+                (is-error (error "Raising an error") 'simple-error)
+                "(?s)✓ \\(ERROR \"Raising an error\"\\) is expected to raise a condition SIMPLE-ERROR \\(got #<(a )?SIMPLE-ERROR.*>\\)")
+
+
+(define-condition my-condition () ())
+
+(test-assertion "If condition type mismatch, \"is-error\" fails"
+                (is-error (error 'my-condition) 'simple-error)
+                "(?s)× \\(ERROR ('MY-CONDITION|\\(QUOTE MY-CONDITION\\))\\) is expected to raise a condition SIMPLE-ERROR \\(got #<(a T.PROVE::)?MY-CONDITION.*>\\)")
+
+
+(test-assertion
+ "All lines of multiline description should be indented"
+ (is 'blah 'blah
+     "Blah with multiline
+description!")
+                "
+✓ Blah with multiline
+  description!")
+
+
+(test-assertion
+ "Multiline indentation should work for nested tests"
+ (subtest "Outer testcase
+with multiline
+description."
+   (is 'blah 'blah
+       "Blah with multiline
+description!")
+  
+   (subtest "Inner testcase
+with multiline description."
+     (is 'foo 'foo
+         "Foo with multiline
+description!")))
+                "
+Outer testcase
+with multiline
+description.
+   ✓ Blah with multiline
+     description! 
+  Inner testcase
+  with multiline description.
+     ✓ Foo with multiline
+       description!")
+
+
+(test-assertion "Check finalize's output without a plan"
+                (finalize)
+                "
+△ Tests were run but no plan was declared.
+✓ 0 tests completed (0ms)")
+
+
+(finalize)
diff --git a/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/t/utils.lisp b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/t/utils.lisp
new file mode 100644
index 0000000..1170447
--- /dev/null
+++ b/sbcl/.quicklisp/dists/quicklisp/software/prove-20171130-git/t/utils.lisp
@@ -0,0 +1,118 @@
+(in-package :cl-user)
+(defpackage prove.t.utils
+  (:use :cl)
+  (:import-from :split-sequence
+                :split-sequence)
+  (:import-from :alexandria
+                :with-gensyms)
+  (:import-from :prove
+                :like
+                :subtest
+                :is)
+  (:export :test-assertion))
+(in-package :prove.t.utils)
+
+
+(defun empty-line-p (line)
+  "Checks if line of text is empty."
+  (equal line ""))
+
+
+(defun get-indentation (line)
+  "Returns numbers of leading spaces for the line."
+  (loop
+     :for char :across line
+     :for num-spaces :upfrom 0
+     :when (not (equal char #\Space))
+     :do (return num-spaces)))
+
+
+(defun left-remove-if (items predicate)
+  "Returns list skipping leftmost items
+ which match a predicate."
+  (do ()
+      ((not (funcall predicate (car items))) items)
+    (setf items (cdr items))))
+
+(defun right-remove-if (items predicate)
+  "Returns a new list, without rightmost items
+which match a predicate."
+  (labels ((recur (items)
+             (destructuring-bind (head . tail) items
+               (if tail
+                   (let ((tail (recur tail)))
+                     (if tail
+                         (cons head tail)
+                         (unless (funcall predicate head)
+                           (list head))))
+                   (if (funcall predicate head)
+                       nil
+                       (list head))))))
+    (recur items)))
+
+
+(defun deindent (text)
+  "Removes empty new lines at the begining and at the end of the text,
+and removes common number of whitespaces from rest of the lines."
+  (let* ((all-lines (split-sequence
+                     #\Newline
+                     text))
+         ;; remove empty lines at beginning
+         (left-trimmed (left-remove-if
+                        all-lines
+                        #'empty-line-p))
+         ;; and at the end
+         (lines (right-remove-if
+                 left-trimmed
+                 #'empty-line-p))
+         
+         ;; calculate common indentation
+         (min-indent (apply #'min (mapcar #'get-indentation lines)))
+         
+         ;; remove common indentation from lines
+         (new-lines (loop :for line :in lines
+                       :collect (subseq line min-indent))))
+    
+    ;; now join lines together and separate them with new-lines
+    (values (format nil "~{~a~^~%~}" new-lines)
+            min-indent)))
+
+
+(defmacro test-assertion (title body expected
+                          &aux (method (if (search ".*" expected)
+                                           'like
+                                           'is)))
+  "Tests that assertion result in prove's output
+matches given regular expression.
+
+Body evaluated and it's result is matched agains expected string,
+using prove:like. Dangling spaces and newlines are trimmed from
+the result before trying to match."
+  
+  (with-gensyms (result trimmed-result deindented-expected)
+    `(subtest ,title
+       (let* ((,result
+               ;; All output during the test, should be captured
+               ;; to test against give regex
+               (with-output-to-string
+                   (prove.output:*test-result-output*)
+
+                 (let ( ;; Colors whould be turned off to
+                       ;; prevent Prove's reporter return
+                       ;; string with terminal sequences.
+                       ;; This way it will be easier to compare
+                       ;; results with usual strings
+                       (prove.color:*enable-colors* nil)
+                       ;; We need to overide current suite, to prevent
+                       ;; tested assert-that macro from modifying real testsuite.
+                       ;; Otherwise it can increment failed or success tests count
+                       ;; and prove will output wrong data.
+                       (prove.suite:*suite* (make-instance 'prove.suite:suite))
+                       (prove.reporter::*debug-indentation* nil))
+                   ,body)))
+
+              (,trimmed-result (string-trim '(#\Space #\Newline)
+                                            (deindent ,result)))
+              (,deindented-expected (deindent ,expected)))
+         (,method ,trimmed-result
+                  ,deindented-expected)))))
diff --git a/tmux/.tmux.conf b/tmux/.tmux.conf
index abdbb0e..ffe5c3b 100644
--- a/tmux/.tmux.conf
+++ b/tmux/.tmux.conf
@@ -32,7 +32,7 @@ bind -n C-k run "($is_vim && tmux send-keys C-k) || \
 bind -n C-l run  "($is_vim && tmux send-keys C-l) || \
                           tmux select-pane -R"
 
-bind-key -n C-\ if-shell "$is_vim" "send-keys C-\\" "select-pane -l"
+# bind-key -n C-\ if-shell "$is_vim" "send-keys C-\\" "select-pane -l"
 
 bind a resize-pane -Z
 
diff --git a/vim/.vim/.netrwhist b/vim/.vim/.netrwhist
index 6f00140..a026b32 100644
--- a/vim/.vim/.netrwhist
+++ b/vim/.vim/.netrwhist
@@ -1,5 +1,7 @@
 let g:netrw_dirhistmax  =10
-let g:netrw_dirhistcnt =3
+let g:netrw_dirhistcnt =5
+let g:netrw_dirhist_5='/home/green/.vim'
+let g:netrw_dirhist_4='/home/green/.newsboat'
 let g:netrw_dirhist_3='/home/green/.config/sxhkd'
 let g:netrw_dirhist_2='/home/green/.newsboat'
 let g:netrw_dirhist_1='/home/green/.config/sxhkd'
diff --git a/vim/.vimrc b/vim/.vimrc
index 5e1c747..6700f63 100755
--- a/vim/.vimrc
+++ b/vim/.vimrc
@@ -33,6 +33,11 @@
     Plug 'ap/vim-css-color'
     Plug 'dylanaraps/wal.vim'
     Plug 'sjl/tslime.vim'
+    " TODO setup
+    Plug 'roxma/vim-tmux-clipboard'
+    " TODO setup
+    Plug 'melonmanchan/vim-tmux-resizer'
+    " Plug 'roman/golden-ratio'
     Plug 'kovisoft/slimv'
     
     " Todo:
@@ -65,12 +70,12 @@
     set showcmd               " Show command in bottom bar
     set wildmenu              " Visual autocomplete for command menu
     set wildmode=list:longest " Show all completions on tab
-    set laststatus=1          " Last window will always have statusline
+    set laststatus=2        " Last window will always have statusline
     set showmatch             " Highlight matching [{()}]
     set cursorline            " Highlight current line
 
     " remove underline on current line number
-    hi CursorLineNr    cterm=bold 
+    hi CursorLineNr cterm=bold 
 
     " Lightline
     let g:lightline = { 'colorscheme': 'sceaduhelm', }
@@ -101,6 +106,10 @@
     set lazyredraw                 " Redraw only when necessary
     set updatetime=100             " Make updates happen faster (gitgutter)
     set splitright                 " Make split to right by default
+    set winheight=30               " Soft minimum window height (active)
+    set winminheight=10               " Hard minimum window height (inactive)
+    set winwidth=80                " Window width for current window
+    set winminwidth=30             " Hard minimum for window width
 
 "}}} 
 
@@ -184,6 +193,12 @@
     nnoremap k gk
 
 "}}}
+"
+" slimv{{{
+    let g:slimv_repl_split=2
+    let g:slimv_repl_split_size=10
+"
+"}}}
 
 " split pane navigation {{{
     " Map vertical split to \ w, switch to it, open explorer, prompt for filename
diff --git a/x/.Xresources b/x/.Xresources
index 3a8db04..caac3c3 100644
--- a/x/.Xresources
+++ b/x/.Xresources
@@ -40,7 +40,8 @@
 
 
 
-URxvt.font: xft:BitstreamVeraSansMono:antialias=true:pixelsize=14
+!URxvt.font: xft:BitstreamVeraSansMono:antialias=true:pixelsize=14
+URxvt.font: xft:DejaVu Sans Mono:pixelsize=14, xft:symbola:pixelsize=14, xft:Kochi Gothic:antialias=false
 URxvt.letterSpace: 0
 URxvt.lineSpace: 0
 URxvt.geometry: 92x24
@@ -62,3 +63,7 @@ URxvt.shading: 30
 !URxvt.depth: 32
 !URxvt.background: rgba:0000/0000/0200/c800
 
+
+!! DZEN2
+!
+dzen2.font: xft:BitstreamVeraSansMono:antialias=true:pixelsize=14
diff --git a/x/.xinitrc b/x/.xinitrc
index ac7f120..d94cf45 100644
--- a/x/.xinitrc
+++ b/x/.xinitrc
@@ -1 +1,12 @@
+#picom &
+
+xrdb .Xresources &
+feh --bg-fill ~/Documents/Pictures/Wallpapers/winfuck.jpg &
+#exec i3
+mpd &
+pulseaudio &
+setxkbmap -option caps:ctrl_modifier &
+i3status | dzen2 -ta r -y 1062 -dock -fn xft:BitstreamVeraSansMono:pixelsize=14 &
 exec bspwm
+
+
diff --git a/zsh/.zshrc b/zsh/.zshrc
index 0290b6a..394163f 100644
--- a/zsh/.zshrc
+++ b/zsh/.zshrc
@@ -67,5 +67,19 @@ lfcd () {
 
 bindkey -s '^o' 'lfcd\n'  # zsh
 
+# bindkey '^e' edit-command-line
+
 # Load zsh-syntax-highlighting; should be last.
 source /usr/share/zsh/plugins/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh 2>/dev/null
+
+# man page colors
+man() {
+    LESS_TERMCAP_md=$'\e[01;31m' \
+    LESS_TERMCAP_me=$'\e[0m' \
+    LESS_TERMCAP_se=$'\e[0m' \
+    LESS_TERMCAP_so=$'\e[01;44;33m' \
+    LESS_TERMCAP_ue=$'\e[0m' \
+    LESS_TERMCAP_us=$'\e[01;32m' \
+    command man "$@"
+}
+