diff --git "a/codeparrot-valid_104.txt" "b/codeparrot-valid_104.txt"
new file mode 100644--- /dev/null
+++ "b/codeparrot-valid_104.txt"
@@ -0,0 +1,10000 @@
+    def is_detached(self):
+        # symbolic-ref returns 1 if the repo is in a detached HEAD state
+        with open(os.devnull, 'w') as DEVNULL:
+            return self._callgit(["symbolic-ref", "--quiet", "HEAD"], stdout=DEVNULL)
+
+    def is_ancestor(self, parent, child):
+        # merge base returns 0 if parent is an ancestor of child
+        return not self._callgit(["merge-base", "--is-ancestor", parent, child])
+
+    def is_commit(self, sha1):
+        # cat-file -e returns 0 if it is a valid hash
+        return not self._callgit(["cat-file", "-e", "%s^{commit}" % sha1])
+
+    def is_working_tree_dirty(self):
+        # diff returns 1 if the working tree has local changes
+        return self._callgit(["diff", "--quiet"])
+
+    def does_branch_exist(self, branch):
+        # rev-parse returns 0 if the branch exists
+        return not self._callgit(["rev-parse", "--verify", "--quiet", branch])
+
+    def get_merge_base(self, commit):
+        return self._callgito(["merge-base", "HEAD", commit]).rstrip()
+
+    def get_branch_name(self):
+        """Get the current branch name, short form
+           This returns "master", not "refs/head/master"
+           Will not work if the current branch is detached
+        """
+        branch = self.rev_parse(["--abbrev-ref", "HEAD"])
+        if branch == "HEAD":
+            raise ValueError("Branch is currently detached")
+
+        return branch
+
+    def add(self, command):       return self._callgito(["add"] + command)
+    def checkout(self, command):  return self._callgito(["checkout"] + command)
+    def commit(self, command):    return self._callgito(["commit"] + command)
+    def diff(self, command):      return self._callgito(["diff"] + command)
+    def log(self, command):       return self._callgito(["log"] + command)
+    def rev_parse(self, command): return self._callgito(["rev-parse"] + command).rstrip()
+    def rm(self, command):        return self._callgito(["rm"] + command)
+    def show(self, command):      return self._callgito(["show"] + command)
+    def lsfiles(self):            return self._callgito(["ls-files"])
+
+class ClangFormat(object):
+    """Class encapsulates finding a suitable copy of clang-format,
+    and linting/formating an individual file
+    """
+    def __init__(self, cf_cmd):
+        self.cf_cmd = cf_cmd
+        if which(cf_cmd) is None:
+            raise ValueError("Could not find clang-format at %s" % cf_cmd)
+        self._validate_version()
+
+    def _validate_version(self):
+        cf_version = callo([self.cf_cmd, "--version"])
+
+        if CLANG_FORMAT_ACCEPTED_VERSION_REGEX.search(cf_version):
+            return
+
+        # TODO add instructions to check docs when docs are written
+        raise ValueError("clang-format found, but incorrect version at " +
+                self.cf_cmd + " with version: " + cf_version + "\nAccepted versions: " +
+                CLANG_FORMAT_ACCEPTED_VERSION_STRING)
+        sys.exit(5)
+
+    def lint(self, file_name, print_diff):
+        """Check the specified file has the correct format
+        """
+        with open(file_name, 'rb') as original_text:
+            original_file = original_text.read().decode('utf-8')
+
+        # Get formatted file as clang-format would format the file
+        formatted_file = callo([self.cf_cmd, '-style=file', file_name])
+
+        if original_file != formatted_file:
+            if print_diff:
+                original_lines = original_file.splitlines()
+                formatted_lines = formatted_file.splitlines()
+                result = difflib.unified_diff(original_lines, formatted_lines, file_name, file_name)
+                for line in result:
+                    print(line.rstrip())
+
+            return False
+
+        return True
+
+    def format(self, file_name):
+        """Update the format of the specified file
+        """
+        if self.lint(file_name, print_diff=False):
+            return True
+
+        # Update the file with clang-format
+        formatted = not subprocess.call([self.cf_cmd, '-style=file', '-i', file_name])
+
+        # Version 3.8 generates files like foo.cpp~RF83372177.TMP when it formats foo.cpp
+        # on Windows, we must clean these up
+        if sys.platform == "win32":
+            glob_pattern = file_name + "*.TMP"
+            for fglob in glob.glob(glob_pattern):
+                os.unlink(fglob)
+
+        return formatted
+
+def get_list_from_lines(lines):
+    """"Convert a string containing a series of lines into a list of strings
+    """
+    return [line.rstrip() for line in lines.splitlines()]
+
+def validate_repo_state_for_rebase(commit_before_reformat, commit_after_reformat, target_branch):
+    if sys.version_info[0] == 2:
+        cwd = os.getcwdu()
+    else:
+        cwd = os.getcwd()
+
+    if os.path.normpath(cwd) != os.path.normpath(get_base_dir()):
+        raise ValueError("reformat-branch must be run from the repo root")
+
+    repo = Repo(get_base_dir())
+
+    if not repo.is_commit(commit_before_reformat):
+        raise ValueError("Commit before reformat '%s' is not a valid commit in this repo" %
+                commit_before_reformat)
+
+    if not repo.is_commit(commit_after_reformat):
+        raise ValueError("Commit after reformat '%s' is not a valid commit in this repo" %
+                commit_after_reformat)
+
+    if not repo.is_ancestor(commit_before_reformat, commit_after_reformat):
+        raise ValueError(("Commit before reformat '%s' is not a valid ancestor of commit after" +
+                " reformat '%s' in this repo") % (commit_before_reformat, commit_after_reformat))
+
+    if repo.is_detached():
+        raise ValueError("You must not run this script in a detached HEAD state")
+
+    if repo.is_working_tree_dirty():
+        raise ValueError("Your working tree has pending changes. You must have a clean working" +
+            " tree before proceeding.\n\nRun `git status` to see your pending changes, and then" +
+            " try `git stash save`, `git reset --hard`, `git submodule update` and/or committing" +
+            " your changes.")
+
+    merge_base = repo.get_merge_base(commit_before_reformat)
+
+    if not merge_base == repo.rev_parse([commit_before_reformat]):
+        raise ValueError(("Merge base is '%s'. Please rebase to '%s' and resolve all conflicts" +
+            " before running this script.\n\nTo interactively rebase, use `git rebase -i %s`") %
+            (merge_base, commit_before_reformat, commit_before_reformat))
+
+    # We assume the target branch is master, it could be a different branch if needed for testing
+    merge_base = repo.get_merge_base(target_branch)
+
+    if not merge_base == repo.rev_parse([commit_before_reformat]):
+        raise ValueError("This branch appears to already have advanced too far through the merge process")
+
+    return repo
+
+def get_branch_names(repo):
+    # Everything looks good so lets start going through all the commits
+    branch_name = repo.get_branch_name()
+    new_branch = branch_name + "-reformatted"
+
+    if repo.does_branch_exist(new_branch):
+        raise ValueError("The branch '%s' already exists. Please delete the branch '%s', or rename the current branch." % (new_branch, new_branch))
+
+    return (branch_name, new_branch)
+
+def is_3rd_party_file(name):
+    return name.find('external_libraries') != -1
+def is_autogen_file(name):
+    return AUTOGEN_FILES_REGEX.search(name)
+def is_clang_formattable(name):
+    return CLANG_FORMAT_FILES_REGEX.search(name)
+
+def is_wanted_clang_formattable_file(f):
+    """Is this something we want to use ClangFormat to format?
+    """
+    return is_clang_formattable(f) and not is_3rd_party_file(f) and not is_autogen_file(f)
+
+def get_all_clang_formattable_files(repo):
+    files = get_list_from_lines(repo.lsfiles())
+    return [f for f in files if is_wanted_clang_formattable_file(f)]
+
+def rebase_branch(clang_format, commit_before_reformat, commit_after_reformat, target_branch):
+    """Reformat a branch made before a clang-format run
+    """
+    clang_format = ClangFormat(clang_format)
+    repo = validate_repo_state_for_rebase(commit_before_reformat, commit_after_reformat, target_branch)
+    old_branch, new_branch = get_branch_names(repo)
+    commits = get_list_from_lines(repo.log(["--reverse", "--pretty=format:%H", "%s..HEAD" % commit_before_reformat]))
+    previous_commit_base = commit_after_reformat
+
+    # Go through all the commits the user made on the local branch and migrate to a new branch
+    # that is based on post_reformat commits instead
+    for idx, commit_hash in enumerate(commits):
+        print("--- Formatting " + commit_hash + (" (%s of %s)" % (idx + 1, len(commits))))
+        repo.checkout(["--quiet", "--detach", commit_hash])
+
+        deleted_files = []
+
+        # Format each of the files by checking out just a single commit from the user's branch
+        commit_files = get_list_from_lines(repo.diff(["HEAD~", "--name-only"]))
+
+        for commit_file in commit_files:
+
+            # Format each file needed if it was not deleted
+            if not os.path.exists(commit_file):
+                print("\tSkipping file '%s' since it has been deleted in commit '%s'" % (
+                        commit_file, commit_hash))
+                deleted_files.append(commit_file)
+                continue
+
+            if is_3rd_party_file(commit_file):
+                print("\tSkipping external libraries file '%s'" % commit_file)
+            elif is_autogen_file(commit_file):
+                print("\tSkipping autogenerated file '%s'" % commit_file)
+            elif is_clang_formattable(commit_file):
+                clang_format.format(commit_file)
+            else:
+                print("\tSkipping file '%s' (no formatting to apply)" % commit_file)
+
+        # Check if anything needed reformatting, and if so amend the commit
+        if not repo.is_working_tree_dirty():
+            print ("Commit %s needed no reformatting" % commit_hash)
+        else:
+            repo.commit(["--all", "--amend", "--no-edit"])
+
+        # Rebase our new commit on top the post-reformat commit
+        previous_commit = repo.rev_parse(["HEAD"])
+
+        # Checkout the new branch with the reformatted commits
+        # Note: we will not name as a branch until we are done with all commits on the local branch
+        repo.checkout(["--quiet", "--detach", previous_commit_base])
+
+        # Copy each file from the reformatted commit on top of the post reformat
+        diff_files = get_list_from_lines(repo.diff(["%s~..%s" % (previous_commit, previous_commit),
+            "--name-only"]))
+
+        for diff_file in diff_files:
+            # If the file was deleted in the commit we are reformatting, we need to delete it again
+            if diff_file in deleted_files:
+                repo.rm([diff_file])
+                continue
+
+            # The file has been added or modified, continue as normal
+            file_contents = repo.show(["%s:%s" % (previous_commit, diff_file)])
+
+            root_dir = os.path.dirname(diff_file)
+            if root_dir and not os.path.exists(root_dir):
+                os.makedirs(root_dir)
+
+            with open(diff_file, "w+") as new_file:
+                new_file.write(file_contents)
+
+            repo.add([diff_file])
+
+        # Create a new commit onto clang-formatted branch
+        repo.commit(["--reuse-message=%s" % previous_commit])
+
+        previous_commit_base = repo.rev_parse(["HEAD"])
+
+    # Create a new branch to mark the hashes we have been using
+    repo.checkout(["-b", new_branch])
+
+    print("reformat-branch is done running.\n")
+    print("A copy of your branch has been made named '%s', and formatted with clang-format.\n" % new_branch)
+    print("The original branch has been left unchanged.")
+    print("If you have not just done so, the next step is to rebase the new branch on '%s'.\n" % target_branch)
+    print("To undo this, run `git checkout %s && git branch -D %s`" % (old_branch, new_branch))
+
+def is_wanted_diff(diff_text):
+    # Extract file name
+    match = DIFF_FILENAME_REGEX.search(diff_text)
+    if not match:
+        if '+++ /dev/null' in diff_text:
+            # The file was deleted, so ignore it:
+            return False;
+        raise ValueError("Could not extract filename from diff")
+    return is_wanted_clang_formattable_file(match.group(1))
+
+def filter_unwanted_files_from_diff(diff_text):
+    # git diff was called with -U0 so all actual diffed lines can't start with '^diff'
+    # Couldn't find a way to split on lookaheads, so went with this instead.
+    # [1:] to discard initial empty string
+    diffs = ['diff' + match for match in re.split('^diff', diff_text, flags=re.MULTILINE)][1:]
+    filter_diffs = [diff for diff in diffs if is_wanted_diff(diff)]
+    return ''.join(filter_diffs)
+
+def prepare_diff_for_lint_format(clang_format, commit):
+    ClangFormat(clang_format) # validation
+
+    repo = Repo(get_base_dir())
+    if not repo.is_commit(commit):
+        raise ValueError("Commit before reformat '%s' is not a valid commit in this repo" % commit)
+
+    os.chdir(repo.path)
+
+    diff_text = repo.diff([commit, '-U0', '--no-color'])
+    return filter_unwanted_files_from_diff(diff_text)
+
+def do_lint(clang_format, clang_format_diff, commit):
+    diff_text = prepare_diff_for_lint_format(clang_format, commit)
+    lint_out = callo_with_input(['python', clang_format_diff, '-p1', '-binary', clang_format], diff_text)
+    print(lint_out, end='')
+    if lint_out != '\n' and lint_out != '':
+        sys.exit(1)
+
+def do_format(clang_format, clang_format_diff, commit):
+    diff_text = prepare_diff_for_lint_format(clang_format, commit)
+    callo_with_input(['python', clang_format_diff, '-i', '-p1', '-binary', clang_format], diff_text)
+
+def do_lintall(clang_format):
+    repo = Repo(get_base_dir())
+    os.chdir(repo.path)
+    clang_format = ClangFormat(clang_format)
+    no_changes_needed = True
+    for f in get_all_clang_formattable_files(repo):
+        no_changes_needed = clang_format.lint(f, True) and no_changes_needed
+    if not no_changes_needed:
+        sys.exit(1)
+
+def do_formatall(clang_format):
+    repo = Repo(get_base_dir())
+    os.chdir(repo.path)
+    clang_format = ClangFormat(clang_format)
+    for f in get_all_clang_formattable_files(repo):
+        clang_format.format(f)
+
+def resolve_program_name(cmd_line_option, env_var_name, default_program_name):
+    if cmd_line_option != '':
+        return cmd_line_option
+    elif env_var_name in os.environ and os.environ[env_var_name] != '':
+        return os.environ[env_var_name]
+    else:
+        return default_program_name
+
+def main():
+    parser = ArgumentParser(
+            usage='''
+    format.py lint [commit]
+    format.py format [commit]
+    format.py lintall
+    format.py formatall
+    format.py rebase -b base-branch
+    format.py rebase commit1 commit2 target
+
+PLEASE READ.
+
+This script provides commands for linting and formatting your working directory. It provides five
+commands:
+1. `lint` lints the diff between the working directory and a given commit
+2. `format` will apply formatting rules to the diff between working directory and given commit
+3. `lintall` lints all available files for various formatting rules and indicates any problems.
+4. `formatall` formats all available files.
+5. `rebase` reformats a branch past the great reformatting wall. It can be run two ways; the second
+   is simpler and usually works.
+    a. `format.py rebase commit-right-before-reformat commit-after-reformat original-branch`
+    b. `format.py 3.10 # or develop`
+
+Rebase requires:
+- you have a clean working directory
+- you have rebased your branch on commit-right-before-reformat (implicitly for the second usage)
+- you have the branch you want to rebase currently checked out
+
+If there is an issue, this script will most likely detect it and provide you with commands to
+proceed.
+
+'commit' arguments can be a branch name, tag, or commit hash.
+
+This script will exit with 0 on success, 1 to indicate lint failure, and >1 if some other error
+occurs.
+''')
+    parser.add_argument("-c", "--clang-format", dest="clang_format", default='',
+            help='Command to use for clang-format; will also be passed to clang-format-diff.py.'
+            + ' Defaults to environment variable SC_CLANG_FORMAT if it is set and non-empty,'
+            + ' otherwise `clang-format`')
+    parser.add_argument("-b", "--base", dest="base_branch", help='Tries to rebase on the tip of this'
+            + ' branch given a base branch name (experimental). This should be the main branch the'
+            + ' current branch is based on (3.10 or develop)')
+    parser.add_argument("-d", "--clang-format-diff", dest="clang_format_diff", default='',
+            help='Command to use for clang-format-diff.py script'
+            + ' Defaults to environment variable SC_CLANG_FORMAT_DIFF if it is set and non-empty,'
+            + ' otherwise `clang-format-diff.py`')
+    parser.add_argument("command", help="command; one of lint, format, lintall, formatall, rebase")
+    parser.add_argument("commit1", help="for lint and format: commit to compare against (default: HEAD);" +
+            " for rebase: commit immediately prior to reformat", nargs='?', default='')
+    parser.add_argument("commit2", help="commit after reformat", nargs='?', default='')
+    parser.add_argument("target", help="target branch name (likely 3.10 or develop)", nargs='?', default='')
+
+    options = parser.parse_args()
+
+    options.clang_format = resolve_program_name(options.clang_format, 'SC_CLANG_FORMAT', 'clang-format')
+    options.clang_format_diff = resolve_program_name(options.clang_format_diff, 'SC_CLANG_FORMAT_DIFF', 'clang-format-diff.py')
+
+    try:
+        if options.command == 'lint' or options.command == 'format':
+            commit = 'HEAD' if options.commit1 == '' else options.commit1
+
+            # For portability, we use the full path of the clang-format-diff.py script. subprocess
+            # module on Windows won't be able to find a Python-executable python script in PATH, and
+            # if we invoke it with `python <script> <args>` then the python interpreter needs the
+            # full path of the script. Of course, the downside is that we use whatever `python`
+            # resolves to in the host system's shell.
+            clang_format_diff_path = which(options.clang_format_diff)
+            if clang_format_diff_path is None:
+                if options.clang_format_diff == 'clang-format-diff.py':
+                    raise ValueError(
+                            "Could not find clang-format-diff.py. "
+                            "Please ensure that clang %s is installed and that "
+                            "clang-format-diff.py is in your PATH."
+                            % CLANG_FORMAT_ACCEPTED_VERSION_STRING)
+                else:
+                    raise ValueError("Could not find clang-format-diff.py at %s." % options.clang_format_diff)
+            if options.command == 'lint':
+                do_lint(options.clang_format, clang_format_diff_path, commit)
+            else:
+                do_format(options.clang_format, clang_format_diff_path, commit)
+        elif options.command == 'lintall':
+            do_lintall(options.clang_format)
+        elif options.command == 'formatall':
+            do_formatall(options.clang_format)
+        elif options.command == 'rebase':
+            if not options.commit1 or not options.commit2 or not options.target:
+                if not options.base_branch:
+                    parser.print_help()
+                    sys.exit(2)
+
+                if options.base_branch == '3.10':
+                    options.commit1 = 'tag-clang-format-3.10^'
+                    options.commit2 = options.target = 'tag-clang-format-3.10'
+                elif options.base_branch == 'develop':
+                    options.commit1 = 'tag-clang-format-develop^'
+                    options.commit2 = options.target = 'tag-clang-format-develop'
+                else:
+                    print("Don't know how to use this base branch: %s. Try using the three-argument " +
+                            "version of rebase command")
+                    sys.exit(3)
+
+            rebase_branch(options.clang_format, options.commit1, options.commit2, options.target)
+        else:
+            parser.print_help()
+            sys.exit(4)
+    except ValueError as ve:
+        # print entire traceback to aid in diagnosing issues
+        import traceback
+        traceback.print_tb(sys.exc_info()[2])
+        print("\n*** ERROR:\n" + str(ve) + "\n")
+        sys.exit(6)
+
+if __name__ == "__main__":
+    main()
+
+"""
+===================================================
+Recursive feature elimination with cross-validation
+===================================================
+
+A recursive feature elimination example with automatic tuning of the
+number of features selected with cross-validation.
+"""
+print(__doc__)
+
+import matplotlib.pyplot as plt
+from sklearn.svm import SVC
+from sklearn.cross_validation import StratifiedKFold
+from sklearn.feature_selection import RFECV
+from sklearn.datasets import make_classification
+
+# Build a classification task using 3 informative features
+X, y = make_classification(n_samples=1000, n_features=25, n_informative=3,
+                           n_redundant=2, n_repeated=0, n_classes=8,
+                           n_clusters_per_class=1, random_state=0)
+
+# Create the RFE object and compute a cross-validated score.
+svc = SVC(kernel="linear")
+# The "accuracy" scoring is proportional to the number of correct
+# classifications
+rfecv = RFECV(estimator=svc, step=1, cv=StratifiedKFold(y, 2),
+              scoring='accuracy')
+rfecv.fit(X, y)
+
+print("Optimal number of features : %d" % rfecv.n_features_)
+
+# Plot number of features VS. cross-validation scores
+plt.figure()
+plt.xlabel("Number of features selected")
+plt.ylabel("Cross validation score (nb of correct classifications)")
+plt.plot(range(1, len(rfecv.grid_scores_) + 1), rfecv.grid_scores_)
+plt.show()
+
+# -*- coding: utf-8 -*-
+# Copyright ReportLab Europe Ltd. 2000-2008
+# see license.txt for license details
+# history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/platypus/paragraph.py
+# Modifications by Dirk Holtwick, 2008
+from string import join, whitespace
+from operator import truth
+from reportlab.pdfbase.pdfmetrics import stringWidth, getAscentDescent
+from reportlab.platypus.paraparser import ParaParser
+from reportlab.platypus.flowables import Flowable
+from reportlab.lib.colors import Color
+from reportlab.lib.enums import TA_LEFT, TA_RIGHT, TA_CENTER, TA_JUSTIFY
+from reportlab.lib.textsplit import ALL_CANNOT_START
+from copy import deepcopy
+from reportlab.lib.abag import ABag
+import re
+
+PARAGRAPH_DEBUG = False
+LEADING_FACTOR = 1.0
+
+_wsc_re_split=re.compile('[%s]+'% re.escape(''.join((
+    u'\u0009',    # HORIZONTAL TABULATION
+    u'\u000A',    # LINE FEED
+    u'\u000B',    # VERTICAL TABULATION
+    u'\u000C',    # FORM FEED
+    u'\u000D',    # CARRIAGE RETURN
+    u'\u001C',    # FILE SEPARATOR
+    u'\u001D',    # GROUP SEPARATOR
+    u'\u001E',    # RECORD SEPARATOR
+    u'\u001F',    # UNIT SEPARATOR
+    u'\u0020',    # SPACE
+    u'\u0085',    # NEXT LINE
+    #u'\u00A0', # NO-BREAK SPACE
+    u'\u1680',    # OGHAM SPACE MARK
+    u'\u2000',    # EN QUAD
+    u'\u2001',    # EM QUAD
+    u'\u2002',    # EN SPACE
+    u'\u2003',    # EM SPACE
+    u'\u2004',    # THREE-PER-EM SPACE
+    u'\u2005',    # FOUR-PER-EM SPACE
+    u'\u2006',    # SIX-PER-EM SPACE
+    u'\u2007',    # FIGURE SPACE
+    u'\u2008',    # PUNCTUATION SPACE
+    u'\u2009',    # THIN SPACE
+    u'\u200A',    # HAIR SPACE
+    u'\u200B',    # ZERO WIDTH SPACE
+    u'\u2028',    # LINE SEPARATOR
+    u'\u2029',    # PARAGRAPH SEPARATOR
+    u'\u202F',    # NARROW NO-BREAK SPACE
+    u'\u205F',    # MEDIUM MATHEMATICAL SPACE
+    u'\u3000',    # IDEOGRAPHIC SPACE
+    )))).split
+
+def split(text, delim=None):
+    if type(text) is str:
+        text = text.decode('utf8')
+    if type(delim) is str:
+        delim = delim.decode('utf8')
+    elif delim is None and u'\xa0' in text:
+        return [uword.encode('utf8') for uword in _wsc_re_split(text)]
+    return [uword.encode('utf8') for uword in text.split(delim)]
+
+def strip(text):
+    if type(text) is str:
+        text = text.decode('utf8')
+    return text.strip().encode('utf8')
+
+class ParaLines(ABag):
+    """
+    class ParaLines contains the broken into lines representation of Paragraphs
+        kind=0  Simple
+        fontName, fontSize, textColor apply to whole Paragraph
+        lines   [(extraSpace1,words1),....,(extraspaceN,wordsN)]
+
+        kind==1 Complex
+        lines   [FragLine1,...,FragLineN]
+    """
+
+class FragLine(ABag):
+    """
+    class FragLine contains a styled line (ie a line with more than one style)::
+
+    extraSpace  unused space for justification only
+    wordCount   1+spaces in line for justification purposes
+    words       [ParaFrags] style text lumps to be concatenated together
+    fontSize    maximum fontSize seen on the line; not used at present,
+                but could be used for line spacing.
+    """
+
+#our one and only parser
+# XXXXX if the parser has any internal state using only one is probably a BAD idea!
+_parser=ParaParser()
+
+def _lineClean(L):
+    return join(filter(truth,split(strip(L))))
+
+def cleanBlockQuotedText(text,joiner=' '):
+    """This is an internal utility which takes triple-
+    quoted text form within the document and returns
+    (hopefully) the paragraph the user intended originally."""
+    L=filter(truth,map(_lineClean, split(text, '\n')))
+    return join(L, joiner)
+
+def setXPos(tx,dx):
+    if dx>1e-6 or dx<-1e-6:
+        tx.setXPos(dx)
+
+def _leftDrawParaLine( tx, offset, extraspace, words, last=0):
+    setXPos(tx,offset)
+    tx._textOut(join(words),1)
+    setXPos(tx,-offset)
+    return offset
+
+def _centerDrawParaLine( tx, offset, extraspace, words, last=0):
+    m = offset + 0.5 * extraspace
+    setXPos(tx,m)
+    tx._textOut(join(words),1)
+    setXPos(tx,-m)
+    return m
+
+def _rightDrawParaLine( tx, offset, extraspace, words, last=0):
+    m = offset + extraspace
+    setXPos(tx,m)
+    tx._textOut(join(words),1)
+    setXPos(tx,-m)
+    return m
+
+def _justifyDrawParaLine( tx, offset, extraspace, words, last=0):
+    setXPos(tx,offset)
+    text  = join(words)
+    if last:
+        #last one, left align
+        tx._textOut(text,1)
+    else:
+        nSpaces = len(words)-1
+        if nSpaces:
+            tx.setWordSpace(extraspace / float(nSpaces))
+            tx._textOut(text,1)
+            tx.setWordSpace(0)
+        else:
+            tx._textOut(text,1)
+    setXPos(tx,-offset)
+    return offset
+
+def imgVRange(h,va,fontSize):
+    '''return bottom,top offsets relative to baseline(0)'''
+    if va=='baseline':
+        iyo = 0
+    elif va in ('text-top','top'):
+        iyo = fontSize-h
+    elif va=='middle':
+        iyo = fontSize - (1.2*fontSize+h)*0.5
+    elif va in ('text-bottom','bottom'):
+        iyo = fontSize - 1.2*fontSize
+    elif va=='super':
+        iyo = 0.5*fontSize
+    elif va=='sub':
+        iyo = -0.5*fontSize
+    elif hasattr(va,'normalizedValue'):
+        iyo = va.normalizedValue(fontSize)
+    else:
+        iyo = va
+    return iyo,iyo+h
+
+_56=5./6
+_16=1./6
+def _putFragLine(cur_x, tx, line):
+    xs = tx.XtraState
+    cur_y = xs.cur_y
+    x0 = tx._x0
+    autoLeading = xs.autoLeading
+    leading = xs.leading
+    cur_x += xs.leftIndent
+    dal = autoLeading in ('min','max')
+    if dal:
+        if autoLeading=='max':
+            ascent = max(_56*leading,line.ascent)
+            descent = max(_16*leading,-line.descent)
+        else:
+            ascent = line.ascent
+            descent = -line.descent
+        leading = ascent+descent
+    if tx._leading!=leading:
+        tx.setLeading(leading)
+    if dal:
+        olb = tx._olb
+        if olb is not None:
+            xcy = olb-ascent
+            if tx._oleading!=leading:
+                cur_y += leading - tx._oleading
+            if abs(xcy-cur_y)>1e-8:
+                cur_y = xcy
+                tx.setTextOrigin(x0,cur_y)
+                xs.cur_y = cur_y
+        tx._olb = cur_y - descent
+        tx._oleading = leading
+    ws = getattr(tx,'_wordSpace',0)
+    nSpaces = 0
+    words = line.words
+    for f in words:
+        if hasattr(f,'cbDefn'):
+            cbDefn = f.cbDefn
+            kind = cbDefn.kind
+            if kind=='img':
+                #draw image cbDefn,cur_y,cur_x
+                w = cbDefn.width
+                h = cbDefn.height
+                txfs = tx._fontsize
+                if txfs is None:
+                    txfs = xs.style.fontSize
+                iy0,iy1 = imgVRange(h,cbDefn.valign,txfs)
+                cur_x_s = cur_x + nSpaces*ws
+                # print "draw", id(f), id(cbDefn.image), repr(dal), cur_y, iy0, iy1, h
+                tx._canvas.drawImage(cbDefn.image.getImage(),cur_x_s,cur_y+iy0,w,h,mask='auto')
+                cur_x += w
+                cur_x_s += w
+                setXPos(tx,cur_x_s-tx._x0)
+            elif kind=='barcode':
+                barcode = cbDefn.barcode
+                w = cbDefn.width
+                h = cbDefn.height
+                txfs = tx._fontsize
+                if txfs is None:
+                    txfs = xs.style.fontSize
+                iy0, iy1 = imgVRange(h, cbDefn.valign, txfs)
+                cur_x_s = cur_x + nSpaces*ws
+                barcode.draw(canvas=tx._canvas, xoffset=cur_x_s)
+                cur_x += w
+                cur_x_s += w
+                setXPos(tx, cur_x_s-tx._x0)
+            else:
+                name = cbDefn.name
+                if kind=='anchor':
+                    tx._canvas.bookmarkHorizontal(name,cur_x,cur_y+leading)
+                else:
+                    func = getattr(tx._canvas,name,None)
+                    if not func:
+                        raise AttributeError("Missing %s callback attribute '%s'" % (kind,name))
+                    func(tx._canvas,kind,cbDefn.label)
+            if f is words[-1]:
+                if not tx._fontname:
+                    tx.setFont(xs.style.fontName,xs.style.fontSize)
+                    tx._textOut('',1)
+                elif kind=='img':
+                    tx._textOut('',1)
+        else:
+            cur_x_s = cur_x + nSpaces*ws
+            if (tx._fontname,tx._fontsize)!=(f.fontName,f.fontSize):
+                tx._setFont(f.fontName, f.fontSize)
+            if xs.textColor!=f.textColor:
+                xs.textColor = f.textColor
+                tx.setFillColor(f.textColor)
+            if xs.rise!=f.rise:
+                xs.rise=f.rise
+                tx.setRise(f.rise)
+            text = f.text
+            tx._textOut(text,f is words[-1])    # cheap textOut
+
+            # XXX Modified for XHTML2PDF
+            # Background colors (done like underline)
+            # print "#", repr(f.text), f.fontSize, f.backColor, f.underline
+            if hasattr(f, "backColor"):
+                if xs.backgroundColor != f.backColor or xs.backgroundFontSize != f.fontSize:
+                    if xs.backgroundColor is not None:
+                        xs.backgrounds.append((xs.background_x, cur_x_s, xs.backgroundColor, xs.backgroundFontSize))
+                    xs.background_x = cur_x_s
+                    xs.backgroundColor = f.backColor
+                    xs.backgroundFontSize = f.fontSize
+
+            # Underline
+            if not xs.underline and f.underline:
+                xs.underline = 1
+                xs.underline_x = cur_x_s
+                xs.underlineColor = f.textColor
+            elif xs.underline:
+                if not f.underline:
+                    xs.underline = 0
+                    xs.underlines.append((xs.underline_x, cur_x_s, xs.underlineColor))
+                    xs.underlineColor = None
+                elif xs.textColor != xs.underlineColor:
+                    xs.underlines.append((xs.underline_x, cur_x_s, xs.underlineColor))
+                    xs.underlineColor = xs.textColor
+                    xs.underline_x = cur_x_s
+
+            # Strike
+            if not xs.strike and f.strike:
+                xs.strike = 1
+                xs.strike_x = cur_x_s
+                xs.strikeColor = f.textColor
+                # XXX Modified for XHTML2PDF
+                xs.strikeFontSize = f.fontSize
+            elif xs.strike:
+                if not f.strike:
+                    xs.strike = 0
+                    # XXX Modified for XHTML2PDF
+                    xs.strikes.append((xs.strike_x, cur_x_s, xs.strikeColor, xs.strikeFontSize))
+                    xs.strikeColor = None
+                    xs.strikeFontSize = None
+                elif xs.textColor != xs.strikeColor:
+                    xs.strikes.append((xs.strike_x, cur_x_s, xs.strikeColor, xs.strikeFontSize))
+                    xs.strikeColor = xs.textColor
+                    xs.strikeFontSize = f.fontSize
+                    xs.strike_x = cur_x_s
+            if f.link and not xs.link:
+                if not xs.link:
+                    xs.link = f.link
+                    xs.link_x = cur_x_s
+                    xs.linkColor = xs.textColor
+            elif xs.link:
+                if not f.link:
+                    xs.links.append( (xs.link_x, cur_x_s, xs.link, xs.linkColor) )
+                    xs.link = None
+                    xs.linkColor = None
+                elif f.link!=xs.link or xs.textColor!=xs.linkColor:
+                    xs.links.append( (xs.link_x, cur_x_s, xs.link, xs.linkColor) )
+                    xs.link = f.link
+                    xs.link_x = cur_x_s
+                    xs.linkColor = xs.textColor
+            txtlen = tx._canvas.stringWidth(text, tx._fontname, tx._fontsize)
+            cur_x += txtlen
+            nSpaces += text.count(' ')
+    cur_x_s = cur_x+(nSpaces-1)*ws
+
+    # XXX Modified for XHTML2PDF
+    # Underline
+    if xs.underline:
+        xs.underlines.append((xs.underline_x, cur_x_s, xs.underlineColor))
+
+    # XXX Modified for XHTML2PDF
+    # Backcolor
+    if hasattr(f, "backColor"):
+        if xs.backgroundColor is not None:
+            xs.backgrounds.append((xs.background_x, cur_x_s, xs.backgroundColor, xs.backgroundFontSize))
+
+    # XXX Modified for XHTML2PDF
+    # Strike
+    if xs.strike:
+        xs.strikes.append((xs.strike_x, cur_x_s, xs.strikeColor, xs.strikeFontSize))
+
+    if xs.link:
+        xs.links.append( (xs.link_x, cur_x_s, xs.link,xs.linkColor) )
+    if tx._x0!=x0:
+        setXPos(tx,x0-tx._x0)
+
+def _leftDrawParaLineX( tx, offset, line, last=0):
+    setXPos(tx,offset)
+    _putFragLine(offset, tx, line)
+    setXPos(tx,-offset)
+
+def _centerDrawParaLineX( tx, offset, line, last=0):
+    m = offset+0.5*line.extraSpace
+    setXPos(tx,m)
+    _putFragLine(m,tx, line)
+    setXPos(tx,-m)
+
+def _rightDrawParaLineX( tx, offset, line, last=0):
+    m = offset+line.extraSpace
+    setXPos(tx,m)
+    _putFragLine(m,tx, line)
+    setXPos(tx,-m)
+
+def _justifyDrawParaLineX( tx, offset, line, last=0):
+    setXPos(tx,offset)
+    extraSpace = line.extraSpace
+    nSpaces = line.wordCount - 1
+    if last or not nSpaces or abs(extraSpace)<=1e-8 or line.lineBreak:
+        _putFragLine(offset, tx, line)  #no space modification
+    else:
+        tx.setWordSpace(extraSpace / float(nSpaces))
+        _putFragLine(offset, tx, line)
+        tx.setWordSpace(0)
+    setXPos(tx,-offset)
+
+# XXX Modified for XHTML2PDF
+# !!! Important, don't import accelerators !!!
+#try:
+#    from _rl_accel import _sameFrag
+#except ImportError:
+#    try:
+#        from reportlab.lib._rl_accel import _sameFrag
+#    except ImportError:
+def _sameFrag(f,g):
+    'returns 1 if two ParaFrags map out the same'
+    if (hasattr(f,'cbDefn') or hasattr(g,'cbDefn')
+            or hasattr(f,'lineBreak') or hasattr(g,'lineBreak')): return 0
+    for a in ('fontName', 'fontSize', 'textColor', 'backColor', 'rise', 'underline', 'strike', 'link'):
+        if getattr(f,a,None)!=getattr(g,a,None): return 0
+    return 1
+
+def _getFragWords(frags):
+    ''' given a Parafrag list return a list of fragwords
+        [[size, (f00,w00), ..., (f0n,w0n)],....,[size, (fm0,wm0), ..., (f0n,wmn)]]
+        each pair f,w represents a style and some string
+        each sublist represents a word
+    '''
+    R = []
+    W = []
+    n = 0
+    hangingStrip = False
+    for f in frags:
+        text = f.text
+        #del f.text # we can't do this until we sort out splitting
+                    # of paragraphs
+        if text!='':
+            if hangingStrip:
+                hangingStrip = False
+                text = text.lstrip()
+            #if type(text) is str:
+            #    text = text.decode('utf8')
+            S = split(text)
+            if S==[]: S = ['']
+            if W!=[] and text[0] in whitespace:
+                W.insert(0,n)
+                R.append(W)
+                W = []
+                n = 0
+
+            for w in S[:-1]:
+                W.append((f,w))
+                n += stringWidth(w, f.fontName, f.fontSize)
+                W.insert(0,n)
+                R.append(W)
+                W = []
+                n = 0
+
+            w = S[-1]
+            W.append((f,w))
+            n += stringWidth(w, f.fontName, f.fontSize)
+            if text and text[-1] in whitespace:
+                W.insert(0,n)
+                R.append(W)
+                W = []
+                n = 0
+        elif hasattr(f,'cbDefn'):
+            w = getattr(f.cbDefn,'width',0)
+            if w:
+                if W!=[]:
+                    W.insert(0,n)
+                    R.append(W)
+                    W = []
+                    n = 0
+                R.append([w,(f,'')])
+            else:
+                W.append((f,''))
+        elif hasattr(f, 'lineBreak'):
+            #pass the frag through.  The line breaker will scan for it.
+            if W!=[]:
+                W.insert(0,n)
+                R.append(W)
+                W = []
+                n = 0
+            R.append([0,(f,'')])
+            hangingStrip = True
+
+    if W!=[]:
+        W.insert(0,n)
+        R.append(W)
+
+    return R
+
+def _split_blParaSimple(blPara,start,stop):
+    f = blPara.clone()
+    for a in ('lines', 'kind', 'text'):
+        if hasattr(f,a): delattr(f,a)
+
+    f.words = []
+    for l in blPara.lines[start:stop]:
+        for w in l[1]:
+            f.words.append(w)
+    return [f]
+
+def _split_blParaHard(blPara,start,stop):
+    f = []
+    lines = blPara.lines[start:stop]
+    for l in lines:
+        for w in l.words:
+            f.append(w)
+        if l is not lines[-1]:
+            i = len(f)-1
+            while i>=0 and hasattr(f[i],'cbDefn') and not getattr(f[i].cbDefn,'width',0): i -= 1
+            if i>=0:
+                g = f[i]
+                if not g.text: g.text = ' '
+                elif g.text[-1]!=' ': g.text += ' '
+    return f
+
+def _drawBullet(canvas, offset, cur_y, bulletText, style):
+    '''draw a bullet text could be a simple string or a frag list'''
+    tx2 = canvas.beginText(style.bulletIndent, cur_y+getattr(style,"bulletOffsetY",0))
+    tx2.setFont(style.bulletFontName, style.bulletFontSize)
+    tx2.setFillColor(hasattr(style,'bulletColor') and style.bulletColor or style.textColor)
+    if isinstance(bulletText,basestring):
+        tx2.textOut(bulletText)
+    else:
+        for f in bulletText:
+            if hasattr(f, "image"):
+                image = f.image
+                width = image.drawWidth
+                height = image.drawHeight
+                gap = style.bulletFontSize * 0.25
+                img = image.getImage()
+                # print style.bulletIndent, offset, width
+                canvas.drawImage(
+                    img,
+                    style.leftIndent - width - gap,
+                    cur_y+getattr(style,"bulletOffsetY",0),
+                    width,
+                    height)
+            else:
+                tx2.setFont(f.fontName, f.fontSize)
+                tx2.setFillColor(f.textColor)
+                tx2.textOut(f.text)
+
+    canvas.drawText(tx2)
+    #AR making definition lists a bit less ugly
+    #bulletEnd = tx2.getX()
+    bulletEnd = tx2.getX() + style.bulletFontSize * 0.6
+    offset = max(offset,bulletEnd - style.leftIndent)
+    return offset
+
+def _handleBulletWidth(bulletText,style,maxWidths):
+    '''work out bullet width and adjust maxWidths[0] if neccessary
+    '''
+    if bulletText:
+        if isinstance(bulletText,basestring):
+            bulletWidth = stringWidth( bulletText, style.bulletFontName, style.bulletFontSize)
+        else:
+            #it's a list of fragments
+            bulletWidth = 0
+            for f in bulletText:
+                bulletWidth = bulletWidth + stringWidth(f.text, f.fontName, f.fontSize)
+        bulletRight = style.bulletIndent + bulletWidth + 0.6 * style.bulletFontSize
+        indent = style.leftIndent+style.firstLineIndent
+        if bulletRight > indent:
+            #..then it overruns, and we have less space available on line 1
+            maxWidths[0] -= (bulletRight - indent)
+
+def splitLines0(frags,widths):
+    '''
+    given a list of ParaFrags we return a list of ParaLines
+
+    each ParaLine has
+    1)  ExtraSpace
+    2)  blankCount
+    3)  [textDefns....]
+        each text definition is a (ParaFrag, start, limit) triplet
+    '''
+    #initialise the algorithm
+    lines   = []
+    lineNum = 0
+    maxW    = widths[lineNum]
+    i       = -1
+    l       = len(frags)
+    lim     = start = 0
+    while 1:
+        #find a non whitespace character
+        while i<l:
+            while start<lim and text[start]==' ': start += 1
+            if start==lim:
+                i += 1
+                if i==l: break
+                start = 0
+                f = frags[i]
+                text = f.text
+                lim = len(text)
+            else:
+                break   # we found one
+
+        if start==lim: break    #if we didn't find one we are done
+
+        #start of a line
+        g       = (None,None,None)
+        line    = []
+        cLen    = 0
+        nSpaces = 0
+        while cLen<maxW:
+            j = text.find(' ',start)
+            if j<0: j==lim
+            w = stringWidth(text[start:j],f.fontName,f.fontSize)
+            cLen += w
+            if cLen>maxW and line!=[]:
+                cLen = cLen-w
+                #this is the end of the line
+                while g.text[lim]==' ':
+                    lim = lim - 1
+                    nSpaces = nSpaces-1
+                break
+            if j<0: j = lim
+            if g[0] is f: g[2] = j  #extend
+            else:
+                g = (f,start,j)
+                line.append(g)
+            if j==lim:
+                i += 1
+
+def _do_under_line(i, t_off, ws, tx, lm=-0.125):
+    y = tx.XtraState.cur_y - i*tx.XtraState.style.leading + lm*tx.XtraState.f.fontSize
+    textlen = tx._canvas.stringWidth(join(tx.XtraState.lines[i][1]), tx._fontname, tx._fontsize)
+    tx._canvas.line(t_off, y, t_off+textlen+ws, y)
+
+_scheme_re = re.compile('^[a-zA-Z][-+a-zA-Z0-9]+$')
+def _doLink(tx,link,rect):
+    if isinstance(link,unicode):
+        link = link.encode('utf8')
+    parts = link.split(':',1)
+    scheme = len(parts)==2 and parts[0].lower() or ''
+    if _scheme_re.match(scheme) and scheme!='document':
+        kind=scheme.lower()=='pdf' and 'GoToR' or 'URI'
+        if kind=='GoToR': link = parts[1]
+        tx._canvas.linkURL(link, rect, relative=1, kind=kind)
+    else:
+        if link[0]=='#':
+            link = link[1:]
+            scheme=''
+        tx._canvas.linkRect("", scheme!='document' and link or parts[1], rect, relative=1)
+
+def _do_link_line(i, t_off, ws, tx):
+    xs = tx.XtraState
+    leading = xs.style.leading
+    y = xs.cur_y - i*leading - xs.f.fontSize/8.0 # 8.0 factor copied from para.py
+    text = join(xs.lines[i][1])
+    textlen = tx._canvas.stringWidth(text, tx._fontname, tx._fontsize)
+    _doLink(tx, xs.link, (t_off, y, t_off+textlen+ws, y+leading))
+
+# XXX Modified for XHTML2PDF
+def _do_post_text(tx):
+    """
+    Try to find out what the variables mean:
+
+    tx         A structure containing more informations about paragraph ???
+
+    leading    Height of lines
+    ff         1/8 of the font size
+    y0         The "baseline" postion ???
+    y          1/8 below the baseline
+    """
+
+    xs = tx.XtraState
+    leading = xs.style.leading
+    autoLeading = xs.autoLeading
+    f = xs.f
+    if autoLeading=='max':
+        # leading = max(leading, f.fontSize)
+        leading = max(leading, LEADING_FACTOR*f.fontSize)
+    elif autoLeading=='min':
+        leading = LEADING_FACTOR*f.fontSize
+    ff = 0.125*f.fontSize
+    y0 = xs.cur_y
+    y = y0 - ff
+
+    # Background
+    for x1, x2, c, fs in xs.backgrounds:
+        inlineFF = fs * 0.125
+        gap = inlineFF * 1.25
+        tx._canvas.setFillColor(c)
+        tx._canvas.rect(x1, y - gap, x2 - x1, fs + 1, fill=1, stroke=0)
+        # tx._canvas.rect(x1, y, x2 - x1, fs, fill=1, stroke=0)
+    xs.backgrounds = []
+    xs.background = 0
+    xs.backgroundColor = None
+    xs.backgroundFontSize = None
+
+    # Underline
+    yUnderline = y0 - 1.5 * ff
+    tx._canvas.setLineWidth(ff * 0.75)
+    csc = None
+    for x1,x2,c in xs.underlines:
+        if c!=csc:
+            tx._canvas.setStrokeColor(c)
+            csc = c
+        tx._canvas.line(x1, yUnderline, x2, yUnderline)
+    xs.underlines = []
+    xs.underline=0
+    xs.underlineColor=None
+
+    # Strike
+    for x1,x2,c,fs in xs.strikes:
+        inlineFF = fs * 0.125
+        ys = y0 + 2 * inlineFF
+        if c!=csc:
+            tx._canvas.setStrokeColor(c)
+            csc = c
+        tx._canvas.setLineWidth(inlineFF * 0.75)
+        tx._canvas.line(x1, ys, x2, ys)
+    xs.strikes = []
+    xs.strike=0
+    xs.strikeColor=None
+
+    yl = y + leading
+    for x1,x2,link,c in xs.links:
+        # No automatic underlining for links, never!
+        _doLink(tx, link, (x1, y, x2, yl))
+    xs.links = []
+    xs.link=None
+    xs.linkColor=None
+    xs.cur_y -= leading
+
+def textTransformFrags(frags,style):
+    tt = style.textTransform
+    if tt:
+        tt=tt.lower()
+        if tt=='lowercase':
+            tt = unicode.lower
+        elif tt=='uppercase':
+            tt = unicode.upper
+        elif  tt=='capitalize':
+            tt = unicode.title
+        elif tt=='none':
+            return
+        else:
+            raise ValueError('ParaStyle.textTransform value %r is invalid' % style.textTransform)
+        n = len(frags)
+        if n==1:
+            #single fragment the easy case
+            frags[0].text = tt(frags[0].text.decode('utf8')).encode('utf8')
+        elif tt is unicode.title:
+            pb = True
+            for f in frags:
+                t = f.text
+                if not t: continue
+                u = t.decode('utf8')
+                if u.startswith(u' ') or pb:
+                    u = tt(u)
+                else:
+                    i = u.find(u' ')
+                    if i>=0:
+                        u = u[:i]+tt(u[i:])
+                pb = u.endswith(u' ')
+                f.text = u.encode('utf8')
+        else:
+            for f in frags:
+                t = f.text
+                if not t: continue
+                f.text = tt(t.decode('utf8')).encode('utf8')
+
+class cjkU(unicode):
+    '''simple class to hold the frag corresponding to a str'''
+    def __new__(cls,value,frag,encoding):
+        self = unicode.__new__(cls,value)
+        self._frag = frag
+        if hasattr(frag,'cbDefn'):
+            w = getattr(frag.cbDefn,'width',0)
+            self._width = w
+        else:
+            self._width = stringWidth(value,frag.fontName,frag.fontSize)
+        return self
+    frag = property(lambda self: self._frag)
+    width = property(lambda self: self._width)
+
+def makeCJKParaLine(U,extraSpace,calcBounds):
+    words = []
+    CW = []
+    f0 = FragLine()
+    maxSize = maxAscent = minDescent = 0
+    for u in U:
+        f = u.frag
+        fontSize = f.fontSize
+        if calcBounds:
+            cbDefn = getattr(f,'cbDefn',None)
+            if getattr(cbDefn,'width',0):
+                descent, ascent = imgVRange(cbDefn.height,cbDefn.valign,fontSize)
+            else:
+                ascent, descent = getAscentDescent(f.fontName,fontSize)
+        else:
+            ascent, descent = getAscentDescent(f.fontName,fontSize)
+        maxSize = max(maxSize,fontSize)
+        maxAscent = max(maxAscent,ascent)
+        minDescent = min(minDescent,descent)
+        if not _sameFrag(f0,f):
+            f0=f0.clone()
+            f0.text = u''.join(CW)
+            words.append(f0)
+            CW = []
+            f0 = f
+        CW.append(u)
+    if CW:
+        f0=f0.clone()
+        f0.text = u''.join(CW)
+        words.append(f0)
+    return FragLine(kind=1,extraSpace=extraSpace,wordCount=1,words=words[1:],fontSize=maxSize,ascent=maxAscent,descent=minDescent)
+
+def cjkFragSplit(frags, maxWidths, calcBounds, encoding='utf8'):
+    '''This attempts to be wordSplit for frags using the dumb algorithm'''
+    from reportlab.rl_config import _FUZZ
+    U = []  #get a list of single glyphs with their widths etc etc
+    for f in frags:
+        text = f.text
+        if not isinstance(text,unicode):
+            text = text.decode(encoding)
+        if text:
+            U.extend([cjkU(t,f,encoding) for t in text])
+        else:
+            U.append(cjkU(text,f,encoding))
+    lines = []
+    widthUsed = lineStartPos = 0
+    maxWidth = maxWidths[0]
+    for i, u in enumerate(U):
+        w = u.width
+        widthUsed += w
+        lineBreak = hasattr(u.frag,'lineBreak')
+        endLine = (widthUsed>maxWidth + _FUZZ and widthUsed>0) or lineBreak
+        if endLine:
+            if lineBreak: continue
+            extraSpace = maxWidth - widthUsed + w
+            #This is the most important of the Japanese typography rules.
+            #if next character cannot start a line, wrap it up to this line so it hangs
+            #in the right margin. We won't do two or more though - that's unlikely and
+            #would result in growing ugliness.
+            nextChar = U[i]
+            if nextChar in ALL_CANNOT_START:
+                extraSpace -= w
+                i += 1
+            lines.append(makeCJKParaLine(U[lineStartPos:i],extraSpace,calcBounds))
+            try:
+                maxWidth = maxWidths[len(lines)]
+            except IndexError:
+                maxWidth = maxWidths[-1]  # use the last one
+
+            lineStartPos = i
+            widthUsed = w
+            i -= 1
+    #any characters left?
+    if widthUsed > 0:
+        lines.append(makeCJKParaLine(U[lineStartPos:],maxWidth-widthUsed,calcBounds))
+
+    return ParaLines(kind=1,lines=lines)
+
+class Paragraph(Flowable):
+    """ Paragraph(text, style, bulletText=None, caseSensitive=1)
+        text a string of stuff to go into the paragraph.
+        style is a style definition as in reportlab.lib.styles.
+        bulletText is an optional bullet defintion.
+        caseSensitive set this to 0 if you want the markup tags and their attributes to be case-insensitive.
+
+        This class is a flowable that can format a block of text
+        into a paragraph with a given style.
+
+        The paragraph Text can contain XML-like markup including the tags:
+        <b> ... </b> - bold
+        <i> ... </i> - italics
+        <u> ... </u> - underline
+        <strike> ... </strike> - strike through
+        <super> ... </super> - superscript
+        <sub> ... </sub> - subscript
+        <font name=fontfamily/fontname color=colorname size=float>
+        <onDraw name=callable label="a label">
+        <link>link text</link>
+            attributes of links
+                size/fontSize=num
+                name/face/fontName=name
+                fg/textColor/color=color
+                backcolor/backColor/bgcolor=color
+                dest/destination/target/href/link=target
+        <a>anchor text</a>
+            attributes of anchors
+                fontSize=num
+                fontName=name
+                fg/textColor/color=color
+                backcolor/backColor/bgcolor=color
+                href=href
+        <a name="anchorpoint"/>
+        <unichar name="unicode character name"/>
+        <unichar value="unicode code point"/>
+        <img src="path" width="1in" height="1in" valign="bottom"/>
+
+        The whole may be surrounded by <para> </para> tags
+
+        The <b> and <i> tags will work for the built-in fonts (Helvetica
+        /Times / Courier).  For other fonts you need to register a family
+        of 4 fonts using reportlab.pdfbase.pdfmetrics.registerFont; then
+        use the addMapping function to tell the library that these 4 fonts
+        form a family e.g.
+            from reportlab.lib.fonts import addMapping
+            addMapping('Vera', 0, 0, 'Vera')    #normal
+            addMapping('Vera', 0, 1, 'Vera-Italic')    #italic
+            addMapping('Vera', 1, 0, 'Vera-Bold')    #bold
+            addMapping('Vera', 1, 1, 'Vera-BoldItalic')    #italic and bold
+
+        It will also be able to handle any MathML specified Greek characters.
+    """
+    def __init__(self, text, style, bulletText = None, frags=None, caseSensitive=1, encoding='utf8'):
+        self.caseSensitive = caseSensitive
+        self.encoding = encoding
+        self._setup(text, style, bulletText, frags, cleanBlockQuotedText)
+
+    def __repr__(self):
+        n = self.__class__.__name__
+        L = [n+"("]
+        keys = self.__dict__.keys()
+        for k in keys:
+            v = getattr(self, k)
+            rk = repr(k)
+            rv = repr(v)
+            rk = "  "+rk.replace("\n", "\n  ")
+            rv = "    "+rk.replace("\n", "\n    ")
+            L.append(rk)
+            L.append(rv)
+        L.append(") #"+n)
+        return '\n'.join(L)
+
+    def _setup(self, text, style, bulletText, frags, cleaner):
+        if frags is None:
+            text = cleaner(text)
+            _parser.caseSensitive = self.caseSensitive
+            style, frags, bulletTextFrags = _parser.parse(text,style)
+            if frags is None:
+                raise ValueError("xml parser error (%s) in paragraph beginning\n'%s'"\
+                    % (_parser.errors[0],text[:min(30,len(text))]))
+            textTransformFrags(frags,style)
+            if bulletTextFrags: bulletText = bulletTextFrags
+
+        #AR hack
+        self.text = text
+        self.frags = frags
+        self.style = style
+        self.bulletText = bulletText
+        self.debug = PARAGRAPH_DEBUG  #turn this on to see a pretty one with all the margins etc.
+
+    def wrap(self, availWidth, availHeight):
+
+        if self.debug:
+            print id(self), "wrap"
+            try:
+                print repr(self.getPlainText()[:80])
+            except:
+                print "???"
+
+        # work out widths array for breaking
+        self.width = availWidth
+        style = self.style
+        leftIndent = style.leftIndent
+        first_line_width = availWidth - (leftIndent+style.firstLineIndent) - style.rightIndent
+        later_widths = availWidth - leftIndent - style.rightIndent
+
+        if style.wordWrap == 'CJK':
+            #use Asian text wrap algorithm to break characters
+            blPara = self.breakLinesCJK([first_line_width, later_widths])
+        else:
+            blPara = self.breakLines([first_line_width, later_widths])
+        self.blPara = blPara
+        autoLeading = getattr(self,'autoLeading',getattr(style,'autoLeading',''))
+        leading = style.leading
+        if blPara.kind==1 and autoLeading not in ('','off'):
+            height = 0
+            if autoLeading=='max':
+                for l in blPara.lines:
+                    height += max(l.ascent-l.descent,leading)
+            elif autoLeading=='min':
+                for l in blPara.lines:
+                    height += l.ascent - l.descent
+            else:
+                raise ValueError('invalid autoLeading value %r' % autoLeading)
+        else:
+            if autoLeading=='max':
+                leading = max(leading,LEADING_FACTOR*style.fontSize)
+            elif autoLeading=='min':
+                leading = LEADING_FACTOR*style.fontSize
+            height = len(blPara.lines) * leading
+        self.height = height
+        return self.width, height
+
+    def minWidth(self):
+        'Attempt to determine a minimum sensible width'
+        frags = self.frags
+        nFrags= len(frags)
+        if not nFrags: return 0
+        if nFrags==1:
+            f = frags[0]
+            fS = f.fontSize
+            fN = f.fontName
+            words = hasattr(f,'text') and split(f.text, ' ') or f.words
+            func = lambda w, fS=fS, fN=fN: stringWidth(w,fN,fS)
+        else:
+            words = _getFragWords(frags)
+            func  = lambda x: x[0]
+        return max(map(func,words))
+
+    def _get_split_blParaFunc(self):
+        return self.blPara.kind==0 and _split_blParaSimple or _split_blParaHard
+
+    def split(self,availWidth, availHeight):
+
+        if self.debug:
+            print  id(self), "split"
+
+        if len(self.frags)<=0: return []
+
+        #the split information is all inside self.blPara
+        if not hasattr(self,'blPara'):
+            # return []
+            self.wrap(availWidth,availHeight)
+        blPara = self.blPara
+        style = self.style
+        autoLeading = getattr(self,'autoLeading',getattr(style,'autoLeading',''))
+        leading = style.leading
+        lines = blPara.lines
+        if blPara.kind==1 and autoLeading not in ('','off'):
+            s = height = 0
+            if autoLeading=='max':
+                for i,l in enumerate(blPara.lines):
+                    h = max(l.ascent-l.descent,leading)
+                    n = height+h
+                    if n>availHeight+1e-8:
+                        break
+                    height = n
+                    s = i+1
+            elif autoLeading=='min':
+                for i,l in enumerate(blPara.lines):
+                    n = height+l.ascent-l.descent
+                    if n>availHeight+1e-8:
+                        break
+                    height = n
+                    s = i+1
+            else:
+                raise ValueError('invalid autoLeading value %r' % autoLeading)
+        else:
+            l = leading
+            if autoLeading=='max':
+                l = max(leading,LEADING_FACTOR*style.fontSize)
+            elif autoLeading=='min':
+                l = LEADING_FACTOR*style.fontSize
+            s = int(availHeight/l)
+            height = s*l
+
+        n = len(lines)
+        allowWidows = getattr(self,'allowWidows',getattr(self,'allowWidows',1))
+        allowOrphans = getattr(self,'allowOrphans',getattr(self,'allowOrphans',0))
+        if not allowOrphans:
+            if s<=1:    #orphan?
+                del self.blPara
+                return []
+        if n<=s: return [self]
+        if not allowWidows:
+            if n==s+1: #widow?
+                if (allowOrphans and n==3) or n>3:
+                    s -= 1  #give the widow some company
+                else:
+                    del self.blPara #no room for adjustment; force the whole para onwards
+                    return []
+        func = self._get_split_blParaFunc()
+
+        P1=self.__class__(None,style,bulletText=self.bulletText,frags=func(blPara,0,s))
+        #this is a major hack
+        P1.blPara = ParaLines(kind=1,lines=blPara.lines[0:s],aH=availHeight,aW=availWidth)
+        P1._JustifyLast = 1
+        P1._splitpara = 1
+        P1.height = height
+        P1.width = availWidth
+        if style.firstLineIndent != 0:
+            style = deepcopy(style)
+            style.firstLineIndent = 0
+        P2=self.__class__(None,style,bulletText=None,frags=func(blPara,s,n))
+        for a in ('autoLeading',    #possible attributes that might be directly on self.
+                ):
+            if hasattr(self,a):
+                setattr(P1,a,getattr(self,a))
+                setattr(P2,a,getattr(self,a))
+        return [P1,P2]
+
+    def draw(self):
+        #call another method for historical reasons.  Besides, I
+        #suspect I will be playing with alternate drawing routines
+        #so not doing it here makes it easier to switch.
+        self.drawPara(self.debug)
+
+    def breakLines(self, width):
+        """
+        Returns a broken line structure. There are two cases
+
+        A) For the simple case of a single formatting input fragment the output is
+            A fragment specifier with
+                - kind = 0
+                - fontName, fontSize, leading, textColor
+                - lines=  A list of lines
+
+                        Each line has two items.
+
+                        1. unused width in points
+                        2. word list
+
+        B) When there is more than one input formatting fragment the output is
+            A fragment specifier with
+               - kind = 1
+               - lines=  A list of fragments each having fields
+                            - extraspace (needed for justified)
+                            - fontSize
+                            - words=word list
+                                each word is itself a fragment with
+                                various settings
+
+        This structure can be used to easily draw paragraphs with the various alignments.
+        You can supply either a single width or a list of widths; the latter will have its
+        last item repeated until necessary. A 2-element list is useful when there is a
+        different first line indent; a longer list could be created to facilitate custom wraps
+        around irregular objects."""
+
+        if self.debug:
+            print id(self), "breakLines"
+
+        if not isinstance(width,(tuple,list)): maxWidths = [width]
+        else: maxWidths = width
+        lines = []
+        lineno = 0
+        style = self.style
+
+        #for bullets, work out width and ensure we wrap the right amount onto line one
+        _handleBulletWidth(self.bulletText,style,maxWidths)
+
+        maxWidth = maxWidths[0]
+
+        self.height = 0
+        autoLeading = getattr(self,'autoLeading',getattr(style,'autoLeading',''))
+        calcBounds = autoLeading not in ('','off')
+        frags = self.frags
+        nFrags= len(frags)
+        if nFrags==1 and not hasattr(frags[0],'cbDefn'):
+            f = frags[0]
+            fontSize = f.fontSize
+            fontName = f.fontName
+            ascent, descent = getAscentDescent(fontName,fontSize)
+            words = hasattr(f,'text') and split(f.text, ' ') or f.words
+            spaceWidth = stringWidth(' ', fontName, fontSize, self.encoding)
+            cLine = []
+            currentWidth = -spaceWidth   # hack to get around extra space for word 1
+            for word in words:
+                #this underscores my feeling that Unicode throughout would be easier!
+                wordWidth = stringWidth(word, fontName, fontSize, self.encoding)
+                newWidth = currentWidth + spaceWidth + wordWidth
+                if newWidth <= maxWidth or not len(cLine):
+                    # fit one more on this line
+                    cLine.append(word)
+                    currentWidth = newWidth
+                else:
+                    if currentWidth > self.width: self.width = currentWidth
+                    #end of line
+                    lines.append((maxWidth - currentWidth, cLine))
+                    cLine = [word]
+                    currentWidth = wordWidth
+                    lineno += 1
+                    try:
+                        maxWidth = maxWidths[lineno]
+                    except IndexError:
+                        maxWidth = maxWidths[-1]  # use the last one
+
+            #deal with any leftovers on the final line
+            if cLine!=[]:
+                if currentWidth>self.width: self.width = currentWidth
+                lines.append((maxWidth - currentWidth, cLine))
+
+            return f.clone(kind=0, lines=lines,ascent=ascent,descent=descent,fontSize=fontSize)
+        elif nFrags<=0:
+            return ParaLines(kind=0, fontSize=style.fontSize, fontName=style.fontName,
+                            textColor=style.textColor, ascent=style.fontSize,descent=-0.2*style.fontSize,
+                            lines=[])
+        else:
+            if hasattr(self,'blPara') and getattr(self,'_splitpara',0):
+                #NB this is an utter hack that awaits the proper information
+                #preserving splitting algorithm
+                return self.blPara
+            n = 0
+            words = []
+            for w in _getFragWords(frags):
+                f=w[-1][0]
+                fontName = f.fontName
+                fontSize = f.fontSize
+                spaceWidth = stringWidth(' ',fontName, fontSize)
+
+                if not words:
+                    currentWidth = -spaceWidth   # hack to get around extra space for word 1
+                    maxSize = fontSize
+                    maxAscent, minDescent = getAscentDescent(fontName,fontSize)
+
+                wordWidth = w[0]
+                f = w[1][0]
+                if wordWidth>0:
+                    newWidth = currentWidth + spaceWidth + wordWidth
+                else:
+                    newWidth = currentWidth
+
+                #test to see if this frag is a line break. If it is we will only act on it
+                #if the current width is non-negative or the previous thing was a deliberate lineBreak
+                lineBreak = hasattr(f,'lineBreak')
+                endLine = (newWidth>maxWidth and n>0) or lineBreak
+                if not endLine:
+                    if lineBreak: continue      #throw it away
+                    nText = w[1][1]
+                    if nText: n += 1
+                    fontSize = f.fontSize
+                    if calcBounds:
+                        cbDefn = getattr(f,'cbDefn',None)
+                        if getattr(cbDefn,'width',0):
+                            descent,ascent = imgVRange(cbDefn.height,cbDefn.valign,fontSize)
+                        else:
+                            ascent, descent = getAscentDescent(f.fontName,fontSize)
+                    else:
+                        ascent, descent = getAscentDescent(f.fontName,fontSize)
+                    maxSize = max(maxSize,fontSize)
+                    maxAscent = max(maxAscent,ascent)
+                    minDescent = min(minDescent,descent)
+                    if not words:
+                        g = f.clone()
+                        words = [g]
+                        g.text = nText
+                    elif not _sameFrag(g,f):
+                        if currentWidth>0 and ((nText!='' and nText[0]!=' ') or hasattr(f,'cbDefn')):
+                            if hasattr(g,'cbDefn'):
+                                i = len(words)-1
+                                while i>=0:
+                                    wi = words[i]
+                                    cbDefn = getattr(wi,'cbDefn',None)
+                                    if cbDefn:
+                                        if not getattr(cbDefn,'width',0):
+                                            i -= 1
+                                            continue
+                                    if not wi.text.endswith(' '):
+                                        wi.text += ' '
+                                    break
+                            else:
+                                if not g.text.endswith(' '):
+                                    g.text += ' '
+                        g = f.clone()
+                        words.append(g)
+                        g.text = nText
+                    else:
+                        if nText!='' and nText[0]!=' ':
+                            g.text += ' ' + nText
+
+                    for i in w[2:]:
+                        g = i[0].clone()
+                        g.text=i[1]
+                        words.append(g)
+                        fontSize = g.fontSize
+                        if calcBounds:
+                            cbDefn = getattr(g,'cbDefn',None)
+                            if getattr(cbDefn,'width',0):
+                                descent,ascent = imgVRange(cbDefn.height,cbDefn.valign,fontSize)
+                            else:
+                                ascent, descent = getAscentDescent(g.fontName,fontSize)
+                        else:
+                            ascent, descent = getAscentDescent(g.fontName,fontSize)
+                        maxSize = max(maxSize,fontSize)
+                        maxAscent = max(maxAscent,ascent)
+                        minDescent = min(minDescent,descent)
+
+                    currentWidth = newWidth
+                else:  #either it won't fit, or it's a lineBreak tag
+                    if lineBreak:
+                        g = f.clone()
+                        #del g.lineBreak
+                        words.append(g)
+
+                    if currentWidth>self.width: self.width = currentWidth
+                    #end of line
+                    lines.append(FragLine(extraSpace=maxWidth-currentWidth, wordCount=n,
+                                        lineBreak=lineBreak, words=words, fontSize=maxSize, ascent=maxAscent, descent=minDescent))
+
+                    #start new line
+                    lineno += 1
+                    try:
+                        maxWidth = maxWidths[lineno]
+                    except IndexError:
+                        maxWidth = maxWidths[-1]  # use the last one
+
+                    if lineBreak:
+                        n = 0
+                        words = []
+                        continue
+
+                    currentWidth = wordWidth
+                    n = 1
+                    g = f.clone()
+                    maxSize = g.fontSize
+                    if calcBounds:
+                        cbDefn = getattr(g,'cbDefn',None)
+                        if getattr(cbDefn,'width',0):
+                            minDescent,maxAscent = imgVRange(cbDefn.height,cbDefn.valign,maxSize)
+                        else:
+                            maxAscent, minDescent = getAscentDescent(g.fontName,maxSize)
+                    else:
+                        maxAscent, minDescent = getAscentDescent(g.fontName,maxSize)
+                    words = [g]
+                    g.text = w[1][1]
+
+                    for i in w[2:]:
+                        g = i[0].clone()
+                        g.text=i[1]
+                        words.append(g)
+                        fontSize = g.fontSize
+                        if calcBounds:
+                            cbDefn = getattr(g,'cbDefn',None)
+                            if getattr(cbDefn,'width',0):
+                                descent,ascent = imgVRange(cbDefn.height,cbDefn.valign,fontSize)
+                            else:
+                                ascent, descent = getAscentDescent(g.fontName,fontSize)
+                        else:
+                            ascent, descent = getAscentDescent(g.fontName,fontSize)
+                        maxSize = max(maxSize,fontSize)
+                        maxAscent = max(maxAscent,ascent)
+                        minDescent = min(minDescent,descent)
+
+            #deal with any leftovers on the final line
+            if words!=[]:
+                if currentWidth>self.width: self.width = currentWidth
+                lines.append(ParaLines(extraSpace=(maxWidth - currentWidth),wordCount=n,
+                                    words=words, fontSize=maxSize,ascent=maxAscent,descent=minDescent))
+            return ParaLines(kind=1, lines=lines)
+
+        return lines
+
+    def breakLinesCJK(self, width):
+        """Initially, the dumbest possible wrapping algorithm.
+        Cannot handle font variations."""
+
+        if self.debug:
+            print id(self), "breakLinesCJK"
+
+        if not isinstance(width,(list,tuple)): maxWidths = [width]
+        else: maxWidths = width
+        style = self.style
+
+        #for bullets, work out width and ensure we wrap the right amount onto line one
+        _handleBulletWidth(self.bulletText, style, maxWidths)
+        if len(self.frags)>1:
+            autoLeading = getattr(self,'autoLeading',getattr(style,'autoLeading',''))
+            calcBounds = autoLeading not in ('','off')
+            return cjkFragSplit(self.frags, maxWidths, calcBounds)
+            #raise ValueError('CJK Wordwrap can only handle one fragment per paragraph for now. Tried to handle:\ntext:  %s\nfrags: %s' % (self.text, self.frags))
+        elif not len(self.frags):
+            return ParaLines(kind=0, fontSize=style.fontSize, fontName=style.fontName,
+                            textColor=style.textColor, lines=[],ascent=style.fontSize,descent=-0.2*style.fontSize)
+        f = self.frags[0]
+        if 1 and hasattr(self,'blPara') and getattr(self,'_splitpara',0):
+            #NB this is an utter hack that awaits the proper information
+            #preserving splitting algorithm
+            return f.clone(kind=0, lines=self.blPara.lines)
+        lines = []
+        lineno = 0
+
+        self.height = 0
+
+        f = self.frags[0]
+
+        if hasattr(f,'text'):
+            text = f.text
+        else:
+            text = ''.join(getattr(f,'words',[]))
+
+        from reportlab.lib.textsplit import wordSplit
+        lines = wordSplit(text, maxWidths[0], f.fontName, f.fontSize)
+        #the paragraph drawing routine assumes multiple frags per line, so we need an
+        #extra list like this
+        #  [space, [text]]
+        #
+        wrappedLines = [(sp, [line]) for (sp, line) in lines]
+        return f.clone(kind=0, lines=wrappedLines, ascent=f.fontSize, descent=-0.2*f.fontSize)
+
+    def beginText(self, x, y):
+        return self.canv.beginText(x, y)
+
+    def drawPara(self,debug=0):
+        """Draws a paragraph according to the given style.
+        Returns the final y position at the bottom. Not safe for
+        paragraphs without spaces e.g. Japanese; wrapping
+        algorithm will go infinite."""
+
+        if self.debug:
+            print id(self), "drawPara", self.blPara.kind
+
+        #stash the key facts locally for speed
+        canvas = self.canv
+        style = self.style
+        blPara = self.blPara
+        lines = blPara.lines
+        leading = style.leading
+        autoLeading = getattr(self,'autoLeading',getattr(style,'autoLeading',''))
+
+        #work out the origin for line 1
+        leftIndent = style.leftIndent
+        cur_x = leftIndent
+
+        if debug:
+            bw = 0.5
+            bc = Color(1,1,0)
+            bg = Color(0.9,0.9,0.9)
+        else:
+            bw = getattr(style,'borderWidth',None)
+            bc = getattr(style,'borderColor',None)
+            bg = style.backColor
+
+        #if has a background or border, draw it
+        if bg or (bc and bw):
+            canvas.saveState()
+            op = canvas.rect
+            kwds = dict(fill=0,stroke=0)
+            if bc and bw:
+                canvas.setStrokeColor(bc)
+                canvas.setLineWidth(bw)
+                kwds['stroke'] = 1
+                br = getattr(style,'borderRadius',0)
+                if br and not debug:
+                    op = canvas.roundRect
+                    kwds['radius'] = br
+            if bg:
+                canvas.setFillColor(bg)
+                kwds['fill'] = 1
+            bp = getattr(style,'borderPadding',0)
+            op(leftIndent-bp,
+                        -bp,
+                        self.width - (leftIndent+style.rightIndent)+2*bp,
+                        self.height+2*bp,
+                        **kwds)
+            canvas.restoreState()
+
+        nLines = len(lines)
+        bulletText = self.bulletText
+        if nLines > 0:
+            _offsets = getattr(self,'_offsets',[0])
+            _offsets += (nLines-len(_offsets))*[_offsets[-1]]
+            canvas.saveState()
+            #canvas.addLiteral('%% %s.drawPara' % _className(self))
+            alignment = style.alignment
+            offset = style.firstLineIndent+_offsets[0]
+            lim = nLines-1
+            noJustifyLast = not (hasattr(self,'_JustifyLast') and self._JustifyLast)
+
+            if blPara.kind==0:
+                if alignment == TA_LEFT:
+                    dpl = _leftDrawParaLine
+                elif alignment == TA_CENTER:
+                    dpl = _centerDrawParaLine
+                elif self.style.alignment == TA_RIGHT:
+                    dpl = _rightDrawParaLine
+                elif self.style.alignment == TA_JUSTIFY:
+                    dpl = _justifyDrawParaLine
+                f = blPara
+                cur_y = self.height - getattr(f,'ascent',f.fontSize)    #TODO fix XPreformatted to remove this hack
+                if bulletText:
+                    offset = _drawBullet(canvas,offset,cur_y,bulletText,style)
+
+                #set up the font etc.
+                canvas.setFillColor(f.textColor)
+
+                tx = self.beginText(cur_x, cur_y)
+                if autoLeading=='max':
+                    leading = max(leading,LEADING_FACTOR*f.fontSize)
+                elif autoLeading=='min':
+                    leading = LEADING_FACTOR*f.fontSize
+
+                #now the font for the rest of the paragraph
+                tx.setFont(f.fontName, f.fontSize, leading)
+                ws = lines[0][0]
+                t_off = dpl( tx, offset, ws, lines[0][1], noJustifyLast and nLines==1)
+                if f.underline or f.link or f.strike:
+                    xs = tx.XtraState = ABag()
+                    xs.cur_y = cur_y
+                    xs.f = f
+                    xs.style = style
+                    xs.lines = lines
+                    xs.underlines = []
+                    xs.underlineColor = None
+                    # XXX Modified for XHTML2PDF
+                    xs.backgrounds = []
+                    xs.backgroundColor = None
+                    xs.backgroundFontSize = None
+                    xs.strikes = []
+                    xs.strikeColor = None
+                    # XXX Modified for XHTML2PDF
+                    xs.strikeFontSize = None
+                    xs.links = []
+                    xs.link = f.link
+                    canvas.setStrokeColor(f.textColor)
+                    dx = t_off + leftIndent
+                    if dpl != _justifyDrawParaLine: ws = 0
+                    # XXX Never underline!
+                    underline = f.underline
+                    strike = f.strike
+                    link = f.link
+                    if underline: _do_under_line(0, dx, ws, tx)
+                    if strike: _do_under_line(0, dx, ws, tx, lm=0.125)
+                    if link: _do_link_line(0, dx, ws, tx)
+
+                    #now the middle of the paragraph, aligned with the left margin which is our origin.
+                    for i in xrange(1, nLines):
+                        ws = lines[i][0]
+                        t_off = dpl( tx, _offsets[i], ws, lines[i][1], noJustifyLast and i==lim)
+                        if dpl!=_justifyDrawParaLine: ws = 0
+                        if underline: _do_under_line(i, t_off+leftIndent, ws, tx)
+                        if strike: _do_under_line(i, t_off+leftIndent, ws, tx, lm=0.125)
+                        if link: _do_link_line(i, t_off+leftIndent, ws, tx)
+                else:
+                    for i in xrange(1, nLines):
+                        dpl( tx, _offsets[i], lines[i][0], lines[i][1], noJustifyLast and i==lim)
+            else:
+                f = lines[0]
+                cur_y = self.height - getattr(f,'ascent',f.fontSize)    #TODO fix XPreformatted to remove this hack
+                # default?
+                dpl = _leftDrawParaLineX
+                if bulletText:
+                    oo = offset
+                    offset = _drawBullet(canvas,offset,cur_y,bulletText,style)
+                if alignment == TA_LEFT:
+                    dpl = _leftDrawParaLineX
+                elif alignment == TA_CENTER:
+                    dpl = _centerDrawParaLineX
+                elif self.style.alignment == TA_RIGHT:
+                    dpl = _rightDrawParaLineX
+                elif self.style.alignment == TA_JUSTIFY:
+                    dpl = _justifyDrawParaLineX
+                else:
+                    raise ValueError("bad align %s" % repr(alignment))
+
+                #set up the font etc.
+                tx = self.beginText(cur_x, cur_y)
+                xs = tx.XtraState = ABag()
+                xs.textColor = None
+                # XXX Modified for XHTML2PDF
+                xs.backColor = None
+                xs.rise = 0
+                xs.underline = 0
+                xs.underlines = []
+                xs.underlineColor = None
+                # XXX Modified for XHTML2PDF
+                xs.background = 0
+                xs.backgrounds = []
+                xs.backgroundColor = None
+                xs.backgroundFontSize = None
+                xs.strike = 0
+                xs.strikes = []
+                xs.strikeColor = None
+                # XXX Modified for XHTML2PDF
+                xs.strikeFontSize = None
+                xs.links = []
+                xs.link = None
+                xs.leading = style.leading
+                xs.leftIndent = leftIndent
+                tx._leading = None
+                tx._olb = None
+                xs.cur_y = cur_y
+                xs.f = f
+                xs.style = style
+                xs.autoLeading = autoLeading
+
+                tx._fontname,tx._fontsize = None, None
+                dpl( tx, offset, lines[0], noJustifyLast and nLines==1)
+                _do_post_text(tx)
+
+                #now the middle of the paragraph, aligned with the left margin which is our origin.
+                for i in xrange(1, nLines):
+                    f = lines[i]
+                    dpl( tx, _offsets[i], f, noJustifyLast and i==lim)
+                    _do_post_text(tx)
+
+            canvas.drawText(tx)
+            canvas.restoreState()
+
+    def getPlainText(self,identify=None):
+        """Convenience function for templates which want access
+        to the raw text, without XML tags. """
+        frags = getattr(self,'frags',None)
+        if frags:
+            plains = []
+            for frag in frags:
+                if hasattr(frag, 'text'):
+                    plains.append(frag.text)
+            return join(plains, '')
+        elif identify:
+            text = getattr(self,'text',None)
+            if text is None: text = repr(self)
+            return text
+        else:
+            return ''
+
+    def getActualLineWidths0(self):
+        """Convenience function; tells you how wide each line
+        actually is.  For justified styles, this will be
+        the same as the wrap width; for others it might be
+        useful for seeing if paragraphs will fit in spaces."""
+        assert hasattr(self, 'width'), "Cannot call this method before wrap()"
+        if self.blPara.kind:
+            func = lambda frag, w=self.width: w - frag.extraSpace
+        else:
+            func = lambda frag, w=self.width: w - frag[0]
+        return map(func,self.blPara.lines)
+
+if __name__=='__main__':    #NORUNTESTS
+    def dumpParagraphLines(P):
+        print 'dumpParagraphLines(<Paragraph @ %d>)' % id(P)
+        lines = P.blPara.lines
+        for l,line in enumerate(lines):
+            line = lines[l]
+            if hasattr(line,'words'):
+                words = line.words
+            else:
+                words = line[1]
+            nwords = len(words)
+            print 'line%d: %d(%s)\n  ' % (l,nwords,str(getattr(line,'wordCount','Unknown'))),
+            for w in xrange(nwords):
+                print "%d:'%s'"%(w,getattr(words[w],'text',words[w])),
+            print
+
+    def fragDump(w):
+        R= ["'%s'" % w[1]]
+        for a in ('fontName', 'fontSize', 'textColor', 'rise', 'underline', 'strike', 'link', 'cbDefn','lineBreak'):
+            if hasattr(w[0],a):
+                R.append('%s=%r' % (a,getattr(w[0],a)))
+        return ', '.join(R)
+
+    def dumpParagraphFrags(P):
+        print 'dumpParagraphFrags(<Paragraph @ %d>) minWidth() = %.2f' % (id(P), P.minWidth())
+        frags = P.frags
+        n =len(frags)
+        for l in xrange(n):
+            print "frag%d: '%s' %s" % (l, frags[l].text,' '.join(['%s=%s' % (k,getattr(frags[l],k)) for k in frags[l].__dict__ if k!=text]))
+
+        l = 0
+        cum = 0
+        for W in _getFragWords(frags):
+            cum += W[0]
+            print "fragword%d: cum=%3d size=%d" % (l, cum, W[0]),
+            for w in W[1:]:
+                print '(%s)' % fragDump(w),
+            print
+            l += 1
+
+
+    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+    from reportlab.lib.units import cm
+    import sys
+    TESTS = sys.argv[1:]
+    if TESTS==[]: TESTS=['4']
+    def flagged(i,TESTS=TESTS):
+        return 'all' in TESTS or '*' in TESTS or str(i) in TESTS
+
+    styleSheet = getSampleStyleSheet()
+    B = styleSheet['BodyText']
+    style = ParagraphStyle("discussiontext", parent=B)
+    style.fontName= 'Helvetica'
+    if flagged(1):
+        text='''The <font name=courier color=green>CMYK</font> or subtractive method follows the way a printer
+mixes three pigments (cyan, magenta, and yellow) to form colors.
+Because mixing chemicals is more difficult than combining light there
+is a fourth parameter for darkness.  For example a chemical
+combination of the <font name=courier color=green>CMY</font> pigments generally never makes a perfect
+black -- instead producing a muddy color -- so, to get black printers
+don't use the <font name=courier color=green>CMY</font> pigments but use a direct black ink.  Because
+<font name=courier color=green>CMYK</font> maps more directly to the way printer hardware works it may
+be the case that &amp;| &amp; | colors specified in <font name=courier color=green>CMYK</font> will provide better fidelity
+and better control when printed.
+'''
+        P=Paragraph(text,style)
+        dumpParagraphFrags(P)
+        aW, aH = 456.0, 42.8
+        w,h = P.wrap(aW, aH)
+        dumpParagraphLines(P)
+        S = P.split(aW,aH)
+        for s in S:
+            s.wrap(aW,aH)
+            dumpParagraphLines(s)
+            aH = 500
+
+    if flagged(2):
+        P=Paragraph("""Price<super><font color="red">*</font></super>""", styleSheet['Normal'])
+        dumpParagraphFrags(P)
+        w,h = P.wrap(24, 200)
+        dumpParagraphLines(P)
+
+    if flagged(3):
+        text = """Dieses Kapitel bietet eine schnelle <b><font color=red>Programme :: starten</font></b>
+<onDraw name=myIndex label="Programme :: starten">
+<b><font color=red>Eingabeaufforderung :: (&gt;&gt;&gt;)</font></b>
+<onDraw name=myIndex label="Eingabeaufforderung :: (&gt;&gt;&gt;)">
+<b><font color=red>&gt;&gt;&gt; (Eingabeaufforderung)</font></b>
+<onDraw name=myIndex label="&gt;&gt;&gt; (Eingabeaufforderung)">
+Einf&#xfc;hrung in Python <b><font color=red>Python :: Einf&#xfc;hrung</font></b>
+<onDraw name=myIndex label="Python :: Einf&#xfc;hrung">.
+Das Ziel ist, die grundlegenden Eigenschaften von Python darzustellen, ohne
+sich zu sehr in speziellen Regeln oder Details zu verstricken. Dazu behandelt
+dieses Kapitel kurz die wesentlichen Konzepte wie Variablen, Ausdr&#xfc;cke,
+Kontrollfluss, Funktionen sowie Ein- und Ausgabe. Es erhebt nicht den Anspruch,
+umfassend zu sein."""
+        P=Paragraph(text, styleSheet['Code'])
+        dumpParagraphFrags(P)
+        w,h = P.wrap(6*72, 9.7*72)
+        dumpParagraphLines(P)
+
+    if flagged(4):
+        text='''Die eingebaute Funktion <font name=Courier>range(i, j [, stride])</font><onDraw name=myIndex label="eingebaute Funktionen::range()"><onDraw name=myIndex label="range() (Funktion)"><onDraw name=myIndex label="Funktionen::range()"> erzeugt eine Liste von Ganzzahlen und f&#xfc;llt sie mit Werten <font name=Courier>k</font>, f&#xfc;r die gilt: <font name=Courier>i &lt;= k &lt; j</font>. Man kann auch eine optionale Schrittweite angeben. Die eingebaute Funktion <font name=Courier>xrange()</font><onDraw name=myIndex label="eingebaute Funktionen::xrange()"><onDraw name=myIndex label="xrange() (Funktion)"><onDraw name=myIndex label="Funktionen::xrange()"> erf&#xfc;llt einen &#xe4;hnlichen Zweck, gibt aber eine unver&#xe4;nderliche Sequenz vom Typ <font name=Courier>XRangeType</font><onDraw name=myIndex label="XRangeType"> zur&#xfc;ck. Anstatt alle Werte in der Liste abzuspeichern, berechnet diese Liste ihre Werte, wann immer sie angefordert werden. Das ist sehr viel speicherschonender, wenn mit sehr langen Listen von Ganzzahlen gearbeitet wird. <font name=Courier>XRangeType</font> kennt eine einzige Methode, <font name=Courier>s.tolist()</font><onDraw name=myIndex label="XRangeType::tolist() (Methode)"><onDraw name=myIndex label="s.tolist() (Methode)"><onDraw name=myIndex label="Methoden::s.tolist()">, die seine Werte in eine Liste umwandelt.'''
+        aW = 420
+        aH = 64.4
+        P=Paragraph(text, B)
+        dumpParagraphFrags(P)
+        w,h = P.wrap(aW,aH)
+        print 'After initial wrap',w,h
+        dumpParagraphLines(P)
+        S = P.split(aW,aH)
+        dumpParagraphFrags(S[0])
+        w0,h0 = S[0].wrap(aW,aH)
+        print 'After split wrap',w0,h0
+        dumpParagraphLines(S[0])
+
+    if flagged(5):
+        text = '<para> %s <![CDATA[</font></b>& %s < >]]></para>' % (chr(163),chr(163))
+        P=Paragraph(text, styleSheet['Code'])
+        dumpParagraphFrags(P)
+        w,h = P.wrap(6*72, 9.7*72)
+        dumpParagraphLines(P)
+
+    if flagged(6):
+        for text in ['''Here comes <FONT FACE="Helvetica" SIZE="14pt">Helvetica 14</FONT> with <STRONG>strong</STRONG> <EM>emphasis</EM>.''',
+                     '''Here comes <font face="Helvetica" size="14pt">Helvetica 14</font> with <Strong>strong</Strong> <em>emphasis</em>.''',
+                     '''Here comes <font face="Courier" size="3cm">Courier 3cm</font> and normal again.''',
+                     ]:
+            P=Paragraph(text, styleSheet['Normal'], caseSensitive=0)
+            dumpParagraphFrags(P)
+            w,h = P.wrap(6*72, 9.7*72)
+            dumpParagraphLines(P)
+
+    if flagged(7):
+        text = """<para align="CENTER" fontSize="24" leading="30"><b>Generated by:</b>Dilbert</para>"""
+        P=Paragraph(text, styleSheet['Code'])
+        dumpParagraphFrags(P)
+        w,h = P.wrap(6*72, 9.7*72)
+        dumpParagraphLines(P)
+
+    if flagged(8):
+        text ="""- bullet 0<br/>- bullet 1<br/>- bullet 2<br/>- bullet 3<br/>- bullet 4<br/>- bullet 5"""
+        P=Paragraph(text, styleSheet['Normal'])
+        dumpParagraphFrags(P)
+        w,h = P.wrap(6*72, 9.7*72)
+        dumpParagraphLines(P)
+        S = P.split(6*72,h/2.0)
+        print len(S)
+        dumpParagraphLines(S[0])
+        dumpParagraphLines(S[1])
+
+
+    if flagged(9):
+        text="""Furthermore, the fundamental error of
+regarding <img src="../docs/images/testimg.gif" width="3" height="7"/> functional notions as
+categorial delimits a general
+convention regarding the forms of the<br/>
+grammar. I suggested that these results
+would follow from the assumption that"""
+        P=Paragraph(text,ParagraphStyle('aaa',parent=styleSheet['Normal'],align=TA_JUSTIFY))
+        dumpParagraphFrags(P)
+        w,h = P.wrap(6*cm-12, 9.7*72)
+        dumpParagraphLines(P)
+
+    if flagged(10):
+        text="""a b c\xc2\xa0d e f"""
+        P=Paragraph(text,ParagraphStyle('aaa',parent=styleSheet['Normal'],align=TA_JUSTIFY))
+        dumpParagraphFrags(P)
+        w,h = P.wrap(6*cm-12, 9.7*72)
+        dumpParagraphLines(P)
+
+# Copyright (c) 2001-2010 Twisted Matrix Laboratories.
+# See LICENSE for details.
+
+"""
+Tests for L{twisted.words.protocols.jabber.xmlstream}.
+"""
+
+from twisted.trial import unittest
+
+from zope.interface.verify import verifyObject
+
+from twisted.internet import defer, task
+from twisted.internet.error import ConnectionLost
+from twisted.internet.interfaces import IProtocolFactory
+from twisted.test import proto_helpers
+from twisted.words.test.test_xmlstream import GenericXmlStreamFactoryTestsMixin
+from twisted.words.xish import domish
+from twisted.words.protocols.jabber import error, ijabber, jid, xmlstream
+
+
+
+NS_XMPP_TLS = 'urn:ietf:params:xml:ns:xmpp-tls'
+
+
+
+class HashPasswordTest(unittest.TestCase):
+    """
+    Tests for L{xmlstream.hashPassword}.
+    """
+
+    def test_basic(self):
+        """
+        The sid and secret are concatenated to calculate sha1 hex digest.
+        """
+        hash = xmlstream.hashPassword(u"12345", u"secret")
+        self.assertEqual('99567ee91b2c7cabf607f10cb9f4a3634fa820e0', hash)
+
+
+    def test_sidNotUnicode(self):
+        """
+        The session identifier must be a unicode object.
+        """
+        self.assertRaises(TypeError, xmlstream.hashPassword, "\xc2\xb92345",
+                                                             u"secret")
+
+
+    def test_passwordNotUnicode(self):
+        """
+        The password must be a unicode object.
+        """
+        self.assertRaises(TypeError, xmlstream.hashPassword, u"12345",
+                                                             "secr\xc3\xa9t")
+
+
+    def test_unicodeSecret(self):
+        """
+        The concatenated sid and password must be encoded to UTF-8 before hashing.
+        """
+        hash = xmlstream.hashPassword(u"12345", u"secr\u00e9t")
+        self.assertEqual('659bf88d8f8e179081f7f3b4a8e7d224652d2853', hash)
+
+
+
+class IQTest(unittest.TestCase):
+    """
+    Tests both IQ and the associated IIQResponseTracker callback.
+    """
+
+    def setUp(self):
+        authenticator = xmlstream.ConnectAuthenticator('otherhost')
+        authenticator.namespace = 'testns'
+        self.xmlstream = xmlstream.XmlStream(authenticator)
+        self.clock = task.Clock()
+        self.xmlstream._callLater = self.clock.callLater
+        self.xmlstream.makeConnection(proto_helpers.StringTransport())
+        self.xmlstream.dataReceived(
+           "<stream:stream xmlns:stream='http://etherx.jabber.org/streams' "
+                          "xmlns='testns' from='otherhost' version='1.0'>")
+        self.iq = xmlstream.IQ(self.xmlstream, 'get')
+
+
+    def testBasic(self):
+        self.assertEquals(self.iq['type'], 'get')
+        self.assertTrue(self.iq['id'])
+
+
+    def testSend(self):
+        self.xmlstream.transport.clear()
+        self.iq.send()
+        self.assertEquals("<iq type='get' id='%s'/>" % self.iq['id'],
+                          self.xmlstream.transport.value())
+
+
+    def testResultResponse(self):
+        def cb(result):
+            self.assertEquals(result['type'], 'result')
+
+        d = self.iq.send()
+        d.addCallback(cb)
+
+        xs = self.xmlstream
+        xs.dataReceived("<iq type='result' id='%s'/>" % self.iq['id'])
+        return d
+
+
+    def testErrorResponse(self):
+        d = self.iq.send()
+        self.assertFailure(d, error.StanzaError)
+
+        xs = self.xmlstream
+        xs.dataReceived("<iq type='error' id='%s'/>" % self.iq['id'])
+        return d
+
+
+    def testNonTrackedResponse(self):
+        """
+        Test that untracked iq responses don't trigger any action.
+
+        Untracked means that the id of the incoming response iq is not
+        in the stream's C{iqDeferreds} dictionary.
+        """
+        xs = self.xmlstream
+        xmlstream.upgradeWithIQResponseTracker(xs)
+
+        # Make sure we aren't tracking any iq's.
+        self.assertFalse(xs.iqDeferreds)
+
+        # Set up a fallback handler that checks the stanza's handled attribute.
+        # If that is set to True, the iq tracker claims to have handled the
+        # response.
+        def cb(iq):
+            self.assertFalse(getattr(iq, 'handled', False))
+
+        xs.addObserver("/iq", cb, -1)
+
+        # Receive an untracked iq response
+        xs.dataReceived("<iq type='result' id='test'/>")
+
+
+    def testCleanup(self):
+        """
+        Test if the deferred associated with an iq request is removed
+        from the list kept in the L{XmlStream} object after it has
+        been fired.
+        """
+
+        d = self.iq.send()
+        xs = self.xmlstream
+        xs.dataReceived("<iq type='result' id='%s'/>" % self.iq['id'])
+        self.assertNotIn(self.iq['id'], xs.iqDeferreds)
+        return d
+
+
+    def testDisconnectCleanup(self):
+        """
+        Test if deferreds for iq's that haven't yet received a response
+        have their errback called on stream disconnect.
+        """
+
+        d = self.iq.send()
+        xs = self.xmlstream
+        xs.connectionLost("Closed by peer")
+        self.assertFailure(d, ConnectionLost)
+        return d
+
+
+    def testNoModifyingDict(self):
+        """
+        Test to make sure the errbacks cannot cause the iteration of the
+        iqDeferreds to blow up in our face.
+        """
+
+        def eb(failure):
+            d = xmlstream.IQ(self.xmlstream).send()
+            d.addErrback(eb)
+
+        d = self.iq.send()
+        d.addErrback(eb)
+        self.xmlstream.connectionLost("Closed by peer")
+        return d
+
+
+    def testRequestTimingOut(self):
+        """
+        Test that an iq request with a defined timeout times out.
+        """
+        self.iq.timeout = 60
+        d = self.iq.send()
+        self.assertFailure(d, xmlstream.TimeoutError)
+
+        self.clock.pump([1, 60])
+        self.assertFalse(self.clock.calls)
+        self.assertFalse(self.xmlstream.iqDeferreds)
+        return d
+
+
+    def testRequestNotTimingOut(self):
+        """
+        Test that an iq request with a defined timeout does not time out
+        when a response was received before the timeout period elapsed.
+        """
+        self.iq.timeout = 60
+        d = self.iq.send()
+        self.clock.callLater(1, self.xmlstream.dataReceived,
+                             "<iq type='result' id='%s'/>" % self.iq['id'])
+        self.clock.pump([1, 1])
+        self.assertFalse(self.clock.calls)
+        return d
+
+
+    def testDisconnectTimeoutCancellation(self):
+        """
+        Test if timeouts for iq's that haven't yet received a response
+        are cancelled on stream disconnect.
+        """
+
+        self.iq.timeout = 60
+        d = self.iq.send()
+
+        xs = self.xmlstream
+        xs.connectionLost("Closed by peer")
+        self.assertFailure(d, ConnectionLost)
+        self.assertFalse(self.clock.calls)
+        return d
+
+
+
+class XmlStreamTest(unittest.TestCase):
+
+    def onStreamStart(self, obj):
+        self.gotStreamStart = True
+
+
+    def onStreamEnd(self, obj):
+        self.gotStreamEnd = True
+
+
+    def onStreamError(self, obj):
+        self.gotStreamError = True
+
+
+    def setUp(self):
+        """
+        Set up XmlStream and several observers.
+        """
+        self.gotStreamStart = False
+        self.gotStreamEnd = False
+        self.gotStreamError = False
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        xs.addObserver('//event/stream/start', self.onStreamStart)
+        xs.addObserver('//event/stream/end', self.onStreamEnd)
+        xs.addObserver('//event/stream/error', self.onStreamError)
+        xs.makeConnection(proto_helpers.StringTransportWithDisconnection())
+        xs.transport.protocol = xs
+        xs.namespace = 'testns'
+        xs.version = (1, 0)
+        self.xmlstream = xs
+
+
+    def test_sendHeaderBasic(self):
+        """
+        Basic test on the header sent by sendHeader.
+        """
+        xs = self.xmlstream
+        xs.sendHeader()
+        splitHeader = self.xmlstream.transport.value()[0:-1].split(' ')
+        self.assertIn("<stream:stream", splitHeader)
+        self.assertIn("xmlns:stream='http://etherx.jabber.org/streams'",
+                      splitHeader)
+        self.assertIn("xmlns='testns'", splitHeader)
+        self.assertIn("version='1.0'", splitHeader)
+        self.assertTrue(xs._headerSent)
+
+
+    def test_sendHeaderAdditionalNamespaces(self):
+        """
+        Test for additional namespace declarations.
+        """
+        xs = self.xmlstream
+        xs.prefixes['jabber:server:dialback'] = 'db'
+        xs.sendHeader()
+        splitHeader = self.xmlstream.transport.value()[0:-1].split(' ')
+        self.assertIn("<stream:stream", splitHeader)
+        self.assertIn("xmlns:stream='http://etherx.jabber.org/streams'",
+                      splitHeader)
+        self.assertIn("xmlns:db='jabber:server:dialback'", splitHeader)
+        self.assertIn("xmlns='testns'", splitHeader)
+        self.assertIn("version='1.0'", splitHeader)
+        self.assertTrue(xs._headerSent)
+
+
+    def test_sendHeaderInitiating(self):
+        """
+        Test addressing when initiating a stream.
+        """
+        xs = self.xmlstream
+        xs.thisEntity = jid.JID('thisHost')
+        xs.otherEntity = jid.JID('otherHost')
+        xs.initiating = True
+        xs.sendHeader()
+        splitHeader = xs.transport.value()[0:-1].split(' ')
+        self.assertIn("to='otherhost'", splitHeader)
+        self.assertIn("from='thishost'", splitHeader)
+
+
+    def test_sendHeaderReceiving(self):
+        """
+        Test addressing when receiving a stream.
+        """
+        xs = self.xmlstream
+        xs.thisEntity = jid.JID('thisHost')
+        xs.otherEntity = jid.JID('otherHost')
+        xs.initiating = False
+        xs.sid = 'session01'
+        xs.sendHeader()
+        splitHeader = xs.transport.value()[0:-1].split(' ')
+        self.assertIn("to='otherhost'", splitHeader)
+        self.assertIn("from='thishost'", splitHeader)
+        self.assertIn("id='session01'", splitHeader)
+
+
+    def test_receiveStreamError(self):
+        """
+        Test events when a stream error is received.
+        """
+        xs = self.xmlstream
+        xs.dataReceived("<stream:stream xmlns='jabber:client' "
+                        "xmlns:stream='http://etherx.jabber.org/streams' "
+                        "from='example.com' id='12345' version='1.0'>")
+        xs.dataReceived("<stream:error/>")
+        self.assertTrue(self.gotStreamError)
+        self.assertTrue(self.gotStreamEnd)
+
+
+    def test_sendStreamErrorInitiating(self):
+        """
+        Test sendStreamError on an initiating xmlstream with a header sent.
+
+        An error should be sent out and the connection lost.
+        """
+        xs = self.xmlstream
+        xs.initiating = True
+        xs.sendHeader()
+        xs.transport.clear()
+        xs.sendStreamError(error.StreamError('version-unsupported'))
+        self.assertNotEqual('', xs.transport.value())
+        self.assertTrue(self.gotStreamEnd)
+
+
+    def test_sendStreamErrorInitiatingNoHeader(self):
+        """
+        Test sendStreamError on an initiating xmlstream without having sent a
+        header.
+
+        In this case, no header should be generated. Also, the error should
+        not be sent out on the stream. Just closing the connection.
+        """
+        xs = self.xmlstream
+        xs.initiating = True
+        xs.transport.clear()
+        xs.sendStreamError(error.StreamError('version-unsupported'))
+        self.assertNot(xs._headerSent)
+        self.assertEqual('', xs.transport.value())
+        self.assertTrue(self.gotStreamEnd)
+
+
+    def test_sendStreamErrorReceiving(self):
+        """
+        Test sendStreamError on a receiving xmlstream with a header sent.
+
+        An error should be sent out and the connection lost.
+        """
+        xs = self.xmlstream
+        xs.initiating = False
+        xs.sendHeader()
+        xs.transport.clear()
+        xs.sendStreamError(error.StreamError('version-unsupported'))
+        self.assertNotEqual('', xs.transport.value())
+        self.assertTrue(self.gotStreamEnd)
+
+
+    def test_sendStreamErrorReceivingNoHeader(self):
+        """
+        Test sendStreamError on a receiving xmlstream without having sent a
+        header.
+
+        In this case, a header should be generated. Then, the error should
+        be sent out on the stream followed by closing the connection.
+        """
+        xs = self.xmlstream
+        xs.initiating = False
+        xs.transport.clear()
+        xs.sendStreamError(error.StreamError('version-unsupported'))
+        self.assertTrue(xs._headerSent)
+        self.assertNotEqual('', xs.transport.value())
+        self.assertTrue(self.gotStreamEnd)
+
+
+    def test_reset(self):
+        """
+        Test resetting the XML stream to start a new layer.
+        """
+        xs = self.xmlstream
+        xs.sendHeader()
+        stream = xs.stream
+        xs.reset()
+        self.assertNotEqual(stream, xs.stream)
+        self.assertNot(xs._headerSent)
+
+
+    def test_send(self):
+        """
+        Test send with various types of objects.
+        """
+        xs = self.xmlstream
+        xs.send('<presence/>')
+        self.assertEqual(xs.transport.value(), '<presence/>')
+
+        xs.transport.clear()
+        el = domish.Element(('testns', 'presence'))
+        xs.send(el)
+        self.assertEqual(xs.transport.value(), '<presence/>')
+
+        xs.transport.clear()
+        el = domish.Element(('http://etherx.jabber.org/streams', 'features'))
+        xs.send(el)
+        self.assertEqual(xs.transport.value(), '<stream:features/>')
+
+
+    def test_authenticator(self):
+        """
+        Test that the associated authenticator is correctly called.
+        """
+        connectionMadeCalls = []
+        streamStartedCalls = []
+        associateWithStreamCalls = []
+
+        class TestAuthenticator:
+            def connectionMade(self):
+                connectionMadeCalls.append(None)
+
+            def streamStarted(self, rootElement):
+                streamStartedCalls.append(rootElement)
+
+            def associateWithStream(self, xs):
+                associateWithStreamCalls.append(xs)
+
+        a = TestAuthenticator()
+        xs = xmlstream.XmlStream(a)
+        self.assertEqual([xs], associateWithStreamCalls)
+        xs.connectionMade()
+        self.assertEqual([None], connectionMadeCalls)
+        xs.dataReceived("<stream:stream xmlns='jabber:client' "
+                        "xmlns:stream='http://etherx.jabber.org/streams' "
+                        "from='example.com' id='12345'>")
+        self.assertEqual(1, len(streamStartedCalls))
+        xs.reset()
+        self.assertEqual([None], connectionMadeCalls)
+
+
+
+class TestError(Exception):
+    pass
+
+
+
+class AuthenticatorTest(unittest.TestCase):
+    def setUp(self):
+        self.authenticator = xmlstream.Authenticator()
+        self.xmlstream = xmlstream.XmlStream(self.authenticator)
+
+
+    def test_streamStart(self):
+        """
+        Test streamStart to fill the appropriate attributes from the
+        stream header.
+        """
+        xs = self.xmlstream
+        xs.makeConnection(proto_helpers.StringTransport())
+        xs.dataReceived("<stream:stream xmlns='jabber:client' "
+                         "xmlns:stream='http://etherx.jabber.org/streams' "
+                         "from='example.org' to='example.com' id='12345' "
+                         "version='1.0'>")
+        self.assertEqual((1, 0), xs.version)
+        self.assertIdentical(None, xs.sid)
+        self.assertEqual('invalid', xs.namespace)
+        self.assertIdentical(None, xs.otherEntity)
+        self.assertEqual(None, xs.thisEntity)
+
+
+    def test_streamStartLegacy(self):
+        """
+        Test streamStart to fill the appropriate attributes from the
+        stream header for a pre-XMPP-1.0 header.
+        """
+        xs = self.xmlstream
+        xs.makeConnection(proto_helpers.StringTransport())
+        xs.dataReceived("<stream:stream xmlns='jabber:client' "
+                        "xmlns:stream='http://etherx.jabber.org/streams' "
+                        "from='example.com' id='12345'>")
+        self.assertEqual((0, 0), xs.version)
+
+
+    def test_streamBadVersionOneDigit(self):
+        """
+        Test streamStart to fill the appropriate attributes from the
+        stream header for a version with only one digit.
+        """
+        xs = self.xmlstream
+        xs.makeConnection(proto_helpers.StringTransport())
+        xs.dataReceived("<stream:stream xmlns='jabber:client' "
+                        "xmlns:stream='http://etherx.jabber.org/streams' "
+                        "from='example.com' id='12345' version='1'>")
+        self.assertEqual((0, 0), xs.version)
+
+
+    def test_streamBadVersionNoNumber(self):
+        """
+        Test streamStart to fill the appropriate attributes from the
+        stream header for a malformed version.
+        """
+        xs = self.xmlstream
+        xs.makeConnection(proto_helpers.StringTransport())
+        xs.dataReceived("<stream:stream xmlns='jabber:client' "
+                        "xmlns:stream='http://etherx.jabber.org/streams' "
+                        "from='example.com' id='12345' version='blah'>")
+        self.assertEqual((0, 0), xs.version)
+
+
+
+class ConnectAuthenticatorTest(unittest.TestCase):
+
+    def setUp(self):
+        self.gotAuthenticated = False
+        self.initFailure = None
+        self.authenticator = xmlstream.ConnectAuthenticator('otherHost')
+        self.xmlstream = xmlstream.XmlStream(self.authenticator)
+        self.xmlstream.addObserver('//event/stream/authd', self.onAuthenticated)
+        self.xmlstream.addObserver('//event/xmpp/initfailed', self.onInitFailed)
+
+
+    def onAuthenticated(self, obj):
+        self.gotAuthenticated = True
+
+
+    def onInitFailed(self, failure):
+        self.initFailure = failure
+
+
+    def testSucces(self):
+        """
+        Test successful completion of an initialization step.
+        """
+        class Initializer:
+            def initialize(self):
+                pass
+
+        init = Initializer()
+        self.xmlstream.initializers = [init]
+
+        self.authenticator.initializeStream()
+        self.assertEqual([], self.xmlstream.initializers)
+        self.assertTrue(self.gotAuthenticated)
+
+
+    def testFailure(self):
+        """
+        Test failure of an initialization step.
+        """
+        class Initializer:
+            def initialize(self):
+                raise TestError
+
+        init = Initializer()
+        self.xmlstream.initializers = [init]
+
+        self.authenticator.initializeStream()
+        self.assertEqual([init], self.xmlstream.initializers)
+        self.assertFalse(self.gotAuthenticated)
+        self.assertNotIdentical(None, self.initFailure)
+        self.assertTrue(self.initFailure.check(TestError))
+
+
+    def test_streamStart(self):
+        """
+        Test streamStart to fill the appropriate attributes from the
+        stream header.
+        """
+        self.authenticator.namespace = 'testns'
+        xs = self.xmlstream
+        xs.makeConnection(proto_helpers.StringTransport())
+        xs.dataReceived("<stream:stream xmlns='jabber:client' "
+                         "xmlns:stream='http://etherx.jabber.org/streams' "
+                         "from='example.com' to='example.org' id='12345' "
+                         "version='1.0'>")
+        self.assertEqual((1, 0), xs.version)
+        self.assertEqual('12345', xs.sid)
+        self.assertEqual('testns', xs.namespace)
+        self.assertEqual('example.com', xs.otherEntity.host)
+        self.assertIdentical(None, xs.thisEntity)
+        self.assertNot(self.gotAuthenticated)
+        xs.dataReceived("<stream:features>"
+                          "<test xmlns='testns'/>"
+                        "</stream:features>")
+        self.assertIn(('testns', 'test'), xs.features)
+        self.assertTrue(self.gotAuthenticated)
+
+
+
+class ListenAuthenticatorTest(unittest.TestCase):
+    """
+    Tests for L{xmlstream.ListenAuthenticator}
+    """
+
+    def setUp(self):
+        self.authenticator = xmlstream.ListenAuthenticator()
+        self.xmlstream = xmlstream.XmlStream(self.authenticator)
+
+
+    def test_streamStart(self):
+        """
+        Test streamStart to fill the appropriate attributes from the
+        stream header.
+        """
+        xs = self.xmlstream
+        xs.makeConnection(proto_helpers.StringTransport())
+        self.assertIdentical(None, xs.sid)
+        xs.dataReceived("<stream:stream xmlns='jabber:client' "
+                         "xmlns:stream='http://etherx.jabber.org/streams' "
+                         "from='example.org' to='example.com' id='12345' "
+                         "version='1.0'>")
+        self.assertEqual((1, 0), xs.version)
+        self.assertNotIdentical(None, xs.sid)
+        self.assertNotEquals('12345', xs.sid)
+        self.assertEqual('jabber:client', xs.namespace)
+        self.assertIdentical(None, xs.otherEntity)
+        self.assertEqual('example.com', xs.thisEntity.host)
+
+
+    def test_streamStartUnicodeSessionID(self):
+        """
+        The generated session id must be a unicode object.
+        """
+        xs = self.xmlstream
+        xs.makeConnection(proto_helpers.StringTransport())
+        xs.dataReceived("<stream:stream xmlns='jabber:client' "
+                         "xmlns:stream='http://etherx.jabber.org/streams' "
+                         "from='example.org' to='example.com' id='12345' "
+                         "version='1.0'>")
+        self.assertIsInstance(xs.sid, unicode)
+
+
+
+class TLSInitiatingInitializerTest(unittest.TestCase):
+    def setUp(self):
+        self.output = []
+        self.done = []
+
+        self.savedSSL = xmlstream.ssl
+
+        self.authenticator = xmlstream.Authenticator()
+        self.xmlstream = xmlstream.XmlStream(self.authenticator)
+        self.xmlstream.send = self.output.append
+        self.xmlstream.connectionMade()
+        self.xmlstream.dataReceived("<stream:stream xmlns='jabber:client' "
+                        "xmlns:stream='http://etherx.jabber.org/streams' "
+                        "from='example.com' id='12345' version='1.0'>")
+        self.init = xmlstream.TLSInitiatingInitializer(self.xmlstream)
+
+
+    def tearDown(self):
+        xmlstream.ssl = self.savedSSL
+
+
+    def testWantedSupported(self):
+        """
+        Test start when TLS is wanted and the SSL library available.
+        """
+        self.xmlstream.transport = proto_helpers.StringTransport()
+        self.xmlstream.transport.startTLS = lambda ctx: self.done.append('TLS')
+        self.xmlstream.reset = lambda: self.done.append('reset')
+        self.xmlstream.sendHeader = lambda: self.done.append('header')
+
+        d = self.init.start()
+        d.addCallback(self.assertEquals, xmlstream.Reset)
+        starttls = self.output[0]
+        self.assertEquals('starttls', starttls.name)
+        self.assertEquals(NS_XMPP_TLS, starttls.uri)
+        self.xmlstream.dataReceived("<proceed xmlns='%s'/>" % NS_XMPP_TLS)
+        self.assertEquals(['TLS', 'reset', 'header'], self.done)
+
+        return d
+
+    if not xmlstream.ssl:
+        testWantedSupported.skip = "SSL not available"
+
+
+    def testWantedNotSupportedNotRequired(self):
+        """
+        Test start when TLS is wanted and the SSL library available.
+        """
+        xmlstream.ssl = None
+
+        d = self.init.start()
+        d.addCallback(self.assertEquals, None)
+        self.assertEquals([], self.output)
+
+        return d
+
+
+    def testWantedNotSupportedRequired(self):
+        """
+        Test start when TLS is wanted and the SSL library available.
+        """
+        xmlstream.ssl = None
+        self.init.required = True
+
+        d = self.init.start()
+        self.assertFailure(d, xmlstream.TLSNotSupported)
+        self.assertEquals([], self.output)
+
+        return d
+
+
+    def testNotWantedRequired(self):
+        """
+        Test start when TLS is not wanted, but required by the server.
+        """
+        tls = domish.Element(('urn:ietf:params:xml:ns:xmpp-tls', 'starttls'))
+        tls.addElement('required')
+        self.xmlstream.features = {(tls.uri, tls.name): tls}
+        self.init.wanted = False
+
+        d = self.init.start()
+        self.assertEquals([], self.output)
+        self.assertFailure(d, xmlstream.TLSRequired)
+
+        return d
+
+
+    def testNotWantedNotRequired(self):
+        """
+        Test start when TLS is not wanted, but required by the server.
+        """
+        tls = domish.Element(('urn:ietf:params:xml:ns:xmpp-tls', 'starttls'))
+        self.xmlstream.features = {(tls.uri, tls.name): tls}
+        self.init.wanted = False
+
+        d = self.init.start()
+        d.addCallback(self.assertEqual, None)
+        self.assertEquals([], self.output)
+        return d
+
+
+    def testFailed(self):
+        """
+        Test failed TLS negotiation.
+        """
+        # Pretend that ssl is supported, it isn't actually used when the
+        # server starts out with a failure in response to our initial
+        # C{starttls} stanza.
+        xmlstream.ssl = 1
+
+        d = self.init.start()
+        self.assertFailure(d, xmlstream.TLSFailed)
+        self.xmlstream.dataReceived("<failure xmlns='%s'/>" % NS_XMPP_TLS)
+        return d
+
+
+
+class TestFeatureInitializer(xmlstream.BaseFeatureInitiatingInitializer):
+    feature = ('testns', 'test')
+
+    def start(self):
+        return defer.succeed(None)
+
+
+
+class BaseFeatureInitiatingInitializerTest(unittest.TestCase):
+
+    def setUp(self):
+        self.xmlstream = xmlstream.XmlStream(xmlstream.Authenticator())
+        self.init = TestFeatureInitializer(self.xmlstream)
+
+
+    def testAdvertized(self):
+        """
+        Test that an advertized feature results in successful initialization.
+        """
+        self.xmlstream.features = {self.init.feature:
+                                   domish.Element(self.init.feature)}
+        return self.init.initialize()
+
+
+    def testNotAdvertizedRequired(self):
+        """
+        Test that when the feature is not advertized, but required by the
+        initializer, an exception is raised.
+        """
+        self.init.required = True
+        self.assertRaises(xmlstream.FeatureNotAdvertized, self.init.initialize)
+
+
+    def testNotAdvertizedNotRequired(self):
+        """
+        Test that when the feature is not advertized, and not required by the
+        initializer, the initializer silently succeeds.
+        """
+        self.init.required = False
+        self.assertIdentical(None, self.init.initialize())
+
+
+
+class ToResponseTest(unittest.TestCase):
+
+    def test_toResponse(self):
+        """
+        Test that a response stanza is generated with addressing swapped.
+        """
+        stanza = domish.Element(('jabber:client', 'iq'))
+        stanza['type'] = 'get'
+        stanza['to'] = 'user1@example.com'
+        stanza['from'] = 'user2@example.com/resource'
+        stanza['id'] = 'stanza1'
+        response = xmlstream.toResponse(stanza, 'result')
+        self.assertNotIdentical(stanza, response)
+        self.assertEqual(response['from'], 'user1@example.com')
+        self.assertEqual(response['to'], 'user2@example.com/resource')
+        self.assertEqual(response['type'], 'result')
+        self.assertEqual(response['id'], 'stanza1')
+
+
+    def test_toResponseNoFrom(self):
+        """
+        Test that a response is generated from a stanza without a from address.
+        """
+        stanza = domish.Element(('jabber:client', 'iq'))
+        stanza['type'] = 'get'
+        stanza['to'] = 'user1@example.com'
+        response = xmlstream.toResponse(stanza)
+        self.assertEqual(response['from'], 'user1@example.com')
+        self.assertFalse(response.hasAttribute('to'))
+
+
+    def test_toResponseNoTo(self):
+        """
+        Test that a response is generated from a stanza without a to address.
+        """
+        stanza = domish.Element(('jabber:client', 'iq'))
+        stanza['type'] = 'get'
+        stanza['from'] = 'user2@example.com/resource'
+        response = xmlstream.toResponse(stanza)
+        self.assertFalse(response.hasAttribute('from'))
+        self.assertEqual(response['to'], 'user2@example.com/resource')
+
+
+    def test_toResponseNoAddressing(self):
+        """
+        Test that a response is generated from a stanza without any addressing.
+        """
+        stanza = domish.Element(('jabber:client', 'message'))
+        stanza['type'] = 'chat'
+        response = xmlstream.toResponse(stanza)
+        self.assertFalse(response.hasAttribute('to'))
+        self.assertFalse(response.hasAttribute('from'))
+
+
+    def test_noID(self):
+        """
+        Test that a proper response is generated without id attribute.
+        """
+        stanza = domish.Element(('jabber:client', 'message'))
+        response = xmlstream.toResponse(stanza)
+        self.assertFalse(response.hasAttribute('id'))
+
+
+    def test_noType(self):
+        """
+        Test that a proper response is generated without type attribute.
+        """
+        stanza = domish.Element(('jabber:client', 'message'))
+        response = xmlstream.toResponse(stanza)
+        self.assertFalse(response.hasAttribute('type'))
+
+
+class DummyFactory(object):
+    """
+    Dummy XmlStream factory that only registers bootstrap observers.
+    """
+    def __init__(self):
+        self.callbacks = {}
+
+
+    def addBootstrap(self, event, callback):
+        self.callbacks[event] = callback
+
+
+
+class DummyXMPPHandler(xmlstream.XMPPHandler):
+    """
+    Dummy XMPP subprotocol handler to count the methods are called on it.
+    """
+    def __init__(self):
+        self.doneMade = 0
+        self.doneInitialized = 0
+        self.doneLost = 0
+
+
+    def makeConnection(self, xs):
+        self.connectionMade()
+
+
+    def connectionMade(self):
+        self.doneMade += 1
+
+
+    def connectionInitialized(self):
+        self.doneInitialized += 1
+
+
+    def connectionLost(self, reason):
+        self.doneLost += 1
+
+
+
+class XMPPHandlerTest(unittest.TestCase):
+    """
+    Tests for L{xmlstream.XMPPHandler}.
+    """
+
+    def test_interface(self):
+        """
+        L{xmlstream.XMPPHandler} implements L{ijabber.IXMPPHandler}.
+        """
+        verifyObject(ijabber.IXMPPHandler, xmlstream.XMPPHandler())
+
+
+    def test_send(self):
+        """
+        Test that data is passed on for sending by the stream manager.
+        """
+        class DummyStreamManager(object):
+            def __init__(self):
+                self.outlist = []
+
+            def send(self, data):
+                self.outlist.append(data)
+
+        handler = xmlstream.XMPPHandler()
+        handler.parent = DummyStreamManager()
+        handler.send('<presence/>')
+        self.assertEquals(['<presence/>'], handler.parent.outlist)
+
+
+    def test_makeConnection(self):
+        """
+        Test that makeConnection saves the XML stream and calls connectionMade.
+        """
+        class TestXMPPHandler(xmlstream.XMPPHandler):
+            def connectionMade(self):
+                self.doneMade = True
+
+        handler = TestXMPPHandler()
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        handler.makeConnection(xs)
+        self.assertTrue(handler.doneMade)
+        self.assertIdentical(xs, handler.xmlstream)
+
+
+    def test_connectionLost(self):
+        """
+        Test that connectionLost forgets the XML stream.
+        """
+        handler = xmlstream.XMPPHandler()
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        handler.makeConnection(xs)
+        handler.connectionLost(Exception())
+        self.assertIdentical(None, handler.xmlstream)
+
+
+
+class XMPPHandlerCollectionTest(unittest.TestCase):
+    """
+    Tests for L{xmlstream.XMPPHandlerCollection}.
+    """
+
+    def setUp(self):
+        self.collection = xmlstream.XMPPHandlerCollection()
+
+
+    def test_interface(self):
+        """
+        L{xmlstream.StreamManager} implements L{ijabber.IXMPPHandlerCollection}.
+        """
+        verifyObject(ijabber.IXMPPHandlerCollection, self.collection)
+
+
+    def test_addHandler(self):
+        """
+        Test the addition of a protocol handler.
+        """
+        handler = DummyXMPPHandler()
+        handler.setHandlerParent(self.collection)
+        self.assertIn(handler, self.collection)
+        self.assertIdentical(self.collection, handler.parent)
+
+
+    def test_removeHandler(self):
+        """
+        Test removal of a protocol handler.
+        """
+        handler = DummyXMPPHandler()
+        handler.setHandlerParent(self.collection)
+        handler.disownHandlerParent(self.collection)
+        self.assertNotIn(handler, self.collection)
+        self.assertIdentical(None, handler.parent)
+
+
+
+class StreamManagerTest(unittest.TestCase):
+    """
+    Tests for L{xmlstream.StreamManager}.
+    """
+
+    def setUp(self):
+        factory = DummyFactory()
+        self.streamManager = xmlstream.StreamManager(factory)
+
+
+    def test_basic(self):
+        """
+        Test correct initialization and setup of factory observers.
+        """
+        sm = self.streamManager
+        self.assertIdentical(None, sm.xmlstream)
+        self.assertEquals([], sm.handlers)
+        self.assertEquals(sm._connected,
+                          sm.factory.callbacks['//event/stream/connected'])
+        self.assertEquals(sm._authd,
+                          sm.factory.callbacks['//event/stream/authd'])
+        self.assertEquals(sm._disconnected,
+                          sm.factory.callbacks['//event/stream/end'])
+        self.assertEquals(sm.initializationFailed,
+                          sm.factory.callbacks['//event/xmpp/initfailed'])
+
+
+    def test_connected(self):
+        """
+        Test that protocol handlers have their connectionMade method called
+        when the XML stream is connected.
+        """
+        sm = self.streamManager
+        handler = DummyXMPPHandler()
+        handler.setHandlerParent(sm)
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        sm._connected(xs)
+        self.assertEquals(1, handler.doneMade)
+        self.assertEquals(0, handler.doneInitialized)
+        self.assertEquals(0, handler.doneLost)
+
+
+    def test_connectedLogTrafficFalse(self):
+        """
+        Test raw data functions unset when logTraffic is set to False.
+        """
+        sm = self.streamManager
+        handler = DummyXMPPHandler()
+        handler.setHandlerParent(sm)
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        sm._connected(xs)
+        self.assertIdentical(None, xs.rawDataInFn)
+        self.assertIdentical(None, xs.rawDataOutFn)
+
+
+    def test_connectedLogTrafficTrue(self):
+        """
+        Test raw data functions set when logTraffic is set to True.
+        """
+        sm = self.streamManager
+        sm.logTraffic = True
+        handler = DummyXMPPHandler()
+        handler.setHandlerParent(sm)
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        sm._connected(xs)
+        self.assertNotIdentical(None, xs.rawDataInFn)
+        self.assertNotIdentical(None, xs.rawDataOutFn)
+
+
+    def test_authd(self):
+        """
+        Test that protocol handlers have their connectionInitialized method
+        called when the XML stream is initialized.
+        """
+        sm = self.streamManager
+        handler = DummyXMPPHandler()
+        handler.setHandlerParent(sm)
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        sm._authd(xs)
+        self.assertEquals(0, handler.doneMade)
+        self.assertEquals(1, handler.doneInitialized)
+        self.assertEquals(0, handler.doneLost)
+
+
+    def test_disconnected(self):
+        """
+        Test that protocol handlers have their connectionLost method
+        called when the XML stream is disconnected.
+        """
+        sm = self.streamManager
+        handler = DummyXMPPHandler()
+        handler.setHandlerParent(sm)
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        sm._disconnected(xs)
+        self.assertEquals(0, handler.doneMade)
+        self.assertEquals(0, handler.doneInitialized)
+        self.assertEquals(1, handler.doneLost)
+
+
+    def test_addHandler(self):
+        """
+        Test the addition of a protocol handler while not connected.
+        """
+        sm = self.streamManager
+        handler = DummyXMPPHandler()
+        handler.setHandlerParent(sm)
+
+        self.assertEquals(0, handler.doneMade)
+        self.assertEquals(0, handler.doneInitialized)
+        self.assertEquals(0, handler.doneLost)
+
+
+    def test_addHandlerInitialized(self):
+        """
+        Test the addition of a protocol handler after the stream
+        have been initialized.
+
+        Make sure that the handler will have the connected stream
+        passed via C{makeConnection} and have C{connectionInitialized}
+        called.
+        """
+        sm = self.streamManager
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        sm._connected(xs)
+        sm._authd(xs)
+        handler = DummyXMPPHandler()
+        handler.setHandlerParent(sm)
+
+        self.assertEquals(1, handler.doneMade)
+        self.assertEquals(1, handler.doneInitialized)
+        self.assertEquals(0, handler.doneLost)
+
+
+    def test_sendInitialized(self):
+        """
+        Test send when the stream has been initialized.
+
+        The data should be sent directly over the XML stream.
+        """
+        factory = xmlstream.XmlStreamFactory(xmlstream.Authenticator())
+        sm = xmlstream.StreamManager(factory)
+        xs = factory.buildProtocol(None)
+        xs.transport = proto_helpers.StringTransport()
+        xs.connectionMade()
+        xs.dataReceived("<stream:stream xmlns='jabber:client' "
+                        "xmlns:stream='http://etherx.jabber.org/streams' "
+                        "from='example.com' id='12345'>")
+        xs.dispatch(xs, "//event/stream/authd")
+        sm.send("<presence/>")
+        self.assertEquals("<presence/>", xs.transport.value())
+
+
+    def test_sendNotConnected(self):
+        """
+        Test send when there is no established XML stream.
+
+        The data should be cached until an XML stream has been established and
+        initialized.
+        """
+        factory = xmlstream.XmlStreamFactory(xmlstream.Authenticator())
+        sm = xmlstream.StreamManager(factory)
+        handler = DummyXMPPHandler()
+        sm.addHandler(handler)
+
+        xs = factory.buildProtocol(None)
+        xs.transport = proto_helpers.StringTransport()
+        sm.send("<presence/>")
+        self.assertEquals("", xs.transport.value())
+        self.assertEquals("<presence/>", sm._packetQueue[0])
+
+        xs.connectionMade()
+        self.assertEquals("", xs.transport.value())
+        self.assertEquals("<presence/>", sm._packetQueue[0])
+
+        xs.dataReceived("<stream:stream xmlns='jabber:client' "
+                        "xmlns:stream='http://etherx.jabber.org/streams' "
+                        "from='example.com' id='12345'>")
+        xs.dispatch(xs, "//event/stream/authd")
+
+        self.assertEquals("<presence/>", xs.transport.value())
+        self.assertFalse(sm._packetQueue)
+
+
+    def test_sendNotInitialized(self):
+        """
+        Test send when the stream is connected but not yet initialized.
+
+        The data should be cached until the XML stream has been initialized.
+        """
+        factory = xmlstream.XmlStreamFactory(xmlstream.Authenticator())
+        sm = xmlstream.StreamManager(factory)
+        xs = factory.buildProtocol(None)
+        xs.transport = proto_helpers.StringTransport()
+        xs.connectionMade()
+        xs.dataReceived("<stream:stream xmlns='jabber:client' "
+                        "xmlns:stream='http://etherx.jabber.org/streams' "
+                        "from='example.com' id='12345'>")
+        sm.send("<presence/>")
+        self.assertEquals("", xs.transport.value())
+        self.assertEquals("<presence/>", sm._packetQueue[0])
+
+
+    def test_sendDisconnected(self):
+        """
+        Test send after XML stream disconnection.
+
+        The data should be cached until a new XML stream has been established
+        and initialized.
+        """
+        factory = xmlstream.XmlStreamFactory(xmlstream.Authenticator())
+        sm = xmlstream.StreamManager(factory)
+        handler = DummyXMPPHandler()
+        sm.addHandler(handler)
+
+        xs = factory.buildProtocol(None)
+        xs.connectionMade()
+        xs.transport = proto_helpers.StringTransport()
+        xs.connectionLost(None)
+
+        sm.send("<presence/>")
+        self.assertEquals("", xs.transport.value())
+        self.assertEquals("<presence/>", sm._packetQueue[0])
+
+
+
+class XmlStreamServerFactoryTest(GenericXmlStreamFactoryTestsMixin):
+    """
+    Tests for L{xmlstream.XmlStreamServerFactory}.
+    """
+
+    def setUp(self):
+        """
+        Set up a server factory with a authenticator factory function.
+        """
+        class TestAuthenticator(object):
+            def __init__(self):
+                self.xmlstreams = []
+
+            def associateWithStream(self, xs):
+                self.xmlstreams.append(xs)
+
+        def authenticatorFactory():
+            return TestAuthenticator()
+
+        self.factory = xmlstream.XmlStreamServerFactory(authenticatorFactory)
+
+
+    def test_interface(self):
+        """
+        L{XmlStreamServerFactory} is a L{Factory}.
+        """
+        verifyObject(IProtocolFactory, self.factory)
+
+
+    def test_buildProtocolAuthenticatorInstantiation(self):
+        """
+        The authenticator factory should be used to instantiate the
+        authenticator and pass it to the protocol.
+
+        The default protocol, L{XmlStream} stores the authenticator it is
+        passed, and calls its C{associateWithStream} method. so we use that to
+        check whether our authenticator factory is used and the protocol
+        instance gets an authenticator.
+        """
+        xs = self.factory.buildProtocol(None)
+        self.assertEquals([xs], xs.authenticator.xmlstreams)
+
+
+    def test_buildProtocolXmlStream(self):
+        """
+        The protocol factory creates Jabber XML Stream protocols by default.
+        """
+        xs = self.factory.buildProtocol(None)
+        self.assertIsInstance(xs, xmlstream.XmlStream)
+
+
+    def test_buildProtocolTwice(self):
+        """
+        Subsequent calls to buildProtocol should result in different instances
+        of the protocol, as well as their authenticators.
+        """
+        xs1 = self.factory.buildProtocol(None)
+        xs2 = self.factory.buildProtocol(None)
+        self.assertNotIdentical(xs1, xs2)
+        self.assertNotIdentical(xs1.authenticator, xs2.authenticator)
+
+# -*- coding: utf-8 -*-
+##############################################################################
+#
+#    OpenERP, Open Source Business Applications
+#    Copyright (c) 2011 OpenERP S.A. <http://openerp.com>
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as
+#    published by the Free Software Foundation, either version 3 of the
+#    License, 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 Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##############################################################################
+
+import purchase_order
+
+# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
+
+# Copyright 2011, Google Inc.
+# 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.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS 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 COPYRIGHT
+# OWNER OR CONTRIBUTORS 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.
+
+
+"""Base stream class.
+"""
+
+
+# Note: request.connection.write/read are used in this module, even though
+# mod_python document says that they should be used only in connection
+# handlers. Unfortunately, we have no other options. For example,
+# request.write/read are not suitable because they don't allow direct raw bytes
+# writing/reading.
+
+
+import socket
+
+from mod_pywebsocket import util
+
+
+# Exceptions
+
+
+class ConnectionTerminatedException(Exception):
+    """This exception will be raised when a connection is terminated
+    unexpectedly.
+    """
+
+    pass
+
+
+class InvalidFrameException(ConnectionTerminatedException):
+    """This exception will be raised when we received an invalid frame we
+    cannot parse.
+    """
+
+    pass
+
+
+class BadOperationException(Exception):
+    """This exception will be raised when send_message() is called on
+    server-terminated connection or receive_message() is called on
+    client-terminated connection.
+    """
+
+    pass
+
+
+class UnsupportedFrameException(Exception):
+    """This exception will be raised when we receive a frame with flag, opcode
+    we cannot handle. Handlers can just catch and ignore this exception and
+    call receive_message() again to continue processing the next frame.
+    """
+
+    pass
+
+
+class InvalidUTF8Exception(Exception):
+    """This exception will be raised when we receive a text frame which
+    contains invalid UTF-8 strings.
+    """
+
+    pass
+
+
+class StreamBase(object):
+    """Base stream class."""
+
+    def __init__(self, request):
+        """Construct an instance.
+
+        Args:
+            request: mod_python request.
+        """
+
+        self._logger = util.get_class_logger(self)
+
+        self._request = request
+
+    def _read(self, length):
+        """Reads length bytes from connection. In case we catch any exception,
+        prepends remote address to the exception message and raise again.
+
+        Raises:
+            ConnectionTerminatedException: when read returns empty string.
+        """
+
+        try:
+            read_bytes = self._request.connection.read(length)
+            if not read_bytes:
+                raise ConnectionTerminatedException(
+                    'Receiving %d byte failed. Peer (%r) closed connection' %
+                    (length, (self._request.connection.remote_addr,)))
+            return read_bytes
+        except socket.error, e:
+            # Catch a socket.error. Because it's not a child class of the
+            # IOError prior to Python 2.6, we cannot omit this except clause.
+            # Use %s rather than %r for the exception to use human friendly
+            # format.
+            raise ConnectionTerminatedException(
+                'Receiving %d byte failed. socket.error (%s) occurred' %
+                (length, e))
+        except IOError, e:
+            # Also catch an IOError because mod_python throws it.
+            raise ConnectionTerminatedException(
+                'Receiving %d byte failed. IOError (%s) occurred' %
+                (length, e))
+
+    def _write(self, bytes_to_write):
+        """Writes given bytes to connection. In case we catch any exception,
+        prepends remote address to the exception message and raise again.
+        """
+
+        try:
+            self._request.connection.write(bytes_to_write)
+        except Exception, e:
+            util.prepend_message_to_exception(
+                    'Failed to send message to %r: ' %
+                            (self._request.connection.remote_addr,),
+                    e)
+            raise
+
+    def receive_bytes(self, length):
+        """Receives multiple bytes. Retries read when we couldn't receive the
+        specified amount.
+
+        Raises:
+            ConnectionTerminatedException: when read returns empty string.
+        """
+
+        read_bytes = []
+        while length > 0:
+            new_read_bytes = self._read(length)
+            read_bytes.append(new_read_bytes)
+            length -= len(new_read_bytes)
+        return ''.join(read_bytes)
+
+    def _read_until(self, delim_char):
+        """Reads bytes until we encounter delim_char. The result will not
+        contain delim_char.
+
+        Raises:
+            ConnectionTerminatedException: when read returns empty string.
+        """
+
+        read_bytes = []
+        while True:
+            ch = self._read(1)
+            if ch == delim_char:
+                break
+            read_bytes.append(ch)
+        return ''.join(read_bytes)
+
+
+# vi:sts=4 sw=4 et
+
+# Copyright 2010 Michael Murr
+#
+# This file is part of LibForensics.
+#
+# LibForensics is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# LibForensics 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with LibForensics.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Ctypes classes for shell link files"""
+
+# local imports
+from lf.win.shell.link.dtypes import (
+    HotKey, ShellLinkHeader, LinkInfoHeader, VolumeIDHeader, CNRLHeader,
+    ConsoleDataBlock, ConsoleFEDataBlock, DarwinDataBlock,
+    ExpandableStringsDataBlock, EnvironmentVariableDataBlock,
+    IconEnvironmentDataBlock, DarwinDataBlock, KnownFolderDataBlock,
+    SpecialFolderDataBlock, TrackerDataBlock, TrackerDataBlockFooter,
+    DataBlockHeader, FileAttributes, LinkFlags, DomainRelativeObjId
+)
+
+__docformat__ = "restructuredtext en"
+__all__ = [
+    "hot_key", "shell_link_header", "link_info_header", "volume_id_header",
+    "cnrl_header", "console_data_block", "console_fe_data_block",
+    "darwin_data_block", "expandable_strings_data_block",
+    "environment_variable_data_block", "icon_environment_data_block",
+    "known_folder_data_block", "special_folder_data_block",
+    "tracker_data_block", "tracker_data_block_footer", "data_block_header",
+    "file_attributes", "link_flags", "domain_relative_obj_id"
+]
+
+hot_key = HotKey._ctype_
+shell_link_header = ShellLinkHeader._ctype_
+link_info_header = LinkInfoHeader._ctype_
+volume_id_header =  VolumeIDHeader._ctype_
+cnrl_header = CNRLHeader._ctype_
+console_data_block = ConsoleDataBlock._ctype_
+console_fe_data_block = ConsoleFEDataBlock._ctype_
+darwin_data_block = DarwinDataBlock._ctype_
+environment_variable_data_block = EnvironmentVariableDataBlock._ctype_
+expandable_strings_data_block = ExpandableStringsDataBlock._ctype_
+icon_environment_data_block = IconEnvironmentDataBlock._ctype_
+known_folder_data_block = KnownFolderDataBlock._ctype_
+special_folder_data_block = SpecialFolderDataBlock._ctype_
+tracker_data_block = TrackerDataBlock._ctype_
+tracker_data_block_footer = TrackerDataBlockFooter._ctype_
+data_block_header = DataBlockHeader._ctype_
+file_attributes = FileAttributes._ctype_
+link_flags = LinkFlags._ctype_
+domain_relative_obj_id = DomainRelativeObjId._ctype_
+
+'''
+Created on Jan 5, 2015
+
+@author: Francois Belletti
+'''
+
+import numpy as np
+
+from OSM.misc.geoTools import computeDist
+
+#
+#    Need to change that distance
+#
+def l2_dist(node_1, node_2):
+    lat_1 = float(node_1.get('lat'))
+    lon_1 = float(node_1.get('lon'))
+    lat_2 = float(node_2.get('lat'))
+    lon_2 = float(node_2.get('lon'))
+    return computeDist(lon_1, lat_1, lon_2, lat_2)
+
+#
+#    Extract a given target network (road, rail, subway)
+#        from a list of ways as well as the references
+#        to all nodes (as a dict)
+#    Returns the edges as a list, the nodes as the keys
+#        of a dict recaping all their parents
+#
+def extract_edges(ways, target_key, target_values):
+    node_seqs = []
+    node_refs = {}
+    #
+    for way in ways:
+        ref_tags  = way.findall('tag')
+        in_network = False
+        for ref_tag in ref_tags:
+            k = ref_tag.get('k')
+            v = ref_tag.get('v')
+            if k == target_key and v in target_values:
+                in_network = True
+                break
+        if not in_network:
+            continue
+        else:
+            node_seqs.append(way)
+        way_id = way.get('id')
+        child_nodes = way.findall('nd')
+        for child_node in child_nodes:
+            node_id = child_node.get('ref')
+            if node_id not in node_refs:
+                node_refs[node_id] = []
+            node_refs[node_id].append(way_id)
+    return node_seqs, node_refs
+    
+#
+#    Split ways into links between intersections
+#
+def split_ways(node_seqs, node_refs, node_dict, target_features):
+    #    Convenience compute distance function
+    def cmpt_length(node_seq):
+        dist = 0
+        for i in range(len(node_seq) - 1):
+            prev_node = node_dict[node_seq[i].get('ref')]
+            next_node = node_dict[node_seq[i+1].get('ref')]
+            dist += l2_dist(prev_node, next_node)
+        return dist
+    #
+    all_features = ['length', 'node_seq']
+    all_features.extend(target_features)
+    #
+    links = []
+    for node_seq in node_seqs:
+        features = dict.fromkeys(target_features, None)
+        for tag in node_seq.findall('tag'):
+            k = tag.get('k')
+            if k not in features:
+                continue
+            v = tag.get('v')
+            features[k] = v
+        node_seq = node_seq.findall('nd')
+        ref_seq = [len(node_refs[x.get('ref')]) for x in node_seq]
+        cut_indices = []
+        ref_seq_len = len(ref_seq)
+        for i, n_ref in enumerate(ref_seq):
+            if n_ref > 1 and (i != 0) and (i != (ref_seq_len - 1)):
+                cut_indices.append(i)
+        sub_links = []
+        cut_indices_len = len(cut_indices)
+        #    For factoring
+        def sub_seq_summary(sub_sequence):
+            sub_seq_length = cmpt_length(sub_sequence)
+            summary = dict.fromkeys(all_features, None)
+            summary['length']   = sub_seq_length # in meters
+            summary['node_seq'] = sub_sequence
+            for feature in target_features:
+                summary[feature] = features[feature]
+            return summary
+        #
+        if cut_indices_len > 0:
+            for i, cut_index in enumerate(cut_indices):
+                if i == 0:
+                    sub_seq = node_seq[:cut_index + 1]  # reach for 1 more to create overlap
+                    sub_links.append(sub_seq_summary(sub_seq))
+                if i < (cut_indices_len - 1):
+                    sub_seq = node_seq[cut_index:cut_indices[i+1] + 1]
+                    sub_links.append(sub_seq_summary(sub_seq))
+                if i == (cut_indices_len - 1):
+                    sub_seq = node_seq[cut_index:]
+                    sub_links.append(sub_seq_summary(sub_seq))
+        else:
+            sub_seq = node_seq
+            sub_links = [sub_seq_summary(sub_seq)]
+        links.extend(sub_links)
+    return links
+
+#        
+#    From the links (dual graph) build the nodes and link
+#        them one to another (primal graph)
+#    The result is a dict[node] = [neighbours]
+#
+def link_nodes(links, target_features):
+    linked_nodes = {}
+    for link in links:
+        leftmost_node_id  = link['node_seq'][0].get('ref')
+        rightmost_node_id = link['node_seq'][-1].get('ref')
+        # The following work on the set of features
+        #     needs to become dynamic
+        edge_dict = {}
+        edge_dict['length'] = link['length']
+        for feature in target_features:
+            edge_dict[feature] = link[feature]
+        #
+        #    Create edges in graph (vertices are keys)
+        #    So far one ways are not taken into account
+        #
+        # Link left to right
+        if leftmost_node_id not in linked_nodes:
+            linked_nodes[leftmost_node_id] = {}
+        linked_nodes[leftmost_node_id][rightmost_node_id] = \
+            edge_dict
+        # Link right to left
+        if rightmost_node_id not in linked_nodes:
+            linked_nodes[rightmost_node_id] = {}
+        linked_nodes[rightmost_node_id][leftmost_node_id] = \
+            edge_dict
+    return linked_nodes
+            
+#
+#    Reduce network for routing applications, get rid of
+#        nodes that do not correspond to intersections
+#
+def reduce_network(linked_nodes,
+                   feature_list):
+    to_delete = []
+    for node_id, neighbours in linked_nodes.iteritems():
+        if len(neighbours) == 2:
+            neigh_items = neighbours.items()
+            left_neigh  , left_features  = neigh_items[0]
+            right_neigh , right_features = neigh_items[1]
+            #    Check that properties are identical
+            identical = True
+            for feature in feature_list:
+                if left_features[feature] != right_features[feature]:
+                    identical = False
+            if not identical:
+                continue
+            # Collapse node with node_id into neighbours
+            tot_length = left_features['length'] + \
+                         right_features['length']
+            merge_features = {}
+            merge_features['length'] = tot_length
+            for feature in feature_list:
+                merge_features[feature] = left_features[feature]
+            #
+            linked_nodes[right_neigh][left_neigh] = merge_features
+            del linked_nodes[right_neigh][node_id]
+            #
+            linked_nodes[left_neigh][right_neigh] = merge_features
+            del linked_nodes[left_neigh][node_id]
+            #
+            to_delete.append(node_id)
+    for node_id in to_delete:
+        del linked_nodes[node_id]
+               
+                
+"""
+setuptools installer for exim_ses_transport
+"""
+# Copyright 2011, Jayson Vantuyl <jvantuyl@gmail.com>
+#
+# This file is part of exim_ses_transport.
+#
+# exim_ses_transport is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or (at your
+# option) any later version.
+#
+# exim_ses_transport 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 Lesser General Public License
+# for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with exim_ses_transport.  If not, see <http://www.gnu.org/licenses/>.
+
+from setuptools import setup
+
+setup(
+	name = "EximSesTransport",
+	version = "0.4",
+
+	description = 'An Amazon SES transport for the Exim MTA.',
+	platforms = [ 'any' ],
+	author = "Jayson Vantuyl",
+	author_email = "jvantuyl@gmail.com",
+	long_description = """Amazon's cloud includes a service to send e-mail through their infrastructure.
+While this is useful, sometimes there's just no substitute for an MTA.  This
+transport allows you to selectively integrate Amazon's SES with one of the
+Internet's most powerful MTAs, Exim.
+""",
+	url = 'https://github.com/jvantuyl/exim_ses_transport',
+	license = "http://www.gnu.org/copyleft/lesser.html",
+	classifiers = [
+		'Topic :: Communications :: Email :: Filters',
+		'License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)'
+	],
+
+	packages = ['exim_ses_transport'],
+	install_requires = ['boto>=2.0', 'dkimpy>=0.5'],
+	dependency_links = ['https://launchpad.net/dkimpy/trunk/0.5.4/+download/dkimpy-0.5.4.tar.gz#egg=dkimpy-0.5.4'],
+	entry_points = { 'console_scripts': [ 'exim_ses_transport=exim_ses_transport.run:main' ] }
+)
+
+import psycopg2
+
+from steersuite import LogParser
+from steersuitedb import Composite1Benchmark
+# import steersuitedb.Composite1Benchmark
+
+logfile = open('ppr/test.log', 'r')
+
+lparser = LogParser.LogParser()
+
+out = lparser.parseLog(logfile)
+
+con = psycopg2.connect(database='steersuitedb', user='steeruser', password='steersuite') 
+
+cur = con.cursor()   
+
+benchmark = Composite1Benchmark.Composite1Benchmark(1,
+                                                    out[2][0],
+                                                    out[2][1],
+                                                    out[2][2],
+                                                    out[2][3],
+                                                    out[2][4],
+                                                    out[2][5],
+                                                    out[2][6],
+                                                    out[2][7],
+                                                    out[2][8],
+                                                    out[2][9],
+                                                    out[2][10],
+                                                    out[2][11],
+                                                    out[2][12],
+                                                    out[2][13],
+                                                    out[2][14],
+                                                    out[2][15],
+                                                    out[2][16],
+                                                    out[2][17],
+                                                    out[2][18],
+                                                    out[2][19],
+                                                    out[2][20],
+                                                    out[2][21],
+                                                    out[2][22]
+                                                    )
+   
+print out
+print ":"
+print out[2][3]
+print benchmark._total_change_in_speed
+
+cur.execute("Select * from nextval('algorithm_seq')")
+row = cur.fetchone()
+print row
+print row[0]
+
+status = benchmark.insertTest2(cur)
+logfile.close()
+
+from rest_framework import permissions
+from readthedocs.privacy.backend import AdminPermission
+
+
+class IsOwner(permissions.BasePermission):
+    """
+    Custom permission to only allow owners of an object to edit it.
+    """
+
+    def has_object_permission(self, request, view, obj):
+        # Write permissions are only allowed to the owner of the snippet
+        return request.user in obj.users.all()
+
+
+class CommentModeratorOrReadOnly(permissions.BasePermission):
+
+    def has_object_permission(self, request, view, comment):
+        if request.method in permissions.SAFE_METHODS:
+            return True  # TODO: Similar logic to #1084
+        else:
+            return AdminPermission.is_admin(request.user, comment.node.project)
+
+
+class RelatedProjectIsOwner(permissions.BasePermission):
+    """
+    Custom permission to only allow owners of an object to edit it.
+    """
+
+    def has_object_permission(self, request, view, obj):
+        # Write permissions are only allowed to the owner of the snippet
+        return request.user in obj.project.users.all()
+
+
+class APIPermission(permissions.IsAuthenticatedOrReadOnly):
+    '''
+    This permission should allow authenicated users readonly access to the API,
+    and allow admin users write access. This should be used on API resources
+    that need to implement write operations to resources that were based on the
+    ReadOnlyViewSet
+    '''
+
+    def has_object_permission(self, request, view, obj):
+        has_perm = super(APIPermission, self).has_object_permission(
+            request, view, obj)
+        return has_perm or (request.user and request.user.is_staff)
+
+
+class APIRestrictedPermission(permissions.IsAdminUser):
+    """Allow admin write, authenticated and anonymous read only
+
+    This differs from :py:cls:`APIPermission` by not allowing for authenticated
+    POSTs. This permission is endpoints like ``/api/v2/build/``, which are used
+    by admin users to coordinate build instance creation, but only should be
+    readable by end users.
+    """
+
+    def has_object_permission(self, request, view, obj):
+        return (
+            request.method in permissions.SAFE_METHODS or
+            (request.user and request.user.is_staff)
+        )
+
+import unittest2
+
+from google.appengine.ext import ndb
+from google.appengine.ext import testbed
+
+from consts.award_type import AwardType
+from consts.event_type import EventType
+from consts.notification_type import NotificationType
+from models.award import Award
+from models.event import Event
+from models.team import Team
+
+from models.notifications.awards import AwardsNotification
+
+
+class TestAwardsNotification(unittest2.TestCase):
+
+    def setUp(self):
+        self.testbed = testbed.Testbed()
+        self.testbed.activate()
+        self.testbed.init_datastore_v3_stub()
+        self.testbed.init_memcache_stub()
+        ndb.get_context().clear_cache()
+
+        self.testbed.init_taskqueue_stub(root_path='.')
+
+        self.event = Event(
+            id='2020miket',
+            event_type_enum=EventType.DISTRICT,
+            short_name='Kettering University #1',
+            name='FIM District Kettering University Event #1',
+            event_short='miket',
+            year=2020
+        )
+
+        self.team = Team(
+            id='frc7332',
+            team_number=7332
+        )
+
+        self.award = Award(
+            id=Award.render_key_name(self.event.key_name, AwardType.INDUSTRIAL_DESIGN),
+            name_str='Industrial Design Award sponsored by General Motors',
+            award_type_enum=AwardType.INDUSTRIAL_DESIGN,
+            event=self.event.key,
+            event_type_enum=EventType.DISTRICT,
+            year=2020
+        )
+
+        self.winner_award = Award(
+            id=Award.render_key_name(self.event.key_name, AwardType.WINNER),
+            name_str='District Event Winner',
+            award_type_enum=AwardType.WINNER,
+            event=self.event.key,
+            event_type_enum=EventType.DISTRICT,
+            year=2020
+        )
+
+    def tearDown(self):
+        self.testbed.deactivate()
+
+    def test_type(self):
+        notification = AwardsNotification(self.event)
+        self.assertEqual(AwardsNotification._type(), NotificationType.AWARDS)
+
+    def test_fcm_notification_event(self):
+        notification = AwardsNotification(self.event)
+        self.assertIsNotNone(notification.fcm_notification)
+        self.assertEqual(notification.fcm_notification.title, 'MIKET Awards')
+        self.assertEqual(notification.fcm_notification.body, '2020 Kettering University #1 District awards have been posted.')
+
+    def test_fcm_notification_team(self):
+        self.award.team_list = [self.team.key]
+        self.award.put()
+
+        notification = AwardsNotification(self.event, self.team)
+
+        self.assertIsNotNone(notification.fcm_notification)
+        self.assertEqual(notification.fcm_notification.title, 'Team 7332 Awards')
+        self.assertEqual(notification.fcm_notification.body, 'Team 7332 won the Industrial Design Award sponsored by General Motors at the 2020 Kettering University #1 District.')
+
+    def test_fcm_notification_team_winner(self):
+        self.winner_award.team_list = [self.team.key]
+        self.winner_award.put()
+
+        notification = AwardsNotification(self.event, self.team)
+
+        self.assertIsNotNone(notification.fcm_notification)
+        self.assertEqual(notification.fcm_notification.title, 'Team 7332 Awards')
+        self.assertEqual(notification.fcm_notification.body, 'Team 7332 is the District Event Winner at the 2020 Kettering University #1 District.')
+
+    def test_fcm_notification_team_finalist(self):
+        self.winner_award.award_type_enum=AwardType.WINNER
+        self.winner_award.name_str='District Event Finalist'
+        self.winner_award.team_list = [self.team.key]
+        self.winner_award.put()
+
+        notification = AwardsNotification(self.event, self.team)
+
+        self.assertIsNotNone(notification.fcm_notification)
+        self.assertEqual(notification.fcm_notification.title, 'Team 7332 Awards')
+        self.assertEqual(notification.fcm_notification.body, 'Team 7332 is the District Event Finalist at the 2020 Kettering University #1 District.')
+
+    def test_fcm_notification_team_multiple(self):
+        self.award.team_list = [self.team.key]
+        self.award.put()
+        self.winner_award.team_list = [self.team.key]
+        self.winner_award.put()
+
+        notification = AwardsNotification(self.event, self.team)
+
+        self.assertIsNotNone(notification.fcm_notification)
+        self.assertEqual(notification.fcm_notification.title, 'Team 7332 Awards')
+        self.assertEqual(notification.fcm_notification.body, 'Team 7332 won 2 awards at the 2020 Kettering University #1 District.')
+
+    def test_data_payload(self):
+        notification = AwardsNotification(self.event)
+        # No `event_name`
+        payload = notification.data_payload
+        self.assertEqual(len(payload), 1)
+        self.assertEqual(payload['event_key'], '2020miket')
+
+    def test_data_payload_team(self):
+        notification = AwardsNotification(self.event, self.team)
+        payload = notification.data_payload
+        self.assertEqual(len(payload), 2)
+        self.assertEqual(payload['event_key'], '2020miket')
+        self.assertEqual(payload['team_key'], 'frc7332')
+
+    def test_webhook_message_data(self):
+        self.award.put()
+        self.winner_award.put()
+
+        notification = AwardsNotification(self.event)
+
+        payload = notification.webhook_message_data
+        self.assertEqual(len(payload), 3)
+        self.assertEqual(payload['event_key'], '2020miket')
+        self.assertEqual(payload['event_name'], 'FIM District Kettering University Event #1')
+        self.assertIsNotNone(payload['awards'])
+        self.assertEqual(len(payload['awards']), 2)
+
+    def test_webhook_message_data_team(self):
+        self.award.team_list = [self.team.key]
+        self.award.put()
+
+        notification = AwardsNotification(self.event, self.team)
+
+        payload = notification.webhook_message_data
+        self.assertEqual(len(payload), 4)
+        self.assertEqual(payload['event_key'], '2020miket')
+        self.assertEqual(payload['team_key'], 'frc7332')
+        self.assertEqual(payload['event_name'], 'FIM District Kettering University Event #1')
+        self.assertIsNotNone(payload['awards'])
+        self.assertEqual(len(payload['awards']), 1)
+
+
+"""
+Renderbot 
+
+Renderbot is an advanced bot used in conjunction with the 
+designer module. It demonstrates arbitrary pattern formation.
+
+Based on the Abot, see it for some details.
+
+NOTE: The next position is defined by two existing reference
+      points in the pattern. Bots bumping into each other is an
+      issue and inaccurate positioning makes merry hell of the 
+      whole structure, causing complete breakdowns at times,
+      as failing gracefully is not always an option.
+
+"""
+
+from Kilobot import *
+
+def load(sim):
+    return Renderbot(sim)
+
+# msgs, dodge lsb
+GO = 0x8; SCATTER = 0xA; DONE = 0xC;
+# magic consts
+TURN = 19; TRIGGER = 5
+FRINGE = 67
+ANON = -1
+RXBUFSIZE = 4
+
+class Renderbot(Kilobot):
+    def __init__(self, sim):
+        Kilobot.__init__(self, sim)
+
+        self.sim = sim
+        self.id = ANON # identity
+        self.top = 0
+
+        self.mark = 0 # finish
+        self.rules = None 
+
+        self.target = 0 # orbit
+        self.tcount = 0
+        self.tvalid = False
+
+        self.spiral = 0 # spiral
+        self.scount = 0
+
+        if (self.secretID == 0): # the leader, the first violin
+            self.program = [self.activateL,
+                            self.hold
+                            ]
+        else: # others
+            self.program = [self.activate,
+                            self.get,
+                            self.doOrbit,
+                            self.doSpiral,
+                            self.doFinish,
+                            self.hold
+                            ]
+    ##
+    ## Info print hack; Simulator function override
+    ##
+    def drawinfo(self, screen): # draw position text
+        pos = self.pos.inttup()
+        text = self.font.render(
+            "%d:%s" % (self.secretID, str(self.id) if self.id >= 0 else "-"),
+            True, (0, 0, 0))
+        screen.blit(text, (pos[0] - 12, pos[1] - 2))
+
+    ##
+    ## Activation
+    ##
+     
+    def activateL(self):
+        self.id = 0
+        print "0 assumes position as 0"
+        self.debug = "S:0"
+        self.message_out(0,0,GO)
+        self.toggle_tx()
+        self.set_color(0,3,0)
+        return self.goto(self.hold)
+           
+    def activate(self):
+        self.get_message()
+        if (self.msgrx[5] == 1): # scatter
+            self.message_out(42,0,SCATTER)
+            self.enable_tx()
+            if (self.rand() % 4 == 0):
+                self.op = self.fullCW if self.op == self.fullCCW else self.fullCCW
+            self.op()
+        elif (self.rand() % 100 == 0): # start
+            self.disable_tx()
+            print self.secretID, "begins target hunt"
+            self.set_color(3,0,0)           
+            self.target = 1
+            self.debug = "T:%d" % (self.target)
+            self.getRules(self.target)
+            return self.goto(self.get)
+        else:
+            self.midFWRD()
+
+        self.PC -= 1
+
+    ##
+    ## Listen
+    ##
+
+    def get(self): 
+        isConnected = False
+        for i in range(0, RXBUFSIZE): # check all of the buffer for msgs
+            self.get_message()
+            if (self.msgrx[5] == 1):
+                isConnected = True
+                self.history_add(self.msgrx[0:4])
+            else:
+                break
+
+        self.reset_rx()
+
+        if (isConnected and self.id == ANON):
+            return self.goto(self.doOrbit)
+        elif (isConnected and self.id != ANON):
+            return self.goto(self.doFinish)
+        else:
+            return self.goto(self.doSpiral)
+
+    ##
+    ## Move
+    ##
+
+    def doSpiral(self): # spiral towards the swarm; turn, forward or finish
+        self.scount += 1
+        if (self.scount < TURN):
+            self.fullCCW()
+        elif (self.scount <= TURN + self.spiral):
+            self.midFWRD()
+        else:
+            self.scount = 0
+            self.spiral += 3
+
+        # are we by the form yet?
+        self.get_message()
+        if (self.msgrx[5] == 1):
+            self.midFWRD()
+            self.fullCCW()
+            self.scount = 0
+            self.spiral = 0
+            self.history_reset()
+            return self.goto(self.doOrbit)
+        else:            
+            self.PC -= 1       
+
+    def doOrbit(self): # follow the form gradient
+        
+        # ensure we have enough history
+        if (not self.history_full()):
+            self.fullCCW()
+            return self.goto(self.get)
+
+        # reduce and aggregate message history
+        top, dists, heard, hbins = self.history_reduce()        
+        heardR1 = self.rules[1][0] in heard
+
+        # adjust target, if necessary
+        if (top >= self.target):
+            self.target = top + 1
+            self.getRules(self.target)
+            print self.secretID, "target adjust to", self.target
+            self.debug = "T:%d" % (self.target)
+            self.tvalid = False
+            self.tcount = 0
+            return self.goto(self.get)
+
+        # decide: either follow general orbit, or start closing in
+        if (heardR1): # TODO un-NEGATE
+            rule1 = self.rules[1][0]
+            rdists = map((lambda x: x[3]), hbins[heard.index(rule1)])
+
+            # average hits the FRINGE, note: smart array
+            isValid = len(rdists) > 2 and sum(rdists)/len(rdists) == FRINGE 
+#            if (self.target > 6 and not isValid): # make a bit easier to start later on
+#                isValid = FRINGE in rdists
+#
+#            print self.secretID, rule1, rdists, isValid
+
+            if (isValid): # assume the position
+                print self.secretID, "assumes position as", self.target
+                self.id = self.target
+                self.debug = "S:%d" % (self.id)
+                self.set_color(3,0,3)        
+                return self.goto(self.doFinish)                
+                                       
+        # steering decision
+        self._steer(FRINGE, dists, 50)
+          
+        return self.goto(self.get)
+
+    def _steer(self, goal, dists, repel):
+        multi = 8
+        d = dists[0]
+        diff = d - goal
+        repels = d < repel
+        goingUp = diff < 0
+        near = 0*multi <= abs(diff) < 1*multi
+        far1 = 1*multi <= abs(diff) < 2*multi
+        far2 = 2*multi <= abs(diff) < 3*multi
+        far3 = 3*multi <= abs(diff) < 4*multi
+        far4 = 4*multi <= abs(diff) < 5*multi # 32 <= d < 40
+        avg = sum(dists)/len(dists)
+
+        # we are near our goal
+        if (goal < d <= goal + multi):
+            self.fullCCW()
+            self.fullCCW()          
+        elif (d == goal):
+            self.midFWRD()
+        elif (goal - multi <= d < goal):
+            self.fullCW() 
+            self.fullCW() 
+
+        # we are too close
+        elif (repels):
+            self.fullCW()
+
+        # we are !near
+        elif (far1):
+            self.midFWRD()
+            self.op = self.fullCW if goingUp else self.fullCCW
+            self.op()
+        elif (far2): # going down
+            self.midFWRD()
+            self.op = self.fullCW if goingUp else self.fullCCW
+            if (self.rand() % 5 == 0):
+                self.op()
+        elif (far3):
+            self.midFWRD()
+            self.op = self.fullCW if goingUp else self.fullCCW
+            if (self.rand() % 10 == 0 or avg == d):
+                self.op()
+        elif (far4):
+            self.midFWRD()
+            self.op = self.fullCW if goingUp else self.fullCCW
+            if (self.rand() % 20 == 0 or avg == d):
+                self.op()
+
+
+    # NOTE: custom pattern; 
+    def getRules(self, target):
+        rules = self.sim.config['form']['rules'] # ask the simulation for the rules
+
+        if (target == 0): # never used, merely for human readability
+            print "ERROR: someone requested rules for target 0"
+            exit(-42)
+            self.rules = [0, (0, 00), (0, 00), 0]
+        else:
+            self.rules = rules[target - 1]
+        
+
+    def _forfeit(self):
+        print self.secretID, "forfeits position as", self.id
+        self.mark = 0
+        self.target = 0
+        self.tcount = 0
+        self.id = ANON
+        self.set_color(3,0,0)
+        self.disable_tx()        
+
+    # TODO: proper maintenance procedure
+    # the last mms are the hardest
+    def doFinish(self):
+        # reduce and aggregate message history
+        top, dists, heard, hbins = self.history_reduce()        
+       
+        # if denied, reset and restart
+        if (top >= self.id):
+            self._forfeit()
+            return self.goto(self.get)
+
+        heardR1 = self.rules[1][0] in heard
+        heardR2 = self.rules[2][0] in heard
+        r1bin = r2bin = None
+        heardR1bound = heardR2bound = False
+        if (heardR1):
+            r1bin = map((lambda x: x[3]), hbins[heard.index(self.rules[1][0])])
+            heardR1bound = self.rules[1][1] in r1bin
+        if (heardR2):            
+            r2bin = map((lambda x: x[3]), hbins[heard.index(self.rules[2][0])])
+            heardR2bound = self.rules[2][1] in r2bin
+                  
+        # done when second is reached (or when we want to be the first violin)
+        if ((self.mark == 1 and heardR2bound) or (heardR1bound and self.id == 1)):
+            self.top = self.id
+            if (self.id == self.secretN - 1):
+                self.message_out(self.id, self.id, DONE)
+                self.set_color(0,3,0)        
+            else:
+                self.message_out(self.id, self.id, GO)
+                self.set_color(0,0,3)
+            self.enable_tx()
+            return self.goto(self.hold)
+        elif (heardR1): # otherwise follow first
+            if (heardR1bound):
+                self.mark = 1
+            r1bin = map((lambda x: x[3]), hbins[heard.index(self.rules[1][0])])
+            # steering
+            self._steer(self.rules[1][1], r1bin, 0)
+                    
+        elif (self.rand() % 100 == 0):
+            self._forfeit()
+            return self.goto(self.get)
+            
+        return self.goto(self.get)
+
+
+    def hold(self):
+        self.PC -= 1
+        self.get_message()
+        if (self.msgrx[5] == 1):
+
+            heard = self.msgrx[0]
+            top   = self.msgrx[1]
+            mode  = self.msgrx[2]
+            dist  = self.msgrx[3]
+
+            if (top > self.top): # to help others, all of the swarm shouts the top
+                self.top = top
+                self.message_out(self.id, self.top, mode)
+
+            if (mode == DONE): # finish trigger
+                self.enable_tx()
+                self.message_out(self.id, self.top, DONE)
+                self.set_color(0,3,0)
+
+            self.reset_rx()
+
+# Copyright (c) Twisted Matrix Laboratories.
+# See LICENSE for details.
+
+"""
+Checker for common errors in Lore documents.
+"""
+
+from xml.dom import minidom as dom
+import parser
+import urlparse
+import os.path
+
+from twisted.lore import tree, process
+from twisted.web import domhelpers
+from twisted.python import reflect
+from twisted.python.versions import Version
+from twisted.python.deprecate import deprecatedModuleAttribute
+
+
+parserErrors = (SyntaxError,)
+deprecatedModuleAttribute(
+    Version("Twisted", 13, 1, 0),
+    "parserErrors is deprecated",
+    __name__,
+    "parserErrors")
+
+
+class TagChecker:
+
+    def check(self, dom, filename):
+        self.hadErrors = 0
+        for method in reflect.prefixedMethods(self, 'check_'):
+            method(dom, filename)
+        if self.hadErrors:
+            raise process.ProcessingFailure("invalid format")
+
+    def _reportError(self, filename, element, error):
+        hlint = element.hasAttribute('hlint') and element.getAttribute('hlint')
+        if hlint != 'off':
+            self.hadErrors = 1
+            pos = getattr(element, '_markpos', None) or (0, 0)
+            print "%s:%s:%s: %s" % ((filename,)+pos+(error,))
+
+
+class DefaultTagChecker(TagChecker):
+
+    def __init__(self, allowedTags, allowedClasses):
+        self.allowedTags = allowedTags
+        self.allowedClasses = allowedClasses
+
+    def check_disallowedElements(self, dom, filename):
+        def m(node, self=self):
+            return not self.allowedTags(node.tagName)
+        for element in domhelpers.findElements(dom, m):
+            self._reportError(filename, element,
+                               'unrecommended tag %s' % element.tagName)
+
+    def check_disallowedClasses(self, dom, filename):
+        def matcher(element, self=self):
+            if not element.hasAttribute('class'):
+                return 0
+            checker = self.allowedClasses.get(element.tagName, lambda x:0)
+            return not checker(element.getAttribute('class'))
+        for element in domhelpers.findElements(dom, matcher):
+            self._reportError(filename, element,
+                              'unknown class %s' %element.getAttribute('class'))
+
+    def check_quote(self, doc, filename):
+        def matcher(node):
+            return ('"' in getattr(node, 'data', '') and
+                    not isinstance(node, dom.Comment) and
+                    not  [1 for n in domhelpers.getParents(node)[1:-1]
+                           if n.tagName in ('pre', 'code')])
+        for node in domhelpers.findNodes(doc, matcher):
+            self._reportError(filename, node.parentNode, 'contains quote')
+
+    def check_styleattr(self, dom, filename):
+        for node in domhelpers.findElementsWithAttribute(dom, 'style'):
+            self._reportError(filename, node, 'explicit style')
+
+    def check_align(self, dom, filename):
+        for node in domhelpers.findElementsWithAttribute(dom, 'align'):
+            self._reportError(filename, node, 'explicit alignment')
+
+    def check_style(self, dom, filename):
+        for node in domhelpers.findNodesNamed(dom, 'style'):
+            if domhelpers.getNodeText(node) != '':
+                self._reportError(filename, node, 'hand hacked style')
+
+    def check_title(self, dom, filename):
+        doc = dom.documentElement
+        title = domhelpers.findNodesNamed(dom, 'title')
+        if len(title)!=1:
+            return self._reportError(filename, doc, 'not exactly one title')
+        h1 = domhelpers.findNodesNamed(dom, 'h1')
+        if len(h1)!=1:
+            return self._reportError(filename, doc, 'not exactly one h1')
+        if domhelpers.getNodeText(h1[0]) != domhelpers.getNodeText(title[0]):
+            self._reportError(filename, h1[0], 'title and h1 text differ')
+
+    def check_80_columns(self, dom, filename):
+        for node in domhelpers.findNodesNamed(dom, 'pre'):
+            # the ps/pdf output is in a font that cuts off at 80 characters,
+            # so this is enforced to make sure the interesting parts (which
+            # are likely to be on the right-hand edge) stay on the printed
+            # page.
+            for line in domhelpers.gatherTextNodes(node, 1).split('\n'):
+                if len(line.rstrip()) > 80:
+                    self._reportError(filename, node,
+                                      'text wider than 80 columns in pre')
+        for node in domhelpers.findNodesNamed(dom, 'a'):
+            if node.getAttribute('class').endswith('listing'):
+                try:
+                    fn = os.path.dirname(filename)
+                    fn = os.path.join(fn, node.getAttribute('href'))
+                    lines = open(fn,'r').readlines()
+                except:
+                    self._reportError(filename, node,
+                                      'bad listing href: %r' %
+                                      node.getAttribute('href'))
+                    continue
+
+                for line in lines:
+                    if len(line.rstrip()) > 80:
+                        self._reportError(filename, node,
+                                          'listing wider than 80 columns')
+
+    def check_pre_py_listing(self, dom, filename):
+        for node in domhelpers.findNodesNamed(dom, 'pre'):
+            if node.getAttribute('class') == 'python':
+                try:
+                    text = domhelpers.getNodeText(node)
+                    # Fix < and >
+                    text = text.replace('&gt;', '>').replace('&lt;', '<')
+                    # Strip blank lines
+                    lines = filter(None,[l.rstrip() for l in text.split('\n')])
+                    # Strip leading space
+                    while not [1 for line in lines if line[:1] not in ('',' ')]:
+                        lines = [line[1:] for line in lines]
+                    text = '\n'.join(lines) + '\n'
+                    try:
+                        parser.suite(text)
+                    except SyntaxError:
+                        # Pretend the "..." idiom is syntactically valid
+                        text = text.replace("...","'...'")
+                        parser.suite(text)
+                except SyntaxError as e:
+                    self._reportError(filename, node,
+                                      'invalid python code:' + str(e))
+
+    def check_anchor_in_heading(self, dom, filename):
+        headingNames = ['h%d' % n for n in range(1,7)]
+        for hname in headingNames:
+            for node in domhelpers.findNodesNamed(dom, hname):
+                if domhelpers.findNodesNamed(node, 'a'):
+                    self._reportError(filename, node, 'anchor in heading')
+
+    def check_texturl_matches_href(self, dom, filename):
+        for node in domhelpers.findNodesNamed(dom, 'a'):
+            if not node.hasAttribute('href'):
+                continue
+            text = domhelpers.getNodeText(node)
+            proto = urlparse.urlparse(text)[0]
+            if proto and ' ' not in text:
+                if text != node.getAttribute('href'):
+                    self._reportError(filename, node,
+                                      'link text does not match href')
+
+    def check_lists(self, dom, filename):
+        for node in (domhelpers.findNodesNamed(dom, 'ul')+
+                     domhelpers.findNodesNamed(dom, 'ol')):
+            if not node.childNodes:
+                self._reportError(filename, node, 'empty list')
+            for child in node.childNodes:
+                if child.nodeName != 'li':
+                    self._reportError(filename, node,
+                                      'only list items allowed in lists')
+
+
+def list2dict(l):
+    d = {}
+    for el in l:
+        d[el] = None
+    return d
+
+classes = list2dict(['shell', 'API', 'python', 'py-prototype', 'py-filename',
+                     'py-src-string', 'py-signature', 'py-src-parameter',
+                     'py-src-identifier', 'py-src-keyword'])
+
+tags = list2dict(["html", "title", "head", "body", "h1", "h2", "h3", "ol", "ul",
+                  "dl", "li", "dt", "dd", "p", "code", "img", "blockquote", "a",
+                  "cite", "div", "span", "strong", "em", "pre", "q", "table",
+                  "tr", "td", "th", "style", "sub", "sup", "link"])
+
+span = list2dict(['footnote', 'manhole-output', 'index'])
+
+div = list2dict(['note', 'boxed', 'doit'])
+
+a = list2dict(['listing', 'py-listing', 'html-listing', 'absolute'])
+
+pre = list2dict(['python', 'shell', 'python-interpreter', 'elisp'])
+
+allowed = {'code': classes.has_key, 'span': span.has_key, 'div': div.has_key,
+           'a': a.has_key, 'pre': pre.has_key, 'ul': lambda x: x=='toc',
+           'ol': lambda x: x=='toc', 'li': lambda x: x=='ignoretoc'}
+
+def getDefaultChecker():
+    return DefaultTagChecker(tags.__contains__, allowed)
+
+def doFile(file, checker):
+    doc = tree.parseFileAndReport(file)
+    if doc:
+        checker.check(doc, file)
+
+#!/usr/bin/env python
+# Copyright (c) 2012 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+  Invokes git diff [args...] and inserts file:line in front of each line of diff
+  output where possible.
+
+  This is useful from an IDE that allows you to double-click lines that begin
+  with file:line to open and jump to that point in the file.
+
+Synopsis:
+  %prog [git diff args...]
+
+Examples:
+  %prog
+  %prog HEAD
+"""
+
+import subprocess
+import sys
+
+
+def GitShell(args, ignore_return=False):
+  """A shell invocation suitable for communicating with git. Returns
+  output as list of lines, raises exception on error.
+  """
+  job = subprocess.Popen(args,
+                         shell=True,
+                         stdout=subprocess.PIPE,
+                         stderr=subprocess.STDOUT)
+  (out, err) = job.communicate()
+  if job.returncode != 0 and not ignore_return:
+    print out
+    raise Exception("Error %d running command %s" % (
+        job.returncode, args))
+  return out.split('\n')
+
+
+def PrintGitDiff(extra_args):
+  """Outputs git diff extra_args with file:line inserted into relevant lines."""
+  current_file = '';
+  line_num = 0;
+  lines = GitShell('git diff %s' % ' '.join(extra_args))
+  for line in lines:
+    # Pass-through lines:
+    #  diff --git a/file.c b/file.c
+    #  index 0e38c2d..8cd69ae 100644
+    #  --- a/file.c
+    if (line.startswith('diff ') or
+        line.startswith('index ') or
+        line.startswith('--- ')):
+      print line
+      continue
+
+    # Get the filename from the +++ line:
+    #  +++ b/file.c
+    if line.startswith('+++ '):
+      # Filename might be /dev/null or a/file or b/file.
+      # Skip the first two characters unless it starts with /.
+      current_file = line[4:] if line[4] == '/' else line[6:]
+      print line
+      continue
+
+    # Update line number from the @@ lines:
+    #  @@ -41,9 +41,9 @@ def MyFunc():
+    #            ^^
+    if line.startswith('@@ '):
+      _, old_nr, new_nr, _ = line.split(' ', 3)
+      line_num = int(new_nr.split(',')[0])
+      print line
+      continue
+    print current_file + ':' + repr(line_num) + ':' + line
+
+    # Increment line number for lines that start with ' ' or '+':
+    #  @@ -41,4 +41,4 @@ def MyFunc():
+    #  file.c:41: // existing code
+    #  file.c:42: // existing code
+    #  file.c:43:-// deleted code
+    #  file.c:43:-// deleted code
+    #  file.c:43:+// inserted code
+    #  file.c:44:+// inserted code
+    if line.startswith(' ') or line.startswith('+'):
+      line_num += 1
+
+
+def main():
+  PrintGitDiff(sys.argv[1:])
+
+
+if __name__ == '__main__':
+  main()
+
+########################################################################
+#
+# (C) 2015, Chris Houseknecht <chouse@ansible.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+########################################################################
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import base64
+import os
+import json
+from stat import S_IRUSR, S_IWUSR
+
+import yaml
+
+from ansible import constants as C
+from ansible.galaxy.user_agent import user_agent
+from ansible.module_utils._text import to_bytes, to_native, to_text
+from ansible.module_utils.urls import open_url
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class NoTokenSentinel(object):
+    """ Represents an ansible.cfg server with not token defined (will ignore cmdline and GALAXY_TOKEN_PATH. """
+    def __new__(cls, *args, **kwargs):
+        return cls
+
+
+class KeycloakToken(object):
+    '''A token granted by a Keycloak server.
+
+    Like sso.redhat.com as used by cloud.redhat.com
+    ie Automation Hub'''
+
+    token_type = 'Bearer'
+
+    def __init__(self, access_token=None, auth_url=None, validate_certs=True):
+        self.access_token = access_token
+        self.auth_url = auth_url
+        self._token = None
+        self.validate_certs = validate_certs
+
+    def _form_payload(self):
+        return 'grant_type=refresh_token&client_id=cloud-services&refresh_token=%s' % self.access_token
+
+    def get(self):
+        if self._token:
+            return self._token
+
+        # - build a request to POST to auth_url
+        #  - body is form encoded
+        #    - 'request_token' is the offline token stored in ansible.cfg
+        #    - 'grant_type' is 'refresh_token'
+        #    - 'client_id' is 'cloud-services'
+        #       - should probably be based on the contents of the
+        #         offline_ticket's JWT payload 'aud' (audience)
+        #         or 'azp' (Authorized party - the party to which the ID Token was issued)
+        payload = self._form_payload()
+
+        resp = open_url(to_native(self.auth_url),
+                        data=payload,
+                        validate_certs=self.validate_certs,
+                        method='POST',
+                        http_agent=user_agent())
+
+        # TODO: handle auth errors
+
+        data = json.loads(to_text(resp.read(), errors='surrogate_or_strict'))
+
+        # - extract 'access_token'
+        self._token = data.get('access_token')
+
+        return self._token
+
+    def headers(self):
+        headers = {}
+        headers['Authorization'] = '%s %s' % (self.token_type, self.get())
+        return headers
+
+
+class GalaxyToken(object):
+    ''' Class to storing and retrieving local galaxy token '''
+
+    token_type = 'Token'
+
+    def __init__(self, token=None):
+        self.b_file = to_bytes(C.GALAXY_TOKEN_PATH, errors='surrogate_or_strict')
+        # Done so the config file is only opened when set/get/save is called
+        self._config = None
+        self._token = token
+
+    @property
+    def config(self):
+        if self._config is None:
+            self._config = self._read()
+
+        # Prioritise the token passed into the constructor
+        if self._token:
+            self._config['token'] = None if self._token is NoTokenSentinel else self._token
+
+        return self._config
+
+    def _read(self):
+        action = 'Opened'
+        if not os.path.isfile(self.b_file):
+            # token file not found, create and chomd u+rw
+            open(self.b_file, 'w').close()
+            os.chmod(self.b_file, S_IRUSR | S_IWUSR)  # owner has +rw
+            action = 'Created'
+
+        with open(self.b_file, 'r') as f:
+            config = yaml.safe_load(f)
+
+        display.vvv('%s %s' % (action, to_text(self.b_file)))
+
+        return config or {}
+
+    def set(self, token):
+        self._token = token
+        self.save()
+
+    def get(self):
+        return self.config.get('token', None)
+
+    def save(self):
+        with open(self.b_file, 'w') as f:
+            yaml.safe_dump(self.config, f, default_flow_style=False)
+
+    def headers(self):
+        headers = {}
+        token = self.get()
+        if token:
+            headers['Authorization'] = '%s %s' % (self.token_type, self.get())
+        return headers
+
+
+class BasicAuthToken(object):
+    token_type = 'Basic'
+
+    def __init__(self, username, password=None):
+        self.username = username
+        self.password = password
+        self._token = None
+
+    @staticmethod
+    def _encode_token(username, password):
+        token = "%s:%s" % (to_text(username, errors='surrogate_or_strict'),
+                           to_text(password, errors='surrogate_or_strict', nonstring='passthru') or '')
+        b64_val = base64.b64encode(to_bytes(token, encoding='utf-8', errors='surrogate_or_strict'))
+        return to_text(b64_val)
+
+    def get(self):
+        if self._token:
+            return self._token
+
+        self._token = self._encode_token(self.username, self.password)
+
+        return self._token
+
+    def headers(self):
+        headers = {}
+        headers['Authorization'] = '%s %s' % (self.token_type, self.get())
+        return headers
+
+from __future__ import unicode_literals
+
+from django.db import connection, models
+from django.db.backends.utils import truncate_name
+from django.test import TestCase
+
+from .models.article import Article, Site
+from .models.publication import Publication
+
+
+class Advertisement(models.Model):
+    customer = models.CharField(max_length=100)
+    publications = models.ManyToManyField("model_package.Publication", blank=True)
+
+
+class ModelPackageTests(TestCase):
+
+    def test_m2m_tables_in_subpackage_models(self):
+        """
+        Regression for #12168: models split into subpackages still get M2M
+        tables.
+        """
+        p = Publication.objects.create(title="FooBar")
+
+        site = Site.objects.create(name="example.com")
+
+        a = Article.objects.create(headline="a foo headline")
+        a.publications.add(p)
+        a.sites.add(site)
+
+        a = Article.objects.get(id=a.pk)
+        self.assertEqual(a.id, a.pk)
+        self.assertEqual(a.sites.count(), 1)
+
+    def test_models_in_the_test_package(self):
+        """
+        Regression for #12245 - Models can exist in the test package, too.
+        """
+        p = Publication.objects.create(title="FooBar")
+        ad = Advertisement.objects.create(customer="Lawrence Journal-World")
+        ad.publications.add(p)
+
+        ad = Advertisement.objects.get(id=ad.pk)
+        self.assertEqual(ad.publications.count(), 1)
+
+    def test_automatic_m2m_column_names(self):
+        """
+        Regression for #12386 - field names on the autogenerated intermediate
+        class that are specified as dotted strings don't retain any path
+        component for the field or column name.
+        """
+        self.assertEqual(
+            Article.publications.through._meta.fields[1].name, 'article'
+        )
+        self.assertEqual(
+            Article.publications.through._meta.fields[1].get_attname_column(),
+            ('article_id', 'article_id')
+        )
+        self.assertEqual(
+            Article.publications.through._meta.fields[2].name, 'publication'
+        )
+        self.assertEqual(
+            Article.publications.through._meta.fields[2].get_attname_column(),
+            ('publication_id', 'publication_id')
+        )
+
+        self.assertEqual(
+            Article._meta.get_field('publications').m2m_db_table(),
+            truncate_name('model_package_article_publications', connection.ops.max_name_length()),
+        )
+
+        self.assertEqual(
+            Article._meta.get_field('publications').m2m_column_name(), 'article_id'
+        )
+        self.assertEqual(
+            Article._meta.get_field('publications').m2m_reverse_name(),
+            'publication_id'
+        )
+
+from __future__ import unicode_literals, with_statement
+import re
+import os
+import subprocess
+
+from django.utils.encoding import smart_str
+from django.core.files.temp import NamedTemporaryFile
+
+from sorl.thumbnail.base import EXTENSIONS
+from sorl.thumbnail.compat import b
+from sorl.thumbnail.conf import settings
+from sorl.thumbnail.engines.base import EngineBase
+from sorl.thumbnail.compat import OrderedDict
+
+
+size_re = re.compile(r'^(?:.+) (?:[A-Z]+) (?P<x>\d+)x(?P<y>\d+)')
+
+
+class Engine(EngineBase):
+    """
+    Image object is a dict with source path, options and size
+    """
+
+    def write(self, image, options, thumbnail):
+        """
+        Writes the thumbnail image
+        """
+        if options['format'] == 'JPEG' and options.get(
+                'progressive', settings.THUMBNAIL_PROGRESSIVE):
+            image['options']['interlace'] = 'line'
+
+        image['options']['quality'] = options['quality']
+
+        args = settings.THUMBNAIL_CONVERT.split(' ')
+        args.append(image['source'] + '[0]')
+
+        for k in image['options']:
+            v = image['options'][k]
+            args.append('-%s' % k)
+            if v is not None:
+                args.append('%s' % v)
+
+        flatten = "on"
+        if 'flatten' in options:
+            flatten = options['flatten']
+
+        if settings.THUMBNAIL_FLATTEN and not flatten == "off":
+            args.append('-flatten')
+
+        suffix = '.%s' % EXTENSIONS[options['format']]
+
+        with NamedTemporaryFile(suffix=suffix, mode='rb') as fp:
+            args.append(fp.name)
+            args = map(smart_str, args)
+            p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            p.wait()
+            out, err = p.communicate()
+
+            if err:
+                raise Exception(err)
+
+            thumbnail.write(fp.read())
+
+    def cleanup(self, image):
+        os.remove(image['source'])  # we should not need this now
+
+    def get_image(self, source):
+        """
+        Returns the backend image objects from a ImageFile instance
+        """
+        with NamedTemporaryFile(mode='wb', delete=False) as fp:
+            fp.write(source.read())
+        return {'source': fp.name, 'options': OrderedDict(), 'size': None}
+
+    def get_image_size(self, image):
+        """
+        Returns the image width and height as a tuple
+        """
+        if image['size'] is None:
+            args = settings.THUMBNAIL_IDENTIFY.split(' ')
+            args.append(image['source'])
+            p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            p.wait()
+            m = size_re.match(str(p.stdout.read()))
+            image['size'] = int(m.group('x')), int(m.group('y'))
+        return image['size']
+
+    def is_valid_image(self, raw_data):
+        """
+        This is not very good for imagemagick because it will say anything is
+        valid that it can use as input.
+        """
+        with NamedTemporaryFile(mode='wb') as fp:
+            fp.write(raw_data)
+            fp.flush()
+            args = settings.THUMBNAIL_IDENTIFY.split(' ')
+            args.append(fp.name)
+            p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            retcode = p.wait()
+        return retcode == 0
+
+    def _orientation(self, image):
+        # return image
+        # XXX need to get the dimensions right after a transpose.
+
+        if settings.THUMBNAIL_CONVERT.endswith('gm convert'):
+            args = settings.THUMBNAIL_IDENTIFY.split()
+            args.extend(['-format', '%[exif:orientation]', image['source']])
+            p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            p.wait()
+            result = p.stdout.read().strip()
+            if result and result != b('unknown'):
+                result = int(result)
+                options = image['options']
+                if result == 2:
+                    options['flop'] = None
+                elif result == 3:
+                    options['rotate'] = '180'
+                elif result == 4:
+                    options['flip'] = None
+                elif result == 5:
+                    options['rotate'] = '90'
+                    options['flop'] = None
+                elif result == 6:
+                    options['rotate'] = '90'
+                elif result == 7:
+                    options['rotate'] = '-90'
+                    options['flop'] = None
+                elif result == 8:
+                    options['rotate'] = '-90'
+        else:
+            # ImageMagick also corrects the orientation exif data for
+            # destination
+            image['options']['auto-orient'] = None
+        return image
+
+    def _colorspace(self, image, colorspace):
+        """
+        `Valid colorspaces
+        <http://www.graphicsmagick.org/GraphicsMagick.html#details-colorspace>`_.
+        Backends need to implement the following::
+            RGB, GRAY
+        """
+        image['options']['colorspace'] = colorspace
+        return image
+
+    def _crop(self, image, width, height, x_offset, y_offset):
+        """
+        Crops the image
+        """
+        image['options']['crop'] = '%sx%s+%s+%s' % (width, height, x_offset, y_offset)
+        image['size'] = (width, height)  # update image size
+        return image
+
+    def _scale(self, image, width, height):
+        """
+        Does the resizing of the image
+        """
+        image['options']['scale'] = '%sx%s!' % (width, height)
+        image['size'] = (width, height)  # update image size
+        return image
+
+    def _padding(self, image, geometry, options):
+        """
+        Pads the image
+        """
+        # The order is important. The gravity option should come before extent.
+        image['options']['background'] = options.get('padding_color')
+        image['options']['gravity'] = 'center'
+        image['options']['extent'] = '%sx%s' % (geometry[0], geometry[1])
+        return image
+
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import os
+import socket
+import time
+import urllib
+import subprocess
+import signal
+
+
+SERVER_ADDR = "localhost"
+DEFAULT_PORT = 4444
+
+SERVER_PATH = "build/java/server/src/org/openqa/grid/selenium/selenium-standalone.jar"
+
+def start_server(module):
+    _socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    url = "http://%s:%d/wd/hub" % (SERVER_ADDR, DEFAULT_PORT)
+    try:
+        _socket.connect((SERVER_ADDR, DEFAULT_PORT))
+        print("The remote driver server is already running or something else"
+               "is using port %d, continuing..." % DEFAULT_PORT)
+    except:
+        print("Starting the remote driver server")
+        module.server_proc = subprocess.Popen(
+            "java -jar %s" % SERVER_PATH,
+            shell=True)
+
+        assert wait_for_server(url, 10), "can't connect"
+        print("Server should be online")
+
+def wait_for_server(url, timeout):
+    start = time.time()
+    while time.time() - start < timeout:
+        try:
+            urllib.urlopen(url)
+            return 1
+        except IOError:
+            time.sleep(0.2)
+
+    return 0
+
+def stop_server(module):
+# FIXME: This does not seem to work, the server process lingers
+    try:
+        os.kill(module.server_proc.pid, signal.SIGTERM)
+        time.sleep(5)
+    except:
+        pass
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+from socorro.lib.transform_rules import Rule
+
+
+#==============================================================================
+class IdentifierRule(Rule):
+    #--------------------------------------------------------------------------
+    def version(self):
+        return '1.0'
+
+    #--------------------------------------------------------------------------
+    def _action(self, raw_crash, raw_dumps, processed_crash, processor_meta):
+
+        processed_crash.crash_id = raw_crash.uuid
+        processed_crash.uuid = raw_crash.uuid
+
+        return True
+
+
+#==============================================================================
+class CPUInfoRule(Rule):
+    #--------------------------------------------------------------------------
+    def version(self):
+        return '1.0'
+
+    #--------------------------------------------------------------------------
+    def _action(self, raw_crash, raw_dumps, processed_crash, processor_meta):
+
+        processed_crash.cpu_info = ''
+        processed_crash.cpu_name = ''
+        try:
+            processed_crash.cpu_info = (
+                '%s | %s' % (
+                    processed_crash.json_dump['system_info']['cpu_info'],
+                    processed_crash.json_dump['system_info']['cpu_count']
+                )
+            )
+        except KeyError:
+            # cpu_count is likely missing
+            processed_crash.cpu_info = (
+                processed_crash.json_dump['system_info']['cpu_info']
+            )
+        processed_crash.cpu_name = (
+            processed_crash.json_dump['system_info']['cpu_arch']
+        )
+
+        return True
+
+
+#==============================================================================
+class OSInfoRule(Rule):
+    #--------------------------------------------------------------------------
+    def version(self):
+        return '1.0'
+
+    #--------------------------------------------------------------------------
+    def _action(self, raw_crash, raw_dumps, processed_crash, processor_meta):
+        processed_crash.os_name = ''
+        processed_crash.os_version = ''
+        processed_crash.os_name = (
+            processed_crash.json_dump['system_info']['os'].strip()
+        )
+        processed_crash.os_version = (
+            processed_crash.json_dump['system_info']['os_ver'].strip()
+        )
+
+        return True
+
+
+
+# -*- coding: utf-8 -*-
+# Generated by Finn Stutzenstein on 2018-07-13 12:43 :)
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+from openslides.core.config import config
+
+
+def logos_available_default_to_database(apps, schema_editor):
+    """
+    Writes the new default value of the 'logos_available' into the database.
+    """
+    ConfigStore = apps.get_model("core", "ConfigStore")
+
+    try:
+        logos_available = ConfigStore.objects.get(key="logos_available")
+    except ConfigStore.DoesNotExist:
+        return  # The key is not in the database, nothing to change here
+
+    default_value = config.config_variables["logos_available"].default_value
+    logos_available.value = default_value
+    logos_available.save()
+
+
+def move_old_logo_settings(apps, schema_editor):
+    """
+    moves the value of 'logo_pdf_header' to 'logo_pdf_header_L' and the same
+    for the footer. The old ones are deleted.
+    """
+    ConfigStore = apps.get_model("core", "ConfigStore")
+
+    for place in ("header", "footer"):
+        try:
+            logo_pdf = ConfigStore.objects.get(key=f"logo_pdf_{place}")
+        except ConfigStore.DoesNotExist:
+            continue  # The old entry is not in the database, nothing to change here
+
+        # The key of the new entry
+        new_value_key = f"logo_pdf_{place}_L"
+        try:
+            logo_pdf_L = ConfigStore.objects.get(key=new_value_key)
+        except ConfigStore.DoesNotExist:
+            logo_pdf_L = ConfigStore(key=new_value_key)
+            logo_pdf_L.value = {}
+
+        # Move the path to the new configentry
+        logo_pdf_L.value["path"] = logo_pdf.value.get("path", "")
+        # Save the new one, delete the old
+        logo_pdf_L.save()
+        logo_pdf.delete()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [("core", "0007_auto_20180130_1400")]
+
+    operations = [
+        migrations.RunPython(logos_available_default_to_database),
+        migrations.RunPython(move_old_logo_settings),
+    ]
+
+# base classes for virtualization facts
+# -*- coding: utf-8 -*-
+#
+# This file is part of Ansible
+#
+# Ansible 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 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible.module_utils.facts.collector import BaseFactCollector
+
+
+class Virtual:
+    """
+    This is a generic Virtual subclass of Facts.  This should be further
+    subclassed to implement per platform.  If you subclass this,
+    you should define:
+    - virtualization_type
+    - virtualization_role
+    - container (e.g. solaris zones, freebsd jails, linux containers)
+
+    All subclasses MUST define platform.
+    """
+    platform = 'Generic'
+
+    # FIXME: remove load_on_init if we can
+    def __init__(self, module, load_on_init=False):
+        self.module = module
+
+    # FIXME: just here for existing tests cases till they are updated
+    def populate(self, collected_facts=None):
+        virtual_facts = self.get_virtual_facts()
+
+        return virtual_facts
+
+    def get_virtual_facts(self):
+        virtual_facts = {'virtualization_type': '',
+                         'virtualization_role': ''}
+        return virtual_facts
+
+
+class VirtualCollector(BaseFactCollector):
+    name = 'virtual'
+    _fact_class = Virtual
+    _fact_ids = set(['virtualization_type',
+                     'virtualization_role'])
+
+    def collect(self, module=None, collected_facts=None):
+        collected_facts = collected_facts or {}
+        if not module:
+            return {}
+
+        # Network munges cached_facts by side effect, so give it a copy
+        facts_obj = self._fact_class(module)
+
+        facts_dict = facts_obj.populate(collected_facts=collected_facts)
+
+        return facts_dict
+
+"""
+NOTE: Anytime a `key` is passed into a function here, we assume it's a raw byte
+string. It should *not* be a string representation of a hex value. In other
+words, passing the `str` value of
+`"32fe72aaf2abb44de9e161131b5435c8d37cbdb6f5df242ae860b283115f2dae"` is bad.
+You want to pass in the result of calling .decode('hex') on that, so this instead:
+"'2\xfer\xaa\xf2\xab\xb4M\xe9\xe1a\x13\x1bT5\xc8\xd3|\xbd\xb6\xf5\xdf$*\xe8`\xb2\x83\x11_-\xae'"
+
+The RSA functions take any key format that RSA.importKey() accepts, so...
+
+An RSA public key can be in any of the following formats:
+* X.509 subjectPublicKeyInfo DER SEQUENCE (binary or PEM encoding)
+* PKCS#1 RSAPublicKey DER SEQUENCE (binary or PEM encoding)
+* OpenSSH (textual public key only)
+
+An RSA private key can be in any of the following formats:
+* PKCS#1 RSAPrivateKey DER SEQUENCE (binary or PEM encoding)
+* PKCS#8 PrivateKeyInfo DER SEQUENCE (binary or PEM encoding)
+* OpenSSH (textual public key only)
+
+In case of PEM encoding, the private key can be encrypted with DES or 3TDES
+according to a certain pass phrase. Only OpenSSL-compatible pass phrases are
+supported.
+"""
+from hashlib import md5, sha256
+import base64
+import binascii
+import hmac
+import logging
+
+from Crypto import Random
+from Crypto.Cipher import AES, PKCS1_OAEP
+from Crypto.PublicKey import RSA
+
+log = logging.getLogger(__name__)
+
+
+def encrypt_and_encode(data, key):
+    """ Encrypts and endcodes `data` using `key' """
+    return base64.urlsafe_b64encode(aes_encrypt(data, key))
+
+
+def decode_and_decrypt(encoded_data, key):
+    """ Decrypts and decodes `data` using `key' """
+    return aes_decrypt(base64.urlsafe_b64decode(encoded_data), key)
+
+
+def aes_encrypt(data, key):
+    """
+    Return a version of the `data` that has been encrypted to
+    """
+    cipher = aes_cipher_from_key(key)
+    padded_data = pad(data)
+    return cipher.encrypt(padded_data)
+
+
+def aes_decrypt(encrypted_data, key):
+    """
+    Decrypt `encrypted_data` using `key`
+    """
+    cipher = aes_cipher_from_key(key)
+    padded_data = cipher.decrypt(encrypted_data)
+    return unpad(padded_data)
+
+
+def aes_cipher_from_key(key):
+    """
+    Given an AES key, return a Cipher object that has `encrypt()` and
+    `decrypt()` methods. It will create the cipher to use CBC mode, and create
+    the initialization vector as Software Secure expects it.
+    """
+    return AES.new(key, AES.MODE_CBC, generate_aes_iv(key))
+
+
+def generate_aes_iv(key):
+    """
+    Return the initialization vector Software Secure expects for a given AES
+    key (they hash it a couple of times and take a substring).
+    """
+    return md5(key + md5(key).hexdigest()).hexdigest()[:AES.block_size]
+
+
+def random_aes_key():
+    return Random.new().read(32)
+
+
+def pad(data):
+    """ Pad the given `data` such that it fits into the proper AES block size """
+    bytes_to_pad = AES.block_size - len(data) % AES.block_size
+    return data + (bytes_to_pad * chr(bytes_to_pad))
+
+
+def unpad(padded_data):
+    """  remove all padding from `padded_data` """
+    num_padded_bytes = ord(padded_data[-1])
+    return padded_data[:-num_padded_bytes]
+
+
+def rsa_encrypt(data, rsa_pub_key_str):
+    """
+    `rsa_pub_key` is a string with the public key
+    """
+    key = RSA.importKey(rsa_pub_key_str)
+    cipher = PKCS1_OAEP.new(key)
+    encrypted_data = cipher.encrypt(data)
+    return encrypted_data
+
+
+def rsa_decrypt(data, rsa_priv_key_str):
+    """
+    When given some `data` and an RSA private key, decrypt the data
+    """
+    key = RSA.importKey(rsa_priv_key_str)
+    cipher = PKCS1_OAEP.new(key)
+    return cipher.decrypt(data)
+
+
+def has_valid_signature(method, headers_dict, body_dict, access_key, secret_key):
+    """
+    Given a message (either request or response), say whether it has a valid
+    signature or not.
+    """
+    _, expected_signature, _ = generate_signed_message(
+        method, headers_dict, body_dict, access_key, secret_key
+    )
+
+    authorization = headers_dict["Authorization"]
+    auth_token, post_signature = authorization.split(":")
+    _, post_access_key = auth_token.split()
+
+    if post_access_key != access_key:
+        log.error("Posted access key does not match ours")
+        log.debug("Their access: %s; Our access: %s", post_access_key, access_key)
+        return False
+
+    if post_signature != expected_signature:
+        log.error("Posted signature does not match expected")
+        log.debug("Their sig: %s; Expected: %s", post_signature, expected_signature)
+        return False
+
+    return True
+
+
+def generate_signed_message(method, headers_dict, body_dict, access_key, secret_key):
+    """
+    Returns a (message, signature) pair.
+    """
+    message = signing_format_message(method, headers_dict, body_dict)
+
+    # hmac needs a byte string for it's starting key, can't be unicode.
+    hashed = hmac.new(secret_key.encode('utf-8'), message, sha256)
+    signature = binascii.b2a_base64(hashed.digest()).rstrip('\n')
+    authorization_header = "SSI {}:{}".format(access_key, signature)
+
+    message += '\n'
+    return message, signature, authorization_header
+
+
+def signing_format_message(method, headers_dict, body_dict):
+    """
+    Given a dictionary of headers and a dictionary of the JSON for the body,
+    will return a str that represents the normalized version of this messsage
+    that will be used to generate a signature.
+    """
+    headers_str = "{}\n\n{}".format(method, header_string(headers_dict))
+    body_str = body_string(body_dict)
+    message = headers_str + body_str
+
+    return message
+
+
+def header_string(headers_dict):
+    """Given a dictionary of headers, return a canonical string representation."""
+    header_list = []
+
+    if 'Content-Type' in headers_dict:
+        header_list.append(headers_dict['Content-Type'] + "\n")
+    if 'Date' in headers_dict:
+        header_list.append(headers_dict['Date'] + "\n")
+    if 'Content-MD5' in headers_dict:
+        header_list.append(headers_dict['Content-MD5'] + "\n")
+
+    return "".join(header_list)  # Note that trailing \n's are important
+
+
+def body_string(body_dict, prefix=""):
+    """
+    Return a canonical string representation of the body of a JSON request or
+    response. This canonical representation will be used as an input to the
+    hashing used to generate a signature.
+    """
+    body_list = []
+    for key, value in sorted(body_dict.items()):
+        if isinstance(value, (list, tuple)):
+            for i, arr in enumerate(value):
+                if isinstance(arr, dict):
+                    body_list.append(body_string(arr, u"{}.{}.".format(key, i)))
+                else:
+                    body_list.append(u"{}.{}:{}\n".format(key, i, arr).encode('utf-8'))
+        elif isinstance(value, dict):
+            body_list.append(body_string(value, key + ":"))
+        else:
+            if value is None:
+                value = "null"
+            body_list.append(u"{}{}:{}\n".format(prefix, key, value).encode('utf-8'))
+
+    return "".join(body_list)  # Note that trailing \n's are important
+
+
+#!/usr/bin/env python
+"""
+refguide_check.py [OPTIONS] [-- ARGS]
+
+Check for a PyWavelets submodule whether the objects in its __all__ dict
+correspond to the objects included in the reference guide.
+
+Example of usage::
+
+    $ python refguide_check.py optimize
+
+Note that this is a helper script to be able to check if things are missing;
+the output of this script does need to be checked manually.  In some cases
+objects are left out of the refguide for a good reason (it's an alias of
+another function, or deprecated, or ...)
+
+Another use of this helper script is to check validity of code samples
+in docstrings. This is different from doctesting [we do not aim to have
+scipy docstrings doctestable!], this is just to make sure that code in
+docstrings is valid python::
+
+    $ python refguide_check.py --check_docs optimize
+
+"""
+from __future__ import print_function
+
+import sys
+import os
+import re
+import copy
+import inspect
+import warnings
+import doctest
+import tempfile
+import io
+import docutils.core
+from docutils.parsers.rst import directives
+import shutil
+import glob
+from doctest import NORMALIZE_WHITESPACE, ELLIPSIS, IGNORE_EXCEPTION_DETAIL
+from argparse import ArgumentParser
+import numpy as np
+
+# sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'doc',
+#                 'sphinxext'))
+from numpydoc.docscrape_sphinx import get_doc_object
+# Remove sphinx directives that don't run without Sphinx environment
+directives._directives.pop('versionadded', None)
+directives._directives.pop('versionchanged', None)
+directives._directives.pop('moduleauthor', None)
+directives._directives.pop('sectionauthor', None)
+directives._directives.pop('codeauthor', None)
+directives._directives.pop('toctree', None)
+
+
+BASE_MODULE = "pywt"
+
+PUBLIC_SUBMODULES = []
+
+# Docs for these modules are included in the parent module
+OTHER_MODULE_DOCS = {}
+
+# these names are known to fail doctesting and we like to keep it that way
+# e.g. sometimes pseudocode is acceptable etc
+DOCTEST_SKIPLIST = set([])
+
+# these names are not required to be present in ALL despite being in
+# autosummary:: listing
+REFGUIDE_ALL_SKIPLIST = []
+
+HAVE_MATPLOTLIB = False
+
+
+def short_path(path, cwd=None):
+    """
+    Return relative or absolute path name, whichever is shortest.
+    """
+    if not isinstance(path, str):
+        return path
+    if cwd is None:
+        cwd = os.getcwd()
+    abspath = os.path.abspath(path)
+    relpath = os.path.relpath(path, cwd)
+    if len(abspath) <= len(relpath):
+        return abspath
+    return relpath
+
+
+def find_names(module, names_dict):
+    # Refguide entries:
+    #
+    # - 3 spaces followed by function name, and maybe some spaces, some
+    #   dashes, and an explanation; only function names listed in
+    #   refguide are formatted like this (mostly, there may be some false
+    #   positives)
+    #
+    # - special directives, such as data and function
+    #
+    # - (scipy.constants only): quoted list
+    #
+    patterns = [
+        r"^\s\s\s([a-z_0-9A-Z]+)(\s+-+.*)?$",
+        r"^\.\. (?:data|function)::\s*([a-z_0-9A-Z]+)\s*$"
+    ]
+
+    if module.__name__ == 'scipy.constants':
+        patterns += ["^``([a-z_0-9A-Z]+)``"]
+
+    patterns = [re.compile(pattern) for pattern in patterns]
+    module_name = module.__name__
+
+    for line in module.__doc__.splitlines():
+        res = re.search(r"^\s*\.\. (?:currentmodule|module):: ([a-z0-9A-Z_.]+)\s*$", line)
+        if res:
+            module_name = res.group(1)
+            continue
+
+        for pattern in patterns:
+            res = re.match(pattern, line)
+            if res is not None:
+                name = res.group(1)
+                entry = '.'.join([module_name, name])
+                names_dict.setdefault(module_name, set()).add(name)
+                break
+
+
+def get_all_dict(module):
+    """Return a copy of the __all__ dict with irrelevant items removed."""
+    if hasattr(module, "__all__"):
+        all_dict = copy.deepcopy(module.__all__)
+    else:
+        all_dict = copy.deepcopy(dir(module))
+        all_dict = [name for name in all_dict
+                    if not name.startswith("_")]
+    for name in ['absolute_import', 'division', 'print_function']:
+        try:
+            all_dict.remove(name)
+        except ValueError:
+            pass
+
+    # Modules are almost always private; real submodules need a separate
+    # run of refguide_check.
+    all_dict = [name for name in all_dict
+                if not inspect.ismodule(getattr(module, name, None))]
+
+    deprecated = []
+    not_deprecated = []
+    for name in all_dict:
+        f = getattr(module, name, None)
+        if callable(f) and is_deprecated(f):
+            deprecated.append(name)
+        else:
+            not_deprecated.append(name)
+
+    others = set(dir(module)).difference(set(deprecated)).difference(set(not_deprecated))
+
+    return not_deprecated, deprecated, others
+
+
+def compare(all_dict, others, names, module_name):
+    """Return sets of objects only in __all__, refguide, or completely missing."""
+    only_all = set()
+    for name in all_dict:
+        if name not in names:
+            only_all.add(name)
+
+    only_ref = set()
+    missing = set()
+    for name in names:
+        if name not in all_dict:
+            for pat in REFGUIDE_ALL_SKIPLIST:
+                if re.match(pat, module_name + '.' + name):
+                    if name not in others:
+                        missing.add(name)
+                    break
+            else:
+                only_ref.add(name)
+
+    return only_all, only_ref, missing
+
+
+def is_deprecated(f):
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("error")
+        try:
+            f(**{"not a kwarg": None})
+        except DeprecationWarning:
+            return True
+        except:
+            pass
+        return False
+
+
+def check_items(all_dict, names, deprecated, others, module_name, dots=True):
+    num_all = len(all_dict)
+    num_ref = len(names)
+
+    output = ""
+
+    output += "Non-deprecated objects in __all__: %i\n" % num_all
+    output += "Objects in refguide: %i\n\n" % num_ref
+
+    only_all, only_ref, missing = compare(all_dict, others, names, module_name)
+    dep_in_ref = set(only_ref).intersection(deprecated)
+    only_ref = set(only_ref).difference(deprecated)
+
+    if len(dep_in_ref) > 0:
+        output += "Deprecated objects in refguide::\n\n"
+        for name in sorted(deprecated):
+            output += "    " + name + "\n"
+
+    if len(only_all) == len(only_ref) == len(missing) == 0:
+        if dots:
+            output_dot('.')
+        return [(None, True, output)]
+    else:
+        if len(only_all) > 0:
+            output += "ERROR: objects in %s.__all__ but not in refguide::\n\n" % module_name
+            for name in sorted(only_all):
+                output += "    " + name + "\n"
+
+        if len(only_ref) > 0:
+            output += "ERROR: objects in refguide but not in %s.__all__::\n\n" % module_name
+            for name in sorted(only_ref):
+                output += "    " + name + "\n"
+
+        if len(missing) > 0:
+            output += "ERROR: missing objects::\n\n"
+            for name in sorted(missing):
+                output += "    " + name + "\n"
+
+        if dots:
+            output_dot('F')
+        return [(None, False, output)]
+
+
+def validate_rst_syntax(text, name, dots=True):
+    if text is None:
+        if dots:
+            output_dot('E')
+        return False, "ERROR: %s: no documentation" % (name,)
+
+    ok_unknown_items = set([
+        'mod', 'currentmodule', 'autosummary', 'data',
+        'obj', 'versionadded', 'versionchanged', 'module', 'class',
+        'ref', 'func', 'toctree', 'moduleauthor',
+        'sectionauthor', 'codeauthor', 'eq',
+    ])
+
+    # Run through docutils
+    error_stream = io.StringIO()
+
+    def resolve(name, is_label=False):
+        return ("http://foo", name)
+
+    token = '<RST-VALIDATE-SYNTAX-CHECK>'
+
+    docutils.core.publish_doctree(
+        text, token,
+        settings_overrides = dict(halt_level=5,
+                                  traceback=True,
+                                  default_reference_context='title-reference',
+                                  default_role='emphasis',
+                                  link_base='',
+                                  resolve_name=resolve,
+                                  stylesheet_path='',
+                                  raw_enabled=0,
+                                  file_insertion_enabled=0,
+                                  warning_stream=error_stream))
+
+    # Print errors, disregarding unimportant ones
+    error_msg = error_stream.getvalue()
+    errors = error_msg.split(token)
+    success = True
+    output = ""
+
+    for error in errors:
+        lines = error.splitlines()
+        if not lines:
+            continue
+
+        m = re.match(r'.*Unknown (?:interpreted text role|directive type) "(.*)".*$', lines[0])
+        if m:
+            if m.group(1) in ok_unknown_items:
+                continue
+
+        m = re.match(r'.*Error in "math" directive:.*unknown option: "label"', " ".join(lines), re.S)
+        if m:
+            continue
+
+        output += name + lines[0] + "::\n    " + "\n    ".join(lines[1:]).rstrip() + "\n"
+        success = False
+
+    if not success:
+        output += "    " + "-"*72 + "\n"
+        for lineno, line in enumerate(text.splitlines()):
+            output += "    %-4d    %s\n" % (lineno+1, line)
+        output += "    " + "-"*72 + "\n\n"
+
+    if dots:
+        output_dot('.' if success else 'F')
+    return success, output
+
+
+def output_dot(msg='.', stream=sys.stderr):
+    stream.write(msg)
+    stream.flush()
+
+
+def check_rest(module, names, dots=True):
+    """
+    Check reStructuredText formatting of docstrings
+
+    Returns: [(name, success_flag, output), ...]
+    """
+
+    try:
+        skip_types = (dict, str, unicode, float, int)
+    except NameError:
+        # python 3
+        skip_types = (dict, str, float, int)
+
+    results = []
+
+    if module.__name__[6:] not in OTHER_MODULE_DOCS:
+        results += [(module.__name__,) +
+                    validate_rst_syntax(inspect.getdoc(module),
+                                        module.__name__, dots=dots)]
+
+    for name in names:
+        full_name = module.__name__ + '.' + name
+        obj = getattr(module, name, None)
+
+        if obj is None:
+            results.append((full_name, False, "%s has no docstring" % (full_name,)))
+            continue
+        elif isinstance(obj, skip_types):
+            continue
+
+        if inspect.ismodule(obj):
+            text = inspect.getdoc(obj)
+        else:
+            try:
+                text = str(get_doc_object(obj))
+            except:
+                import traceback
+                results.append((full_name, False,
+                                "Error in docstring format!\n" +
+                                traceback.format_exc()))
+                continue
+
+        m = re.search("([\x00-\x09\x0b-\x1f])", text)
+        if m:
+            msg = ("Docstring contains a non-printable character %r! "
+                   "Maybe forgot r\"\"\"?" % (m.group(1),))
+            results.append((full_name, False, msg))
+            continue
+
+        try:
+            src_file = short_path(inspect.getsourcefile(obj))
+        except TypeError:
+            src_file = None
+
+        if src_file:
+            file_full_name = src_file + ':' + full_name
+        else:
+            file_full_name = full_name
+
+        results.append((full_name,) +
+                       validate_rst_syntax(text, file_full_name, dots=dots))
+
+    return results
+
+
+### Doctest helpers ####
+
+# the namespace to run examples in
+DEFAULT_NAMESPACE = {'np': np}
+
+# the namespace to do checks in
+CHECK_NAMESPACE = {
+      'np': np,
+      'assert_allclose': np.testing.assert_allclose,
+      'assert_equal': np.testing.assert_equal,
+      # recognize numpy repr's
+      'array': np.array,
+      'matrix': np.matrix,
+      'int64': np.int64,
+      'uint64': np.uint64,
+      'int8': np.int8,
+      'int32': np.int32,
+      'float64': np.float64,
+      'dtype': np.dtype,
+      'nan': np.nan,
+      'NaN': np.nan,
+      'inf': np.inf,
+      'Inf': np.inf, }
+
+
+class DTRunner(doctest.DocTestRunner):
+    DIVIDER = "\n"
+
+    def __init__(self, item_name, checker=None, verbose=None, optionflags=0):
+        self._item_name = item_name
+        doctest.DocTestRunner.__init__(self, checker=checker, verbose=verbose,
+                                       optionflags=optionflags)
+
+    def _report_item_name(self, out, new_line=False):
+        if self._item_name is not None:
+            if new_line:
+                out("\n")
+            self._item_name = None
+
+    def report_start(self, out, test, example):
+        self._checker._source = example.source
+        return doctest.DocTestRunner.report_start(self, out, test, example)
+
+    def report_success(self, out, test, example, got):
+        if self._verbose:
+            self._report_item_name(out, new_line=True)
+        return doctest.DocTestRunner.report_success(
+            self, out, test, example, got)
+
+    def report_unexpected_exception(self, out, test, example, exc_info):
+        self._report_item_name(out)
+        return doctest.DocTestRunner.report_unexpected_exception(
+            self, out, test, example, exc_info)
+
+    def report_failure(self, out, test, example, got):
+        self._report_item_name(out)
+        return doctest.DocTestRunner.report_failure(self, out, test,
+                                                    example, got)
+
+class Checker(doctest.OutputChecker):
+    obj_pattern = re.compile('at 0x[0-9a-fA-F]+>')
+    vanilla = doctest.OutputChecker()
+    rndm_markers = {'# random', '# Random', '#random', '#Random', "# may vary"}
+    stopwords = {'plt.', '.hist', '.show', '.ylim', '.subplot(',
+                 'set_title', 'imshow', 'plt.show', 'ax.axis', 'plt.plot(',
+                 '.bar(', '.title', '.ylabel', '.xlabel', 'set_ylim',
+                 'set_xlim', '# reformatted'}
+
+    def __init__(self, parse_namedtuples=True, ns=None, atol=1e-8, rtol=1e-2):
+        self.parse_namedtuples = parse_namedtuples
+        self.atol, self.rtol = atol, rtol
+        if ns is None:
+            self.ns = dict(CHECK_NAMESPACE)
+        else:
+            self.ns = ns
+
+    def check_output(self, want, got, optionflags):
+        # cut it short if they are equal
+        if want == got:
+            return True
+
+        # skip stopwords in source
+        if any(word in self._source for word in self.stopwords):
+            return True
+
+        # skip random stuff
+        if any(word in want for word in self.rndm_markers):
+            return True
+
+        # skip function/object addresses
+        if self.obj_pattern.search(got):
+            return True
+
+        # ignore comments (e.g. signal.freqresp)
+        if want.lstrip().startswith("#"):
+            return True
+
+        # try the standard doctest
+        try:
+            if self.vanilla.check_output(want, got, optionflags):
+                return True
+        except Exception:
+            pass
+
+        # OK then, convert strings to objects
+        try:
+            a_want = eval(want, dict(self.ns))
+            a_got = eval(got, dict(self.ns))
+        except:
+            if not self.parse_namedtuples:
+                return False
+            # suppose that "want"  is a tuple, and "got" is smth like
+            # MoodResult(statistic=10, pvalue=0.1).
+            # Then convert the latter to the tuple (10, 0.1),
+            # and then compare the tuples.
+            try:
+                num = len(a_want)
+                regex = ('[\w\d_]+\(' +
+                         ', '.join(['[\w\d_]+=(.+)']*num) +
+                         '\)')
+                grp = re.findall(regex, got.replace('\n', ' '))
+                if len(grp) > 1:  # no more than one for now
+                    return False
+                # fold it back to a tuple
+                got_again = '(' + ', '.join(grp[0]) + ')'
+                return self.check_output(want, got_again, optionflags)
+            except Exception:
+                return False
+
+        # ... and defer to numpy
+        try:
+            return self._do_check(a_want, a_got)
+        except Exception:
+            # heterog tuple, eg (1, np.array([1., 2.]))
+           try:
+                return all(self._do_check(w, g) for w, g in zip(a_want, a_got))
+           except (TypeError, ValueError):
+                return False
+
+    def _do_check(self, want, got):
+        # This should be done exactly as written to correctly handle all of
+        # numpy-comparable objects, strings, and heterogenous tuples
+        try:
+            if want == got:
+                return True
+        except Exception:
+            pass
+        return np.allclose(want, got, atol=self.atol, rtol=self.rtol)
+
+
+def _run_doctests(tests, full_name, verbose, doctest_warnings):
+    """Run modified doctests for the set of `tests`.
+
+    Returns: list of [(success_flag, output), ...]
+    """
+    flags = NORMALIZE_WHITESPACE | ELLIPSIS | IGNORE_EXCEPTION_DETAIL
+    runner = DTRunner(full_name, checker=Checker(), optionflags=flags,
+                      verbose=verbose)
+
+    output = []
+    success = True
+    def out(msg):
+        output.append(msg)
+
+    class MyStderr(object):
+        """Redirect stderr to the current stdout"""
+        def write(self, msg):
+            if doctest_warnings:
+                sys.stdout.write(msg)
+            else:
+                out(msg)
+
+    # Run tests, trying to restore global state afterward
+    old_printoptions = np.get_printoptions()
+    old_errstate = np.seterr()
+    old_stderr = sys.stderr
+    cwd = os.getcwd()
+    tmpdir = tempfile.mkdtemp()
+    sys.stderr = MyStderr()
+    try:
+        os.chdir(tmpdir)
+
+        # try to ensure random seed is NOT reproducible
+        np.random.seed(None)
+
+        for t in tests:
+            t.filename = short_path(t.filename, cwd)
+            fails, successes = runner.run(t, out=out)
+            if fails > 0:
+                success = False
+    finally:
+        sys.stderr = old_stderr
+        os.chdir(cwd)
+        shutil.rmtree(tmpdir)
+        np.set_printoptions(**old_printoptions)
+        np.seterr(**old_errstate)
+
+    return success, output
+
+
+def check_doctests(module, verbose, ns=None,
+                   dots=True, doctest_warnings=False):
+    """Check code in docstrings of the module's public symbols.
+
+    Returns: list of [(item_name, success_flag, output), ...]
+    """
+    if ns is None:
+        ns = dict(DEFAULT_NAMESPACE)
+
+    # Loop over non-deprecated items
+    results = []
+
+    for name in get_all_dict(module)[0]:
+        full_name = module.__name__ + '.' + name
+
+        if full_name in DOCTEST_SKIPLIST:
+            continue
+
+        try:
+            obj = getattr(module, name)
+        except AttributeError:
+            import traceback
+            results.append((full_name, False,
+                            "Missing item!\n" +
+                            traceback.format_exc()))
+            continue
+
+        finder = doctest.DocTestFinder()
+        try:
+            tests = finder.find(obj, name, globs=dict(ns))
+        except:
+            import traceback
+            results.append((full_name, False,
+                            "Failed to get doctests!\n" +
+                            traceback.format_exc()))
+            continue
+
+        success, output = _run_doctests(tests, full_name, verbose,
+                                        doctest_warnings)
+
+        if dots:
+            output_dot('.' if success else 'F')
+
+        results.append((full_name, success, "".join(output)))
+
+        if HAVE_MATPLOTLIB:
+            import matplotlib.pyplot as plt
+            plt.close('all')
+
+    return results
+
+
+def check_doctests_testfile(fname, verbose, ns=None,
+                            dots=True, doctest_warnings=False):
+    """Check code in a text file.
+
+    Mimic `check_doctests` above, differing mostly in test discovery.
+    (which is borrowed from stdlib's doctest.testfile here,
+     https://github.com/python-git/python/blob/master/Lib/doctest.py)
+
+    Returns: list of [(item_name, success_flag, output), ...]
+
+    Notes
+    -----
+
+    We also try to weed out pseudocode:
+    * We maintain a list of exceptions which signal pseudocode,
+    * We split the text file into "blocks" of code separated by empty lines
+      and/or intervening text.
+    * If a block contains a marker, the whole block is then assumed to be
+      pseudocode. It is then not being doctested.
+
+    The rationale is that typically, the text looks like this:
+
+    blah
+    <BLANKLINE>
+    >>> from numpy import some_module   # pseudocode!
+    >>> func = some_module.some_function
+    >>> func(42)                  # still pseudocode
+    146
+    <BLANKLINE>
+    blah
+    <BLANKLINE>
+    >>> 2 + 3        # real code, doctest it
+    5
+
+    """
+    results = []
+
+    if ns is None:
+        ns = dict(DEFAULT_NAMESPACE)
+
+    _, short_name = os.path.split(fname)
+    if short_name in DOCTEST_SKIPLIST:
+        return results
+
+    full_name = fname
+    text = open(fname).read()
+
+    PSEUDOCODE = set(['some_function', 'some_module', 'import example',
+                      'ctypes.CDLL',     # likely need compiling, skip it
+                      'integrate.nquad(func,'  # ctypes integrate tutotial
+    ])
+
+    # split the text into "blocks" and try to detect and omit pseudocode blocks.
+    parser = doctest.DocTestParser()
+    good_parts = []
+    for part in text.split('\n\n'):
+        tests = parser.get_doctest(part, ns, fname, fname, 0)
+        if any(word in ex.source for word in PSEUDOCODE
+                                 for ex in tests.examples):
+            # omit it
+            pass
+        else:
+            # `part` looks like a good code, let's doctest it
+            good_parts += [part]
+
+    # Reassemble the good bits and doctest them:
+    good_text = '\n\n'.join(good_parts)
+    tests = parser.get_doctest(good_text, ns, fname, fname, 0)
+    success, output = _run_doctests([tests], full_name, verbose,
+                                    doctest_warnings)
+
+    if dots:
+        output_dot('.' if success else 'F')
+
+    results.append((full_name, success, "".join(output)))
+
+    if HAVE_MATPLOTLIB:
+        import matplotlib.pyplot as plt
+        plt.close('all')
+
+    return results
+
+
+def init_matplotlib():
+    global HAVE_MATPLOTLIB
+
+    try:
+        import matplotlib
+        matplotlib.use('Agg')
+        HAVE_MATPLOTLIB = True
+    except ImportError:
+        HAVE_MATPLOTLIB = False
+
+
+def main(argv):
+    parser = ArgumentParser(usage=__doc__.lstrip())
+    parser.add_argument("module_names", metavar="SUBMODULES", default=[],
+                        nargs='*',
+                        help="Submodules to check (default: all public)")
+    parser.add_argument("--doctests", action="store_true",
+                        help="Run also doctests")
+    parser.add_argument("-v", "--verbose", action="count", default=0)
+    parser.add_argument("--doctest-warnings", action="store_true",
+                        help="Enforce warning checking for doctests")
+    parser.add_argument("--skip-examples", action="store_true",
+                        help="Skip running doctests in the examples.")
+    args = parser.parse_args(argv)
+
+    modules = []
+    names_dict = {}
+
+    if args.module_names:
+        args.skip_examples = True
+    else:
+        args.module_names = list(PUBLIC_SUBMODULES)
+
+    os.environ['SCIPY_PIL_IMAGE_VIEWER'] = 'true'
+
+    module_names = list(args.module_names)
+    for name in list(module_names):
+        if name in OTHER_MODULE_DOCS:
+            name = OTHER_MODULE_DOCS[name]
+            if name not in module_names:
+                module_names.append(name)
+
+    for submodule_name in module_names:
+        module_name = BASE_MODULE + '.' + submodule_name
+        __import__(module_name)
+        module = sys.modules[module_name]
+
+        if submodule_name not in OTHER_MODULE_DOCS:
+            find_names(module, names_dict)
+
+        if submodule_name in args.module_names:
+            modules.append(module)
+
+    dots = True
+    success = True
+    results = []
+
+    print("Running checks for %d modules:" % (len(modules),))
+
+    if args.doctests or not args.skip_examples:
+        init_matplotlib()
+
+    for module in modules:
+        if dots:
+            if module is not modules[0]:
+                sys.stderr.write(' ')
+            sys.stderr.write(module.__name__ + ' ')
+            sys.stderr.flush()
+
+        all_dict, deprecated, others = get_all_dict(module)
+        names = names_dict.get(module.__name__, set())
+
+        mod_results = []
+        mod_results += check_items(all_dict, names, deprecated, others, module.__name__)
+        mod_results += check_rest(module, set(names).difference(deprecated),
+                                  dots=dots)
+        if args.doctests:
+            mod_results += check_doctests(module, (args.verbose >= 2), dots=dots,
+                                          doctest_warnings=args.doctest_warnings)
+
+        for v in mod_results:
+            assert isinstance(v, tuple), v
+
+        results.append((module, mod_results))
+
+    if dots:
+        sys.stderr.write("\n")
+        sys.stderr.flush()
+
+    if not args.skip_examples:
+        examples_path = os.path.join(
+            os.getcwd(), 'doc', 'source', 'regression', '*.rst')
+        print('\nChecking examples files at %s:' % examples_path)
+        for filename in sorted(glob.glob(examples_path)):
+            if dots:
+                sys.stderr.write('\n')
+                sys.stderr.write(os.path.split(filename)[1] + ' ')
+                sys.stderr.flush()
+
+            examples_results = check_doctests_testfile(
+                filename, (args.verbose >= 2), dots=dots,
+                doctest_warnings=args.doctest_warnings)
+
+            def scratch(): pass        # stub out a "module", see below
+            scratch.__name__ = filename
+            results.append((scratch, examples_results))
+
+        if dots:
+            sys.stderr.write("\n")
+            sys.stderr.flush()
+
+    # Report results
+    all_success = True
+
+    for module, mod_results in results:
+        success = all(x[1] for x in mod_results)
+        all_success = all_success and success
+
+        if success and args.verbose == 0:
+            continue
+
+        print("")
+        print("=" * len(module.__name__))
+        print(module.__name__)
+        print("=" * len(module.__name__))
+        print("")
+
+        for name, success, output in mod_results:
+            if name is None:
+                if not success or args.verbose >= 1:
+                    print(output.strip())
+                    print("")
+            elif not success or (args.verbose >= 2 and output.strip()):
+                print(name)
+                print("-"*len(name))
+                print("")
+                print(output.strip())
+                print("")
+
+    if all_success:
+        print("\nOK: refguide and doctests checks passed!")
+        sys.exit(0)
+    else:
+        print("\nERROR: refguide or doctests have errors")
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main(argv=sys.argv[1:])
+
+# -*- encoding: utf-8 -*-
+##############################################################################
+#
+#    OpenERP, Open Source Management Solution
+#    Copyright (C) 2004-2008 Tiny SPRL (<http://tiny.be>). All Rights Reserved
+#    $Id$
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, 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 Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##############################################################################
+
+from openerp.osv import fields, osv
+from openerp.tools.translate import _
+
+class product_pricelist(osv.osv):
+    _inherit = 'product.pricelist'
+
+    _columns ={
+        'visible_discount': fields.boolean('Visible Discount'),
+    }
+    _defaults = {
+         'visible_discount': True,
+    }
+
+
+class sale_order_line(osv.osv):
+    _inherit = "sale.order.line"
+
+    def product_id_change(self, cr, uid, ids, pricelist, product, qty=0,
+            uom=False, qty_uos=0, uos=False, name='', partner_id=False,
+            lang=False, update_tax=True, date_order=False, packaging=False,
+            fiscal_position=False, flag=False, context=None):
+
+        def get_real_price(res_dict, product_id, qty, uom, pricelist):
+            item_obj = self.pool.get('product.pricelist.item')
+            price_type_obj = self.pool.get('product.price.type')
+            product_obj = self.pool.get('product.product')
+            field_name = 'list_price'
+
+            product = product_obj.browse(cr, uid, product_id, context)
+            product_read = product_obj.read(cr, uid, [product_id], [field_name], context=context)[0]
+
+            factor = 1.0
+            if uom and uom != product.uom_id.id:
+                product_uom_obj = self.pool.get('product.uom')
+                uom_data = product_uom_obj.browse(cr, uid,  product.uom_id.id)
+                factor = uom_data.factor
+            return product_read[field_name] * factor
+
+
+        res=super(sale_order_line, self).product_id_change(cr, uid, ids, pricelist, product, qty,
+            uom, qty_uos, uos, name, partner_id,
+            lang, update_tax, date_order, packaging=packaging, fiscal_position=fiscal_position, flag=flag, context=context)
+
+        context = {'lang': lang, 'partner_id': partner_id}
+        result=res['value']
+        pricelist_obj=self.pool.get('product.pricelist')
+        product_obj = self.pool.get('product.product')
+        if product and pricelist:
+            if result.get('price_unit',False):
+                price=result['price_unit']
+            else:
+                return res
+
+            product = product_obj.browse(cr, uid, product, context)
+            list_price = pricelist_obj.price_get(cr, uid, [pricelist],
+                    product.id, qty or 1.0, partner_id, {'uom': uom,'date': date_order })
+
+            so_pricelist = pricelist_obj.browse(cr, uid, pricelist, context=context)
+
+            new_list_price = get_real_price(list_price, product.id, qty, uom, pricelist)
+            if so_pricelist.visible_discount and list_price[pricelist] != 0 and new_list_price != 0:
+                if product.company_id and so_pricelist.currency_id.id != product.company_id.currency_id.id:
+                    # new_list_price is in company's currency while price in pricelist currency
+                    new_list_price = self.pool['res.currency'].compute(cr, uid,
+                        product.company_id.currency_id.id, so_pricelist.currency_id.id,
+                        new_list_price, context=context)
+                discount = (new_list_price - price) / new_list_price * 100
+                if discount > 0:
+                    result['price_unit'] = new_list_price
+                    result['discount'] = discount
+                else:
+                    result['discount'] = 0.0
+            else:
+                result['discount'] = 0.0
+        else:
+            result['discount'] = 0.0
+        return res
+
+from Coordinate import Coordinate as C
+from Move import Move
+
+WHITE = True
+BLACK = False
+X = 0
+Y = 1
+
+
+class Piece:
+
+    def __init__(self, board, side, position, movesMade=0):
+        self.board = board
+        self.side = side
+        self.position = position
+        self.movesMade = 0
+
+    def __str__(self):
+        sideString = 'White' if self.side == WHITE else 'Black'
+        return 'Type : ' + type(self).__name__ + \
+               ' - Position : ' + str(self.position) + \
+               " - Side : " + sideString + \
+               ' -- Value : ' + str(self.value) + \
+               " -- Moves made : " + str(self.movesMade)
+
+    def move_in_direction(self, pos, direction, side):
+        '''
+        Get next move in specified direction
+
+        @param pos - current position of the piece
+        @param direction - direction to move to, in format [x_off, y_off]
+        @param side - which side the piece is: WHITE or BLACK
+        @return a Move() object which describes the next move of current piece
+        '''
+        for dis in range(1, 8):
+            movement = C(dis * direction[X], dis * direction[Y])
+            new_pos = pos + movement
+            if self.board.is_valid_pos(new_pos):
+                piece_at_pos = self.board.get_piece_at_pos(new_pos)
+                if piece_at_pos is None:
+                    yield Move(self, new_pos)
+
+                elif piece_at_pos is not None:
+                    if piece_at_pos.side != side:
+                        yield Move(self, new_pos, piece_to_capture=piece_at_pos)
+                    return
+
+    def __eq__(self, other):
+        if self.board == other.board and \
+           self.side == other.side and \
+           self.position == other.position and \
+           self.__class__ == other.__class__:
+            return True
+        return False
+
+    def copy(self):
+        cpy = self.__class__(self.board, self.side, self.position,
+                             movesMade=self.movesMade)
+        return cpy
+
+from __future__ import unicode_literals
+
+from django.db import transaction
+from django.test import TestCase
+from django.utils import six
+
+from .models import Article, InheritedArticleA, InheritedArticleB, Publication
+
+
+class ManyToManyTests(TestCase):
+
+    def setUp(self):
+        # Create a couple of Publications.
+        self.p1 = Publication.objects.create(id=None, title='The Python Journal')
+        self.p2 = Publication.objects.create(id=None, title='Science News')
+        self.p3 = Publication.objects.create(id=None, title='Science Weekly')
+        self.p4 = Publication.objects.create(title='Highlights for Children')
+
+        self.a1 = Article.objects.create(id=None, headline='Django lets you build Web apps easily')
+        self.a1.publications.add(self.p1)
+
+        self.a2 = Article.objects.create(id=None, headline='NASA uses Python')
+        self.a2.publications.add(self.p1, self.p2, self.p3, self.p4)
+
+        self.a3 = Article.objects.create(headline='NASA finds intelligent life on Earth')
+        self.a3.publications.add(self.p2)
+
+        self.a4 = Article.objects.create(headline='Oxygen-free diet works wonders')
+        self.a4.publications.add(self.p2)
+
+    def test_add(self):
+        # Create an Article.
+        a5 = Article(id=None, headline='Django lets you reate Web apps easily')
+        # You can't associate it with a Publication until it's been saved.
+        self.assertRaises(ValueError, getattr, a5, 'publications')
+        # Save it!
+        a5.save()
+        # Associate the Article with a Publication.
+        a5.publications.add(self.p1)
+        self.assertQuerysetEqual(a5.publications.all(),
+                                 ['<Publication: The Python Journal>'])
+        # Create another Article, and set it to appear in both Publications.
+        a6 = Article(id=None, headline='ESA uses Python')
+        a6.save()
+        a6.publications.add(self.p1, self.p2)
+        a6.publications.add(self.p3)
+        # Adding a second time is OK
+        a6.publications.add(self.p3)
+        self.assertQuerysetEqual(a6.publications.all(),
+            [
+                '<Publication: Science News>',
+                '<Publication: Science Weekly>',
+                '<Publication: The Python Journal>',
+            ])
+
+        # Adding an object of the wrong type raises TypeError
+        with six.assertRaisesRegex(self, TypeError, "'Publication' instance expected, got <Article.*"):
+            with transaction.atomic():
+                a6.publications.add(a5)
+
+        # Add a Publication directly via publications.add by using keyword arguments.
+        a6.publications.create(title='Highlights for Adults')
+        self.assertQuerysetEqual(a6.publications.all(),
+            [
+                '<Publication: Highlights for Adults>',
+                '<Publication: Science News>',
+                '<Publication: Science Weekly>',
+                '<Publication: The Python Journal>',
+            ])
+
+    def test_reverse_add(self):
+        # Adding via the 'other' end of an m2m
+        a5 = Article(headline='NASA finds intelligent life on Mars')
+        a5.save()
+        self.p2.article_set.add(a5)
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+            [
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: NASA finds intelligent life on Mars>',
+                '<Article: NASA uses Python>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        self.assertQuerysetEqual(a5.publications.all(),
+                                 ['<Publication: Science News>'])
+
+        # Adding via the other end using keywords
+        self.p2.article_set.create(headline='Carbon-free diet works wonders')
+        self.assertQuerysetEqual(
+            self.p2.article_set.all(),
+            [
+                '<Article: Carbon-free diet works wonders>',
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: NASA finds intelligent life on Mars>',
+                '<Article: NASA uses Python>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        a6 = self.p2.article_set.all()[3]
+        self.assertQuerysetEqual(a6.publications.all(),
+            [
+                '<Publication: Highlights for Children>',
+                '<Publication: Science News>',
+                '<Publication: Science Weekly>',
+                '<Publication: The Python Journal>',
+            ])
+
+    def test_related_sets(self):
+        # Article objects have access to their related Publication objects.
+        self.assertQuerysetEqual(self.a1.publications.all(),
+             ['<Publication: The Python Journal>'])
+        self.assertQuerysetEqual(self.a2.publications.all(),
+            [
+                '<Publication: Highlights for Children>',
+                '<Publication: Science News>',
+                '<Publication: Science Weekly>',
+                '<Publication: The Python Journal>',
+            ])
+        # Publication objects have access to their related Article objects.
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+            [
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: NASA uses Python>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        self.assertQuerysetEqual(self.p1.article_set.all(),
+            [
+                '<Article: Django lets you build Web apps easily>',
+                '<Article: NASA uses Python>',
+            ])
+        self.assertQuerysetEqual(Publication.objects.get(id=self.p4.id).article_set.all(),
+                                 ['<Article: NASA uses Python>'])
+
+    def test_selects(self):
+        # We can perform kwarg queries across m2m relationships
+        self.assertQuerysetEqual(
+            Article.objects.filter(publications__id__exact=self.p1.id),
+            [
+                '<Article: Django lets you build Web apps easily>',
+                '<Article: NASA uses Python>',
+            ])
+        self.assertQuerysetEqual(
+            Article.objects.filter(publications__pk=self.p1.id),
+            [
+                '<Article: Django lets you build Web apps easily>',
+                '<Article: NASA uses Python>',
+            ])
+        self.assertQuerysetEqual(
+            Article.objects.filter(publications=self.p1.id),
+            [
+                '<Article: Django lets you build Web apps easily>',
+                '<Article: NASA uses Python>',
+            ])
+        self.assertQuerysetEqual(
+            Article.objects.filter(publications=self.p1),
+            [
+                '<Article: Django lets you build Web apps easily>',
+                '<Article: NASA uses Python>',
+            ])
+        self.assertQuerysetEqual(
+            Article.objects.filter(publications__title__startswith="Science"),
+            [
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: NASA uses Python>',
+                '<Article: NASA uses Python>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        self.assertQuerysetEqual(
+            Article.objects.filter(publications__title__startswith="Science").distinct(),
+            [
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: NASA uses Python>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+
+        # The count() function respects distinct() as well.
+        self.assertEqual(Article.objects.filter(publications__title__startswith="Science").count(), 4)
+        self.assertEqual(Article.objects.filter(publications__title__startswith="Science").distinct().count(), 3)
+        self.assertQuerysetEqual(
+            Article.objects.filter(publications__in=[self.p1.id, self.p2.id]).distinct(),
+            [
+                '<Article: Django lets you build Web apps easily>',
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: NASA uses Python>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        self.assertQuerysetEqual(
+            Article.objects.filter(publications__in=[self.p1.id, self.p2]).distinct(),
+            [
+                '<Article: Django lets you build Web apps easily>',
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: NASA uses Python>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        self.assertQuerysetEqual(
+            Article.objects.filter(publications__in=[self.p1, self.p2]).distinct(),
+            [
+                '<Article: Django lets you build Web apps easily>',
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: NASA uses Python>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+
+        # Excluding a related item works as you would expect, too (although the SQL
+        # involved is a little complex).
+        self.assertQuerysetEqual(Article.objects.exclude(publications=self.p2),
+                                 ['<Article: Django lets you build Web apps easily>'])
+
+    def test_reverse_selects(self):
+        # Reverse m2m queries are supported (i.e., starting at the table that
+        # doesn't have a ManyToManyField).
+        self.assertQuerysetEqual(Publication.objects.filter(id__exact=self.p1.id),
+                                 ['<Publication: The Python Journal>'])
+        self.assertQuerysetEqual(Publication.objects.filter(pk=self.p1.id),
+                                 ['<Publication: The Python Journal>'])
+        self.assertQuerysetEqual(
+            Publication.objects.filter(article__headline__startswith="NASA"),
+            [
+                '<Publication: Highlights for Children>',
+                '<Publication: Science News>',
+                '<Publication: Science News>',
+                '<Publication: Science Weekly>',
+                '<Publication: The Python Journal>',
+            ])
+        self.assertQuerysetEqual(Publication.objects.filter(article__id__exact=self.a1.id),
+                                 ['<Publication: The Python Journal>'])
+        self.assertQuerysetEqual(Publication.objects.filter(article__pk=self.a1.id),
+                                 ['<Publication: The Python Journal>'])
+        self.assertQuerysetEqual(Publication.objects.filter(article=self.a1.id),
+                                 ['<Publication: The Python Journal>'])
+        self.assertQuerysetEqual(Publication.objects.filter(article=self.a1),
+                                 ['<Publication: The Python Journal>'])
+
+        self.assertQuerysetEqual(
+            Publication.objects.filter(article__in=[self.a1.id, self.a2.id]).distinct(),
+            [
+                '<Publication: Highlights for Children>',
+                '<Publication: Science News>',
+                '<Publication: Science Weekly>',
+                '<Publication: The Python Journal>',
+            ])
+        self.assertQuerysetEqual(
+            Publication.objects.filter(article__in=[self.a1.id, self.a2]).distinct(),
+            [
+                '<Publication: Highlights for Children>',
+                '<Publication: Science News>',
+                '<Publication: Science Weekly>',
+                '<Publication: The Python Journal>',
+            ])
+        self.assertQuerysetEqual(
+            Publication.objects.filter(article__in=[self.a1, self.a2]).distinct(),
+            [
+                '<Publication: Highlights for Children>',
+                '<Publication: Science News>',
+                '<Publication: Science Weekly>',
+                '<Publication: The Python Journal>',
+            ])
+
+    def test_delete(self):
+        # If we delete a Publication, its Articles won't be able to access it.
+        self.p1.delete()
+        self.assertQuerysetEqual(Publication.objects.all(),
+            [
+                '<Publication: Highlights for Children>',
+                '<Publication: Science News>',
+                '<Publication: Science Weekly>',
+            ])
+        self.assertQuerysetEqual(self.a1.publications.all(), [])
+        # If we delete an Article, its Publications won't be able to access it.
+        self.a2.delete()
+        self.assertQuerysetEqual(Article.objects.all(),
+            [
+                '<Article: Django lets you build Web apps easily>',
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+            [
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+
+    def test_bulk_delete(self):
+        # Bulk delete some Publications - references to deleted publications should go
+        Publication.objects.filter(title__startswith='Science').delete()
+        self.assertQuerysetEqual(Publication.objects.all(),
+            [
+                '<Publication: Highlights for Children>',
+                '<Publication: The Python Journal>',
+            ])
+        self.assertQuerysetEqual(Article.objects.all(),
+            [
+                '<Article: Django lets you build Web apps easily>',
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: NASA uses Python>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        self.assertQuerysetEqual(self.a2.publications.all(),
+            [
+                '<Publication: Highlights for Children>',
+                '<Publication: The Python Journal>',
+            ])
+
+        # Bulk delete some articles - references to deleted objects should go
+        q = Article.objects.filter(headline__startswith='Django')
+        self.assertQuerysetEqual(q, ['<Article: Django lets you build Web apps easily>'])
+        q.delete()
+        # After the delete, the QuerySet cache needs to be cleared,
+        # and the referenced objects should be gone
+        self.assertQuerysetEqual(q, [])
+        self.assertQuerysetEqual(self.p1.article_set.all(),
+                                 ['<Article: NASA uses Python>'])
+
+    def test_remove(self):
+        # Removing publication from an article:
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+            [
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: NASA uses Python>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        self.a4.publications.remove(self.p2)
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+            [
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: NASA uses Python>',
+            ])
+        self.assertQuerysetEqual(self.a4.publications.all(), [])
+        # And from the other end
+        self.p2.article_set.remove(self.a3)
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+            [
+                '<Article: NASA uses Python>',
+            ])
+        self.assertQuerysetEqual(self.a3.publications.all(), [])
+
+    def test_set(self):
+        self.p2.article_set.set([self.a4, self.a3])
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+            [
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        self.assertQuerysetEqual(self.a4.publications.all(),
+                                 ['<Publication: Science News>'])
+        self.a4.publications.set([self.p3.id])
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+                                 ['<Article: NASA finds intelligent life on Earth>'])
+        self.assertQuerysetEqual(self.a4.publications.all(),
+                                 ['<Publication: Science Weekly>'])
+
+        self.p2.article_set.set([])
+        self.assertQuerysetEqual(self.p2.article_set.all(), [])
+        self.a4.publications.set([])
+        self.assertQuerysetEqual(self.a4.publications.all(), [])
+
+        self.p2.article_set.set([self.a4, self.a3], clear=True)
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+            [
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        self.assertQuerysetEqual(self.a4.publications.all(),
+                                 ['<Publication: Science News>'])
+        self.a4.publications.set([self.p3.id], clear=True)
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+                                 ['<Article: NASA finds intelligent life on Earth>'])
+        self.assertQuerysetEqual(self.a4.publications.all(),
+                                 ['<Publication: Science Weekly>'])
+
+        self.p2.article_set.set([], clear=True)
+        self.assertQuerysetEqual(self.p2.article_set.all(), [])
+        self.a4.publications.set([], clear=True)
+        self.assertQuerysetEqual(self.a4.publications.all(), [])
+
+    def test_assign(self):
+        # Relation sets can be assigned. Assignment clears any existing set members
+        self.p2.article_set = [self.a4, self.a3]
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+            [
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        self.assertQuerysetEqual(self.a4.publications.all(),
+                                 ['<Publication: Science News>'])
+        self.a4.publications = [self.p3.id]
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+                                 ['<Article: NASA finds intelligent life on Earth>'])
+        self.assertQuerysetEqual(self.a4.publications.all(),
+                                 ['<Publication: Science Weekly>'])
+
+        # An alternate to calling clear() is to assign the empty set
+        self.p2.article_set = []
+        self.assertQuerysetEqual(self.p2.article_set.all(), [])
+        self.a4.publications = []
+        self.assertQuerysetEqual(self.a4.publications.all(), [])
+
+    def test_assign_ids(self):
+        # Relation sets can also be set using primary key values
+        self.p2.article_set = [self.a4.id, self.a3.id]
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+            [
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        self.assertQuerysetEqual(self.a4.publications.all(),
+                                 ['<Publication: Science News>'])
+        self.a4.publications = [self.p3.id]
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+                                 ['<Article: NASA finds intelligent life on Earth>'])
+        self.assertQuerysetEqual(self.a4.publications.all(),
+                                 ['<Publication: Science Weekly>'])
+
+    def test_forward_assign_with_queryset(self):
+        # Ensure that querysets used in m2m assignments are pre-evaluated
+        # so their value isn't affected by the clearing operation in
+        # ManyRelatedObjectsDescriptor.__set__. Refs #19816.
+        self.a1.publications = [self.p1, self.p2]
+
+        qs = self.a1.publications.filter(title='The Python Journal')
+        self.a1.publications = qs
+
+        self.assertEqual(1, self.a1.publications.count())
+        self.assertEqual(1, qs.count())
+
+    def test_reverse_assign_with_queryset(self):
+        # Ensure that querysets used in M2M assignments are pre-evaluated
+        # so their value isn't affected by the clearing operation in
+        # ManyRelatedObjectsDescriptor.__set__. Refs #19816.
+        self.p1.article_set = [self.a1, self.a2]
+
+        qs = self.p1.article_set.filter(headline='Django lets you build Web apps easily')
+        self.p1.article_set = qs
+
+        self.assertEqual(1, self.p1.article_set.count())
+        self.assertEqual(1, qs.count())
+
+    def test_clear(self):
+        # Relation sets can be cleared:
+        self.p2.article_set.clear()
+        self.assertQuerysetEqual(self.p2.article_set.all(), [])
+        self.assertQuerysetEqual(self.a4.publications.all(), [])
+
+        # And you can clear from the other end
+        self.p2.article_set.add(self.a3, self.a4)
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+            [
+                '<Article: NASA finds intelligent life on Earth>',
+                '<Article: Oxygen-free diet works wonders>',
+            ])
+        self.assertQuerysetEqual(self.a4.publications.all(),
+            [
+                '<Publication: Science News>',
+            ])
+        self.a4.publications.clear()
+        self.assertQuerysetEqual(self.a4.publications.all(), [])
+        self.assertQuerysetEqual(self.p2.article_set.all(),
+                                 ['<Article: NASA finds intelligent life on Earth>'])
+
+    def test_inherited_models_selects(self):
+        """
+        #24156 - Objects from child models where the parent's m2m field uses
+        related_name='+' should be retrieved correctly.
+        """
+        a = InheritedArticleA.objects.create()
+        b = InheritedArticleB.objects.create()
+        a.publications.add(self.p1, self.p2)
+        self.assertQuerysetEqual(a.publications.all(),
+            [
+                '<Publication: Science News>',
+                '<Publication: The Python Journal>',
+            ])
+        self.assertQuerysetEqual(b.publications.all(), [])
+        b.publications.add(self.p3)
+        self.assertQuerysetEqual(a.publications.all(),
+            [
+                '<Publication: Science News>',
+                '<Publication: The Python Journal>',
+            ])
+        self.assertQuerysetEqual(b.publications.all(),
+            [
+                '<Publication: Science Weekly>',
+            ])
+
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# (c) 2014, 2015 YAEGASHI Takeshi <yaegashi@debian.org>
+#
+# This file is part of Ansible
+#
+# Ansible 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 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+ANSIBLE_METADATA = {'metadata_version': '1.0',
+                    'status': ['preview'],
+                    'supported_by': 'core'}
+
+
+DOCUMENTATION = """
+---
+module: blockinfile
+author:
+    - 'YAEGASHI Takeshi (@yaegashi)'
+extends_documentation_fragment:
+    - files
+    - validate
+short_description: Insert/update/remove a text block
+                   surrounded by marker lines.
+version_added: '2.0'
+description:
+  - This module will insert/update/remove a block of multi-line text
+    surrounded by customizable marker lines.
+options:
+  path:
+    aliases: [ dest, destfile, name ]
+    required: true
+    description:
+      - The file to modify.
+      - Before 2.3 this option was only usable as I(dest), I(destfile) and I(name).
+  state:
+    required: false
+    choices: [ present, absent ]
+    default: present
+    description:
+      - Whether the block should be there or not.
+  marker:
+    required: false
+    default: '# {mark} ANSIBLE MANAGED BLOCK'
+    description:
+      - The marker line template.
+        "{mark}" will be replaced with "BEGIN" or "END".
+  block:
+    aliases: [ content ]
+    required: false
+    default: ''
+    description:
+      - The text to insert inside the marker lines.
+        If it's missing or an empty string,
+        the block will be removed as if C(state) were specified to C(absent).
+  insertafter:
+    required: false
+    default: EOF
+    description:
+      - If specified, the block will be inserted after the last match of
+        specified regular expression. A special value is available; C(EOF) for
+        inserting the block at the end of the file.  If specified regular
+        expresion has no matches, C(EOF) will be used instead.
+    choices: [ 'EOF', '*regex*' ]
+  insertbefore:
+    required: false
+    default: None
+    description:
+      - If specified, the block will be inserted before the last match of
+        specified regular expression. A special value is available; C(BOF) for
+        inserting the block at the beginning of the file.  If specified regular
+        expresion has no matches, the block will be inserted at the end of the
+        file.
+    choices: [ 'BOF', '*regex*' ]
+  create:
+    required: false
+    default: 'no'
+    choices: [ 'yes', 'no' ]
+    description:
+      - Create a new file if it doesn't exist.
+  backup:
+    required: false
+    default: 'no'
+    choices: [ 'yes', 'no' ]
+    description:
+      - Create a backup file including the timestamp information so you can
+        get the original file back if you somehow clobbered it incorrectly.
+  follow:
+    required: false
+    default: "no"
+    choices: [ "yes", "no" ]
+    description:
+      - 'This flag indicates that filesystem links, if they exist, should be followed.'
+    version_added: "2.1"
+notes:
+  - This module supports check mode.
+  - When using 'with_*' loops be aware that if you do not set a unique mark the block will be overwritten on each iteration.
+  - As of Ansible 2.3, the I(dest) option has been changed to I(path) as default, but I(dest) still works as well.
+"""
+
+EXAMPLES = r"""
+# Before 2.3, option 'dest' or 'name' was used instead of 'path'
+- name: insert/update "Match User" configuration block in /etc/ssh/sshd_config
+  blockinfile:
+    path: /etc/ssh/sshd_config
+    block: |
+      Match User ansible-agent
+      PasswordAuthentication no
+
+- name: insert/update eth0 configuration stanza in /etc/network/interfaces
+        (it might be better to copy files into /etc/network/interfaces.d/)
+  blockinfile:
+    path: /etc/network/interfaces
+    block: |
+      iface eth0 inet static
+          address 192.0.2.23
+          netmask 255.255.255.0
+
+- name: insert/update configuration using a local file
+  blockinfile:
+    block: "{{ lookup('file', './local/ssh_config') }}"
+    dest: "/etc/ssh/ssh_config"
+    backup: yes
+
+- name: insert/update HTML surrounded by custom markers after <body> line
+  blockinfile:
+    path: /var/www/html/index.html
+    marker: "<!-- {mark} ANSIBLE MANAGED BLOCK -->"
+    insertafter: "<body>"
+    content: |
+      <h1>Welcome to {{ ansible_hostname }}</h1>
+      <p>Last updated on {{ ansible_date_time.iso8601 }}</p>
+
+- name: remove HTML as well as surrounding markers
+  blockinfile:
+    path: /var/www/html/index.html
+    marker: "<!-- {mark} ANSIBLE MANAGED BLOCK -->"
+    content: ""
+
+- name: Add mappings to /etc/hosts
+  blockinfile:
+    path: /etc/hosts
+    block: |
+      {{ item.ip }} {{ item.name }}
+    marker: "# {mark} ANSIBLE MANAGED BLOCK {{ item.name }}"
+  with_items:
+    - { name: host1, ip: 10.10.1.10 }
+    - { name: host2, ip: 10.10.1.11 }
+    - { name: host3, ip: 10.10.1.12 }
+"""
+
+import re
+import os
+import tempfile
+from ansible.module_utils.six import b
+from ansible.module_utils.basic import AnsibleModule
+from ansible.module_utils._text import to_bytes
+
+def write_changes(module, contents, path):
+
+    tmpfd, tmpfile = tempfile.mkstemp()
+    f = os.fdopen(tmpfd, 'wb')
+    f.write(contents)
+    f.close()
+
+    validate = module.params.get('validate', None)
+    valid = not validate
+    if validate:
+        if "%s" not in validate:
+            module.fail_json(msg="validate must contain %%s: %s" % (validate))
+        (rc, out, err) = module.run_command(validate % tmpfile)
+        valid = rc == 0
+        if rc != 0:
+            module.fail_json(msg='failed to validate: '
+                                 'rc:%s error:%s' % (rc, err))
+    if valid:
+        module.atomic_move(tmpfile, path, unsafe_writes=module.params['unsafe_writes'])
+
+
+def check_file_attrs(module, changed, message):
+
+    file_args = module.load_file_common_arguments(module.params)
+    if module.set_file_attributes_if_different(file_args, False):
+
+        if changed:
+            message += " and "
+        changed = True
+        message += "ownership, perms or SE linux context changed"
+
+    return message, changed
+
+
+def main():
+    module = AnsibleModule(
+        argument_spec=dict(
+            path=dict(required=True, aliases=['dest', 'destfile', 'name'], type='path'),
+            state=dict(default='present', choices=['absent', 'present']),
+            marker=dict(default='# {mark} ANSIBLE MANAGED BLOCK', type='str'),
+            block=dict(default='', type='str', aliases=['content']),
+            insertafter=dict(default=None),
+            insertbefore=dict(default=None),
+            create=dict(default=False, type='bool'),
+            backup=dict(default=False, type='bool'),
+            validate=dict(default=None, type='str'),
+        ),
+        mutually_exclusive=[['insertbefore', 'insertafter']],
+        add_file_common_args=True,
+        supports_check_mode=True
+    )
+
+    params = module.params
+    path = params['path']
+    if module.boolean(params.get('follow', None)):
+        path = os.path.realpath(path)
+
+    if os.path.isdir(path):
+        module.fail_json(rc=256,
+                         msg='Path %s is a directory !' % path)
+
+    path_exists = os.path.exists(path)
+    if not path_exists:
+        if not module.boolean(params['create']):
+            module.fail_json(rc=257,
+                             msg='Path %s does not exist !' % path)
+        original = None
+        lines = []
+    else:
+        f = open(path, 'rb')
+        original = f.read()
+        f.close()
+        lines = original.splitlines()
+
+    insertbefore = params['insertbefore']
+    insertafter = params['insertafter']
+    block = to_bytes(params['block'])
+    marker = to_bytes(params['marker'])
+    present = params['state'] == 'present'
+
+    if not present and not path_exists:
+        module.exit_json(changed=False, msg="File %s not present" % path)
+
+    if insertbefore is None and insertafter is None:
+        insertafter = 'EOF'
+
+    if insertafter not in (None, 'EOF'):
+        insertre = re.compile(insertafter)
+    elif insertbefore not in (None, 'BOF'):
+        insertre = re.compile(insertbefore)
+    else:
+        insertre = None
+
+    marker0 = re.sub(b(r'{mark}'), b('BEGIN'), marker)
+    marker1 = re.sub(b(r'{mark}'), b('END'), marker)
+    if present and block:
+        # Escape seqeuences like '\n' need to be handled in Ansible 1.x
+        if module.ansible_version.startswith('1.'):
+            block = re.sub('', block, '')
+        blocklines = [marker0] + block.splitlines() + [marker1]
+    else:
+        blocklines = []
+
+    n0 = n1 = None
+    for i, line in enumerate(lines):
+        if line == marker0:
+            n0 = i
+        if line == marker1:
+            n1 = i
+
+    if None in (n0, n1):
+        n0 = None
+        if insertre is not None:
+            for i, line in enumerate(lines):
+                if insertre.search(line):
+                    n0 = i
+            if n0 is None:
+                n0 = len(lines)
+            elif insertafter is not None:
+                n0 += 1
+        elif insertbefore is not None:
+            n0 = 0           # insertbefore=BOF
+        else:
+            n0 = len(lines)  # insertafter=EOF
+    elif n0 < n1:
+        lines[n0:n1+1] = []
+    else:
+        lines[n1:n0+1] = []
+        n0 = n1
+
+    lines[n0:n0] = blocklines
+
+    if lines:
+        result = b('\n').join(lines)
+        if original is None or original.endswith(b('\n')):
+            result += b('\n')
+    else:
+        result = ''
+    if original == result:
+        msg = ''
+        changed = False
+    elif original is None:
+        msg = 'File created'
+        changed = True
+    elif not blocklines:
+        msg = 'Block removed'
+        changed = True
+    else:
+        msg = 'Block inserted'
+        changed = True
+
+    if changed and not module.check_mode:
+        if module.boolean(params['backup']) and path_exists:
+            module.backup_local(path)
+        write_changes(module, result, path)
+
+    if module.check_mode and not path_exists:
+        module.exit_json(changed=changed, msg=msg)
+
+    msg, changed = check_file_attrs(module, changed, msg)
+    module.exit_json(changed=changed, msg=msg)
+
+
+if __name__ == '__main__':
+    main()
+
+# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for tf.bitcast."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+import numpy as np
+import tensorflow as tf
+
+
+class BitcastTest(tf.test.TestCase):
+
+  def _testBitcast(self, x, datatype, shape):
+    with self.test_session():
+      tf_ans = tf.bitcast(x, datatype)
+      out = tf_ans.eval()
+      buff_after = memoryview(out).tobytes()
+      buff_before = memoryview(x).tobytes()
+      self.assertEqual(buff_before, buff_after)
+      self.assertEqual(tf_ans.get_shape(), shape)
+      self.assertEqual(tf_ans.dtype, datatype)
+
+  def testSmaller(self):
+    x = np.random.rand(3, 2)
+    datatype = tf.int8
+    shape = [3, 2, 8]
+    self._testBitcast(x, datatype, shape)
+
+  def testLarger(self):
+    x = np.arange(16, dtype=np.int8).reshape([4, 4])
+    datatype = tf.int32
+    shape = [4]
+    self._testBitcast(x, datatype, shape)
+
+  def testSameDtype(self):
+    x = np.random.rand(3, 4)
+    shape = [3, 4]
+    self._testBitcast(x, x.dtype, shape)
+
+  def testSameSize(self):
+    x = np.random.rand(3, 4)
+    shape = [3, 4]
+    self._testBitcast(x, tf.int64, shape)
+
+  def testErrors(self):
+    x = np.zeros([1, 1], np.int8)
+    datatype = tf.int32
+    with self.assertRaisesRegexp(ValueError, "Cannot bitcast due to shape"):
+      tf.bitcast(x, datatype, None)
+
+  def testEmpty(self):
+    x = np.ones([], np.int32)
+    datatype = tf.int8
+    shape = [4]
+    self._testBitcast(x, datatype, shape)
+
+  def testUnknown(self):
+    x = tf.placeholder(tf.float32)
+    datatype = tf.int8
+    tf.bitcast(x, datatype, None)
+
+
+if __name__ == "__main__":
+  tf.test.main()
+
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2012 OpenStack Foundation
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import sqlalchemy as sql
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine; bind
+    # migrate_engine to your metadata
+    meta = sql.MetaData()
+    meta.bind = migrate_engine
+
+    # catalog
+
+    service_table = sql.Table(
+        'service',
+        meta,
+        sql.Column('id', sql.String(64), primary_key=True),
+        sql.Column('type', sql.String(255)),
+        sql.Column('extra', sql.Text()))
+    service_table.create(migrate_engine, checkfirst=True)
+
+    endpoint_table = sql.Table(
+        'endpoint',
+        meta,
+        sql.Column('id', sql.String(64), primary_key=True),
+        sql.Column('region', sql.String(255)),
+        sql.Column('service_id',
+                   sql.String(64),
+                   sql.ForeignKey('service.id'),
+                   nullable=False),
+        sql.Column('extra', sql.Text()))
+    endpoint_table.create(migrate_engine, checkfirst=True)
+
+    # identity
+
+    role_table = sql.Table(
+        'role',
+        meta,
+        sql.Column('id', sql.String(64), primary_key=True),
+        sql.Column('name', sql.String(255), unique=True, nullable=False))
+    role_table.create(migrate_engine, checkfirst=True)
+
+    if migrate_engine.name == 'ibm_db_sa':
+        # NOTE(blk-u): SQLAlchemy for PostgreSQL picks the name tenant_name_key
+        # for the unique constraint, but for DB2 doesn't give the UC a name
+        # unless we tell it to and there is no DDL to alter a column to drop
+        # an unnamed unique constraint, so this code creates a named unique
+        # constraint on the name column rather than an unnamed one.
+        # (This is used in migration 16.)
+        tenant_table = sql.Table(
+            'tenant',
+            meta,
+            sql.Column('id', sql.String(64), primary_key=True),
+            sql.Column('name', sql.String(64), nullable=False),
+            sql.Column('extra', sql.Text()),
+            sql.UniqueConstraint('name', name='tenant_name_key'))
+    else:
+        tenant_table = sql.Table(
+            'tenant',
+            meta,
+            sql.Column('id', sql.String(64), primary_key=True),
+            sql.Column('name', sql.String(64), unique=True, nullable=False),
+            sql.Column('extra', sql.Text()))
+
+    tenant_table.create(migrate_engine, checkfirst=True)
+
+    metadata_table = sql.Table(
+        'metadata',
+        meta,
+        sql.Column('user_id', sql.String(64), primary_key=True),
+        sql.Column('tenant_id', sql.String(64), primary_key=True),
+        sql.Column('data', sql.Text()))
+    metadata_table.create(migrate_engine, checkfirst=True)
+
+    ec2_credential_table = sql.Table(
+        'ec2_credential',
+        meta,
+        sql.Column('access', sql.String(64), primary_key=True),
+        sql.Column('secret', sql.String(64)),
+        sql.Column('user_id', sql.String(64)),
+        sql.Column('tenant_id', sql.String(64)))
+    ec2_credential_table.create(migrate_engine, checkfirst=True)
+
+    if migrate_engine.name == 'ibm_db_sa':
+        # NOTE(blk-u): SQLAlchemy for PostgreSQL picks the name user_name_key
+        # for the unique constraint, but for DB2 doesn't give the UC a name
+        # unless we tell it to and there is no DDL to alter a column to drop
+        # an unnamed unique constraint, so this code creates a named unique
+        # constraint on the name column rather than an unnamed one.
+        # (This is used in migration 16.)
+        user_table = sql.Table(
+            'user',
+            meta,
+            sql.Column('id', sql.String(64), primary_key=True),
+            sql.Column('name', sql.String(64), nullable=False),
+            sql.Column('extra', sql.Text()),
+            sql.UniqueConstraint('name', name='user_name_key'))
+    else:
+        user_table = sql.Table(
+            'user',
+            meta,
+            sql.Column('id', sql.String(64), primary_key=True),
+            sql.Column('name', sql.String(64), unique=True, nullable=False),
+            sql.Column('extra', sql.Text()))
+
+    user_table.create(migrate_engine, checkfirst=True)
+
+    user_tenant_membership_table = sql.Table(
+        'user_tenant_membership',
+        meta,
+        sql.Column(
+            'user_id',
+            sql.String(64),
+            sql.ForeignKey('user.id'),
+            primary_key=True),
+        sql.Column(
+            'tenant_id',
+            sql.String(64),
+            sql.ForeignKey('tenant.id'),
+            primary_key=True))
+    user_tenant_membership_table.create(migrate_engine, checkfirst=True)
+
+    # token
+
+    token_table = sql.Table(
+        'token',
+        meta,
+        sql.Column('id', sql.String(64), primary_key=True),
+        sql.Column('expires', sql.DateTime()),
+        sql.Column('extra', sql.Text()))
+    token_table.create(migrate_engine, checkfirst=True)
+
+
+def downgrade(migrate_engine):
+    # Operations to reverse the above upgrade go here.
+    meta = sql.MetaData()
+    meta.bind = migrate_engine
+
+    tables = ['user_tenant_membership', 'token', 'user', 'tenant', 'role',
+              'metadata', 'ec2_credential', 'endpoint', 'service']
+    for t in tables:
+        table = sql.Table(t, meta, autoload=True)
+        table.drop(migrate_engine, checkfirst=True)
+
+# ==================================================================================================
+# Copyright 2013 Twitter, Inc.
+# --------------------------------------------------------------------------------------------------
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this work except in compliance with the License.
+# You may obtain a copy of the License in the LICENSE file, or at:
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==================================================================================================
+
+from twitter.common.zookeeper.serverset.endpoint import Endpoint, ServiceInstance, Status
+
+
+def _service_instance(vals):
+  json = '''{
+    "additionalEndpoints": {
+        "aurora": {
+            "host": "smfd-akb-%d-sr1.devel.twitter.com",
+            "port": 31181
+        },
+        "health": {
+            "host": "smfd-akb-%d-sr1.devel.twitter.com",
+            "port": 31181
+        }
+    },
+    "serviceEndpoint": {
+        "host": "smfd-akb-%d-sr1.devel.twitter.com",
+        "port": 31181
+    },
+    "shard": %d,
+    "status": "ALIVE"
+}''' % vals
+
+  return ServiceInstance.unpack(json)
+
+
+def test_endpoint_equality():
+  assert Endpoint('host', 8340) == Endpoint('host', 8340)
+
+
+def test_endpoint_hash_equality():
+  assert Endpoint('host', 8340).__hash__() == Endpoint('host', 8340).__hash__()
+
+
+def test_endpoint_inequality():
+  assert Endpoint('host', 8340) != Endpoint('xhost', 8341)
+
+
+def test_endpoint_hash_inequality():
+  assert Endpoint('host', 8340).__hash__() != Endpoint('xhost', 8341).__hash__()
+
+
+def test_status_equality():
+  assert Status.from_string('DEAD') == Status.from_string('DEAD')
+
+
+def test_status_hash_equality():
+  assert Status.from_string('DEAD').__hash__() == Status.from_string('DEAD').__hash__()
+
+
+def test_status_inequality():
+  assert Status.from_string('DEAD') != Status.from_string('STARTING')
+
+
+def test_status_hash_inequality():
+  assert Status.from_string('DEAD').__hash__() != Status.from_string('STARTING').__hash__()
+
+
+def test_service_instance_equality():
+  vals = (1, 2, 3, 4)
+  assert _service_instance(vals) == _service_instance(vals)
+
+
+def test_service_instance_hash_equality():
+  vals = (1, 2, 3, 4)
+  assert _service_instance(vals).__hash__() == _service_instance(vals).__hash__()
+
+
+def test_service_instance_inequality():
+  vals = (1, 2, 3, 4)
+  vals2 = (5, 6, 7, 8)
+  assert _service_instance(vals) != _service_instance(vals2)
+
+
+def test_service_instance_hash_inequality():
+  vals = (1, 2, 3, 4)
+  vals2 = (5, 6, 7, 8)
+  assert _service_instance(vals).__hash__() != _service_instance(vals2).__hash__()
+
+# -*- coding: utf-8 -*-
+
+'''Monkeypatch s3 Storage preventing parallel key stream read in unittesting.
+   It is called from lib/storage/s3'''
+
+import six
+
+from docker_registry.core import exceptions
+import docker_registry.drivers.s3 as s3
+from docker_registry.testing import utils
+
+
+@six.add_metaclass(utils.monkeypatch_class)
+class Storage(s3.Storage):
+
+    # def stream_read(self, path, bytes_range=None):
+    #     path = self._init_path(path)
+    #     headers = None
+    #     if bytes_range:
+    #         headers = {'Range': 'bytes={0}-{1}'.format(*bytes_range)}
+    #     key = self._boto_bucket.lookup(path, headers=headers)
+    #     if not key:
+    #         raise exceptions.FileNotFoundError('%s is not there' % path)
+    #     while True:
+    #         buf = key.read(self.buffer_size)
+    #         if not buf:
+    #             break
+    #         yield buf
+
+    def stream_read(self, path, bytes_range=None):
+        path = self._init_path(path)
+        nb_bytes = 0
+        total_size = 0
+        key = self._boto_bucket.lookup(path)
+        if not key:
+            raise exceptions.FileNotFoundError('%s is not there' % path)
+        if bytes_range:
+            key._last_position = bytes_range[0]
+            total_size = bytes_range[1] - bytes_range[0] + 1
+        while True:
+            if bytes_range:
+                # Bytes Range is enabled
+                buf_size = self.buffer_size
+                if nb_bytes + buf_size > total_size:
+                    # We make sure we don't read out of the range
+                    buf_size = total_size - nb_bytes
+                if buf_size > 0:
+                    buf = key.read(buf_size)
+                    nb_bytes += len(buf)
+                else:
+                    # We're at the end of the range
+                    buf = ''
+            else:
+                buf = key.read(self.buffer_size)
+            if not buf:
+                break
+            yield buf
+
+# -*- coding: utf-8 -*-
+##############################################################################
+#
+#    OpenERP, Open Source Management Solution
+#    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as
+#    published by the Free Software Foundation, either version 3 of the
+#    License, 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 Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##############################################################################
+
+import time
+from datetime import datetime
+from dateutil.relativedelta import relativedelta
+from openerp.osv import fields, osv
+from openerp.tools.translate import _
+
+
+class account_aged_trial_balance(osv.osv_memory):
+    _inherit = 'account.common.partner.report'
+    _name = 'account.aged.trial.balance'
+    _description = 'Account Aged Trial balance Report'
+
+    _columns = {
+        'period_length':fields.integer('Period Length (days)', required=True),
+        'direction_selection': fields.selection([('past','Past'),
+                                                 ('future','Future')],
+                                                 'Analysis Direction', required=True),
+        'journal_ids': fields.many2many('account.journal', 'account_aged_trial_balance_journal_rel', 'account_id', 'journal_id', 'Journals', required=True),
+    }
+    _defaults = {
+        'period_length': 30,
+        'date_from': lambda *a: time.strftime('%Y-%m-%d'),
+        'direction_selection': 'past',
+    }
+
+    def _print_report(self, cr, uid, ids, data, context=None):
+        res = {}
+        if context is None:
+            context = {}
+
+        data = self.pre_print_report(cr, uid, ids, data, context=context)
+        data['form'].update(self.read(cr, uid, ids, ['period_length', 'direction_selection'])[0])
+
+        period_length = data['form']['period_length']
+        if period_length<=0:
+            raise osv.except_osv(_('User Error!'), _('You must set a period length greater than 0.'))
+        if not data['form']['date_from']:
+            raise osv.except_osv(_('User Error!'), _('You must set a start date.'))
+
+        start = datetime.strptime(data['form']['date_from'], "%Y-%m-%d")
+
+        if data['form']['direction_selection'] == 'past':
+            for i in range(5)[::-1]:
+                stop = start - relativedelta(days=period_length)
+                res[str(i)] = {
+                    'name': (i!=0 and (str((5-(i+1)) * period_length) + '-' + str((5-i) * period_length)) or ('+'+str(4 * period_length))),
+                    'stop': start.strftime('%Y-%m-%d'),
+                    'start': (i!=0 and stop.strftime('%Y-%m-%d') or False),
+                }
+                start = stop - relativedelta(days=1)
+        else:
+            for i in range(5):
+                stop = start + relativedelta(days=period_length)
+                res[str(5-(i+1))] = {
+                    'name': (i!=4 and str((i) * period_length)+'-' + str((i+1) * period_length) or ('+'+str(4 * period_length))),
+                    'start': start.strftime('%Y-%m-%d'),
+                    'stop': (i!=4 and stop.strftime('%Y-%m-%d') or False),
+                }
+                start = stop + relativedelta(days=1)
+        data['form'].update(res)
+        if data.get('form',False):
+            data['ids']=[data['form'].get('chart_account_id',False)]
+        return self.pool['report'].get_action(cr, uid, [], 'account.report_agedpartnerbalance', data=data, context=context)
+
+# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
+
+from django.contrib.gis.db import models
+from django.utils.encoding import python_2_unicode_compatible
+
+
+@python_2_unicode_compatible
+class NamedModel(models.Model):
+    name = models.CharField(max_length=25)
+
+    objects = models.GeoManager()
+
+    class Meta:
+        abstract = True
+        app_label = 'layermap'
+
+    def __str__(self):
+        return self.name
+
+
+class State(NamedModel):
+    pass
+
+
+class County(NamedModel):
+    state = models.ForeignKey(State)
+    mpoly = models.MultiPolygonField(srid=4269)  # Multipolygon in NAD83
+
+
+class CountyFeat(NamedModel):
+    poly = models.PolygonField(srid=4269)
+
+
+class City(NamedModel):
+    name_txt = models.TextField(default='')
+    population = models.IntegerField()
+    density = models.DecimalField(max_digits=7, decimal_places=1)
+    dt = models.DateField()
+    point = models.PointField()
+
+
+class Interstate(NamedModel):
+    length = models.DecimalField(max_digits=6, decimal_places=2)
+    path = models.LineStringField()
+
+
+# Same as `City` above, but for testing model inheritance.
+class CityBase(NamedModel):
+    population = models.IntegerField()
+    density = models.DecimalField(max_digits=7, decimal_places=1)
+    point = models.PointField()
+
+
+class ICity1(CityBase):
+    dt = models.DateField()
+
+    class Meta(CityBase.Meta):
+        pass
+
+
+class ICity2(ICity1):
+    dt_time = models.DateTimeField(auto_now=True)
+
+    class Meta(ICity1.Meta):
+        pass
+
+
+class Invalid(models.Model):
+    point = models.PointField()
+
+    class Meta:
+        app_label = 'layermap'
+
+
+# Mapping dictionaries for the models above.
+co_mapping = {'name': 'Name',
+              'state': {'name': 'State'},  # ForeignKey's use another mapping dictionary for the _related_ Model (State in this case).
+              'mpoly': 'MULTIPOLYGON',  # Will convert POLYGON features into MULTIPOLYGONS.
+              }
+
+cofeat_mapping = {'name': 'Name',
+                  'poly': 'POLYGON',
+                  }
+
+city_mapping = {'name': 'Name',
+                'population': 'Population',
+                'density': 'Density',
+                'dt': 'Created',
+                'point': 'POINT',
+                }
+
+inter_mapping = {'name': 'Name',
+                 'length': 'Length',
+                 'path': 'LINESTRING',
+                 }
+
+"""
+LWR job manager that uses a CLI interface to a job queue (e.g. Torque's qsub,
+qstat, etc...).
+"""
+
+from .base.external import ExternalBaseManager
+from .util.external import parse_external_id
+from .util.cli import CliInterface, split_params
+from .util.job_script import job_script
+
+from logging import getLogger
+log = getLogger(__name__)
+
+
+class CliQueueManager(ExternalBaseManager):
+    manager_type = "queued_cli"
+
+    def __init__(self, name, app, **kwds):
+        super(CliQueueManager, self).__init__(name, app, **kwds)
+        self.cli_interface = CliInterface(code_dir='.')
+        self.shell_params, self.job_params = split_params(kwds)
+
+    def launch(self, job_id, command_line, submit_params={}, dependencies_description=None, env=[]):
+        self._check_execution_with_tool_file(job_id, command_line)
+        shell, job_interface = self.__get_cli_plugins()
+        stdout_path = self._stdout_path(job_id)
+        stderr_path = self._stderr_path(job_id)
+        job_name = self._job_name(job_id)
+        command_line = self._expand_command_line(command_line, dependencies_description)
+        job_script_kwargs = self._job_template_env(job_id, command_line=command_line, env=env)
+        extra_kwargs = job_interface.job_script_kwargs(stdout_path, stderr_path, job_name)
+        job_script_kwargs.update(extra_kwargs)
+        script = job_script(**job_script_kwargs)
+        script_path = self._write_job_script(job_id, script)
+        submission_command = job_interface.submit(script_path)
+        cmd_out = shell.execute(submission_command)
+        if cmd_out.returncode != 0:
+            log.warn("Failed to submit job - command was %s" % submission_command)
+            raise Exception("Failed to submit job")
+        external_id = parse_external_id(cmd_out.stdout.strip())
+        if not external_id:
+            message_template = "Failed to obtain externl id for job_id %s and submission_command %s"
+            message = message_template % (job_id, submission_command)
+            log.warn(message)
+            raise Exception("Failed to obtain external id")
+        self._register_external_id(job_id, external_id)
+
+    def __get_cli_plugins(self):
+        return self.cli_interface.get_plugins(self.shell_params, self.job_params)
+
+    def _kill_external(self, external_id):
+        shell, job_interface = self.__get_cli_plugins()
+        kill_command = job_interface.delete(external_id)
+        shell.execute(kill_command)
+
+    def _get_status_external(self, external_id):
+        shell, job_interface = self.__get_cli_plugins()
+        status_command = job_interface.get_single_status(external_id)
+        cmd_out = shell.execute(status_command)
+        state = job_interface.parse_single_status(cmd_out.stdout, external_id)
+        return state
+
+#!/usr/bin/env python3
+# -*- coding:utf-8 -*-
+
+from urllib import parse
+import os
+from nico_tools import nico_xml_parser
+from nico_tools.nicowalker import NicoWalker
+from nico_tools.mylist_items import GetMyListItems
+from nico_tools.mylist import MyList
+from progressbar import ProgressBar, Percentage, Bar, ETA
+import subprocess
+from nico_tools import mp3_tag
+import re
+
+character_replace = {
+    "\\": "＼",
+    "/": "／",
+    ":": "：",
+    "?": "？",
+    "\"": "”",
+    "<": "＜",
+    ">": "＞",
+    "|": "｜",
+    " ": "_",
+    "*": "＊"
+}
+
+
+class DownloadVideo(NicoWalker):
+    command_name = 'download nicovideo flv'
+
+    def __init__(self, args):
+        super(DownloadVideo, self).__init__()
+        self.parser.add_argument('vid',
+                                 metavar='VID',
+                                 help='watch ID or mylist name')
+        self.parser.add_argument('-l', '--location',
+                                 dest='location',
+                                 default='./'.replace("/", os.sep),
+                                 help='video output folder')
+        self.parser.add_argument('-f', '--force',
+                                 dest='overwrite',
+                                 action='store_true',
+                                 help='allow overwrite')
+        self.parser.add_argument('--mp3',
+                                 dest='mp3conv',
+                                 action='store_true',
+                                 help='convert to mp3')
+        self.parser.add_argument('-b', '--bitrate',
+                                 dest='bitrate',
+                                 default=192,
+                                 help='mp3 bitrate')
+        self.parser.add_argument('-m', '--mylist',
+                                 dest='mylist',
+                                 action='store_true',
+                                 help='download mylist items')
+        self.set_parser(args)
+
+    def invoke(self):
+        if self.args.mylist:
+            mylist_array = MyList.get_mylist_names(self.session)
+            mylist_items = GetMyListItems.get_mylist_items(self.args.vid, self.session, mylist_array)
+            watch_ids = list(map(lambda mylist_item: mylist_item["item_data"]["watch_id"], mylist_items))
+        else:
+            watch_ids = [self.args.vid]
+        for watch_id in watch_ids:
+            # Watch IDがURLで指定された場合、動画IDを抜き出す
+            if watch_id.startswith("http"):
+                searched = re.search("nicovideo.jp/watch/([a-z0-9]*)", watch_id)
+                assert searched is not None, "URL中に動画IDが見つかりませんでした"
+                watch_id = searched.groups()[0]
+            # 3回失敗するまで繰り返す
+            for _ in range(3):
+                success = self.download(self.session, watch_id, self.args.location, self.args.overwrite,
+                                        self.args.mp3conv, self.args.bitrate)
+                if success:
+                    # 成功したら終了
+                    break
+                else:
+                    # 失敗したらログインしなおす
+                    print("Dispose old session and retry.")
+                    self.login(force=True)
+
+    @staticmethod
+    def get_video_metadata(session, watch_id):
+        # 動画の情報をAPIから取得して、視聴ページを訪問
+        # （これをやらないとFLVのURLが取れない）
+        api_url = "http://ext.nicovideo.jp/api/getthumbinfo/{0}".format(watch_id)
+        api_response_text = session.get(api_url).text
+        video_info = nico_xml_parser.parse_video_info(api_response_text)
+        session.get(video_info["watch_url"])
+        return video_info
+
+    @staticmethod
+    def get_download_url(session, video_info, watch_id):
+        # ダウンロードURLを取得
+        print(video_info["title"], video_info["user_nickname"])
+        url = 'http://flapi.nicovideo.jp/api/getflv?v={0}'.format(watch_id)
+        text = session.get(url).text
+        flv_url = text.split('&')[2].replace('url=', '')
+        flv_url = parse.unquote(flv_url)
+        return flv_url
+
+    @staticmethod
+    def gen_video_path(save_directory, video_info):
+        # FLV保存のためのファイル名を決定
+        if not save_directory.endswith('/') and not save_directory.endswith(os.sep):
+            save_directory += '/'
+        # ファイル名に使用不可能の文字列は大文字に置き換える
+        video_title = video_info["title"]
+        for key, value in character_replace.items():
+            if key in video_title:
+                video_title = video_title.replace(key, value)
+        flv_path = "{0}{1}.{2}".format(save_directory, video_title, video_info["movie_type"])
+        flv_path = flv_path.replace("/", os.sep)
+        return flv_path
+
+    @staticmethod
+    def exec_download(session, flv_url, flv_path, progressbar):
+        # ダウンロード＆保存処理開始
+        with open(flv_path, 'wb') as f:
+            # FLVのURLに対してセッションを開く
+            res = session.get(flv_url, stream=True)
+            if res.status_code != 200:
+                print("Download failed. Status code is {0}.".format(res.status_code))
+                return False
+            # ファイルサイズ取得
+            content_length = res.headers.get("content-length")
+            content_length = int(content_length)
+            # プログレスバー準備
+            division_size = int(content_length / 100)
+            downloaded_size = 0
+            progressbar.start()
+            # ストリーミングで4096bytesずつデータ取得
+            for data in res.iter_content(chunk_size=4096):
+                downloaded_size += len(data)
+                f.write(data)
+                # プログレスバーを更新
+                try:
+                    progressbar.update(int(downloaded_size / division_size))
+                except OSError:
+                    pass
+            progressbar.finish()
+            print('Saved as {0}'.format(flv_path))
+        return True
+
+    @staticmethod
+    def convert_mp3(video_info, flv_path, mp3_bitrate, leave_flv=False):
+        mp3_path = flv_path[:flv_path.rfind(".")] + ".mp3"
+        print(mp3_path)
+        command = 'ffmpeg -y -i "{0}" -ab {1}k "{2}"'.format(flv_path, mp3_bitrate, mp3_path)
+        try:
+            subprocess.run(command, shell=True, check=True)
+        except subprocess.CalledProcessError:
+            print("ffmpegの実行に失敗しました。")
+            exit(-1)
+        mp3_tag.add_tag(
+            mp3_path,
+            video_info["thumbnail_url"],
+            video_info["title"],
+            video_info["user_nickname"],
+            "ニコニコ動画"
+        )
+        # mp3ファイルが存在したら元のファイルを削除
+        if leave_flv is False and os.path.exists(mp3_path):
+            os.remove(flv_path)
+
+    @staticmethod
+    def download(session, watch_id, save_directory, overwrite=False, convert_mp3=False, mp3_bitrate="192"):
+        if convert_mp3:
+            try:
+                subprocess.run("ffmpeg -version", shell=True, check=True, stdout=subprocess.DEVNULL)
+            except subprocess.CalledProcessError:
+                print("ffmpegが実行できません。ffmpegがインストールされ、PATHに含まれているか確認してください。\n"
+                      "インストールする場合、 https://www.ffmpeg.org/download.html を参照してください。")
+                exit(-1)
+        video_info = DownloadVideo.get_video_metadata(session, watch_id)
+        flv_url = DownloadVideo.get_download_url(session, video_info, watch_id)
+        flv_path = DownloadVideo.gen_video_path(save_directory, video_info)
+        # ファイルが存在したら終了
+        if not overwrite and os.path.exists(flv_path):
+            print("ファイルが存在します。上書きする場合は --overwrite オプションを指定してください。")
+            return True
+        # ダウンロード実行
+        widgets = ["Downloading: ", Percentage(), Bar(), ETA()]
+        progressbar = ProgressBar(maxval=100, widgets=widgets)
+        if not DownloadVideo.exec_download(session, flv_url, flv_path, progressbar):
+            return False
+        # mp3へ変換
+        if convert_mp3:
+            DownloadVideo.convert_mp3(video_info, flv_path, mp3_bitrate)
+        return True
+
+
+if __name__ == '__main__':
+    DownloadVideo(None).invoke()
+
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Constants for export/import."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+VERSION_FORMAT_SPECIFIER = "%08d"
+ASSETS_DIRECTORY = "assets"
+EXPORT_BASE_NAME = "export"
+EXPORT_SUFFIX_NAME = "meta"
+META_GRAPH_DEF_FILENAME = "export.meta"
+VARIABLES_FILENAME = "export"
+VARIABLES_FILENAME_PATTERN = "export-?????-of-?????"
+VARIABLES_FILENAME_PATTERN_V2 = "export.data-?????-of-?????"
+VARIABLES_INDEX_FILENAME_V2 = "export.index"
+INIT_OP_KEY = "serving_init_op"
+SIGNATURES_KEY = "serving_signatures"
+ASSETS_KEY = "serving_assets"
+GRAPH_KEY = "serving_graph"
+
+# -*- coding: utf-8 -*-
+
+# Resource object code
+#
+# Created by: The Resource Compiler for PyQt (Qt v4.8.6)
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore
+
+qt_resource_data = "\
+\x00\x00\x1c\x5f\
+\x89\
+\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
+\x00\x00\xc8\x00\x00\x00\x4b\x08\x06\x00\x00\x00\x35\x7c\xc8\xe8\
+\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
+\x00\x00\x1c\x16\x49\x44\x41\x54\x78\x5e\xed\x9d\x09\x9c\x14\xc5\
+\xf5\xc7\xbb\x7b\x66\x16\xe4\x74\xd9\x5d\x05\x54\x14\x34\x9a\x78\
+\x82\xb7\x51\x44\x14\x0f\xbc\x4f\x3c\xfe\x1a\xc5\x3b\xde\xfa\xf7\
+\xf8\x0b\x82\xa3\x1c\x1e\x89\xf1\x8a\x46\x63\x14\xf5\xef\x15\x35\
+\x26\xf1\x56\xe4\x70\xc5\x78\xc5\x68\x8c\x8a\xf1\x88\x82\x88\x07\
+\xec\x72\xb8\xa8\xec\x31\x9d\xdf\x77\x98\x5e\x7a\x7b\x7a\x66\x7a\
+\x66\x7a\x11\x96\x7e\x9f\xcf\x6f\x67\xba\xba\xea\x55\xd5\xab\xf7\
+\x5e\xbd\xae\xaa\x9e\x35\x8c\x88\x22\x09\x44\x12\x88\x24\x10\x49\
+\x20\x92\x40\x24\x81\x48\x02\x91\x04\x22\x09\x44\x12\x88\x24\x10\
+\x49\x20\x92\x40\x24\x81\x48\x02\x91\x04\x22\x09\x44\x12\x88\x24\
+\x10\x49\x60\x15\x96\x80\xb9\x0a\xb7\x3d\x6a\x7a\x07\x92\x40\xf7\
+\x4b\x5f\xa8\xea\xdc\x25\xb1\x83\x61\x59\x83\x0c\xd3\xee\x6d\xdb\
+\x56\xdc\xe9\x9e\x69\xd8\x29\xc3\xb0\x17\xa5\x6c\x73\xa6\x65\xa7\
+\x5e\x9d\xf7\xce\xd7\xff\x31\x1e\x19\xd1\xb2\x22\xba\x1f\x19\xc8\
+\x8a\x90\x72\x54\x47\x6e\x09\x24\x1f\xae\xa8\x49\xf4\x3d\xd8\x30\
+\x8d\xf3\x0c\xdb\x96\x71\x98\x9d\x73\x65\xb6\x6d\x23\x65\x9a\xc6\
+\xec\x54\xca\x78\xe0\x87\xe6\xa6\x9b\x97\x24\x87\x7e\x95\x2b\x6f\
+\x58\xe9\x91\x81\x84\x25\xc9\x88\x4f\xf1\x12\x38\xfb\xe9\x4e\x35\
+\x7d\xba\x5f\x64\xd8\xc6\x25\x32\x8c\x6e\x41\x19\xd8\x9a\x4e\x64\
+\x4c\xcf\x36\xa5\x52\x67\x2e\x1a\x33\xe4\xd3\xa0\xe5\x4a\xc9\x67\
+\x95\x52\x28\x2a\x13\x49\x20\x0c\x09\x54\xaf\xdd\x6d\xa4\x61\x98\
+\xa3\x8a\x31\x0e\xea\x95\x57\x37\x45\xc3\x2b\x62\xd6\x35\xbd\x92\
+\x4f\xf7\x08\xa3\x2d\xb9\x78\xb4\xc6\x79\xb9\x32\xa4\xd3\x93\x49\
+\x19\xd2\x90\x8a\xea\xef\x16\x27\x52\x5d\x12\x65\xcf\x3a\xf5\xc6\
+\x1a\x8a\x29\xe7\x35\x1a\xc9\x11\x4d\xe2\x2e\x87\x10\x0a\xc5\xc4\
+\xa5\x93\x10\xac\x4f\xa5\x55\xf9\x83\x8a\x35\xe6\x28\x8a\x5c\xd6\
+\x10\xbc\x4e\x87\xfc\xb9\xca\xe4\x60\x95\xee\x03\x7d\xa1\x4f\xed\
+\x45\xc4\xf0\xdf\x09\x61\xc9\xbf\xa8\x76\x56\x8f\x9b\xba\x89\x69\
+\x59\xff\xab\x42\xc8\xac\x24\xb2\x0d\xf3\x60\x23\xd6\xfd\x19\x15\
+\x9e\x54\x12\x83\x00\x85\xf2\x29\xbb\x59\x99\x9c\xb1\x5e\x2c\x91\
+\xda\xcb\x34\xac\x9d\x35\xa7\xad\x27\xab\xed\xa2\xa9\x2d\x5f\x99\
+\x00\x55\xa6\xb3\xb4\x68\x54\x16\x8b\xd3\x47\x66\x4b\x6a\x4a\x73\
+\x4b\xaa\x76\x61\x72\xe8\xc2\xa0\x85\x5d\xf9\x50\xa0\x9f\x09\xfb\
+\x08\xdb\x0a\xbd\x05\x14\xab\x3d\x88\x7e\x5f\x27\x3c\x92\x83\x79\
+\xa5\xd2\x6f\x12\x36\x14\xe4\x00\xd2\x44\xfb\xee\x16\x6e\xcf\x5c\
+\xe7\xfb\xa8\xd0\xcd\x41\x02\x7d\xd9\x4a\xa8\x16\x12\xf9\x0a\x94\
+\x71\x0f\x23\xfe\xb7\x70\xb6\xb0\xa8\x0c\x3e\x25\x17\xad\x9a\x58\
+\x7b\xb1\x65\x58\xd7\x94\xcc\x60\x79\xc1\xe7\xe7\xd5\x2f\x39\xd4\
+\xf8\xf5\xde\x4b\x42\xe0\x95\xc5\xc2\xdf\xdb\x26\x9f\xe8\x52\x5d\
+\x51\x79\x9c\x8c\xe1\x1c\x4d\x66\x9b\xa8\x54\xcc\x64\x62\x83\xf4\
+\x94\x14\x06\xc1\x45\x18\xae\x55\x8b\x53\xe3\x96\xf5\x72\xd5\x84\
+\xda\xab\xea\x9a\xa6\x4e\xd3\x6c\xe5\x28\x57\xa1\x6a\xd6\x52\x06\
+\x06\x78\xa4\xd0\x77\x19\xbb\x42\x45\xca\xbe\x8f\x01\xe6\x22\x14\
+\x7c\x6b\x61\x53\x4f\x86\x69\xb9\x0a\xb8\xd2\x31\xaa\x8b\x85\xc3\
+\x84\xaa\x00\xf9\xc3\xc8\x82\x23\x69\x2f\x03\xcc\xdf\x3e\x3d\x7b\
+\x48\x9f\x06\xe7\xcf\x14\xec\xae\x6d\xdb\x5b\x54\xf5\xec\xdc\xaf\
+\xce\x30\x66\x06\x2b\x51\x5c\x2e\x6f\x38\x60\xac\x99\x9c\xb6\x66\
+\x4d\xa2\xf2\x6a\x2d\xad\xdd\xa8\x19\x63\x53\x75\xa4\x3d\xa7\x79\
+\x0c\xae\xb3\xea\xd9\xc3\x32\xad\x07\xaa\x13\xbb\x9f\x68\x1c\xf1\
+\x70\x90\xfa\x06\xa8\x9b\x4c\xab\xa3\x84\x75\x84\x70\xac\xb6\x38\
+\xd9\x85\x95\x7b\x7b\x31\x7a\x48\x38\x55\x58\x51\xc6\x11\x56\xdb\
+\x4b\xe2\xd3\xa3\xca\xea\x6a\xda\xe6\xba\x25\x15\xf6\x14\x92\x7e\
+\xf6\x54\x84\xb3\x76\x18\xbc\xfc\x78\xb4\x35\x10\x2d\xb9\xc5\x2b\
+\x62\xa3\x6d\xd3\x3e\x43\x3a\xd7\x5e\xa1\x8a\x5f\x3b\x48\xd3\x8c\
+\x60\x5d\x53\x33\xb0\x2f\x5e\x34\x1f\xd5\xe8\xe6\x8d\xc2\xbe\x42\
+\x96\x81\xe7\x2b\xb8\x12\xde\x63\x76\xbe\x55\x20\x3c\x5c\x6d\x28\
+\x65\x98\x71\xe9\x58\x38\xb3\x97\x69\xc7\x14\x72\xe4\x5c\x1a\x2e\
+\x57\xa8\x6d\x14\xac\x2a\xde\x7b\xb8\x74\xee\xb4\x5c\xb3\x06\xcb\
+\x6b\x61\x20\x57\xa3\x15\xbd\xf5\xd2\xbd\x31\x3d\xc7\xbd\xd8\x3f\
+\x57\x1e\xa5\x9f\x26\xec\x97\xe7\x3e\x0f\x9d\xed\x81\x3c\x55\x96\
+\x74\x8b\x90\x8c\xb0\x6a\x9b\x3c\xa5\xdb\xa3\x1f\xf0\x84\x1c\xde\
+\x79\xaa\x6f\x9f\x5b\x76\xa3\x22\xf6\x55\x84\x96\x3f\x83\x28\x2e\
+\xb4\x4c\xf3\x17\x6a\x77\x77\x6f\xdb\x15\xe7\xbd\x6f\xd8\xe6\xa3\
+\xa6\x65\xcc\x96\x89\x38\x02\xf6\x66\x0b\x7c\x2d\x06\x71\x49\x68\
+\x2b\x85\x57\x87\xab\x10\xcf\x12\xcb\xc9\x34\x36\x4f\x98\xb1\x83\
+\x94\x70\x83\x0f\x43\xa6\xe5\xa3\x05\xaf\x80\x59\x91\x99\x21\x3c\
+\x29\xd4\xfb\x94\x0b\x23\x89\x3a\x5f\x09\x83\x51\x86\xc7\x16\xfa\
+\x3c\xc0\x87\xdf\x52\xa5\x3d\x27\x4c\x11\x1a\x7c\xee\x87\x91\x44\
+\x5f\x14\xb6\x1b\xed\xf2\x60\x1b\x46\x03\x57\x16\x1e\xad\x06\xd2\
+\xb3\xaa\xfb\x3a\x5a\x36\xdb\xc6\xab\x79\xb2\x87\xd7\x53\xa6\x3d\
+\xb2\x7e\xf4\xe0\xf7\x43\x6d\xb4\x96\x8e\xab\x2a\x76\x9f\xac\x95\
+\x0c\x56\x78\x3c\x46\x62\x0f\x31\x4e\xbd\xfd\x16\xe3\xf7\xa7\xb1\
+\x0c\xec\xa6\xcd\x75\xc1\xf3\x87\x97\x88\xe1\xcf\x17\xe6\x79\x6f\
+\xac\xc4\xd7\x3b\xa8\x6d\x84\x8b\x6e\xc2\xd0\xaf\x17\xc6\x0b\x91\
+\xf2\x7a\x84\xf3\x63\x5c\xb6\x86\x58\x71\xab\x85\x07\x44\x96\x2a\
+\xdb\x92\x6d\x4f\xaa\x1f\xb5\x6b\xb8\xc6\x41\x0d\x5a\xad\xaa\x7b\
+\xeb\xab\x27\x34\x9b\x4c\xf6\x56\xa9\x99\x65\x9d\xca\xca\x01\x5d\
+\xb2\xd2\x0d\x83\x19\xc4\xfb\x6c\xc4\x32\x25\x71\xfc\xaa\x64\x1c\
+\x74\x6d\x7d\x9f\xfe\xcd\x52\x1a\x0e\xa3\x43\x1b\x47\xe7\x2e\x26\
+\x8e\x39\x94\x67\x10\x39\x75\x05\x3e\xb6\x57\x27\x7c\x44\x5b\x5a\
+\x52\xab\x81\xa4\xe2\x56\x85\x56\xae\xda\x3c\x93\x68\xf6\x68\x56\
+\x03\xbe\x2e\x8d\x75\x80\x52\xe9\x03\x67\x76\x16\x7f\xd3\x36\x12\
+\xcd\x56\x5a\x88\x5e\x42\x10\xde\x49\xee\x3b\xa5\x11\x2e\xac\x6a\
+\xe4\x37\xa8\x8b\xd5\x89\x1f\x65\x5f\x62\x45\x0a\xaf\x25\x55\x51\
+\xad\x31\xce\x76\xc6\x25\x34\x42\xca\x20\x43\xb3\xd6\x2b\xa1\x68\
+\xa0\x22\x6d\x57\x81\x5a\x37\x3b\x02\x95\x8d\x32\x95\x27\x01\xbf\
+\xfd\x1e\xc6\x63\x55\x5f\x99\x2b\x28\x95\x78\xcc\xde\x4e\x8e\x37\
+\xb4\x25\x6d\x3d\x1b\xef\x62\x68\x05\xb6\x60\xc5\x25\x64\xe8\xf0\
+\x83\x51\x82\x4c\x56\x54\x11\xbf\x99\x82\x67\xb1\x50\xf6\x07\x56\
+\x54\x27\x8a\xad\x87\x7d\x36\xf9\xe1\x11\x5a\xb1\x0c\x4d\xf7\x4c\
+\xdb\xde\xbd\x57\x7c\xed\x76\x59\x2a\xf7\x0b\x63\x8a\xed\xf3\xca\
+\x94\x1f\xa1\xf3\xec\x52\xae\xf0\x79\x58\xe6\xfc\x94\x77\x91\x20\
+\xcc\xbe\xb2\xf3\xdb\x2c\xb8\xc7\x80\x9d\xfa\xcb\x85\x6b\x85\xcf\
+\x33\xf7\xbd\x75\xe6\x5a\x9e\xcd\x95\x4e\x5f\x38\x43\xc6\xea\x58\
+\xd9\x2b\x90\xde\xc6\x14\x79\x6d\x26\x12\xf1\xe3\x35\x7b\x0c\xf1\
+\xc6\xc9\x45\xf2\x69\x9b\xdd\x34\x6b\x2c\x33\x76\x49\x8f\xe4\xb3\
+\x23\x17\x27\xf7\x09\x75\x15\xb3\xa3\x19\x08\xe7\x97\x6e\x11\xfa\
+\x09\x7e\x21\x4c\xd0\x71\x40\x71\xe7\x0b\x6f\x0b\xcf\x0b\xff\x10\
+\x50\xb0\x30\xe9\x35\x31\xfb\x44\x60\xb3\xd0\x4d\x87\xe8\x62\xa8\
+\xc0\xa2\x83\xdf\x21\xc7\x5c\x86\x40\x7f\xfd\x0c\x80\xbe\x70\xce\
+\xed\x5d\x61\xaa\x50\x2b\xf8\xcd\x5e\x4a\x6e\x47\xd2\x09\x89\xea\
+\x81\x7d\x8f\xd4\x13\xe4\x28\x19\x47\x3b\x84\x43\xf6\x7e\x15\x89\
+\x6e\x13\x64\x24\xa3\xc3\x34\x92\x8e\x66\x20\xce\x81\x3f\xce\x36\
+\x85\x41\x07\x8b\xc9\xb9\xc2\x63\xc2\xd5\xc2\xc7\x61\x30\xcd\xf0\
+\x60\xc5\xea\x0f\xc2\x55\x82\x77\x1c\xd6\x54\x1a\x08\x93\x86\x89\
+\xd9\xe9\xc2\x74\x61\xbc\xf0\x72\x98\xcc\xf3\xf0\x72\x0e\xbd\x9e\
+\xac\x3c\x67\x0a\x6c\x06\x87\x4e\x6c\x6e\x6b\x77\xfe\x94\x8a\x8a\
+\xae\xeb\x56\x4e\xac\xbd\x7a\x41\xe3\x57\x6f\xe8\xb4\xb8\x9f\x83\
+\x29\xaa\x6e\xef\xc0\x14\x55\x78\x35\xc9\xcc\x6a\xcb\x49\x02\x27\
+\x6c\x19\xe0\xd7\x43\xec\xf7\x1d\xe2\xb5\x99\xc0\x06\x6d\xb9\x61\
+\x61\x90\x66\x71\x24\x83\xd3\xc2\x9c\x80\x3e\x47\x78\x3c\x48\xa1\
+\x9c\x79\x92\xd3\xe2\x6b\xc6\x53\xeb\xc4\xed\x8a\xfe\x76\xcc\x96\
+\x41\x5b\xad\x7d\xd0\xcb\x7f\x5c\x54\xea\xcc\xd5\x56\x9a\xd6\xf6\
+\xd0\xbd\x8d\xf3\x3d\x77\xf0\xb6\x20\x2b\x9a\x9a\x5d\x3e\xb1\x4d\
+\xb3\x5e\xcf\x15\xcc\x7c\x69\x52\x79\x4b\x33\x0f\x2f\x54\xf5\xd3\
+\xfd\xf5\x73\x1d\x83\xca\x9c\x00\xd9\x3f\x6e\x1b\x3b\xd6\x24\xfa\
+\xd4\xda\x13\x6a\x67\x88\xcf\xdc\x94\x15\x5b\x1e\x2a\xa7\xb4\x36\
+\x6b\x1b\xdf\xdb\x56\xf3\x9c\x05\x0b\x1a\x3f\x2d\x74\x0a\x38\x32\
+\x90\x9c\xa3\x9f\x75\x83\x87\x40\xf6\x5b\x8e\x11\x3e\xcc\xba\x5b\
+\x5a\x02\xa1\xce\x85\x02\x71\x33\x46\xd8\xb3\x34\x36\x45\x97\x92\
+\x92\xa5\x37\x24\xe7\x0a\x7f\x2f\xba\xb4\x34\xb4\xfa\xca\x97\xb6\
+\x96\xda\x9e\xa6\x83\xa6\xbb\x4b\x79\xfb\x28\x29\xe1\x7e\x15\x22\
+\xbd\x20\x6a\xea\xa0\xab\xbe\x14\x7a\xde\x90\xc6\x7e\x24\x33\xb8\
+\x23\xd5\x62\x3d\x5d\x9f\x6a\x9a\x65\xcc\xfd\x70\xa9\xd1\x77\xe3\
+\xe5\xe1\xe2\xdc\x0f\x4d\x5d\xc7\x34\xf5\x54\x1b\x15\xb1\x1d\x63\
+\xb6\x71\xb2\x8c\x68\x77\xf1\xf5\xdf\x4b\x31\x4d\x42\xed\x43\x55\
+\xf5\xa1\x9a\x55\x5a\x64\x24\xcb\x79\xa9\x90\x2c\x57\xcf\x65\x89\
+\x45\x35\xbd\x12\x6f\xdb\xe3\x5f\xba\x7b\x7e\xf3\xc2\xbf\x1a\xc9\
+\x03\xd8\x2e\xc8\xa2\x8e\x68\x20\x8e\x30\xfc\xe2\xf1\x2c\x01\xe4\
+\x48\xc8\x35\xa6\x9c\x9b\xba\x40\xe0\x98\x7d\x58\x0f\xf0\xec\xe1\
+\x5c\x2a\x3c\x2b\x30\x93\xec\x24\xb0\x9a\xe5\xb7\xe7\xa3\xe4\x34\
+\xe5\x6a\x9f\x73\xdf\xfd\x89\x57\xf7\x9b\x9d\x06\x28\xfd\x3c\xe1\
+\x44\x21\x78\x28\xa2\x67\x89\xaa\x81\xbd\x8f\x53\x99\x2b\x65\x1c\
+\xad\xfb\x0f\xe9\x06\x15\x34\x05\x77\xb3\x9c\xef\xf6\xb3\x2d\x46\
+\xf3\x45\x0b\x46\x0f\xe5\x19\x29\x1f\x35\xc9\x8b\xcc\x51\x86\x47\
+\xb5\x12\xf6\x42\x3c\x11\x3f\x4f\x52\x90\x73\x31\xbb\xe6\x2b\x94\
+\x9e\x55\xb2\xa5\x85\xde\x23\xe3\xbd\xd4\xe4\x5d\xab\x13\x6b\xde\
+\xfb\xc3\xc4\xda\xcb\x1a\x46\xed\x9a\xb5\xd9\xdc\xd1\x0c\x64\x81\
+\x3a\x8d\xb2\xf1\x1a\x66\x39\x06\xc2\x74\x3e\x4c\xd8\x5b\xf0\x6e\
+\xe8\x1d\xa8\x34\x16\x02\xfe\x25\x84\x45\x28\x28\x27\x0a\xa6\x0b\
+\xf2\xc6\xe9\x23\xfc\xf4\xc1\xcf\x43\xe6\x52\x78\xd2\xb3\x55\x61\
+\xd9\xaa\xde\x20\xdd\x63\xe6\xf3\x1e\x0b\x57\xe8\x93\x5e\x24\x08\
+\xdc\x97\xea\xad\xd6\x3e\x4a\xd5\x5c\x2f\xe3\x28\xfb\x19\x49\x8e\
+\xfd\xc5\x66\xbb\xf1\xf4\x85\x97\xed\x31\x4b\x6d\x08\x4c\xe9\x97\
+\xeb\x92\x0f\x4f\xac\x4e\xf4\x26\xf4\xd2\x43\x7f\x19\xaf\x64\x2c\
+\xfb\x91\x88\x53\x3a\xa7\x8c\x58\xc3\x85\xcf\x9d\xeb\x0d\xb9\xc2\
+\x32\x10\x53\xef\x71\x64\x7b\xa9\x47\x46\xe4\x5a\x59\x09\x2c\x8c\
+\x22\x33\x72\x44\xe3\xd1\x22\xcb\xe4\xca\x7e\x97\x6e\x60\x6c\x97\
+\x08\x6e\x39\xb1\x14\xcb\x4c\x12\x58\xa9\x72\x55\xe0\x93\xce\xac\
+\x34\x3b\x03\x9f\xdb\x25\x27\xfd\xbf\x4a\xfe\x5b\xb8\x59\x70\x1b\
+\x1d\x67\xc1\x38\xdf\x16\xa8\x2f\x55\x13\xa7\xfd\x54\x93\xd1\x58\
+\x29\x64\xd9\xc6\xa1\x70\x6c\xbe\x7e\xde\xe7\xf2\x85\xa3\x8b\x33\
+\x8e\x56\x09\xe8\x01\x7c\xe9\xa5\x2f\xdc\xd8\xa9\x7b\xe7\x9d\x95\
+\xb6\x7b\xc9\x92\x51\x41\x79\x15\x76\x65\x8e\xed\xd5\xb3\xcb\xcb\
+\x9a\xa5\x26\xb9\x79\x65\x2b\x75\x09\x35\xf5\x1c\x37\x65\x40\xcd\
+\xa0\xde\x77\xd6\x0c\xea\xf3\x60\xf5\xc0\x3e\x0f\xa4\x31\xa8\xef\
+\xfd\xbd\xae\x9c\xbe\x63\x09\xec\x56\x96\x22\x18\x1b\x0f\xd1\x5e\
+\xef\x86\x97\x6e\xb7\xa3\x0d\xed\xd8\xf9\xe9\xe2\xcd\xd2\xb5\x9b\
+\x78\x39\xcd\x3b\xab\xe4\x6c\x82\x69\xc7\x8f\x92\x71\x6c\x9c\x33\
+\x43\x11\x37\xf4\xba\xf5\x33\xf3\x3f\x9b\xf9\xb7\x22\x8a\x64\x65\
+\xfd\xf6\xaa\x61\x75\x76\xca\xbe\x9b\x23\x51\x59\x37\x8b\x4e\x30\
+\x3b\x59\x96\x39\x92\x8d\x4c\x77\xd1\x50\x66\x90\xb8\x99\xa8\xd2\
+\x0f\x7d\x1d\xa2\x78\xae\x87\x13\x86\xb2\x2a\x11\x8b\xc5\x59\x1e\
+\x7d\xa5\xe8\xb6\xae\x3c\x05\xbe\x55\x53\x38\x1f\xe5\x25\x6f\xd8\
+\xe5\xbd\xbf\x32\x5e\xb3\x8f\xe3\xf7\xac\xe1\x17\xc6\x65\xb5\x9f\
+\x5f\x0f\x91\x67\xd8\x33\xeb\x46\x09\x09\xfa\x7d\x83\x16\x23\x95\
+\x7a\xce\xe7\xb4\x76\xd1\xdc\x14\xa2\xfd\x2d\x61\x76\xfa\x42\x05\
+\x59\x78\x28\x8f\x4c\x63\x4b\x19\x09\x2b\x7c\xad\x3a\xdb\x3a\x83\
+\x98\xcd\xfa\x39\x2e\xb5\xbc\x4d\x0d\x72\x17\xb6\x65\xe3\x65\xf2\
+\x53\x2a\x55\x72\xbc\xaf\x82\x59\x46\xaa\x66\xa4\xcc\x4e\x3a\x27\
+\x99\x4d\x7e\x9b\x7f\xf4\xa1\x70\x1b\xb3\x79\x05\x49\x61\xb6\xf0\
+\xe3\xed\xd7\x8e\x20\xfc\x7e\xcc\x3c\xc8\x39\x4b\xd6\x4a\x0b\xd4\
+\x97\x96\x58\xa7\x1a\x0d\x48\x48\x33\xa7\xd9\xa0\xdd\x74\xad\x5c\
+\x95\x4f\x8b\x5a\x2c\x2d\x0d\xdb\x18\x48\xf9\x64\x1b\xdd\xcd\x98\
+\xb5\xa1\x9b\x51\xab\x81\xa8\xc1\x0d\xba\xc1\x91\x84\x56\xe2\xe1\
+\xc7\xb2\x4d\x62\xd4\xf6\xa1\xe4\xb4\x6e\x96\x9d\xb5\x93\x4c\x5d\
+\xdf\x2e\x36\x9a\xda\xb4\x25\xd3\x80\x85\xfa\xf4\x0e\x28\x4b\xa3\
+\x3c\x68\xb6\x07\x6d\x20\xa6\x3c\x73\x78\x89\x76\xac\x6a\xf4\x73\
+\x35\x98\xe5\x4f\x37\xe1\x84\x58\x62\x2e\x48\x96\x1d\xef\x22\x6f\
+\xb1\x46\xc1\x8c\x01\x32\x88\xcf\x52\x3b\x65\x85\x75\xa4\xbf\x59\
+\xab\x67\xe8\x6e\xd9\x94\xde\xa7\x31\xdb\xbe\x30\xd8\xea\x51\x34\
+\x81\x7c\x19\x8f\xc5\xe6\xa8\x16\x8f\x10\xcd\x93\xab\x27\xce\xf8\
+\xd2\x36\x9a\x5e\x6c\x49\xa5\xbe\xf7\xb6\xc2\x6a\xb6\x5a\xb4\xa2\
+\xd1\x67\xd9\x51\x79\x1c\x6e\x86\x64\x5d\xda\x93\xa9\xa9\x1a\x3f\
+\x65\x1d\x2d\x3a\xb7\xf5\x5c\x3a\xcb\x9e\xb0\xac\x4a\x3b\x6e\x1e\
+\xa3\x39\x6b\x88\x97\xa7\x9e\x99\x66\x6a\x5d\x3a\xab\x2e\xe5\xc3\
+\xeb\xa0\x9c\xee\xdd\x58\x36\xbf\x46\x0b\x18\x0e\x4b\x85\x21\xc4\
+\xa3\xe9\x59\xa3\xbf\x70\x91\xc0\x72\xa0\x9b\x08\x55\x78\xe0\x2d\
+\x97\x88\x75\x43\x51\xb8\x02\x0d\x41\x3e\xac\x56\x21\x23\x6f\x68\
+\xc8\x3e\x0c\x67\xc2\x82\x91\x06\x3a\x58\xc6\x02\xb9\xbc\x91\x4a\
+\x81\xec\x79\x6f\xd7\x7d\x6f\x1b\x7d\xe2\x1a\xfb\x70\x9a\xa6\x37\
+\x67\xdb\x3c\x97\xb7\x2a\xee\xb7\xc9\xa1\xf3\x3b\x4d\x98\x31\x59\
+\xd5\x0c\x74\x37\x48\x22\xd1\x9b\x86\xc6\xcd\x96\x9d\xa8\xb7\x4c\
+\x3b\x7b\x33\x45\x11\xac\x36\x6d\x3a\xe9\x99\x03\x0f\xd3\x4a\xfa\
+\x2e\x71\x9a\x63\x0d\xb3\xe2\x02\xcd\x12\x6d\x5b\x5f\xa1\x57\x5c\
+\x6c\x2d\x63\xda\x3a\x4e\x91\x7d\xaa\xf3\x7b\xdb\x4e\xb1\x27\xe0\
+\x17\x62\x7d\xa0\xf4\x37\x04\x96\x5f\xdd\xc4\xaa\xd2\x83\x02\xde\
+\xd0\x2f\xce\xf6\x64\x2f\x78\x89\x5c\x30\x42\xbf\x35\x76\x14\xea\
+\x1f\x05\x39\xe4\xcf\xc0\x20\x8c\x12\x38\x77\x15\x86\x41\xe7\xab\
+\x0d\x23\x64\xe9\xd8\xef\xfc\xd3\xcb\x4a\x2f\xb4\xff\x90\x8f\x77\
+\x87\xbf\xd7\xc6\xb3\xdb\xa9\x96\x49\x86\x15\x3b\x50\x46\xd1\x26\
+\x64\x91\x76\x27\xa4\xc8\x5a\xed\xf0\xb7\xd2\x74\xaa\xff\x2d\x79\
+\x5f\x73\x2d\xbf\x7b\x39\x7d\x91\x6d\x3f\x55\xd7\xdc\x32\x25\x87\
+\xe4\x99\x4a\xd9\xcd\x66\x75\xcc\xbb\xeb\x8c\x22\xb0\x7f\xd0\x9e\
+\x84\xf1\xb1\xb2\xf5\x65\x08\x95\xf4\x15\x8f\x8d\x42\xe0\x53\x2a\
+\x0b\x5e\x54\x63\x37\x3d\x94\xf0\xa4\xa8\x46\x28\xba\x28\x2a\xff\
+\x8f\x98\xb9\xcd\x74\x52\x37\x66\xc8\x4c\x2d\xbf\xc9\xb3\xd9\x5f\
+\xfd\x28\x6d\xb2\xed\x57\x53\x66\xf3\x18\x23\x39\x34\xdf\xa0\x3d\
+\xad\xb6\x5d\x23\xf8\x85\x60\xed\xd9\x6c\x45\x8a\xe9\xc3\x85\xf7\
+\xb4\x67\x25\x2b\x88\x37\xbb\xf7\x84\x5c\x53\x83\xd6\x67\x1a\xfa\
+\x75\x1d\x4d\xed\x41\xf3\xe7\xcb\xa7\x65\xd9\x16\x33\xde\x84\x3c\
+\xcb\xa7\xaa\x06\xb1\x33\xc3\xe1\xa5\xd6\x28\xb4\x69\xc3\x2b\x6b\
+\x1f\xa4\x6e\xd4\x2e\x7f\x56\xcc\x74\xa2\xe2\x9b\xb7\x04\xbf\x30\
+\xa7\xfc\x4e\x65\x71\xb0\x97\x4a\xf8\x8f\xc9\x38\x46\xd6\x8d\x1a\
+\x4a\x18\x95\x8f\x08\x49\xf0\x7c\x17\x0a\xb3\xf3\x65\x0c\xf1\x1e\
+\xfb\x07\xe3\x05\xc2\xa2\xb0\x1e\x2e\x43\x6c\x5e\x60\x56\x8c\x27\
+\x21\xd5\x29\xc2\xdd\x42\xe0\xf1\x95\x69\x68\xc9\xdb\xf4\x5b\xf2\
+\x0e\x5c\xb9\x2b\x63\x83\x96\x79\x59\x42\x2f\x9f\xf4\xfb\xce\x9a\
+\x8e\xb2\x8e\x88\x94\xc2\x98\xfd\x14\x79\x80\x36\xbc\xda\x3e\x3c\
+\x2f\xe3\x6a\xcf\x1b\xbd\xcb\x33\xfa\x5d\xde\xf7\xac\x0a\xe3\x18\
+\x59\xd4\x01\x7a\x9a\xd8\x48\x0a\xdc\x83\x17\xe4\x7d\x2b\xd6\x94\
+\x99\x0e\xc3\x3c\xb4\x6c\x03\xc7\xf4\xf5\x3a\xca\xaf\x75\x5c\x5b\
+\x9e\xcc\x7c\x47\x9f\x0f\xd9\x4d\x0d\x8f\xd7\x27\xf7\x0d\x3a\x00\
+\xac\x70\xfd\x4e\x20\x86\xfe\x85\x30\x4c\x60\x09\x92\x97\xa5\xc2\
+\x98\xbe\x51\x1c\xea\xe0\x30\xdf\x0c\xe1\x5e\xe1\x55\x21\xdf\xf3\
+\x02\x65\x9a\x04\x3c\x90\xe3\x85\x90\x6f\x2e\xef\x06\x2f\x64\x93\
+\x8f\xa7\x6e\x97\x4d\xb4\x0b\xa3\xfe\x54\x78\x42\x60\x57\xfd\x3f\
+\xc5\x72\x5d\x60\x34\x7d\x53\x6d\xc6\x67\x6a\xa8\xdb\x2c\x83\x16\
+\xcb\x67\x59\x7e\xf3\xfd\xba\xaf\x97\x7a\x37\x2d\x4b\x63\x25\x23\
+\xd7\x26\xc3\x9b\x96\x69\x9c\x50\x2a\x03\x57\xb9\x79\x3a\x84\xdc\
+\xc6\x41\x17\x54\xa6\xca\x4b\x26\xf7\x34\xba\x56\xf4\xb3\x62\xe6\
+\x5a\xda\x9d\xc8\x32\x02\x8d\x71\x2a\x66\x59\xda\x5c\x31\x27\x4a\
+\x35\x5b\x7f\x89\x84\xd9\x47\x5e\xe7\x2a\x85\x6c\xd3\x8d\x54\xf6\
+\x5e\x4a\xcc\x4c\x7d\xb7\xb4\x39\x35\x57\x16\x31\x47\x21\x15\xca\
+\x58\x2a\x61\xb4\x55\x42\x3f\x81\x07\x6b\xbf\x7d\x8b\x62\x79\xa3\
+\xb8\xac\x96\x7d\x2e\x7c\x23\xe4\x52\x72\x37\x5f\x56\x88\x78\x36\
+\xea\x2e\x38\x9e\x19\xf9\xb2\xf2\xe6\x5d\xf5\x22\x7d\x0b\x81\x67\
+\xa6\xc0\x5e\x5c\x79\x4b\x21\xda\x4e\x48\x35\x4b\x60\x11\xa3\xe4\
+\xfa\x7a\x8d\x7b\x69\xa4\xf4\xe0\x76\x3f\x67\x18\xb4\x61\x69\x2f\
+\x9d\x32\x4e\xad\x1f\x33\x78\x52\xd0\x32\x85\xf2\xa5\x7f\x29\x3e\
+\x96\x50\xe8\x6d\x0e\x28\x94\x37\xdf\x7d\x39\xea\x07\xe7\x37\x7e\
+\x79\x82\xfb\x3d\x92\x82\x06\x92\x8f\xa1\x73\xaf\x6a\x7c\xed\xf6\
+\xa6\x69\x4d\xd6\x34\xc2\x01\xbb\x34\xb1\x93\x9e\x32\x53\x47\xea\
+\x27\x83\xc2\x3a\x1b\x15\xa4\x29\x51\x9e\x76\x94\x80\xde\xd6\xeb\
+\x55\x91\xe8\x7a\x9f\x56\x27\x87\x97\x51\xcd\xf3\x4b\x1b\x1b\x8e\
+\x0e\xf3\xad\x3f\xda\xc2\xaf\xc5\xeb\xdd\x93\x09\x6a\x9b\x5f\x54\
+\x54\xb0\xb9\x32\xdc\x2f\x5b\x6c\x73\xc4\x82\xcb\x76\x21\x62\x68\
+\x25\xff\x90\xa9\x20\xbb\x60\x19\x62\xfc\xc3\xac\x88\x3a\x8c\x04\
+\x50\xea\xe6\x16\x1d\xe0\xb4\xd3\xaf\x22\x17\x4f\xb6\xf1\xae\x7e\
+\x48\x6a\x54\xd8\xc6\x41\x43\xec\xc6\x86\xdb\xd4\xae\x7b\xd2\xc7\
+\x58\x8a\x24\x39\xf3\xc5\x7a\x48\xb8\x42\xc6\x41\xc8\xde\x86\xda\
+\xd5\x40\xbc\x95\x45\xd7\xab\xbe\x04\x16\x8e\x1d\xfc\xcf\x66\x23\
+\x75\xbc\x94\xea\x29\x21\xd0\x9e\x93\x62\x3a\x9e\xcd\x9e\x57\x50\
+\x71\xfc\xfc\xb1\x83\xdf\x6c\x0f\x29\xf0\xfc\xda\xd4\x60\x5c\xa4\
+\x27\xde\x5f\xa9\x5d\x81\x4e\x07\xd0\x0e\xcd\x1c\x1f\x09\x67\xcd\
+\x6f\x6c\xba\x93\x4b\x6f\xdb\x4a\x9a\x8e\xbc\x4c\x14\x4c\xd9\xfa\
+\x0f\x22\xfa\xa3\x9f\x03\x6b\xdd\x25\xd5\xae\x8a\xa5\xa6\x46\xd4\
+\xe1\x24\xb0\x60\xf4\xae\xef\xe8\xd4\xeb\xb1\xb1\x44\x6c\x7f\x85\
+\x35\x07\x69\x90\x37\x55\x27\xbb\xeb\x19\x74\x79\xc4\xb0\x4c\x0f\
+\x1a\x94\x30\x53\xcb\xb0\x8f\x37\x36\x37\x3c\xd1\x1e\x33\x87\x5b\
+\xb8\x8b\xae\x1e\xbc\x40\x3f\x59\x3b\xb6\xa6\xdf\x4f\x9f\xd1\xb1\
+\xfc\x11\x7a\xfe\xdd\x51\x2b\xb2\xd5\x52\xcb\x36\xcf\xa5\x6a\xf3\
+\x52\xbd\x69\xf8\xb9\xee\x4d\x95\xe9\xfe\xb1\x2e\x39\x98\xe7\x44\
+\x5f\x5d\x0d\x25\x04\xea\x9e\x9c\x56\xdd\x29\x11\x1b\x26\x41\x2c\
+\x7f\x88\x67\x41\xd9\x6e\x7a\xa9\xd8\x97\x61\x3a\x9c\x36\x75\xf4\
+\x0e\xe9\x07\xdb\xba\x26\x7a\x55\xc6\x53\x89\x2e\x46\x8b\xd6\x92\
+\x1c\x8a\xa5\xec\x66\xab\xe9\xbb\x25\x4d\xf5\x0b\xc2\xf8\xf1\x84\
+\xa2\xc5\xa8\xdf\x7e\xee\xf9\xc3\x1e\x3d\xcd\x6e\x8d\x3d\xec\xe6\
+\x8a\x36\x06\x12\x33\x9a\x1b\xeb\x1b\x1a\x17\x78\x5f\x8e\x2a\xba\
+\x8e\xa8\x40\x24\x81\x48\x02\x91\x04\x22\x09\x44\x12\x88\x24\x10\
+\x49\x20\x92\x40\x24\x81\x48\x02\x91\x04\x22\x09\x44\x12\x88\x24\
+\x10\x49\x60\x55\x96\x00\x4b\xe7\x3e\x47\x72\x56\xe5\x2e\xad\xbe\
+\x6d\xcf\x77\x6e\x89\x7b\x1b\x09\x3b\x09\xeb\x0b\xbc\x2c\xe5\x77\
+\x0c\x9d\xf3\x4f\xdb\x0b\xfc\xf6\x12\x67\xb1\xf8\x6d\x2a\xf7\x01\
+\x3c\xbd\x47\x92\x7e\x61\x87\xb3\x4d\xce\x5a\x33\x2f\xef\x70\x16\
+\x89\xb3\x4b\xdc\xe3\x64\x67\xbe\xe3\xeb\x2c\x1f\xae\x2b\xd0\x16\
+\x9d\xfb\x4a\x9f\x8d\xe2\x6d\x38\x87\x9f\x7e\x8e\xc6\xe0\xd7\x36\
+\xbe\x70\xa5\xe9\x6b\x68\x84\xd2\x0f\x16\xd8\x58\x2d\xf4\xba\xed\
+\x31\xca\xb3\xad\x50\xee\x4b\x55\xde\xc6\x23\x03\xe4\xc5\x99\xb3\
+\x39\xde\x9b\x45\x5e\x33\x4e\xbb\x09\xc8\x3d\xfb\x25\xb8\x22\x99\
+\xe5\xc8\xde\x5f\xe9\x5b\x0a\x8c\x89\xef\x81\xd5\x1c\xe5\x56\x89\
+\x64\x5e\x3e\xe2\x68\x37\x87\xec\x38\x1e\xcd\xe7\xdf\x85\x83\x3c\
+\xad\xdf\x45\xd7\x2f\x66\xee\x73\xfc\xe0\x63\x81\x1d\x49\x94\xde\
+\x21\x5e\x5b\x7d\x52\x70\x0e\x32\xf2\x5b\xb7\x37\x08\x9c\x9a\x84\
+\xe7\x7b\x42\xad\x00\x2f\x3f\x42\x29\x39\xb1\xfb\x4f\x81\xbc\xb4\
+\xe7\x7d\xe1\x1c\xc1\xf1\xd4\xb4\xf5\x71\xc1\xef\xad\x39\x25\x97\
+\x4d\xdd\xc4\xe1\x25\xe1\xe4\x00\x9c\x68\xcb\x84\x00\xf9\x8a\xcd\
+\x82\x1c\x26\x09\xf7\x0b\xf9\x1c\x5b\x10\xbe\x1b\x28\xd3\xbf\x84\
+\xdd\x82\x64\x2e\x31\xcf\xa9\x2a\x37\x5d\x40\x76\xab\x2c\xe5\x3a\
+\x6a\x72\xac\x7a\x74\xba\xf0\x2b\x81\xd7\x5b\xf7\x17\x50\x90\x5f\
+\x0b\x5b\x67\x7a\xcb\xac\x72\xa3\x80\x37\xe3\xd5\xd1\xbd\x04\xca\
+\x30\x9b\x5c\x26\x38\x83\x88\xb1\x71\x88\xd1\xd9\x44\x42\x70\xe4\
+\x3d\x4b\xd8\x53\xc0\xe8\x3e\x17\xae\x13\x98\x6d\xbc\xb4\x9b\x12\
+\xc6\x0b\x7f\x11\xf6\x15\x68\xcf\x6d\xc2\xc5\xc2\x3e\x02\x04\xef\
+\x5c\x7d\xc9\x64\x29\xfb\x03\xfe\x41\x36\x56\x99\xd5\x7c\x77\x65\
+\x4b\x6c\x01\x8e\xa5\x3a\xc3\x33\xa9\x4f\x5e\x74\x0a\xc3\x23\x97\
+\x6b\x64\x85\xba\xe3\x8c\x49\x10\x99\x15\xe2\xf5\xa3\xdd\xf7\x3b\
+\x6a\xc2\x71\x6d\x0c\x84\x53\xb8\xee\xf3\x29\xe3\x74\x8d\xf2\x1f\
+\x21\x10\x3e\xa0\xac\x0c\x1e\xc6\xf0\xa9\x00\xbd\x20\xa0\xcc\x28\
+\x31\x7c\xbc\xe1\x08\x1e\x7f\x88\x30\x35\x93\x57\x1f\xe9\x90\x8c\
+\x37\x04\xaf\x14\x30\x10\x5e\x05\x75\x08\xe1\x1e\x2d\x30\x73\x5c\
+\x2b\x38\x2f\x2b\xdd\xae\xef\xdb\x09\x3b\x0b\xbc\xe3\xe0\x47\x1c\
+\x25\xa7\x2e\x8c\x93\xf6\x82\xe6\x4c\xc6\x81\xfa\x24\xa4\x63\x66\
+\x84\x08\x13\x37\x15\x38\x27\xe4\x84\x7a\x38\x00\xca\xd3\xe6\xd2\
+\x0e\xe7\xc1\xb9\x2d\xd1\x1f\x5e\x67\xfe\xb9\xc0\x11\xff\x97\x05\
+\x94\x1f\xf9\xd5\x67\xb2\xae\xa5\xcf\xa1\x42\x4d\x26\xfd\x40\x7d\
+\x12\x4e\x32\x33\xe1\x6c\x30\x54\xc7\x00\x91\x3f\xa1\x1f\xe1\xe5\
+\x5c\xa1\x56\x70\xbf\xf0\x43\x38\xb6\x9b\xc0\xbb\xf5\xbc\xcb\xff\
+\x96\x90\xeb\x30\x9f\x73\x5c\x7f\x33\xe5\xf9\x46\x98\x2e\xcc\x17\
+\x20\xda\x48\xbb\x91\x0f\xed\xa6\x1f\x38\x4a\xc6\xf7\x13\x01\xa2\
+\x6d\x8c\x07\xf9\x88\x0e\x68\x5b\x3e\x47\x01\x0f\xea\x42\x16\xb4\
+\x09\x07\xfc\xa1\xe0\x10\xaf\x54\xef\x2a\xd0\x07\x8e\x82\xcc\x10\
+\x9c\x70\xb0\xaf\xbe\xa3\x2b\x8c\x15\x79\x78\x8f\x68\xb2\x80\x6c\
+\x70\xba\xe8\x1e\xb2\x98\x29\x94\x45\x7e\x06\xc2\xc0\xac\x2b\xdc\
+\x24\xb8\x3b\xc8\x00\xa2\x64\x5b\x0a\x28\x0d\x4a\x86\x82\xe1\xfd\
+\xdd\xf4\xb0\x2e\xfe\x24\xf8\x0d\x04\x87\xd6\xbe\x10\x50\xee\x6d\
+\x84\x8f\x05\x94\x9e\xe9\x1e\x43\x68\x14\xdc\x84\x90\x79\xe6\x98\
+\x22\x38\xc6\xc1\xfd\xa5\xc2\x05\x42\xae\x59\x03\xc1\xff\x56\xa0\
+\xbe\x3a\xe1\x97\xc2\x1d\xc2\x2d\x02\x74\x91\xf0\x99\x30\x3a\x73\
+\xbd\x85\x3e\x99\x0d\x0f\xce\xa4\x6f\xae\x4f\x8c\x10\x65\xa0\xbd\
+\x84\x78\x3f\x11\xca\xf5\xdc\x28\xfe\x6f\x32\x3c\x1b\xf4\x39\x52\
+\x40\x01\x4e\x13\xa6\x0b\xc8\xfd\x77\x02\xe3\x32\x4b\x38\x43\x40\
+\xe1\x4f\x10\x30\xee\xb3\x05\x14\x99\x50\xaf\x42\x48\x0a\x3b\x09\
+\x84\x9c\x87\x0b\xc7\x09\xcc\xd0\x28\x38\xcf\x84\xc8\x00\x25\xc2\
+\x09\x9d\x29\x5c\x2b\xdc\x2b\x78\x09\x5e\x18\x20\xc6\xf8\x9e\xb0\
+\x9e\x40\x9f\x29\xc3\xf8\x32\xd6\x94\x75\x66\x7b\xda\x37\x46\xe0\
+\x25\xb2\xab\x05\xf4\x01\x59\x12\x49\xa0\x23\xcc\xec\x1b\x0a\xb4\
+\x3d\x17\xc1\x0b\xa7\x88\x73\x60\x36\x63\x8c\xce\x13\x30\x04\xde\
+\xef\x61\x3c\xe0\x81\x8e\x20\xa7\x57\x84\xff\x13\xd0\x03\x1c\xd7\
+\x58\x61\xb6\xc0\x18\x6d\x24\xd0\x7f\xf4\xa7\x52\xe8\x21\x20\xd3\
+\x63\x05\x64\x53\x32\xf9\x29\x58\x57\x71\x43\x00\x28\x96\x97\x48\
+\xc3\x3a\x19\xa4\x35\x05\x8c\x86\x81\x83\xcf\x51\x02\xb3\x4c\x52\
+\x38\x47\xc0\xeb\xf8\xd1\xcd\x4a\xa4\x53\x7f\x16\xb0\x7a\x66\x2a\
+\x14\x16\xa1\x78\x8d\x8a\x81\xc3\x33\xf9\xb5\x05\xe1\xbb\x67\x1b\
+\x5d\xa6\x0d\x9a\xb6\x9c\x2f\xa0\x14\x47\x08\x18\x1e\x83\xcb\x60\
+\xf3\x30\x4f\x1e\xfa\x07\x1c\xc2\x9b\x31\xc8\x7c\x42\x0c\x16\x7d\
+\xa3\x3c\x8a\xc2\x60\x75\x16\xf2\x79\x44\xca\xe5\x23\xfa\x81\x51\
+\x33\xd0\x0c\xe6\x31\xc2\xb3\x42\x6f\xc1\xa9\x77\x3f\x7d\x67\x80\
+\x4f\x10\x08\x57\x2f\x17\xf0\xa4\xce\xcc\xe7\x6e\xf7\x00\xa5\x0f\
+\x17\x50\x1a\x94\xe1\x78\x01\x87\x80\x21\xc3\x8f\xba\x50\xee\xc3\
+\x84\x23\x85\x3b\x85\x53\x04\xf8\x7b\xfb\xb1\x83\xd2\x68\x0f\x61\
+\x2b\x4a\x85\xcc\x18\xdf\x93\x05\x08\x99\xba\xe5\x43\x1a\xd7\x28\
+\x36\xc4\x6c\x42\x1d\x97\x08\x18\xe9\x49\x02\x8e\x85\x3c\xde\xba\
+\x94\x94\x1e\x6b\xea\x7a\x4c\x40\x16\xc8\xf9\x4d\x81\xf6\x41\x23\
+\x84\xcd\x04\x64\x0f\x3f\x64\x31\x4c\xd8\x9b\x9b\x22\xfa\x87\x33\
+\xb9\x5b\xc0\xd0\x30\xac\x3d\x05\x66\xbc\x43\x05\x78\x22\x8b\xbd\
+\x84\xb2\xc8\xcf\x40\xe8\x90\xa3\x68\x5e\xe6\xe4\x77\xee\xe3\x4d\
+\xdd\xe5\x69\x30\xde\x1e\x61\xa3\xa0\x6b\x7b\x0b\x67\xae\xdf\xd1\
+\x27\x1d\x40\x09\x99\x6d\x50\x74\xbc\xde\x5d\x02\xca\xe2\x26\x47\
+\xb8\x7e\xed\xf4\x64\x6d\xbd\x44\xa1\xb6\x12\x9e\x16\x16\x65\x52\
+\xa7\xea\x13\x81\x6d\x99\xab\x50\x26\x9d\xfa\x70\x00\x0c\x38\xe5\
+\x31\x12\x88\xf2\x33\x05\x47\x21\x32\xc9\x45\x7d\xf4\x51\x6e\x3c\
+\xe2\x5f\x04\xbc\x3a\xce\xe0\xaf\xc2\x97\x82\xd3\x3f\x8c\xe8\x5b\
+\x61\xb1\x00\x31\xe0\x18\x05\x8a\xe6\xa5\x06\x25\x30\x93\xe2\x5d\
+\x51\x4e\xc2\x0e\xe4\x8e\x57\xaf\x11\x98\x05\x9f\x10\x90\x01\x63\
+\x35\x49\x40\x91\x08\x53\x1c\x83\xd4\xd7\x34\x6d\x27\x7c\x25\x60\
+\xbc\xd0\x5c\x61\x8a\xb0\xa3\x40\x9f\xfd\x94\xdc\x9d\xb6\xad\xf2\
+\x30\x6b\xd5\x52\x38\xf3\xfd\x71\x7d\xd2\x47\x6f\x5d\xdc\xef\x2f\
+\xd0\x46\xf2\x30\x2e\xc8\xe3\x0a\xe1\x3a\x81\xfe\xfe\x5c\x78\x4d\
+\xf8\x48\x80\xde\x16\x3e\x10\x98\x2d\x21\xe4\xf5\x99\x30\x7d\xd9\
+\x65\xfa\x15\x62\x9c\xe5\x73\x02\xbc\xd0\xa9\x39\x02\x75\x94\x45\
+\x6e\x2f\xea\x30\x62\x80\x68\xb4\xa3\xe0\xcc\x28\xdb\x08\x6f\x64\
+\xd2\xf0\xcc\xcc\x00\x78\x75\x06\x1c\x2f\xcf\xd4\x46\xe7\x10\x1a\
+\xc2\xbe\x4f\xf0\x12\xf7\xf0\x4a\xdc\xc7\x5b\x3c\x95\x01\xf9\x10\
+\xc8\x1f\x85\x3d\x84\xfb\x49\xc8\x10\x0a\x40\x7b\xfc\x8c\x6d\x90\
+\xd2\xa9\x1b\x41\x3a\x44\x1d\xa4\x31\xc3\x39\xc6\xc1\x3d\xda\x0b\
+\xe8\x8b\x1f\x21\x70\x67\x20\x73\x95\xa7\x1d\xe5\x10\xca\x4f\x3d\
+\xee\x76\xa1\xe4\x28\xac\x43\x18\x22\xce\x02\x65\x79\x57\xc0\x83\
+\xce\x10\x18\x6c\x2f\x91\x76\xa1\x70\xa2\x80\x87\xc5\x2b\xcf\x16\
+\xce\x16\x90\x1b\x46\xe5\x18\x9a\xbe\xa6\x9f\x17\x90\xbb\x1f\x75\
+\x53\xe2\x12\x81\x71\x74\x88\xfc\x84\xb8\x7e\x4e\x01\x59\xb9\xd3\
+\x71\x2a\xf4\x83\x7a\x1d\xa2\xbc\x37\x22\x70\xee\x21\x0b\x8c\x96\
+\x3a\x1d\xc2\x28\x01\x7c\x69\x0f\xdf\x1d\x82\x0f\xf2\x77\xc6\x8f\
+\xfa\x29\xcb\x98\x3a\x84\xce\x22\x4f\x08\x3d\x80\xbf\x9f\x71\x66\
+\xb2\x04\xfb\xf0\xf3\xcc\x78\x02\xe2\xbe\x61\x82\xd3\xd8\x4b\xf5\
+\x9d\xc1\xc0\x53\xbc\x2e\xd0\x60\x0c\x66\x13\x81\xb0\x05\x72\x3c\
+\xca\x60\x7d\xc7\x10\xbc\x5e\x87\xeb\x6a\xe1\x56\xe1\xc0\x74\x89\
+\xe5\x34\x4b\x5f\xe9\x9c\x57\x81\xf1\x06\x6f\x09\xbb\x08\xbd\x5c\
+\xf9\x11\xe0\x35\x02\x9e\xd3\x21\xf8\x23\x10\x06\x0a\xc5\xe8\xe7\
+\xba\x57\xa9\xef\x0c\x22\x7d\x83\x10\x1e\x86\xe0\x10\xb3\x1f\x46\
+\x05\x21\x78\x94\x78\xfd\xcc\x35\x1f\x94\x67\x76\xf3\xf6\xc9\x95\
+\xa5\xe0\x57\x14\x06\x05\xa4\x2e\x87\x30\x7c\x78\x3b\x7c\xfb\xeb\
+\x3b\x6d\x44\x0e\xc8\x91\x19\xe0\x32\xc1\xad\xb8\xba\x4c\x13\xce\
+\x89\xb0\x8f\xb0\x64\x5f\xe1\x70\x01\x19\x1d\x2a\xa0\x4c\xf4\xc3\
+\x5d\xd7\x06\xba\x3e\x43\xf0\x1b\x1b\x66\x0f\xc6\x86\xd8\xdd\xa1\
+\x0d\xf4\x85\x19\x8c\xba\x91\x17\xba\xe2\x18\x05\xb2\xa4\xed\x4e\
+\xbb\x99\x05\x31\x50\x66\x6f\x87\xe8\x8b\x7b\xe6\xc3\x19\x3b\x32\
+\x67\x66\x86\x9f\x3b\x62\xd8\x5e\xd7\x27\x64\xd2\x99\x0d\xd6\x13\
+\x9c\xfa\x30\x28\x66\x48\xda\xb9\x42\xc9\xcf\x40\x50\xca\xdf\x0b\
+\xc4\x74\xe3\x04\x84\x8c\x51\x8c\x16\xe8\x30\x9e\x1e\x7a\x56\xc0\
+\x63\xdd\x20\xec\x25\x10\xbe\x9c\x29\xe0\xcd\xb0\x66\xaf\xf5\x52\
+\xd7\x67\x02\xe5\x30\xb8\x63\x85\x2d\x84\x1d\x84\x31\x02\x83\x80\
+\xb7\xf4\xd2\xbd\x4a\x58\x4b\xb8\x5e\xd8\x59\x60\x06\x1a\x2f\xa0\
+\x20\x3c\xbf\x40\x78\x12\x84\xfd\x33\x01\x43\xa3\x8e\xa3\x84\x1d\
+\x05\x04\xfd\x4b\xc1\xed\x41\x3f\xd1\x35\x46\x07\x2f\xea\x3f\x5e\
+\x60\x00\x21\x78\x51\x7e\x84\x40\x7d\xeb\x08\xa7\x09\x1b\x09\xb4\
+\xb1\x54\x72\x42\x18\x14\x7a\x53\x01\x03\x44\x5e\x35\x82\xa3\x68\
+\x84\x10\xc8\xff\x4f\xc2\x7d\x02\xf2\x40\x8e\x5e\x59\x2a\x29\xbd\
+\xd7\x74\xa3\x40\x0c\x8e\x41\x75\x11\xe8\x03\xc6\x01\x5e\x10\x98\
+\x81\xe8\x1f\xca\x3a\x4a\x38\x4c\xc0\xb9\x35\x0b\x10\x63\x46\xd9\
+\x5a\x01\x63\x3b\x49\x40\x11\x19\x7b\xc6\xf4\x49\x01\xc2\x9b\xe3\
+\x40\xa8\x0b\xb9\x9f\x2c\xfc\x44\x70\xe4\xf1\xb2\xbe\xa3\x1b\xa7\
+\x0a\x94\x1f\x22\x20\x7f\xb7\x43\x39\x57\xd7\x8c\x25\xe3\x84\xfc\
+\xdf\x11\xce\x12\x70\xb0\x84\x83\x13\x04\xda\x8a\xee\x3c\x25\xe0\
+\x8c\x0f\x11\xe8\xe7\xff\x08\x8c\xe3\x64\xc1\x21\x3f\x99\xb8\x6e\
+\xfb\xca\xcc\x7d\x3f\xd0\x77\x47\x29\xbc\x99\xf1\x5c\x08\x9c\xe9\
+\x1a\xa1\x22\x88\x0f\x04\x94\xc7\x11\x0a\x56\x4e\x07\xc7\x0a\x37\
+\x09\x08\x03\xcf\x70\x9d\x80\xe2\x39\x5e\x6f\x9e\xbe\xcf\x12\x28\
+\xc7\xc0\x5c\x29\xc0\xe7\x62\xc1\x31\xd0\xcf\xf5\x9d\xba\xde\x17\
+\xbc\xc4\x0c\x82\x82\x63\x54\x77\x09\xd4\x83\xc7\x42\xe0\xaf\x64\
+\x32\x4f\xd7\x27\x0a\x0d\x4f\x94\xf9\x56\x01\x8f\x46\xbb\x50\x08\
+\x66\x94\x4b\x04\xca\x41\xf7\x08\x03\x85\x49\x02\x6d\x46\x11\xf9\
+\x74\x14\xe7\x0f\xfa\x8e\x02\xff\x56\x40\xd9\x3e\x16\x1e\x17\xdc\
+\xe1\x91\x2e\x8b\x22\xda\xc1\xac\x07\x50\x14\xf8\x62\x34\xcc\x18\
+\xce\x60\x4f\xd5\xf7\xa3\x85\x2b\x04\x0c\x05\x8f\x8b\x8c\xae\x16\
+\x9e\x16\x68\xbf\xe3\x85\x5f\xd3\xf7\x5b\x84\xf3\x05\xe4\x83\x02\
+\x93\x86\x71\x41\x18\x0f\xb3\x05\xb2\x40\xf6\xf4\x0f\x23\xa1\x5e\
+\x42\x21\x9c\x00\x8a\xce\xb8\x3e\x2f\xe0\x00\x2f\x10\x30\x02\xf4\
+\xe2\x61\xe1\x21\x01\xfa\x48\xb8\x4d\x20\x3f\x8e\x0d\xe5\x7e\x44\
+\xa8\xe3\xa6\x08\xf9\x24\x85\x8b\x04\x66\x33\xe4\x34\x45\x58\x43\
+\xa0\xdf\x10\x8e\xa0\x9f\x80\x21\x31\xfe\x97\x09\x38\xe0\xfb\x04\
+\xfa\x4f\x3b\x90\x0d\xf4\x9c\x30\x40\xb8\x50\xa0\x4d\x8c\x39\x06\
+\x44\xff\x20\xf8\x7f\x2a\x38\xbc\xd1\x35\x8c\xee\xbb\x65\xb7\xd3\
+\x7f\x67\x0b\x65\xcf\x38\x85\xac\xb0\x97\x2a\x59\x57\xa0\x01\x0b\
+\x04\x3c\x0c\x5e\x05\x01\x39\x84\xe7\xc1\xba\x31\xa8\x2f\x04\x84\
+\xc6\x54\xbd\x44\x40\xe1\xf0\x50\x0c\x2a\x1e\xdc\xf1\x28\x4c\x9d\
+\x6b\x0b\x4c\xeb\x08\x8b\x72\xe4\xcf\x47\xdd\x75\x93\x7a\x28\x4b\
+\xe7\xdd\xca\x4a\x3f\xe0\xc5\x3d\x14\x0e\x85\x60\x20\x18\x10\x06\
+\x69\x8e\x40\xfd\x6e\xa2\x8d\xf4\x0d\xe3\xf9\x5a\x80\x3f\x3c\x1d\
+\xa1\xa3\x70\x18\x09\xca\xf2\x99\x00\x6f\xbc\x1b\xed\xcd\x47\x28\
+\x21\x7d\x46\xe1\xfc\x88\xf0\xb0\xbf\x80\x92\x42\x28\xf4\x79\x02\
+\x0a\x75\x93\x80\x9c\x7f\x93\xbe\xb3\xac\x4e\x14\x04\xcf\x8a\xe2\
+\xd2\x06\xfa\x4a\x9b\x21\x8c\xa7\xb7\xb0\x96\x80\xe2\xe3\x68\x1c\
+\xc7\xc4\x7d\xe4\xee\xc8\xc0\x2b\x33\xe4\x82\xcc\x18\x2f\x47\xb1\
+\xb8\xc6\x63\xc3\x1f\x99\x39\xb2\xd0\xd7\xb4\x1c\x90\x17\xe5\x66\
+\x09\xb4\x05\x39\x3b\xe3\x46\xbb\x68\x07\xed\x41\x9e\xf4\x03\xdd\
+\x80\x17\xe3\x8e\xbc\x91\x29\x86\xea\xf0\x45\x4e\xb4\x0f\x82\xa7\
+\x5b\xc1\xe9\x1b\x6d\xc1\xd1\xc1\x8f\x71\x75\xf4\x07\xbe\xe8\x1b\
+\x75\x90\x46\x5b\x70\x06\xc8\xc0\xe9\x3f\xf5\x51\x4f\x21\xbd\x52\
+\x96\xf0\xc8\x19\xa0\xf0\x38\x76\x3c\x4e\xc3\xd5\x25\x94\x39\x08\
+\x6d\xa0\x4c\xef\x0a\x7b\x08\x28\xd8\x63\x02\xb3\x05\x83\x8b\x12\
+\xf4\x14\xae\x12\xf0\xa8\x28\x66\x44\x2b\x58\x02\x78\x85\x62\xc8\
+\xed\x51\x8a\x29\xb7\x3a\xe5\x7d\xa6\x88\xce\x32\x23\x11\xdf\x13\
+\x4e\xe1\x09\x09\x63\x2e\x17\x9e\x10\xf0\xbc\xcc\x36\xcc\x84\xe3\
+\x04\xf2\x44\xb4\x82\x25\x50\x28\xc4\x5a\xc1\xcd\x59\xed\xaa\xc3\
+\x41\x11\x6a\x12\xe6\x10\xba\x31\x1e\x84\x15\x9b\x0a\x18\x07\xe1\
+\xc8\x87\x42\xd9\xb1\xb4\x78\x44\x14\x49\x20\x92\x40\x24\x81\x48\
+\x02\x91\x04\x22\x09\x44\x12\x88\x24\x10\x49\x20\x92\x40\x24\x81\
+\x48\x02\x91\x04\x22\x09\x44\x12\x88\x24\x10\x49\x20\x92\x40\x24\
+\x81\x48\x02\x91\x04\x56\x37\x09\xfc\x17\x56\x4e\x4f\x7c\x3f\x83\
+\x3c\x91\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
+\x00\x00\x01\xfd\
+\x89\
+\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
+\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
+\x00\x00\x00\x06\x62\x4b\x47\x44\x00\xff\x00\xff\x00\xff\xa0\xbd\
+\xa7\x93\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x0b\x13\x00\x00\
+\x0b\x13\x01\x00\x9a\x9c\x18\x00\x00\x00\x07\x74\x49\x4d\x45\x07\
+\xdd\x04\x17\x06\x0f\x24\xe5\x2c\xe8\x1b\x00\x00\x01\x8a\x49\x44\
+\x41\x54\x58\xc3\xed\x96\x31\x52\xc2\x50\x10\x86\xff\xff\x11\xc5\
+\x46\x4e\xc0\x05\xf4\x02\xd8\xc9\x0c\xc6\x19\xea\x5c\x80\xd6\x26\
+\x36\x10\x1b\x4a\x1a\x90\xc6\x54\x5e\x82\xca\x82\x99\xa0\x33\xb6\
+\x5c\x00\x2f\x10\x2f\x10\x1b\x1c\x34\x6b\x11\x64\x44\x60\xf2\x1e\
+\x43\x26\x4d\xb6\x4c\x36\xbb\xdf\xdb\xfc\xff\xce\xa3\x88\x20\xcf\
+\x50\xc8\x39\x0a\x80\xdc\x01\x2c\xd3\x0f\xd8\x0e\x6c\x90\x5d\x90\
+\xd5\xb5\x17\x22\x21\x48\x5f\x06\x57\x23\xa3\x7a\x26\x2e\x60\x3b\
+\xb0\xa1\xd4\x63\x4a\x9a\x67\x02\x61\xf6\x0b\xc8\xae\x46\x56\x37\
+\x3b\x0d\xfc\x1f\xfb\xf6\xa8\xb0\xfd\x72\x9e\xaf\x08\xf9\x7d\x7a\
+\x70\x00\xba\xe3\x4a\xbe\x36\x2c\x97\xce\xf2\x05\x20\x2f\x0c\xca\
+\x3a\x07\x05\x48\x44\x45\x57\x1f\x16\x0e\xbd\x67\x67\xaf\x3d\xc0\
+\x4e\x50\xdb\x38\x0d\xe1\xec\x35\x5f\xc1\x08\x12\x4f\x40\x44\xab\
+\x67\x9f\xdf\x6f\xe2\x37\xa3\x0d\x00\x7a\x93\x5b\x80\x2d\x00\x69\
+\x62\x8b\x00\xf4\x30\x5f\x4c\x7e\x0b\xd1\x1d\x57\x70\x72\x64\x43\
+\xc4\xd5\xb3\xaa\xf8\x32\xb0\x1f\x56\x00\xcb\xe6\x3a\x23\x8e\x30\
+\x5f\x5c\xfe\x3d\xc1\x86\x53\xca\xd6\x93\x09\xc4\x52\x03\x6c\x69\
+\x0e\xb5\xb7\xab\x79\x52\xb2\x19\x81\xf4\x75\x8d\x0d\x00\x6a\xb9\
+\xb5\xf4\x3c\x2e\x71\x98\x5e\xd7\x9a\x6a\x6b\xb5\x13\xd4\x94\xc9\
+\xd6\xd2\x62\xec\xd7\xc3\x6c\xf6\x40\x66\x17\x12\x75\xfc\xae\x7d\
+\xba\xfb\xeb\xe9\x41\xbb\x4b\xe9\x43\x49\xbf\x1e\x42\x44\x67\x6c\
+\x26\xcd\xd3\x73\x45\x42\x19\x36\x66\xc9\x2f\x10\x75\xb3\xf4\xf7\
+\x6e\xfb\xc5\xec\x69\xb7\x4f\x72\xa3\x14\x02\x6f\x7d\x11\xdd\xbd\
+\x56\x11\x7f\xb9\x80\xd4\x56\x3e\x16\x09\x01\x4e\xa1\x2c\xdf\x54\
+\x5c\x5b\xeb\x01\x11\xc0\x29\x62\xf8\x32\x6c\xcc\x8c\xaf\x64\xc5\
+\xb5\xbc\x00\x28\x00\xb2\x88\x1f\x66\x62\x9a\xe2\x52\x1b\xa9\xf7\
+\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
+"
+
+qt_resource_name = "\
+\x00\x07\
+\x07\x3b\xe0\xb3\
+\x00\x70\
+\x00\x6c\x00\x75\x00\x67\x00\x69\x00\x6e\x00\x73\
+\x00\x09\
+\x00\x9a\xd9\x74\
+\x00\x71\
+\x00\x67\x00\x69\x00\x73\x00\x63\x00\x6c\x00\x6f\x00\x75\x00\x64\
+\x00\x08\
+\x05\xe2\x59\x27\
+\x00\x6c\
+\x00\x6f\x00\x67\x00\x6f\x00\x2e\x00\x70\x00\x6e\x00\x67\
+\x00\x08\
+\x0a\x61\x5a\xa7\
+\x00\x69\
+\x00\x63\x00\x6f\x00\x6e\x00\x2e\x00\x70\x00\x6e\x00\x67\
+"
+
+qt_resource_struct = "\
+\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x01\
+\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x02\
+\x00\x00\x00\x14\x00\x02\x00\x00\x00\x02\x00\x00\x00\x03\
+\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\
+\x00\x00\x00\x42\x00\x00\x00\x00\x00\x01\x00\x00\x1c\x63\
+"
+
+def qInitResources():
+    QtCore.qRegisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
+
+def qCleanupResources():
+    QtCore.qUnregisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
+
+qInitResources()
+
+from __future__ import (absolute_import, division, print_function,
+                        unicode_literals)
+from collections import OrderedDict
+import six
+
+
+BASE_COLORS = {
+    'b': (0, 0, 1),
+    'g': (0, 0.5, 0),
+    'r': (1, 0, 0),
+    'c': (0, 0.75, 0.75),
+    'm': (0.75, 0, 0.75),
+    'y': (0.75, 0.75, 0),
+    'k': (0, 0, 0),
+    'w': (1, 1, 1)}
+
+
+# These colors are from Tableau
+TABLEAU_COLORS = (
+    ('blue', '#1f77b4'),
+    ('orange', '#ff7f0e'),
+    ('green', '#2ca02c'),
+    ('red', '#d62728'),
+    ('purple', '#9467bd'),
+    ('brown', '#8c564b'),
+    ('pink', '#e377c2'),
+    ('gray', '#7f7f7f'),
+    ('olive', '#bcbd22'),
+    ('cyan', '#17becf'),
+)
+
+# Normalize name to "tab:<name>" to avoid name collisions.
+TABLEAU_COLORS = OrderedDict(
+    ('tab:' + name, value) for name, value in TABLEAU_COLORS)
+
+# This mapping of color names -> hex values is taken from
+# a survey run by Randel Monroe see:
+# http://blog.xkcd.com/2010/05/03/color-survey-results/
+# for more details.  The results are hosted at
+# https://xkcd.com/color/rgb.txt
+#
+# License: http://creativecommons.org/publicdomain/zero/1.0/
+XKCD_COLORS = {
+    'cloudy blue': '#acc2d9',
+    'dark pastel green': '#56ae57',
+    'dust': '#b2996e',
+    'electric lime': '#a8ff04',
+    'fresh green': '#69d84f',
+    'light eggplant': '#894585',
+    'nasty green': '#70b23f',
+    'really light blue': '#d4ffff',
+    'tea': '#65ab7c',
+    'warm purple': '#952e8f',
+    'yellowish tan': '#fcfc81',
+    'cement': '#a5a391',
+    'dark grass green': '#388004',
+    'dusty teal': '#4c9085',
+    'grey teal': '#5e9b8a',
+    'macaroni and cheese': '#efb435',
+    'pinkish tan': '#d99b82',
+    'spruce': '#0a5f38',
+    'strong blue': '#0c06f7',
+    'toxic green': '#61de2a',
+    'windows blue': '#3778bf',
+    'blue blue': '#2242c7',
+    'blue with a hint of purple': '#533cc6',
+    'booger': '#9bb53c',
+    'bright sea green': '#05ffa6',
+    'dark green blue': '#1f6357',
+    'deep turquoise': '#017374',
+    'green teal': '#0cb577',
+    'strong pink': '#ff0789',
+    'bland': '#afa88b',
+    'deep aqua': '#08787f',
+    'lavender pink': '#dd85d7',
+    'light moss green': '#a6c875',
+    'light seafoam green': '#a7ffb5',
+    'olive yellow': '#c2b709',
+    'pig pink': '#e78ea5',
+    'deep lilac': '#966ebd',
+    'desert': '#ccad60',
+    'dusty lavender': '#ac86a8',
+    'purpley grey': '#947e94',
+    'purply': '#983fb2',
+    'candy pink': '#ff63e9',
+    'light pastel green': '#b2fba5',
+    'boring green': '#63b365',
+    'kiwi green': '#8ee53f',
+    'light grey green': '#b7e1a1',
+    'orange pink': '#ff6f52',
+    'tea green': '#bdf8a3',
+    'very light brown': '#d3b683',
+    'egg shell': '#fffcc4',
+    'eggplant purple': '#430541',
+    'powder pink': '#ffb2d0',
+    'reddish grey': '#997570',
+    'baby shit brown': '#ad900d',
+    'liliac': '#c48efd',
+    'stormy blue': '#507b9c',
+    'ugly brown': '#7d7103',
+    'custard': '#fffd78',
+    'darkish pink': '#da467d',
+    'deep brown': '#410200',
+    'greenish beige': '#c9d179',
+    'manilla': '#fffa86',
+    'off blue': '#5684ae',
+    'battleship grey': '#6b7c85',
+    'browny green': '#6f6c0a',
+    'bruise': '#7e4071',
+    'kelley green': '#009337',
+    'sickly yellow': '#d0e429',
+    'sunny yellow': '#fff917',
+    'azul': '#1d5dec',
+    'darkgreen': '#054907',
+    'green/yellow': '#b5ce08',
+    'lichen': '#8fb67b',
+    'light light green': '#c8ffb0',
+    'pale gold': '#fdde6c',
+    'sun yellow': '#ffdf22',
+    'tan green': '#a9be70',
+    'burple': '#6832e3',
+    'butterscotch': '#fdb147',
+    'toupe': '#c7ac7d',
+    'dark cream': '#fff39a',
+    'indian red': '#850e04',
+    'light lavendar': '#efc0fe',
+    'poison green': '#40fd14',
+    'baby puke green': '#b6c406',
+    'bright yellow green': '#9dff00',
+    'charcoal grey': '#3c4142',
+    'squash': '#f2ab15',
+    'cinnamon': '#ac4f06',
+    'light pea green': '#c4fe82',
+    'radioactive green': '#2cfa1f',
+    'raw sienna': '#9a6200',
+    'baby purple': '#ca9bf7',
+    'cocoa': '#875f42',
+    'light royal blue': '#3a2efe',
+    'orangeish': '#fd8d49',
+    'rust brown': '#8b3103',
+    'sand brown': '#cba560',
+    'swamp': '#698339',
+    'tealish green': '#0cdc73',
+    'burnt siena': '#b75203',
+    'camo': '#7f8f4e',
+    'dusk blue': '#26538d',
+    'fern': '#63a950',
+    'old rose': '#c87f89',
+    'pale light green': '#b1fc99',
+    'peachy pink': '#ff9a8a',
+    'rosy pink': '#f6688e',
+    'light bluish green': '#76fda8',
+    'light bright green': '#53fe5c',
+    'light neon green': '#4efd54',
+    'light seafoam': '#a0febf',
+    'tiffany blue': '#7bf2da',
+    'washed out green': '#bcf5a6',
+    'browny orange': '#ca6b02',
+    'nice blue': '#107ab0',
+    'sapphire': '#2138ab',
+    'greyish teal': '#719f91',
+    'orangey yellow': '#fdb915',
+    'parchment': '#fefcaf',
+    'straw': '#fcf679',
+    'very dark brown': '#1d0200',
+    'terracota': '#cb6843',
+    'ugly blue': '#31668a',
+    'clear blue': '#247afd',
+    'creme': '#ffffb6',
+    'foam green': '#90fda9',
+    'grey/green': '#86a17d',
+    'light gold': '#fddc5c',
+    'seafoam blue': '#78d1b6',
+    'topaz': '#13bbaf',
+    'violet pink': '#fb5ffc',
+    'wintergreen': '#20f986',
+    'yellow tan': '#ffe36e',
+    'dark fuchsia': '#9d0759',
+    'indigo blue': '#3a18b1',
+    'light yellowish green': '#c2ff89',
+    'pale magenta': '#d767ad',
+    'rich purple': '#720058',
+    'sunflower yellow': '#ffda03',
+    'green/blue': '#01c08d',
+    'leather': '#ac7434',
+    'racing green': '#014600',
+    'vivid purple': '#9900fa',
+    'dark royal blue': '#02066f',
+    'hazel': '#8e7618',
+    'muted pink': '#d1768f',
+    'booger green': '#96b403',
+    'canary': '#fdff63',
+    'cool grey': '#95a3a6',
+    'dark taupe': '#7f684e',
+    'darkish purple': '#751973',
+    'true green': '#089404',
+    'coral pink': '#ff6163',
+    'dark sage': '#598556',
+    'dark slate blue': '#214761',
+    'flat blue': '#3c73a8',
+    'mushroom': '#ba9e88',
+    'rich blue': '#021bf9',
+    'dirty purple': '#734a65',
+    'greenblue': '#23c48b',
+    'icky green': '#8fae22',
+    'light khaki': '#e6f2a2',
+    'warm blue': '#4b57db',
+    'dark hot pink': '#d90166',
+    'deep sea blue': '#015482',
+    'carmine': '#9d0216',
+    'dark yellow green': '#728f02',
+    'pale peach': '#ffe5ad',
+    'plum purple': '#4e0550',
+    'golden rod': '#f9bc08',
+    'neon red': '#ff073a',
+    'old pink': '#c77986',
+    'very pale blue': '#d6fffe',
+    'blood orange': '#fe4b03',
+    'grapefruit': '#fd5956',
+    'sand yellow': '#fce166',
+    'clay brown': '#b2713d',
+    'dark blue grey': '#1f3b4d',
+    'flat green': '#699d4c',
+    'light green blue': '#56fca2',
+    'warm pink': '#fb5581',
+    'dodger blue': '#3e82fc',
+    'gross green': '#a0bf16',
+    'ice': '#d6fffa',
+    'metallic blue': '#4f738e',
+    'pale salmon': '#ffb19a',
+    'sap green': '#5c8b15',
+    'algae': '#54ac68',
+    'bluey grey': '#89a0b0',
+    'greeny grey': '#7ea07a',
+    'highlighter green': '#1bfc06',
+    'light light blue': '#cafffb',
+    'light mint': '#b6ffbb',
+    'raw umber': '#a75e09',
+    'vivid blue': '#152eff',
+    'deep lavender': '#8d5eb7',
+    'dull teal': '#5f9e8f',
+    'light greenish blue': '#63f7b4',
+    'mud green': '#606602',
+    'pinky': '#fc86aa',
+    'red wine': '#8c0034',
+    'shit green': '#758000',
+    'tan brown': '#ab7e4c',
+    'darkblue': '#030764',
+    'rosa': '#fe86a4',
+    'lipstick': '#d5174e',
+    'pale mauve': '#fed0fc',
+    'claret': '#680018',
+    'dandelion': '#fedf08',
+    'orangered': '#fe420f',
+    'poop green': '#6f7c00',
+    'ruby': '#ca0147',
+    'dark': '#1b2431',
+    'greenish turquoise': '#00fbb0',
+    'pastel red': '#db5856',
+    'piss yellow': '#ddd618',
+    'bright cyan': '#41fdfe',
+    'dark coral': '#cf524e',
+    'algae green': '#21c36f',
+    'darkish red': '#a90308',
+    'reddy brown': '#6e1005',
+    'blush pink': '#fe828c',
+    'camouflage green': '#4b6113',
+    'lawn green': '#4da409',
+    'putty': '#beae8a',
+    'vibrant blue': '#0339f8',
+    'dark sand': '#a88f59',
+    'purple/blue': '#5d21d0',
+    'saffron': '#feb209',
+    'twilight': '#4e518b',
+    'warm brown': '#964e02',
+    'bluegrey': '#85a3b2',
+    'bubble gum pink': '#ff69af',
+    'duck egg blue': '#c3fbf4',
+    'greenish cyan': '#2afeb7',
+    'petrol': '#005f6a',
+    'royal': '#0c1793',
+    'butter': '#ffff81',
+    'dusty orange': '#f0833a',
+    'off yellow': '#f1f33f',
+    'pale olive green': '#b1d27b',
+    'orangish': '#fc824a',
+    'leaf': '#71aa34',
+    'light blue grey': '#b7c9e2',
+    'dried blood': '#4b0101',
+    'lightish purple': '#a552e6',
+    'rusty red': '#af2f0d',
+    'lavender blue': '#8b88f8',
+    'light grass green': '#9af764',
+    'light mint green': '#a6fbb2',
+    'sunflower': '#ffc512',
+    'velvet': '#750851',
+    'brick orange': '#c14a09',
+    'lightish red': '#fe2f4a',
+    'pure blue': '#0203e2',
+    'twilight blue': '#0a437a',
+    'violet red': '#a50055',
+    'yellowy brown': '#ae8b0c',
+    'carnation': '#fd798f',
+    'muddy yellow': '#bfac05',
+    'dark seafoam green': '#3eaf76',
+    'deep rose': '#c74767',
+    'dusty red': '#b9484e',
+    'grey/blue': '#647d8e',
+    'lemon lime': '#bffe28',
+    'purple/pink': '#d725de',
+    'brown yellow': '#b29705',
+    'purple brown': '#673a3f',
+    'wisteria': '#a87dc2',
+    'banana yellow': '#fafe4b',
+    'lipstick red': '#c0022f',
+    'water blue': '#0e87cc',
+    'brown grey': '#8d8468',
+    'vibrant purple': '#ad03de',
+    'baby green': '#8cff9e',
+    'barf green': '#94ac02',
+    'eggshell blue': '#c4fff7',
+    'sandy yellow': '#fdee73',
+    'cool green': '#33b864',
+    'pale': '#fff9d0',
+    'blue/grey': '#758da3',
+    'hot magenta': '#f504c9',
+    'greyblue': '#77a1b5',
+    'purpley': '#8756e4',
+    'baby shit green': '#889717',
+    'brownish pink': '#c27e79',
+    'dark aquamarine': '#017371',
+    'diarrhea': '#9f8303',
+    'light mustard': '#f7d560',
+    'pale sky blue': '#bdf6fe',
+    'turtle green': '#75b84f',
+    'bright olive': '#9cbb04',
+    'dark grey blue': '#29465b',
+    'greeny brown': '#696006',
+    'lemon green': '#adf802',
+    'light periwinkle': '#c1c6fc',
+    'seaweed green': '#35ad6b',
+    'sunshine yellow': '#fffd37',
+    'ugly purple': '#a442a0',
+    'medium pink': '#f36196',
+    'puke brown': '#947706',
+    'very light pink': '#fff4f2',
+    'viridian': '#1e9167',
+    'bile': '#b5c306',
+    'faded yellow': '#feff7f',
+    'very pale green': '#cffdbc',
+    'vibrant green': '#0add08',
+    'bright lime': '#87fd05',
+    'spearmint': '#1ef876',
+    'light aquamarine': '#7bfdc7',
+    'light sage': '#bcecac',
+    'yellowgreen': '#bbf90f',
+    'baby poo': '#ab9004',
+    'dark seafoam': '#1fb57a',
+    'deep teal': '#00555a',
+    'heather': '#a484ac',
+    'rust orange': '#c45508',
+    'dirty blue': '#3f829d',
+    'fern green': '#548d44',
+    'bright lilac': '#c95efb',
+    'weird green': '#3ae57f',
+    'peacock blue': '#016795',
+    'avocado green': '#87a922',
+    'faded orange': '#f0944d',
+    'grape purple': '#5d1451',
+    'hot green': '#25ff29',
+    'lime yellow': '#d0fe1d',
+    'mango': '#ffa62b',
+    'shamrock': '#01b44c',
+    'bubblegum': '#ff6cb5',
+    'purplish brown': '#6b4247',
+    'vomit yellow': '#c7c10c',
+    'pale cyan': '#b7fffa',
+    'key lime': '#aeff6e',
+    'tomato red': '#ec2d01',
+    'lightgreen': '#76ff7b',
+    'merlot': '#730039',
+    'night blue': '#040348',
+    'purpleish pink': '#df4ec8',
+    'apple': '#6ecb3c',
+    'baby poop green': '#8f9805',
+    'green apple': '#5edc1f',
+    'heliotrope': '#d94ff5',
+    'yellow/green': '#c8fd3d',
+    'almost black': '#070d0d',
+    'cool blue': '#4984b8',
+    'leafy green': '#51b73b',
+    'mustard brown': '#ac7e04',
+    'dusk': '#4e5481',
+    'dull brown': '#876e4b',
+    'frog green': '#58bc08',
+    'vivid green': '#2fef10',
+    'bright light green': '#2dfe54',
+    'fluro green': '#0aff02',
+    'kiwi': '#9cef43',
+    'seaweed': '#18d17b',
+    'navy green': '#35530a',
+    'ultramarine blue': '#1805db',
+    'iris': '#6258c4',
+    'pastel orange': '#ff964f',
+    'yellowish orange': '#ffab0f',
+    'perrywinkle': '#8f8ce7',
+    'tealish': '#24bca8',
+    'dark plum': '#3f012c',
+    'pear': '#cbf85f',
+    'pinkish orange': '#ff724c',
+    'midnight purple': '#280137',
+    'light urple': '#b36ff6',
+    'dark mint': '#48c072',
+    'greenish tan': '#bccb7a',
+    'light burgundy': '#a8415b',
+    'turquoise blue': '#06b1c4',
+    'ugly pink': '#cd7584',
+    'sandy': '#f1da7a',
+    'electric pink': '#ff0490',
+    'muted purple': '#805b87',
+    'mid green': '#50a747',
+    'greyish': '#a8a495',
+    'neon yellow': '#cfff04',
+    'banana': '#ffff7e',
+    'carnation pink': '#ff7fa7',
+    'tomato': '#ef4026',
+    'sea': '#3c9992',
+    'muddy brown': '#886806',
+    'turquoise green': '#04f489',
+    'buff': '#fef69e',
+    'fawn': '#cfaf7b',
+    'muted blue': '#3b719f',
+    'pale rose': '#fdc1c5',
+    'dark mint green': '#20c073',
+    'amethyst': '#9b5fc0',
+    'blue/green': '#0f9b8e',
+    'chestnut': '#742802',
+    'sick green': '#9db92c',
+    'pea': '#a4bf20',
+    'rusty orange': '#cd5909',
+    'stone': '#ada587',
+    'rose red': '#be013c',
+    'pale aqua': '#b8ffeb',
+    'deep orange': '#dc4d01',
+    'earth': '#a2653e',
+    'mossy green': '#638b27',
+    'grassy green': '#419c03',
+    'pale lime green': '#b1ff65',
+    'light grey blue': '#9dbcd4',
+    'pale grey': '#fdfdfe',
+    'asparagus': '#77ab56',
+    'blueberry': '#464196',
+    'purple red': '#990147',
+    'pale lime': '#befd73',
+    'greenish teal': '#32bf84',
+    'caramel': '#af6f09',
+    'deep magenta': '#a0025c',
+    'light peach': '#ffd8b1',
+    'milk chocolate': '#7f4e1e',
+    'ocher': '#bf9b0c',
+    'off green': '#6ba353',
+    'purply pink': '#f075e6',
+    'lightblue': '#7bc8f6',
+    'dusky blue': '#475f94',
+    'golden': '#f5bf03',
+    'light beige': '#fffeb6',
+    'butter yellow': '#fffd74',
+    'dusky purple': '#895b7b',
+    'french blue': '#436bad',
+    'ugly yellow': '#d0c101',
+    'greeny yellow': '#c6f808',
+    'orangish red': '#f43605',
+    'shamrock green': '#02c14d',
+    'orangish brown': '#b25f03',
+    'tree green': '#2a7e19',
+    'deep violet': '#490648',
+    'gunmetal': '#536267',
+    'blue/purple': '#5a06ef',
+    'cherry': '#cf0234',
+    'sandy brown': '#c4a661',
+    'warm grey': '#978a84',
+    'dark indigo': '#1f0954',
+    'midnight': '#03012d',
+    'bluey green': '#2bb179',
+    'grey pink': '#c3909b',
+    'soft purple': '#a66fb5',
+    'blood': '#770001',
+    'brown red': '#922b05',
+    'medium grey': '#7d7f7c',
+    'berry': '#990f4b',
+    'poo': '#8f7303',
+    'purpley pink': '#c83cb9',
+    'light salmon': '#fea993',
+    'snot': '#acbb0d',
+    'easter purple': '#c071fe',
+    'light yellow green': '#ccfd7f',
+    'dark navy blue': '#00022e',
+    'drab': '#828344',
+    'light rose': '#ffc5cb',
+    'rouge': '#ab1239',
+    'purplish red': '#b0054b',
+    'slime green': '#99cc04',
+    'baby poop': '#937c00',
+    'irish green': '#019529',
+    'pink/purple': '#ef1de7',
+    'dark navy': '#000435',
+    'greeny blue': '#42b395',
+    'light plum': '#9d5783',
+    'pinkish grey': '#c8aca9',
+    'dirty orange': '#c87606',
+    'rust red': '#aa2704',
+    'pale lilac': '#e4cbff',
+    'orangey red': '#fa4224',
+    'primary blue': '#0804f9',
+    'kermit green': '#5cb200',
+    'brownish purple': '#76424e',
+    'murky green': '#6c7a0e',
+    'wheat': '#fbdd7e',
+    'very dark purple': '#2a0134',
+    'bottle green': '#044a05',
+    'watermelon': '#fd4659',
+    'deep sky blue': '#0d75f8',
+    'fire engine red': '#fe0002',
+    'yellow ochre': '#cb9d06',
+    'pumpkin orange': '#fb7d07',
+    'pale olive': '#b9cc81',
+    'light lilac': '#edc8ff',
+    'lightish green': '#61e160',
+    'carolina blue': '#8ab8fe',
+    'mulberry': '#920a4e',
+    'shocking pink': '#fe02a2',
+    'auburn': '#9a3001',
+    'bright lime green': '#65fe08',
+    'celadon': '#befdb7',
+    'pinkish brown': '#b17261',
+    'poo brown': '#885f01',
+    'bright sky blue': '#02ccfe',
+    'celery': '#c1fd95',
+    'dirt brown': '#836539',
+    'strawberry': '#fb2943',
+    'dark lime': '#84b701',
+    'copper': '#b66325',
+    'medium brown': '#7f5112',
+    'muted green': '#5fa052',
+    "robin's egg": '#6dedfd',
+    'bright aqua': '#0bf9ea',
+    'bright lavender': '#c760ff',
+    'ivory': '#ffffcb',
+    'very light purple': '#f6cefc',
+    'light navy': '#155084',
+    'pink red': '#f5054f',
+    'olive brown': '#645403',
+    'poop brown': '#7a5901',
+    'mustard green': '#a8b504',
+    'ocean green': '#3d9973',
+    'very dark blue': '#000133',
+    'dusty green': '#76a973',
+    'light navy blue': '#2e5a88',
+    'minty green': '#0bf77d',
+    'adobe': '#bd6c48',
+    'barney': '#ac1db8',
+    'jade green': '#2baf6a',
+    'bright light blue': '#26f7fd',
+    'light lime': '#aefd6c',
+    'dark khaki': '#9b8f55',
+    'orange yellow': '#ffad01',
+    'ocre': '#c69c04',
+    'maize': '#f4d054',
+    'faded pink': '#de9dac',
+    'british racing green': '#05480d',
+    'sandstone': '#c9ae74',
+    'mud brown': '#60460f',
+    'light sea green': '#98f6b0',
+    'robin egg blue': '#8af1fe',
+    'aqua marine': '#2ee8bb',
+    'dark sea green': '#11875d',
+    'soft pink': '#fdb0c0',
+    'orangey brown': '#b16002',
+    'cherry red': '#f7022a',
+    'burnt yellow': '#d5ab09',
+    'brownish grey': '#86775f',
+    'camel': '#c69f59',
+    'purplish grey': '#7a687f',
+    'marine': '#042e60',
+    'greyish pink': '#c88d94',
+    'pale turquoise': '#a5fbd5',
+    'pastel yellow': '#fffe71',
+    'bluey purple': '#6241c7',
+    'canary yellow': '#fffe40',
+    'faded red': '#d3494e',
+    'sepia': '#985e2b',
+    'coffee': '#a6814c',
+    'bright magenta': '#ff08e8',
+    'mocha': '#9d7651',
+    'ecru': '#feffca',
+    'purpleish': '#98568d',
+    'cranberry': '#9e003a',
+    'darkish green': '#287c37',
+    'brown orange': '#b96902',
+    'dusky rose': '#ba6873',
+    'melon': '#ff7855',
+    'sickly green': '#94b21c',
+    'silver': '#c5c9c7',
+    'purply blue': '#661aee',
+    'purpleish blue': '#6140ef',
+    'hospital green': '#9be5aa',
+    'shit brown': '#7b5804',
+    'mid blue': '#276ab3',
+    'amber': '#feb308',
+    'easter green': '#8cfd7e',
+    'soft blue': '#6488ea',
+    'cerulean blue': '#056eee',
+    'golden brown': '#b27a01',
+    'bright turquoise': '#0ffef9',
+    'red pink': '#fa2a55',
+    'red purple': '#820747',
+    'greyish brown': '#7a6a4f',
+    'vermillion': '#f4320c',
+    'russet': '#a13905',
+    'steel grey': '#6f828a',
+    'lighter purple': '#a55af4',
+    'bright violet': '#ad0afd',
+    'prussian blue': '#004577',
+    'slate green': '#658d6d',
+    'dirty pink': '#ca7b80',
+    'dark blue green': '#005249',
+    'pine': '#2b5d34',
+    'yellowy green': '#bff128',
+    'dark gold': '#b59410',
+    'bluish': '#2976bb',
+    'darkish blue': '#014182',
+    'dull red': '#bb3f3f',
+    'pinky red': '#fc2647',
+    'bronze': '#a87900',
+    'pale teal': '#82cbb2',
+    'military green': '#667c3e',
+    'barbie pink': '#fe46a5',
+    'bubblegum pink': '#fe83cc',
+    'pea soup green': '#94a617',
+    'dark mustard': '#a88905',
+    'shit': '#7f5f00',
+    'medium purple': '#9e43a2',
+    'very dark green': '#062e03',
+    'dirt': '#8a6e45',
+    'dusky pink': '#cc7a8b',
+    'red violet': '#9e0168',
+    'lemon yellow': '#fdff38',
+    'pistachio': '#c0fa8b',
+    'dull yellow': '#eedc5b',
+    'dark lime green': '#7ebd01',
+    'denim blue': '#3b5b92',
+    'teal blue': '#01889f',
+    'lightish blue': '#3d7afd',
+    'purpley blue': '#5f34e7',
+    'light indigo': '#6d5acf',
+    'swamp green': '#748500',
+    'brown green': '#706c11',
+    'dark maroon': '#3c0008',
+    'hot purple': '#cb00f5',
+    'dark forest green': '#002d04',
+    'faded blue': '#658cbb',
+    'drab green': '#749551',
+    'light lime green': '#b9ff66',
+    'snot green': '#9dc100',
+    'yellowish': '#faee66',
+    'light blue green': '#7efbb3',
+    'bordeaux': '#7b002c',
+    'light mauve': '#c292a1',
+    'ocean': '#017b92',
+    'marigold': '#fcc006',
+    'muddy green': '#657432',
+    'dull orange': '#d8863b',
+    'steel': '#738595',
+    'electric purple': '#aa23ff',
+    'fluorescent green': '#08ff08',
+    'yellowish brown': '#9b7a01',
+    'blush': '#f29e8e',
+    'soft green': '#6fc276',
+    'bright orange': '#ff5b00',
+    'lemon': '#fdff52',
+    'purple grey': '#866f85',
+    'acid green': '#8ffe09',
+    'pale lavender': '#eecffe',
+    'violet blue': '#510ac9',
+    'light forest green': '#4f9153',
+    'burnt red': '#9f2305',
+    'khaki green': '#728639',
+    'cerise': '#de0c62',
+    'faded purple': '#916e99',
+    'apricot': '#ffb16d',
+    'dark olive green': '#3c4d03',
+    'grey brown': '#7f7053',
+    'green grey': '#77926f',
+    'true blue': '#010fcc',
+    'pale violet': '#ceaefa',
+    'periwinkle blue': '#8f99fb',
+    'light sky blue': '#c6fcff',
+    'blurple': '#5539cc',
+    'green brown': '#544e03',
+    'bluegreen': '#017a79',
+    'bright teal': '#01f9c6',
+    'brownish yellow': '#c9b003',
+    'pea soup': '#929901',
+    'forest': '#0b5509',
+    'barney purple': '#a00498',
+    'ultramarine': '#2000b1',
+    'purplish': '#94568c',
+    'puke yellow': '#c2be0e',
+    'bluish grey': '#748b97',
+    'dark periwinkle': '#665fd1',
+    'dark lilac': '#9c6da5',
+    'reddish': '#c44240',
+    'light maroon': '#a24857',
+    'dusty purple': '#825f87',
+    'terra cotta': '#c9643b',
+    'avocado': '#90b134',
+    'marine blue': '#01386a',
+    'teal green': '#25a36f',
+    'slate grey': '#59656d',
+    'lighter green': '#75fd63',
+    'electric green': '#21fc0d',
+    'dusty blue': '#5a86ad',
+    'golden yellow': '#fec615',
+    'bright yellow': '#fffd01',
+    'light lavender': '#dfc5fe',
+    'umber': '#b26400',
+    'poop': '#7f5e00',
+    'dark peach': '#de7e5d',
+    'jungle green': '#048243',
+    'eggshell': '#ffffd4',
+    'denim': '#3b638c',
+    'yellow brown': '#b79400',
+    'dull purple': '#84597e',
+    'chocolate brown': '#411900',
+    'wine red': '#7b0323',
+    'neon blue': '#04d9ff',
+    'dirty green': '#667e2c',
+    'light tan': '#fbeeac',
+    'ice blue': '#d7fffe',
+    'cadet blue': '#4e7496',
+    'dark mauve': '#874c62',
+    'very light blue': '#d5ffff',
+    'grey purple': '#826d8c',
+    'pastel pink': '#ffbacd',
+    'very light green': '#d1ffbd',
+    'dark sky blue': '#448ee4',
+    'evergreen': '#05472a',
+    'dull pink': '#d5869d',
+    'aubergine': '#3d0734',
+    'mahogany': '#4a0100',
+    'reddish orange': '#f8481c',
+    'deep green': '#02590f',
+    'vomit green': '#89a203',
+    'purple pink': '#e03fd8',
+    'dusty pink': '#d58a94',
+    'faded green': '#7bb274',
+    'camo green': '#526525',
+    'pinky purple': '#c94cbe',
+    'pink purple': '#db4bda',
+    'brownish red': '#9e3623',
+    'dark rose': '#b5485d',
+    'mud': '#735c12',
+    'brownish': '#9c6d57',
+    'emerald green': '#028f1e',
+    'pale brown': '#b1916e',
+    'dull blue': '#49759c',
+    'burnt umber': '#a0450e',
+    'medium green': '#39ad48',
+    'clay': '#b66a50',
+    'light aqua': '#8cffdb',
+    'light olive green': '#a4be5c',
+    'brownish orange': '#cb7723',
+    'dark aqua': '#05696b',
+    'purplish pink': '#ce5dae',
+    'dark salmon': '#c85a53',
+    'greenish grey': '#96ae8d',
+    'jade': '#1fa774',
+    'ugly green': '#7a9703',
+    'dark beige': '#ac9362',
+    'emerald': '#01a049',
+    'pale red': '#d9544d',
+    'light magenta': '#fa5ff7',
+    'sky': '#82cafc',
+    'light cyan': '#acfffc',
+    'yellow orange': '#fcb001',
+    'reddish purple': '#910951',
+    'reddish pink': '#fe2c54',
+    'orchid': '#c875c4',
+    'dirty yellow': '#cdc50a',
+    'orange red': '#fd411e',
+    'deep red': '#9a0200',
+    'orange brown': '#be6400',
+    'cobalt blue': '#030aa7',
+    'neon pink': '#fe019a',
+    'rose pink': '#f7879a',
+    'greyish purple': '#887191',
+    'raspberry': '#b00149',
+    'aqua green': '#12e193',
+    'salmon pink': '#fe7b7c',
+    'tangerine': '#ff9408',
+    'brownish green': '#6a6e09',
+    'red brown': '#8b2e16',
+    'greenish brown': '#696112',
+    'pumpkin': '#e17701',
+    'pine green': '#0a481e',
+    'charcoal': '#343837',
+    'baby pink': '#ffb7ce',
+    'cornflower': '#6a79f7',
+    'blue violet': '#5d06e9',
+    'chocolate': '#3d1c02',
+    'greyish green': '#82a67d',
+    'scarlet': '#be0119',
+    'green yellow': '#c9ff27',
+    'dark olive': '#373e02',
+    'sienna': '#a9561e',
+    'pastel purple': '#caa0ff',
+    'terracotta': '#ca6641',
+    'aqua blue': '#02d8e9',
+    'sage green': '#88b378',
+    'blood red': '#980002',
+    'deep pink': '#cb0162',
+    'grass': '#5cac2d',
+    'moss': '#769958',
+    'pastel blue': '#a2bffe',
+    'bluish green': '#10a674',
+    'green blue': '#06b48b',
+    'dark tan': '#af884a',
+    'greenish blue': '#0b8b87',
+    'pale orange': '#ffa756',
+    'vomit': '#a2a415',
+    'forrest green': '#154406',
+    'dark lavender': '#856798',
+    'dark violet': '#34013f',
+    'purple blue': '#632de9',
+    'dark cyan': '#0a888a',
+    'olive drab': '#6f7632',
+    'pinkish': '#d46a7e',
+    'cobalt': '#1e488f',
+    'neon purple': '#bc13fe',
+    'light turquoise': '#7ef4cc',
+    'apple green': '#76cd26',
+    'dull green': '#74a662',
+    'wine': '#80013f',
+    'powder blue': '#b1d1fc',
+    'off white': '#ffffe4',
+    'electric blue': '#0652ff',
+    'dark turquoise': '#045c5a',
+    'blue purple': '#5729ce',
+    'azure': '#069af3',
+    'bright red': '#ff000d',
+    'pinkish red': '#f10c45',
+    'cornflower blue': '#5170d7',
+    'light olive': '#acbf69',
+    'grape': '#6c3461',
+    'greyish blue': '#5e819d',
+    'purplish blue': '#601ef9',
+    'yellowish green': '#b0dd16',
+    'greenish yellow': '#cdfd02',
+    'medium blue': '#2c6fbb',
+    'dusty rose': '#c0737a',
+    'light violet': '#d6b4fc',
+    'midnight blue': '#020035',
+    'bluish purple': '#703be7',
+    'red orange': '#fd3c06',
+    'dark magenta': '#960056',
+    'greenish': '#40a368',
+    'ocean blue': '#03719c',
+    'coral': '#fc5a50',
+    'cream': '#ffffc2',
+    'reddish brown': '#7f2b0a',
+    'burnt sienna': '#b04e0f',
+    'brick': '#a03623',
+    'sage': '#87ae73',
+    'grey green': '#789b73',
+    'white': '#ffffff',
+    "robin's egg blue": '#98eff9',
+    'moss green': '#658b38',
+    'steel blue': '#5a7d9a',
+    'eggplant': '#380835',
+    'light yellow': '#fffe7a',
+    'leaf green': '#5ca904',
+    'light grey': '#d8dcd6',