From 2c1c4c2cca5cf8f6506314fa0edc01ed84fa9509 Mon Sep 17 00:00:00 2001
From: Bobby Brennan <bobby.brennan@gmail.com>
Date: Wed, 8 May 2019 14:54:06 +0000
Subject: [PATCH 1/2] add new deps

---
 Gopkg.lock                                    |    39 +-
 Gopkg.toml                                    |     8 +
 .../gorilla/mux/.github/release-drafter.yml   |     8 +
 .../github.com/gorilla/mux/.github/stale.yml  |    12 +
 vendor/github.com/gorilla/mux/.travis.yml     |    24 +
 vendor/github.com/gorilla/mux/AUTHORS         |     8 +
 .../github.com/gorilla/mux/ISSUE_TEMPLATE.md  |    11 +
 vendor/github.com/gorilla/mux/LICENSE         |    27 +
 vendor/github.com/gorilla/mux/README.md       |   649 +
 vendor/github.com/gorilla/mux/bench_test.go   |    49 +
 vendor/github.com/gorilla/mux/context.go      |    18 +
 vendor/github.com/gorilla/mux/context_test.go |    30 +
 vendor/github.com/gorilla/mux/doc.go          |   306 +
 .../example_authentication_middleware_test.go |    46 +
 .../gorilla/mux/example_route_test.go         |    51 +
 vendor/github.com/gorilla/mux/go.mod          |     1 +
 vendor/github.com/gorilla/mux/middleware.go   |    72 +
 .../github.com/gorilla/mux/middleware_test.go |   437 +
 vendor/github.com/gorilla/mux/mux.go          |   607 +
 vendor/github.com/gorilla/mux/mux_test.go     |  2846 +++
 vendor/github.com/gorilla/mux/old_test.go     |   704 +
 vendor/github.com/gorilla/mux/regexp.go       |   328 +
 vendor/github.com/gorilla/mux/route.go        |   710 +
 vendor/github.com/gorilla/mux/test_helpers.go |    19 +
 .../golang-commonmark/html/.gitlab-ci.yml     |    16 +
 .../gitlab.com/golang-commonmark/html/LICENSE |    10 +
 .../golang-commonmark/html/README.md          |     8 +
 .../gitlab.com/golang-commonmark/html/html.go |   211 +
 .../golang-commonmark/html/html5_entities.go  |  2133 ++
 .../html/html_benchmark_test.go               |    32 +
 .../html/html_example_test.go                 |    54 +
 .../golang-commonmark/html/html_test.go       |   108 +
 .../golang-commonmark/linkify/.gitlab-ci.yml  |    19 +
 .../golang-commonmark/linkify/LICENSE         |    10 +
 .../golang-commonmark/linkify/README.md       |    12 +
 .../golang-commonmark/linkify/charset.go      |    51 +
 .../golang-commonmark/linkify/email.go        |    93 +
 .../golang-commonmark/linkify/generated.go    | 18175 ++++++++++++++++
 .../linkify/genfsm/genfsm.go                  |   162 +
 .../linkify/genfsm/suffixes.txt               |  1130 +
 .../golang-commonmark/linkify/linkify.go      |   462 +
 .../linkify/linkify_benchmark_test.go         |    22 +
 .../linkify/linkify_example_test.go           |    34 +
 .../golang-commonmark/linkify/linkify_test.go |   383 +
 .../golang-commonmark/linkify/url.go          |   404 +
 .../golang-commonmark/linkify/util.go         |    20 +
 .../golang-commonmark/markdown/.gitlab-ci.yml |    25 +
 .../golang-commonmark/markdown/AUTHORS        |     1 +
 .../golang-commonmark/markdown/LICENSE        |    10 +
 .../golang-commonmark/markdown/README.md      |    64 +
 .../golang-commonmark/markdown/align.go       |    26 +
 .../golang-commonmark/markdown/autolink.go    |    70 +
 .../golang-commonmark/markdown/backticks.go   |    60 +
 .../markdown/balance_pairs.go                 |    43 +
 .../golang-commonmark/markdown/blockquote.go  |   233 +
 .../golang-commonmark/markdown/code.go        |    37 +
 .../golang-commonmark/markdown/emphasis.go    |    89 +
 .../golang-commonmark/markdown/entity.go      |    35 +
 .../golang-commonmark/markdown/escape.go      |    61 +
 .../golang-commonmark/markdown/fence.go       |   102 +
 .../golang-commonmark/markdown/fuzz.go        |     9 +
 .../golang-commonmark/markdown/heading.go     |    59 +
 .../golang-commonmark/markdown/helpers.go     |   164 +
 .../markdown/helpers_test.go                  |    71 +
 .../golang-commonmark/markdown/hr.go          |    54 +
 .../golang-commonmark/markdown/html_block.go  |   222 +
 .../markdown/html_block_test.go               |    32 +
 .../golang-commonmark/markdown/html_inline.go |    57 +
 .../golang-commonmark/markdown/image.go       |   131 +
 .../golang-commonmark/markdown/inline.go      |    13 +
 .../golang-commonmark/markdown/lheading.go    |    80 +
 .../golang-commonmark/markdown/link.go        |   132 +
 .../golang-commonmark/markdown/linkify.go     |   131 +
 .../golang-commonmark/markdown/list.go        |   285 +
 .../golang-commonmark/markdown/markdown.go    |   112 +
 .../markdown/markdown_benchmark_test.go       |    93 +
 .../markdown/markdown_it_test.go              |   587 +
 .../markdown/markdown_test.go                 |    93 +
 .../golang-commonmark/markdown/newline.go     |    46 +
 .../golang-commonmark/markdown/options.go     |    77 +
 .../markdown/options_test.go                  |    18 +
 .../golang-commonmark/markdown/paragraph.go   |    51 +
 .../markdown/parser_block.go                  |   159 +
 .../markdown/parser_inline.go                 |   106 +
 .../golang-commonmark/markdown/plugins.go     |   158 +
 .../golang-commonmark/markdown/reference.go   |   173 +
 .../golang-commonmark/markdown/render.go      |   333 +
 .../markdown/replacements.go                  |   229 +
 .../markdown/replacements_test.go             |    82 +
 .../golang-commonmark/markdown/smartquotes.go |   256 +
 .../markdown/smartquotes_test.go              |    27 +
 .../markdown/spec/commonmark-0.28.json        |  4994 +++++
 .../markdown/spec/spec-0.28.txt               |  9414 ++++++++
 .../golang-commonmark/markdown/state_block.go |   141 +
 .../golang-commonmark/markdown/state_core.go  |    13 +
 .../markdown/state_inline.go                  |   116 +
 .../markdown/strikethrough.go                 |   101 +
 .../golang-commonmark/markdown/table.go       |   229 +
 .../golang-commonmark/markdown/table_fsm.go   |   108 +
 .../golang-commonmark/markdown/table_test.go  |    87 +
 .../golang-commonmark/markdown/text.go        |    52 +
 .../markdown/text_collapse.go                 |    42 +
 .../golang-commonmark/markdown/token.go       |   753 +
 .../golang-commonmark/markdown/urlschema.go   |   185 +
 .../golang-commonmark/markdown/util.go        |   264 +
 .../golang-commonmark/markdown/util_test.go   |   195 +
 .../golang-commonmark/markdown/writer.go      |    69 +
 .../golang-commonmark/mdurl/.gitlab-ci.yml    |    16 +
 .../golang-commonmark/mdurl/LICENSE           |    10 +
 .../golang-commonmark/mdurl/README.md         |     8 +
 .../golang-commonmark/mdurl/decode.go         |    80 +
 .../golang-commonmark/mdurl/encode.go         |    53 +
 .../golang-commonmark/mdurl/parse.go          |   146 +
 .../gitlab.com/golang-commonmark/mdurl/url.go |   101 +
 .../mdurl/url_benchmark_test.go               |   153 +
 .../golang-commonmark/mdurl/url_test.go       |  1112 +
 .../golang-commonmark/mdurl/util.go           |    36 +
 .../golang-commonmark/puny/.gitlab-ci.yml     |    16 +
 .../gitlab.com/golang-commonmark/puny/LICENSE |    10 +
 .../golang-commonmark/puny/README.md          |     8 +
 .../gitlab.com/golang-commonmark/puny/puny.go |   287 +
 .../golang-commonmark/puny/puny_test.go       |   237 +
 122 files changed, 54489 insertions(+), 2 deletions(-)
 create mode 100644 vendor/github.com/gorilla/mux/.github/release-drafter.yml
 create mode 100644 vendor/github.com/gorilla/mux/.github/stale.yml
 create mode 100644 vendor/github.com/gorilla/mux/.travis.yml
 create mode 100644 vendor/github.com/gorilla/mux/AUTHORS
 create mode 100644 vendor/github.com/gorilla/mux/ISSUE_TEMPLATE.md
 create mode 100644 vendor/github.com/gorilla/mux/LICENSE
 create mode 100644 vendor/github.com/gorilla/mux/README.md
 create mode 100644 vendor/github.com/gorilla/mux/bench_test.go
 create mode 100644 vendor/github.com/gorilla/mux/context.go
 create mode 100644 vendor/github.com/gorilla/mux/context_test.go
 create mode 100644 vendor/github.com/gorilla/mux/doc.go
 create mode 100644 vendor/github.com/gorilla/mux/example_authentication_middleware_test.go
 create mode 100644 vendor/github.com/gorilla/mux/example_route_test.go
 create mode 100644 vendor/github.com/gorilla/mux/go.mod
 create mode 100644 vendor/github.com/gorilla/mux/middleware.go
 create mode 100644 vendor/github.com/gorilla/mux/middleware_test.go
 create mode 100644 vendor/github.com/gorilla/mux/mux.go
 create mode 100644 vendor/github.com/gorilla/mux/mux_test.go
 create mode 100644 vendor/github.com/gorilla/mux/old_test.go
 create mode 100644 vendor/github.com/gorilla/mux/regexp.go
 create mode 100644 vendor/github.com/gorilla/mux/route.go
 create mode 100644 vendor/github.com/gorilla/mux/test_helpers.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/html/.gitlab-ci.yml
 create mode 100644 vendor/gitlab.com/golang-commonmark/html/LICENSE
 create mode 100644 vendor/gitlab.com/golang-commonmark/html/README.md
 create mode 100644 vendor/gitlab.com/golang-commonmark/html/html.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/html/html5_entities.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/html/html_benchmark_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/html/html_example_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/html/html_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/.gitlab-ci.yml
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/LICENSE
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/README.md
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/charset.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/email.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/generated.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/genfsm/genfsm.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/genfsm/suffixes.txt
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/linkify.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/linkify_benchmark_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/linkify_example_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/linkify_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/url.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/linkify/util.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/.gitlab-ci.yml
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/AUTHORS
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/LICENSE
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/README.md
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/align.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/autolink.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/backticks.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/balance_pairs.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/blockquote.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/code.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/emphasis.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/entity.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/escape.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/fence.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/fuzz.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/heading.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/helpers.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/helpers_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/hr.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/html_block.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/html_block_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/html_inline.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/image.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/inline.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/lheading.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/link.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/linkify.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/list.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/markdown.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/markdown_benchmark_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/markdown_it_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/markdown_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/newline.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/options.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/options_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/paragraph.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/parser_block.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/parser_inline.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/plugins.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/reference.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/render.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/replacements.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/replacements_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/smartquotes.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/smartquotes_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/spec/commonmark-0.28.json
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/spec/spec-0.28.txt
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/state_block.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/state_core.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/state_inline.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/strikethrough.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/table.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/table_fsm.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/table_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/text.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/text_collapse.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/token.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/urlschema.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/util.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/util_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/markdown/writer.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/.gitlab-ci.yml
 create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/LICENSE
 create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/README.md
 create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/decode.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/encode.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/parse.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/url.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/url_benchmark_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/url_test.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/mdurl/util.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/puny/.gitlab-ci.yml
 create mode 100644 vendor/gitlab.com/golang-commonmark/puny/LICENSE
 create mode 100644 vendor/gitlab.com/golang-commonmark/puny/README.md
 create mode 100644 vendor/gitlab.com/golang-commonmark/puny/puny.go
 create mode 100644 vendor/gitlab.com/golang-commonmark/puny/puny_test.go

diff --git a/Gopkg.lock b/Gopkg.lock
index cb61ce6c0..b69bb2626 100644
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -81,7 +81,7 @@
 
 [[projects]]
   name = "github.com/gobuffalo/packr"
-  packages = [".","v2","v2/file","v2/file/resolver","v2/file/resolver/encoding/hex","v2/jam/parser","v2/plog"]
+  packages = ["v2","v2/file","v2/file/resolver","v2/file/resolver/encoding/hex","v2/jam/parser","v2/plog"]
   revision = "cda4ac25577350dac682c8715dc6659327232596"
   version = "v2.2.0"
 
@@ -124,6 +124,12 @@
   packages = ["OpenAPIv2","compiler","extensions"]
   revision = "0c5108395e2debce0d731cf0287ddf7242066aba"
 
+[[projects]]
+  name = "github.com/gorilla/mux"
+  packages = ["."]
+  revision = "c5c6c98bc25355028a63748a498942a6398ccd22"
+  version = "v1.7.1"
+
 [[projects]]
   name = "github.com/gregjones/httpcache"
   packages = [".","diskcache"]
@@ -271,6 +277,35 @@
   revision = "ffdc059bfe9ce6a4e144ba849dbedead332c6053"
   version = "v1.3.0"
 
+[[projects]]
+  branch = "master"
+  name = "gitlab.com/golang-commonmark/html"
+  packages = ["."]
+  revision = "cfaf75183c4a5f0e44e3d51ece1065accafdd2b3"
+
+[[projects]]
+  branch = "master"
+  name = "gitlab.com/golang-commonmark/linkify"
+  packages = ["."]
+  revision = "c22b7bdb117955ff2cc0e3724083d35e3419d71e"
+
+[[projects]]
+  name = "gitlab.com/golang-commonmark/markdown"
+  packages = ["."]
+  revision = "772775880e1fbf39a7804149ed11c0f714ec89fe"
+
+[[projects]]
+  branch = "master"
+  name = "gitlab.com/golang-commonmark/mdurl"
+  packages = ["."]
+  revision = "e5bce34c34f29ecf232fec34f3982e55533ec14e"
+
+[[projects]]
+  branch = "master"
+  name = "gitlab.com/golang-commonmark/puny"
+  packages = ["."]
+  revision = "2cd490539afe7c6fc0eda6c59ef88fa93a00ea0d"
+
 [[projects]]
   name = "go.uber.org/atomic"
   packages = ["."]
@@ -389,6 +424,6 @@
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "23f3629786ef5c144dfcbf51c3ef27cafa7f200acfdc9779a234a6419e6aeb6a"
+  inputs-digest = "0413cf32305d8e92a5f65d059d93e2bf151b8755f5a24088ef26ea12a148cd68"
   solver-name = "gps-cdcl"
   solver-version = 1
diff --git a/Gopkg.toml b/Gopkg.toml
index 9dd199358..d71b6fbe1 100644
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -48,3 +48,11 @@
 [[constraint]]
   name = "github.com/gobuffalo/packr"
   version = "2.2.0"
+
+[[constraint]]
+  name = "github.com/gorilla/mux"
+  version = "1.7.1"
+
+[[constraint]]
+  revision = "772775880e1fbf39a7804149ed11c0f714ec89fe"
+  name = "gitlab.com/golang-commonmark/markdown"
diff --git a/vendor/github.com/gorilla/mux/.github/release-drafter.yml b/vendor/github.com/gorilla/mux/.github/release-drafter.yml
new file mode 100644
index 000000000..2db2e1397
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/.github/release-drafter.yml
@@ -0,0 +1,8 @@
+# Config for https://github.com/apps/release-drafter
+template: |
+  
+  <summary of changes here>
+  
+  ## CHANGELOG
+
+  $CHANGES
diff --git a/vendor/github.com/gorilla/mux/.github/stale.yml b/vendor/github.com/gorilla/mux/.github/stale.yml
new file mode 100644
index 000000000..de8a67804
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/.github/stale.yml
@@ -0,0 +1,12 @@
+daysUntilStale: 60
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - v2
+  - needs-review
+  - work-required
+staleLabel: stale
+markComment: >
+  This issue has been automatically marked as stale because it hasn't seen
+  a recent update. It'll be automatically closed in a few days.
+closeComment: false
diff --git a/vendor/github.com/gorilla/mux/.travis.yml b/vendor/github.com/gorilla/mux/.travis.yml
new file mode 100644
index 000000000..d003ad922
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/.travis.yml
@@ -0,0 +1,24 @@
+language: go
+
+
+matrix:
+  include:
+    - go: 1.7.x
+    - go: 1.8.x
+    - go: 1.9.x
+    - go: 1.10.x
+    - go: 1.11.x
+    - go: 1.x
+      env: LATEST=true
+    - go: tip
+  allow_failures:
+    - go: tip
+
+install:
+  - # Skip
+
+script:
+  - go get -t -v ./...
+  - diff -u <(echo -n) <(gofmt -d .)
+  - if [[ "$LATEST" = true ]]; then go vet .; fi
+  - go test -v -race ./...
diff --git a/vendor/github.com/gorilla/mux/AUTHORS b/vendor/github.com/gorilla/mux/AUTHORS
new file mode 100644
index 000000000..b722392ee
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/AUTHORS
@@ -0,0 +1,8 @@
+# This is the official list of gorilla/mux authors for copyright purposes.
+#
+# Please keep the list sorted.
+
+Google LLC (https://opensource.google.com/)
+Kamil Kisielk <kamil@kamilkisiel.net>
+Matt Silverlock <matt@eatsleeprepeat.net>
+Rodrigo Moraes (https://github.com/moraes)
diff --git a/vendor/github.com/gorilla/mux/ISSUE_TEMPLATE.md b/vendor/github.com/gorilla/mux/ISSUE_TEMPLATE.md
new file mode 100644
index 000000000..232be82e4
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/ISSUE_TEMPLATE.md
@@ -0,0 +1,11 @@
+**What version of Go are you running?** (Paste the output of `go version`)
+
+
+**What version of gorilla/mux are you at?** (Paste the output of `git rev-parse HEAD` inside `$GOPATH/src/github.com/gorilla/mux`)
+
+
+**Describe your problem** (and what you have tried so far)
+
+
+**Paste a minimal, runnable, reproduction of your issue below** (use backticks to format it)
+
diff --git a/vendor/github.com/gorilla/mux/LICENSE b/vendor/github.com/gorilla/mux/LICENSE
new file mode 100644
index 000000000..6903df638
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2012-2018 The Gorilla Authors. 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.
diff --git a/vendor/github.com/gorilla/mux/README.md b/vendor/github.com/gorilla/mux/README.md
new file mode 100644
index 000000000..c661599ab
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/README.md
@@ -0,0 +1,649 @@
+# gorilla/mux
+
+[![GoDoc](https://godoc.org/github.com/gorilla/mux?status.svg)](https://godoc.org/github.com/gorilla/mux)
+[![Build Status](https://travis-ci.org/gorilla/mux.svg?branch=master)](https://travis-ci.org/gorilla/mux)
+[![Sourcegraph](https://sourcegraph.com/github.com/gorilla/mux/-/badge.svg)](https://sourcegraph.com/github.com/gorilla/mux?badge)
+
+![Gorilla Logo](http://www.gorillatoolkit.org/static/images/gorilla-icon-64.png)
+
+https://www.gorillatoolkit.org/pkg/mux
+
+Package `gorilla/mux` implements a request router and dispatcher for matching incoming requests to
+their respective handler.
+
+The name mux stands for "HTTP request multiplexer". Like the standard `http.ServeMux`, `mux.Router` matches incoming requests against a list of registered routes and calls a handler for the route that matches the URL or other conditions. The main features are:
+
+* It implements the `http.Handler` interface so it is compatible with the standard `http.ServeMux`.
+* Requests can be matched based on URL host, path, path prefix, schemes, header and query values, HTTP methods or using custom matchers.
+* URL hosts, paths and query values can have variables with an optional regular expression.
+* Registered URLs can be built, or "reversed", which helps maintaining references to resources.
+* Routes can be used as subrouters: nested routes are only tested if the parent route matches. This is useful to define groups of routes that share common conditions like a host, a path prefix or other repeated attributes. As a bonus, this optimizes request matching.
+
+---
+
+* [Install](#install)
+* [Examples](#examples)
+* [Matching Routes](#matching-routes)
+* [Static Files](#static-files)
+* [Registered URLs](#registered-urls)
+* [Walking Routes](#walking-routes)
+* [Graceful Shutdown](#graceful-shutdown)
+* [Middleware](#middleware)
+* [Testing Handlers](#testing-handlers)
+* [Full Example](#full-example)
+
+---
+
+## Install
+
+With a [correctly configured](https://golang.org/doc/install#testing) Go toolchain:
+
+```sh
+go get -u github.com/gorilla/mux
+```
+
+## Examples
+
+Let's start registering a couple of URL paths and handlers:
+
+```go
+func main() {
+    r := mux.NewRouter()
+    r.HandleFunc("/", HomeHandler)
+    r.HandleFunc("/products", ProductsHandler)
+    r.HandleFunc("/articles", ArticlesHandler)
+    http.Handle("/", r)
+}
+```
+
+Here we register three routes mapping URL paths to handlers. This is equivalent to how `http.HandleFunc()` works: if an incoming request URL matches one of the paths, the corresponding handler is called passing (`http.ResponseWriter`, `*http.Request`) as parameters.
+
+Paths can have variables. They are defined using the format `{name}` or `{name:pattern}`. If a regular expression pattern is not defined, the matched variable will be anything until the next slash. For example:
+
+```go
+r := mux.NewRouter()
+r.HandleFunc("/products/{key}", ProductHandler)
+r.HandleFunc("/articles/{category}/", ArticlesCategoryHandler)
+r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler)
+```
+
+The names are used to create a map of route variables which can be retrieved calling `mux.Vars()`:
+
+```go
+func ArticlesCategoryHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    w.WriteHeader(http.StatusOK)
+    fmt.Fprintf(w, "Category: %v\n", vars["category"])
+}
+```
+
+And this is all you need to know about the basic usage. More advanced options are explained below.
+
+### Matching Routes
+
+Routes can also be restricted to a domain or subdomain. Just define a host pattern to be matched. They can also have variables:
+
+```go
+r := mux.NewRouter()
+// Only matches if domain is "www.example.com".
+r.Host("www.example.com")
+// Matches a dynamic subdomain.
+r.Host("{subdomain:[a-z]+}.example.com")
+```
+
+There are several other matchers that can be added. To match path prefixes:
+
+```go
+r.PathPrefix("/products/")
+```
+
+...or HTTP methods:
+
+```go
+r.Methods("GET", "POST")
+```
+
+...or URL schemes:
+
+```go
+r.Schemes("https")
+```
+
+...or header values:
+
+```go
+r.Headers("X-Requested-With", "XMLHttpRequest")
+```
+
+...or query values:
+
+```go
+r.Queries("key", "value")
+```
+
+...or to use a custom matcher function:
+
+```go
+r.MatcherFunc(func(r *http.Request, rm *RouteMatch) bool {
+    return r.ProtoMajor == 0
+})
+```
+
+...and finally, it is possible to combine several matchers in a single route:
+
+```go
+r.HandleFunc("/products", ProductsHandler).
+  Host("www.example.com").
+  Methods("GET").
+  Schemes("http")
+```
+
+Routes are tested in the order they were added to the router. If two routes match, the first one wins:
+
+```go
+r := mux.NewRouter()
+r.HandleFunc("/specific", specificHandler)
+r.PathPrefix("/").Handler(catchAllHandler)
+```
+
+Setting the same matching conditions again and again can be boring, so we have a way to group several routes that share the same requirements. We call it "subrouting".
+
+For example, let's say we have several URLs that should only match when the host is `www.example.com`. Create a route for that host and get a "subrouter" from it:
+
+```go
+r := mux.NewRouter()
+s := r.Host("www.example.com").Subrouter()
+```
+
+Then register routes in the subrouter:
+
+```go
+s.HandleFunc("/products/", ProductsHandler)
+s.HandleFunc("/products/{key}", ProductHandler)
+s.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler)
+```
+
+The three URL paths we registered above will only be tested if the domain is `www.example.com`, because the subrouter is tested first. This is not only convenient, but also optimizes request matching. You can create subrouters combining any attribute matchers accepted by a route.
+
+Subrouters can be used to create domain or path "namespaces": you define subrouters in a central place and then parts of the app can register its paths relatively to a given subrouter.
+
+There's one more thing about subroutes. When a subrouter has a path prefix, the inner routes use it as base for their paths:
+
+```go
+r := mux.NewRouter()
+s := r.PathPrefix("/products").Subrouter()
+// "/products/"
+s.HandleFunc("/", ProductsHandler)
+// "/products/{key}/"
+s.HandleFunc("/{key}/", ProductHandler)
+// "/products/{key}/details"
+s.HandleFunc("/{key}/details", ProductDetailsHandler)
+```
+
+
+### Static Files
+
+Note that the path provided to `PathPrefix()` represents a "wildcard": calling
+`PathPrefix("/static/").Handler(...)` means that the handler will be passed any
+request that matches "/static/\*". This makes it easy to serve static files with mux:
+
+```go
+func main() {
+    var dir string
+
+    flag.StringVar(&dir, "dir", ".", "the directory to serve files from. Defaults to the current dir")
+    flag.Parse()
+    r := mux.NewRouter()
+
+    // This will serve files under http://localhost:8000/static/<filename>
+    r.PathPrefix("/static/").Handler(http.StripPrefix("/static/", http.FileServer(http.Dir(dir))))
+
+    srv := &http.Server{
+        Handler:      r,
+        Addr:         "127.0.0.1:8000",
+        // Good practice: enforce timeouts for servers you create!
+        WriteTimeout: 15 * time.Second,
+        ReadTimeout:  15 * time.Second,
+    }
+
+    log.Fatal(srv.ListenAndServe())
+}
+```
+
+### Registered URLs
+
+Now let's see how to build registered URLs.
+
+Routes can be named. All routes that define a name can have their URLs built, or "reversed". We define a name calling `Name()` on a route. For example:
+
+```go
+r := mux.NewRouter()
+r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler).
+  Name("article")
+```
+
+To build a URL, get the route and call the `URL()` method, passing a sequence of key/value pairs for the route variables. For the previous route, we would do:
+
+```go
+url, err := r.Get("article").URL("category", "technology", "id", "42")
+```
+
+...and the result will be a `url.URL` with the following path:
+
+```
+"/articles/technology/42"
+```
+
+This also works for host and query value variables:
+
+```go
+r := mux.NewRouter()
+r.Host("{subdomain}.example.com").
+  Path("/articles/{category}/{id:[0-9]+}").
+  Queries("filter", "{filter}").
+  HandlerFunc(ArticleHandler).
+  Name("article")
+
+// url.String() will be "http://news.example.com/articles/technology/42?filter=gorilla"
+url, err := r.Get("article").URL("subdomain", "news",
+                                 "category", "technology",
+                                 "id", "42",
+                                 "filter", "gorilla")
+```
+
+All variables defined in the route are required, and their values must conform to the corresponding patterns. These requirements guarantee that a generated URL will always match a registered route -- the only exception is for explicitly defined "build-only" routes which never match.
+
+Regex support also exists for matching Headers within a route. For example, we could do:
+
+```go
+r.HeadersRegexp("Content-Type", "application/(text|json)")
+```
+
+...and the route will match both requests with a Content-Type of `application/json` as well as `application/text`
+
+There's also a way to build only the URL host or path for a route: use the methods `URLHost()` or `URLPath()` instead. For the previous route, we would do:
+
+```go
+// "http://news.example.com/"
+host, err := r.Get("article").URLHost("subdomain", "news")
+
+// "/articles/technology/42"
+path, err := r.Get("article").URLPath("category", "technology", "id", "42")
+```
+
+And if you use subrouters, host and path defined separately can be built as well:
+
+```go
+r := mux.NewRouter()
+s := r.Host("{subdomain}.example.com").Subrouter()
+s.Path("/articles/{category}/{id:[0-9]+}").
+  HandlerFunc(ArticleHandler).
+  Name("article")
+
+// "http://news.example.com/articles/technology/42"
+url, err := r.Get("article").URL("subdomain", "news",
+                                 "category", "technology",
+                                 "id", "42")
+```
+
+### Walking Routes
+
+The `Walk` function on `mux.Router` can be used to visit all of the routes that are registered on a router. For example,
+the following prints all of the registered routes:
+
+```go
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/gorilla/mux"
+)
+
+func handler(w http.ResponseWriter, r *http.Request) {
+	return
+}
+
+func main() {
+	r := mux.NewRouter()
+	r.HandleFunc("/", handler)
+	r.HandleFunc("/products", handler).Methods("POST")
+	r.HandleFunc("/articles", handler).Methods("GET")
+	r.HandleFunc("/articles/{id}", handler).Methods("GET", "PUT")
+	r.HandleFunc("/authors", handler).Queries("surname", "{surname}")
+	err := r.Walk(func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error {
+		pathTemplate, err := route.GetPathTemplate()
+		if err == nil {
+			fmt.Println("ROUTE:", pathTemplate)
+		}
+		pathRegexp, err := route.GetPathRegexp()
+		if err == nil {
+			fmt.Println("Path regexp:", pathRegexp)
+		}
+		queriesTemplates, err := route.GetQueriesTemplates()
+		if err == nil {
+			fmt.Println("Queries templates:", strings.Join(queriesTemplates, ","))
+		}
+		queriesRegexps, err := route.GetQueriesRegexp()
+		if err == nil {
+			fmt.Println("Queries regexps:", strings.Join(queriesRegexps, ","))
+		}
+		methods, err := route.GetMethods()
+		if err == nil {
+			fmt.Println("Methods:", strings.Join(methods, ","))
+		}
+		fmt.Println()
+		return nil
+	})
+
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	http.Handle("/", r)
+}
+```
+
+### Graceful Shutdown
+
+Go 1.8 introduced the ability to [gracefully shutdown](https://golang.org/doc/go1.8#http_shutdown) a `*http.Server`. Here's how to do that alongside `mux`:
+
+```go
+package main
+
+import (
+    "context"
+    "flag"
+    "log"
+    "net/http"
+    "os"
+    "os/signal"
+    "time"
+
+    "github.com/gorilla/mux"
+)
+
+func main() {
+    var wait time.Duration
+    flag.DurationVar(&wait, "graceful-timeout", time.Second * 15, "the duration for which the server gracefully wait for existing connections to finish - e.g. 15s or 1m")
+    flag.Parse()
+
+    r := mux.NewRouter()
+    // Add your routes as needed
+
+    srv := &http.Server{
+        Addr:         "0.0.0.0:8080",
+        // Good practice to set timeouts to avoid Slowloris attacks.
+        WriteTimeout: time.Second * 15,
+        ReadTimeout:  time.Second * 15,
+        IdleTimeout:  time.Second * 60,
+        Handler: r, // Pass our instance of gorilla/mux in.
+    }
+
+    // Run our server in a goroutine so that it doesn't block.
+    go func() {
+        if err := srv.ListenAndServe(); err != nil {
+            log.Println(err)
+        }
+    }()
+
+    c := make(chan os.Signal, 1)
+    // We'll accept graceful shutdowns when quit via SIGINT (Ctrl+C)
+    // SIGKILL, SIGQUIT or SIGTERM (Ctrl+/) will not be caught.
+    signal.Notify(c, os.Interrupt)
+
+    // Block until we receive our signal.
+    <-c
+
+    // Create a deadline to wait for.
+    ctx, cancel := context.WithTimeout(context.Background(), wait)
+    defer cancel()
+    // Doesn't block if no connections, but will otherwise wait
+    // until the timeout deadline.
+    srv.Shutdown(ctx)
+    // Optionally, you could run srv.Shutdown in a goroutine and block on
+    // <-ctx.Done() if your application should wait for other services
+    // to finalize based on context cancellation.
+    log.Println("shutting down")
+    os.Exit(0)
+}
+```
+
+### Middleware
+
+Mux supports the addition of middlewares to a [Router](https://godoc.org/github.com/gorilla/mux#Router), which are executed in the order they are added if a match is found, including its subrouters.
+Middlewares are (typically) small pieces of code which take one request, do something with it, and pass it down to another middleware or the final handler. Some common use cases for middleware are request logging, header manipulation, or `ResponseWriter` hijacking.
+
+Mux middlewares are defined using the de facto standard type:
+
+```go
+type MiddlewareFunc func(http.Handler) http.Handler
+```
+
+Typically, the returned handler is a closure which does something with the http.ResponseWriter and http.Request passed to it, and then calls the handler passed as parameter to the MiddlewareFunc. This takes advantage of closures being able access variables from the context where they are created, while retaining the signature enforced by the receivers.
+
+A very basic middleware which logs the URI of the request being handled could be written as:
+
+```go
+func loggingMiddleware(next http.Handler) http.Handler {
+    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+        // Do stuff here
+        log.Println(r.RequestURI)
+        // Call the next handler, which can be another middleware in the chain, or the final handler.
+        next.ServeHTTP(w, r)
+    })
+}
+```
+
+Middlewares can be added to a router using `Router.Use()`:
+
+```go
+r := mux.NewRouter()
+r.HandleFunc("/", handler)
+r.Use(loggingMiddleware)
+```
+
+A more complex authentication middleware, which maps session token to users, could be written as:
+
+```go
+// Define our struct
+type authenticationMiddleware struct {
+	tokenUsers map[string]string
+}
+
+// Initialize it somewhere
+func (amw *authenticationMiddleware) Populate() {
+	amw.tokenUsers["00000000"] = "user0"
+	amw.tokenUsers["aaaaaaaa"] = "userA"
+	amw.tokenUsers["05f717e5"] = "randomUser"
+	amw.tokenUsers["deadbeef"] = "user0"
+}
+
+// Middleware function, which will be called for each request
+func (amw *authenticationMiddleware) Middleware(next http.Handler) http.Handler {
+    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+        token := r.Header.Get("X-Session-Token")
+
+        if user, found := amw.tokenUsers[token]; found {
+        	// We found the token in our map
+        	log.Printf("Authenticated user %s\n", user)
+        	// Pass down the request to the next middleware (or final handler)
+        	next.ServeHTTP(w, r)
+        } else {
+        	// Write an error and stop the handler chain
+        	http.Error(w, "Forbidden", http.StatusForbidden)
+        }
+    })
+}
+```
+
+```go
+r := mux.NewRouter()
+r.HandleFunc("/", handler)
+
+amw := authenticationMiddleware{}
+amw.Populate()
+
+r.Use(amw.Middleware)
+```
+
+Note: The handler chain will be stopped if your middleware doesn't call `next.ServeHTTP()` with the corresponding parameters. This can be used to abort a request if the middleware writer wants to. Middlewares _should_ write to `ResponseWriter` if they _are_ going to terminate the request, and they _should not_ write to `ResponseWriter` if they _are not_ going to terminate it.
+
+### Testing Handlers
+
+Testing handlers in a Go web application is straightforward, and _mux_ doesn't complicate this any further. Given two files: `endpoints.go` and `endpoints_test.go`, here's how we'd test an application using _mux_.
+
+First, our simple HTTP handler:
+
+```go
+// endpoints.go
+package main
+
+func HealthCheckHandler(w http.ResponseWriter, r *http.Request) {
+    // A very simple health check.
+    w.Header().Set("Content-Type", "application/json")
+    w.WriteHeader(http.StatusOK)
+
+    // In the future we could report back on the status of our DB, or our cache
+    // (e.g. Redis) by performing a simple PING, and include them in the response.
+    io.WriteString(w, `{"alive": true}`)
+}
+
+func main() {
+    r := mux.NewRouter()
+    r.HandleFunc("/health", HealthCheckHandler)
+
+    log.Fatal(http.ListenAndServe("localhost:8080", r))
+}
+```
+
+Our test code:
+
+```go
+// endpoints_test.go
+package main
+
+import (
+    "net/http"
+    "net/http/httptest"
+    "testing"
+)
+
+func TestHealthCheckHandler(t *testing.T) {
+    // Create a request to pass to our handler. We don't have any query parameters for now, so we'll
+    // pass 'nil' as the third parameter.
+    req, err := http.NewRequest("GET", "/health", nil)
+    if err != nil {
+        t.Fatal(err)
+    }
+
+    // We create a ResponseRecorder (which satisfies http.ResponseWriter) to record the response.
+    rr := httptest.NewRecorder()
+    handler := http.HandlerFunc(HealthCheckHandler)
+
+    // Our handlers satisfy http.Handler, so we can call their ServeHTTP method
+    // directly and pass in our Request and ResponseRecorder.
+    handler.ServeHTTP(rr, req)
+
+    // Check the status code is what we expect.
+    if status := rr.Code; status != http.StatusOK {
+        t.Errorf("handler returned wrong status code: got %v want %v",
+            status, http.StatusOK)
+    }
+
+    // Check the response body is what we expect.
+    expected := `{"alive": true}`
+    if rr.Body.String() != expected {
+        t.Errorf("handler returned unexpected body: got %v want %v",
+            rr.Body.String(), expected)
+    }
+}
+```
+
+In the case that our routes have [variables](#examples), we can pass those in the request. We could write
+[table-driven tests](https://dave.cheney.net/2013/06/09/writing-table-driven-tests-in-go) to test multiple
+possible route variables as needed.
+
+```go
+// endpoints.go
+func main() {
+    r := mux.NewRouter()
+    // A route with a route variable:
+    r.HandleFunc("/metrics/{type}", MetricsHandler)
+
+    log.Fatal(http.ListenAndServe("localhost:8080", r))
+}
+```
+
+Our test file, with a table-driven test of `routeVariables`:
+
+```go
+// endpoints_test.go
+func TestMetricsHandler(t *testing.T) {
+    tt := []struct{
+        routeVariable string
+        shouldPass bool
+    }{
+        {"goroutines", true},
+        {"heap", true},
+        {"counters", true},
+        {"queries", true},
+        {"adhadaeqm3k", false},
+    }
+
+    for _, tc := range tt {
+        path := fmt.Sprintf("/metrics/%s", tc.routeVariable)
+        req, err := http.NewRequest("GET", path, nil)
+        if err != nil {
+            t.Fatal(err)
+        }
+
+        rr := httptest.NewRecorder()
+	
+	// Need to create a router that we can pass the request through so that the vars will be added to the context
+	router := mux.NewRouter()
+        router.HandleFunc("/metrics/{type}", MetricsHandler)
+        router.ServeHTTP(rr, req)
+
+        // In this case, our MetricsHandler returns a non-200 response
+        // for a route variable it doesn't know about.
+        if rr.Code == http.StatusOK && !tc.shouldPass {
+            t.Errorf("handler should have failed on routeVariable %s: got %v want %v",
+                tc.routeVariable, rr.Code, http.StatusOK)
+        }
+    }
+}
+```
+
+## Full Example
+
+Here's a complete, runnable example of a small `mux` based server:
+
+```go
+package main
+
+import (
+    "net/http"
+    "log"
+    "github.com/gorilla/mux"
+)
+
+func YourHandler(w http.ResponseWriter, r *http.Request) {
+    w.Write([]byte("Gorilla!\n"))
+}
+
+func main() {
+    r := mux.NewRouter()
+    // Routes consist of a path and a handler function.
+    r.HandleFunc("/", YourHandler)
+
+    // Bind to a port and pass our router in
+    log.Fatal(http.ListenAndServe(":8000", r))
+}
+```
+
+## License
+
+BSD licensed. See the LICENSE file for details.
diff --git a/vendor/github.com/gorilla/mux/bench_test.go b/vendor/github.com/gorilla/mux/bench_test.go
new file mode 100644
index 000000000..522156dcc
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/bench_test.go
@@ -0,0 +1,49 @@
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mux
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func BenchmarkMux(b *testing.B) {
+	router := new(Router)
+	handler := func(w http.ResponseWriter, r *http.Request) {}
+	router.HandleFunc("/v1/{v1}", handler)
+
+	request, _ := http.NewRequest("GET", "/v1/anything", nil)
+	for i := 0; i < b.N; i++ {
+		router.ServeHTTP(nil, request)
+	}
+}
+
+func BenchmarkMuxAlternativeInRegexp(b *testing.B) {
+	router := new(Router)
+	handler := func(w http.ResponseWriter, r *http.Request) {}
+	router.HandleFunc("/v1/{v1:(?:a|b)}", handler)
+
+	requestA, _ := http.NewRequest("GET", "/v1/a", nil)
+	requestB, _ := http.NewRequest("GET", "/v1/b", nil)
+	for i := 0; i < b.N; i++ {
+		router.ServeHTTP(nil, requestA)
+		router.ServeHTTP(nil, requestB)
+	}
+}
+
+func BenchmarkManyPathVariables(b *testing.B) {
+	router := new(Router)
+	handler := func(w http.ResponseWriter, r *http.Request) {}
+	router.HandleFunc("/v1/{v1}/{v2}/{v3}/{v4}/{v5}", handler)
+
+	matchingRequest, _ := http.NewRequest("GET", "/v1/1/2/3/4/5", nil)
+	notMatchingRequest, _ := http.NewRequest("GET", "/v1/1/2/3/4", nil)
+	recorder := httptest.NewRecorder()
+	for i := 0; i < b.N; i++ {
+		router.ServeHTTP(nil, matchingRequest)
+		router.ServeHTTP(recorder, notMatchingRequest)
+	}
+}
diff --git a/vendor/github.com/gorilla/mux/context.go b/vendor/github.com/gorilla/mux/context.go
new file mode 100644
index 000000000..665940a26
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/context.go
@@ -0,0 +1,18 @@
+package mux
+
+import (
+	"context"
+	"net/http"
+)
+
+func contextGet(r *http.Request, key interface{}) interface{} {
+	return r.Context().Value(key)
+}
+
+func contextSet(r *http.Request, key, val interface{}) *http.Request {
+	if val == nil {
+		return r
+	}
+
+	return r.WithContext(context.WithValue(r.Context(), key, val))
+}
diff --git a/vendor/github.com/gorilla/mux/context_test.go b/vendor/github.com/gorilla/mux/context_test.go
new file mode 100644
index 000000000..d8a56b422
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/context_test.go
@@ -0,0 +1,30 @@
+package mux
+
+import (
+	"context"
+	"net/http"
+	"testing"
+	"time"
+)
+
+func TestNativeContextMiddleware(t *testing.T) {
+	withTimeout := func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			ctx, cancel := context.WithTimeout(r.Context(), time.Minute)
+			defer cancel()
+			h.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
+
+	r := NewRouter()
+	r.Handle("/path/{foo}", withTimeout(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		vars := Vars(r)
+		if vars["foo"] != "bar" {
+			t.Fatal("Expected foo var to be set")
+		}
+	})))
+
+	rec := NewRecorder()
+	req := newRequest("GET", "/path/bar")
+	r.ServeHTTP(rec, req)
+}
diff --git a/vendor/github.com/gorilla/mux/doc.go b/vendor/github.com/gorilla/mux/doc.go
new file mode 100644
index 000000000..38957deea
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/doc.go
@@ -0,0 +1,306 @@
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package mux implements a request router and dispatcher.
+
+The name mux stands for "HTTP request multiplexer". Like the standard
+http.ServeMux, mux.Router matches incoming requests against a list of
+registered routes and calls a handler for the route that matches the URL
+or other conditions. The main features are:
+
+	* Requests can be matched based on URL host, path, path prefix, schemes,
+	  header and query values, HTTP methods or using custom matchers.
+	* URL hosts, paths and query values can have variables with an optional
+	  regular expression.
+	* Registered URLs can be built, or "reversed", which helps maintaining
+	  references to resources.
+	* Routes can be used as subrouters: nested routes are only tested if the
+	  parent route matches. This is useful to define groups of routes that
+	  share common conditions like a host, a path prefix or other repeated
+	  attributes. As a bonus, this optimizes request matching.
+	* It implements the http.Handler interface so it is compatible with the
+	  standard http.ServeMux.
+
+Let's start registering a couple of URL paths and handlers:
+
+	func main() {
+		r := mux.NewRouter()
+		r.HandleFunc("/", HomeHandler)
+		r.HandleFunc("/products", ProductsHandler)
+		r.HandleFunc("/articles", ArticlesHandler)
+		http.Handle("/", r)
+	}
+
+Here we register three routes mapping URL paths to handlers. This is
+equivalent to how http.HandleFunc() works: if an incoming request URL matches
+one of the paths, the corresponding handler is called passing
+(http.ResponseWriter, *http.Request) as parameters.
+
+Paths can have variables. They are defined using the format {name} or
+{name:pattern}. If a regular expression pattern is not defined, the matched
+variable will be anything until the next slash. For example:
+
+	r := mux.NewRouter()
+	r.HandleFunc("/products/{key}", ProductHandler)
+	r.HandleFunc("/articles/{category}/", ArticlesCategoryHandler)
+	r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler)
+
+Groups can be used inside patterns, as long as they are non-capturing (?:re). For example:
+
+	r.HandleFunc("/articles/{category}/{sort:(?:asc|desc|new)}", ArticlesCategoryHandler)
+
+The names are used to create a map of route variables which can be retrieved
+calling mux.Vars():
+
+	vars := mux.Vars(request)
+	category := vars["category"]
+
+Note that if any capturing groups are present, mux will panic() during parsing. To prevent
+this, convert any capturing groups to non-capturing, e.g. change "/{sort:(asc|desc)}" to
+"/{sort:(?:asc|desc)}". This is a change from prior versions which behaved unpredictably
+when capturing groups were present.
+
+And this is all you need to know about the basic usage. More advanced options
+are explained below.
+
+Routes can also be restricted to a domain or subdomain. Just define a host
+pattern to be matched. They can also have variables:
+
+	r := mux.NewRouter()
+	// Only matches if domain is "www.example.com".
+	r.Host("www.example.com")
+	// Matches a dynamic subdomain.
+	r.Host("{subdomain:[a-z]+}.domain.com")
+
+There are several other matchers that can be added. To match path prefixes:
+
+	r.PathPrefix("/products/")
+
+...or HTTP methods:
+
+	r.Methods("GET", "POST")
+
+...or URL schemes:
+
+	r.Schemes("https")
+
+...or header values:
+
+	r.Headers("X-Requested-With", "XMLHttpRequest")
+
+...or query values:
+
+	r.Queries("key", "value")
+
+...or to use a custom matcher function:
+
+	r.MatcherFunc(func(r *http.Request, rm *RouteMatch) bool {
+		return r.ProtoMajor == 0
+	})
+
+...and finally, it is possible to combine several matchers in a single route:
+
+	r.HandleFunc("/products", ProductsHandler).
+	  Host("www.example.com").
+	  Methods("GET").
+	  Schemes("http")
+
+Setting the same matching conditions again and again can be boring, so we have
+a way to group several routes that share the same requirements.
+We call it "subrouting".
+
+For example, let's say we have several URLs that should only match when the
+host is "www.example.com". Create a route for that host and get a "subrouter"
+from it:
+
+	r := mux.NewRouter()
+	s := r.Host("www.example.com").Subrouter()
+
+Then register routes in the subrouter:
+
+	s.HandleFunc("/products/", ProductsHandler)
+	s.HandleFunc("/products/{key}", ProductHandler)
+	s.HandleFunc("/articles/{category}/{id:[0-9]+}"), ArticleHandler)
+
+The three URL paths we registered above will only be tested if the domain is
+"www.example.com", because the subrouter is tested first. This is not
+only convenient, but also optimizes request matching. You can create
+subrouters combining any attribute matchers accepted by a route.
+
+Subrouters can be used to create domain or path "namespaces": you define
+subrouters in a central place and then parts of the app can register its
+paths relatively to a given subrouter.
+
+There's one more thing about subroutes. When a subrouter has a path prefix,
+the inner routes use it as base for their paths:
+
+	r := mux.NewRouter()
+	s := r.PathPrefix("/products").Subrouter()
+	// "/products/"
+	s.HandleFunc("/", ProductsHandler)
+	// "/products/{key}/"
+	s.HandleFunc("/{key}/", ProductHandler)
+	// "/products/{key}/details"
+	s.HandleFunc("/{key}/details", ProductDetailsHandler)
+
+Note that the path provided to PathPrefix() represents a "wildcard": calling
+PathPrefix("/static/").Handler(...) means that the handler will be passed any
+request that matches "/static/*". This makes it easy to serve static files with mux:
+
+	func main() {
+		var dir string
+
+		flag.StringVar(&dir, "dir", ".", "the directory to serve files from. Defaults to the current dir")
+		flag.Parse()
+		r := mux.NewRouter()
+
+		// This will serve files under http://localhost:8000/static/<filename>
+		r.PathPrefix("/static/").Handler(http.StripPrefix("/static/", http.FileServer(http.Dir(dir))))
+
+		srv := &http.Server{
+			Handler:      r,
+			Addr:         "127.0.0.1:8000",
+			// Good practice: enforce timeouts for servers you create!
+			WriteTimeout: 15 * time.Second,
+			ReadTimeout:  15 * time.Second,
+		}
+
+		log.Fatal(srv.ListenAndServe())
+	}
+
+Now let's see how to build registered URLs.
+
+Routes can be named. All routes that define a name can have their URLs built,
+or "reversed". We define a name calling Name() on a route. For example:
+
+	r := mux.NewRouter()
+	r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler).
+	  Name("article")
+
+To build a URL, get the route and call the URL() method, passing a sequence of
+key/value pairs for the route variables. For the previous route, we would do:
+
+	url, err := r.Get("article").URL("category", "technology", "id", "42")
+
+...and the result will be a url.URL with the following path:
+
+	"/articles/technology/42"
+
+This also works for host and query value variables:
+
+	r := mux.NewRouter()
+	r.Host("{subdomain}.domain.com").
+	  Path("/articles/{category}/{id:[0-9]+}").
+	  Queries("filter", "{filter}").
+	  HandlerFunc(ArticleHandler).
+	  Name("article")
+
+	// url.String() will be "http://news.domain.com/articles/technology/42?filter=gorilla"
+	url, err := r.Get("article").URL("subdomain", "news",
+	                                 "category", "technology",
+	                                 "id", "42",
+	                                 "filter", "gorilla")
+
+All variables defined in the route are required, and their values must
+conform to the corresponding patterns. These requirements guarantee that a
+generated URL will always match a registered route -- the only exception is
+for explicitly defined "build-only" routes which never match.
+
+Regex support also exists for matching Headers within a route. For example, we could do:
+
+	r.HeadersRegexp("Content-Type", "application/(text|json)")
+
+...and the route will match both requests with a Content-Type of `application/json` as well as
+`application/text`
+
+There's also a way to build only the URL host or path for a route:
+use the methods URLHost() or URLPath() instead. For the previous route,
+we would do:
+
+	// "http://news.domain.com/"
+	host, err := r.Get("article").URLHost("subdomain", "news")
+
+	// "/articles/technology/42"
+	path, err := r.Get("article").URLPath("category", "technology", "id", "42")
+
+And if you use subrouters, host and path defined separately can be built
+as well:
+
+	r := mux.NewRouter()
+	s := r.Host("{subdomain}.domain.com").Subrouter()
+	s.Path("/articles/{category}/{id:[0-9]+}").
+	  HandlerFunc(ArticleHandler).
+	  Name("article")
+
+	// "http://news.domain.com/articles/technology/42"
+	url, err := r.Get("article").URL("subdomain", "news",
+	                                 "category", "technology",
+	                                 "id", "42")
+
+Mux supports the addition of middlewares to a Router, which are executed in the order they are added if a match is found, including its subrouters. Middlewares are (typically) small pieces of code which take one request, do something with it, and pass it down to another middleware or the final handler. Some common use cases for middleware are request logging, header manipulation, or ResponseWriter hijacking.
+
+	type MiddlewareFunc func(http.Handler) http.Handler
+
+Typically, the returned handler is a closure which does something with the http.ResponseWriter and http.Request passed to it, and then calls the handler passed as parameter to the MiddlewareFunc (closures can access variables from the context where they are created).
+
+A very basic middleware which logs the URI of the request being handled could be written as:
+
+	func simpleMw(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			// Do stuff here
+			log.Println(r.RequestURI)
+			// Call the next handler, which can be another middleware in the chain, or the final handler.
+			next.ServeHTTP(w, r)
+		})
+	}
+
+Middlewares can be added to a router using `Router.Use()`:
+
+	r := mux.NewRouter()
+	r.HandleFunc("/", handler)
+	r.Use(simpleMw)
+
+A more complex authentication middleware, which maps session token to users, could be written as:
+
+	// Define our struct
+	type authenticationMiddleware struct {
+		tokenUsers map[string]string
+	}
+
+	// Initialize it somewhere
+	func (amw *authenticationMiddleware) Populate() {
+		amw.tokenUsers["00000000"] = "user0"
+		amw.tokenUsers["aaaaaaaa"] = "userA"
+		amw.tokenUsers["05f717e5"] = "randomUser"
+		amw.tokenUsers["deadbeef"] = "user0"
+	}
+
+	// Middleware function, which will be called for each request
+	func (amw *authenticationMiddleware) Middleware(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			token := r.Header.Get("X-Session-Token")
+
+			if user, found := amw.tokenUsers[token]; found {
+				// We found the token in our map
+				log.Printf("Authenticated user %s\n", user)
+				next.ServeHTTP(w, r)
+			} else {
+				http.Error(w, "Forbidden", http.StatusForbidden)
+			}
+		})
+	}
+
+	r := mux.NewRouter()
+	r.HandleFunc("/", handler)
+
+	amw := authenticationMiddleware{}
+	amw.Populate()
+
+	r.Use(amw.Middleware)
+
+Note: The handler chain will be stopped if your middleware doesn't call `next.ServeHTTP()` with the corresponding parameters. This can be used to abort a request if the middleware writer wants to.
+
+*/
+package mux
diff --git a/vendor/github.com/gorilla/mux/example_authentication_middleware_test.go b/vendor/github.com/gorilla/mux/example_authentication_middleware_test.go
new file mode 100644
index 000000000..6f2ea86ca
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/example_authentication_middleware_test.go
@@ -0,0 +1,46 @@
+package mux_test
+
+import (
+	"log"
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+// Define our struct
+type authenticationMiddleware struct {
+	tokenUsers map[string]string
+}
+
+// Initialize it somewhere
+func (amw *authenticationMiddleware) Populate() {
+	amw.tokenUsers["00000000"] = "user0"
+	amw.tokenUsers["aaaaaaaa"] = "userA"
+	amw.tokenUsers["05f717e5"] = "randomUser"
+	amw.tokenUsers["deadbeef"] = "user0"
+}
+
+// Middleware function, which will be called for each request
+func (amw *authenticationMiddleware) Middleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		token := r.Header.Get("X-Session-Token")
+
+		if user, found := amw.tokenUsers[token]; found {
+			// We found the token in our map
+			log.Printf("Authenticated user %s\n", user)
+			next.ServeHTTP(w, r)
+		} else {
+			http.Error(w, "Forbidden", http.StatusForbidden)
+		}
+	})
+}
+
+func Example_authenticationMiddleware() {
+	r := mux.NewRouter()
+	r.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		// Do something here
+	})
+	amw := authenticationMiddleware{make(map[string]string)}
+	amw.Populate()
+	r.Use(amw.Middleware)
+}
diff --git a/vendor/github.com/gorilla/mux/example_route_test.go b/vendor/github.com/gorilla/mux/example_route_test.go
new file mode 100644
index 000000000..112557071
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/example_route_test.go
@@ -0,0 +1,51 @@
+package mux_test
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+// This example demonstrates setting a regular expression matcher for
+// the header value. A plain word will match any value that contains a
+// matching substring as if the pattern was wrapped with `.*`.
+func ExampleRoute_HeadersRegexp() {
+	r := mux.NewRouter()
+	route := r.NewRoute().HeadersRegexp("Accept", "html")
+
+	req1, _ := http.NewRequest("GET", "example.com", nil)
+	req1.Header.Add("Accept", "text/plain")
+	req1.Header.Add("Accept", "text/html")
+
+	req2, _ := http.NewRequest("GET", "example.com", nil)
+	req2.Header.Set("Accept", "application/xhtml+xml")
+
+	matchInfo := &mux.RouteMatch{}
+	fmt.Printf("Match: %v %q\n", route.Match(req1, matchInfo), req1.Header["Accept"])
+	fmt.Printf("Match: %v %q\n", route.Match(req2, matchInfo), req2.Header["Accept"])
+	// Output:
+	// Match: true ["text/plain" "text/html"]
+	// Match: true ["application/xhtml+xml"]
+}
+
+// This example demonstrates setting a strict regular expression matcher
+// for the header value. Using the start and end of string anchors, the
+// value must be an exact match.
+func ExampleRoute_HeadersRegexp_exactMatch() {
+	r := mux.NewRouter()
+	route := r.NewRoute().HeadersRegexp("Origin", "^https://example.co$")
+
+	yes, _ := http.NewRequest("GET", "example.co", nil)
+	yes.Header.Set("Origin", "https://example.co")
+
+	no, _ := http.NewRequest("GET", "example.co.uk", nil)
+	no.Header.Set("Origin", "https://example.co.uk")
+
+	matchInfo := &mux.RouteMatch{}
+	fmt.Printf("Match: %v %q\n", route.Match(yes, matchInfo), yes.Header["Origin"])
+	fmt.Printf("Match: %v %q\n", route.Match(no, matchInfo), no.Header["Origin"])
+	// Output:
+	// Match: true ["https://example.co"]
+	// Match: false ["https://example.co.uk"]
+}
diff --git a/vendor/github.com/gorilla/mux/go.mod b/vendor/github.com/gorilla/mux/go.mod
new file mode 100644
index 000000000..cfc8ede58
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/go.mod
@@ -0,0 +1 @@
+module github.com/gorilla/mux
diff --git a/vendor/github.com/gorilla/mux/middleware.go b/vendor/github.com/gorilla/mux/middleware.go
new file mode 100644
index 000000000..ceb812cee
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/middleware.go
@@ -0,0 +1,72 @@
+package mux
+
+import (
+	"net/http"
+	"strings"
+)
+
+// MiddlewareFunc is a function which receives an http.Handler and returns another http.Handler.
+// Typically, the returned handler is a closure which does something with the http.ResponseWriter and http.Request passed
+// to it, and then calls the handler passed as parameter to the MiddlewareFunc.
+type MiddlewareFunc func(http.Handler) http.Handler
+
+// middleware interface is anything which implements a MiddlewareFunc named Middleware.
+type middleware interface {
+	Middleware(handler http.Handler) http.Handler
+}
+
+// Middleware allows MiddlewareFunc to implement the middleware interface.
+func (mw MiddlewareFunc) Middleware(handler http.Handler) http.Handler {
+	return mw(handler)
+}
+
+// Use appends a MiddlewareFunc to the chain. Middleware can be used to intercept or otherwise modify requests and/or responses, and are executed in the order that they are applied to the Router.
+func (r *Router) Use(mwf ...MiddlewareFunc) {
+	for _, fn := range mwf {
+		r.middlewares = append(r.middlewares, fn)
+	}
+}
+
+// useInterface appends a middleware to the chain. Middleware can be used to intercept or otherwise modify requests and/or responses, and are executed in the order that they are applied to the Router.
+func (r *Router) useInterface(mw middleware) {
+	r.middlewares = append(r.middlewares, mw)
+}
+
+// CORSMethodMiddleware sets the Access-Control-Allow-Methods response header
+// on a request, by matching routes based only on paths. It also handles
+// OPTIONS requests, by settings Access-Control-Allow-Methods, and then
+// returning without calling the next http handler.
+func CORSMethodMiddleware(r *Router) MiddlewareFunc {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+			var allMethods []string
+
+			err := r.Walk(func(route *Route, _ *Router, _ []*Route) error {
+				for _, m := range route.matchers {
+					if _, ok := m.(*routeRegexp); ok {
+						if m.Match(req, &RouteMatch{}) {
+							methods, err := route.GetMethods()
+							if err != nil {
+								return err
+							}
+
+							allMethods = append(allMethods, methods...)
+						}
+						break
+					}
+				}
+				return nil
+			})
+
+			if err == nil {
+				w.Header().Set("Access-Control-Allow-Methods", strings.Join(append(allMethods, "OPTIONS"), ","))
+
+				if req.Method == "OPTIONS" {
+					return
+				}
+			}
+
+			next.ServeHTTP(w, req)
+		})
+	}
+}
diff --git a/vendor/github.com/gorilla/mux/middleware_test.go b/vendor/github.com/gorilla/mux/middleware_test.go
new file mode 100644
index 000000000..24016cbb7
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/middleware_test.go
@@ -0,0 +1,437 @@
+package mux
+
+import (
+	"bytes"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+type testMiddleware struct {
+	timesCalled uint
+}
+
+func (tm *testMiddleware) Middleware(h http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		tm.timesCalled++
+		h.ServeHTTP(w, r)
+	})
+}
+
+func dummyHandler(w http.ResponseWriter, r *http.Request) {}
+
+func TestMiddlewareAdd(t *testing.T) {
+	router := NewRouter()
+	router.HandleFunc("/", dummyHandler).Methods("GET")
+
+	mw := &testMiddleware{}
+
+	router.useInterface(mw)
+	if len(router.middlewares) != 1 || router.middlewares[0] != mw {
+		t.Fatal("Middleware was not added correctly")
+	}
+
+	router.Use(mw.Middleware)
+	if len(router.middlewares) != 2 {
+		t.Fatal("MiddlewareFunc method was not added correctly")
+	}
+
+	banalMw := func(handler http.Handler) http.Handler {
+		return handler
+	}
+	router.Use(banalMw)
+	if len(router.middlewares) != 3 {
+		t.Fatal("MiddlewareFunc method was not added correctly")
+	}
+}
+
+func TestMiddleware(t *testing.T) {
+	router := NewRouter()
+	router.HandleFunc("/", dummyHandler).Methods("GET")
+
+	mw := &testMiddleware{}
+	router.useInterface(mw)
+
+	rw := NewRecorder()
+	req := newRequest("GET", "/")
+
+	// Test regular middleware call
+	router.ServeHTTP(rw, req)
+	if mw.timesCalled != 1 {
+		t.Fatalf("Expected %d calls, but got only %d", 1, mw.timesCalled)
+	}
+
+	// Middleware should not be called for 404
+	req = newRequest("GET", "/not/found")
+	router.ServeHTTP(rw, req)
+	if mw.timesCalled != 1 {
+		t.Fatalf("Expected %d calls, but got only %d", 1, mw.timesCalled)
+	}
+
+	// Middleware should not be called if there is a method mismatch
+	req = newRequest("POST", "/")
+	router.ServeHTTP(rw, req)
+	if mw.timesCalled != 1 {
+		t.Fatalf("Expected %d calls, but got only %d", 1, mw.timesCalled)
+	}
+
+	// Add the middleware again as function
+	router.Use(mw.Middleware)
+	req = newRequest("GET", "/")
+	router.ServeHTTP(rw, req)
+	if mw.timesCalled != 3 {
+		t.Fatalf("Expected %d calls, but got only %d", 3, mw.timesCalled)
+	}
+
+}
+
+func TestMiddlewareSubrouter(t *testing.T) {
+	router := NewRouter()
+	router.HandleFunc("/", dummyHandler).Methods("GET")
+
+	subrouter := router.PathPrefix("/sub").Subrouter()
+	subrouter.HandleFunc("/x", dummyHandler).Methods("GET")
+
+	mw := &testMiddleware{}
+	subrouter.useInterface(mw)
+
+	rw := NewRecorder()
+	req := newRequest("GET", "/")
+
+	router.ServeHTTP(rw, req)
+	if mw.timesCalled != 0 {
+		t.Fatalf("Expected %d calls, but got only %d", 0, mw.timesCalled)
+	}
+
+	req = newRequest("GET", "/sub/")
+	router.ServeHTTP(rw, req)
+	if mw.timesCalled != 0 {
+		t.Fatalf("Expected %d calls, but got only %d", 0, mw.timesCalled)
+	}
+
+	req = newRequest("GET", "/sub/x")
+	router.ServeHTTP(rw, req)
+	if mw.timesCalled != 1 {
+		t.Fatalf("Expected %d calls, but got only %d", 1, mw.timesCalled)
+	}
+
+	req = newRequest("GET", "/sub/not/found")
+	router.ServeHTTP(rw, req)
+	if mw.timesCalled != 1 {
+		t.Fatalf("Expected %d calls, but got only %d", 1, mw.timesCalled)
+	}
+
+	router.useInterface(mw)
+
+	req = newRequest("GET", "/")
+	router.ServeHTTP(rw, req)
+	if mw.timesCalled != 2 {
+		t.Fatalf("Expected %d calls, but got only %d", 2, mw.timesCalled)
+	}
+
+	req = newRequest("GET", "/sub/x")
+	router.ServeHTTP(rw, req)
+	if mw.timesCalled != 4 {
+		t.Fatalf("Expected %d calls, but got only %d", 4, mw.timesCalled)
+	}
+}
+
+func TestMiddlewareExecution(t *testing.T) {
+	mwStr := []byte("Middleware\n")
+	handlerStr := []byte("Logic\n")
+
+	router := NewRouter()
+	router.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
+		w.Write(handlerStr)
+	})
+
+	rw := NewRecorder()
+	req := newRequest("GET", "/")
+
+	// Test handler-only call
+	router.ServeHTTP(rw, req)
+
+	if !bytes.Equal(rw.Body.Bytes(), handlerStr) {
+		t.Fatal("Handler response is not what it should be")
+	}
+
+	// Test middleware call
+	rw = NewRecorder()
+
+	router.Use(func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Write(mwStr)
+			h.ServeHTTP(w, r)
+		})
+	})
+
+	router.ServeHTTP(rw, req)
+	if !bytes.Equal(rw.Body.Bytes(), append(mwStr, handlerStr...)) {
+		t.Fatal("Middleware + handler response is not what it should be")
+	}
+}
+
+func TestMiddlewareNotFound(t *testing.T) {
+	mwStr := []byte("Middleware\n")
+	handlerStr := []byte("Logic\n")
+
+	router := NewRouter()
+	router.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
+		w.Write(handlerStr)
+	})
+	router.Use(func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Write(mwStr)
+			h.ServeHTTP(w, r)
+		})
+	})
+
+	// Test not found call with default handler
+	rw := NewRecorder()
+	req := newRequest("GET", "/notfound")
+
+	router.ServeHTTP(rw, req)
+	if bytes.Contains(rw.Body.Bytes(), mwStr) {
+		t.Fatal("Middleware was called for a 404")
+	}
+
+	// Test not found call with custom handler
+	rw = NewRecorder()
+	req = newRequest("GET", "/notfound")
+
+	router.NotFoundHandler = http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+		rw.Write([]byte("Custom 404 handler"))
+	})
+	router.ServeHTTP(rw, req)
+
+	if bytes.Contains(rw.Body.Bytes(), mwStr) {
+		t.Fatal("Middleware was called for a custom 404")
+	}
+}
+
+func TestMiddlewareMethodMismatch(t *testing.T) {
+	mwStr := []byte("Middleware\n")
+	handlerStr := []byte("Logic\n")
+
+	router := NewRouter()
+	router.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
+		w.Write(handlerStr)
+	}).Methods("GET")
+
+	router.Use(func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Write(mwStr)
+			h.ServeHTTP(w, r)
+		})
+	})
+
+	// Test method mismatch
+	rw := NewRecorder()
+	req := newRequest("POST", "/")
+
+	router.ServeHTTP(rw, req)
+	if bytes.Contains(rw.Body.Bytes(), mwStr) {
+		t.Fatal("Middleware was called for a method mismatch")
+	}
+
+	// Test not found call
+	rw = NewRecorder()
+	req = newRequest("POST", "/")
+
+	router.MethodNotAllowedHandler = http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+		rw.Write([]byte("Method not allowed"))
+	})
+	router.ServeHTTP(rw, req)
+
+	if bytes.Contains(rw.Body.Bytes(), mwStr) {
+		t.Fatal("Middleware was called for a method mismatch")
+	}
+}
+
+func TestMiddlewareNotFoundSubrouter(t *testing.T) {
+	mwStr := []byte("Middleware\n")
+	handlerStr := []byte("Logic\n")
+
+	router := NewRouter()
+	router.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
+		w.Write(handlerStr)
+	})
+
+	subrouter := router.PathPrefix("/sub/").Subrouter()
+	subrouter.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
+		w.Write(handlerStr)
+	})
+
+	router.Use(func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Write(mwStr)
+			h.ServeHTTP(w, r)
+		})
+	})
+
+	// Test not found call for default handler
+	rw := NewRecorder()
+	req := newRequest("GET", "/sub/notfound")
+
+	router.ServeHTTP(rw, req)
+	if bytes.Contains(rw.Body.Bytes(), mwStr) {
+		t.Fatal("Middleware was called for a 404")
+	}
+
+	// Test not found call with custom handler
+	rw = NewRecorder()
+	req = newRequest("GET", "/sub/notfound")
+
+	subrouter.NotFoundHandler = http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+		rw.Write([]byte("Custom 404 handler"))
+	})
+	router.ServeHTTP(rw, req)
+
+	if bytes.Contains(rw.Body.Bytes(), mwStr) {
+		t.Fatal("Middleware was called for a custom 404")
+	}
+}
+
+func TestMiddlewareMethodMismatchSubrouter(t *testing.T) {
+	mwStr := []byte("Middleware\n")
+	handlerStr := []byte("Logic\n")
+
+	router := NewRouter()
+	router.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
+		w.Write(handlerStr)
+	})
+
+	subrouter := router.PathPrefix("/sub/").Subrouter()
+	subrouter.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
+		w.Write(handlerStr)
+	}).Methods("GET")
+
+	router.Use(func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Write(mwStr)
+			h.ServeHTTP(w, r)
+		})
+	})
+
+	// Test method mismatch without custom handler
+	rw := NewRecorder()
+	req := newRequest("POST", "/sub/")
+
+	router.ServeHTTP(rw, req)
+	if bytes.Contains(rw.Body.Bytes(), mwStr) {
+		t.Fatal("Middleware was called for a method mismatch")
+	}
+
+	// Test method mismatch with custom handler
+	rw = NewRecorder()
+	req = newRequest("POST", "/sub/")
+
+	router.MethodNotAllowedHandler = http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+		rw.Write([]byte("Method not allowed"))
+	})
+	router.ServeHTTP(rw, req)
+
+	if bytes.Contains(rw.Body.Bytes(), mwStr) {
+		t.Fatal("Middleware was called for a method mismatch")
+	}
+}
+
+func TestCORSMethodMiddleware(t *testing.T) {
+	router := NewRouter()
+
+	cases := []struct {
+		path                   string
+		response               string
+		method                 string
+		testURL                string
+		expectedAllowedMethods string
+	}{
+		{"/g/{o}", "a", "POST", "/g/asdf", "POST,PUT,GET,OPTIONS"},
+		{"/g/{o}", "b", "PUT", "/g/bla", "POST,PUT,GET,OPTIONS"},
+		{"/g/{o}", "c", "GET", "/g/orilla", "POST,PUT,GET,OPTIONS"},
+		{"/g", "d", "POST", "/g", "POST,OPTIONS"},
+	}
+
+	for _, tt := range cases {
+		router.HandleFunc(tt.path, stringHandler(tt.response)).Methods(tt.method)
+	}
+
+	router.Use(CORSMethodMiddleware(router))
+
+	for _, tt := range cases {
+		rr := httptest.NewRecorder()
+		req := newRequest(tt.method, tt.testURL)
+
+		router.ServeHTTP(rr, req)
+
+		if rr.Body.String() != tt.response {
+			t.Errorf("Expected body '%s', found '%s'", tt.response, rr.Body.String())
+		}
+
+		allowedMethods := rr.Header().Get("Access-Control-Allow-Methods")
+
+		if allowedMethods != tt.expectedAllowedMethods {
+			t.Errorf("Expected Access-Control-Allow-Methods '%s', found '%s'", tt.expectedAllowedMethods, allowedMethods)
+		}
+	}
+}
+
+func TestMiddlewareOnMultiSubrouter(t *testing.T) {
+	first := "first"
+	second := "second"
+	notFound := "404 not found"
+
+	router := NewRouter()
+	firstSubRouter := router.PathPrefix("/").Subrouter()
+	secondSubRouter := router.PathPrefix("/").Subrouter()
+
+	router.NotFoundHandler = http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+		rw.Write([]byte(notFound))
+	})
+
+	firstSubRouter.HandleFunc("/first", func(w http.ResponseWriter, r *http.Request) {
+
+	})
+
+	secondSubRouter.HandleFunc("/second", func(w http.ResponseWriter, r *http.Request) {
+
+	})
+
+	firstSubRouter.Use(func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Write([]byte(first))
+			h.ServeHTTP(w, r)
+		})
+	})
+
+	secondSubRouter.Use(func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Write([]byte(second))
+			h.ServeHTTP(w, r)
+		})
+	})
+
+	rw := NewRecorder()
+	req := newRequest("GET", "/first")
+
+	router.ServeHTTP(rw, req)
+	if rw.Body.String() != first {
+		t.Fatalf("Middleware did not run: expected %s middleware to write a response (got %s)", first, rw.Body.String())
+	}
+
+	rw = NewRecorder()
+	req = newRequest("GET", "/second")
+
+	router.ServeHTTP(rw, req)
+	if rw.Body.String() != second {
+		t.Fatalf("Middleware did not run: expected %s middleware to write a response (got %s)", second, rw.Body.String())
+	}
+
+	rw = NewRecorder()
+	req = newRequest("GET", "/second/not-exist")
+
+	router.ServeHTTP(rw, req)
+	if rw.Body.String() != notFound {
+		t.Fatalf("Notfound handler did not run: expected %s for not-exist, (got %s)", notFound, rw.Body.String())
+	}
+}
diff --git a/vendor/github.com/gorilla/mux/mux.go b/vendor/github.com/gorilla/mux/mux.go
new file mode 100644
index 000000000..a2cd193e4
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/mux.go
@@ -0,0 +1,607 @@
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mux
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"path"
+	"regexp"
+)
+
+var (
+	// ErrMethodMismatch is returned when the method in the request does not match
+	// the method defined against the route.
+	ErrMethodMismatch = errors.New("method is not allowed")
+	// ErrNotFound is returned when no route match is found.
+	ErrNotFound = errors.New("no matching route was found")
+)
+
+// NewRouter returns a new router instance.
+func NewRouter() *Router {
+	return &Router{namedRoutes: make(map[string]*Route)}
+}
+
+// Router registers routes to be matched and dispatches a handler.
+//
+// It implements the http.Handler interface, so it can be registered to serve
+// requests:
+//
+//     var router = mux.NewRouter()
+//
+//     func main() {
+//         http.Handle("/", router)
+//     }
+//
+// Or, for Google App Engine, register it in a init() function:
+//
+//     func init() {
+//         http.Handle("/", router)
+//     }
+//
+// This will send all incoming requests to the router.
+type Router struct {
+	// Configurable Handler to be used when no route matches.
+	NotFoundHandler http.Handler
+
+	// Configurable Handler to be used when the request method does not match the route.
+	MethodNotAllowedHandler http.Handler
+
+	// Routes to be matched, in order.
+	routes []*Route
+
+	// Routes by name for URL building.
+	namedRoutes map[string]*Route
+
+	// If true, do not clear the request context after handling the request.
+	//
+	// Deprecated: No effect when go1.7+ is used, since the context is stored
+	// on the request itself.
+	KeepContext bool
+
+	// Slice of middlewares to be called after a match is found
+	middlewares []middleware
+
+	// configuration shared with `Route`
+	routeConf
+}
+
+// common route configuration shared between `Router` and `Route`
+type routeConf struct {
+	// If true, "/path/foo%2Fbar/to" will match the path "/path/{var}/to"
+	useEncodedPath bool
+
+	// If true, when the path pattern is "/path/", accessing "/path" will
+	// redirect to the former and vice versa.
+	strictSlash bool
+
+	// If true, when the path pattern is "/path//to", accessing "/path//to"
+	// will not redirect
+	skipClean bool
+
+	// Manager for the variables from host and path.
+	regexp routeRegexpGroup
+
+	// List of matchers.
+	matchers []matcher
+
+	// The scheme used when building URLs.
+	buildScheme string
+
+	buildVarsFunc BuildVarsFunc
+}
+
+// returns an effective deep copy of `routeConf`
+func copyRouteConf(r routeConf) routeConf {
+	c := r
+
+	if r.regexp.path != nil {
+		c.regexp.path = copyRouteRegexp(r.regexp.path)
+	}
+
+	if r.regexp.host != nil {
+		c.regexp.host = copyRouteRegexp(r.regexp.host)
+	}
+
+	c.regexp.queries = make([]*routeRegexp, 0, len(r.regexp.queries))
+	for _, q := range r.regexp.queries {
+		c.regexp.queries = append(c.regexp.queries, copyRouteRegexp(q))
+	}
+
+	c.matchers = make([]matcher, 0, len(r.matchers))
+	for _, m := range r.matchers {
+		c.matchers = append(c.matchers, m)
+	}
+
+	return c
+}
+
+func copyRouteRegexp(r *routeRegexp) *routeRegexp {
+	c := *r
+	return &c
+}
+
+// Match attempts to match the given request against the router's registered routes.
+//
+// If the request matches a route of this router or one of its subrouters the Route,
+// Handler, and Vars fields of the the match argument are filled and this function
+// returns true.
+//
+// If the request does not match any of this router's or its subrouters' routes
+// then this function returns false. If available, a reason for the match failure
+// will be filled in the match argument's MatchErr field. If the match failure type
+// (eg: not found) has a registered handler, the handler is assigned to the Handler
+// field of the match argument.
+func (r *Router) Match(req *http.Request, match *RouteMatch) bool {
+	for _, route := range r.routes {
+		if route.Match(req, match) {
+			// Build middleware chain if no error was found
+			if match.MatchErr == nil {
+				for i := len(r.middlewares) - 1; i >= 0; i-- {
+					match.Handler = r.middlewares[i].Middleware(match.Handler)
+				}
+			}
+			return true
+		}
+	}
+
+	if match.MatchErr == ErrMethodMismatch {
+		if r.MethodNotAllowedHandler != nil {
+			match.Handler = r.MethodNotAllowedHandler
+			return true
+		}
+
+		return false
+	}
+
+	// Closest match for a router (includes sub-routers)
+	if r.NotFoundHandler != nil {
+		match.Handler = r.NotFoundHandler
+		match.MatchErr = ErrNotFound
+		return true
+	}
+
+	match.MatchErr = ErrNotFound
+	return false
+}
+
+// ServeHTTP dispatches the handler registered in the matched route.
+//
+// When there is a match, the route variables can be retrieved calling
+// mux.Vars(request).
+func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	if !r.skipClean {
+		path := req.URL.Path
+		if r.useEncodedPath {
+			path = req.URL.EscapedPath()
+		}
+		// Clean path to canonical form and redirect.
+		if p := cleanPath(path); p != path {
+
+			// Added 3 lines (Philip Schlump) - It was dropping the query string and #whatever from query.
+			// This matches with fix in go 1.2 r.c. 4 for same problem.  Go Issue:
+			// http://code.google.com/p/go/issues/detail?id=5252
+			url := *req.URL
+			url.Path = p
+			p = url.String()
+
+			w.Header().Set("Location", p)
+			w.WriteHeader(http.StatusMovedPermanently)
+			return
+		}
+	}
+	var match RouteMatch
+	var handler http.Handler
+	if r.Match(req, &match) {
+		handler = match.Handler
+		req = setVars(req, match.Vars)
+		req = setCurrentRoute(req, match.Route)
+	}
+
+	if handler == nil && match.MatchErr == ErrMethodMismatch {
+		handler = methodNotAllowedHandler()
+	}
+
+	if handler == nil {
+		handler = http.NotFoundHandler()
+	}
+
+	handler.ServeHTTP(w, req)
+}
+
+// Get returns a route registered with the given name.
+func (r *Router) Get(name string) *Route {
+	return r.namedRoutes[name]
+}
+
+// GetRoute returns a route registered with the given name. This method
+// was renamed to Get() and remains here for backwards compatibility.
+func (r *Router) GetRoute(name string) *Route {
+	return r.namedRoutes[name]
+}
+
+// StrictSlash defines the trailing slash behavior for new routes. The initial
+// value is false.
+//
+// When true, if the route path is "/path/", accessing "/path" will perform a redirect
+// to the former and vice versa. In other words, your application will always
+// see the path as specified in the route.
+//
+// When false, if the route path is "/path", accessing "/path/" will not match
+// this route and vice versa.
+//
+// The re-direct is a HTTP 301 (Moved Permanently). Note that when this is set for
+// routes with a non-idempotent method (e.g. POST, PUT), the subsequent re-directed
+// request will be made as a GET by most clients. Use middleware or client settings
+// to modify this behaviour as needed.
+//
+// Special case: when a route sets a path prefix using the PathPrefix() method,
+// strict slash is ignored for that route because the redirect behavior can't
+// be determined from a prefix alone. However, any subrouters created from that
+// route inherit the original StrictSlash setting.
+func (r *Router) StrictSlash(value bool) *Router {
+	r.strictSlash = value
+	return r
+}
+
+// SkipClean defines the path cleaning behaviour for new routes. The initial
+// value is false. Users should be careful about which routes are not cleaned
+//
+// When true, if the route path is "/path//to", it will remain with the double
+// slash. This is helpful if you have a route like: /fetch/http://xkcd.com/534/
+//
+// When false, the path will be cleaned, so /fetch/http://xkcd.com/534/ will
+// become /fetch/http/xkcd.com/534
+func (r *Router) SkipClean(value bool) *Router {
+	r.skipClean = value
+	return r
+}
+
+// UseEncodedPath tells the router to match the encoded original path
+// to the routes.
+// For eg. "/path/foo%2Fbar/to" will match the path "/path/{var}/to".
+//
+// If not called, the router will match the unencoded path to the routes.
+// For eg. "/path/foo%2Fbar/to" will match the path "/path/foo/bar/to"
+func (r *Router) UseEncodedPath() *Router {
+	r.useEncodedPath = true
+	return r
+}
+
+// ----------------------------------------------------------------------------
+// Route factories
+// ----------------------------------------------------------------------------
+
+// NewRoute registers an empty route.
+func (r *Router) NewRoute() *Route {
+	// initialize a route with a copy of the parent router's configuration
+	route := &Route{routeConf: copyRouteConf(r.routeConf), namedRoutes: r.namedRoutes}
+	r.routes = append(r.routes, route)
+	return route
+}
+
+// Name registers a new route with a name.
+// See Route.Name().
+func (r *Router) Name(name string) *Route {
+	return r.NewRoute().Name(name)
+}
+
+// Handle registers a new route with a matcher for the URL path.
+// See Route.Path() and Route.Handler().
+func (r *Router) Handle(path string, handler http.Handler) *Route {
+	return r.NewRoute().Path(path).Handler(handler)
+}
+
+// HandleFunc registers a new route with a matcher for the URL path.
+// See Route.Path() and Route.HandlerFunc().
+func (r *Router) HandleFunc(path string, f func(http.ResponseWriter,
+	*http.Request)) *Route {
+	return r.NewRoute().Path(path).HandlerFunc(f)
+}
+
+// Headers registers a new route with a matcher for request header values.
+// See Route.Headers().
+func (r *Router) Headers(pairs ...string) *Route {
+	return r.NewRoute().Headers(pairs...)
+}
+
+// Host registers a new route with a matcher for the URL host.
+// See Route.Host().
+func (r *Router) Host(tpl string) *Route {
+	return r.NewRoute().Host(tpl)
+}
+
+// MatcherFunc registers a new route with a custom matcher function.
+// See Route.MatcherFunc().
+func (r *Router) MatcherFunc(f MatcherFunc) *Route {
+	return r.NewRoute().MatcherFunc(f)
+}
+
+// Methods registers a new route with a matcher for HTTP methods.
+// See Route.Methods().
+func (r *Router) Methods(methods ...string) *Route {
+	return r.NewRoute().Methods(methods...)
+}
+
+// Path registers a new route with a matcher for the URL path.
+// See Route.Path().
+func (r *Router) Path(tpl string) *Route {
+	return r.NewRoute().Path(tpl)
+}
+
+// PathPrefix registers a new route with a matcher for the URL path prefix.
+// See Route.PathPrefix().
+func (r *Router) PathPrefix(tpl string) *Route {
+	return r.NewRoute().PathPrefix(tpl)
+}
+
+// Queries registers a new route with a matcher for URL query values.
+// See Route.Queries().
+func (r *Router) Queries(pairs ...string) *Route {
+	return r.NewRoute().Queries(pairs...)
+}
+
+// Schemes registers a new route with a matcher for URL schemes.
+// See Route.Schemes().
+func (r *Router) Schemes(schemes ...string) *Route {
+	return r.NewRoute().Schemes(schemes...)
+}
+
+// BuildVarsFunc registers a new route with a custom function for modifying
+// route variables before building a URL.
+func (r *Router) BuildVarsFunc(f BuildVarsFunc) *Route {
+	return r.NewRoute().BuildVarsFunc(f)
+}
+
+// Walk walks the router and all its sub-routers, calling walkFn for each route
+// in the tree. The routes are walked in the order they were added. Sub-routers
+// are explored depth-first.
+func (r *Router) Walk(walkFn WalkFunc) error {
+	return r.walk(walkFn, []*Route{})
+}
+
+// SkipRouter is used as a return value from WalkFuncs to indicate that the
+// router that walk is about to descend down to should be skipped.
+var SkipRouter = errors.New("skip this router")
+
+// WalkFunc is the type of the function called for each route visited by Walk.
+// At every invocation, it is given the current route, and the current router,
+// and a list of ancestor routes that lead to the current route.
+type WalkFunc func(route *Route, router *Router, ancestors []*Route) error
+
+func (r *Router) walk(walkFn WalkFunc, ancestors []*Route) error {
+	for _, t := range r.routes {
+		err := walkFn(t, r, ancestors)
+		if err == SkipRouter {
+			continue
+		}
+		if err != nil {
+			return err
+		}
+		for _, sr := range t.matchers {
+			if h, ok := sr.(*Router); ok {
+				ancestors = append(ancestors, t)
+				err := h.walk(walkFn, ancestors)
+				if err != nil {
+					return err
+				}
+				ancestors = ancestors[:len(ancestors)-1]
+			}
+		}
+		if h, ok := t.handler.(*Router); ok {
+			ancestors = append(ancestors, t)
+			err := h.walk(walkFn, ancestors)
+			if err != nil {
+				return err
+			}
+			ancestors = ancestors[:len(ancestors)-1]
+		}
+	}
+	return nil
+}
+
+// ----------------------------------------------------------------------------
+// Context
+// ----------------------------------------------------------------------------
+
+// RouteMatch stores information about a matched route.
+type RouteMatch struct {
+	Route   *Route
+	Handler http.Handler
+	Vars    map[string]string
+
+	// MatchErr is set to appropriate matching error
+	// It is set to ErrMethodMismatch if there is a mismatch in
+	// the request method and route method
+	MatchErr error
+}
+
+type contextKey int
+
+const (
+	varsKey contextKey = iota
+	routeKey
+)
+
+// Vars returns the route variables for the current request, if any.
+func Vars(r *http.Request) map[string]string {
+	if rv := contextGet(r, varsKey); rv != nil {
+		return rv.(map[string]string)
+	}
+	return nil
+}
+
+// CurrentRoute returns the matched route for the current request, if any.
+// This only works when called inside the handler of the matched route
+// because the matched route is stored in the request context which is cleared
+// after the handler returns, unless the KeepContext option is set on the
+// Router.
+func CurrentRoute(r *http.Request) *Route {
+	if rv := contextGet(r, routeKey); rv != nil {
+		return rv.(*Route)
+	}
+	return nil
+}
+
+func setVars(r *http.Request, val interface{}) *http.Request {
+	return contextSet(r, varsKey, val)
+}
+
+func setCurrentRoute(r *http.Request, val interface{}) *http.Request {
+	return contextSet(r, routeKey, val)
+}
+
+// ----------------------------------------------------------------------------
+// Helpers
+// ----------------------------------------------------------------------------
+
+// cleanPath returns the canonical path for p, eliminating . and .. elements.
+// Borrowed from the net/http package.
+func cleanPath(p string) string {
+	if p == "" {
+		return "/"
+	}
+	if p[0] != '/' {
+		p = "/" + p
+	}
+	np := path.Clean(p)
+	// path.Clean removes trailing slash except for root;
+	// put the trailing slash back if necessary.
+	if p[len(p)-1] == '/' && np != "/" {
+		np += "/"
+	}
+
+	return np
+}
+
+// uniqueVars returns an error if two slices contain duplicated strings.
+func uniqueVars(s1, s2 []string) error {
+	for _, v1 := range s1 {
+		for _, v2 := range s2 {
+			if v1 == v2 {
+				return fmt.Errorf("mux: duplicated route variable %q", v2)
+			}
+		}
+	}
+	return nil
+}
+
+// checkPairs returns the count of strings passed in, and an error if
+// the count is not an even number.
+func checkPairs(pairs ...string) (int, error) {
+	length := len(pairs)
+	if length%2 != 0 {
+		return length, fmt.Errorf(
+			"mux: number of parameters must be multiple of 2, got %v", pairs)
+	}
+	return length, nil
+}
+
+// mapFromPairsToString converts variadic string parameters to a
+// string to string map.
+func mapFromPairsToString(pairs ...string) (map[string]string, error) {
+	length, err := checkPairs(pairs...)
+	if err != nil {
+		return nil, err
+	}
+	m := make(map[string]string, length/2)
+	for i := 0; i < length; i += 2 {
+		m[pairs[i]] = pairs[i+1]
+	}
+	return m, nil
+}
+
+// mapFromPairsToRegex converts variadic string parameters to a
+// string to regex map.
+func mapFromPairsToRegex(pairs ...string) (map[string]*regexp.Regexp, error) {
+	length, err := checkPairs(pairs...)
+	if err != nil {
+		return nil, err
+	}
+	m := make(map[string]*regexp.Regexp, length/2)
+	for i := 0; i < length; i += 2 {
+		regex, err := regexp.Compile(pairs[i+1])
+		if err != nil {
+			return nil, err
+		}
+		m[pairs[i]] = regex
+	}
+	return m, nil
+}
+
+// matchInArray returns true if the given string value is in the array.
+func matchInArray(arr []string, value string) bool {
+	for _, v := range arr {
+		if v == value {
+			return true
+		}
+	}
+	return false
+}
+
+// matchMapWithString returns true if the given key/value pairs exist in a given map.
+func matchMapWithString(toCheck map[string]string, toMatch map[string][]string, canonicalKey bool) bool {
+	for k, v := range toCheck {
+		// Check if key exists.
+		if canonicalKey {
+			k = http.CanonicalHeaderKey(k)
+		}
+		if values := toMatch[k]; values == nil {
+			return false
+		} else if v != "" {
+			// If value was defined as an empty string we only check that the
+			// key exists. Otherwise we also check for equality.
+			valueExists := false
+			for _, value := range values {
+				if v == value {
+					valueExists = true
+					break
+				}
+			}
+			if !valueExists {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// matchMapWithRegex returns true if the given key/value pairs exist in a given map compiled against
+// the given regex
+func matchMapWithRegex(toCheck map[string]*regexp.Regexp, toMatch map[string][]string, canonicalKey bool) bool {
+	for k, v := range toCheck {
+		// Check if key exists.
+		if canonicalKey {
+			k = http.CanonicalHeaderKey(k)
+		}
+		if values := toMatch[k]; values == nil {
+			return false
+		} else if v != nil {
+			// If value was defined as an empty string we only check that the
+			// key exists. Otherwise we also check for equality.
+			valueExists := false
+			for _, value := range values {
+				if v.MatchString(value) {
+					valueExists = true
+					break
+				}
+			}
+			if !valueExists {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// methodNotAllowed replies to the request with an HTTP status code 405.
+func methodNotAllowed(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusMethodNotAllowed)
+}
+
+// methodNotAllowedHandler returns a simple request handler
+// that replies to each request with a status code 405.
+func methodNotAllowedHandler() http.Handler { return http.HandlerFunc(methodNotAllowed) }
diff --git a/vendor/github.com/gorilla/mux/mux_test.go b/vendor/github.com/gorilla/mux/mux_test.go
new file mode 100644
index 000000000..f5c1e9c5b
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/mux_test.go
@@ -0,0 +1,2846 @@
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mux
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func (r *Route) GoString() string {
+	matchers := make([]string, len(r.matchers))
+	for i, m := range r.matchers {
+		matchers[i] = fmt.Sprintf("%#v", m)
+	}
+	return fmt.Sprintf("&Route{matchers:[]matcher{%s}}", strings.Join(matchers, ", "))
+}
+
+func (r *routeRegexp) GoString() string {
+	return fmt.Sprintf("&routeRegexp{template: %q, regexpType: %v, options: %v, regexp: regexp.MustCompile(%q), reverse: %q, varsN: %v, varsR: %v", r.template, r.regexpType, r.options, r.regexp.String(), r.reverse, r.varsN, r.varsR)
+}
+
+type routeTest struct {
+	title           string            // title of the test
+	route           *Route            // the route being tested
+	request         *http.Request     // a request to test the route
+	vars            map[string]string // the expected vars of the match
+	scheme          string            // the expected scheme of the built URL
+	host            string            // the expected host of the built URL
+	path            string            // the expected path of the built URL
+	query           string            // the expected query string of the built URL
+	pathTemplate    string            // the expected path template of the route
+	hostTemplate    string            // the expected host template of the route
+	queriesTemplate string            // the expected query template of the route
+	methods         []string          // the expected route methods
+	pathRegexp      string            // the expected path regexp
+	queriesRegexp   string            // the expected query regexp
+	shouldMatch     bool              // whether the request is expected to match the route at all
+	shouldRedirect  bool              // whether the request should result in a redirect
+}
+
+func TestHost(t *testing.T) {
+
+	tests := []routeTest{
+		{
+			title:       "Host route match",
+			route:       new(Route).Host("aaa.bbb.ccc"),
+			request:     newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:        map[string]string{},
+			host:        "aaa.bbb.ccc",
+			path:        "",
+			shouldMatch: true,
+		},
+		{
+			title:       "Host route, wrong host in request URL",
+			route:       new(Route).Host("aaa.bbb.ccc"),
+			request:     newRequest("GET", "http://aaa.222.ccc/111/222/333"),
+			vars:        map[string]string{},
+			host:        "aaa.bbb.ccc",
+			path:        "",
+			shouldMatch: false,
+		},
+		{
+			title:       "Host route with port, match",
+			route:       new(Route).Host("aaa.bbb.ccc:1234"),
+			request:     newRequest("GET", "http://aaa.bbb.ccc:1234/111/222/333"),
+			vars:        map[string]string{},
+			host:        "aaa.bbb.ccc:1234",
+			path:        "",
+			shouldMatch: true,
+		},
+		{
+			title:       "Host route with port, wrong port in request URL",
+			route:       new(Route).Host("aaa.bbb.ccc:1234"),
+			request:     newRequest("GET", "http://aaa.bbb.ccc:9999/111/222/333"),
+			vars:        map[string]string{},
+			host:        "aaa.bbb.ccc:1234",
+			path:        "",
+			shouldMatch: false,
+		},
+		{
+			title:       "Host route, match with host in request header",
+			route:       new(Route).Host("aaa.bbb.ccc"),
+			request:     newRequestHost("GET", "/111/222/333", "aaa.bbb.ccc"),
+			vars:        map[string]string{},
+			host:        "aaa.bbb.ccc",
+			path:        "",
+			shouldMatch: true,
+		},
+		{
+			title:       "Host route, wrong host in request header",
+			route:       new(Route).Host("aaa.bbb.ccc"),
+			request:     newRequestHost("GET", "/111/222/333", "aaa.222.ccc"),
+			vars:        map[string]string{},
+			host:        "aaa.bbb.ccc",
+			path:        "",
+			shouldMatch: false,
+		},
+		{
+			title:       "Host route with port, match with request header",
+			route:       new(Route).Host("aaa.bbb.ccc:1234"),
+			request:     newRequestHost("GET", "/111/222/333", "aaa.bbb.ccc:1234"),
+			vars:        map[string]string{},
+			host:        "aaa.bbb.ccc:1234",
+			path:        "",
+			shouldMatch: true,
+		},
+		{
+			title:       "Host route with port, wrong host in request header",
+			route:       new(Route).Host("aaa.bbb.ccc:1234"),
+			request:     newRequestHost("GET", "/111/222/333", "aaa.bbb.ccc:9999"),
+			vars:        map[string]string{},
+			host:        "aaa.bbb.ccc:1234",
+			path:        "",
+			shouldMatch: false,
+		},
+		{
+			title:        "Host route with pattern, match with request header",
+			route:        new(Route).Host("aaa.{v1:[a-z]{3}}.ccc:1{v2:(?:23|4)}"),
+			request:      newRequestHost("GET", "/111/222/333", "aaa.bbb.ccc:123"),
+			vars:         map[string]string{"v1": "bbb", "v2": "23"},
+			host:         "aaa.bbb.ccc:123",
+			path:         "",
+			hostTemplate: `aaa.{v1:[a-z]{3}}.ccc:1{v2:(?:23|4)}`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Host route with pattern, match",
+			route:        new(Route).Host("aaa.{v1:[a-z]{3}}.ccc"),
+			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:         map[string]string{"v1": "bbb"},
+			host:         "aaa.bbb.ccc",
+			path:         "",
+			hostTemplate: `aaa.{v1:[a-z]{3}}.ccc`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Host route with pattern, additional capturing group, match",
+			route:        new(Route).Host("aaa.{v1:[a-z]{2}(?:b|c)}.ccc"),
+			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:         map[string]string{"v1": "bbb"},
+			host:         "aaa.bbb.ccc",
+			path:         "",
+			hostTemplate: `aaa.{v1:[a-z]{2}(?:b|c)}.ccc`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Host route with pattern, wrong host in request URL",
+			route:        new(Route).Host("aaa.{v1:[a-z]{3}}.ccc"),
+			request:      newRequest("GET", "http://aaa.222.ccc/111/222/333"),
+			vars:         map[string]string{"v1": "bbb"},
+			host:         "aaa.bbb.ccc",
+			path:         "",
+			hostTemplate: `aaa.{v1:[a-z]{3}}.ccc`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Host route with multiple patterns, match",
+			route:        new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}"),
+			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:         map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc"},
+			host:         "aaa.bbb.ccc",
+			path:         "",
+			hostTemplate: `{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Host route with multiple patterns, wrong host in request URL",
+			route:        new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}"),
+			request:      newRequest("GET", "http://aaa.222.ccc/111/222/333"),
+			vars:         map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc"},
+			host:         "aaa.bbb.ccc",
+			path:         "",
+			hostTemplate: `{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Host route with hyphenated name and pattern, match",
+			route:        new(Route).Host("aaa.{v-1:[a-z]{3}}.ccc"),
+			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:         map[string]string{"v-1": "bbb"},
+			host:         "aaa.bbb.ccc",
+			path:         "",
+			hostTemplate: `aaa.{v-1:[a-z]{3}}.ccc`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Host route with hyphenated name and pattern, additional capturing group, match",
+			route:        new(Route).Host("aaa.{v-1:[a-z]{2}(?:b|c)}.ccc"),
+			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:         map[string]string{"v-1": "bbb"},
+			host:         "aaa.bbb.ccc",
+			path:         "",
+			hostTemplate: `aaa.{v-1:[a-z]{2}(?:b|c)}.ccc`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Host route with multiple hyphenated names and patterns, match",
+			route:        new(Route).Host("{v-1:[a-z]{3}}.{v-2:[a-z]{3}}.{v-3:[a-z]{3}}"),
+			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:         map[string]string{"v-1": "aaa", "v-2": "bbb", "v-3": "ccc"},
+			host:         "aaa.bbb.ccc",
+			path:         "",
+			hostTemplate: `{v-1:[a-z]{3}}.{v-2:[a-z]{3}}.{v-3:[a-z]{3}}`,
+			shouldMatch:  true,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testRoute(t, test)
+			testTemplate(t, test)
+		})
+	}
+}
+
+func TestPath(t *testing.T) {
+	tests := []routeTest{
+		{
+			title:       "Path route, match",
+			route:       new(Route).Path("/111/222/333"),
+			request:     newRequest("GET", "http://localhost/111/222/333"),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "/111/222/333",
+			shouldMatch: true,
+		},
+		{
+			title:       "Path route, match with trailing slash in request and path",
+			route:       new(Route).Path("/111/"),
+			request:     newRequest("GET", "http://localhost/111/"),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "/111/",
+			shouldMatch: true,
+		},
+		{
+			title:        "Path route, do not match with trailing slash in path",
+			route:        new(Route).Path("/111/"),
+			request:      newRequest("GET", "http://localhost/111"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/111",
+			pathTemplate: `/111/`,
+			pathRegexp:   `^/111/$`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Path route, do not match with trailing slash in request",
+			route:        new(Route).Path("/111"),
+			request:      newRequest("GET", "http://localhost/111/"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/111/",
+			pathTemplate: `/111`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Path route, match root with no host",
+			route:        new(Route).Path("/"),
+			request:      newRequest("GET", "/"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/",
+			pathTemplate: `/`,
+			pathRegexp:   `^/$`,
+			shouldMatch:  true,
+		},
+		{
+			title: "Path route, match root with no host, App Engine format",
+			route: new(Route).Path("/"),
+			request: func() *http.Request {
+				r := newRequest("GET", "http://localhost/")
+				r.RequestURI = "/"
+				return r
+			}(),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/",
+			pathTemplate: `/`,
+			shouldMatch:  true,
+		},
+		{
+			title:       "Path route, wrong path in request in request URL",
+			route:       new(Route).Path("/111/222/333"),
+			request:     newRequest("GET", "http://localhost/1/2/3"),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "/111/222/333",
+			shouldMatch: false,
+		},
+		{
+			title:        "Path route with pattern, match",
+			route:        new(Route).Path("/111/{v1:[0-9]{3}}/333"),
+			request:      newRequest("GET", "http://localhost/111/222/333"),
+			vars:         map[string]string{"v1": "222"},
+			host:         "",
+			path:         "/111/222/333",
+			pathTemplate: `/111/{v1:[0-9]{3}}/333`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Path route with pattern, URL in request does not match",
+			route:        new(Route).Path("/111/{v1:[0-9]{3}}/333"),
+			request:      newRequest("GET", "http://localhost/111/aaa/333"),
+			vars:         map[string]string{"v1": "222"},
+			host:         "",
+			path:         "/111/222/333",
+			pathTemplate: `/111/{v1:[0-9]{3}}/333`,
+			pathRegexp:   `^/111/(?P<v0>[0-9]{3})/333$`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Path route with multiple patterns, match",
+			route:        new(Route).Path("/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}"),
+			request:      newRequest("GET", "http://localhost/111/222/333"),
+			vars:         map[string]string{"v1": "111", "v2": "222", "v3": "333"},
+			host:         "",
+			path:         "/111/222/333",
+			pathTemplate: `/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}`,
+			pathRegexp:   `^/(?P<v0>[0-9]{3})/(?P<v1>[0-9]{3})/(?P<v2>[0-9]{3})$`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Path route with multiple patterns, URL in request does not match",
+			route:        new(Route).Path("/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}"),
+			request:      newRequest("GET", "http://localhost/111/aaa/333"),
+			vars:         map[string]string{"v1": "111", "v2": "222", "v3": "333"},
+			host:         "",
+			path:         "/111/222/333",
+			pathTemplate: `/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}`,
+			pathRegexp:   `^/(?P<v0>[0-9]{3})/(?P<v1>[0-9]{3})/(?P<v2>[0-9]{3})$`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Path route with multiple patterns with pipe, match",
+			route:        new(Route).Path("/{category:a|(?:b/c)}/{product}/{id:[0-9]+}"),
+			request:      newRequest("GET", "http://localhost/a/product_name/1"),
+			vars:         map[string]string{"category": "a", "product": "product_name", "id": "1"},
+			host:         "",
+			path:         "/a/product_name/1",
+			pathTemplate: `/{category:a|(?:b/c)}/{product}/{id:[0-9]+}`,
+			pathRegexp:   `^/(?P<v0>a|(?:b/c))/(?P<v1>[^/]+)/(?P<v2>[0-9]+)$`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Path route with hyphenated name and pattern, match",
+			route:        new(Route).Path("/111/{v-1:[0-9]{3}}/333"),
+			request:      newRequest("GET", "http://localhost/111/222/333"),
+			vars:         map[string]string{"v-1": "222"},
+			host:         "",
+			path:         "/111/222/333",
+			pathTemplate: `/111/{v-1:[0-9]{3}}/333`,
+			pathRegexp:   `^/111/(?P<v0>[0-9]{3})/333$`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Path route with multiple hyphenated names and patterns, match",
+			route:        new(Route).Path("/{v-1:[0-9]{3}}/{v-2:[0-9]{3}}/{v-3:[0-9]{3}}"),
+			request:      newRequest("GET", "http://localhost/111/222/333"),
+			vars:         map[string]string{"v-1": "111", "v-2": "222", "v-3": "333"},
+			host:         "",
+			path:         "/111/222/333",
+			pathTemplate: `/{v-1:[0-9]{3}}/{v-2:[0-9]{3}}/{v-3:[0-9]{3}}`,
+			pathRegexp:   `^/(?P<v0>[0-9]{3})/(?P<v1>[0-9]{3})/(?P<v2>[0-9]{3})$`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Path route with multiple hyphenated names and patterns with pipe, match",
+			route:        new(Route).Path("/{product-category:a|(?:b/c)}/{product-name}/{product-id:[0-9]+}"),
+			request:      newRequest("GET", "http://localhost/a/product_name/1"),
+			vars:         map[string]string{"product-category": "a", "product-name": "product_name", "product-id": "1"},
+			host:         "",
+			path:         "/a/product_name/1",
+			pathTemplate: `/{product-category:a|(?:b/c)}/{product-name}/{product-id:[0-9]+}`,
+			pathRegexp:   `^/(?P<v0>a|(?:b/c))/(?P<v1>[^/]+)/(?P<v2>[0-9]+)$`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Path route with multiple hyphenated names and patterns with pipe and case insensitive, match",
+			route:        new(Route).Path("/{type:(?i:daily|mini|variety)}-{date:\\d{4,4}-\\d{2,2}-\\d{2,2}}"),
+			request:      newRequest("GET", "http://localhost/daily-2016-01-01"),
+			vars:         map[string]string{"type": "daily", "date": "2016-01-01"},
+			host:         "",
+			path:         "/daily-2016-01-01",
+			pathTemplate: `/{type:(?i:daily|mini|variety)}-{date:\d{4,4}-\d{2,2}-\d{2,2}}`,
+			pathRegexp:   `^/(?P<v0>(?i:daily|mini|variety))-(?P<v1>\d{4,4}-\d{2,2}-\d{2,2})$`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Path route with empty match right after other match",
+			route:        new(Route).Path(`/{v1:[0-9]*}{v2:[a-z]*}/{v3:[0-9]*}`),
+			request:      newRequest("GET", "http://localhost/111/222"),
+			vars:         map[string]string{"v1": "111", "v2": "", "v3": "222"},
+			host:         "",
+			path:         "/111/222",
+			pathTemplate: `/{v1:[0-9]*}{v2:[a-z]*}/{v3:[0-9]*}`,
+			pathRegexp:   `^/(?P<v0>[0-9]*)(?P<v1>[a-z]*)/(?P<v2>[0-9]*)$`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Path route with single pattern with pipe, match",
+			route:        new(Route).Path("/{category:a|b/c}"),
+			request:      newRequest("GET", "http://localhost/a"),
+			vars:         map[string]string{"category": "a"},
+			host:         "",
+			path:         "/a",
+			pathTemplate: `/{category:a|b/c}`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Path route with single pattern with pipe, match",
+			route:        new(Route).Path("/{category:a|b/c}"),
+			request:      newRequest("GET", "http://localhost/b/c"),
+			vars:         map[string]string{"category": "b/c"},
+			host:         "",
+			path:         "/b/c",
+			pathTemplate: `/{category:a|b/c}`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Path route with multiple patterns with pipe, match",
+			route:        new(Route).Path("/{category:a|b/c}/{product}/{id:[0-9]+}"),
+			request:      newRequest("GET", "http://localhost/a/product_name/1"),
+			vars:         map[string]string{"category": "a", "product": "product_name", "id": "1"},
+			host:         "",
+			path:         "/a/product_name/1",
+			pathTemplate: `/{category:a|b/c}/{product}/{id:[0-9]+}`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Path route with multiple patterns with pipe, match",
+			route:        new(Route).Path("/{category:a|b/c}/{product}/{id:[0-9]+}"),
+			request:      newRequest("GET", "http://localhost/b/c/product_name/1"),
+			vars:         map[string]string{"category": "b/c", "product": "product_name", "id": "1"},
+			host:         "",
+			path:         "/b/c/product_name/1",
+			pathTemplate: `/{category:a|b/c}/{product}/{id:[0-9]+}`,
+			shouldMatch:  true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testRoute(t, test)
+			testTemplate(t, test)
+			testUseEscapedRoute(t, test)
+			testRegexp(t, test)
+		})
+	}
+}
+
+func TestPathPrefix(t *testing.T) {
+	tests := []routeTest{
+		{
+			title:       "PathPrefix route, match",
+			route:       new(Route).PathPrefix("/111"),
+			request:     newRequest("GET", "http://localhost/111/222/333"),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "/111",
+			shouldMatch: true,
+		},
+		{
+			title:       "PathPrefix route, match substring",
+			route:       new(Route).PathPrefix("/1"),
+			request:     newRequest("GET", "http://localhost/111/222/333"),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "/1",
+			shouldMatch: true,
+		},
+		{
+			title:       "PathPrefix route, URL prefix in request does not match",
+			route:       new(Route).PathPrefix("/111"),
+			request:     newRequest("GET", "http://localhost/1/2/3"),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "/111",
+			shouldMatch: false,
+		},
+		{
+			title:        "PathPrefix route with pattern, match",
+			route:        new(Route).PathPrefix("/111/{v1:[0-9]{3}}"),
+			request:      newRequest("GET", "http://localhost/111/222/333"),
+			vars:         map[string]string{"v1": "222"},
+			host:         "",
+			path:         "/111/222",
+			pathTemplate: `/111/{v1:[0-9]{3}}`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "PathPrefix route with pattern, URL prefix in request does not match",
+			route:        new(Route).PathPrefix("/111/{v1:[0-9]{3}}"),
+			request:      newRequest("GET", "http://localhost/111/aaa/333"),
+			vars:         map[string]string{"v1": "222"},
+			host:         "",
+			path:         "/111/222",
+			pathTemplate: `/111/{v1:[0-9]{3}}`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "PathPrefix route with multiple patterns, match",
+			route:        new(Route).PathPrefix("/{v1:[0-9]{3}}/{v2:[0-9]{3}}"),
+			request:      newRequest("GET", "http://localhost/111/222/333"),
+			vars:         map[string]string{"v1": "111", "v2": "222"},
+			host:         "",
+			path:         "/111/222",
+			pathTemplate: `/{v1:[0-9]{3}}/{v2:[0-9]{3}}`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "PathPrefix route with multiple patterns, URL prefix in request does not match",
+			route:        new(Route).PathPrefix("/{v1:[0-9]{3}}/{v2:[0-9]{3}}"),
+			request:      newRequest("GET", "http://localhost/111/aaa/333"),
+			vars:         map[string]string{"v1": "111", "v2": "222"},
+			host:         "",
+			path:         "/111/222",
+			pathTemplate: `/{v1:[0-9]{3}}/{v2:[0-9]{3}}`,
+			shouldMatch:  false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testRoute(t, test)
+			testTemplate(t, test)
+			testUseEscapedRoute(t, test)
+		})
+	}
+}
+
+func TestSchemeHostPath(t *testing.T) {
+	tests := []routeTest{
+		{
+			title:        "Host and Path route, match",
+			route:        new(Route).Host("aaa.bbb.ccc").Path("/111/222/333"),
+			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:         map[string]string{},
+			scheme:       "http",
+			host:         "aaa.bbb.ccc",
+			path:         "/111/222/333",
+			pathTemplate: `/111/222/333`,
+			hostTemplate: `aaa.bbb.ccc`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Scheme, Host, and Path route, match",
+			route:        new(Route).Schemes("https").Host("aaa.bbb.ccc").Path("/111/222/333"),
+			request:      newRequest("GET", "https://aaa.bbb.ccc/111/222/333"),
+			vars:         map[string]string{},
+			scheme:       "https",
+			host:         "aaa.bbb.ccc",
+			path:         "/111/222/333",
+			pathTemplate: `/111/222/333`,
+			hostTemplate: `aaa.bbb.ccc`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Host and Path route, wrong host in request URL",
+			route:        new(Route).Host("aaa.bbb.ccc").Path("/111/222/333"),
+			request:      newRequest("GET", "http://aaa.222.ccc/111/222/333"),
+			vars:         map[string]string{},
+			scheme:       "http",
+			host:         "aaa.bbb.ccc",
+			path:         "/111/222/333",
+			pathTemplate: `/111/222/333`,
+			hostTemplate: `aaa.bbb.ccc`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Host and Path route with pattern, match",
+			route:        new(Route).Host("aaa.{v1:[a-z]{3}}.ccc").Path("/111/{v2:[0-9]{3}}/333"),
+			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:         map[string]string{"v1": "bbb", "v2": "222"},
+			scheme:       "http",
+			host:         "aaa.bbb.ccc",
+			path:         "/111/222/333",
+			pathTemplate: `/111/{v2:[0-9]{3}}/333`,
+			hostTemplate: `aaa.{v1:[a-z]{3}}.ccc`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Scheme, Host, and Path route with host and path patterns, match",
+			route:        new(Route).Schemes("ftp", "ssss").Host("aaa.{v1:[a-z]{3}}.ccc").Path("/111/{v2:[0-9]{3}}/333"),
+			request:      newRequest("GET", "ssss://aaa.bbb.ccc/111/222/333"),
+			vars:         map[string]string{"v1": "bbb", "v2": "222"},
+			scheme:       "ftp",
+			host:         "aaa.bbb.ccc",
+			path:         "/111/222/333",
+			pathTemplate: `/111/{v2:[0-9]{3}}/333`,
+			hostTemplate: `aaa.{v1:[a-z]{3}}.ccc`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Host and Path route with pattern, URL in request does not match",
+			route:        new(Route).Host("aaa.{v1:[a-z]{3}}.ccc").Path("/111/{v2:[0-9]{3}}/333"),
+			request:      newRequest("GET", "http://aaa.222.ccc/111/222/333"),
+			vars:         map[string]string{"v1": "bbb", "v2": "222"},
+			scheme:       "http",
+			host:         "aaa.bbb.ccc",
+			path:         "/111/222/333",
+			pathTemplate: `/111/{v2:[0-9]{3}}/333`,
+			hostTemplate: `aaa.{v1:[a-z]{3}}.ccc`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Host and Path route with multiple patterns, match",
+			route:        new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}").Path("/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}"),
+			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
+			vars:         map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc", "v4": "111", "v5": "222", "v6": "333"},
+			scheme:       "http",
+			host:         "aaa.bbb.ccc",
+			path:         "/111/222/333",
+			pathTemplate: `/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}`,
+			hostTemplate: `{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Host and Path route with multiple patterns, URL in request does not match",
+			route:        new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}").Path("/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}"),
+			request:      newRequest("GET", "http://aaa.222.ccc/111/222/333"),
+			vars:         map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc", "v4": "111", "v5": "222", "v6": "333"},
+			scheme:       "http",
+			host:         "aaa.bbb.ccc",
+			path:         "/111/222/333",
+			pathTemplate: `/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}`,
+			hostTemplate: `{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}`,
+			shouldMatch:  false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testRoute(t, test)
+			testTemplate(t, test)
+			testUseEscapedRoute(t, test)
+		})
+	}
+}
+
+func TestHeaders(t *testing.T) {
+	// newRequestHeaders creates a new request with a method, url, and headers
+	newRequestHeaders := func(method, url string, headers map[string]string) *http.Request {
+		req, err := http.NewRequest(method, url, nil)
+		if err != nil {
+			panic(err)
+		}
+		for k, v := range headers {
+			req.Header.Add(k, v)
+		}
+		return req
+	}
+
+	tests := []routeTest{
+		{
+			title:       "Headers route, match",
+			route:       new(Route).Headers("foo", "bar", "baz", "ding"),
+			request:     newRequestHeaders("GET", "http://localhost", map[string]string{"foo": "bar", "baz": "ding"}),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "",
+			shouldMatch: true,
+		},
+		{
+			title:       "Headers route, bad header values",
+			route:       new(Route).Headers("foo", "bar", "baz", "ding"),
+			request:     newRequestHeaders("GET", "http://localhost", map[string]string{"foo": "bar", "baz": "dong"}),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "",
+			shouldMatch: false,
+		},
+		{
+			title:       "Headers route, regex header values to match",
+			route:       new(Route).Headers("foo", "ba[zr]"),
+			request:     newRequestHeaders("GET", "http://localhost", map[string]string{"foo": "bar"}),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "",
+			shouldMatch: false,
+		},
+		{
+			title:       "Headers route, regex header values to match",
+			route:       new(Route).HeadersRegexp("foo", "ba[zr]"),
+			request:     newRequestHeaders("GET", "http://localhost", map[string]string{"foo": "baz"}),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "",
+			shouldMatch: true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testRoute(t, test)
+			testTemplate(t, test)
+		})
+	}
+}
+
+func TestMethods(t *testing.T) {
+	tests := []routeTest{
+		{
+			title:       "Methods route, match GET",
+			route:       new(Route).Methods("GET", "POST"),
+			request:     newRequest("GET", "http://localhost"),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "",
+			methods:     []string{"GET", "POST"},
+			shouldMatch: true,
+		},
+		{
+			title:       "Methods route, match POST",
+			route:       new(Route).Methods("GET", "POST"),
+			request:     newRequest("POST", "http://localhost"),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "",
+			methods:     []string{"GET", "POST"},
+			shouldMatch: true,
+		},
+		{
+			title:       "Methods route, bad method",
+			route:       new(Route).Methods("GET", "POST"),
+			request:     newRequest("PUT", "http://localhost"),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "",
+			methods:     []string{"GET", "POST"},
+			shouldMatch: false,
+		},
+		{
+			title:       "Route without methods",
+			route:       new(Route),
+			request:     newRequest("PUT", "http://localhost"),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "",
+			methods:     []string{},
+			shouldMatch: true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testRoute(t, test)
+			testTemplate(t, test)
+			testMethods(t, test)
+		})
+	}
+}
+
+func TestQueries(t *testing.T) {
+	tests := []routeTest{
+		{
+			title:           "Queries route, match",
+			route:           new(Route).Queries("foo", "bar", "baz", "ding"),
+			request:         newRequest("GET", "http://localhost?foo=bar&baz=ding"),
+			vars:            map[string]string{},
+			host:            "",
+			path:            "",
+			query:           "foo=bar&baz=ding",
+			queriesTemplate: "foo=bar,baz=ding",
+			queriesRegexp:   "^foo=bar$,^baz=ding$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route, match with a query string",
+			route:           new(Route).Host("www.example.com").Path("/api").Queries("foo", "bar", "baz", "ding"),
+			request:         newRequest("GET", "http://www.example.com/api?foo=bar&baz=ding"),
+			vars:            map[string]string{},
+			host:            "",
+			path:            "",
+			query:           "foo=bar&baz=ding",
+			pathTemplate:    `/api`,
+			hostTemplate:    `www.example.com`,
+			queriesTemplate: "foo=bar,baz=ding",
+			queriesRegexp:   "^foo=bar$,^baz=ding$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route, match with a query string out of order",
+			route:           new(Route).Host("www.example.com").Path("/api").Queries("foo", "bar", "baz", "ding"),
+			request:         newRequest("GET", "http://www.example.com/api?baz=ding&foo=bar"),
+			vars:            map[string]string{},
+			host:            "",
+			path:            "",
+			query:           "foo=bar&baz=ding",
+			pathTemplate:    `/api`,
+			hostTemplate:    `www.example.com`,
+			queriesTemplate: "foo=bar,baz=ding",
+			queriesRegexp:   "^foo=bar$,^baz=ding$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route, bad query",
+			route:           new(Route).Queries("foo", "bar", "baz", "ding"),
+			request:         newRequest("GET", "http://localhost?foo=bar&baz=dong"),
+			vars:            map[string]string{},
+			host:            "",
+			path:            "",
+			queriesTemplate: "foo=bar,baz=ding",
+			queriesRegexp:   "^foo=bar$,^baz=ding$",
+			shouldMatch:     false,
+		},
+		{
+			title:           "Queries route with pattern, match",
+			route:           new(Route).Queries("foo", "{v1}"),
+			request:         newRequest("GET", "http://localhost?foo=bar"),
+			vars:            map[string]string{"v1": "bar"},
+			host:            "",
+			path:            "",
+			query:           "foo=bar",
+			queriesTemplate: "foo={v1}",
+			queriesRegexp:   "^foo=(?P<v0>.*)$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route with multiple patterns, match",
+			route:           new(Route).Queries("foo", "{v1}", "baz", "{v2}"),
+			request:         newRequest("GET", "http://localhost?foo=bar&baz=ding"),
+			vars:            map[string]string{"v1": "bar", "v2": "ding"},
+			host:            "",
+			path:            "",
+			query:           "foo=bar&baz=ding",
+			queriesTemplate: "foo={v1},baz={v2}",
+			queriesRegexp:   "^foo=(?P<v0>.*)$,^baz=(?P<v0>.*)$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route with regexp pattern, match",
+			route:           new(Route).Queries("foo", "{v1:[0-9]+}"),
+			request:         newRequest("GET", "http://localhost?foo=10"),
+			vars:            map[string]string{"v1": "10"},
+			host:            "",
+			path:            "",
+			query:           "foo=10",
+			queriesTemplate: "foo={v1:[0-9]+}",
+			queriesRegexp:   "^foo=(?P<v0>[0-9]+)$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route with regexp pattern, regexp does not match",
+			route:           new(Route).Queries("foo", "{v1:[0-9]+}"),
+			request:         newRequest("GET", "http://localhost?foo=a"),
+			vars:            map[string]string{},
+			host:            "",
+			path:            "",
+			queriesTemplate: "foo={v1:[0-9]+}",
+			queriesRegexp:   "^foo=(?P<v0>[0-9]+)$",
+			shouldMatch:     false,
+		},
+		{
+			title:           "Queries route with regexp pattern with quantifier, match",
+			route:           new(Route).Queries("foo", "{v1:[0-9]{1}}"),
+			request:         newRequest("GET", "http://localhost?foo=1"),
+			vars:            map[string]string{"v1": "1"},
+			host:            "",
+			path:            "",
+			query:           "foo=1",
+			queriesTemplate: "foo={v1:[0-9]{1}}",
+			queriesRegexp:   "^foo=(?P<v0>[0-9]{1})$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route with regexp pattern with quantifier, additional variable in query string, match",
+			route:           new(Route).Queries("foo", "{v1:[0-9]{1}}"),
+			request:         newRequest("GET", "http://localhost?bar=2&foo=1"),
+			vars:            map[string]string{"v1": "1"},
+			host:            "",
+			path:            "",
+			query:           "foo=1",
+			queriesTemplate: "foo={v1:[0-9]{1}}",
+			queriesRegexp:   "^foo=(?P<v0>[0-9]{1})$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route with regexp pattern with quantifier, regexp does not match",
+			route:           new(Route).Queries("foo", "{v1:[0-9]{1}}"),
+			request:         newRequest("GET", "http://localhost?foo=12"),
+			vars:            map[string]string{},
+			host:            "",
+			path:            "",
+			queriesTemplate: "foo={v1:[0-9]{1}}",
+			queriesRegexp:   "^foo=(?P<v0>[0-9]{1})$",
+			shouldMatch:     false,
+		},
+		{
+			title:           "Queries route with regexp pattern with quantifier, additional capturing group",
+			route:           new(Route).Queries("foo", "{v1:[0-9]{1}(?:a|b)}"),
+			request:         newRequest("GET", "http://localhost?foo=1a"),
+			vars:            map[string]string{"v1": "1a"},
+			host:            "",
+			path:            "",
+			query:           "foo=1a",
+			queriesTemplate: "foo={v1:[0-9]{1}(?:a|b)}",
+			queriesRegexp:   "^foo=(?P<v0>[0-9]{1}(?:a|b))$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route with regexp pattern with quantifier, additional variable in query string, regexp does not match",
+			route:           new(Route).Queries("foo", "{v1:[0-9]{1}}"),
+			request:         newRequest("GET", "http://localhost?foo=12"),
+			vars:            map[string]string{},
+			host:            "",
+			path:            "",
+			queriesTemplate: "foo={v1:[0-9]{1}}",
+			queriesRegexp:   "^foo=(?P<v0>[0-9]{1})$",
+			shouldMatch:     false,
+		},
+		{
+			title:           "Queries route with hyphenated name, match",
+			route:           new(Route).Queries("foo", "{v-1}"),
+			request:         newRequest("GET", "http://localhost?foo=bar"),
+			vars:            map[string]string{"v-1": "bar"},
+			host:            "",
+			path:            "",
+			query:           "foo=bar",
+			queriesTemplate: "foo={v-1}",
+			queriesRegexp:   "^foo=(?P<v0>.*)$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route with multiple hyphenated names, match",
+			route:           new(Route).Queries("foo", "{v-1}", "baz", "{v-2}"),
+			request:         newRequest("GET", "http://localhost?foo=bar&baz=ding"),
+			vars:            map[string]string{"v-1": "bar", "v-2": "ding"},
+			host:            "",
+			path:            "",
+			query:           "foo=bar&baz=ding",
+			queriesTemplate: "foo={v-1},baz={v-2}",
+			queriesRegexp:   "^foo=(?P<v0>.*)$,^baz=(?P<v0>.*)$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route with hyphenate name and pattern, match",
+			route:           new(Route).Queries("foo", "{v-1:[0-9]+}"),
+			request:         newRequest("GET", "http://localhost?foo=10"),
+			vars:            map[string]string{"v-1": "10"},
+			host:            "",
+			path:            "",
+			query:           "foo=10",
+			queriesTemplate: "foo={v-1:[0-9]+}",
+			queriesRegexp:   "^foo=(?P<v0>[0-9]+)$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route with hyphenated name and pattern with quantifier, additional capturing group",
+			route:           new(Route).Queries("foo", "{v-1:[0-9]{1}(?:a|b)}"),
+			request:         newRequest("GET", "http://localhost?foo=1a"),
+			vars:            map[string]string{"v-1": "1a"},
+			host:            "",
+			path:            "",
+			query:           "foo=1a",
+			queriesTemplate: "foo={v-1:[0-9]{1}(?:a|b)}",
+			queriesRegexp:   "^foo=(?P<v0>[0-9]{1}(?:a|b))$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route with empty value, should match",
+			route:           new(Route).Queries("foo", ""),
+			request:         newRequest("GET", "http://localhost?foo=bar"),
+			vars:            map[string]string{},
+			host:            "",
+			path:            "",
+			query:           "foo=",
+			queriesTemplate: "foo=",
+			queriesRegexp:   "^foo=.*$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route with empty value and no parameter in request, should not match",
+			route:           new(Route).Queries("foo", ""),
+			request:         newRequest("GET", "http://localhost"),
+			vars:            map[string]string{},
+			host:            "",
+			path:            "",
+			queriesTemplate: "foo=",
+			queriesRegexp:   "^foo=.*$",
+			shouldMatch:     false,
+		},
+		{
+			title:           "Queries route with empty value and empty parameter in request, should match",
+			route:           new(Route).Queries("foo", ""),
+			request:         newRequest("GET", "http://localhost?foo="),
+			vars:            map[string]string{},
+			host:            "",
+			path:            "",
+			query:           "foo=",
+			queriesTemplate: "foo=",
+			queriesRegexp:   "^foo=.*$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route with overlapping value, should not match",
+			route:           new(Route).Queries("foo", "bar"),
+			request:         newRequest("GET", "http://localhost?foo=barfoo"),
+			vars:            map[string]string{},
+			host:            "",
+			path:            "",
+			queriesTemplate: "foo=bar",
+			queriesRegexp:   "^foo=bar$",
+			shouldMatch:     false,
+		},
+		{
+			title:           "Queries route with no parameter in request, should not match",
+			route:           new(Route).Queries("foo", "{bar}"),
+			request:         newRequest("GET", "http://localhost"),
+			vars:            map[string]string{},
+			host:            "",
+			path:            "",
+			queriesTemplate: "foo={bar}",
+			queriesRegexp:   "^foo=(?P<v0>.*)$",
+			shouldMatch:     false,
+		},
+		{
+			title:           "Queries route with empty parameter in request, should match",
+			route:           new(Route).Queries("foo", "{bar}"),
+			request:         newRequest("GET", "http://localhost?foo="),
+			vars:            map[string]string{"foo": ""},
+			host:            "",
+			path:            "",
+			query:           "foo=",
+			queriesTemplate: "foo={bar}",
+			queriesRegexp:   "^foo=(?P<v0>.*)$",
+			shouldMatch:     true,
+		},
+		{
+			title:           "Queries route, bad submatch",
+			route:           new(Route).Queries("foo", "bar", "baz", "ding"),
+			request:         newRequest("GET", "http://localhost?fffoo=bar&baz=dingggg"),
+			vars:            map[string]string{},
+			host:            "",
+			path:            "",
+			queriesTemplate: "foo=bar,baz=ding",
+			queriesRegexp:   "^foo=bar$,^baz=ding$",
+			shouldMatch:     false,
+		},
+		{
+			title:           "Queries route with pattern, match, escaped value",
+			route:           new(Route).Queries("foo", "{v1}"),
+			request:         newRequest("GET", "http://localhost?foo=%25bar%26%20%2F%3D%3F"),
+			vars:            map[string]string{"v1": "%bar& /=?"},
+			host:            "",
+			path:            "",
+			query:           "foo=%25bar%26+%2F%3D%3F",
+			queriesTemplate: "foo={v1}",
+			queriesRegexp:   "^foo=(?P<v0>.*)$",
+			shouldMatch:     true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testTemplate(t, test)
+			testQueriesTemplates(t, test)
+			testUseEscapedRoute(t, test)
+			testQueriesRegexp(t, test)
+		})
+	}
+}
+
+func TestSchemes(t *testing.T) {
+	tests := []routeTest{
+		// Schemes
+		{
+			title:       "Schemes route, default scheme, match http, build http",
+			route:       new(Route).Host("localhost"),
+			request:     newRequest("GET", "http://localhost"),
+			scheme:      "http",
+			host:        "localhost",
+			shouldMatch: true,
+		},
+		{
+			title:       "Schemes route, match https, build https",
+			route:       new(Route).Schemes("https", "ftp").Host("localhost"),
+			request:     newRequest("GET", "https://localhost"),
+			scheme:      "https",
+			host:        "localhost",
+			shouldMatch: true,
+		},
+		{
+			title:       "Schemes route, match ftp, build https",
+			route:       new(Route).Schemes("https", "ftp").Host("localhost"),
+			request:     newRequest("GET", "ftp://localhost"),
+			scheme:      "https",
+			host:        "localhost",
+			shouldMatch: true,
+		},
+		{
+			title:       "Schemes route, match ftp, build ftp",
+			route:       new(Route).Schemes("ftp", "https").Host("localhost"),
+			request:     newRequest("GET", "ftp://localhost"),
+			scheme:      "ftp",
+			host:        "localhost",
+			shouldMatch: true,
+		},
+		{
+			title:       "Schemes route, bad scheme",
+			route:       new(Route).Schemes("https", "ftp").Host("localhost"),
+			request:     newRequest("GET", "http://localhost"),
+			scheme:      "https",
+			host:        "localhost",
+			shouldMatch: false,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testRoute(t, test)
+			testTemplate(t, test)
+		})
+	}
+}
+
+func TestMatcherFunc(t *testing.T) {
+	m := func(r *http.Request, m *RouteMatch) bool {
+		return r.URL.Host == "aaa.bbb.ccc"
+	}
+
+	tests := []routeTest{
+		{
+			title:       "MatchFunc route, match",
+			route:       new(Route).MatcherFunc(m),
+			request:     newRequest("GET", "http://aaa.bbb.ccc"),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "",
+			shouldMatch: true,
+		},
+		{
+			title:       "MatchFunc route, non-match",
+			route:       new(Route).MatcherFunc(m),
+			request:     newRequest("GET", "http://aaa.222.ccc"),
+			vars:        map[string]string{},
+			host:        "",
+			path:        "",
+			shouldMatch: false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testRoute(t, test)
+			testTemplate(t, test)
+		})
+	}
+}
+
+func TestBuildVarsFunc(t *testing.T) {
+	tests := []routeTest{
+		{
+			title: "BuildVarsFunc set on route",
+			route: new(Route).Path(`/111/{v1:\d}{v2:.*}`).BuildVarsFunc(func(vars map[string]string) map[string]string {
+				vars["v1"] = "3"
+				vars["v2"] = "a"
+				return vars
+			}),
+			request:      newRequest("GET", "http://localhost/111/2"),
+			path:         "/111/3a",
+			pathTemplate: `/111/{v1:\d}{v2:.*}`,
+			shouldMatch:  true,
+		},
+		{
+			title: "BuildVarsFunc set on route and parent route",
+			route: new(Route).PathPrefix(`/{v1:\d}`).BuildVarsFunc(func(vars map[string]string) map[string]string {
+				vars["v1"] = "2"
+				return vars
+			}).Subrouter().Path(`/{v2:\w}`).BuildVarsFunc(func(vars map[string]string) map[string]string {
+				vars["v2"] = "b"
+				return vars
+			}),
+			request:      newRequest("GET", "http://localhost/1/a"),
+			path:         "/2/b",
+			pathTemplate: `/{v1:\d}/{v2:\w}`,
+			shouldMatch:  true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testRoute(t, test)
+			testTemplate(t, test)
+		})
+	}
+}
+
+func TestSubRouter(t *testing.T) {
+	subrouter1 := new(Route).Host("{v1:[a-z]+}.google.com").Subrouter()
+	subrouter2 := new(Route).PathPrefix("/foo/{v1}").Subrouter()
+	subrouter3 := new(Route).PathPrefix("/foo").Subrouter()
+	subrouter4 := new(Route).PathPrefix("/foo/bar").Subrouter()
+	subrouter5 := new(Route).PathPrefix("/{category}").Subrouter()
+	tests := []routeTest{
+		{
+			route:        subrouter1.Path("/{v2:[a-z]+}"),
+			request:      newRequest("GET", "http://aaa.google.com/bbb"),
+			vars:         map[string]string{"v1": "aaa", "v2": "bbb"},
+			host:         "aaa.google.com",
+			path:         "/bbb",
+			pathTemplate: `/{v2:[a-z]+}`,
+			hostTemplate: `{v1:[a-z]+}.google.com`,
+			shouldMatch:  true,
+		},
+		{
+			route:        subrouter1.Path("/{v2:[a-z]+}"),
+			request:      newRequest("GET", "http://111.google.com/111"),
+			vars:         map[string]string{"v1": "aaa", "v2": "bbb"},
+			host:         "aaa.google.com",
+			path:         "/bbb",
+			pathTemplate: `/{v2:[a-z]+}`,
+			hostTemplate: `{v1:[a-z]+}.google.com`,
+			shouldMatch:  false,
+		},
+		{
+			route:        subrouter2.Path("/baz/{v2}"),
+			request:      newRequest("GET", "http://localhost/foo/bar/baz/ding"),
+			vars:         map[string]string{"v1": "bar", "v2": "ding"},
+			host:         "",
+			path:         "/foo/bar/baz/ding",
+			pathTemplate: `/foo/{v1}/baz/{v2}`,
+			shouldMatch:  true,
+		},
+		{
+			route:        subrouter2.Path("/baz/{v2}"),
+			request:      newRequest("GET", "http://localhost/foo/bar"),
+			vars:         map[string]string{"v1": "bar", "v2": "ding"},
+			host:         "",
+			path:         "/foo/bar/baz/ding",
+			pathTemplate: `/foo/{v1}/baz/{v2}`,
+			shouldMatch:  false,
+		},
+		{
+			route:        subrouter3.Path("/"),
+			request:      newRequest("GET", "http://localhost/foo/"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/foo/",
+			pathTemplate: `/foo/`,
+			shouldMatch:  true,
+		},
+		{
+			route:        subrouter3.Path(""),
+			request:      newRequest("GET", "http://localhost/foo"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/foo",
+			pathTemplate: `/foo`,
+			shouldMatch:  true,
+		},
+
+		{
+			route:        subrouter4.Path("/"),
+			request:      newRequest("GET", "http://localhost/foo/bar/"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/foo/bar/",
+			pathTemplate: `/foo/bar/`,
+			shouldMatch:  true,
+		},
+		{
+			route:        subrouter4.Path(""),
+			request:      newRequest("GET", "http://localhost/foo/bar"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/foo/bar",
+			pathTemplate: `/foo/bar`,
+			shouldMatch:  true,
+		},
+		{
+			route:        subrouter5.Path("/"),
+			request:      newRequest("GET", "http://localhost/baz/"),
+			vars:         map[string]string{"category": "baz"},
+			host:         "",
+			path:         "/baz/",
+			pathTemplate: `/{category}/`,
+			shouldMatch:  true,
+		},
+		{
+			route:        subrouter5.Path(""),
+			request:      newRequest("GET", "http://localhost/baz"),
+			vars:         map[string]string{"category": "baz"},
+			host:         "",
+			path:         "/baz",
+			pathTemplate: `/{category}`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Mismatch method specified on parent route",
+			route:        new(Route).Methods("POST").PathPrefix("/foo").Subrouter().Path("/"),
+			request:      newRequest("GET", "http://localhost/foo/"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/foo/",
+			pathTemplate: `/foo/`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Match method specified on parent route",
+			route:        new(Route).Methods("POST").PathPrefix("/foo").Subrouter().Path("/"),
+			request:      newRequest("POST", "http://localhost/foo/"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/foo/",
+			pathTemplate: `/foo/`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Mismatch scheme specified on parent route",
+			route:        new(Route).Schemes("https").Subrouter().PathPrefix("/"),
+			request:      newRequest("GET", "http://localhost/"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/",
+			pathTemplate: `/`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Match scheme specified on parent route",
+			route:        new(Route).Schemes("http").Subrouter().PathPrefix("/"),
+			request:      newRequest("GET", "http://localhost/"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/",
+			pathTemplate: `/`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "No match header specified on parent route",
+			route:        new(Route).Headers("X-Forwarded-Proto", "https").Subrouter().PathPrefix("/"),
+			request:      newRequest("GET", "http://localhost/"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/",
+			pathTemplate: `/`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Header mismatch value specified on parent route",
+			route:        new(Route).Headers("X-Forwarded-Proto", "https").Subrouter().PathPrefix("/"),
+			request:      newRequestWithHeaders("GET", "http://localhost/", "X-Forwarded-Proto", "http"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/",
+			pathTemplate: `/`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Header match value specified on parent route",
+			route:        new(Route).Headers("X-Forwarded-Proto", "https").Subrouter().PathPrefix("/"),
+			request:      newRequestWithHeaders("GET", "http://localhost/", "X-Forwarded-Proto", "https"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/",
+			pathTemplate: `/`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Query specified on parent route not present",
+			route:        new(Route).Headers("key", "foobar").Subrouter().PathPrefix("/"),
+			request:      newRequest("GET", "http://localhost/"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/",
+			pathTemplate: `/`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Query mismatch value specified on parent route",
+			route:        new(Route).Queries("key", "foobar").Subrouter().PathPrefix("/"),
+			request:      newRequest("GET", "http://localhost/?key=notfoobar"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/",
+			pathTemplate: `/`,
+			shouldMatch:  false,
+		},
+		{
+			title:        "Query match value specified on subroute",
+			route:        new(Route).Queries("key", "foobar").Subrouter().PathPrefix("/"),
+			request:      newRequest("GET", "http://localhost/?key=foobar"),
+			vars:         map[string]string{},
+			host:         "",
+			path:         "/",
+			pathTemplate: `/`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Build with scheme on parent router",
+			route:        new(Route).Schemes("ftp").Host("google.com").Subrouter().Path("/"),
+			request:      newRequest("GET", "ftp://google.com/"),
+			scheme:       "ftp",
+			host:         "google.com",
+			path:         "/",
+			pathTemplate: `/`,
+			hostTemplate: `google.com`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Prefer scheme on child route when building URLs",
+			route:        new(Route).Schemes("https", "ftp").Host("google.com").Subrouter().Schemes("ftp").Path("/"),
+			request:      newRequest("GET", "ftp://google.com/"),
+			scheme:       "ftp",
+			host:         "google.com",
+			path:         "/",
+			pathTemplate: `/`,
+			hostTemplate: `google.com`,
+			shouldMatch:  true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testRoute(t, test)
+			testTemplate(t, test)
+			testUseEscapedRoute(t, test)
+		})
+	}
+}
+
+func TestNamedRoutes(t *testing.T) {
+	r1 := NewRouter()
+	r1.NewRoute().Name("a")
+	r1.NewRoute().Name("b")
+	r1.NewRoute().Name("c")
+
+	r2 := r1.NewRoute().Subrouter()
+	r2.NewRoute().Name("d")
+	r2.NewRoute().Name("e")
+	r2.NewRoute().Name("f")
+
+	r3 := r2.NewRoute().Subrouter()
+	r3.NewRoute().Name("g")
+	r3.NewRoute().Name("h")
+	r3.NewRoute().Name("i")
+	r3.Name("j")
+
+	if r1.namedRoutes == nil || len(r1.namedRoutes) != 10 {
+		t.Errorf("Expected 10 named routes, got %v", r1.namedRoutes)
+	} else if r1.Get("j") == nil {
+		t.Errorf("Subroute name not registered")
+	}
+}
+
+func TestNameMultipleCalls(t *testing.T) {
+	r1 := NewRouter()
+	rt := r1.NewRoute().Name("foo").Name("bar")
+	err := rt.GetError()
+	if err == nil {
+		t.Errorf("Expected an error")
+	}
+}
+
+func TestStrictSlash(t *testing.T) {
+	r := NewRouter()
+	r.StrictSlash(true)
+
+	tests := []routeTest{
+		{
+			title:          "Redirect path without slash",
+			route:          r.NewRoute().Path("/111/"),
+			request:        newRequest("GET", "http://localhost/111"),
+			vars:           map[string]string{},
+			host:           "",
+			path:           "/111/",
+			shouldMatch:    true,
+			shouldRedirect: true,
+		},
+		{
+			title:          "Do not redirect path with slash",
+			route:          r.NewRoute().Path("/111/"),
+			request:        newRequest("GET", "http://localhost/111/"),
+			vars:           map[string]string{},
+			host:           "",
+			path:           "/111/",
+			shouldMatch:    true,
+			shouldRedirect: false,
+		},
+		{
+			title:          "Redirect path with slash",
+			route:          r.NewRoute().Path("/111"),
+			request:        newRequest("GET", "http://localhost/111/"),
+			vars:           map[string]string{},
+			host:           "",
+			path:           "/111",
+			shouldMatch:    true,
+			shouldRedirect: true,
+		},
+		{
+			title:          "Do not redirect path without slash",
+			route:          r.NewRoute().Path("/111"),
+			request:        newRequest("GET", "http://localhost/111"),
+			vars:           map[string]string{},
+			host:           "",
+			path:           "/111",
+			shouldMatch:    true,
+			shouldRedirect: false,
+		},
+		{
+			title:          "Propagate StrictSlash to subrouters",
+			route:          r.NewRoute().PathPrefix("/static/").Subrouter().Path("/images/"),
+			request:        newRequest("GET", "http://localhost/static/images"),
+			vars:           map[string]string{},
+			host:           "",
+			path:           "/static/images/",
+			shouldMatch:    true,
+			shouldRedirect: true,
+		},
+		{
+			title:          "Ignore StrictSlash for path prefix",
+			route:          r.NewRoute().PathPrefix("/static/"),
+			request:        newRequest("GET", "http://localhost/static/logo.png"),
+			vars:           map[string]string{},
+			host:           "",
+			path:           "/static/",
+			shouldMatch:    true,
+			shouldRedirect: false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testRoute(t, test)
+			testTemplate(t, test)
+			testUseEscapedRoute(t, test)
+		})
+	}
+}
+
+func TestUseEncodedPath(t *testing.T) {
+	r := NewRouter()
+	r.UseEncodedPath()
+
+	tests := []routeTest{
+		{
+			title:        "Router with useEncodedPath, URL with encoded slash does match",
+			route:        r.NewRoute().Path("/v1/{v1}/v2"),
+			request:      newRequest("GET", "http://localhost/v1/1%2F2/v2"),
+			vars:         map[string]string{"v1": "1%2F2"},
+			host:         "",
+			path:         "/v1/1%2F2/v2",
+			pathTemplate: `/v1/{v1}/v2`,
+			shouldMatch:  true,
+		},
+		{
+			title:        "Router with useEncodedPath, URL with encoded slash doesn't match",
+			route:        r.NewRoute().Path("/v1/1/2/v2"),
+			request:      newRequest("GET", "http://localhost/v1/1%2F2/v2"),
+			vars:         map[string]string{"v1": "1%2F2"},
+			host:         "",
+			path:         "/v1/1%2F2/v2",
+			pathTemplate: `/v1/1/2/v2`,
+			shouldMatch:  false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testRoute(t, test)
+			testTemplate(t, test)
+		})
+	}
+}
+
+func TestWalkSingleDepth(t *testing.T) {
+	r0 := NewRouter()
+	r1 := NewRouter()
+	r2 := NewRouter()
+
+	r0.Path("/g")
+	r0.Path("/o")
+	r0.Path("/d").Handler(r1)
+	r0.Path("/r").Handler(r2)
+	r0.Path("/a")
+
+	r1.Path("/z")
+	r1.Path("/i")
+	r1.Path("/l")
+	r1.Path("/l")
+
+	r2.Path("/i")
+	r2.Path("/l")
+	r2.Path("/l")
+
+	paths := []string{"g", "o", "r", "i", "l", "l", "a"}
+	depths := []int{0, 0, 0, 1, 1, 1, 0}
+	i := 0
+	err := r0.Walk(func(route *Route, router *Router, ancestors []*Route) error {
+		matcher := route.matchers[0].(*routeRegexp)
+		if matcher.template == "/d" {
+			return SkipRouter
+		}
+		if len(ancestors) != depths[i] {
+			t.Errorf(`Expected depth of %d at i = %d; got "%d"`, depths[i], i, len(ancestors))
+		}
+		if matcher.template != "/"+paths[i] {
+			t.Errorf(`Expected "/%s" at i = %d; got "%s"`, paths[i], i, matcher.template)
+		}
+		i++
+		return nil
+	})
+	if err != nil {
+		panic(err)
+	}
+	if i != len(paths) {
+		t.Errorf("Expected %d routes, found %d", len(paths), i)
+	}
+}
+
+func TestWalkNested(t *testing.T) {
+	router := NewRouter()
+
+	routeSubrouter := func(r *Route) (*Route, *Router) {
+		return r, r.Subrouter()
+	}
+
+	gRoute, g := routeSubrouter(router.Path("/g"))
+	oRoute, o := routeSubrouter(g.PathPrefix("/o"))
+	rRoute, r := routeSubrouter(o.PathPrefix("/r"))
+	iRoute, i := routeSubrouter(r.PathPrefix("/i"))
+	l1Route, l1 := routeSubrouter(i.PathPrefix("/l"))
+	l2Route, l2 := routeSubrouter(l1.PathPrefix("/l"))
+	l2.Path("/a")
+
+	testCases := []struct {
+		path      string
+		ancestors []*Route
+	}{
+		{"/g", []*Route{}},
+		{"/g/o", []*Route{gRoute}},
+		{"/g/o/r", []*Route{gRoute, oRoute}},
+		{"/g/o/r/i", []*Route{gRoute, oRoute, rRoute}},
+		{"/g/o/r/i/l", []*Route{gRoute, oRoute, rRoute, iRoute}},
+		{"/g/o/r/i/l/l", []*Route{gRoute, oRoute, rRoute, iRoute, l1Route}},
+		{"/g/o/r/i/l/l/a", []*Route{gRoute, oRoute, rRoute, iRoute, l1Route, l2Route}},
+	}
+
+	idx := 0
+	err := router.Walk(func(route *Route, router *Router, ancestors []*Route) error {
+		path := testCases[idx].path
+		tpl := route.regexp.path.template
+		if tpl != path {
+			t.Errorf(`Expected %s got %s`, path, tpl)
+		}
+		currWantAncestors := testCases[idx].ancestors
+		if !reflect.DeepEqual(currWantAncestors, ancestors) {
+			t.Errorf(`Expected %+v got %+v`, currWantAncestors, ancestors)
+		}
+		idx++
+		return nil
+	})
+	if err != nil {
+		panic(err)
+	}
+	if idx != len(testCases) {
+		t.Errorf("Expected %d routes, found %d", len(testCases), idx)
+	}
+}
+
+func TestWalkSubrouters(t *testing.T) {
+	router := NewRouter()
+
+	g := router.Path("/g").Subrouter()
+	o := g.PathPrefix("/o").Subrouter()
+	o.Methods("GET")
+	o.Methods("PUT")
+
+	// all 4 routes should be matched
+	paths := []string{"/g", "/g/o", "/g/o", "/g/o"}
+	idx := 0
+	err := router.Walk(func(route *Route, router *Router, ancestors []*Route) error {
+		path := paths[idx]
+		tpl, _ := route.GetPathTemplate()
+		if tpl != path {
+			t.Errorf(`Expected %s got %s`, path, tpl)
+		}
+		idx++
+		return nil
+	})
+	if err != nil {
+		panic(err)
+	}
+	if idx != len(paths) {
+		t.Errorf("Expected %d routes, found %d", len(paths), idx)
+	}
+}
+
+func TestWalkErrorRoute(t *testing.T) {
+	router := NewRouter()
+	router.Path("/g")
+	expectedError := errors.New("error")
+	err := router.Walk(func(route *Route, router *Router, ancestors []*Route) error {
+		return expectedError
+	})
+	if err != expectedError {
+		t.Errorf("Expected %v routes, found %v", expectedError, err)
+	}
+}
+
+func TestWalkErrorMatcher(t *testing.T) {
+	router := NewRouter()
+	expectedError := router.Path("/g").Subrouter().Path("").GetError()
+	err := router.Walk(func(route *Route, router *Router, ancestors []*Route) error {
+		return route.GetError()
+	})
+	if err != expectedError {
+		t.Errorf("Expected %v routes, found %v", expectedError, err)
+	}
+}
+
+func TestWalkErrorHandler(t *testing.T) {
+	handler := NewRouter()
+	expectedError := handler.Path("/path").Subrouter().Path("").GetError()
+	router := NewRouter()
+	router.Path("/g").Handler(handler)
+	err := router.Walk(func(route *Route, router *Router, ancestors []*Route) error {
+		return route.GetError()
+	})
+	if err != expectedError {
+		t.Errorf("Expected %v routes, found %v", expectedError, err)
+	}
+}
+
+func TestSubrouterErrorHandling(t *testing.T) {
+	superRouterCalled := false
+	subRouterCalled := false
+
+	router := NewRouter()
+	router.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		superRouterCalled = true
+	})
+	subRouter := router.PathPrefix("/bign8").Subrouter()
+	subRouter.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		subRouterCalled = true
+	})
+
+	req, _ := http.NewRequest("GET", "http://localhost/bign8/was/here", nil)
+	router.ServeHTTP(NewRecorder(), req)
+
+	if superRouterCalled {
+		t.Error("Super router 404 handler called when sub-router 404 handler is available.")
+	}
+	if !subRouterCalled {
+		t.Error("Sub-router 404 handler was not called.")
+	}
+}
+
+// See: https://github.com/gorilla/mux/issues/200
+func TestPanicOnCapturingGroups(t *testing.T) {
+	defer func() {
+		if recover() == nil {
+			t.Errorf("(Test that capturing groups now fail fast) Expected panic, however test completed successfully.\n")
+		}
+	}()
+	NewRouter().NewRoute().Path("/{type:(promo|special)}/{promoId}.json")
+}
+
+// ----------------------------------------------------------------------------
+// Helpers
+// ----------------------------------------------------------------------------
+
+func getRouteTemplate(route *Route) string {
+	host, err := route.GetHostTemplate()
+	if err != nil {
+		host = "none"
+	}
+	path, err := route.GetPathTemplate()
+	if err != nil {
+		path = "none"
+	}
+	return fmt.Sprintf("Host: %v, Path: %v", host, path)
+}
+
+func testRoute(t *testing.T, test routeTest) {
+	request := test.request
+	route := test.route
+	vars := test.vars
+	shouldMatch := test.shouldMatch
+	query := test.query
+	shouldRedirect := test.shouldRedirect
+	uri := url.URL{
+		Scheme: test.scheme,
+		Host:   test.host,
+		Path:   test.path,
+	}
+	if uri.Scheme == "" {
+		uri.Scheme = "http"
+	}
+
+	var match RouteMatch
+	ok := route.Match(request, &match)
+	if ok != shouldMatch {
+		msg := "Should match"
+		if !shouldMatch {
+			msg = "Should not match"
+		}
+		t.Errorf("(%v) %v:\nRoute: %#v\nRequest: %#v\nVars: %v\n", test.title, msg, route, request, vars)
+		return
+	}
+	if shouldMatch {
+		if vars != nil && !stringMapEqual(vars, match.Vars) {
+			t.Errorf("(%v) Vars not equal: expected %v, got %v", test.title, vars, match.Vars)
+			return
+		}
+		if test.scheme != "" {
+			u, err := route.URL(mapToPairs(match.Vars)...)
+			if err != nil {
+				t.Fatalf("(%v) URL error: %v -- %v", test.title, err, getRouteTemplate(route))
+			}
+			if uri.Scheme != u.Scheme {
+				t.Errorf("(%v) URLScheme not equal: expected %v, got %v", test.title, uri.Scheme, u.Scheme)
+				return
+			}
+		}
+		if test.host != "" {
+			u, err := test.route.URLHost(mapToPairs(match.Vars)...)
+			if err != nil {
+				t.Fatalf("(%v) URLHost error: %v -- %v", test.title, err, getRouteTemplate(route))
+			}
+			if uri.Scheme != u.Scheme {
+				t.Errorf("(%v) URLHost scheme not equal: expected %v, got %v -- %v", test.title, uri.Scheme, u.Scheme, getRouteTemplate(route))
+				return
+			}
+			if uri.Host != u.Host {
+				t.Errorf("(%v) URLHost host not equal: expected %v, got %v -- %v", test.title, uri.Host, u.Host, getRouteTemplate(route))
+				return
+			}
+		}
+		if test.path != "" {
+			u, err := route.URLPath(mapToPairs(match.Vars)...)
+			if err != nil {
+				t.Fatalf("(%v) URLPath error: %v -- %v", test.title, err, getRouteTemplate(route))
+			}
+			if uri.Path != u.Path {
+				t.Errorf("(%v) URLPath not equal: expected %v, got %v -- %v", test.title, uri.Path, u.Path, getRouteTemplate(route))
+				return
+			}
+		}
+		if test.host != "" && test.path != "" {
+			u, err := route.URL(mapToPairs(match.Vars)...)
+			if err != nil {
+				t.Fatalf("(%v) URL error: %v -- %v", test.title, err, getRouteTemplate(route))
+			}
+			if expected, got := uri.String(), u.String(); expected != got {
+				t.Errorf("(%v) URL not equal: expected %v, got %v -- %v", test.title, expected, got, getRouteTemplate(route))
+				return
+			}
+		}
+		if query != "" {
+			u, err := route.URL(mapToPairs(match.Vars)...)
+			if err != nil {
+				t.Errorf("(%v) erred while creating url: %v", test.title, err)
+				return
+			}
+			if query != u.RawQuery {
+				t.Errorf("(%v) URL query not equal: expected %v, got %v", test.title, query, u.RawQuery)
+				return
+			}
+		}
+		if shouldRedirect && match.Handler == nil {
+			t.Errorf("(%v) Did not redirect", test.title)
+			return
+		}
+		if !shouldRedirect && match.Handler != nil {
+			t.Errorf("(%v) Unexpected redirect", test.title)
+			return
+		}
+	}
+}
+
+func testUseEscapedRoute(t *testing.T, test routeTest) {
+	test.route.useEncodedPath = true
+	testRoute(t, test)
+}
+
+func testTemplate(t *testing.T, test routeTest) {
+	route := test.route
+	pathTemplate := test.pathTemplate
+	if len(pathTemplate) == 0 {
+		pathTemplate = test.path
+	}
+	hostTemplate := test.hostTemplate
+	if len(hostTemplate) == 0 {
+		hostTemplate = test.host
+	}
+
+	routePathTemplate, pathErr := route.GetPathTemplate()
+	if pathErr == nil && routePathTemplate != pathTemplate {
+		t.Errorf("(%v) GetPathTemplate not equal: expected %v, got %v", test.title, pathTemplate, routePathTemplate)
+	}
+
+	routeHostTemplate, hostErr := route.GetHostTemplate()
+	if hostErr == nil && routeHostTemplate != hostTemplate {
+		t.Errorf("(%v) GetHostTemplate not equal: expected %v, got %v", test.title, hostTemplate, routeHostTemplate)
+	}
+}
+
+func testMethods(t *testing.T, test routeTest) {
+	route := test.route
+	methods, _ := route.GetMethods()
+	if strings.Join(methods, ",") != strings.Join(test.methods, ",") {
+		t.Errorf("(%v) GetMethods not equal: expected %v, got %v", test.title, test.methods, methods)
+	}
+}
+
+func testRegexp(t *testing.T, test routeTest) {
+	route := test.route
+	routePathRegexp, regexpErr := route.GetPathRegexp()
+	if test.pathRegexp != "" && regexpErr == nil && routePathRegexp != test.pathRegexp {
+		t.Errorf("(%v) GetPathRegexp not equal: expected %v, got %v", test.title, test.pathRegexp, routePathRegexp)
+	}
+}
+
+func testQueriesRegexp(t *testing.T, test routeTest) {
+	route := test.route
+	queries, queriesErr := route.GetQueriesRegexp()
+	gotQueries := strings.Join(queries, ",")
+	if test.queriesRegexp != "" && queriesErr == nil && gotQueries != test.queriesRegexp {
+		t.Errorf("(%v) GetQueriesRegexp not equal: expected %v, got %v", test.title, test.queriesRegexp, gotQueries)
+	}
+}
+
+func testQueriesTemplates(t *testing.T, test routeTest) {
+	route := test.route
+	queries, queriesErr := route.GetQueriesTemplates()
+	gotQueries := strings.Join(queries, ",")
+	if test.queriesTemplate != "" && queriesErr == nil && gotQueries != test.queriesTemplate {
+		t.Errorf("(%v) GetQueriesTemplates not equal: expected %v, got %v", test.title, test.queriesTemplate, gotQueries)
+	}
+}
+
+type TestA301ResponseWriter struct {
+	hh     http.Header
+	status int
+}
+
+func (ho *TestA301ResponseWriter) Header() http.Header {
+	return http.Header(ho.hh)
+}
+
+func (ho *TestA301ResponseWriter) Write(b []byte) (int, error) {
+	return 0, nil
+}
+
+func (ho *TestA301ResponseWriter) WriteHeader(code int) {
+	ho.status = code
+}
+
+func Test301Redirect(t *testing.T) {
+	m := make(http.Header)
+
+	func1 := func(w http.ResponseWriter, r *http.Request) {}
+	func2 := func(w http.ResponseWriter, r *http.Request) {}
+
+	r := NewRouter()
+	r.HandleFunc("/api/", func2).Name("func2")
+	r.HandleFunc("/", func1).Name("func1")
+
+	req, _ := http.NewRequest("GET", "http://localhost//api/?abc=def", nil)
+
+	res := TestA301ResponseWriter{
+		hh:     m,
+		status: 0,
+	}
+	r.ServeHTTP(&res, req)
+
+	if "http://localhost/api/?abc=def" != res.hh["Location"][0] {
+		t.Errorf("Should have complete URL with query string")
+	}
+}
+
+func TestSkipClean(t *testing.T) {
+	func1 := func(w http.ResponseWriter, r *http.Request) {}
+	func2 := func(w http.ResponseWriter, r *http.Request) {}
+
+	r := NewRouter()
+	r.SkipClean(true)
+	r.HandleFunc("/api/", func2).Name("func2")
+	r.HandleFunc("/", func1).Name("func1")
+
+	req, _ := http.NewRequest("GET", "http://localhost//api/?abc=def", nil)
+	res := NewRecorder()
+	r.ServeHTTP(res, req)
+
+	if len(res.HeaderMap["Location"]) != 0 {
+		t.Errorf("Shouldn't redirect since skip clean is disabled")
+	}
+}
+
+// https://plus.google.com/101022900381697718949/posts/eWy6DjFJ6uW
+func TestSubrouterHeader(t *testing.T) {
+	expected := "func1 response"
+	func1 := func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, expected)
+	}
+	func2 := func(http.ResponseWriter, *http.Request) {}
+
+	r := NewRouter()
+	s := r.Headers("SomeSpecialHeader", "").Subrouter()
+	s.HandleFunc("/", func1).Name("func1")
+	r.HandleFunc("/", func2).Name("func2")
+
+	req, _ := http.NewRequest("GET", "http://localhost/", nil)
+	req.Header.Add("SomeSpecialHeader", "foo")
+	match := new(RouteMatch)
+	matched := r.Match(req, match)
+	if !matched {
+		t.Errorf("Should match request")
+	}
+	if match.Route.GetName() != "func1" {
+		t.Errorf("Expecting func1 handler, got %s", match.Route.GetName())
+	}
+	resp := NewRecorder()
+	match.Handler.ServeHTTP(resp, req)
+	if resp.Body.String() != expected {
+		t.Errorf("Expecting %q", expected)
+	}
+}
+
+func TestNoMatchMethodErrorHandler(t *testing.T) {
+	func1 := func(w http.ResponseWriter, r *http.Request) {}
+
+	r := NewRouter()
+	r.HandleFunc("/", func1).Methods("GET", "POST")
+
+	req, _ := http.NewRequest("PUT", "http://localhost/", nil)
+	match := new(RouteMatch)
+	matched := r.Match(req, match)
+
+	if matched {
+		t.Error("Should not have matched route for methods")
+	}
+
+	if match.MatchErr != ErrMethodMismatch {
+		t.Error("Should get ErrMethodMismatch error")
+	}
+
+	resp := NewRecorder()
+	r.ServeHTTP(resp, req)
+	if resp.Code != 405 {
+		t.Errorf("Expecting code %v", 405)
+	}
+
+	// Add matching route
+	r.HandleFunc("/", func1).Methods("PUT")
+
+	match = new(RouteMatch)
+	matched = r.Match(req, match)
+
+	if !matched {
+		t.Error("Should have matched route for methods")
+	}
+
+	if match.MatchErr != nil {
+		t.Error("Should not have any matching error. Found:", match.MatchErr)
+	}
+}
+
+func TestErrMatchNotFound(t *testing.T) {
+	emptyHandler := func(w http.ResponseWriter, r *http.Request) {}
+
+	r := NewRouter()
+	r.HandleFunc("/", emptyHandler)
+	s := r.PathPrefix("/sub/").Subrouter()
+	s.HandleFunc("/", emptyHandler)
+
+	// Regular 404 not found
+	req, _ := http.NewRequest("GET", "/sub/whatever", nil)
+	match := new(RouteMatch)
+	matched := r.Match(req, match)
+
+	if matched {
+		t.Errorf("Subrouter should not have matched that, got %v", match.Route)
+	}
+	// Even without a custom handler, MatchErr is set to ErrNotFound
+	if match.MatchErr != ErrNotFound {
+		t.Errorf("Expected ErrNotFound MatchErr, but was %v", match.MatchErr)
+	}
+
+	// Now lets add a 404 handler to subrouter
+	s.NotFoundHandler = http.NotFoundHandler()
+	req, _ = http.NewRequest("GET", "/sub/whatever", nil)
+
+	// Test the subrouter first
+	match = new(RouteMatch)
+	matched = s.Match(req, match)
+	// Now we should get a match
+	if !matched {
+		t.Errorf("Subrouter should have matched %s", req.RequestURI)
+	}
+	// But MatchErr should be set to ErrNotFound anyway
+	if match.MatchErr != ErrNotFound {
+		t.Errorf("Expected ErrNotFound MatchErr, but was %v", match.MatchErr)
+	}
+
+	// Now test the parent (MatchErr should propagate)
+	match = new(RouteMatch)
+	matched = r.Match(req, match)
+
+	// Now we should get a match
+	if !matched {
+		t.Errorf("Router should have matched %s via subrouter", req.RequestURI)
+	}
+	// But MatchErr should be set to ErrNotFound anyway
+	if match.MatchErr != ErrNotFound {
+		t.Errorf("Expected ErrNotFound MatchErr, but was %v", match.MatchErr)
+	}
+}
+
+// methodsSubrouterTest models the data necessary for testing handler
+// matching for subrouters created after HTTP methods matcher registration.
+type methodsSubrouterTest struct {
+	title    string
+	wantCode int
+	router   *Router
+	// method is the input into the request and expected response
+	method string
+	// input request path
+	path string
+	// redirectTo is the expected location path for strict-slash matches
+	redirectTo string
+}
+
+// methodHandler writes the method string in response.
+func methodHandler(method string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte(method))
+	}
+}
+
+// TestMethodsSubrouterCatchall matches handlers for subrouters where a
+// catchall handler is set for a mis-matching method.
+func TestMethodsSubrouterCatchall(t *testing.T) {
+	t.Parallel()
+
+	router := NewRouter()
+	router.Methods("PATCH").Subrouter().PathPrefix("/").HandlerFunc(methodHandler("PUT"))
+	router.Methods("GET").Subrouter().HandleFunc("/foo", methodHandler("GET"))
+	router.Methods("POST").Subrouter().HandleFunc("/foo", methodHandler("POST"))
+	router.Methods("DELETE").Subrouter().HandleFunc("/foo", methodHandler("DELETE"))
+
+	tests := []methodsSubrouterTest{
+		{
+			title:    "match GET handler",
+			router:   router,
+			path:     "http://localhost/foo",
+			method:   "GET",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "match POST handler",
+			router:   router,
+			method:   "POST",
+			path:     "http://localhost/foo",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "match DELETE handler",
+			router:   router,
+			method:   "DELETE",
+			path:     "http://localhost/foo",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "disallow PUT method",
+			router:   router,
+			method:   "PUT",
+			path:     "http://localhost/foo",
+			wantCode: http.StatusMethodNotAllowed,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testMethodsSubrouter(t, test)
+		})
+	}
+}
+
+// TestMethodsSubrouterStrictSlash matches handlers on subrouters with
+// strict-slash matchers.
+func TestMethodsSubrouterStrictSlash(t *testing.T) {
+	t.Parallel()
+
+	router := NewRouter()
+	sub := router.PathPrefix("/").Subrouter()
+	sub.StrictSlash(true).Path("/foo").Methods("GET").Subrouter().HandleFunc("", methodHandler("GET"))
+	sub.StrictSlash(true).Path("/foo/").Methods("PUT").Subrouter().HandleFunc("/", methodHandler("PUT"))
+	sub.StrictSlash(true).Path("/foo/").Methods("POST").Subrouter().HandleFunc("/", methodHandler("POST"))
+
+	tests := []methodsSubrouterTest{
+		{
+			title:    "match POST handler",
+			router:   router,
+			method:   "POST",
+			path:     "http://localhost/foo/",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "match GET handler",
+			router:   router,
+			method:   "GET",
+			path:     "http://localhost/foo",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:      "match POST handler, redirect strict-slash",
+			router:     router,
+			method:     "POST",
+			path:       "http://localhost/foo",
+			redirectTo: "http://localhost/foo/",
+			wantCode:   http.StatusMovedPermanently,
+		},
+		{
+			title:      "match GET handler, redirect strict-slash",
+			router:     router,
+			method:     "GET",
+			path:       "http://localhost/foo/",
+			redirectTo: "http://localhost/foo",
+			wantCode:   http.StatusMovedPermanently,
+		},
+		{
+			title:    "disallow DELETE method",
+			router:   router,
+			method:   "DELETE",
+			path:     "http://localhost/foo",
+			wantCode: http.StatusMethodNotAllowed,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testMethodsSubrouter(t, test)
+		})
+	}
+}
+
+// TestMethodsSubrouterPathPrefix matches handlers on subrouters created
+// on a router with a path prefix matcher and method matcher.
+func TestMethodsSubrouterPathPrefix(t *testing.T) {
+	t.Parallel()
+
+	router := NewRouter()
+	router.PathPrefix("/1").Methods("POST").Subrouter().HandleFunc("/2", methodHandler("POST"))
+	router.PathPrefix("/1").Methods("DELETE").Subrouter().HandleFunc("/2", methodHandler("DELETE"))
+	router.PathPrefix("/1").Methods("PUT").Subrouter().HandleFunc("/2", methodHandler("PUT"))
+	router.PathPrefix("/1").Methods("POST").Subrouter().HandleFunc("/2", methodHandler("POST2"))
+
+	tests := []methodsSubrouterTest{
+		{
+			title:    "match first POST handler",
+			router:   router,
+			method:   "POST",
+			path:     "http://localhost/1/2",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "match DELETE handler",
+			router:   router,
+			method:   "DELETE",
+			path:     "http://localhost/1/2",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "match PUT handler",
+			router:   router,
+			method:   "PUT",
+			path:     "http://localhost/1/2",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "disallow PATCH method",
+			router:   router,
+			method:   "PATCH",
+			path:     "http://localhost/1/2",
+			wantCode: http.StatusMethodNotAllowed,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testMethodsSubrouter(t, test)
+		})
+	}
+}
+
+// TestMethodsSubrouterSubrouter matches handlers on subrouters produced
+// from method matchers registered on a root subrouter.
+func TestMethodsSubrouterSubrouter(t *testing.T) {
+	t.Parallel()
+
+	router := NewRouter()
+	sub := router.PathPrefix("/1").Subrouter()
+	sub.Methods("POST").Subrouter().HandleFunc("/2", methodHandler("POST"))
+	sub.Methods("GET").Subrouter().HandleFunc("/2", methodHandler("GET"))
+	sub.Methods("PATCH").Subrouter().HandleFunc("/2", methodHandler("PATCH"))
+	sub.HandleFunc("/2", methodHandler("PUT")).Subrouter().Methods("PUT")
+	sub.HandleFunc("/2", methodHandler("POST2")).Subrouter().Methods("POST")
+
+	tests := []methodsSubrouterTest{
+		{
+			title:    "match first POST handler",
+			router:   router,
+			method:   "POST",
+			path:     "http://localhost/1/2",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "match GET handler",
+			router:   router,
+			method:   "GET",
+			path:     "http://localhost/1/2",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "match PATCH handler",
+			router:   router,
+			method:   "PATCH",
+			path:     "http://localhost/1/2",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "match PUT handler",
+			router:   router,
+			method:   "PUT",
+			path:     "http://localhost/1/2",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "disallow DELETE method",
+			router:   router,
+			method:   "DELETE",
+			path:     "http://localhost/1/2",
+			wantCode: http.StatusMethodNotAllowed,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testMethodsSubrouter(t, test)
+		})
+	}
+}
+
+// TestMethodsSubrouterPathVariable matches handlers on matching paths
+// with path variables in them.
+func TestMethodsSubrouterPathVariable(t *testing.T) {
+	t.Parallel()
+
+	router := NewRouter()
+	router.Methods("GET").Subrouter().HandleFunc("/foo", methodHandler("GET"))
+	router.Methods("POST").Subrouter().HandleFunc("/{any}", methodHandler("POST"))
+	router.Methods("DELETE").Subrouter().HandleFunc("/1/{any}", methodHandler("DELETE"))
+	router.Methods("PUT").Subrouter().HandleFunc("/1/{any}", methodHandler("PUT"))
+
+	tests := []methodsSubrouterTest{
+		{
+			title:    "match GET handler",
+			router:   router,
+			method:   "GET",
+			path:     "http://localhost/foo",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "match POST handler",
+			router:   router,
+			method:   "POST",
+			path:     "http://localhost/foo",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "match DELETE handler",
+			router:   router,
+			method:   "DELETE",
+			path:     "http://localhost/1/foo",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "match PUT handler",
+			router:   router,
+			method:   "PUT",
+			path:     "http://localhost/1/foo",
+			wantCode: http.StatusOK,
+		},
+		{
+			title:    "disallow PATCH method",
+			router:   router,
+			method:   "PATCH",
+			path:     "http://localhost/1/foo",
+			wantCode: http.StatusMethodNotAllowed,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			testMethodsSubrouter(t, test)
+		})
+	}
+}
+
+func ExampleSetURLVars() {
+	req, _ := http.NewRequest("GET", "/foo", nil)
+	req = SetURLVars(req, map[string]string{"foo": "bar"})
+
+	fmt.Println(Vars(req)["foo"])
+
+	// Output: bar
+}
+
+// testMethodsSubrouter runs an individual methodsSubrouterTest.
+func testMethodsSubrouter(t *testing.T, test methodsSubrouterTest) {
+	// Execute request
+	req, _ := http.NewRequest(test.method, test.path, nil)
+	resp := NewRecorder()
+	test.router.ServeHTTP(resp, req)
+
+	switch test.wantCode {
+	case http.StatusMethodNotAllowed:
+		if resp.Code != http.StatusMethodNotAllowed {
+			t.Errorf(`(%s) Expected "405 Method Not Allowed", but got %d code`, test.title, resp.Code)
+		} else if matchedMethod := resp.Body.String(); matchedMethod != "" {
+			t.Errorf(`(%s) Expected "405 Method Not Allowed", but %q handler was called`, test.title, matchedMethod)
+		}
+
+	case http.StatusMovedPermanently:
+		if gotLocation := resp.HeaderMap.Get("Location"); gotLocation != test.redirectTo {
+			t.Errorf("(%s) Expected %q route-match to redirect to %q, but got %q", test.title, test.method, test.redirectTo, gotLocation)
+		}
+
+	case http.StatusOK:
+		if matchedMethod := resp.Body.String(); matchedMethod != test.method {
+			t.Errorf("(%s) Expected %q handler to be called, but %q handler was called", test.title, test.method, matchedMethod)
+		}
+
+	default:
+		expectedCodes := []int{http.StatusMethodNotAllowed, http.StatusMovedPermanently, http.StatusOK}
+		t.Errorf("(%s) Expected wantCode to be one of: %v, but got %d", test.title, expectedCodes, test.wantCode)
+	}
+}
+
+func TestSubrouterMatching(t *testing.T) {
+	const (
+		none, stdOnly, subOnly uint8 = 0, 1 << 0, 1 << 1
+		both                         = subOnly | stdOnly
+	)
+
+	type request struct {
+		Name    string
+		Request *http.Request
+		Flags   uint8
+	}
+
+	cases := []struct {
+		Name                string
+		Standard, Subrouter func(*Router)
+		Requests            []request
+	}{
+		{
+			"pathPrefix",
+			func(r *Router) {
+				r.PathPrefix("/before").PathPrefix("/after")
+			},
+			func(r *Router) {
+				r.PathPrefix("/before").Subrouter().PathPrefix("/after")
+			},
+			[]request{
+				{"no match final path prefix", newRequest("GET", "/after"), none},
+				{"no match parent path prefix", newRequest("GET", "/before"), none},
+				{"matches append", newRequest("GET", "/before/after"), both},
+				{"matches as prefix", newRequest("GET", "/before/after/1234"), both},
+			},
+		},
+		{
+			"path",
+			func(r *Router) {
+				r.Path("/before").Path("/after")
+			},
+			func(r *Router) {
+				r.Path("/before").Subrouter().Path("/after")
+			},
+			[]request{
+				{"no match subroute path", newRequest("GET", "/after"), none},
+				{"no match parent path", newRequest("GET", "/before"), none},
+				{"no match as prefix", newRequest("GET", "/before/after/1234"), none},
+				{"no match append", newRequest("GET", "/before/after"), none},
+			},
+		},
+		{
+			"host",
+			func(r *Router) {
+				r.Host("before.com").Host("after.com")
+			},
+			func(r *Router) {
+				r.Host("before.com").Subrouter().Host("after.com")
+			},
+			[]request{
+				{"no match before", newRequestHost("GET", "/", "before.com"), none},
+				{"no match other", newRequestHost("GET", "/", "other.com"), none},
+				{"matches after", newRequestHost("GET", "/", "after.com"), none},
+			},
+		},
+		{
+			"queries variant keys",
+			func(r *Router) {
+				r.Queries("foo", "bar").Queries("cricket", "baseball")
+			},
+			func(r *Router) {
+				r.Queries("foo", "bar").Subrouter().Queries("cricket", "baseball")
+			},
+			[]request{
+				{"matches with all", newRequest("GET", "/?foo=bar&cricket=baseball"), both},
+				{"matches with more", newRequest("GET", "/?foo=bar&cricket=baseball&something=else"), both},
+				{"no match with none", newRequest("GET", "/"), none},
+				{"no match with some", newRequest("GET", "/?cricket=baseball"), none},
+			},
+		},
+		{
+			"queries overlapping keys",
+			func(r *Router) {
+				r.Queries("foo", "bar").Queries("foo", "baz")
+			},
+			func(r *Router) {
+				r.Queries("foo", "bar").Subrouter().Queries("foo", "baz")
+			},
+			[]request{
+				{"no match old value", newRequest("GET", "/?foo=bar"), none},
+				{"no match diff value", newRequest("GET", "/?foo=bak"), none},
+				{"no match with none", newRequest("GET", "/"), none},
+				{"matches override", newRequest("GET", "/?foo=baz"), none},
+			},
+		},
+		{
+			"header variant keys",
+			func(r *Router) {
+				r.Headers("foo", "bar").Headers("cricket", "baseball")
+			},
+			func(r *Router) {
+				r.Headers("foo", "bar").Subrouter().Headers("cricket", "baseball")
+			},
+			[]request{
+				{
+					"matches with all",
+					newRequestWithHeaders("GET", "/", "foo", "bar", "cricket", "baseball"),
+					both,
+				},
+				{
+					"matches with more",
+					newRequestWithHeaders("GET", "/", "foo", "bar", "cricket", "baseball", "something", "else"),
+					both,
+				},
+				{"no match with none", newRequest("GET", "/"), none},
+				{"no match with some", newRequestWithHeaders("GET", "/", "cricket", "baseball"), none},
+			},
+		},
+		{
+			"header overlapping keys",
+			func(r *Router) {
+				r.Headers("foo", "bar").Headers("foo", "baz")
+			},
+			func(r *Router) {
+				r.Headers("foo", "bar").Subrouter().Headers("foo", "baz")
+			},
+			[]request{
+				{"no match old value", newRequestWithHeaders("GET", "/", "foo", "bar"), none},
+				{"no match diff value", newRequestWithHeaders("GET", "/", "foo", "bak"), none},
+				{"no match with none", newRequest("GET", "/"), none},
+				{"matches override", newRequestWithHeaders("GET", "/", "foo", "baz"), none},
+			},
+		},
+		{
+			"method",
+			func(r *Router) {
+				r.Methods("POST").Methods("GET")
+			},
+			func(r *Router) {
+				r.Methods("POST").Subrouter().Methods("GET")
+			},
+			[]request{
+				{"matches before", newRequest("POST", "/"), none},
+				{"no match other", newRequest("HEAD", "/"), none},
+				{"matches override", newRequest("GET", "/"), none},
+			},
+		},
+		{
+			"schemes",
+			func(r *Router) {
+				r.Schemes("http").Schemes("https")
+			},
+			func(r *Router) {
+				r.Schemes("http").Subrouter().Schemes("https")
+			},
+			[]request{
+				{"matches overrides", newRequest("GET", "https://www.example.com/"), none},
+				{"matches original", newRequest("GET", "http://www.example.com/"), none},
+				{"no match other", newRequest("GET", "ftp://www.example.com/"), none},
+			},
+		},
+	}
+
+	// case -> request -> router
+	for _, c := range cases {
+		t.Run(c.Name, func(t *testing.T) {
+			for _, req := range c.Requests {
+				t.Run(req.Name, func(t *testing.T) {
+					for _, v := range []struct {
+						Name     string
+						Config   func(*Router)
+						Expected bool
+					}{
+						{"subrouter", c.Subrouter, (req.Flags & subOnly) != 0},
+						{"standard", c.Standard, (req.Flags & stdOnly) != 0},
+					} {
+						r := NewRouter()
+						v.Config(r)
+						if r.Match(req.Request, &RouteMatch{}) != v.Expected {
+							if v.Expected {
+								t.Errorf("expected %v match", v.Name)
+							} else {
+								t.Errorf("expected %v no match", v.Name)
+							}
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+// verify that copyRouteConf copies fields as expected.
+func Test_copyRouteConf(t *testing.T) {
+	var (
+		m MatcherFunc = func(*http.Request, *RouteMatch) bool {
+			return true
+		}
+		b BuildVarsFunc = func(i map[string]string) map[string]string {
+			return i
+		}
+		r, _ = newRouteRegexp("hi", regexpTypeHost, routeRegexpOptions{})
+	)
+
+	tests := []struct {
+		name string
+		args routeConf
+		want routeConf
+	}{
+		{
+			"empty",
+			routeConf{},
+			routeConf{},
+		},
+		{
+			"full",
+			routeConf{
+				useEncodedPath: true,
+				strictSlash:    true,
+				skipClean:      true,
+				regexp:         routeRegexpGroup{host: r, path: r, queries: []*routeRegexp{r}},
+				matchers:       []matcher{m},
+				buildScheme:    "https",
+				buildVarsFunc:  b,
+			},
+			routeConf{
+				useEncodedPath: true,
+				strictSlash:    true,
+				skipClean:      true,
+				regexp:         routeRegexpGroup{host: r, path: r, queries: []*routeRegexp{r}},
+				matchers:       []matcher{m},
+				buildScheme:    "https",
+				buildVarsFunc:  b,
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// special case some incomparable fields of routeConf before delegating to reflect.DeepEqual
+			got := copyRouteConf(tt.args)
+
+			// funcs not comparable, just compare length of slices
+			if len(got.matchers) != len(tt.want.matchers) {
+				t.Errorf("matchers different lengths: %v %v", len(got.matchers), len(tt.want.matchers))
+			}
+			got.matchers, tt.want.matchers = nil, nil
+
+			// deep equal treats nil slice differently to empty slice so check for zero len first
+			{
+				bothZero := len(got.regexp.queries) == 0 && len(tt.want.regexp.queries) == 0
+				if !bothZero && !reflect.DeepEqual(got.regexp.queries, tt.want.regexp.queries) {
+					t.Errorf("queries unequal: %v %v", got.regexp.queries, tt.want.regexp.queries)
+				}
+				got.regexp.queries, tt.want.regexp.queries = nil, nil
+			}
+
+			// funcs not comparable, just compare nullity
+			if (got.buildVarsFunc == nil) != (tt.want.buildVarsFunc == nil) {
+				t.Errorf("build vars funcs unequal: %v %v", got.buildVarsFunc == nil, tt.want.buildVarsFunc == nil)
+			}
+			got.buildVarsFunc, tt.want.buildVarsFunc = nil, nil
+
+			// finish the deal
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("route confs unequal: %v %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestMethodNotAllowed(t *testing.T) {
+	handler := func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }
+	router := NewRouter()
+	router.HandleFunc("/thing", handler).Methods(http.MethodGet)
+	router.HandleFunc("/something", handler).Methods(http.MethodGet)
+
+	w := NewRecorder()
+	req := newRequest(http.MethodPut, "/thing")
+
+	router.ServeHTTP(w, req)
+
+	if w.Code != 405 {
+		t.Fatalf("Expected status code 405 (got %d)", w.Code)
+	}
+}
+
+func TestSubrouterNotFound(t *testing.T) {
+	handler := func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }
+	router := NewRouter()
+	router.Path("/a").Subrouter().HandleFunc("/thing", handler).Methods(http.MethodGet)
+	router.Path("/b").Subrouter().HandleFunc("/something", handler).Methods(http.MethodGet)
+
+	w := NewRecorder()
+	req := newRequest(http.MethodPut, "/not-present")
+
+	router.ServeHTTP(w, req)
+
+	if w.Code != 404 {
+		t.Fatalf("Expected status code 404 (got %d)", w.Code)
+	}
+}
+
+// mapToPairs converts a string map to a slice of string pairs
+func mapToPairs(m map[string]string) []string {
+	var i int
+	p := make([]string, len(m)*2)
+	for k, v := range m {
+		p[i] = k
+		p[i+1] = v
+		i += 2
+	}
+	return p
+}
+
+// stringMapEqual checks the equality of two string maps
+func stringMapEqual(m1, m2 map[string]string) bool {
+	nil1 := m1 == nil
+	nil2 := m2 == nil
+	if nil1 != nil2 || len(m1) != len(m2) {
+		return false
+	}
+	for k, v := range m1 {
+		if v != m2[k] {
+			return false
+		}
+	}
+	return true
+}
+
+// stringHandler returns a handler func that writes a message 's' to the
+// http.ResponseWriter.
+func stringHandler(s string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte(s))
+	}
+}
+
+// newRequest is a helper function to create a new request with a method and url.
+// The request returned is a 'server' request as opposed to a 'client' one through
+// simulated write onto the wire and read off of the wire.
+// The differences between requests are detailed in the net/http package.
+func newRequest(method, url string) *http.Request {
+	req, err := http.NewRequest(method, url, nil)
+	if err != nil {
+		panic(err)
+	}
+	// extract the escaped original host+path from url
+	// http://localhost/path/here?v=1#frag -> //localhost/path/here
+	opaque := ""
+	if i := len(req.URL.Scheme); i > 0 {
+		opaque = url[i+1:]
+	}
+
+	if i := strings.LastIndex(opaque, "?"); i > -1 {
+		opaque = opaque[:i]
+	}
+	if i := strings.LastIndex(opaque, "#"); i > -1 {
+		opaque = opaque[:i]
+	}
+
+	// Escaped host+path workaround as detailed in https://golang.org/pkg/net/url/#URL
+	// for < 1.5 client side workaround
+	req.URL.Opaque = opaque
+
+	// Simulate writing to wire
+	var buff bytes.Buffer
+	req.Write(&buff)
+	ioreader := bufio.NewReader(&buff)
+
+	// Parse request off of 'wire'
+	req, err = http.ReadRequest(ioreader)
+	if err != nil {
+		panic(err)
+	}
+	return req
+}
+
+// create a new request with the provided headers
+func newRequestWithHeaders(method, url string, headers ...string) *http.Request {
+	req := newRequest(method, url)
+
+	if len(headers)%2 != 0 {
+		panic(fmt.Sprintf("Expected headers length divisible by 2 but got %v", len(headers)))
+	}
+
+	for i := 0; i < len(headers); i += 2 {
+		req.Header.Set(headers[i], headers[i+1])
+	}
+
+	return req
+}
+
+// newRequestHost a new request with a method, url, and host header
+func newRequestHost(method, url, host string) *http.Request {
+	req, err := http.NewRequest(method, url, nil)
+	if err != nil {
+		panic(err)
+	}
+	req.Host = host
+	return req
+}
diff --git a/vendor/github.com/gorilla/mux/old_test.go b/vendor/github.com/gorilla/mux/old_test.go
new file mode 100644
index 000000000..b228983c4
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/old_test.go
@@ -0,0 +1,704 @@
+// Old tests ported to Go1. This is a mess. Want to drop it one day.
+
+// Copyright 2011 Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mux
+
+import (
+	"bytes"
+	"net/http"
+	"testing"
+)
+
+// ----------------------------------------------------------------------------
+// ResponseRecorder
+// ----------------------------------------------------------------------------
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// ResponseRecorder is an implementation of http.ResponseWriter that
+// records its mutations for later inspection in tests.
+type ResponseRecorder struct {
+	Code      int           // the HTTP response code from WriteHeader
+	HeaderMap http.Header   // the HTTP response headers
+	Body      *bytes.Buffer // if non-nil, the bytes.Buffer to append written data to
+	Flushed   bool
+}
+
+// NewRecorder returns an initialized ResponseRecorder.
+func NewRecorder() *ResponseRecorder {
+	return &ResponseRecorder{
+		HeaderMap: make(http.Header),
+		Body:      new(bytes.Buffer),
+	}
+}
+
+// Header returns the response headers.
+func (rw *ResponseRecorder) Header() http.Header {
+	return rw.HeaderMap
+}
+
+// Write always succeeds and writes to rw.Body, if not nil.
+func (rw *ResponseRecorder) Write(buf []byte) (int, error) {
+	if rw.Body != nil {
+		rw.Body.Write(buf)
+	}
+	if rw.Code == 0 {
+		rw.Code = http.StatusOK
+	}
+	return len(buf), nil
+}
+
+// WriteHeader sets rw.Code.
+func (rw *ResponseRecorder) WriteHeader(code int) {
+	rw.Code = code
+}
+
+// Flush sets rw.Flushed to true.
+func (rw *ResponseRecorder) Flush() {
+	rw.Flushed = true
+}
+
+// ----------------------------------------------------------------------------
+
+func TestRouteMatchers(t *testing.T) {
+	var scheme, host, path, query, method string
+	var headers map[string]string
+	var resultVars map[bool]map[string]string
+
+	router := NewRouter()
+	router.NewRoute().Host("{var1}.google.com").
+		Path("/{var2:[a-z]+}/{var3:[0-9]+}").
+		Queries("foo", "bar").
+		Methods("GET").
+		Schemes("https").
+		Headers("x-requested-with", "XMLHttpRequest")
+	router.NewRoute().Host("www.{var4}.com").
+		PathPrefix("/foo/{var5:[a-z]+}/{var6:[0-9]+}").
+		Queries("baz", "ding").
+		Methods("POST").
+		Schemes("http").
+		Headers("Content-Type", "application/json")
+
+	reset := func() {
+		// Everything match.
+		scheme = "https"
+		host = "www.google.com"
+		path = "/product/42"
+		query = "?foo=bar"
+		method = "GET"
+		headers = map[string]string{"X-Requested-With": "XMLHttpRequest"}
+		resultVars = map[bool]map[string]string{
+			true:  {"var1": "www", "var2": "product", "var3": "42"},
+			false: {},
+		}
+	}
+
+	reset2 := func() {
+		// Everything match.
+		scheme = "http"
+		host = "www.google.com"
+		path = "/foo/product/42/path/that/is/ignored"
+		query = "?baz=ding"
+		method = "POST"
+		headers = map[string]string{"Content-Type": "application/json"}
+		resultVars = map[bool]map[string]string{
+			true:  {"var4": "google", "var5": "product", "var6": "42"},
+			false: {},
+		}
+	}
+
+	match := func(shouldMatch bool) {
+		url := scheme + "://" + host + path + query
+		request, _ := http.NewRequest(method, url, nil)
+		for key, value := range headers {
+			request.Header.Add(key, value)
+		}
+
+		var routeMatch RouteMatch
+		matched := router.Match(request, &routeMatch)
+		if matched != shouldMatch {
+			t.Errorf("Expected: %v\nGot: %v\nRequest: %v %v", shouldMatch, matched, request.Method, url)
+		}
+
+		if matched {
+			currentRoute := routeMatch.Route
+			if currentRoute == nil {
+				t.Errorf("Expected a current route.")
+			}
+			vars := routeMatch.Vars
+			expectedVars := resultVars[shouldMatch]
+			if len(vars) != len(expectedVars) {
+				t.Errorf("Expected vars: %v Got: %v.", expectedVars, vars)
+			}
+			for name, value := range vars {
+				if expectedVars[name] != value {
+					t.Errorf("Expected vars: %v Got: %v.", expectedVars, vars)
+				}
+			}
+		}
+	}
+
+	// 1st route --------------------------------------------------------------
+
+	// Everything match.
+	reset()
+	match(true)
+
+	// Scheme doesn't match.
+	reset()
+	scheme = "http"
+	match(false)
+
+	// Host doesn't match.
+	reset()
+	host = "www.mygoogle.com"
+	match(false)
+
+	// Path doesn't match.
+	reset()
+	path = "/product/notdigits"
+	match(false)
+
+	// Query doesn't match.
+	reset()
+	query = "?foo=baz"
+	match(false)
+
+	// Method doesn't match.
+	reset()
+	method = "POST"
+	match(false)
+
+	// Header doesn't match.
+	reset()
+	headers = map[string]string{}
+	match(false)
+
+	// Everything match, again.
+	reset()
+	match(true)
+
+	// 2nd route --------------------------------------------------------------
+	// Everything match.
+	reset2()
+	match(true)
+
+	// Scheme doesn't match.
+	reset2()
+	scheme = "https"
+	match(false)
+
+	// Host doesn't match.
+	reset2()
+	host = "sub.google.com"
+	match(false)
+
+	// Path doesn't match.
+	reset2()
+	path = "/bar/product/42"
+	match(false)
+
+	// Query doesn't match.
+	reset2()
+	query = "?foo=baz"
+	match(false)
+
+	// Method doesn't match.
+	reset2()
+	method = "GET"
+	match(false)
+
+	// Header doesn't match.
+	reset2()
+	headers = map[string]string{}
+	match(false)
+
+	// Everything match, again.
+	reset2()
+	match(true)
+}
+
+type headerMatcherTest struct {
+	matcher headerMatcher
+	headers map[string]string
+	result  bool
+}
+
+var headerMatcherTests = []headerMatcherTest{
+	{
+		matcher: headerMatcher(map[string]string{"x-requested-with": "XMLHttpRequest"}),
+		headers: map[string]string{"X-Requested-With": "XMLHttpRequest"},
+		result:  true,
+	},
+	{
+		matcher: headerMatcher(map[string]string{"x-requested-with": ""}),
+		headers: map[string]string{"X-Requested-With": "anything"},
+		result:  true,
+	},
+	{
+		matcher: headerMatcher(map[string]string{"x-requested-with": "XMLHttpRequest"}),
+		headers: map[string]string{},
+		result:  false,
+	},
+}
+
+type hostMatcherTest struct {
+	matcher *Route
+	url     string
+	vars    map[string]string
+	result  bool
+}
+
+var hostMatcherTests = []hostMatcherTest{
+	{
+		matcher: NewRouter().NewRoute().Host("{foo:[a-z][a-z][a-z]}.{bar:[a-z][a-z][a-z]}.{baz:[a-z][a-z][a-z]}"),
+		url:     "http://abc.def.ghi/",
+		vars:    map[string]string{"foo": "abc", "bar": "def", "baz": "ghi"},
+		result:  true,
+	},
+	{
+		matcher: NewRouter().NewRoute().Host("{foo:[a-z][a-z][a-z]}.{bar:[a-z][a-z][a-z]}.{baz:[a-z][a-z][a-z]}"),
+		url:     "http://a.b.c/",
+		vars:    map[string]string{"foo": "abc", "bar": "def", "baz": "ghi"},
+		result:  false,
+	},
+}
+
+type methodMatcherTest struct {
+	matcher methodMatcher
+	method  string
+	result  bool
+}
+
+var methodMatcherTests = []methodMatcherTest{
+	{
+		matcher: methodMatcher([]string{"GET", "POST", "PUT"}),
+		method:  "GET",
+		result:  true,
+	},
+	{
+		matcher: methodMatcher([]string{"GET", "POST", "PUT"}),
+		method:  "POST",
+		result:  true,
+	},
+	{
+		matcher: methodMatcher([]string{"GET", "POST", "PUT"}),
+		method:  "PUT",
+		result:  true,
+	},
+	{
+		matcher: methodMatcher([]string{"GET", "POST", "PUT"}),
+		method:  "DELETE",
+		result:  false,
+	},
+}
+
+type pathMatcherTest struct {
+	matcher *Route
+	url     string
+	vars    map[string]string
+	result  bool
+}
+
+var pathMatcherTests = []pathMatcherTest{
+	{
+		matcher: NewRouter().NewRoute().Path("/{foo:[0-9][0-9][0-9]}/{bar:[0-9][0-9][0-9]}/{baz:[0-9][0-9][0-9]}"),
+		url:     "http://localhost:8080/123/456/789",
+		vars:    map[string]string{"foo": "123", "bar": "456", "baz": "789"},
+		result:  true,
+	},
+	{
+		matcher: NewRouter().NewRoute().Path("/{foo:[0-9][0-9][0-9]}/{bar:[0-9][0-9][0-9]}/{baz:[0-9][0-9][0-9]}"),
+		url:     "http://localhost:8080/1/2/3",
+		vars:    map[string]string{"foo": "123", "bar": "456", "baz": "789"},
+		result:  false,
+	},
+}
+
+type schemeMatcherTest struct {
+	matcher schemeMatcher
+	url     string
+	result  bool
+}
+
+var schemeMatcherTests = []schemeMatcherTest{
+	{
+		matcher: schemeMatcher([]string{"http", "https"}),
+		url:     "http://localhost:8080/",
+		result:  true,
+	},
+	{
+		matcher: schemeMatcher([]string{"http", "https"}),
+		url:     "https://localhost:8080/",
+		result:  true,
+	},
+	{
+		matcher: schemeMatcher([]string{"https"}),
+		url:     "http://localhost:8080/",
+		result:  false,
+	},
+	{
+		matcher: schemeMatcher([]string{"http"}),
+		url:     "https://localhost:8080/",
+		result:  false,
+	},
+}
+
+type urlBuildingTest struct {
+	route *Route
+	vars  []string
+	url   string
+}
+
+var urlBuildingTests = []urlBuildingTest{
+	{
+		route: new(Route).Host("foo.domain.com"),
+		vars:  []string{},
+		url:   "http://foo.domain.com",
+	},
+	{
+		route: new(Route).Host("{subdomain}.domain.com"),
+		vars:  []string{"subdomain", "bar"},
+		url:   "http://bar.domain.com",
+	},
+	{
+		route: new(Route).Host("foo.domain.com").Path("/articles"),
+		vars:  []string{},
+		url:   "http://foo.domain.com/articles",
+	},
+	{
+		route: new(Route).Path("/articles"),
+		vars:  []string{},
+		url:   "/articles",
+	},
+	{
+		route: new(Route).Path("/articles/{category}/{id:[0-9]+}"),
+		vars:  []string{"category", "technology", "id", "42"},
+		url:   "/articles/technology/42",
+	},
+	{
+		route: new(Route).Host("{subdomain}.domain.com").Path("/articles/{category}/{id:[0-9]+}"),
+		vars:  []string{"subdomain", "foo", "category", "technology", "id", "42"},
+		url:   "http://foo.domain.com/articles/technology/42",
+	},
+}
+
+func TestHeaderMatcher(t *testing.T) {
+	for _, v := range headerMatcherTests {
+		request, _ := http.NewRequest("GET", "http://localhost:8080/", nil)
+		for key, value := range v.headers {
+			request.Header.Add(key, value)
+		}
+		var routeMatch RouteMatch
+		result := v.matcher.Match(request, &routeMatch)
+		if result != v.result {
+			if v.result {
+				t.Errorf("%#v: should match %v.", v.matcher, request.Header)
+			} else {
+				t.Errorf("%#v: should not match %v.", v.matcher, request.Header)
+			}
+		}
+	}
+}
+
+func TestHostMatcher(t *testing.T) {
+	for _, v := range hostMatcherTests {
+		request, _ := http.NewRequest("GET", v.url, nil)
+		var routeMatch RouteMatch
+		result := v.matcher.Match(request, &routeMatch)
+		vars := routeMatch.Vars
+		if result != v.result {
+			if v.result {
+				t.Errorf("%#v: should match %v.", v.matcher, v.url)
+			} else {
+				t.Errorf("%#v: should not match %v.", v.matcher, v.url)
+			}
+		}
+		if result {
+			if len(vars) != len(v.vars) {
+				t.Errorf("%#v: vars length should be %v, got %v.", v.matcher, len(v.vars), len(vars))
+			}
+			for name, value := range vars {
+				if v.vars[name] != value {
+					t.Errorf("%#v: expected value %v for key %v, got %v.", v.matcher, v.vars[name], name, value)
+				}
+			}
+		} else {
+			if len(vars) != 0 {
+				t.Errorf("%#v: vars length should be 0, got %v.", v.matcher, len(vars))
+			}
+		}
+	}
+}
+
+func TestMethodMatcher(t *testing.T) {
+	for _, v := range methodMatcherTests {
+		request, _ := http.NewRequest(v.method, "http://localhost:8080/", nil)
+		var routeMatch RouteMatch
+		result := v.matcher.Match(request, &routeMatch)
+		if result != v.result {
+			if v.result {
+				t.Errorf("%#v: should match %v.", v.matcher, v.method)
+			} else {
+				t.Errorf("%#v: should not match %v.", v.matcher, v.method)
+			}
+		}
+	}
+}
+
+func TestPathMatcher(t *testing.T) {
+	for _, v := range pathMatcherTests {
+		request, _ := http.NewRequest("GET", v.url, nil)
+		var routeMatch RouteMatch
+		result := v.matcher.Match(request, &routeMatch)
+		vars := routeMatch.Vars
+		if result != v.result {
+			if v.result {
+				t.Errorf("%#v: should match %v.", v.matcher, v.url)
+			} else {
+				t.Errorf("%#v: should not match %v.", v.matcher, v.url)
+			}
+		}
+		if result {
+			if len(vars) != len(v.vars) {
+				t.Errorf("%#v: vars length should be %v, got %v.", v.matcher, len(v.vars), len(vars))
+			}
+			for name, value := range vars {
+				if v.vars[name] != value {
+					t.Errorf("%#v: expected value %v for key %v, got %v.", v.matcher, v.vars[name], name, value)
+				}
+			}
+		} else {
+			if len(vars) != 0 {
+				t.Errorf("%#v: vars length should be 0, got %v.", v.matcher, len(vars))
+			}
+		}
+	}
+}
+
+func TestSchemeMatcher(t *testing.T) {
+	for _, v := range schemeMatcherTests {
+		request, _ := http.NewRequest("GET", v.url, nil)
+		var routeMatch RouteMatch
+		result := v.matcher.Match(request, &routeMatch)
+		if result != v.result {
+			if v.result {
+				t.Errorf("%#v: should match %v.", v.matcher, v.url)
+			} else {
+				t.Errorf("%#v: should not match %v.", v.matcher, v.url)
+			}
+		}
+	}
+}
+
+func TestUrlBuilding(t *testing.T) {
+
+	for _, v := range urlBuildingTests {
+		u, _ := v.route.URL(v.vars...)
+		url := u.String()
+		if url != v.url {
+			t.Errorf("expected %v, got %v", v.url, url)
+			/*
+				reversePath := ""
+				reverseHost := ""
+				if v.route.pathTemplate != nil {
+						reversePath = v.route.pathTemplate.Reverse
+				}
+				if v.route.hostTemplate != nil {
+						reverseHost = v.route.hostTemplate.Reverse
+				}
+
+				t.Errorf("%#v:\nexpected: %q\ngot: %q\nreverse path: %q\nreverse host: %q", v.route, v.url, url, reversePath, reverseHost)
+			*/
+		}
+	}
+
+	ArticleHandler := func(w http.ResponseWriter, r *http.Request) {
+	}
+
+	router := NewRouter()
+	router.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler).Name("article")
+
+	url, _ := router.Get("article").URL("category", "technology", "id", "42")
+	expected := "/articles/technology/42"
+	if url.String() != expected {
+		t.Errorf("Expected %v, got %v", expected, url.String())
+	}
+}
+
+func TestMatchedRouteName(t *testing.T) {
+	routeName := "stock"
+	router := NewRouter()
+	route := router.NewRoute().Path("/products/").Name(routeName)
+
+	url := "http://www.example.com/products/"
+	request, _ := http.NewRequest("GET", url, nil)
+	var rv RouteMatch
+	ok := router.Match(request, &rv)
+
+	if !ok || rv.Route != route {
+		t.Errorf("Expected same route, got %+v.", rv.Route)
+	}
+
+	retName := rv.Route.GetName()
+	if retName != routeName {
+		t.Errorf("Expected %q, got %q.", routeName, retName)
+	}
+}
+
+func TestSubRouting(t *testing.T) {
+	// Example from docs.
+	router := NewRouter()
+	subrouter := router.NewRoute().Host("www.example.com").Subrouter()
+	route := subrouter.NewRoute().Path("/products/").Name("products")
+
+	url := "http://www.example.com/products/"
+	request, _ := http.NewRequest("GET", url, nil)
+	var rv RouteMatch
+	ok := router.Match(request, &rv)
+
+	if !ok || rv.Route != route {
+		t.Errorf("Expected same route, got %+v.", rv.Route)
+	}
+
+	u, _ := router.Get("products").URL()
+	builtURL := u.String()
+	// Yay, subroute aware of the domain when building!
+	if builtURL != url {
+		t.Errorf("Expected %q, got %q.", url, builtURL)
+	}
+}
+
+func TestVariableNames(t *testing.T) {
+	route := new(Route).Host("{arg1}.domain.com").Path("/{arg1}/{arg2:[0-9]+}")
+	if route.err == nil {
+		t.Errorf("Expected error for duplicated variable names")
+	}
+}
+
+func TestRedirectSlash(t *testing.T) {
+	var route *Route
+	var routeMatch RouteMatch
+	r := NewRouter()
+
+	r.StrictSlash(false)
+	route = r.NewRoute()
+	if route.strictSlash != false {
+		t.Errorf("Expected false redirectSlash.")
+	}
+
+	r.StrictSlash(true)
+	route = r.NewRoute()
+	if route.strictSlash != true {
+		t.Errorf("Expected true redirectSlash.")
+	}
+
+	route = new(Route)
+	route.strictSlash = true
+	route.Path("/{arg1}/{arg2:[0-9]+}/")
+	request, _ := http.NewRequest("GET", "http://localhost/foo/123", nil)
+	routeMatch = RouteMatch{}
+	_ = route.Match(request, &routeMatch)
+	vars := routeMatch.Vars
+	if vars["arg1"] != "foo" {
+		t.Errorf("Expected foo.")
+	}
+	if vars["arg2"] != "123" {
+		t.Errorf("Expected 123.")
+	}
+	rsp := NewRecorder()
+	routeMatch.Handler.ServeHTTP(rsp, request)
+	if rsp.HeaderMap.Get("Location") != "http://localhost/foo/123/" {
+		t.Errorf("Expected redirect header.")
+	}
+
+	route = new(Route)
+	route.strictSlash = true
+	route.Path("/{arg1}/{arg2:[0-9]+}")
+	request, _ = http.NewRequest("GET", "http://localhost/foo/123/", nil)
+	routeMatch = RouteMatch{}
+	_ = route.Match(request, &routeMatch)
+	vars = routeMatch.Vars
+	if vars["arg1"] != "foo" {
+		t.Errorf("Expected foo.")
+	}
+	if vars["arg2"] != "123" {
+		t.Errorf("Expected 123.")
+	}
+	rsp = NewRecorder()
+	routeMatch.Handler.ServeHTTP(rsp, request)
+	if rsp.HeaderMap.Get("Location") != "http://localhost/foo/123" {
+		t.Errorf("Expected redirect header.")
+	}
+}
+
+// Test for the new regexp library, still not available in stable Go.
+func TestNewRegexp(t *testing.T) {
+	var p *routeRegexp
+	var matches []string
+
+	tests := map[string]map[string][]string{
+		"/{foo:a{2}}": {
+			"/a":    nil,
+			"/aa":   {"aa"},
+			"/aaa":  nil,
+			"/aaaa": nil,
+		},
+		"/{foo:a{2,}}": {
+			"/a":    nil,
+			"/aa":   {"aa"},
+			"/aaa":  {"aaa"},
+			"/aaaa": {"aaaa"},
+		},
+		"/{foo:a{2,3}}": {
+			"/a":    nil,
+			"/aa":   {"aa"},
+			"/aaa":  {"aaa"},
+			"/aaaa": nil,
+		},
+		"/{foo:[a-z]{3}}/{bar:[a-z]{2}}": {
+			"/a":       nil,
+			"/ab":      nil,
+			"/abc":     nil,
+			"/abcd":    nil,
+			"/abc/ab":  {"abc", "ab"},
+			"/abc/abc": nil,
+			"/abcd/ab": nil,
+		},
+		`/{foo:\w{3,}}/{bar:\d{2,}}`: {
+			"/a":        nil,
+			"/ab":       nil,
+			"/abc":      nil,
+			"/abc/1":    nil,
+			"/abc/12":   {"abc", "12"},
+			"/abcd/12":  {"abcd", "12"},
+			"/abcd/123": {"abcd", "123"},
+		},
+	}
+
+	for pattern, paths := range tests {
+		p, _ = newRouteRegexp(pattern, regexpTypePath, routeRegexpOptions{})
+		for path, result := range paths {
+			matches = p.regexp.FindStringSubmatch(path)
+			if result == nil {
+				if matches != nil {
+					t.Errorf("%v should not match %v.", pattern, path)
+				}
+			} else {
+				if len(matches) != len(result)+1 {
+					t.Errorf("Expected %v matches, got %v.", len(result)+1, len(matches))
+				} else {
+					for k, v := range result {
+						if matches[k+1] != v {
+							t.Errorf("Expected %v, got %v.", v, matches[k+1])
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/vendor/github.com/gorilla/mux/regexp.go b/vendor/github.com/gorilla/mux/regexp.go
new file mode 100644
index 000000000..f25288675
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/regexp.go
@@ -0,0 +1,328 @@
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mux
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+type routeRegexpOptions struct {
+	strictSlash    bool
+	useEncodedPath bool
+}
+
+type regexpType int
+
+const (
+	regexpTypePath   regexpType = 0
+	regexpTypeHost   regexpType = 1
+	regexpTypePrefix regexpType = 2
+	regexpTypeQuery  regexpType = 3
+)
+
+// newRouteRegexp parses a route template and returns a routeRegexp,
+// used to match a host, a path or a query string.
+//
+// It will extract named variables, assemble a regexp to be matched, create
+// a "reverse" template to build URLs and compile regexps to validate variable
+// values used in URL building.
+//
+// Previously we accepted only Python-like identifiers for variable
+// names ([a-zA-Z_][a-zA-Z0-9_]*), but currently the only restriction is that
+// name and pattern can't be empty, and names can't contain a colon.
+func newRouteRegexp(tpl string, typ regexpType, options routeRegexpOptions) (*routeRegexp, error) {
+	// Check if it is well-formed.
+	idxs, errBraces := braceIndices(tpl)
+	if errBraces != nil {
+		return nil, errBraces
+	}
+	// Backup the original.
+	template := tpl
+	// Now let's parse it.
+	defaultPattern := "[^/]+"
+	if typ == regexpTypeQuery {
+		defaultPattern = ".*"
+	} else if typ == regexpTypeHost {
+		defaultPattern = "[^.]+"
+	}
+	// Only match strict slash if not matching
+	if typ != regexpTypePath {
+		options.strictSlash = false
+	}
+	// Set a flag for strictSlash.
+	endSlash := false
+	if options.strictSlash && strings.HasSuffix(tpl, "/") {
+		tpl = tpl[:len(tpl)-1]
+		endSlash = true
+	}
+	varsN := make([]string, len(idxs)/2)
+	varsR := make([]*regexp.Regexp, len(idxs)/2)
+	pattern := bytes.NewBufferString("")
+	pattern.WriteByte('^')
+	reverse := bytes.NewBufferString("")
+	var end int
+	var err error
+	for i := 0; i < len(idxs); i += 2 {
+		// Set all values we are interested in.
+		raw := tpl[end:idxs[i]]
+		end = idxs[i+1]
+		parts := strings.SplitN(tpl[idxs[i]+1:end-1], ":", 2)
+		name := parts[0]
+		patt := defaultPattern
+		if len(parts) == 2 {
+			patt = parts[1]
+		}
+		// Name or pattern can't be empty.
+		if name == "" || patt == "" {
+			return nil, fmt.Errorf("mux: missing name or pattern in %q",
+				tpl[idxs[i]:end])
+		}
+		// Build the regexp pattern.
+		fmt.Fprintf(pattern, "%s(?P<%s>%s)", regexp.QuoteMeta(raw), varGroupName(i/2), patt)
+
+		// Build the reverse template.
+		fmt.Fprintf(reverse, "%s%%s", raw)
+
+		// Append variable name and compiled pattern.
+		varsN[i/2] = name
+		varsR[i/2], err = regexp.Compile(fmt.Sprintf("^%s$", patt))
+		if err != nil {
+			return nil, err
+		}
+	}
+	// Add the remaining.
+	raw := tpl[end:]
+	pattern.WriteString(regexp.QuoteMeta(raw))
+	if options.strictSlash {
+		pattern.WriteString("[/]?")
+	}
+	if typ == regexpTypeQuery {
+		// Add the default pattern if the query value is empty
+		if queryVal := strings.SplitN(template, "=", 2)[1]; queryVal == "" {
+			pattern.WriteString(defaultPattern)
+		}
+	}
+	if typ != regexpTypePrefix {
+		pattern.WriteByte('$')
+	}
+	reverse.WriteString(raw)
+	if endSlash {
+		reverse.WriteByte('/')
+	}
+	// Compile full regexp.
+	reg, errCompile := regexp.Compile(pattern.String())
+	if errCompile != nil {
+		return nil, errCompile
+	}
+
+	// Check for capturing groups which used to work in older versions
+	if reg.NumSubexp() != len(idxs)/2 {
+		panic(fmt.Sprintf("route %s contains capture groups in its regexp. ", template) +
+			"Only non-capturing groups are accepted: e.g. (?:pattern) instead of (pattern)")
+	}
+
+	// Done!
+	return &routeRegexp{
+		template:   template,
+		regexpType: typ,
+		options:    options,
+		regexp:     reg,
+		reverse:    reverse.String(),
+		varsN:      varsN,
+		varsR:      varsR,
+	}, nil
+}
+
+// routeRegexp stores a regexp to match a host or path and information to
+// collect and validate route variables.
+type routeRegexp struct {
+	// The unmodified template.
+	template string
+	// The type of match
+	regexpType regexpType
+	// Options for matching
+	options routeRegexpOptions
+	// Expanded regexp.
+	regexp *regexp.Regexp
+	// Reverse template.
+	reverse string
+	// Variable names.
+	varsN []string
+	// Variable regexps (validators).
+	varsR []*regexp.Regexp
+}
+
+// Match matches the regexp against the URL host or path.
+func (r *routeRegexp) Match(req *http.Request, match *RouteMatch) bool {
+	if r.regexpType != regexpTypeHost {
+		if r.regexpType == regexpTypeQuery {
+			return r.matchQueryString(req)
+		}
+		path := req.URL.Path
+		if r.options.useEncodedPath {
+			path = req.URL.EscapedPath()
+		}
+		return r.regexp.MatchString(path)
+	}
+
+	return r.regexp.MatchString(getHost(req))
+}
+
+// url builds a URL part using the given values.
+func (r *routeRegexp) url(values map[string]string) (string, error) {
+	urlValues := make([]interface{}, len(r.varsN))
+	for k, v := range r.varsN {
+		value, ok := values[v]
+		if !ok {
+			return "", fmt.Errorf("mux: missing route variable %q", v)
+		}
+		if r.regexpType == regexpTypeQuery {
+			value = url.QueryEscape(value)
+		}
+		urlValues[k] = value
+	}
+	rv := fmt.Sprintf(r.reverse, urlValues...)
+	if !r.regexp.MatchString(rv) {
+		// The URL is checked against the full regexp, instead of checking
+		// individual variables. This is faster but to provide a good error
+		// message, we check individual regexps if the URL doesn't match.
+		for k, v := range r.varsN {
+			if !r.varsR[k].MatchString(values[v]) {
+				return "", fmt.Errorf(
+					"mux: variable %q doesn't match, expected %q", values[v],
+					r.varsR[k].String())
+			}
+		}
+	}
+	return rv, nil
+}
+
+// getURLQuery returns a single query parameter from a request URL.
+// For a URL with foo=bar&baz=ding, we return only the relevant key
+// value pair for the routeRegexp.
+func (r *routeRegexp) getURLQuery(req *http.Request) string {
+	if r.regexpType != regexpTypeQuery {
+		return ""
+	}
+	templateKey := strings.SplitN(r.template, "=", 2)[0]
+	for key, vals := range req.URL.Query() {
+		if key == templateKey && len(vals) > 0 {
+			return key + "=" + vals[0]
+		}
+	}
+	return ""
+}
+
+func (r *routeRegexp) matchQueryString(req *http.Request) bool {
+	return r.regexp.MatchString(r.getURLQuery(req))
+}
+
+// braceIndices returns the first level curly brace indices from a string.
+// It returns an error in case of unbalanced braces.
+func braceIndices(s string) ([]int, error) {
+	var level, idx int
+	var idxs []int
+	for i := 0; i < len(s); i++ {
+		switch s[i] {
+		case '{':
+			if level++; level == 1 {
+				idx = i
+			}
+		case '}':
+			if level--; level == 0 {
+				idxs = append(idxs, idx, i+1)
+			} else if level < 0 {
+				return nil, fmt.Errorf("mux: unbalanced braces in %q", s)
+			}
+		}
+	}
+	if level != 0 {
+		return nil, fmt.Errorf("mux: unbalanced braces in %q", s)
+	}
+	return idxs, nil
+}
+
+// varGroupName builds a capturing group name for the indexed variable.
+func varGroupName(idx int) string {
+	return "v" + strconv.Itoa(idx)
+}
+
+// ----------------------------------------------------------------------------
+// routeRegexpGroup
+// ----------------------------------------------------------------------------
+
+// routeRegexpGroup groups the route matchers that carry variables.
+type routeRegexpGroup struct {
+	host    *routeRegexp
+	path    *routeRegexp
+	queries []*routeRegexp
+}
+
+// setMatch extracts the variables from the URL once a route matches.
+func (v routeRegexpGroup) setMatch(req *http.Request, m *RouteMatch, r *Route) {
+	// Store host variables.
+	if v.host != nil {
+		host := getHost(req)
+		matches := v.host.regexp.FindStringSubmatchIndex(host)
+		if len(matches) > 0 {
+			extractVars(host, matches, v.host.varsN, m.Vars)
+		}
+	}
+	path := req.URL.Path
+	if r.useEncodedPath {
+		path = req.URL.EscapedPath()
+	}
+	// Store path variables.
+	if v.path != nil {
+		matches := v.path.regexp.FindStringSubmatchIndex(path)
+		if len(matches) > 0 {
+			extractVars(path, matches, v.path.varsN, m.Vars)
+			// Check if we should redirect.
+			if v.path.options.strictSlash {
+				p1 := strings.HasSuffix(path, "/")
+				p2 := strings.HasSuffix(v.path.template, "/")
+				if p1 != p2 {
+					u, _ := url.Parse(req.URL.String())
+					if p1 {
+						u.Path = u.Path[:len(u.Path)-1]
+					} else {
+						u.Path += "/"
+					}
+					m.Handler = http.RedirectHandler(u.String(), http.StatusMovedPermanently)
+				}
+			}
+		}
+	}
+	// Store query string variables.
+	for _, q := range v.queries {
+		queryURL := q.getURLQuery(req)
+		matches := q.regexp.FindStringSubmatchIndex(queryURL)
+		if len(matches) > 0 {
+			extractVars(queryURL, matches, q.varsN, m.Vars)
+		}
+	}
+}
+
+// getHost tries its best to return the request host.
+// According to section 14.23 of RFC 2616 the Host header
+// can include the port number if the default value of 80 is not used.
+func getHost(r *http.Request) string {
+	if r.URL.IsAbs() {
+		return r.URL.Host
+	}
+	return r.Host
+}
+
+func extractVars(input string, matches []int, names []string, output map[string]string) {
+	for i, name := range names {
+		output[name] = input[matches[2*i+2]:matches[2*i+3]]
+	}
+}
diff --git a/vendor/github.com/gorilla/mux/route.go b/vendor/github.com/gorilla/mux/route.go
new file mode 100644
index 000000000..8479c68c1
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/route.go
@@ -0,0 +1,710 @@
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mux
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+)
+
+// Route stores information to match a request and build URLs.
+type Route struct {
+	// Request handler for the route.
+	handler http.Handler
+	// If true, this route never matches: it is only used to build URLs.
+	buildOnly bool
+	// The name used to build URLs.
+	name string
+	// Error resulted from building a route.
+	err error
+
+	// "global" reference to all named routes
+	namedRoutes map[string]*Route
+
+	// config possibly passed in from `Router`
+	routeConf
+}
+
+// SkipClean reports whether path cleaning is enabled for this route via
+// Router.SkipClean.
+func (r *Route) SkipClean() bool {
+	return r.skipClean
+}
+
+// Match matches the route against the request.
+func (r *Route) Match(req *http.Request, match *RouteMatch) bool {
+	if r.buildOnly || r.err != nil {
+		return false
+	}
+
+	var matchErr error
+
+	// Match everything.
+	for _, m := range r.matchers {
+		if matched := m.Match(req, match); !matched {
+			if _, ok := m.(methodMatcher); ok {
+				matchErr = ErrMethodMismatch
+				continue
+			}
+
+			// Ignore ErrNotFound errors. These errors arise from match call
+			// to Subrouters.
+			//
+			// This prevents subsequent matching subrouters from failing to
+			// run middleware. If not ignored, the middleware would see a
+			// non-nil MatchErr and be skipped, even when there was a
+			// matching route.
+			if match.MatchErr == ErrNotFound {
+				match.MatchErr = nil
+			}
+
+			matchErr = nil
+			return false
+		}
+	}
+
+	if matchErr != nil {
+		match.MatchErr = matchErr
+		return false
+	}
+
+	if match.MatchErr == ErrMethodMismatch {
+		// We found a route which matches request method, clear MatchErr
+		match.MatchErr = nil
+		// Then override the mis-matched handler
+		match.Handler = r.handler
+	}
+
+	// Yay, we have a match. Let's collect some info about it.
+	if match.Route == nil {
+		match.Route = r
+	}
+	if match.Handler == nil {
+		match.Handler = r.handler
+	}
+	if match.Vars == nil {
+		match.Vars = make(map[string]string)
+	}
+
+	// Set variables.
+	r.regexp.setMatch(req, match, r)
+	return true
+}
+
+// ----------------------------------------------------------------------------
+// Route attributes
+// ----------------------------------------------------------------------------
+
+// GetError returns an error resulted from building the route, if any.
+func (r *Route) GetError() error {
+	return r.err
+}
+
+// BuildOnly sets the route to never match: it is only used to build URLs.
+func (r *Route) BuildOnly() *Route {
+	r.buildOnly = true
+	return r
+}
+
+// Handler --------------------------------------------------------------------
+
+// Handler sets a handler for the route.
+func (r *Route) Handler(handler http.Handler) *Route {
+	if r.err == nil {
+		r.handler = handler
+	}
+	return r
+}
+
+// HandlerFunc sets a handler function for the route.
+func (r *Route) HandlerFunc(f func(http.ResponseWriter, *http.Request)) *Route {
+	return r.Handler(http.HandlerFunc(f))
+}
+
+// GetHandler returns the handler for the route, if any.
+func (r *Route) GetHandler() http.Handler {
+	return r.handler
+}
+
+// Name -----------------------------------------------------------------------
+
+// Name sets the name for the route, used to build URLs.
+// It is an error to call Name more than once on a route.
+func (r *Route) Name(name string) *Route {
+	if r.name != "" {
+		r.err = fmt.Errorf("mux: route already has name %q, can't set %q",
+			r.name, name)
+	}
+	if r.err == nil {
+		r.name = name
+		r.namedRoutes[name] = r
+	}
+	return r
+}
+
+// GetName returns the name for the route, if any.
+func (r *Route) GetName() string {
+	return r.name
+}
+
+// ----------------------------------------------------------------------------
+// Matchers
+// ----------------------------------------------------------------------------
+
+// matcher types try to match a request.
+type matcher interface {
+	Match(*http.Request, *RouteMatch) bool
+}
+
+// addMatcher adds a matcher to the route.
+func (r *Route) addMatcher(m matcher) *Route {
+	if r.err == nil {
+		r.matchers = append(r.matchers, m)
+	}
+	return r
+}
+
+// addRegexpMatcher adds a host or path matcher and builder to a route.
+func (r *Route) addRegexpMatcher(tpl string, typ regexpType) error {
+	if r.err != nil {
+		return r.err
+	}
+	if typ == regexpTypePath || typ == regexpTypePrefix {
+		if len(tpl) > 0 && tpl[0] != '/' {
+			return fmt.Errorf("mux: path must start with a slash, got %q", tpl)
+		}
+		if r.regexp.path != nil {
+			tpl = strings.TrimRight(r.regexp.path.template, "/") + tpl
+		}
+	}
+	rr, err := newRouteRegexp(tpl, typ, routeRegexpOptions{
+		strictSlash:    r.strictSlash,
+		useEncodedPath: r.useEncodedPath,
+	})
+	if err != nil {
+		return err
+	}
+	for _, q := range r.regexp.queries {
+		if err = uniqueVars(rr.varsN, q.varsN); err != nil {
+			return err
+		}
+	}
+	if typ == regexpTypeHost {
+		if r.regexp.path != nil {
+			if err = uniqueVars(rr.varsN, r.regexp.path.varsN); err != nil {
+				return err
+			}
+		}
+		r.regexp.host = rr
+	} else {
+		if r.regexp.host != nil {
+			if err = uniqueVars(rr.varsN, r.regexp.host.varsN); err != nil {
+				return err
+			}
+		}
+		if typ == regexpTypeQuery {
+			r.regexp.queries = append(r.regexp.queries, rr)
+		} else {
+			r.regexp.path = rr
+		}
+	}
+	r.addMatcher(rr)
+	return nil
+}
+
+// Headers --------------------------------------------------------------------
+
+// headerMatcher matches the request against header values.
+type headerMatcher map[string]string
+
+func (m headerMatcher) Match(r *http.Request, match *RouteMatch) bool {
+	return matchMapWithString(m, r.Header, true)
+}
+
+// Headers adds a matcher for request header values.
+// It accepts a sequence of key/value pairs to be matched. For example:
+//
+//     r := mux.NewRouter()
+//     r.Headers("Content-Type", "application/json",
+//               "X-Requested-With", "XMLHttpRequest")
+//
+// The above route will only match if both request header values match.
+// If the value is an empty string, it will match any value if the key is set.
+func (r *Route) Headers(pairs ...string) *Route {
+	if r.err == nil {
+		var headers map[string]string
+		headers, r.err = mapFromPairsToString(pairs...)
+		return r.addMatcher(headerMatcher(headers))
+	}
+	return r
+}
+
+// headerRegexMatcher matches the request against the route given a regex for the header
+type headerRegexMatcher map[string]*regexp.Regexp
+
+func (m headerRegexMatcher) Match(r *http.Request, match *RouteMatch) bool {
+	return matchMapWithRegex(m, r.Header, true)
+}
+
+// HeadersRegexp accepts a sequence of key/value pairs, where the value has regex
+// support. For example:
+//
+//     r := mux.NewRouter()
+//     r.HeadersRegexp("Content-Type", "application/(text|json)",
+//               "X-Requested-With", "XMLHttpRequest")
+//
+// The above route will only match if both the request header matches both regular expressions.
+// If the value is an empty string, it will match any value if the key is set.
+// Use the start and end of string anchors (^ and $) to match an exact value.
+func (r *Route) HeadersRegexp(pairs ...string) *Route {
+	if r.err == nil {
+		var headers map[string]*regexp.Regexp
+		headers, r.err = mapFromPairsToRegex(pairs...)
+		return r.addMatcher(headerRegexMatcher(headers))
+	}
+	return r
+}
+
+// Host -----------------------------------------------------------------------
+
+// Host adds a matcher for the URL host.
+// It accepts a template with zero or more URL variables enclosed by {}.
+// Variables can define an optional regexp pattern to be matched:
+//
+// - {name} matches anything until the next dot.
+//
+// - {name:pattern} matches the given regexp pattern.
+//
+// For example:
+//
+//     r := mux.NewRouter()
+//     r.Host("www.example.com")
+//     r.Host("{subdomain}.domain.com")
+//     r.Host("{subdomain:[a-z]+}.domain.com")
+//
+// Variable names must be unique in a given route. They can be retrieved
+// calling mux.Vars(request).
+func (r *Route) Host(tpl string) *Route {
+	r.err = r.addRegexpMatcher(tpl, regexpTypeHost)
+	return r
+}
+
+// MatcherFunc ----------------------------------------------------------------
+
+// MatcherFunc is the function signature used by custom matchers.
+type MatcherFunc func(*http.Request, *RouteMatch) bool
+
+// Match returns the match for a given request.
+func (m MatcherFunc) Match(r *http.Request, match *RouteMatch) bool {
+	return m(r, match)
+}
+
+// MatcherFunc adds a custom function to be used as request matcher.
+func (r *Route) MatcherFunc(f MatcherFunc) *Route {
+	return r.addMatcher(f)
+}
+
+// Methods --------------------------------------------------------------------
+
+// methodMatcher matches the request against HTTP methods.
+type methodMatcher []string
+
+func (m methodMatcher) Match(r *http.Request, match *RouteMatch) bool {
+	return matchInArray(m, r.Method)
+}
+
+// Methods adds a matcher for HTTP methods.
+// It accepts a sequence of one or more methods to be matched, e.g.:
+// "GET", "POST", "PUT".
+func (r *Route) Methods(methods ...string) *Route {
+	for k, v := range methods {
+		methods[k] = strings.ToUpper(v)
+	}
+	return r.addMatcher(methodMatcher(methods))
+}
+
+// Path -----------------------------------------------------------------------
+
+// Path adds a matcher for the URL path.
+// It accepts a template with zero or more URL variables enclosed by {}. The
+// template must start with a "/".
+// Variables can define an optional regexp pattern to be matched:
+//
+// - {name} matches anything until the next slash.
+//
+// - {name:pattern} matches the given regexp pattern.
+//
+// For example:
+//
+//     r := mux.NewRouter()
+//     r.Path("/products/").Handler(ProductsHandler)
+//     r.Path("/products/{key}").Handler(ProductsHandler)
+//     r.Path("/articles/{category}/{id:[0-9]+}").
+//       Handler(ArticleHandler)
+//
+// Variable names must be unique in a given route. They can be retrieved
+// calling mux.Vars(request).
+func (r *Route) Path(tpl string) *Route {
+	r.err = r.addRegexpMatcher(tpl, regexpTypePath)
+	return r
+}
+
+// PathPrefix -----------------------------------------------------------------
+
+// PathPrefix adds a matcher for the URL path prefix. This matches if the given
+// template is a prefix of the full URL path. See Route.Path() for details on
+// the tpl argument.
+//
+// Note that it does not treat slashes specially ("/foobar/" will be matched by
+// the prefix "/foo") so you may want to use a trailing slash here.
+//
+// Also note that the setting of Router.StrictSlash() has no effect on routes
+// with a PathPrefix matcher.
+func (r *Route) PathPrefix(tpl string) *Route {
+	r.err = r.addRegexpMatcher(tpl, regexpTypePrefix)
+	return r
+}
+
+// Query ----------------------------------------------------------------------
+
+// Queries adds a matcher for URL query values.
+// It accepts a sequence of key/value pairs. Values may define variables.
+// For example:
+//
+//     r := mux.NewRouter()
+//     r.Queries("foo", "bar", "id", "{id:[0-9]+}")
+//
+// The above route will only match if the URL contains the defined queries
+// values, e.g.: ?foo=bar&id=42.
+//
+// If the value is an empty string, it will match any value if the key is set.
+//
+// Variables can define an optional regexp pattern to be matched:
+//
+// - {name} matches anything until the next slash.
+//
+// - {name:pattern} matches the given regexp pattern.
+func (r *Route) Queries(pairs ...string) *Route {
+	length := len(pairs)
+	if length%2 != 0 {
+		r.err = fmt.Errorf(
+			"mux: number of parameters must be multiple of 2, got %v", pairs)
+		return nil
+	}
+	for i := 0; i < length; i += 2 {
+		if r.err = r.addRegexpMatcher(pairs[i]+"="+pairs[i+1], regexpTypeQuery); r.err != nil {
+			return r
+		}
+	}
+
+	return r
+}
+
+// Schemes --------------------------------------------------------------------
+
+// schemeMatcher matches the request against URL schemes.
+type schemeMatcher []string
+
+func (m schemeMatcher) Match(r *http.Request, match *RouteMatch) bool {
+	return matchInArray(m, r.URL.Scheme)
+}
+
+// Schemes adds a matcher for URL schemes.
+// It accepts a sequence of schemes to be matched, e.g.: "http", "https".
+func (r *Route) Schemes(schemes ...string) *Route {
+	for k, v := range schemes {
+		schemes[k] = strings.ToLower(v)
+	}
+	if len(schemes) > 0 {
+		r.buildScheme = schemes[0]
+	}
+	return r.addMatcher(schemeMatcher(schemes))
+}
+
+// BuildVarsFunc --------------------------------------------------------------
+
+// BuildVarsFunc is the function signature used by custom build variable
+// functions (which can modify route variables before a route's URL is built).
+type BuildVarsFunc func(map[string]string) map[string]string
+
+// BuildVarsFunc adds a custom function to be used to modify build variables
+// before a route's URL is built.
+func (r *Route) BuildVarsFunc(f BuildVarsFunc) *Route {
+	if r.buildVarsFunc != nil {
+		// compose the old and new functions
+		old := r.buildVarsFunc
+		r.buildVarsFunc = func(m map[string]string) map[string]string {
+			return f(old(m))
+		}
+	} else {
+		r.buildVarsFunc = f
+	}
+	return r
+}
+
+// Subrouter ------------------------------------------------------------------
+
+// Subrouter creates a subrouter for the route.
+//
+// It will test the inner routes only if the parent route matched. For example:
+//
+//     r := mux.NewRouter()
+//     s := r.Host("www.example.com").Subrouter()
+//     s.HandleFunc("/products/", ProductsHandler)
+//     s.HandleFunc("/products/{key}", ProductHandler)
+//     s.HandleFunc("/articles/{category}/{id:[0-9]+}"), ArticleHandler)
+//
+// Here, the routes registered in the subrouter won't be tested if the host
+// doesn't match.
+func (r *Route) Subrouter() *Router {
+	// initialize a subrouter with a copy of the parent route's configuration
+	router := &Router{routeConf: copyRouteConf(r.routeConf), namedRoutes: r.namedRoutes}
+	r.addMatcher(router)
+	return router
+}
+
+// ----------------------------------------------------------------------------
+// URL building
+// ----------------------------------------------------------------------------
+
+// URL builds a URL for the route.
+//
+// It accepts a sequence of key/value pairs for the route variables. For
+// example, given this route:
+//
+//     r := mux.NewRouter()
+//     r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler).
+//       Name("article")
+//
+// ...a URL for it can be built using:
+//
+//     url, err := r.Get("article").URL("category", "technology", "id", "42")
+//
+// ...which will return an url.URL with the following path:
+//
+//     "/articles/technology/42"
+//
+// This also works for host variables:
+//
+//     r := mux.NewRouter()
+//     r.Host("{subdomain}.domain.com").
+//       HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler).
+//       Name("article")
+//
+//     // url.String() will be "http://news.domain.com/articles/technology/42"
+//     url, err := r.Get("article").URL("subdomain", "news",
+//                                      "category", "technology",
+//                                      "id", "42")
+//
+// All variables defined in the route are required, and their values must
+// conform to the corresponding patterns.
+func (r *Route) URL(pairs ...string) (*url.URL, error) {
+	if r.err != nil {
+		return nil, r.err
+	}
+	values, err := r.prepareVars(pairs...)
+	if err != nil {
+		return nil, err
+	}
+	var scheme, host, path string
+	queries := make([]string, 0, len(r.regexp.queries))
+	if r.regexp.host != nil {
+		if host, err = r.regexp.host.url(values); err != nil {
+			return nil, err
+		}
+		scheme = "http"
+		if r.buildScheme != "" {
+			scheme = r.buildScheme
+		}
+	}
+	if r.regexp.path != nil {
+		if path, err = r.regexp.path.url(values); err != nil {
+			return nil, err
+		}
+	}
+	for _, q := range r.regexp.queries {
+		var query string
+		if query, err = q.url(values); err != nil {
+			return nil, err
+		}
+		queries = append(queries, query)
+	}
+	return &url.URL{
+		Scheme:   scheme,
+		Host:     host,
+		Path:     path,
+		RawQuery: strings.Join(queries, "&"),
+	}, nil
+}
+
+// URLHost builds the host part of the URL for a route. See Route.URL().
+//
+// The route must have a host defined.
+func (r *Route) URLHost(pairs ...string) (*url.URL, error) {
+	if r.err != nil {
+		return nil, r.err
+	}
+	if r.regexp.host == nil {
+		return nil, errors.New("mux: route doesn't have a host")
+	}
+	values, err := r.prepareVars(pairs...)
+	if err != nil {
+		return nil, err
+	}
+	host, err := r.regexp.host.url(values)
+	if err != nil {
+		return nil, err
+	}
+	u := &url.URL{
+		Scheme: "http",
+		Host:   host,
+	}
+	if r.buildScheme != "" {
+		u.Scheme = r.buildScheme
+	}
+	return u, nil
+}
+
+// URLPath builds the path part of the URL for a route. See Route.URL().
+//
+// The route must have a path defined.
+func (r *Route) URLPath(pairs ...string) (*url.URL, error) {
+	if r.err != nil {
+		return nil, r.err
+	}
+	if r.regexp.path == nil {
+		return nil, errors.New("mux: route doesn't have a path")
+	}
+	values, err := r.prepareVars(pairs...)
+	if err != nil {
+		return nil, err
+	}
+	path, err := r.regexp.path.url(values)
+	if err != nil {
+		return nil, err
+	}
+	return &url.URL{
+		Path: path,
+	}, nil
+}
+
+// GetPathTemplate returns the template used to build the
+// route match.
+// This is useful for building simple REST API documentation and for instrumentation
+// against third-party services.
+// An error will be returned if the route does not define a path.
+func (r *Route) GetPathTemplate() (string, error) {
+	if r.err != nil {
+		return "", r.err
+	}
+	if r.regexp.path == nil {
+		return "", errors.New("mux: route doesn't have a path")
+	}
+	return r.regexp.path.template, nil
+}
+
+// GetPathRegexp returns the expanded regular expression used to match route path.
+// This is useful for building simple REST API documentation and for instrumentation
+// against third-party services.
+// An error will be returned if the route does not define a path.
+func (r *Route) GetPathRegexp() (string, error) {
+	if r.err != nil {
+		return "", r.err
+	}
+	if r.regexp.path == nil {
+		return "", errors.New("mux: route does not have a path")
+	}
+	return r.regexp.path.regexp.String(), nil
+}
+
+// GetQueriesRegexp returns the expanded regular expressions used to match the
+// route queries.
+// This is useful for building simple REST API documentation and for instrumentation
+// against third-party services.
+// An error will be returned if the route does not have queries.
+func (r *Route) GetQueriesRegexp() ([]string, error) {
+	if r.err != nil {
+		return nil, r.err
+	}
+	if r.regexp.queries == nil {
+		return nil, errors.New("mux: route doesn't have queries")
+	}
+	var queries []string
+	for _, query := range r.regexp.queries {
+		queries = append(queries, query.regexp.String())
+	}
+	return queries, nil
+}
+
+// GetQueriesTemplates returns the templates used to build the
+// query matching.
+// This is useful for building simple REST API documentation and for instrumentation
+// against third-party services.
+// An error will be returned if the route does not define queries.
+func (r *Route) GetQueriesTemplates() ([]string, error) {
+	if r.err != nil {
+		return nil, r.err
+	}
+	if r.regexp.queries == nil {
+		return nil, errors.New("mux: route doesn't have queries")
+	}
+	var queries []string
+	for _, query := range r.regexp.queries {
+		queries = append(queries, query.template)
+	}
+	return queries, nil
+}
+
+// GetMethods returns the methods the route matches against
+// This is useful for building simple REST API documentation and for instrumentation
+// against third-party services.
+// An error will be returned if route does not have methods.
+func (r *Route) GetMethods() ([]string, error) {
+	if r.err != nil {
+		return nil, r.err
+	}
+	for _, m := range r.matchers {
+		if methods, ok := m.(methodMatcher); ok {
+			return []string(methods), nil
+		}
+	}
+	return nil, errors.New("mux: route doesn't have methods")
+}
+
+// GetHostTemplate returns the template used to build the
+// route match.
+// This is useful for building simple REST API documentation and for instrumentation
+// against third-party services.
+// An error will be returned if the route does not define a host.
+func (r *Route) GetHostTemplate() (string, error) {
+	if r.err != nil {
+		return "", r.err
+	}
+	if r.regexp.host == nil {
+		return "", errors.New("mux: route doesn't have a host")
+	}
+	return r.regexp.host.template, nil
+}
+
+// prepareVars converts the route variable pairs into a map. If the route has a
+// BuildVarsFunc, it is invoked.
+func (r *Route) prepareVars(pairs ...string) (map[string]string, error) {
+	m, err := mapFromPairsToString(pairs...)
+	if err != nil {
+		return nil, err
+	}
+	return r.buildVars(m), nil
+}
+
+func (r *Route) buildVars(m map[string]string) map[string]string {
+	if r.buildVarsFunc != nil {
+		m = r.buildVarsFunc(m)
+	}
+	return m
+}
diff --git a/vendor/github.com/gorilla/mux/test_helpers.go b/vendor/github.com/gorilla/mux/test_helpers.go
new file mode 100644
index 000000000..32ecffde4
--- /dev/null
+++ b/vendor/github.com/gorilla/mux/test_helpers.go
@@ -0,0 +1,19 @@
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mux
+
+import "net/http"
+
+// SetURLVars sets the URL variables for the given request, to be accessed via
+// mux.Vars for testing route behaviour. Arguments are not modified, a shallow
+// copy is returned.
+//
+// This API should only be used for testing purposes; it provides a way to
+// inject variables into the request context. Alternatively, URL variables
+// can be set by making a route that captures the required variables,
+// starting a server and sending the request to that server.
+func SetURLVars(r *http.Request, val map[string]string) *http.Request {
+	return setVars(r, val)
+}
diff --git a/vendor/gitlab.com/golang-commonmark/html/.gitlab-ci.yml b/vendor/gitlab.com/golang-commonmark/html/.gitlab-ci.yml
new file mode 100644
index 000000000..aaf2cbddf
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/html/.gitlab-ci.yml
@@ -0,0 +1,16 @@
+image: golang:1.11
+
+stages:
+  - build
+  - test
+
+build:
+  stage: build
+  script:
+    - go build ./...
+
+test:
+  stage: test
+  script:
+    - test -z "$(gofmt -l . | tee /dev/stderr)"
+    - go test ./...
diff --git a/vendor/gitlab.com/golang-commonmark/html/LICENSE b/vendor/gitlab.com/golang-commonmark/html/LICENSE
new file mode 100644
index 000000000..9cdcd2016
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/html/LICENSE
@@ -0,0 +1,10 @@
+Copyright (c) 2015, The Authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE 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 HOLDER 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.
diff --git a/vendor/gitlab.com/golang-commonmark/html/README.md b/vendor/gitlab.com/golang-commonmark/html/README.md
new file mode 100644
index 000000000..1fbc8ea8e
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/html/README.md
@@ -0,0 +1,8 @@
+html [![License](https://img.shields.io/badge/licence-BSD--2--Clause-blue.svg)](https://opensource.org/licenses/BSD-2-Clause) [![GoDoc](http://godoc.org/gitlab.com/golang-commonmark/html?status.svg)](http://godoc.org/gitlab.com/golang-commonmark/html) [![Pipeline status](https://gitlab.com/golang-commonmark/html/badges/master/pipeline.svg)](https://gitlab.com/golang-commonmark/html/commits/master)
+====
+
+Package html provides functions for escaping/unescaping HTML text and for parsing HTML entities.
+
+## Install
+
+    go get -u gitlab.com/golang-commonmark/html
diff --git a/vendor/gitlab.com/golang-commonmark/html/html.go b/vendor/gitlab.com/golang-commonmark/html/html.go
new file mode 100644
index 000000000..25bf7d82a
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/html/html.go
@@ -0,0 +1,211 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package html provides functions for escaping/unescaping HTML text and for parsing HTML entities.
+package html
+
+import (
+	"io"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+)
+
+const BadEntity = string(utf8.RuneError)
+
+var htmlEscapeReplacer = strings.NewReplacer(
+	"&", "&amp;",
+	"<", "&lt;",
+	">", "&gt;",
+	`"`, "&quot;",
+)
+
+func EscapeString(s string) string {
+	return htmlEscapeReplacer.Replace(s)
+}
+
+func WriteEscapedString(w io.Writer, s string) error {
+	_, err := htmlEscapeReplacer.WriteString(w, s)
+	return err
+}
+
+func isValidEntityCode(c int64) bool {
+	switch {
+	case !utf8.ValidRune(rune(c)):
+		return false
+
+	// never used
+	case c >= 0xfdd0 && c <= 0xfdef:
+		return false
+	case c&0xffff == 0xffff || c&0xffff == 0xfffe:
+		return false
+	// control codes
+	case c >= 0x00 && c <= 0x08:
+		return false
+	case c == 0x0b:
+		return false
+	case c >= 0x0e && c <= 0x1f:
+		return false
+	case c >= 0x7f && c <= 0x9f:
+		return false
+	}
+
+	return true
+}
+
+func letter(b byte) bool { return b >= 'a' && b <= 'z' || b >= 'A' && b <= 'Z' }
+
+func digit(b byte) bool { return b >= '0' && b <= '9' }
+
+func alphanum(b byte) bool { return letter(b) || digit(b) }
+
+func hexDigit(b byte) bool {
+	return digit(b) || b >= 'a' && b <= 'f' || b >= 'A' && b <= 'F'
+}
+
+func ParseEntity(s string) (string, int) {
+	st := 0
+	var n int
+
+	for i := 1; i < len(s); i++ {
+		b := s[i]
+
+		switch st {
+		case 0: // initial state
+			switch {
+			case b == '#':
+				st = 1
+			case letter(b):
+				n = 1
+				st = 2
+			default:
+				return "", 0
+			}
+
+		case 1: // &#
+			switch {
+			case b == 'x' || b == 'X':
+				st = 3
+			case digit(b):
+				n = 1
+				st = 4
+			default:
+				return "", 0
+			}
+
+		case 2: // &q
+			switch {
+			case alphanum(b):
+				n++
+				if n > 31 {
+					return "", 0
+				}
+			case b == ';':
+				if e, ok := entities[s[i-n:i]]; ok {
+					return e, i + 1
+				}
+				return "", 0
+			default:
+				return "", 0
+			}
+
+		case 3: // &#x
+			switch {
+			case hexDigit(b):
+				n = 1
+				st = 5
+			default:
+				return "", 0
+			}
+
+		case 4: // &#0
+			switch {
+			case digit(b):
+				n++
+				if n > 8 {
+					return "", 0
+				}
+			case b == ';':
+				c, _ := strconv.ParseInt(s[i-n:i], 10, 32)
+				if !isValidEntityCode(c) {
+					return BadEntity, i + 1
+				}
+				return string(rune(c)), i + 1
+			default:
+				return "", 0
+			}
+
+		case 5: // &#x0
+			switch {
+			case hexDigit(b):
+				n++
+				if n > 8 {
+					return "", 0
+				}
+			case b == ';':
+				c, err := strconv.ParseInt(s[i-n:i], 16, 32)
+				if err != nil {
+					return BadEntity, i + 1
+				}
+				if !isValidEntityCode(c) {
+					return BadEntity, i + 1
+				}
+				return string(rune(c)), i + 1
+			default:
+				return "", 0
+			}
+		}
+	}
+
+	return "", 0
+}
+
+func UnescapeString(s string) string {
+	i := strings.IndexByte(s, '&')
+	if i < 0 {
+		return s
+	}
+
+	anyChanges := false
+	var entityStr string
+	var entityLen int
+	for i < len(s) {
+		if s[i] == '&' {
+			entityStr, entityLen = ParseEntity(s[i:])
+			if entityLen > 0 {
+				anyChanges = true
+				break
+			}
+		}
+		i++
+	}
+
+	if !anyChanges {
+		return s
+	}
+
+	buf := make([]byte, len(s)-entityLen+len(entityStr))
+	copy(buf[:i], s)
+	n := copy(buf[i:], entityStr)
+	j := i + n
+	i += entityLen
+	for i < len(s) {
+		b := s[i]
+		if b == '&' {
+			entityStr, entityLen = ParseEntity(s[i:])
+			if entityLen > 0 {
+				n = copy(buf[j:], entityStr)
+				j += n
+				i += entityLen
+				continue
+			}
+		}
+
+		buf[j] = b
+		j++
+		i++
+	}
+
+	return string(buf[:j])
+}
diff --git a/vendor/gitlab.com/golang-commonmark/html/html5_entities.go b/vendor/gitlab.com/golang-commonmark/html/html5_entities.go
new file mode 100644
index 000000000..200512abc
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/html/html5_entities.go
@@ -0,0 +1,2133 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package html
+
+var entities = map[string]string{
+	"AElig":                           "\u00C6",
+	"AMP":                             "\u0026",
+	"Aacute":                          "\u00C1",
+	"Abreve":                          "\u0102",
+	"Acirc":                           "\u00C2",
+	"Acy":                             "\u0410",
+	"Afr":                             "\U0001D504",
+	"Agrave":                          "\u00C0",
+	"Alpha":                           "\u0391",
+	"Amacr":                           "\u0100",
+	"And":                             "\u2A53",
+	"Aogon":                           "\u0104",
+	"Aopf":                            "\U0001D538",
+	"ApplyFunction":                   "\u2061",
+	"Aring":                           "\u00C5",
+	"Ascr":                            "\U0001D49C",
+	"Assign":                          "\u2254",
+	"Atilde":                          "\u00C3",
+	"Auml":                            "\u00C4",
+	"Backslash":                       "\u2216",
+	"Barv":                            "\u2AE7",
+	"Barwed":                          "\u2306",
+	"Bcy":                             "\u0411",
+	"Because":                         "\u2235",
+	"Bernoullis":                      "\u212C",
+	"Beta":                            "\u0392",
+	"Bfr":                             "\U0001D505",
+	"Bopf":                            "\U0001D539",
+	"Breve":                           "\u02D8",
+	"Bscr":                            "\u212C",
+	"Bumpeq":                          "\u224E",
+	"CHcy":                            "\u0427",
+	"COPY":                            "\u00A9",
+	"Cacute":                          "\u0106",
+	"Cap":                             "\u22D2",
+	"CapitalDifferentialD":            "\u2145",
+	"Cayleys":                         "\u212D",
+	"Ccaron":                          "\u010C",
+	"Ccedil":                          "\u00C7",
+	"Ccirc":                           "\u0108",
+	"Cconint":                         "\u2230",
+	"Cdot":                            "\u010A",
+	"Cedilla":                         "\u00B8",
+	"CenterDot":                       "\u00B7",
+	"Cfr":                             "\u212D",
+	"Chi":                             "\u03A7",
+	"CircleDot":                       "\u2299",
+	"CircleMinus":                     "\u2296",
+	"CirclePlus":                      "\u2295",
+	"CircleTimes":                     "\u2297",
+	"ClockwiseContourIntegral":        "\u2232",
+	"CloseCurlyDoubleQuote":           "\u201D",
+	"CloseCurlyQuote":                 "\u2019",
+	"Colon":                           "\u2237",
+	"Colone":                          "\u2A74",
+	"Congruent":                       "\u2261",
+	"Conint":                          "\u222F",
+	"ContourIntegral":                 "\u222E",
+	"Copf":                            "\u2102",
+	"Coproduct":                       "\u2210",
+	"CounterClockwiseContourIntegral": "\u2233",
+	"Cross":                           "\u2A2F",
+	"Cscr":                            "\U0001D49E",
+	"Cup":                             "\u22D3",
+	"CupCap":                          "\u224D",
+	"DD":                              "\u2145",
+	"DDotrahd":                        "\u2911",
+	"DJcy":                            "\u0402",
+	"DScy":                            "\u0405",
+	"DZcy":                            "\u040F",
+	"Dagger":                          "\u2021",
+	"Darr":                            "\u21A1",
+	"Dashv":                           "\u2AE4",
+	"Dcaron":                          "\u010E",
+	"Dcy":                             "\u0414",
+	"Del":                             "\u2207",
+	"Delta":                           "\u0394",
+	"Dfr":                             "\U0001D507",
+	"DiacriticalAcute":                "\u00B4",
+	"DiacriticalDot":                  "\u02D9",
+	"DiacriticalDoubleAcute":          "\u02DD",
+	"DiacriticalGrave":                "\u0060",
+	"DiacriticalTilde":                "\u02DC",
+	"Diamond":                         "\u22C4",
+	"DifferentialD":                   "\u2146",
+	"Dopf":                            "\U0001D53B",
+	"Dot":                             "\u00A8",
+	"DotDot":                          "\u20DC",
+	"DotEqual":                        "\u2250",
+	"DoubleContourIntegral":           "\u222F",
+	"DoubleDot":                       "\u00A8",
+	"DoubleDownArrow":                 "\u21D3",
+	"DoubleLeftArrow":                 "\u21D0",
+	"DoubleLeftRightArrow":            "\u21D4",
+	"DoubleLeftTee":                   "\u2AE4",
+	"DoubleLongLeftArrow":             "\u27F8",
+	"DoubleLongLeftRightArrow":        "\u27FA",
+	"DoubleLongRightArrow":            "\u27F9",
+	"DoubleRightArrow":                "\u21D2",
+	"DoubleRightTee":                  "\u22A8",
+	"DoubleUpArrow":                   "\u21D1",
+	"DoubleUpDownArrow":               "\u21D5",
+	"DoubleVerticalBar":               "\u2225",
+	"DownArrow":                       "\u2193",
+	"DownArrowBar":                    "\u2913",
+	"DownArrowUpArrow":                "\u21F5",
+	"DownBreve":                       "\u0311",
+	"DownLeftRightVector":             "\u2950",
+	"DownLeftTeeVector":               "\u295E",
+	"DownLeftVector":                  "\u21BD",
+	"DownLeftVectorBar":               "\u2956",
+	"DownRightTeeVector":              "\u295F",
+	"DownRightVector":                 "\u21C1",
+	"DownRightVectorBar":              "\u2957",
+	"DownTee":                         "\u22A4",
+	"DownTeeArrow":                    "\u21A7",
+	"Downarrow":                       "\u21D3",
+	"Dscr":                            "\U0001D49F",
+	"Dstrok":                          "\u0110",
+	"ENG":                             "\u014A",
+	"ETH":                             "\u00D0",
+	"Eacute":                          "\u00C9",
+	"Ecaron":                          "\u011A",
+	"Ecirc":                           "\u00CA",
+	"Ecy":                             "\u042D",
+	"Edot":                            "\u0116",
+	"Efr":                             "\U0001D508",
+	"Egrave":                          "\u00C8",
+	"Element":                         "\u2208",
+	"Emacr":                           "\u0112",
+	"EmptySmallSquare":                "\u25FB",
+	"EmptyVerySmallSquare":            "\u25AB",
+	"Eogon":                           "\u0118",
+	"Eopf":                            "\U0001D53C",
+	"Epsilon":                         "\u0395",
+	"Equal":                           "\u2A75",
+	"EqualTilde":                      "\u2242",
+	"Equilibrium":                     "\u21CC",
+	"Escr":                            "\u2130",
+	"Esim":                            "\u2A73",
+	"Eta":                             "\u0397",
+	"Euml":                            "\u00CB",
+	"Exists":                          "\u2203",
+	"ExponentialE":                    "\u2147",
+	"Fcy":                             "\u0424",
+	"Ffr":                             "\U0001D509",
+	"FilledSmallSquare":               "\u25FC",
+	"FilledVerySmallSquare":           "\u25AA",
+	"Fopf":                            "\U0001D53D",
+	"ForAll":                          "\u2200",
+	"Fouriertrf":                      "\u2131",
+	"Fscr":                            "\u2131",
+	"GJcy":                            "\u0403",
+	"GT":                              "\u003E",
+	"Gamma":                           "\u0393",
+	"Gammad":                          "\u03DC",
+	"Gbreve":                          "\u011E",
+	"Gcedil":                          "\u0122",
+	"Gcirc":                           "\u011C",
+	"Gcy":                             "\u0413",
+	"Gdot":                            "\u0120",
+	"Gfr":                             "\U0001D50A",
+	"Gg":                              "\u22D9",
+	"Gopf":                            "\U0001D53E",
+	"GreaterEqual":                    "\u2265",
+	"GreaterEqualLess":                "\u22DB",
+	"GreaterFullEqual":                "\u2267",
+	"GreaterGreater":                  "\u2AA2",
+	"GreaterLess":                     "\u2277",
+	"GreaterSlantEqual":               "\u2A7E",
+	"GreaterTilde":                    "\u2273",
+	"Gscr":                            "\U0001D4A2",
+	"Gt":                              "\u226B",
+	"HARDcy":                          "\u042A",
+	"Hacek":                           "\u02C7",
+	"Hat":                             "\u005E",
+	"Hcirc":                           "\u0124",
+	"Hfr":                             "\u210C",
+	"HilbertSpace":                    "\u210B",
+	"Hopf":                            "\u210D",
+	"HorizontalLine":                  "\u2500",
+	"Hscr":                            "\u210B",
+	"Hstrok":                          "\u0126",
+	"HumpDownHump":                    "\u224E",
+	"HumpEqual":                       "\u224F",
+	"IEcy":                            "\u0415",
+	"IJlig":                           "\u0132",
+	"IOcy":                            "\u0401",
+	"Iacute":                          "\u00CD",
+	"Icirc":                           "\u00CE",
+	"Icy":                             "\u0418",
+	"Idot":                            "\u0130",
+	"Ifr":                             "\u2111",
+	"Igrave":                          "\u00CC",
+	"Im":                              "\u2111",
+	"Imacr":                           "\u012A",
+	"ImaginaryI":                      "\u2148",
+	"Implies":                         "\u21D2",
+	"Int":                             "\u222C",
+	"Integral":                        "\u222B",
+	"Intersection":                    "\u22C2",
+	"InvisibleComma":                  "\u2063",
+	"InvisibleTimes":                  "\u2062",
+	"Iogon":                           "\u012E",
+	"Iopf":                            "\U0001D540",
+	"Iota":                            "\u0399",
+	"Iscr":                            "\u2110",
+	"Itilde":                          "\u0128",
+	"Iukcy":                           "\u0406",
+	"Iuml":                            "\u00CF",
+	"Jcirc":                           "\u0134",
+	"Jcy":                             "\u0419",
+	"Jfr":                             "\U0001D50D",
+	"Jopf":                            "\U0001D541",
+	"Jscr":                            "\U0001D4A5",
+	"Jsercy":                          "\u0408",
+	"Jukcy":                           "\u0404",
+	"KHcy":                            "\u0425",
+	"KJcy":                            "\u040C",
+	"Kappa":                           "\u039A",
+	"Kcedil":                          "\u0136",
+	"Kcy":                             "\u041A",
+	"Kfr":                             "\U0001D50E",
+	"Kopf":                            "\U0001D542",
+	"Kscr":                            "\U0001D4A6",
+	"LJcy":                            "\u0409",
+	"LT":                              "\u003C",
+	"Lacute":                          "\u0139",
+	"Lambda":                          "\u039B",
+	"Lang":                            "\u27EA",
+	"Laplacetrf":                      "\u2112",
+	"Larr":                            "\u219E",
+	"Lcaron":                          "\u013D",
+	"Lcedil":                          "\u013B",
+	"Lcy":                             "\u041B",
+	"LeftAngleBracket":                "\u27E8",
+	"LeftArrow":                       "\u2190",
+	"LeftArrowBar":                    "\u21E4",
+	"LeftArrowRightArrow":             "\u21C6",
+	"LeftCeiling":                     "\u2308",
+	"LeftDoubleBracket":               "\u27E6",
+	"LeftDownTeeVector":               "\u2961",
+	"LeftDownVector":                  "\u21C3",
+	"LeftDownVectorBar":               "\u2959",
+	"LeftFloor":                       "\u230A",
+	"LeftRightArrow":                  "\u2194",
+	"LeftRightVector":                 "\u294E",
+	"LeftTee":                         "\u22A3",
+	"LeftTeeArrow":                    "\u21A4",
+	"LeftTeeVector":                   "\u295A",
+	"LeftTriangle":                    "\u22B2",
+	"LeftTriangleBar":                 "\u29CF",
+	"LeftTriangleEqual":               "\u22B4",
+	"LeftUpDownVector":                "\u2951",
+	"LeftUpTeeVector":                 "\u2960",
+	"LeftUpVector":                    "\u21BF",
+	"LeftUpVectorBar":                 "\u2958",
+	"LeftVector":                      "\u21BC",
+	"LeftVectorBar":                   "\u2952",
+	"Leftarrow":                       "\u21D0",
+	"Leftrightarrow":                  "\u21D4",
+	"LessEqualGreater":                "\u22DA",
+	"LessFullEqual":                   "\u2266",
+	"LessGreater":                     "\u2276",
+	"LessLess":                        "\u2AA1",
+	"LessSlantEqual":                  "\u2A7D",
+	"LessTilde":                       "\u2272",
+	"Lfr":                             "\U0001D50F",
+	"Ll":                              "\u22D8",
+	"Lleftarrow":                      "\u21DA",
+	"Lmidot":                          "\u013F",
+	"LongLeftArrow":                   "\u27F5",
+	"LongLeftRightArrow":              "\u27F7",
+	"LongRightArrow":                  "\u27F6",
+	"Longleftarrow":                   "\u27F8",
+	"Longleftrightarrow":              "\u27FA",
+	"Longrightarrow":                  "\u27F9",
+	"Lopf":                            "\U0001D543",
+	"LowerLeftArrow":                  "\u2199",
+	"LowerRightArrow":                 "\u2198",
+	"Lscr":                            "\u2112",
+	"Lsh":                             "\u21B0",
+	"Lstrok":                          "\u0141",
+	"Lt":                              "\u226A",
+	"Map":                             "\u2905",
+	"Mcy":                             "\u041C",
+	"MediumSpace":                     "\u205F",
+	"Mellintrf":                       "\u2133",
+	"Mfr":                             "\U0001D510",
+	"MinusPlus":                       "\u2213",
+	"Mopf":                            "\U0001D544",
+	"Mscr":                            "\u2133",
+	"Mu":                              "\u039C",
+	"NJcy":                            "\u040A",
+	"Nacute":                          "\u0143",
+	"Ncaron":                          "\u0147",
+	"Ncedil":                          "\u0145",
+	"Ncy":                             "\u041D",
+	"NegativeMediumSpace":             "\u200B",
+	"NegativeThickSpace":              "\u200B",
+	"NegativeThinSpace":               "\u200B",
+	"NegativeVeryThinSpace":           "\u200B",
+	"NestedGreaterGreater":            "\u226B",
+	"NestedLessLess":                  "\u226A",
+	"NewLine":                         "\u000A",
+	"Nfr":                             "\U0001D511",
+	"NoBreak":                         "\u2060",
+	"NonBreakingSpace":                "\u00A0",
+	"Nopf":                            "\u2115",
+	"Not":                             "\u2AEC",
+	"NotCongruent":                    "\u2262",
+	"NotCupCap":                       "\u226D",
+	"NotDoubleVerticalBar":            "\u2226",
+	"NotElement":                      "\u2209",
+	"NotEqual":                        "\u2260",
+	"NotEqualTilde":                   "\u2242\u0338",
+	"NotExists":                       "\u2204",
+	"NotGreater":                      "\u226F",
+	"NotGreaterEqual":                 "\u2271",
+	"NotGreaterFullEqual":             "\u2267\u0338",
+	"NotGreaterGreater":               "\u226B\u0338",
+	"NotGreaterLess":                  "\u2279",
+	"NotGreaterSlantEqual":            "\u2A7E\u0338",
+	"NotGreaterTilde":                 "\u2275",
+	"NotHumpDownHump":                 "\u224E\u0338",
+	"NotHumpEqual":                    "\u224F\u0338",
+	"NotLeftTriangle":                 "\u22EA",
+	"NotLeftTriangleBar":              "\u29CF\u0338",
+	"NotLeftTriangleEqual":            "\u22EC",
+	"NotLess":                         "\u226E",
+	"NotLessEqual":                    "\u2270",
+	"NotLessGreater":                  "\u2278",
+	"NotLessLess":                     "\u226A\u0338",
+	"NotLessSlantEqual":               "\u2A7D\u0338",
+	"NotLessTilde":                    "\u2274",
+	"NotNestedGreaterGreater":         "\u2AA2\u0338",
+	"NotNestedLessLess":               "\u2AA1\u0338",
+	"NotPrecedes":                     "\u2280",
+	"NotPrecedesEqual":                "\u2AAF\u0338",
+	"NotPrecedesSlantEqual":           "\u22E0",
+	"NotReverseElement":               "\u220C",
+	"NotRightTriangle":                "\u22EB",
+	"NotRightTriangleBar":             "\u29D0\u0338",
+	"NotRightTriangleEqual":           "\u22ED",
+	"NotSquareSubset":                 "\u228F\u0338",
+	"NotSquareSubsetEqual":            "\u22E2",
+	"NotSquareSuperset":               "\u2290\u0338",
+	"NotSquareSupersetEqual":          "\u22E3",
+	"NotSubset":                       "\u2282\u20D2",
+	"NotSubsetEqual":                  "\u2288",
+	"NotSucceeds":                     "\u2281",
+	"NotSucceedsEqual":                "\u2AB0\u0338",
+	"NotSucceedsSlantEqual":           "\u22E1",
+	"NotSucceedsTilde":                "\u227F\u0338",
+	"NotSuperset":                     "\u2283\u20D2",
+	"NotSupersetEqual":                "\u2289",
+	"NotTilde":                        "\u2241",
+	"NotTildeEqual":                   "\u2244",
+	"NotTildeFullEqual":               "\u2247",
+	"NotTildeTilde":                   "\u2249",
+	"NotVerticalBar":                  "\u2224",
+	"Nscr":                            "\U0001D4A9",
+	"Ntilde":                          "\u00D1",
+	"Nu":                              "\u039D",
+	"OElig":                           "\u0152",
+	"Oacute":                          "\u00D3",
+	"Ocirc":                           "\u00D4",
+	"Ocy":                             "\u041E",
+	"Odblac":                          "\u0150",
+	"Ofr":                             "\U0001D512",
+	"Ograve":                          "\u00D2",
+	"Omacr":                           "\u014C",
+	"Omega":                           "\u03A9",
+	"Omicron":                         "\u039F",
+	"Oopf":                            "\U0001D546",
+	"OpenCurlyDoubleQuote":            "\u201C",
+	"OpenCurlyQuote":                  "\u2018",
+	"Or":                              "\u2A54",
+	"Oscr":                            "\U0001D4AA",
+	"Oslash":                          "\u00D8",
+	"Otilde":                          "\u00D5",
+	"Otimes":                          "\u2A37",
+	"Ouml":                            "\u00D6",
+	"OverBar":                         "\u203E",
+	"OverBrace":                       "\u23DE",
+	"OverBracket":                     "\u23B4",
+	"OverParenthesis":                 "\u23DC",
+	"PartialD":                        "\u2202",
+	"Pcy":                             "\u041F",
+	"Pfr":                             "\U0001D513",
+	"Phi":                             "\u03A6",
+	"Pi":                              "\u03A0",
+	"PlusMinus":                       "\u00B1",
+	"Poincareplane":                   "\u210C",
+	"Popf":                            "\u2119",
+	"Pr":                              "\u2ABB",
+	"Precedes":                        "\u227A",
+	"PrecedesEqual":                   "\u2AAF",
+	"PrecedesSlantEqual":              "\u227C",
+	"PrecedesTilde":                   "\u227E",
+	"Prime":                           "\u2033",
+	"Product":                         "\u220F",
+	"Proportion":                      "\u2237",
+	"Proportional":                    "\u221D",
+	"Pscr":                            "\U0001D4AB",
+	"Psi":                             "\u03A8",
+	"QUOT":                            "\u0022",
+	"Qfr":                             "\U0001D514",
+	"Qopf":                            "\u211A",
+	"Qscr":                            "\U0001D4AC",
+	"RBarr":                           "\u2910",
+	"REG":                             "\u00AE",
+	"Racute":                          "\u0154",
+	"Rang":                            "\u27EB",
+	"Rarr":                            "\u21A0",
+	"Rarrtl":                          "\u2916",
+	"Rcaron":                          "\u0158",
+	"Rcedil":                          "\u0156",
+	"Rcy":                             "\u0420",
+	"Re":                              "\u211C",
+	"ReverseElement":                  "\u220B",
+	"ReverseEquilibrium":              "\u21CB",
+	"ReverseUpEquilibrium":            "\u296F",
+	"Rfr":                             "\u211C",
+	"Rho":                             "\u03A1",
+	"RightAngleBracket":               "\u27E9",
+	"RightArrow":                      "\u2192",
+	"RightArrowBar":                   "\u21E5",
+	"RightArrowLeftArrow":             "\u21C4",
+	"RightCeiling":                    "\u2309",
+	"RightDoubleBracket":              "\u27E7",
+	"RightDownTeeVector":              "\u295D",
+	"RightDownVector":                 "\u21C2",
+	"RightDownVectorBar":              "\u2955",
+	"RightFloor":                      "\u230B",
+	"RightTee":                        "\u22A2",
+	"RightTeeArrow":                   "\u21A6",
+	"RightTeeVector":                  "\u295B",
+	"RightTriangle":                   "\u22B3",
+	"RightTriangleBar":                "\u29D0",
+	"RightTriangleEqual":              "\u22B5",
+	"RightUpDownVector":               "\u294F",
+	"RightUpTeeVector":                "\u295C",
+	"RightUpVector":                   "\u21BE",
+	"RightUpVectorBar":                "\u2954",
+	"RightVector":                     "\u21C0",
+	"RightVectorBar":                  "\u2953",
+	"Rightarrow":                      "\u21D2",
+	"Ropf":                            "\u211D",
+	"RoundImplies":                    "\u2970",
+	"Rrightarrow":                     "\u21DB",
+	"Rscr":                            "\u211B",
+	"Rsh":                             "\u21B1",
+	"RuleDelayed":                     "\u29F4",
+	"SHCHcy":                          "\u0429",
+	"SHcy":                            "\u0428",
+	"SOFTcy":                          "\u042C",
+	"Sacute":                          "\u015A",
+	"Sc":                              "\u2ABC",
+	"Scaron":                          "\u0160",
+	"Scedil":                          "\u015E",
+	"Scirc":                           "\u015C",
+	"Scy":                             "\u0421",
+	"Sfr":                             "\U0001D516",
+	"ShortDownArrow":                  "\u2193",
+	"ShortLeftArrow":                  "\u2190",
+	"ShortRightArrow":                 "\u2192",
+	"ShortUpArrow":                    "\u2191",
+	"Sigma":                           "\u03A3",
+	"SmallCircle":                     "\u2218",
+	"Sopf":                            "\U0001D54A",
+	"Sqrt":                            "\u221A",
+	"Square":                          "\u25A1",
+	"SquareIntersection":              "\u2293",
+	"SquareSubset":                    "\u228F",
+	"SquareSubsetEqual":               "\u2291",
+	"SquareSuperset":                  "\u2290",
+	"SquareSupersetEqual":             "\u2292",
+	"SquareUnion":                     "\u2294",
+	"Sscr":                            "\U0001D4AE",
+	"Star":                            "\u22C6",
+	"Sub":                             "\u22D0",
+	"Subset":                          "\u22D0",
+	"SubsetEqual":                     "\u2286",
+	"Succeeds":                        "\u227B",
+	"SucceedsEqual":                   "\u2AB0",
+	"SucceedsSlantEqual":              "\u227D",
+	"SucceedsTilde":                   "\u227F",
+	"SuchThat":                        "\u220B",
+	"Sum":                             "\u2211",
+	"Sup":                             "\u22D1",
+	"Superset":                        "\u2283",
+	"SupersetEqual":                   "\u2287",
+	"Supset":                          "\u22D1",
+	"THORN":                           "\u00DE",
+	"TRADE":                           "\u2122",
+	"TSHcy":                           "\u040B",
+	"TScy":                            "\u0426",
+	"Tab":                             "\u0009",
+	"Tau":                             "\u03A4",
+	"Tcaron":                          "\u0164",
+	"Tcedil":                          "\u0162",
+	"Tcy":                             "\u0422",
+	"Tfr":                             "\U0001D517",
+	"Therefore":                       "\u2234",
+	"Theta":                           "\u0398",
+	"ThickSpace":                      "\u205F\u200A",
+	"ThinSpace":                       "\u2009",
+	"Tilde":                           "\u223C",
+	"TildeEqual":                      "\u2243",
+	"TildeFullEqual":                  "\u2245",
+	"TildeTilde":                      "\u2248",
+	"Topf":                            "\U0001D54B",
+	"TripleDot":                       "\u20DB",
+	"Tscr":                            "\U0001D4AF",
+	"Tstrok":                          "\u0166",
+	"Uacute":                          "\u00DA",
+	"Uarr":                            "\u219F",
+	"Uarrocir":                        "\u2949",
+	"Ubrcy":                           "\u040E",
+	"Ubreve":                          "\u016C",
+	"Ucirc":                           "\u00DB",
+	"Ucy":                             "\u0423",
+	"Udblac":                          "\u0170",
+	"Ufr":                             "\U0001D518",
+	"Ugrave":                          "\u00D9",
+	"Umacr":                           "\u016A",
+	"UnderBar":                        "\u005F",
+	"UnderBrace":                      "\u23DF",
+	"UnderBracket":                    "\u23B5",
+	"UnderParenthesis":                "\u23DD",
+	"Union":                           "\u22C3",
+	"UnionPlus":                       "\u228E",
+	"Uogon":                           "\u0172",
+	"Uopf":                            "\U0001D54C",
+	"UpArrow":                         "\u2191",
+	"UpArrowBar":                      "\u2912",
+	"UpArrowDownArrow":                "\u21C5",
+	"UpDownArrow":                     "\u2195",
+	"UpEquilibrium":                   "\u296E",
+	"UpTee":                           "\u22A5",
+	"UpTeeArrow":                      "\u21A5",
+	"Uparrow":                         "\u21D1",
+	"Updownarrow":                     "\u21D5",
+	"UpperLeftArrow":                  "\u2196",
+	"UpperRightArrow":                 "\u2197",
+	"Upsi":                            "\u03D2",
+	"Upsilon":                         "\u03A5",
+	"Uring":                           "\u016E",
+	"Uscr":                            "\U0001D4B0",
+	"Utilde":                          "\u0168",
+	"Uuml":                            "\u00DC",
+	"VDash":                           "\u22AB",
+	"Vbar":                            "\u2AEB",
+	"Vcy":                             "\u0412",
+	"Vdash":                           "\u22A9",
+	"Vdashl":                          "\u2AE6",
+	"Vee":                             "\u22C1",
+	"Verbar":                          "\u2016",
+	"Vert":                            "\u2016",
+	"VerticalBar":                     "\u2223",
+	"VerticalLine":                    "\u007C",
+	"VerticalSeparator":               "\u2758",
+	"VerticalTilde":                   "\u2240",
+	"VeryThinSpace":                   "\u200A",
+	"Vfr":                             "\U0001D519",
+	"Vopf":                            "\U0001D54D",
+	"Vscr":                            "\U0001D4B1",
+	"Vvdash":                          "\u22AA",
+	"Wcirc":                           "\u0174",
+	"Wedge":                           "\u22C0",
+	"Wfr":                             "\U0001D51A",
+	"Wopf":                            "\U0001D54E",
+	"Wscr":                            "\U0001D4B2",
+	"Xfr":                             "\U0001D51B",
+	"Xi":                              "\u039E",
+	"Xopf":                            "\U0001D54F",
+	"Xscr":                            "\U0001D4B3",
+	"YAcy":                            "\u042F",
+	"YIcy":                            "\u0407",
+	"YUcy":                            "\u042E",
+	"Yacute":                          "\u00DD",
+	"Ycirc":                           "\u0176",
+	"Ycy":                             "\u042B",
+	"Yfr":                             "\U0001D51C",
+	"Yopf":                            "\U0001D550",
+	"Yscr":                            "\U0001D4B4",
+	"Yuml":                            "\u0178",
+	"ZHcy":                            "\u0416",
+	"Zacute":                          "\u0179",
+	"Zcaron":                          "\u017D",
+	"Zcy":                             "\u0417",
+	"Zdot":                            "\u017B",
+	"ZeroWidthSpace":                  "\u200B",
+	"Zeta":                            "\u0396",
+	"Zfr":                             "\u2128",
+	"Zopf":                            "\u2124",
+	"Zscr":                            "\U0001D4B5",
+	"aacute":                          "\u00E1",
+	"abreve":                          "\u0103",
+	"ac":                              "\u223E",
+	"acE":                             "\u223E\u0333",
+	"acd":                             "\u223F",
+	"acirc":                           "\u00E2",
+	"acute":                           "\u00B4",
+	"acy":                             "\u0430",
+	"aelig":                           "\u00E6",
+	"af":                              "\u2061",
+	"afr":                             "\U0001D51E",
+	"agrave":                          "\u00E0",
+	"alefsym":                         "\u2135",
+	"aleph":                           "\u2135",
+	"alpha":                           "\u03B1",
+	"amacr":                           "\u0101",
+	"amalg":                           "\u2A3F",
+	"amp":                             "\u0026",
+	"and":                             "\u2227",
+	"andand":                          "\u2A55",
+	"andd":                            "\u2A5C",
+	"andslope":                        "\u2A58",
+	"andv":                            "\u2A5A",
+	"ang":                             "\u2220",
+	"ange":                            "\u29A4",
+	"angle":                           "\u2220",
+	"angmsd":                          "\u2221",
+	"angmsdaa":                        "\u29A8",
+	"angmsdab":                        "\u29A9",
+	"angmsdac":                        "\u29AA",
+	"angmsdad":                        "\u29AB",
+	"angmsdae":                        "\u29AC",
+	"angmsdaf":                        "\u29AD",
+	"angmsdag":                        "\u29AE",
+	"angmsdah":                        "\u29AF",
+	"angrt":                           "\u221F",
+	"angrtvb":                         "\u22BE",
+	"angrtvbd":                        "\u299D",
+	"angsph":                          "\u2222",
+	"angst":                           "\u00C5",
+	"angzarr":                         "\u237C",
+	"aogon":                           "\u0105",
+	"aopf":                            "\U0001D552",
+	"ap":                              "\u2248",
+	"apE":                             "\u2A70",
+	"apacir":                          "\u2A6F",
+	"ape":                             "\u224A",
+	"apid":                            "\u224B",
+	"apos":                            "\u0027",
+	"approx":                          "\u2248",
+	"approxeq":                        "\u224A",
+	"aring":                           "\u00E5",
+	"ascr":                            "\U0001D4B6",
+	"ast":                             "\u002A",
+	"asymp":                           "\u2248",
+	"asympeq":                         "\u224D",
+	"atilde":                          "\u00E3",
+	"auml":                            "\u00E4",
+	"awconint":                        "\u2233",
+	"awint":                           "\u2A11",
+	"bNot":                            "\u2AED",
+	"backcong":                        "\u224C",
+	"backepsilon":                     "\u03F6",
+	"backprime":                       "\u2035",
+	"backsim":                         "\u223D",
+	"backsimeq":                       "\u22CD",
+	"barvee":                          "\u22BD",
+	"barwed":                          "\u2305",
+	"barwedge":                        "\u2305",
+	"bbrk":                            "\u23B5",
+	"bbrktbrk":                        "\u23B6",
+	"bcong":                           "\u224C",
+	"bcy":                             "\u0431",
+	"bdquo":                           "\u201E",
+	"becaus":                          "\u2235",
+	"because":                         "\u2235",
+	"bemptyv":                         "\u29B0",
+	"bepsi":                           "\u03F6",
+	"bernou":                          "\u212C",
+	"beta":                            "\u03B2",
+	"beth":                            "\u2136",
+	"between":                         "\u226C",
+	"bfr":                             "\U0001D51F",
+	"bigcap":                          "\u22C2",
+	"bigcirc":                         "\u25EF",
+	"bigcup":                          "\u22C3",
+	"bigodot":                         "\u2A00",
+	"bigoplus":                        "\u2A01",
+	"bigotimes":                       "\u2A02",
+	"bigsqcup":                        "\u2A06",
+	"bigstar":                         "\u2605",
+	"bigtriangledown":                 "\u25BD",
+	"bigtriangleup":                   "\u25B3",
+	"biguplus":                        "\u2A04",
+	"bigvee":                          "\u22C1",
+	"bigwedge":                        "\u22C0",
+	"bkarow":                          "\u290D",
+	"blacklozenge":                    "\u29EB",
+	"blacksquare":                     "\u25AA",
+	"blacktriangle":                   "\u25B4",
+	"blacktriangledown":               "\u25BE",
+	"blacktriangleleft":               "\u25C2",
+	"blacktriangleright":              "\u25B8",
+	"blank":                           "\u2423",
+	"blk12":                           "\u2592",
+	"blk14":                           "\u2591",
+	"blk34":                           "\u2593",
+	"block":                           "\u2588",
+	"bne":                             "\u003D\u20E5",
+	"bnequiv":                         "\u2261\u20E5",
+	"bnot":                            "\u2310",
+	"bopf":                            "\U0001D553",
+	"bot":                             "\u22A5",
+	"bottom":                          "\u22A5",
+	"bowtie":                          "\u22C8",
+	"boxDL":                           "\u2557",
+	"boxDR":                           "\u2554",
+	"boxDl":                           "\u2556",
+	"boxDr":                           "\u2553",
+	"boxH":                            "\u2550",
+	"boxHD":                           "\u2566",
+	"boxHU":                           "\u2569",
+	"boxHd":                           "\u2564",
+	"boxHu":                           "\u2567",
+	"boxUL":                           "\u255D",
+	"boxUR":                           "\u255A",
+	"boxUl":                           "\u255C",
+	"boxUr":                           "\u2559",
+	"boxV":                            "\u2551",
+	"boxVH":                           "\u256C",
+	"boxVL":                           "\u2563",
+	"boxVR":                           "\u2560",
+	"boxVh":                           "\u256B",
+	"boxVl":                           "\u2562",
+	"boxVr":                           "\u255F",
+	"boxbox":                          "\u29C9",
+	"boxdL":                           "\u2555",
+	"boxdR":                           "\u2552",
+	"boxdl":                           "\u2510",
+	"boxdr":                           "\u250C",
+	"boxh":                            "\u2500",
+	"boxhD":                           "\u2565",
+	"boxhU":                           "\u2568",
+	"boxhd":                           "\u252C",
+	"boxhu":                           "\u2534",
+	"boxminus":                        "\u229F",
+	"boxplus":                         "\u229E",
+	"boxtimes":                        "\u22A0",
+	"boxuL":                           "\u255B",
+	"boxuR":                           "\u2558",
+	"boxul":                           "\u2518",
+	"boxur":                           "\u2514",
+	"boxv":                            "\u2502",
+	"boxvH":                           "\u256A",
+	"boxvL":                           "\u2561",
+	"boxvR":                           "\u255E",
+	"boxvh":                           "\u253C",
+	"boxvl":                           "\u2524",
+	"boxvr":                           "\u251C",
+	"bprime":                          "\u2035",
+	"breve":                           "\u02D8",
+	"brvbar":                          "\u00A6",
+	"bscr":                            "\U0001D4B7",
+	"bsemi":                           "\u204F",
+	"bsim":                            "\u223D",
+	"bsime":                           "\u22CD",
+	"bsol":                            "\u005C",
+	"bsolb":                           "\u29C5",
+	"bsolhsub":                        "\u27C8",
+	"bull":                            "\u2022",
+	"bullet":                          "\u2022",
+	"bump":                            "\u224E",
+	"bumpE":                           "\u2AAE",
+	"bumpe":                           "\u224F",
+	"bumpeq":                          "\u224F",
+	"cacute":                          "\u0107",
+	"cap":                             "\u2229",
+	"capand":                          "\u2A44",
+	"capbrcup":                        "\u2A49",
+	"capcap":                          "\u2A4B",
+	"capcup":                          "\u2A47",
+	"capdot":                          "\u2A40",
+	"caps":                            "\u2229\uFE00",
+	"caret":                           "\u2041",
+	"caron":                           "\u02C7",
+	"ccaps":                           "\u2A4D",
+	"ccaron":                          "\u010D",
+	"ccedil":                          "\u00E7",
+	"ccirc":                           "\u0109",
+	"ccups":                           "\u2A4C",
+	"ccupssm":                         "\u2A50",
+	"cdot":                            "\u010B",
+	"cedil":                           "\u00B8",
+	"cemptyv":                         "\u29B2",
+	"cent":                            "\u00A2",
+	"centerdot":                       "\u00B7",
+	"cfr":                             "\U0001D520",
+	"chcy":                            "\u0447",
+	"check":                           "\u2713",
+	"checkmark":                       "\u2713",
+	"chi":                             "\u03C7",
+	"cir":                             "\u25CB",
+	"cirE":                            "\u29C3",
+	"circ":                            "\u02C6",
+	"circeq":                          "\u2257",
+	"circlearrowleft":                 "\u21BA",
+	"circlearrowright":                "\u21BB",
+	"circledR":                        "\u00AE",
+	"circledS":                        "\u24C8",
+	"circledast":                      "\u229B",
+	"circledcirc":                     "\u229A",
+	"circleddash":                     "\u229D",
+	"cire":                            "\u2257",
+	"cirfnint":                        "\u2A10",
+	"cirmid":                          "\u2AEF",
+	"cirscir":                         "\u29C2",
+	"clubs":                           "\u2663",
+	"clubsuit":                        "\u2663",
+	"colon":                           "\u003A",
+	"colone":                          "\u2254",
+	"coloneq":                         "\u2254",
+	"comma":                           "\u002C",
+	"commat":                          "\u0040",
+	"comp":                            "\u2201",
+	"compfn":                          "\u2218",
+	"complement":                      "\u2201",
+	"complexes":                       "\u2102",
+	"cong":                            "\u2245",
+	"congdot":                         "\u2A6D",
+	"conint":                          "\u222E",
+	"copf":                            "\U0001D554",
+	"coprod":                          "\u2210",
+	"copy":                            "\u00A9",
+	"copysr":                          "\u2117",
+	"crarr":                           "\u21B5",
+	"cross":                           "\u2717",
+	"cscr":                            "\U0001D4B8",
+	"csub":                            "\u2ACF",
+	"csube":                           "\u2AD1",
+	"csup":                            "\u2AD0",
+	"csupe":                           "\u2AD2",
+	"ctdot":                           "\u22EF",
+	"cudarrl":                         "\u2938",
+	"cudarrr":                         "\u2935",
+	"cuepr":                           "\u22DE",
+	"cuesc":                           "\u22DF",
+	"cularr":                          "\u21B6",
+	"cularrp":                         "\u293D",
+	"cup":                             "\u222A",
+	"cupbrcap":                        "\u2A48",
+	"cupcap":                          "\u2A46",
+	"cupcup":                          "\u2A4A",
+	"cupdot":                          "\u228D",
+	"cupor":                           "\u2A45",
+	"cups":                            "\u222A\uFE00",
+	"curarr":                          "\u21B7",
+	"curarrm":                         "\u293C",
+	"curlyeqprec":                     "\u22DE",
+	"curlyeqsucc":                     "\u22DF",
+	"curlyvee":                        "\u22CE",
+	"curlywedge":                      "\u22CF",
+	"curren":                          "\u00A4",
+	"curvearrowleft":                  "\u21B6",
+	"curvearrowright":                 "\u21B7",
+	"cuvee":                           "\u22CE",
+	"cuwed":                           "\u22CF",
+	"cwconint":                        "\u2232",
+	"cwint":                           "\u2231",
+	"cylcty":                          "\u232D",
+	"dArr":                            "\u21D3",
+	"dHar":                            "\u2965",
+	"dagger":                          "\u2020",
+	"daleth":                          "\u2138",
+	"darr":                            "\u2193",
+	"dash":                            "\u2010",
+	"dashv":                           "\u22A3",
+	"dbkarow":                         "\u290F",
+	"dblac":                           "\u02DD",
+	"dcaron":                          "\u010F",
+	"dcy":                             "\u0434",
+	"dd":                              "\u2146",
+	"ddagger":                         "\u2021",
+	"ddarr":                           "\u21CA",
+	"ddotseq":                         "\u2A77",
+	"deg":                             "\u00B0",
+	"delta":                           "\u03B4",
+	"demptyv":                         "\u29B1",
+	"dfisht":                          "\u297F",
+	"dfr":                             "\U0001D521",
+	"dharl":                           "\u21C3",
+	"dharr":                           "\u21C2",
+	"diam":                            "\u22C4",
+	"diamond":                         "\u22C4",
+	"diamondsuit":                     "\u2666",
+	"diams":                           "\u2666",
+	"die":                             "\u00A8",
+	"digamma":                         "\u03DD",
+	"disin":                           "\u22F2",
+	"div":                             "\u00F7",
+	"divide":                          "\u00F7",
+	"divideontimes":                   "\u22C7",
+	"divonx":                          "\u22C7",
+	"djcy":                            "\u0452",
+	"dlcorn":                          "\u231E",
+	"dlcrop":                          "\u230D",
+	"dollar":                          "\u0024",
+	"dopf":                            "\U0001D555",
+	"dot":                             "\u02D9",
+	"doteq":                           "\u2250",
+	"doteqdot":                        "\u2251",
+	"dotminus":                        "\u2238",
+	"dotplus":                         "\u2214",
+	"dotsquare":                       "\u22A1",
+	"doublebarwedge":                  "\u2306",
+	"downarrow":                       "\u2193",
+	"downdownarrows":                  "\u21CA",
+	"downharpoonleft":                 "\u21C3",
+	"downharpoonright":                "\u21C2",
+	"drbkarow":                        "\u2910",
+	"drcorn":                          "\u231F",
+	"drcrop":                          "\u230C",
+	"dscr":                            "\U0001D4B9",
+	"dscy":                            "\u0455",
+	"dsol":                            "\u29F6",
+	"dstrok":                          "\u0111",
+	"dtdot":                           "\u22F1",
+	"dtri":                            "\u25BF",
+	"dtrif":                           "\u25BE",
+	"duarr":                           "\u21F5",
+	"duhar":                           "\u296F",
+	"dwangle":                         "\u29A6",
+	"dzcy":                            "\u045F",
+	"dzigrarr":                        "\u27FF",
+	"eDDot":                           "\u2A77",
+	"eDot":                            "\u2251",
+	"eacute":                          "\u00E9",
+	"easter":                          "\u2A6E",
+	"ecaron":                          "\u011B",
+	"ecir":                            "\u2256",
+	"ecirc":                           "\u00EA",
+	"ecolon":                          "\u2255",
+	"ecy":                             "\u044D",
+	"edot":                            "\u0117",
+	"ee":                              "\u2147",
+	"efDot":                           "\u2252",
+	"efr":                             "\U0001D522",
+	"eg":                              "\u2A9A",
+	"egrave":                          "\u00E8",
+	"egs":                             "\u2A96",
+	"egsdot":                          "\u2A98",
+	"el":                              "\u2A99",
+	"elinters":                        "\u23E7",
+	"ell":                             "\u2113",
+	"els":                             "\u2A95",
+	"elsdot":                          "\u2A97",
+	"emacr":                           "\u0113",
+	"empty":                           "\u2205",
+	"emptyset":                        "\u2205",
+	"emptyv":                          "\u2205",
+	"emsp":                            "\u2003",
+	"emsp13":                          "\u2004",
+	"emsp14":                          "\u2005",
+	"eng":                             "\u014B",
+	"ensp":                            "\u2002",
+	"eogon":                           "\u0119",
+	"eopf":                            "\U0001D556",
+	"epar":                            "\u22D5",
+	"eparsl":                          "\u29E3",
+	"eplus":                           "\u2A71",
+	"epsi":                            "\u03B5",
+	"epsilon":                         "\u03B5",
+	"epsiv":                           "\u03F5",
+	"eqcirc":                          "\u2256",
+	"eqcolon":                         "\u2255",
+	"eqsim":                           "\u2242",
+	"eqslantgtr":                      "\u2A96",
+	"eqslantless":                     "\u2A95",
+	"equals":                          "\u003D",
+	"equest":                          "\u225F",
+	"equiv":                           "\u2261",
+	"equivDD":                         "\u2A78",
+	"eqvparsl":                        "\u29E5",
+	"erDot":                           "\u2253",
+	"erarr":                           "\u2971",
+	"escr":                            "\u212F",
+	"esdot":                           "\u2250",
+	"esim":                            "\u2242",
+	"eta":                             "\u03B7",
+	"eth":                             "\u00F0",
+	"euml":                            "\u00EB",
+	"euro":                            "\u20AC",
+	"excl":                            "\u0021",
+	"exist":                           "\u2203",
+	"expectation":                     "\u2130",
+	"exponentiale":                    "\u2147",
+	"fallingdotseq":                   "\u2252",
+	"fcy":                             "\u0444",
+	"female":                          "\u2640",
+	"ffilig":                          "\uFB03",
+	"fflig":                           "\uFB00",
+	"ffllig":                          "\uFB04",
+	"ffr":                             "\U0001D523",
+	"filig":                           "\uFB01",
+	"fjlig":                           "\u0066\u006A fj",
+	"flat":                            "\u266D",
+	"fllig":                           "\uFB02",
+	"fltns":                           "\u25B1",
+	"fnof":                            "\u0192",
+	"fopf":                            "\U0001D557",
+	"forall":                          "\u2200",
+	"fork":                            "\u22D4",
+	"forkv":                           "\u2AD9",
+	"fpartint":                        "\u2A0D",
+	"frac12":                          "\u00BD",
+	"frac13":                          "\u2153",
+	"frac14":                          "\u00BC",
+	"frac15":                          "\u2155",
+	"frac16":                          "\u2159",
+	"frac18":                          "\u215B",
+	"frac23":                          "\u2154",
+	"frac25":                          "\u2156",
+	"frac34":                          "\u00BE",
+	"frac35":                          "\u2157",
+	"frac38":                          "\u215C",
+	"frac45":                          "\u2158",
+	"frac56":                          "\u215A",
+	"frac58":                          "\u215D",
+	"frac78":                          "\u215E",
+	"frasl":                           "\u2044",
+	"frown":                           "\u2322",
+	"fscr":                            "\U0001D4BB",
+	"gE":                              "\u2267",
+	"gEl":                             "\u2A8C",
+	"gacute":                          "\u01F5",
+	"gamma":                           "\u03B3",
+	"gammad":                          "\u03DD",
+	"gap":                             "\u2A86",
+	"gbreve":                          "\u011F",
+	"gcirc":                           "\u011D",
+	"gcy":                             "\u0433",
+	"gdot":                            "\u0121",
+	"ge":                              "\u2265",
+	"gel":                             "\u22DB",
+	"geq":                             "\u2265",
+	"geqq":                            "\u2267",
+	"geqslant":                        "\u2A7E",
+	"ges":                             "\u2A7E",
+	"gescc":                           "\u2AA9",
+	"gesdot":                          "\u2A80",
+	"gesdoto":                         "\u2A82",
+	"gesdotol":                        "\u2A84",
+	"gesl":                            "\u22DB\uFE00",
+	"gesles":                          "\u2A94",
+	"gfr":                             "\U0001D524",
+	"gg":                              "\u226B",
+	"ggg":                             "\u22D9",
+	"gimel":                           "\u2137",
+	"gjcy":                            "\u0453",
+	"gl":                              "\u2277",
+	"glE":                             "\u2A92",
+	"gla":                             "\u2AA5",
+	"glj":                             "\u2AA4",
+	"gnE":                             "\u2269",
+	"gnap":                            "\u2A8A",
+	"gnapprox":                        "\u2A8A",
+	"gne":                             "\u2A88",
+	"gneq":                            "\u2A88",
+	"gneqq":                           "\u2269",
+	"gnsim":                           "\u22E7",
+	"gopf":                            "\U0001D558",
+	"grave":                           "\u0060",
+	"gscr":                            "\u210A",
+	"gsim":                            "\u2273",
+	"gsime":                           "\u2A8E",
+	"gsiml":                           "\u2A90",
+	"gt":                              "\u003E",
+	"gtcc":                            "\u2AA7",
+	"gtcir":                           "\u2A7A",
+	"gtdot":                           "\u22D7",
+	"gtlPar":                          "\u2995",
+	"gtquest":                         "\u2A7C",
+	"gtrapprox":                       "\u2A86",
+	"gtrarr":                          "\u2978",
+	"gtrdot":                          "\u22D7",
+	"gtreqless":                       "\u22DB",
+	"gtreqqless":                      "\u2A8C",
+	"gtrless":                         "\u2277",
+	"gtrsim":                          "\u2273",
+	"gvertneqq":                       "\u2269\uFE00",
+	"gvnE":                            "\u2269\uFE00",
+	"hArr":                            "\u21D4",
+	"hairsp":                          "\u200A",
+	"half":                            "\u00BD",
+	"hamilt":                          "\u210B",
+	"hardcy":                          "\u044A",
+	"harr":                            "\u2194",
+	"harrcir":                         "\u2948",
+	"harrw":                           "\u21AD",
+	"hbar":                            "\u210F",
+	"hcirc":                           "\u0125",
+	"hearts":                          "\u2665",
+	"heartsuit":                       "\u2665",
+	"hellip":                          "\u2026",
+	"hercon":                          "\u22B9",
+	"hfr":                             "\U0001D525",
+	"hksearow":                        "\u2925",
+	"hkswarow":                        "\u2926",
+	"hoarr":                           "\u21FF",
+	"homtht":                          "\u223B",
+	"hookleftarrow":                   "\u21A9",
+	"hookrightarrow":                  "\u21AA",
+	"hopf":                            "\U0001D559",
+	"horbar":                          "\u2015",
+	"hscr":                            "\U0001D4BD",
+	"hslash":                          "\u210F",
+	"hstrok":                          "\u0127",
+	"hybull":                          "\u2043",
+	"hyphen":                          "\u2010",
+	"iacute":                          "\u00ED",
+	"ic":                              "\u2063",
+	"icirc":                           "\u00EE",
+	"icy":                             "\u0438",
+	"iecy":                            "\u0435",
+	"iexcl":                           "\u00A1",
+	"iff":                             "\u21D4",
+	"ifr":                             "\U0001D526",
+	"igrave":                          "\u00EC",
+	"ii":                              "\u2148",
+	"iiiint":                          "\u2A0C",
+	"iiint":                           "\u222D",
+	"iinfin":                          "\u29DC",
+	"iiota":                           "\u2129",
+	"ijlig":                           "\u0133",
+	"imacr":                           "\u012B",
+	"image":                           "\u2111",
+	"imagline":                        "\u2110",
+	"imagpart":                        "\u2111",
+	"imath":                           "\u0131",
+	"imof":                            "\u22B7",
+	"imped":                           "\u01B5",
+	"in":                              "\u2208",
+	"incare":                          "\u2105",
+	"infin":                           "\u221E",
+	"infintie":                        "\u29DD",
+	"inodot":                          "\u0131",
+	"int":                             "\u222B",
+	"intcal":                          "\u22BA",
+	"integers":                        "\u2124",
+	"intercal":                        "\u22BA",
+	"intlarhk":                        "\u2A17",
+	"intprod":                         "\u2A3C",
+	"iocy":                            "\u0451",
+	"iogon":                           "\u012F",
+	"iopf":                            "\U0001D55A",
+	"iota":                            "\u03B9",
+	"iprod":                           "\u2A3C",
+	"iquest":                          "\u00BF",
+	"iscr":                            "\U0001D4BE",
+	"isin":                            "\u2208",
+	"isinE":                           "\u22F9",
+	"isindot":                         "\u22F5",
+	"isins":                           "\u22F4",
+	"isinsv":                          "\u22F3",
+	"isinv":                           "\u2208",
+	"it":                              "\u2062",
+	"itilde":                          "\u0129",
+	"iukcy":                           "\u0456",
+	"iuml":                            "\u00EF",
+	"jcirc":                           "\u0135",
+	"jcy":                             "\u0439",
+	"jfr":                             "\U0001D527",
+	"jmath":                           "\u0237",
+	"jopf":                            "\U0001D55B",
+	"jscr":                            "\U0001D4BF",
+	"jsercy":                          "\u0458",
+	"jukcy":                           "\u0454",
+	"kappa":                           "\u03BA",
+	"kappav":                          "\u03F0",
+	"kcedil":                          "\u0137",
+	"kcy":                             "\u043A",
+	"kfr":                             "\U0001D528",
+	"kgreen":                          "\u0138",
+	"khcy":                            "\u0445",
+	"kjcy":                            "\u045C",
+	"kopf":                            "\U0001D55C",
+	"kscr":                            "\U0001D4C0",
+	"lAarr":                           "\u21DA",
+	"lArr":                            "\u21D0",
+	"lAtail":                          "\u291B",
+	"lBarr":                           "\u290E",
+	"lE":                              "\u2266",
+	"lEg":                             "\u2A8B",
+	"lHar":                            "\u2962",
+	"lacute":                          "\u013A",
+	"laemptyv":                        "\u29B4",
+	"lagran":                          "\u2112",
+	"lambda":                          "\u03BB",
+	"lang":                            "\u27E8",
+	"langd":                           "\u2991",
+	"langle":                          "\u27E8",
+	"lap":                             "\u2A85",
+	"laquo":                           "\u00AB",
+	"larr":                            "\u2190",
+	"larrb":                           "\u21E4",
+	"larrbfs":                         "\u291F",
+	"larrfs":                          "\u291D",
+	"larrhk":                          "\u21A9",
+	"larrlp":                          "\u21AB",
+	"larrpl":                          "\u2939",
+	"larrsim":                         "\u2973",
+	"larrtl":                          "\u21A2",
+	"lat":                             "\u2AAB",
+	"latail":                          "\u2919",
+	"late":                            "\u2AAD",
+	"lates":                           "\u2AAD\uFE00",
+	"lbarr":                           "\u290C",
+	"lbbrk":                           "\u2772",
+	"lbrace":                          "\u007B",
+	"lbrack":                          "\u005B",
+	"lbrke":                           "\u298B",
+	"lbrksld":                         "\u298F",
+	"lbrkslu":                         "\u298D",
+	"lcaron":                          "\u013E",
+	"lcedil":                          "\u013C",
+	"lceil":                           "\u2308",
+	"lcub":                            "\u007B",
+	"lcy":                             "\u043B",
+	"ldca":                            "\u2936",
+	"ldquo":                           "\u201C",
+	"ldquor":                          "\u201E",
+	"ldrdhar":                         "\u2967",
+	"ldrushar":                        "\u294B",
+	"ldsh":                            "\u21B2",
+	"le":                              "\u2264",
+	"leftarrow":                       "\u2190",
+	"leftarrowtail":                   "\u21A2",
+	"leftharpoondown":                 "\u21BD",
+	"leftharpoonup":                   "\u21BC",
+	"leftleftarrows":                  "\u21C7",
+	"leftrightarrow":                  "\u2194",
+	"leftrightarrows":                 "\u21C6",
+	"leftrightharpoons":               "\u21CB",
+	"leftrightsquigarrow":             "\u21AD",
+	"leftthreetimes":                  "\u22CB",
+	"leg":                             "\u22DA",
+	"leq":                             "\u2264",
+	"leqq":                            "\u2266",
+	"leqslant":                        "\u2A7D",
+	"les":                             "\u2A7D",
+	"lescc":                           "\u2AA8",
+	"lesdot":                          "\u2A7F",
+	"lesdoto":                         "\u2A81",
+	"lesdotor":                        "\u2A83",
+	"lesg":                            "\u22DA\uFE00",
+	"lesges":                          "\u2A93",
+	"lessapprox":                      "\u2A85",
+	"lessdot":                         "\u22D6",
+	"lesseqgtr":                       "\u22DA",
+	"lesseqqgtr":                      "\u2A8B",
+	"lessgtr":                         "\u2276",
+	"lesssim":                         "\u2272",
+	"lfisht":                          "\u297C",
+	"lfloor":                          "\u230A",
+	"lfr":                             "\U0001D529",
+	"lg":                              "\u2276",
+	"lgE":                             "\u2A91",
+	"lhard":                           "\u21BD",
+	"lharu":                           "\u21BC",
+	"lharul":                          "\u296A",
+	"lhblk":                           "\u2584",
+	"ljcy":                            "\u0459",
+	"ll":                              "\u226A",
+	"llarr":                           "\u21C7",
+	"llcorner":                        "\u231E",
+	"llhard":                          "\u296B",
+	"lltri":                           "\u25FA",
+	"lmidot":                          "\u0140",
+	"lmoust":                          "\u23B0",
+	"lmoustache":                      "\u23B0",
+	"lnE":                             "\u2268",
+	"lnap":                            "\u2A89",
+	"lnapprox":                        "\u2A89",
+	"lne":                             "\u2A87",
+	"lneq":                            "\u2A87",
+	"lneqq":                           "\u2268",
+	"lnsim":                           "\u22E6",
+	"loang":                           "\u27EC",
+	"loarr":                           "\u21FD",
+	"lobrk":                           "\u27E6",
+	"longleftarrow":                   "\u27F5",
+	"longleftrightarrow":              "\u27F7",
+	"longmapsto":                      "\u27FC",
+	"longrightarrow":                  "\u27F6",
+	"looparrowleft":                   "\u21AB",
+	"looparrowright":                  "\u21AC",
+	"lopar":                           "\u2985",
+	"lopf":                            "\U0001D55D",
+	"loplus":                          "\u2A2D",
+	"lotimes":                         "\u2A34",
+	"lowast":                          "\u2217",
+	"lowbar":                          "\u005F",
+	"loz":                             "\u25CA",
+	"lozenge":                         "\u25CA",
+	"lozf":                            "\u29EB",
+	"lpar":                            "\u0028",
+	"lparlt":                          "\u2993",
+	"lrarr":                           "\u21C6",
+	"lrcorner":                        "\u231F",
+	"lrhar":                           "\u21CB",
+	"lrhard":                          "\u296D",
+	"lrm":                             "\u200E",
+	"lrtri":                           "\u22BF",
+	"lsaquo":                          "\u2039",
+	"lscr":                            "\U0001D4C1",
+	"lsh":                             "\u21B0",
+	"lsim":                            "\u2272",
+	"lsime":                           "\u2A8D",
+	"lsimg":                           "\u2A8F",
+	"lsqb":                            "\u005B",
+	"lsquo":                           "\u2018",
+	"lsquor":                          "\u201A",
+	"lstrok":                          "\u0142",
+	"lt":                              "\u003C",
+	"ltcc":                            "\u2AA6",
+	"ltcir":                           "\u2A79",
+	"ltdot":                           "\u22D6",
+	"lthree":                          "\u22CB",
+	"ltimes":                          "\u22C9",
+	"ltlarr":                          "\u2976",
+	"ltquest":                         "\u2A7B",
+	"ltrPar":                          "\u2996",
+	"ltri":                            "\u25C3",
+	"ltrie":                           "\u22B4",
+	"ltrif":                           "\u25C2",
+	"lurdshar":                        "\u294A",
+	"luruhar":                         "\u2966",
+	"lvertneqq":                       "\u2268\uFE00",
+	"lvnE":                            "\u2268\uFE00",
+	"mDDot":                           "\u223A",
+	"macr":                            "\u00AF",
+	"male":                            "\u2642",
+	"malt":                            "\u2720",
+	"maltese":                         "\u2720",
+	"map":                             "\u21A6",
+	"mapsto":                          "\u21A6",
+	"mapstodown":                      "\u21A7",
+	"mapstoleft":                      "\u21A4",
+	"mapstoup":                        "\u21A5",
+	"marker":                          "\u25AE",
+	"mcomma":                          "\u2A29",
+	"mcy":                             "\u043C",
+	"mdash":                           "\u2014",
+	"measuredangle":                   "\u2221",
+	"mfr":                             "\U0001D52A",
+	"mho":                             "\u2127",
+	"micro":                           "\u00B5",
+	"mid":                             "\u2223",
+	"midast":                          "\u002A",
+	"midcir":                          "\u2AF0",
+	"middot":                          "\u00B7",
+	"minus":                           "\u2212",
+	"minusb":                          "\u229F",
+	"minusd":                          "\u2238",
+	"minusdu":                         "\u2A2A",
+	"mlcp":                            "\u2ADB",
+	"mldr":                            "\u2026",
+	"mnplus":                          "\u2213",
+	"models":                          "\u22A7",
+	"mopf":                            "\U0001D55E",
+	"mp":                              "\u2213",
+	"mscr":                            "\U0001D4C2",
+	"mstpos":                          "\u223E",
+	"mu":                              "\u03BC",
+	"multimap":                        "\u22B8",
+	"mumap":                           "\u22B8",
+	"nGg":                             "\u22D9\u0338",
+	"nGt":                             "\u226B\u20D2",
+	"nGtv":                            "\u226B\u0338",
+	"nLeftarrow":                      "\u21CD",
+	"nLeftrightarrow":                 "\u21CE",
+	"nLl":                             "\u22D8\u0338",
+	"nLt":                             "\u226A\u20D2",
+	"nLtv":                            "\u226A\u0338",
+	"nRightarrow":                     "\u21CF",
+	"nVDash":                          "\u22AF",
+	"nVdash":                          "\u22AE",
+	"nabla":                           "\u2207",
+	"nacute":                          "\u0144",
+	"nang":                            "\u2220\u20D2",
+	"nap":                             "\u2249",
+	"napE":                            "\u2A70\u0338",
+	"napid":                           "\u224B\u0338",
+	"napos":                           "\u0149",
+	"napprox":                         "\u2249",
+	"natur":                           "\u266E",
+	"natural":                         "\u266E",
+	"naturals":                        "\u2115",
+	"nbsp":                            "\u00A0",
+	"nbump":                           "\u224E\u0338",
+	"nbumpe":                          "\u224F\u0338",
+	"ncap":                            "\u2A43",
+	"ncaron":                          "\u0148",
+	"ncedil":                          "\u0146",
+	"ncong":                           "\u2247",
+	"ncongdot":                        "\u2A6D\u0338",
+	"ncup":                            "\u2A42",
+	"ncy":                             "\u043D",
+	"ndash":                           "\u2013",
+	"ne":                              "\u2260",
+	"neArr":                           "\u21D7",
+	"nearhk":                          "\u2924",
+	"nearr":                           "\u2197",
+	"nearrow":                         "\u2197",
+	"nedot":                           "\u2250\u0338",
+	"nequiv":                          "\u2262",
+	"nesear":                          "\u2928",
+	"nesim":                           "\u2242\u0338",
+	"nexist":                          "\u2204",
+	"nexists":                         "\u2204",
+	"nfr":                             "\U0001D52B",
+	"ngE":                             "\u2267\u0338",
+	"nge":                             "\u2271",
+	"ngeq":                            "\u2271",
+	"ngeqq":                           "\u2267\u0338",
+	"ngeqslant":                       "\u2A7E\u0338",
+	"nges":                            "\u2A7E\u0338",
+	"ngsim":                           "\u2275",
+	"ngt":                             "\u226F",
+	"ngtr":                            "\u226F",
+	"nhArr":                           "\u21CE",
+	"nharr":                           "\u21AE",
+	"nhpar":                           "\u2AF2",
+	"ni":                              "\u220B",
+	"nis":                             "\u22FC",
+	"nisd":                            "\u22FA",
+	"niv":                             "\u220B",
+	"njcy":                            "\u045A",
+	"nlArr":                           "\u21CD",
+	"nlE":                             "\u2266\u0338",
+	"nlarr":                           "\u219A",
+	"nldr":                            "\u2025",
+	"nle":                             "\u2270",
+	"nleftarrow":                      "\u219A",
+	"nleftrightarrow":                 "\u21AE",
+	"nleq":                            "\u2270",
+	"nleqq":                           "\u2266\u0338",
+	"nleqslant":                       "\u2A7D\u0338",
+	"nles":                            "\u2A7D\u0338",
+	"nless":                           "\u226E",
+	"nlsim":                           "\u2274",
+	"nlt":                             "\u226E",
+	"nltri":                           "\u22EA",
+	"nltrie":                          "\u22EC",
+	"nmid":                            "\u2224",
+	"nopf":                            "\U0001D55F",
+	"not":                             "\u00AC",
+	"notin":                           "\u2209",
+	"notinE":                          "\u22F9\u0338",
+	"notindot":                        "\u22F5\u0338",
+	"notinva":                         "\u2209",
+	"notinvb":                         "\u22F7",
+	"notinvc":                         "\u22F6",
+	"notni":                           "\u220C",
+	"notniva":                         "\u220C",
+	"notnivb":                         "\u22FE",
+	"notnivc":                         "\u22FD",
+	"npar":                            "\u2226",
+	"nparallel":                       "\u2226",
+	"nparsl":                          "\u2AFD\u20E5",
+	"npart":                           "\u2202\u0338",
+	"npolint":                         "\u2A14",
+	"npr":                             "\u2280",
+	"nprcue":                          "\u22E0",
+	"npre":                            "\u2AAF\u0338",
+	"nprec":                           "\u2280",
+	"npreceq":                         "\u2AAF\u0338",
+	"nrArr":                           "\u21CF",
+	"nrarr":                           "\u219B",
+	"nrarrc":                          "\u2933\u0338",
+	"nrarrw":                          "\u219D\u0338",
+	"nrightarrow":                     "\u219B",
+	"nrtri":                           "\u22EB",
+	"nrtrie":                          "\u22ED",
+	"nsc":                             "\u2281",
+	"nsccue":                          "\u22E1",
+	"nsce":                            "\u2AB0\u0338",
+	"nscr":                            "\U0001D4C3",
+	"nshortmid":                       "\u2224",
+	"nshortparallel":                  "\u2226",
+	"nsim":                            "\u2241",
+	"nsime":                           "\u2244",
+	"nsimeq":                          "\u2244",
+	"nsmid":                           "\u2224",
+	"nspar":                           "\u2226",
+	"nsqsube":                         "\u22E2",
+	"nsqsupe":                         "\u22E3",
+	"nsub":                            "\u2284",
+	"nsubE":                           "\u2AC5\u0338",
+	"nsube":                           "\u2288",
+	"nsubset":                         "\u2282\u20D2",
+	"nsubseteq":                       "\u2288",
+	"nsubseteqq":                      "\u2AC5\u0338",
+	"nsucc":                           "\u2281",
+	"nsucceq":                         "\u2AB0\u0338",
+	"nsup":                            "\u2285",
+	"nsupE":                           "\u2AC6\u0338",
+	"nsupe":                           "\u2289",
+	"nsupset":                         "\u2283\u20D2",
+	"nsupseteq":                       "\u2289",
+	"nsupseteqq":                      "\u2AC6\u0338",
+	"ntgl":                            "\u2279",
+	"ntilde":                          "\u00F1",
+	"ntlg":                            "\u2278",
+	"ntriangleleft":                   "\u22EA",
+	"ntrianglelefteq":                 "\u22EC",
+	"ntriangleright":                  "\u22EB",
+	"ntrianglerighteq":                "\u22ED",
+	"nu":                              "\u03BD",
+	"num":                             "\u0023",
+	"numero":                          "\u2116",
+	"numsp":                           "\u2007",
+	"nvDash":                          "\u22AD",
+	"nvHarr":                          "\u2904",
+	"nvap":                            "\u224D\u20D2",
+	"nvdash":                          "\u22AC",
+	"nvge":                            "\u2265\u20D2",
+	"nvgt":                            "\u003E\u20D2",
+	"nvinfin":                         "\u29DE",
+	"nvlArr":                          "\u2902",
+	"nvle":                            "\u2264\u20D2",
+	"nvlt":                            "\u003C\u20D2",
+	"nvltrie":                         "\u22B4\u20D2",
+	"nvrArr":                          "\u2903",
+	"nvrtrie":                         "\u22B5\u20D2",
+	"nvsim":                           "\u223C\u20D2",
+	"nwArr":                           "\u21D6",
+	"nwarhk":                          "\u2923",
+	"nwarr":                           "\u2196",
+	"nwarrow":                         "\u2196",
+	"nwnear":                          "\u2927",
+	"oS":                              "\u24C8",
+	"oacute":                          "\u00F3",
+	"oast":                            "\u229B",
+	"ocir":                            "\u229A",
+	"ocirc":                           "\u00F4",
+	"ocy":                             "\u043E",
+	"odash":                           "\u229D",
+	"odblac":                          "\u0151",
+	"odiv":                            "\u2A38",
+	"odot":                            "\u2299",
+	"odsold":                          "\u29BC",
+	"oelig":                           "\u0153",
+	"ofcir":                           "\u29BF",
+	"ofr":                             "\U0001D52C",
+	"ogon":                            "\u02DB",
+	"ograve":                          "\u00F2",
+	"ogt":                             "\u29C1",
+	"ohbar":                           "\u29B5",
+	"ohm":                             "\u03A9",
+	"oint":                            "\u222E",
+	"olarr":                           "\u21BA",
+	"olcir":                           "\u29BE",
+	"olcross":                         "\u29BB",
+	"oline":                           "\u203E",
+	"olt":                             "\u29C0",
+	"omacr":                           "\u014D",
+	"omega":                           "\u03C9",
+	"omicron":                         "\u03BF",
+	"omid":                            "\u29B6",
+	"ominus":                          "\u2296",
+	"oopf":                            "\U0001D560",
+	"opar":                            "\u29B7",
+	"operp":                           "\u29B9",
+	"oplus":                           "\u2295",
+	"or":                              "\u2228",
+	"orarr":                           "\u21BB",
+	"ord":                             "\u2A5D",
+	"order":                           "\u2134",
+	"orderof":                         "\u2134",
+	"ordf":                            "\u00AA",
+	"ordm":                            "\u00BA",
+	"origof":                          "\u22B6",
+	"oror":                            "\u2A56",
+	"orslope":                         "\u2A57",
+	"orv":                             "\u2A5B",
+	"oscr":                            "\u2134",
+	"oslash":                          "\u00F8",
+	"osol":                            "\u2298",
+	"otilde":                          "\u00F5",
+	"otimes":                          "\u2297",
+	"otimesas":                        "\u2A36",
+	"ouml":                            "\u00F6",
+	"ovbar":                           "\u233D",
+	"par":                             "\u2225",
+	"para":                            "\u00B6",
+	"parallel":                        "\u2225",
+	"parsim":                          "\u2AF3",
+	"parsl":                           "\u2AFD",
+	"part":                            "\u2202",
+	"pcy":                             "\u043F",
+	"percnt":                          "\u0025",
+	"period":                          "\u002E",
+	"permil":                          "\u2030",
+	"perp":                            "\u22A5",
+	"pertenk":                         "\u2031",
+	"pfr":                             "\U0001D52D",
+	"phi":                             "\u03C6",
+	"phiv":                            "\u03D5",
+	"phmmat":                          "\u2133",
+	"phone":                           "\u260E",
+	"pi":                              "\u03C0",
+	"pitchfork":                       "\u22D4",
+	"piv":                             "\u03D6",
+	"planck":                          "\u210F",
+	"planckh":                         "\u210E",
+	"plankv":                          "\u210F",
+	"plus":                            "\u002B",
+	"plusacir":                        "\u2A23",
+	"plusb":                           "\u229E",
+	"pluscir":                         "\u2A22",
+	"plusdo":                          "\u2214",
+	"plusdu":                          "\u2A25",
+	"pluse":                           "\u2A72",
+	"plusmn":                          "\u00B1",
+	"plussim":                         "\u2A26",
+	"plustwo":                         "\u2A27",
+	"pm":                              "\u00B1",
+	"pointint":                        "\u2A15",
+	"popf":                            "\U0001D561",
+	"pound":                           "\u00A3",
+	"pr":                              "\u227A",
+	"prE":                             "\u2AB3",
+	"prap":                            "\u2AB7",
+	"prcue":                           "\u227C",
+	"pre":                             "\u2AAF",
+	"prec":                            "\u227A",
+	"precapprox":                      "\u2AB7",
+	"preccurlyeq":                     "\u227C",
+	"preceq":                          "\u2AAF",
+	"precnapprox":                     "\u2AB9",
+	"precneqq":                        "\u2AB5",
+	"precnsim":                        "\u22E8",
+	"precsim":                         "\u227E",
+	"prime":                           "\u2032",
+	"primes":                          "\u2119",
+	"prnE":                            "\u2AB5",
+	"prnap":                           "\u2AB9",
+	"prnsim":                          "\u22E8",
+	"prod":                            "\u220F",
+	"profalar":                        "\u232E",
+	"profline":                        "\u2312",
+	"profsurf":                        "\u2313",
+	"prop":                            "\u221D",
+	"propto":                          "\u221D",
+	"prsim":                           "\u227E",
+	"prurel":                          "\u22B0",
+	"pscr":                            "\U0001D4C5",
+	"psi":                             "\u03C8",
+	"puncsp":                          "\u2008",
+	"qfr":                             "\U0001D52E",
+	"qint":                            "\u2A0C",
+	"qopf":                            "\U0001D562",
+	"qprime":                          "\u2057",
+	"qscr":                            "\U0001D4C6",
+	"quaternions":                     "\u210D",
+	"quatint":                         "\u2A16",
+	"quest":                           "\u003F",
+	"questeq":                         "\u225F",
+	"quot":                            "\u0022",
+	"rAarr":                           "\u21DB",
+	"rArr":                            "\u21D2",
+	"rAtail":                          "\u291C",
+	"rBarr":                           "\u290F",
+	"rHar":                            "\u2964",
+	"race":                            "\u223D\u0331",
+	"racute":                          "\u0155",
+	"radic":                           "\u221A",
+	"raemptyv":                        "\u29B3",
+	"rang":                            "\u27E9",
+	"rangd":                           "\u2992",
+	"range":                           "\u29A5",
+	"rangle":                          "\u27E9",
+	"raquo":                           "\u00BB",
+	"rarr":                            "\u2192",
+	"rarrap":                          "\u2975",
+	"rarrb":                           "\u21E5",
+	"rarrbfs":                         "\u2920",
+	"rarrc":                           "\u2933",
+	"rarrfs":                          "\u291E",
+	"rarrhk":                          "\u21AA",
+	"rarrlp":                          "\u21AC",
+	"rarrpl":                          "\u2945",
+	"rarrsim":                         "\u2974",
+	"rarrtl":                          "\u21A3",
+	"rarrw":                           "\u219D",
+	"ratail":                          "\u291A",
+	"ratio":                           "\u2236",
+	"rationals":                       "\u211A",
+	"rbarr":                           "\u290D",
+	"rbbrk":                           "\u2773",
+	"rbrace":                          "\u007D",
+	"rbrack":                          "\u005D",
+	"rbrke":                           "\u298C",
+	"rbrksld":                         "\u298E",
+	"rbrkslu":                         "\u2990",
+	"rcaron":                          "\u0159",
+	"rcedil":                          "\u0157",
+	"rceil":                           "\u2309",
+	"rcub":                            "\u007D",
+	"rcy":                             "\u0440",
+	"rdca":                            "\u2937",
+	"rdldhar":                         "\u2969",
+	"rdquo":                           "\u201D",
+	"rdquor":                          "\u201D",
+	"rdsh":                            "\u21B3",
+	"real":                            "\u211C",
+	"realine":                         "\u211B",
+	"realpart":                        "\u211C",
+	"reals":                           "\u211D",
+	"rect":                            "\u25AD",
+	"reg":                             "\u00AE",
+	"rfisht":                          "\u297D",
+	"rfloor":                          "\u230B",
+	"rfr":                             "\U0001D52F",
+	"rhard":                           "\u21C1",
+	"rharu":                           "\u21C0",
+	"rharul":                          "\u296C",
+	"rho":                             "\u03C1",
+	"rhov":                            "\u03F1",
+	"rightarrow":                      "\u2192",
+	"rightarrowtail":                  "\u21A3",
+	"rightharpoondown":                "\u21C1",
+	"rightharpoonup":                  "\u21C0",
+	"rightleftarrows":                 "\u21C4",
+	"rightleftharpoons":               "\u21CC",
+	"rightrightarrows":                "\u21C9",
+	"rightsquigarrow":                 "\u219D",
+	"rightthreetimes":                 "\u22CC",
+	"ring":                            "\u02DA",
+	"risingdotseq":                    "\u2253",
+	"rlarr":                           "\u21C4",
+	"rlhar":                           "\u21CC",
+	"rlm":                             "\u200F",
+	"rmoust":                          "\u23B1",
+	"rmoustache":                      "\u23B1",
+	"rnmid":                           "\u2AEE",
+	"roang":                           "\u27ED",
+	"roarr":                           "\u21FE",
+	"robrk":                           "\u27E7",
+	"ropar":                           "\u2986",
+	"ropf":                            "\U0001D563",
+	"roplus":                          "\u2A2E",
+	"rotimes":                         "\u2A35",
+	"rpar":                            "\u0029",
+	"rpargt":                          "\u2994",
+	"rppolint":                        "\u2A12",
+	"rrarr":                           "\u21C9",
+	"rsaquo":                          "\u203A",
+	"rscr":                            "\U0001D4C7",
+	"rsh":                             "\u21B1",
+	"rsqb":                            "\u005D",
+	"rsquo":                           "\u2019",
+	"rsquor":                          "\u2019",
+	"rthree":                          "\u22CC",
+	"rtimes":                          "\u22CA",
+	"rtri":                            "\u25B9",
+	"rtrie":                           "\u22B5",
+	"rtrif":                           "\u25B8",
+	"rtriltri":                        "\u29CE",
+	"ruluhar":                         "\u2968",
+	"rx":                              "\u211E",
+	"sacute":                          "\u015B",
+	"sbquo":                           "\u201A",
+	"sc":                              "\u227B",
+	"scE":                             "\u2AB4",
+	"scap":                            "\u2AB8",
+	"scaron":                          "\u0161",
+	"sccue":                           "\u227D",
+	"sce":                             "\u2AB0",
+	"scedil":                          "\u015F",
+	"scirc":                           "\u015D",
+	"scnE":                            "\u2AB6",
+	"scnap":                           "\u2ABA",
+	"scnsim":                          "\u22E9",
+	"scpolint":                        "\u2A13",
+	"scsim":                           "\u227F",
+	"scy":                             "\u0441",
+	"sdot":                            "\u22C5",
+	"sdotb":                           "\u22A1",
+	"sdote":                           "\u2A66",
+	"seArr":                           "\u21D8",
+	"searhk":                          "\u2925",
+	"searr":                           "\u2198",
+	"searrow":                         "\u2198",
+	"sect":                            "\u00A7",
+	"semi":                            "\u003B",
+	"seswar":                          "\u2929",
+	"setminus":                        "\u2216",
+	"setmn":                           "\u2216",
+	"sext":                            "\u2736",
+	"sfr":                             "\U0001D530",
+	"sfrown":                          "\u2322",
+	"sharp":                           "\u266F",
+	"shchcy":                          "\u0449",
+	"shcy":                            "\u0448",
+	"shortmid":                        "\u2223",
+	"shortparallel":                   "\u2225",
+	"shy":                             "\u00AD",
+	"sigma":                           "\u03C3",
+	"sigmaf":                          "\u03C2",
+	"sigmav":                          "\u03C2",
+	"sim":                             "\u223C",
+	"simdot":                          "\u2A6A",
+	"sime":                            "\u2243",
+	"simeq":                           "\u2243",
+	"simg":                            "\u2A9E",
+	"simgE":                           "\u2AA0",
+	"siml":                            "\u2A9D",
+	"simlE":                           "\u2A9F",
+	"simne":                           "\u2246",
+	"simplus":                         "\u2A24",
+	"simrarr":                         "\u2972",
+	"slarr":                           "\u2190",
+	"smallsetminus":                   "\u2216",
+	"smashp":                          "\u2A33",
+	"smeparsl":                        "\u29E4",
+	"smid":                            "\u2223",
+	"smile":                           "\u2323",
+	"smt":                             "\u2AAA",
+	"smte":                            "\u2AAC",
+	"smtes":                           "\u2AAC\uFE00",
+	"softcy":                          "\u044C",
+	"sol":                             "\u002F",
+	"solb":                            "\u29C4",
+	"solbar":                          "\u233F",
+	"sopf":                            "\U0001D564",
+	"spades":                          "\u2660",
+	"spadesuit":                       "\u2660",
+	"spar":                            "\u2225",
+	"sqcap":                           "\u2293",
+	"sqcaps":                          "\u2293\uFE00",
+	"sqcup":                           "\u2294",
+	"sqcups":                          "\u2294\uFE00",
+	"sqsub":                           "\u228F",
+	"sqsube":                          "\u2291",
+	"sqsubset":                        "\u228F",
+	"sqsubseteq":                      "\u2291",
+	"sqsup":                           "\u2290",
+	"sqsupe":                          "\u2292",
+	"sqsupset":                        "\u2290",
+	"sqsupseteq":                      "\u2292",
+	"squ":                             "\u25A1",
+	"square":                          "\u25A1",
+	"squarf":                          "\u25AA",
+	"squf":                            "\u25AA",
+	"srarr":                           "\u2192",
+	"sscr":                            "\U0001D4C8",
+	"ssetmn":                          "\u2216",
+	"ssmile":                          "\u2323",
+	"sstarf":                          "\u22C6",
+	"star":                            "\u2606",
+	"starf":                           "\u2605",
+	"straightepsilon":                 "\u03F5",
+	"straightphi":                     "\u03D5",
+	"strns":                           "\u00AF",
+	"sub":                             "\u2282",
+	"subE":                            "\u2AC5",
+	"subdot":                          "\u2ABD",
+	"sube":                            "\u2286",
+	"subedot":                         "\u2AC3",
+	"submult":                         "\u2AC1",
+	"subnE":                           "\u2ACB",
+	"subne":                           "\u228A",
+	"subplus":                         "\u2ABF",
+	"subrarr":                         "\u2979",
+	"subset":                          "\u2282",
+	"subseteq":                        "\u2286",
+	"subseteqq":                       "\u2AC5",
+	"subsetneq":                       "\u228A",
+	"subsetneqq":                      "\u2ACB",
+	"subsim":                          "\u2AC7",
+	"subsub":                          "\u2AD5",
+	"subsup":                          "\u2AD3",
+	"succ":                            "\u227B",
+	"succapprox":                      "\u2AB8",
+	"succcurlyeq":                     "\u227D",
+	"succeq":                          "\u2AB0",
+	"succnapprox":                     "\u2ABA",
+	"succneqq":                        "\u2AB6",
+	"succnsim":                        "\u22E9",
+	"succsim":                         "\u227F",
+	"sum":                             "\u2211",
+	"sung":                            "\u266A",
+	"sup":                             "\u2283",
+	"sup1":                            "\u00B9",
+	"sup2":                            "\u00B2",
+	"sup3":                            "\u00B3",
+	"supE":                            "\u2AC6",
+	"supdot":                          "\u2ABE",
+	"supdsub":                         "\u2AD8",
+	"supe":                            "\u2287",
+	"supedot":                         "\u2AC4",
+	"suphsol":                         "\u27C9",
+	"suphsub":                         "\u2AD7",
+	"suplarr":                         "\u297B",
+	"supmult":                         "\u2AC2",
+	"supnE":                           "\u2ACC",
+	"supne":                           "\u228B",
+	"supplus":                         "\u2AC0",
+	"supset":                          "\u2283",
+	"supseteq":                        "\u2287",
+	"supseteqq":                       "\u2AC6",
+	"supsetneq":                       "\u228B",
+	"supsetneqq":                      "\u2ACC",
+	"supsim":                          "\u2AC8",
+	"supsub":                          "\u2AD4",
+	"supsup":                          "\u2AD6",
+	"swArr":                           "\u21D9",
+	"swarhk":                          "\u2926",
+	"swarr":                           "\u2199",
+	"swarrow":                         "\u2199",
+	"swnwar":                          "\u292A",
+	"szlig":                           "\u00DF",
+	"target":                          "\u2316",
+	"tau":                             "\u03C4",
+	"tbrk":                            "\u23B4",
+	"tcaron":                          "\u0165",
+	"tcedil":                          "\u0163",
+	"tcy":                             "\u0442",
+	"tdot":                            "\u20DB",
+	"telrec":                          "\u2315",
+	"tfr":                             "\U0001D531",
+	"there4":                          "\u2234",
+	"therefore":                       "\u2234",
+	"theta":                           "\u03B8",
+	"thetasym":                        "\u03D1",
+	"thetav":                          "\u03D1",
+	"thickapprox":                     "\u2248",
+	"thicksim":                        "\u223C",
+	"thinsp":                          "\u2009",
+	"thkap":                           "\u2248",
+	"thksim":                          "\u223C",
+	"thorn":                           "\u00FE",
+	"tilde":                           "\u02DC",
+	"times":                           "\u00D7",
+	"timesb":                          "\u22A0",
+	"timesbar":                        "\u2A31",
+	"timesd":                          "\u2A30",
+	"tint":                            "\u222D",
+	"toea":                            "\u2928",
+	"top":                             "\u22A4",
+	"topbot":                          "\u2336",
+	"topcir":                          "\u2AF1",
+	"topf":                            "\U0001D565",
+	"topfork":                         "\u2ADA",
+	"tosa":                            "\u2929",
+	"tprime":                          "\u2034",
+	"trade":                           "\u2122",
+	"triangle":                        "\u25B5",
+	"triangledown":                    "\u25BF",
+	"triangleleft":                    "\u25C3",
+	"trianglelefteq":                  "\u22B4",
+	"triangleq":                       "\u225C",
+	"triangleright":                   "\u25B9",
+	"trianglerighteq":                 "\u22B5",
+	"tridot":                          "\u25EC",
+	"trie":                            "\u225C",
+	"triminus":                        "\u2A3A",
+	"triplus":                         "\u2A39",
+	"trisb":                           "\u29CD",
+	"tritime":                         "\u2A3B",
+	"trpezium":                        "\u23E2",
+	"tscr":                            "\U0001D4C9",
+	"tscy":                            "\u0446",
+	"tshcy":                           "\u045B",
+	"tstrok":                          "\u0167",
+	"twixt":                           "\u226C",
+	"twoheadleftarrow":                "\u219E",
+	"twoheadrightarrow":               "\u21A0",
+	"uArr":                            "\u21D1",
+	"uHar":                            "\u2963",
+	"uacute":                          "\u00FA",
+	"uarr":                            "\u2191",
+	"ubrcy":                           "\u045E",
+	"ubreve":                          "\u016D",
+	"ucirc":                           "\u00FB",
+	"ucy":                             "\u0443",
+	"udarr":                           "\u21C5",
+	"udblac":                          "\u0171",
+	"udhar":                           "\u296E",
+	"ufisht":                          "\u297E",
+	"ufr":                             "\U0001D532",
+	"ugrave":                          "\u00F9",
+	"uharl":                           "\u21BF",
+	"uharr":                           "\u21BE",
+	"uhblk":                           "\u2580",
+	"ulcorn":                          "\u231C",
+	"ulcorner":                        "\u231C",
+	"ulcrop":                          "\u230F",
+	"ultri":                           "\u25F8",
+	"umacr":                           "\u016B",
+	"uml":                             "\u00A8",
+	"uogon":                           "\u0173",
+	"uopf":                            "\U0001D566",
+	"uparrow":                         "\u2191",
+	"updownarrow":                     "\u2195",
+	"upharpoonleft":                   "\u21BF",
+	"upharpoonright":                  "\u21BE",
+	"uplus":                           "\u228E",
+	"upsi":                            "\u03C5",
+	"upsih":                           "\u03D2",
+	"upsilon":                         "\u03C5",
+	"upuparrows":                      "\u21C8",
+	"urcorn":                          "\u231D",
+	"urcorner":                        "\u231D",
+	"urcrop":                          "\u230E",
+	"uring":                           "\u016F",
+	"urtri":                           "\u25F9",
+	"uscr":                            "\U0001D4CA",
+	"utdot":                           "\u22F0",
+	"utilde":                          "\u0169",
+	"utri":                            "\u25B5",
+	"utrif":                           "\u25B4",
+	"uuarr":                           "\u21C8",
+	"uuml":                            "\u00FC",
+	"uwangle":                         "\u29A7",
+	"vArr":                            "\u21D5",
+	"vBar":                            "\u2AE8",
+	"vBarv":                           "\u2AE9",
+	"vDash":                           "\u22A8",
+	"vangrt":                          "\u299C",
+	"varepsilon":                      "\u03F5",
+	"varkappa":                        "\u03F0",
+	"varnothing":                      "\u2205",
+	"varphi":                          "\u03D5",
+	"varpi":                           "\u03D6",
+	"varpropto":                       "\u221D",
+	"varr":                            "\u2195",
+	"varrho":                          "\u03F1",
+	"varsigma":                        "\u03C2",
+	"varsubsetneq":                    "\u228A\uFE00",
+	"varsubsetneqq":                   "\u2ACB\uFE00",
+	"varsupsetneq":                    "\u228B\uFE00",
+	"varsupsetneqq":                   "\u2ACC\uFE00",
+	"vartheta":                        "\u03D1",
+	"vartriangleleft":                 "\u22B2",
+	"vartriangleright":                "\u22B3",
+	"vcy":                             "\u0432",
+	"vdash":                           "\u22A2",
+	"vee":                             "\u2228",
+	"veebar":                          "\u22BB",
+	"veeeq":                           "\u225A",
+	"vellip":                          "\u22EE",
+	"verbar":                          "\u007C",
+	"vert":                            "\u007C",
+	"vfr":                             "\U0001D533",
+	"vltri":                           "\u22B2",
+	"vnsub":                           "\u2282\u20D2",
+	"vnsup":                           "\u2283\u20D2",
+	"vopf":                            "\U0001D567",
+	"vprop":                           "\u221D",
+	"vrtri":                           "\u22B3",
+	"vscr":                            "\U0001D4CB",
+	"vsubnE":                          "\u2ACB\uFE00",
+	"vsubne":                          "\u228A\uFE00",
+	"vsupnE":                          "\u2ACC\uFE00",
+	"vsupne":                          "\u228B\uFE00",
+	"vzigzag":                         "\u299A",
+	"wcirc":                           "\u0175",
+	"wedbar":                          "\u2A5F",
+	"wedge":                           "\u2227",
+	"wedgeq":                          "\u2259",
+	"weierp":                          "\u2118",
+	"wfr":                             "\U0001D534",
+	"wopf":                            "\U0001D568",
+	"wp":                              "\u2118",
+	"wr":                              "\u2240",
+	"wreath":                          "\u2240",
+	"wscr":                            "\U0001D4CC",
+	"xcap":                            "\u22C2",
+	"xcirc":                           "\u25EF",
+	"xcup":                            "\u22C3",
+	"xdtri":                           "\u25BD",
+	"xfr":                             "\U0001D535",
+	"xhArr":                           "\u27FA",
+	"xharr":                           "\u27F7",
+	"xi":                              "\u03BE",
+	"xlArr":                           "\u27F8",
+	"xlarr":                           "\u27F5",
+	"xmap":                            "\u27FC",
+	"xnis":                            "\u22FB",
+	"xodot":                           "\u2A00",
+	"xopf":                            "\U0001D569",
+	"xoplus":                          "\u2A01",
+	"xotime":                          "\u2A02",
+	"xrArr":                           "\u27F9",
+	"xrarr":                           "\u27F6",
+	"xscr":                            "\U0001D4CD",
+	"xsqcup":                          "\u2A06",
+	"xuplus":                          "\u2A04",
+	"xutri":                           "\u25B3",
+	"xvee":                            "\u22C1",
+	"xwedge":                          "\u22C0",
+	"yacute":                          "\u00FD",
+	"yacy":                            "\u044F",
+	"ycirc":                           "\u0177",
+	"ycy":                             "\u044B",
+	"yen":                             "\u00A5",
+	"yfr":                             "\U0001D536",
+	"yicy":                            "\u0457",
+	"yopf":                            "\U0001D56A",
+	"yscr":                            "\U0001D4CE",
+	"yucy":                            "\u044E",
+	"yuml":                            "\u00FF",
+	"zacute":                          "\u017A",
+	"zcaron":                          "\u017E",
+	"zcy":                             "\u0437",
+	"zdot":                            "\u017C",
+	"zeetrf":                          "\u2128",
+	"zeta":                            "\u03B6",
+	"zfr":                             "\U0001D537",
+	"zhcy":                            "\u0436",
+	"zigrarr":                         "\u21DD",
+	"zopf":                            "\U0001D56B",
+	"zscr":                            "\U0001D4CF",
+	"zwj":                             "\u200D",
+	"zwnj":                            "\u200C",
+}
diff --git a/vendor/gitlab.com/golang-commonmark/html/html_benchmark_test.go b/vendor/gitlab.com/golang-commonmark/html/html_benchmark_test.go
new file mode 100644
index 000000000..3f127ef2b
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/html/html_benchmark_test.go
@@ -0,0 +1,32 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package html
+
+import (
+	"html"
+	"testing"
+)
+
+var escapeBenchmarkStrings = []string{
+	"",
+	"a b c d e f g h i j k l m n o p q r s t u v w x y z ",
+	`<a href="http://google.com?q=&">google.com</a>`,
+}
+
+func BenchmarkEscapeString(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, s := range escapeBenchmarkStrings {
+			EscapeString(s)
+		}
+	}
+}
+
+func BenchmarkEscapeStringStdlib(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, s := range escapeBenchmarkStrings {
+			html.EscapeString(s)
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/html/html_example_test.go b/vendor/gitlab.com/golang-commonmark/html/html_example_test.go
new file mode 100644
index 000000000..f5775a714
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/html/html_example_test.go
@@ -0,0 +1,54 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package html
+
+import (
+	"bytes"
+	"fmt"
+)
+
+func ExampleEscapeString() {
+	fmt.Println(EscapeString(`<a href="https://www.google.com/search?q=something&ie=utf-8">Google Search</a>`))
+
+	// Output:
+	// &lt;a href=&quot;https://www.google.com/search?q=something&amp;ie=utf-8&quot;&gt;Google Search&lt;/a&gt;
+}
+
+func ExampleWriteEscapedString() {
+	var buf bytes.Buffer
+	WriteEscapedString(&buf, `<a href="https://www.google.com/search?q=something&ie=utf-8">Google Search</a>`)
+	fmt.Println(buf.String())
+
+	// Output:
+	// &lt;a href=&quot;https://www.google.com/search?q=something&amp;ie=utf-8&quot;&gt;Google Search&lt;/a&gt;
+}
+
+func ExampleParseEntity() {
+	fmt.Println(ParseEntity("&quot;"))
+	fmt.Println(ParseEntity("&#x22;"))
+	fmt.Println(ParseEntity("&#34;"))
+	fmt.Println(ParseEntity("&#x00000022;"))
+	fmt.Println(ParseEntity("&#00000034;"))
+	fmt.Println(ParseEntity("&#x000000022;"))
+	fmt.Println(ParseEntity("&#000000034;"))
+	fmt.Println(ParseEntity("&#98765432;"))
+
+	// Output:
+	// " 6
+	// " 6
+	// " 5
+	// " 12
+	// " 11
+	//  0
+	//  0
+	// � 11
+}
+
+func ExampleUnescapeString() {
+	fmt.Println(UnescapeString("&nbsp; &amp; &copy; &AElig; &Dcaron; &frac34; &HilbertSpace; &DifferentialD; &ClockwiseContourIntegral; &#35; &#1234; &#992; &#98765432; &#X22; &#XD06; &#xcab; &nbsp &x; &#; &#x; &ThisIsWayTooLongToBeAnEntityIsntIt; &hi?; &copy &MadeUpEntity;"))
+
+	// Output:
+	//   & © Æ Ď ¾ ℋ ⅆ ∲ # Ӓ Ϡ � " ആ ಫ &nbsp &x; &#; &#x; &ThisIsWayTooLongToBeAnEntityIsntIt; &hi?; &copy &MadeUpEntity;
+}
diff --git a/vendor/gitlab.com/golang-commonmark/html/html_test.go b/vendor/gitlab.com/golang-commonmark/html/html_test.go
new file mode 100644
index 000000000..19e775a4d
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/html/html_test.go
@@ -0,0 +1,108 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package html
+
+import (
+	"testing"
+)
+
+var parseEntityTests = []struct {
+	in     string
+	length int
+	str    string
+}{
+	{in: "&;"},
+	{in: "&"},
+	{in: "&@;"},
+	{in: "&@"},
+	{in: "&#;"},
+	{in: "&#"},
+	{in: "&##;"},
+	{in: "&##"},
+	{in: "&#0"},
+	{in: "&#09"},
+	{in: "&#0a;"},
+	{in: "&#0a"},
+	{in: "&#34;", length: 5, str: `"`},
+	{in: "&#98765432;", length: 11, str: BadEntity},
+	{in: "&#9;", length: 4, str: "\t"},
+	{in: "&ffffffffffffffffuuuuuuuuuuuuuuuu;"},
+	{in: "&ffffffffffffffffuuuuuuuuuuuuuuuu"},
+	{in: "&q;"},
+	{in: "&q"},
+	{in: "&q#;"},
+	{in: "&q#"},
+	{in: "&Q"},
+	{in: "&q0;"},
+	{in: "&q0"},
+	{in: "&qu;"},
+	{in: "&qu"},
+	{in: "&quot;", length: 6, str: `"`},
+	{in: "&#x;"},
+	{in: "&#x"},
+	{in: "&#X;"},
+	{in: "&#X"},
+	{in: "&#x0"},
+	{in: "&#x0@;"},
+	{in: "&#x0@"},
+	{in: "&#X0"},
+	{in: "&#x000000001;"},
+	{in: "&#x000000001"},
+	{in: "&#x09"},
+	{in: "&#x09;", length: 6, str: "\t"},
+	{in: "&#X09;", length: 6, str: "\t"},
+	{in: "&#x0a;", length: 6, str: "\n"},
+	{in: "&#x0A;", length: 6, str: "\n"},
+	{in: "&#X0a;", length: 6, str: "\n"},
+	{in: "&#X0A;", length: 6, str: "\n"},
+	{in: "&#x22;", length: 6, str: `"`},
+	{in: "&#x7fffffff;", length: 12, str: BadEntity},
+	{in: "&#xa"},
+	{in: "&#xA"},
+	{in: "&#Xa"},
+	{in: "&#XA"},
+	{in: "&#xffffffff"},
+	{in: "&#xfffffffff"},
+	{in: "&#xffffffff;", length: 12, str: BadEntity},
+	{in: "&#xG;"},
+	{in: "&#xG"},
+	{in: "&#XG;"},
+	{in: "&#XG"},
+}
+
+var replaceEntitiesTests = []struct {
+	in  string
+	out string // empty means == in
+}{
+	{"", ""},
+	{"a b c d e f g h i j k l m n o p q r s t u v w x y z", ""},
+	{"&", ""},
+	{"&nbsp; &amp; &copy; &quot;", `  & © "`},
+	{"&#x22; &#X22; &#34;", `" " "`},
+	{"&x; &#; &#x; &ThisIsWayTooLongToBeAnEntityIsntIt; &hi?; &copy &MadeUpEntity;", ""},
+}
+
+func TestParseEntity(t *testing.T) {
+	for _, tc := range parseEntityTests {
+		str, length := ParseEntity(tc.in)
+		if str != tc.str || length != tc.length {
+			t.Errorf("ParseEntity(%q): want %d,%q, got %d,%q", tc.in,
+				tc.length, tc.str, length, str)
+		}
+	}
+}
+
+func TestUnescapeString(t *testing.T) {
+	for _, tc := range replaceEntitiesTests {
+		got := UnescapeString(tc.in)
+		want := tc.out
+		if want == "" {
+			want = tc.in
+		}
+		if got != want {
+			t.Errorf("UnescapeString(%q): want %q, got %q", tc.in, want, got)
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/.gitlab-ci.yml b/vendor/gitlab.com/golang-commonmark/linkify/.gitlab-ci.yml
new file mode 100644
index 000000000..c873ca361
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/.gitlab-ci.yml
@@ -0,0 +1,19 @@
+image: golang:1.11
+
+stages:
+  - build
+  - test
+
+before_script:
+  - go get golang.org/x/text/unicode/rangetable
+
+build:
+  stage: build
+  script:
+    - go build ./...
+
+test:
+  stage: test
+  script:
+    - test -z "$(gofmt -l . | tee /dev/stderr)"
+    - go test ./...
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/LICENSE b/vendor/gitlab.com/golang-commonmark/linkify/LICENSE
new file mode 100644
index 000000000..9cdcd2016
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/LICENSE
@@ -0,0 +1,10 @@
+Copyright (c) 2015, The Authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE 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 HOLDER 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.
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/README.md b/vendor/gitlab.com/golang-commonmark/linkify/README.md
new file mode 100644
index 000000000..8b7911133
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/README.md
@@ -0,0 +1,12 @@
+linkify [![License](https://img.shields.io/badge/licence-BSD--2--Clause-blue.svg)](https://opensource.org/licenses/BSD-2-Clause) [![GoDoc](http://godoc.org/gitlab.com/golang-commonmark/linkify?status.svg)](http://godoc.org/gitlab.com/golang-commonmark/linkify) [![Pipeline status](https://gitlab.com/golang-commonmark/linkify/badges/master/pipeline.svg)](https://gitlab.com/golang-commonmark/linkify/commits/master)
+=======
+
+Package linkify provides a way to find what looks like links in plain text.
+
+## Install
+
+    go get -u gitlab.com/golang-commonmark/linkify
+
+## Use
+
+See an [example](https://gitlab.com/golang-commonmark/linkify/blob/master/linkify_example_test.go).
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/charset.go b/vendor/gitlab.com/golang-commonmark/linkify/charset.go
new file mode 100644
index 000000000..7ea3b625a
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/charset.go
@@ -0,0 +1,51 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package linkify
+
+import (
+	"unicode"
+
+	"golang.org/x/text/unicode/rangetable"
+)
+
+var (
+	unreserved = [256]bool{'-': true, '.': true, '_': true, '~': true}
+	basicPunct = [256]bool{'.': true, ',': true, '?': true, '!': true, ';': true, ':': true}
+	subdelims  = [256]bool{'!': true, '$': true, '&': true, '\'': true, '(': true, ')': true,
+		'*': true, '+': true, ',': true, ';': true, '=': true}
+	emailcs = [256]bool{'a': true, 'b': true, 'c': true, 'd': true, 'e': true, 'f': true, 'g': true,
+		'h': true, 'i': true, 'j': true, 'k': true, 'l': true, 'm': true, 'n': true, 'o': true,
+		'p': true, 'q': true, 'r': true, 's': true, 't': true, 'u': true, 'v': true, 'w': true,
+		'x': true, 'y': true, 'z': true, 'A': true, 'B': true, 'C': true, 'D': true, 'E': true,
+		'F': true, 'G': true, 'H': true, 'I': true, 'J': true, 'K': true, 'L': true, 'M': true,
+		'N': true, 'O': true, 'P': true, 'Q': true, 'R': true, 'S': true, 'T': true, 'U': true,
+		'V': true, 'W': true, 'X': true, 'Y': true, 'Z': true, '0': true, '1': true, '2': true,
+		'3': true, '4': true, '5': true, '6': true, '7': true, '8': true, '9': true, '!': true,
+		'#': true, '$': true, '%': true, '&': true, '\'': true, '*': true, '+': true, '/': true,
+		'=': true, '?': true, '^': true, '_': true, '`': true, '{': true, '|': true, '}': true,
+		'~': true, '-': true}
+	letterOrDigit = rangetable.Merge(unicode.Letter, unicode.Digit)
+	punctSpaceCc  = rangetable.Merge(unicode.Punct, unicode.Space, unicode.Cc)
+)
+
+func isAllowedInEmail(r rune) bool {
+	return r < 0x7f && emailcs[r]
+}
+
+func isLetterOrDigit(r rune) bool {
+	return unicode.Is(letterOrDigit, r)
+}
+
+func isPunctOrSpaceOrControl(r rune) bool {
+	return r == '<' || r == '>' || r == '\uff5c' || unicode.Is(punctSpaceCc, r)
+}
+
+func isUnreserved(r rune) bool {
+	return (r < 0x7f && unreserved[r]) || unicode.Is(letterOrDigit, r)
+}
+
+func isSubDelimiter(r rune) bool {
+	return r < 0x7f && subdelims[r]
+}
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/email.go b/vendor/gitlab.com/golang-commonmark/linkify/email.go
new file mode 100644
index 000000000..35bfb679c
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/email.go
@@ -0,0 +1,93 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package linkify
+
+import (
+	"unicode"
+	"unicode/utf8"
+)
+
+func findEmailStart(s string, start int) (_ int, _ bool) {
+	end := start
+	allowDot := false
+	for end >= 0 {
+		b := s[end]
+		switch {
+		case emailcs[b]:
+			allowDot = true
+		case b == '.':
+			if !allowDot {
+				return
+			}
+			allowDot = false
+		default:
+			if end == start {
+				return
+			}
+			if s[end+1] == '.' {
+				return
+			}
+			r, _ := utf8.DecodeLastRuneInString(s[:end+1])
+			if r == utf8.RuneError {
+				return
+			}
+			if !unicode.IsSpace(r) {
+				return
+			}
+			return end + 1, true
+		}
+		end--
+	}
+	if end < start && s[end+1] == '.' {
+		return
+	}
+	return end + 1, true
+}
+
+func findEmailEnd(s string, start int) (_ int, _ bool) {
+	end := start
+	allowDot := false
+loop:
+	for end < len(s) {
+		b := s[end]
+		switch {
+		case emailcs[b]:
+			allowDot = true
+		case b == '.':
+			if !allowDot {
+				return
+			}
+			allowDot = false
+		case b == '@':
+			break loop
+		default:
+			return
+		}
+		end++
+	}
+	if end >= len(s)-5 {
+		return
+	}
+	if end > start && s[end-1] == '.' {
+		return
+	}
+
+	var dot int
+	var ok bool
+	end, dot, ok = findHostnameEnd(s, end+1)
+	if !ok || dot == -1 {
+		return
+	}
+
+	if dot+5 <= len(s) && s[dot+1:dot+5] == "xn--" {
+		return end, true
+	}
+
+	if length := match(s[dot+1:]); dot+length+1 != end {
+		return
+	}
+
+	return end, true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/generated.go b/vendor/gitlab.com/golang-commonmark/linkify/generated.go
new file mode 100644
index 000000000..0fbd3cba4
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/generated.go
@@ -0,0 +1,18175 @@
+// Code generated by genfsm.go. DO NOT EDIT
+
+package linkify
+
+func match(s string) int {
+	st := 0
+	length := -1
+
+	for i := 0; i < len(s); i++ {
+		b := s[i]
+
+		switch st {
+		case 0:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1
+			case 'b':
+				st = 148
+			case 'c':
+				st = 303
+			case 'd':
+				st = 571
+			case 'e':
+				st = 686
+			case 'f':
+				st = 797
+			case 'g':
+				st = 916
+			case 'h':
+				st = 1014
+			case 'i':
+				st = 1099
+			case 'j':
+				st = 1180
+			case 'k':
+				st = 1210
+			case 'l':
+				st = 1253
+			case 'm':
+				st = 1349
+			case 'n':
+				st = 1478
+			case 'o':
+				st = 1536
+			case 'p':
+				st = 1577
+			case 'q':
+				st = 1699
+			case 'r':
+				st = 1709
+			case 's':
+				st = 1797
+			case 't':
+				st = 2010
+			case 'u':
+				st = 2128
+			case 'v':
+				st = 2147
+			case 'w':
+				st = 2220
+			case 'x':
+				st = 2283
+			case 'y':
+				st = 2297
+			case 'z':
+				st = 2330
+			case '0':
+				st = 2348
+			case '1':
+				st = 2350
+			case '2':
+				st = 2352
+			case '3':
+				st = 2354
+			case '4':
+				st = 2356
+			case '5':
+				st = 2358
+			case '6':
+				st = 2360
+			case '7':
+				st = 2362
+			case '8':
+				st = 2364
+			case '9':
+				st = 2366
+			default:
+				return length
+			}
+
+		case 1:
+			switch byteToLower(b) {
+			case 'b':
+				st = 2
+			case 'c':
+				length = i + 1
+				st = 12
+			case 'd':
+				length = i + 1
+				st = 39
+			case 'e':
+				length = i + 1
+				st = 44
+			case 'f':
+				length = i + 1
+				st = 47
+			case 'g':
+				length = i + 1
+				st = 49
+			case 'i':
+				length = i + 1
+				st = 54
+			case 'l':
+				length = i + 1
+				st = 62
+			case 'm':
+				length = i + 1
+				st = 74
+			case 'n':
+				length = i + 1
+				st = 82
+			case 'o':
+				length = i + 1
+				st = 88
+			case 'p':
+				st = 89
+			case 'q':
+				length = i + 1
+				st = 98
+			case 'r':
+				length = i + 1
+				st = 106
+			case 's':
+				length = i + 1
+				st = 114
+			case 't':
+				length = i + 1
+				st = 125
+			case 'u':
+				length = i + 1
+				st = 132
+			case 'w':
+				length = i + 1
+				st = 144
+			case 'x':
+				length = i + 1
+				st = 145
+			case 'z':
+				length = i + 1
+				st = 147
+			default:
+				return length
+			}
+
+		case 2:
+			switch byteToLower(b) {
+			case 'b':
+				length = i + 1
+				st = 3
+			case 'o':
+				st = 7
+			default:
+				return length
+			}
+
+		case 3:
+			switch byteToLower(b) {
+			case 'o':
+				st = 4
+			default:
+				return length
+			}
+
+		case 4:
+			switch byteToLower(b) {
+			case 't':
+				st = 5
+			default:
+				return length
+			}
+
+		case 5:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 6
+			default:
+				return length
+			}
+
+		case 7:
+			switch byteToLower(b) {
+			case 'g':
+				st = 8
+			default:
+				return length
+			}
+
+		case 8:
+			switch byteToLower(b) {
+			case 'a':
+				st = 9
+			default:
+				return length
+			}
+
+		case 9:
+			switch byteToLower(b) {
+			case 'd':
+				st = 10
+			default:
+				return length
+			}
+
+		case 10:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 11
+			default:
+				return length
+			}
+
+		case 12:
+			switch byteToLower(b) {
+			case 'a':
+				st = 13
+			case 'c':
+				st = 18
+			case 't':
+				st = 33
+			default:
+				return length
+			}
+
+		case 13:
+			switch byteToLower(b) {
+			case 'd':
+				st = 14
+			default:
+				return length
+			}
+
+		case 14:
+			switch byteToLower(b) {
+			case 'e':
+				st = 15
+			default:
+				return length
+			}
+
+		case 15:
+			switch byteToLower(b) {
+			case 'm':
+				st = 16
+			default:
+				return length
+			}
+
+		case 16:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 17
+			default:
+				return length
+			}
+
+		case 18:
+			switch byteToLower(b) {
+			case 'e':
+				st = 19
+			case 'o':
+				st = 25
+			default:
+				return length
+			}
+
+		case 19:
+			switch byteToLower(b) {
+			case 'n':
+				st = 20
+			default:
+				return length
+			}
+
+		case 20:
+			switch byteToLower(b) {
+			case 't':
+				st = 21
+			default:
+				return length
+			}
+
+		case 21:
+			switch byteToLower(b) {
+			case 'u':
+				st = 22
+			default:
+				return length
+			}
+
+		case 22:
+			switch byteToLower(b) {
+			case 'r':
+				st = 23
+			default:
+				return length
+			}
+
+		case 23:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 24
+			default:
+				return length
+			}
+
+		case 25:
+			switch byteToLower(b) {
+			case 'u':
+				st = 26
+			default:
+				return length
+			}
+
+		case 26:
+			switch byteToLower(b) {
+			case 'n':
+				st = 27
+			default:
+				return length
+			}
+
+		case 27:
+			switch byteToLower(b) {
+			case 't':
+				st = 28
+			default:
+				return length
+			}
+
+		case 28:
+			switch byteToLower(b) {
+			case 'a':
+				st = 29
+			default:
+				return length
+			}
+
+		case 29:
+			switch byteToLower(b) {
+			case 'n':
+				st = 30
+			default:
+				return length
+			}
+
+		case 30:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 31
+			default:
+				return length
+			}
+
+		case 31:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 32
+			default:
+				return length
+			}
+
+		case 33:
+			switch byteToLower(b) {
+			case 'i':
+				st = 34
+			case 'o':
+				st = 37
+			default:
+				return length
+			}
+
+		case 34:
+			switch byteToLower(b) {
+			case 'v':
+				st = 35
+			default:
+				return length
+			}
+
+		case 35:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 36
+			default:
+				return length
+			}
+
+		case 37:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 38
+			default:
+				return length
+			}
+
+		case 39:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 40
+			case 'u':
+				st = 41
+			default:
+				return length
+			}
+
+		case 41:
+			switch byteToLower(b) {
+			case 'l':
+				st = 42
+			default:
+				return length
+			}
+
+		case 42:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 43
+			default:
+				return length
+			}
+
+		case 44:
+			switch byteToLower(b) {
+			case 'r':
+				st = 45
+			default:
+				return length
+			}
+
+		case 45:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 46
+			default:
+				return length
+			}
+
+		case 47:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 48
+			default:
+				return length
+			}
+
+		case 49:
+			switch byteToLower(b) {
+			case 'e':
+				st = 50
+			default:
+				return length
+			}
+
+		case 50:
+			switch byteToLower(b) {
+			case 'n':
+				st = 51
+			default:
+				return length
+			}
+
+		case 51:
+			switch byteToLower(b) {
+			case 'c':
+				st = 52
+			default:
+				return length
+			}
+
+		case 52:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 53
+			default:
+				return length
+			}
+
+		case 54:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 55
+			case 'r':
+				st = 56
+			default:
+				return length
+			}
+
+		case 56:
+			switch byteToLower(b) {
+			case 'f':
+				st = 57
+			default:
+				return length
+			}
+
+		case 57:
+			switch byteToLower(b) {
+			case 'o':
+				st = 58
+			default:
+				return length
+			}
+
+		case 58:
+			switch byteToLower(b) {
+			case 'r':
+				st = 59
+			default:
+				return length
+			}
+
+		case 59:
+			switch byteToLower(b) {
+			case 'c':
+				st = 60
+			default:
+				return length
+			}
+
+		case 60:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 61
+			default:
+				return length
+			}
+
+		case 62:
+			switch byteToLower(b) {
+			case 'l':
+				st = 63
+			case 's':
+				st = 70
+			default:
+				return length
+			}
+
+		case 63:
+			switch byteToLower(b) {
+			case 'f':
+				st = 64
+			default:
+				return length
+			}
+
+		case 64:
+			switch byteToLower(b) {
+			case 'i':
+				st = 65
+			default:
+				return length
+			}
+
+		case 65:
+			switch byteToLower(b) {
+			case 'n':
+				st = 66
+			default:
+				return length
+			}
+
+		case 66:
+			switch byteToLower(b) {
+			case 'a':
+				st = 67
+			default:
+				return length
+			}
+
+		case 67:
+			switch byteToLower(b) {
+			case 'n':
+				st = 68
+			default:
+				return length
+			}
+
+		case 68:
+			switch byteToLower(b) {
+			case 'z':
+				length = i + 1
+				st = 69
+			default:
+				return length
+			}
+
+		case 70:
+			switch byteToLower(b) {
+			case 'a':
+				st = 71
+			default:
+				return length
+			}
+
+		case 71:
+			switch byteToLower(b) {
+			case 'c':
+				st = 72
+			default:
+				return length
+			}
+
+		case 72:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 73
+			default:
+				return length
+			}
+
+		case 74:
+			switch byteToLower(b) {
+			case 's':
+				st = 75
+			default:
+				return length
+			}
+
+		case 75:
+			switch byteToLower(b) {
+			case 't':
+				st = 76
+			default:
+				return length
+			}
+
+		case 76:
+			switch byteToLower(b) {
+			case 'e':
+				st = 77
+			default:
+				return length
+			}
+
+		case 77:
+			switch byteToLower(b) {
+			case 'r':
+				st = 78
+			default:
+				return length
+			}
+
+		case 78:
+			switch byteToLower(b) {
+			case 'd':
+				st = 79
+			default:
+				return length
+			}
+
+		case 79:
+			switch byteToLower(b) {
+			case 'a':
+				st = 80
+			default:
+				return length
+			}
+
+		case 80:
+			switch byteToLower(b) {
+			case 'm':
+				length = i + 1
+				st = 81
+			default:
+				return length
+			}
+
+		case 82:
+			switch byteToLower(b) {
+			case 'd':
+				st = 83
+			default:
+				return length
+			}
+
+		case 83:
+			switch byteToLower(b) {
+			case 'r':
+				st = 84
+			default:
+				return length
+			}
+
+		case 84:
+			switch byteToLower(b) {
+			case 'o':
+				st = 85
+			default:
+				return length
+			}
+
+		case 85:
+			switch byteToLower(b) {
+			case 'i':
+				st = 86
+			default:
+				return length
+			}
+
+		case 86:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 87
+			default:
+				return length
+			}
+
+		case 89:
+			switch byteToLower(b) {
+			case 'a':
+				st = 90
+			default:
+				return length
+			}
+
+		case 90:
+			switch byteToLower(b) {
+			case 'r':
+				st = 91
+			default:
+				return length
+			}
+
+		case 91:
+			switch byteToLower(b) {
+			case 't':
+				st = 92
+			default:
+				return length
+			}
+
+		case 92:
+			switch byteToLower(b) {
+			case 'm':
+				st = 93
+			default:
+				return length
+			}
+
+		case 93:
+			switch byteToLower(b) {
+			case 'e':
+				st = 94
+			default:
+				return length
+			}
+
+		case 94:
+			switch byteToLower(b) {
+			case 'n':
+				st = 95
+			default:
+				return length
+			}
+
+		case 95:
+			switch byteToLower(b) {
+			case 't':
+				st = 96
+			default:
+				return length
+			}
+
+		case 96:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 97
+			default:
+				return length
+			}
+
+		case 98:
+			switch byteToLower(b) {
+			case 'u':
+				st = 99
+			default:
+				return length
+			}
+
+		case 99:
+			switch byteToLower(b) {
+			case 'a':
+				st = 100
+			default:
+				return length
+			}
+
+		case 100:
+			switch byteToLower(b) {
+			case 'r':
+				st = 101
+			default:
+				return length
+			}
+
+		case 101:
+			switch byteToLower(b) {
+			case 'e':
+				st = 102
+			default:
+				return length
+			}
+
+		case 102:
+			switch byteToLower(b) {
+			case 'l':
+				st = 103
+			default:
+				return length
+			}
+
+		case 103:
+			switch byteToLower(b) {
+			case 'l':
+				st = 104
+			default:
+				return length
+			}
+
+		case 104:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 105
+			default:
+				return length
+			}
+
+		case 106:
+			switch byteToLower(b) {
+			case 'c':
+				st = 107
+			case 'm':
+				st = 110
+			case 'p':
+				st = 112
+			default:
+				return length
+			}
+
+		case 107:
+			switch byteToLower(b) {
+			case 'h':
+				st = 108
+			default:
+				return length
+			}
+
+		case 108:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 109
+			default:
+				return length
+			}
+
+		case 110:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 111
+			default:
+				return length
+			}
+
+		case 112:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 113
+			default:
+				return length
+			}
+
+		case 114:
+			switch byteToLower(b) {
+			case 'i':
+				st = 115
+			case 's':
+				st = 117
+			default:
+				return length
+			}
+
+		case 115:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 116
+			default:
+				return length
+			}
+
+		case 117:
+			switch byteToLower(b) {
+			case 'o':
+				st = 118
+			default:
+				return length
+			}
+
+		case 118:
+			switch byteToLower(b) {
+			case 'c':
+				st = 119
+			default:
+				return length
+			}
+
+		case 119:
+			switch byteToLower(b) {
+			case 'i':
+				st = 120
+			default:
+				return length
+			}
+
+		case 120:
+			switch byteToLower(b) {
+			case 'a':
+				st = 121
+			default:
+				return length
+			}
+
+		case 121:
+			switch byteToLower(b) {
+			case 't':
+				st = 122
+			default:
+				return length
+			}
+
+		case 122:
+			switch byteToLower(b) {
+			case 'e':
+				st = 123
+			default:
+				return length
+			}
+
+		case 123:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 124
+			default:
+				return length
+			}
+
+		case 125:
+			switch byteToLower(b) {
+			case 't':
+				st = 126
+			default:
+				return length
+			}
+
+		case 126:
+			switch byteToLower(b) {
+			case 'o':
+				st = 127
+			default:
+				return length
+			}
+
+		case 127:
+			switch byteToLower(b) {
+			case 'r':
+				st = 128
+			default:
+				return length
+			}
+
+		case 128:
+			switch byteToLower(b) {
+			case 'n':
+				st = 129
+			default:
+				return length
+			}
+
+		case 129:
+			switch byteToLower(b) {
+			case 'e':
+				st = 130
+			default:
+				return length
+			}
+
+		case 130:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 131
+			default:
+				return length
+			}
+
+		case 132:
+			switch byteToLower(b) {
+			case 'c':
+				st = 133
+			case 'd':
+				st = 138
+			case 't':
+				st = 141
+			default:
+				return length
+			}
+
+		case 133:
+			switch byteToLower(b) {
+			case 't':
+				st = 134
+			default:
+				return length
+			}
+
+		case 134:
+			switch byteToLower(b) {
+			case 'i':
+				st = 135
+			default:
+				return length
+			}
+
+		case 135:
+			switch byteToLower(b) {
+			case 'o':
+				st = 136
+			default:
+				return length
+			}
+
+		case 136:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 137
+			default:
+				return length
+			}
+
+		case 138:
+			switch byteToLower(b) {
+			case 'i':
+				st = 139
+			default:
+				return length
+			}
+
+		case 139:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 140
+			default:
+				return length
+			}
+
+		case 141:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 142
+			default:
+				return length
+			}
+
+		case 142:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 143
+			default:
+				return length
+			}
+
+		case 145:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 146
+			default:
+				return length
+			}
+
+		case 148:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 149
+			case 'b':
+				length = i + 1
+				st = 177
+			case 'd':
+				length = i + 1
+				st = 181
+			case 'e':
+				length = i + 1
+				st = 182
+			case 'f':
+				length = i + 1
+				st = 191
+			case 'g':
+				length = i + 1
+				st = 192
+			case 'h':
+				length = i + 1
+				st = 193
+			case 'i':
+				length = i + 1
+				st = 194
+			case 'j':
+				length = i + 1
+				st = 207
+			case 'l':
+				st = 208
+			case 'm':
+				length = i + 1
+				st = 227
+			case 'n':
+				length = i + 1
+				st = 229
+			case 'o':
+				length = i + 1
+				st = 238
+			case 'r':
+				length = i + 1
+				st = 251
+			case 's':
+				length = i + 1
+				st = 275
+			case 't':
+				length = i + 1
+				st = 276
+			case 'u':
+				st = 277
+			case 'v':
+				length = i + 1
+				st = 298
+			case 'w':
+				length = i + 1
+				st = 299
+			case 'y':
+				length = i + 1
+				st = 300
+			case 'z':
+				length = i + 1
+				st = 301
+			default:
+				return length
+			}
+
+		case 149:
+			switch byteToLower(b) {
+			case 'n':
+				st = 150
+			case 'r':
+				length = i + 1
+				st = 153
+			case 'u':
+				st = 168
+			case 'y':
+				st = 173
+			default:
+				return length
+			}
+
+		case 150:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 151
+			case 'k':
+				length = i + 1
+				st = 152
+			default:
+				return length
+			}
+
+		case 153:
+			switch byteToLower(b) {
+			case 'c':
+				st = 154
+			case 'g':
+				st = 163
+			default:
+				return length
+			}
+
+		case 154:
+			switch byteToLower(b) {
+			case 'l':
+				st = 155
+			default:
+				return length
+			}
+
+		case 155:
+			switch byteToLower(b) {
+			case 'a':
+				st = 156
+			default:
+				return length
+			}
+
+		case 156:
+			switch byteToLower(b) {
+			case 'y':
+				st = 157
+			default:
+				return length
+			}
+
+		case 157:
+			switch byteToLower(b) {
+			case 'c':
+				st = 158
+			case 's':
+				length = i + 1
+				st = 162
+			default:
+				return length
+			}
+
+		case 158:
+			switch byteToLower(b) {
+			case 'a':
+				st = 159
+			default:
+				return length
+			}
+
+		case 159:
+			switch byteToLower(b) {
+			case 'r':
+				st = 160
+			default:
+				return length
+			}
+
+		case 160:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 161
+			default:
+				return length
+			}
+
+		case 163:
+			switch byteToLower(b) {
+			case 'a':
+				st = 164
+			default:
+				return length
+			}
+
+		case 164:
+			switch byteToLower(b) {
+			case 'i':
+				st = 165
+			default:
+				return length
+			}
+
+		case 165:
+			switch byteToLower(b) {
+			case 'n':
+				st = 166
+			default:
+				return length
+			}
+
+		case 166:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 167
+			default:
+				return length
+			}
+
+		case 168:
+			switch byteToLower(b) {
+			case 'h':
+				st = 169
+			default:
+				return length
+			}
+
+		case 169:
+			switch byteToLower(b) {
+			case 'a':
+				st = 170
+			default:
+				return length
+			}
+
+		case 170:
+			switch byteToLower(b) {
+			case 'u':
+				st = 171
+			default:
+				return length
+			}
+
+		case 171:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 172
+			default:
+				return length
+			}
+
+		case 173:
+			switch byteToLower(b) {
+			case 'e':
+				st = 174
+			default:
+				return length
+			}
+
+		case 174:
+			switch byteToLower(b) {
+			case 'r':
+				st = 175
+			default:
+				return length
+			}
+
+		case 175:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 176
+			default:
+				return length
+			}
+
+		case 177:
+			switch byteToLower(b) {
+			case 'c':
+				length = i + 1
+				st = 178
+			case 'v':
+				st = 179
+			default:
+				return length
+			}
+
+		case 179:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 180
+			default:
+				return length
+			}
+
+		case 182:
+			switch byteToLower(b) {
+			case 'e':
+				st = 183
+			case 'r':
+				st = 185
+			case 's':
+				st = 189
+			default:
+				return length
+			}
+
+		case 183:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 184
+			default:
+				return length
+			}
+
+		case 185:
+			switch byteToLower(b) {
+			case 'l':
+				st = 186
+			default:
+				return length
+			}
+
+		case 186:
+			switch byteToLower(b) {
+			case 'i':
+				st = 187
+			default:
+				return length
+			}
+
+		case 187:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 188
+			default:
+				return length
+			}
+
+		case 189:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 190
+			default:
+				return length
+			}
+
+		case 194:
+			switch byteToLower(b) {
+			case 'b':
+				st = 195
+			case 'd':
+				length = i + 1
+				st = 198
+			case 'k':
+				st = 199
+			case 'n':
+				st = 201
+			case 'o':
+				length = i + 1
+				st = 204
+			case 't':
+				length = i + 1
+				st = 205
+			case 'z':
+				length = i + 1
+				st = 206
+			default:
+				return length
+			}
+
+		case 195:
+			switch byteToLower(b) {
+			case 'l':
+				st = 196
+			default:
+				return length
+			}
+
+		case 196:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 197
+			default:
+				return length
+			}
+
+		case 199:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 200
+			default:
+				return length
+			}
+
+		case 201:
+			switch byteToLower(b) {
+			case 'g':
+				st = 202
+			default:
+				return length
+			}
+
+		case 202:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 203
+			default:
+				return length
+			}
+
+		case 208:
+			switch byteToLower(b) {
+			case 'a':
+				st = 209
+			case 'o':
+				st = 218
+			case 'u':
+				st = 225
+			default:
+				return length
+			}
+
+		case 209:
+			switch byteToLower(b) {
+			case 'c':
+				st = 210
+			default:
+				return length
+			}
+
+		case 210:
+			switch byteToLower(b) {
+			case 'k':
+				length = i + 1
+				st = 211
+			default:
+				return length
+			}
+
+		case 211:
+			switch byteToLower(b) {
+			case 'f':
+				st = 212
+			default:
+				return length
+			}
+
+		case 212:
+			switch byteToLower(b) {
+			case 'r':
+				st = 213
+			default:
+				return length
+			}
+
+		case 213:
+			switch byteToLower(b) {
+			case 'i':
+				st = 214
+			default:
+				return length
+			}
+
+		case 214:
+			switch byteToLower(b) {
+			case 'd':
+				st = 215
+			default:
+				return length
+			}
+
+		case 215:
+			switch byteToLower(b) {
+			case 'a':
+				st = 216
+			default:
+				return length
+			}
+
+		case 216:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 217
+			default:
+				return length
+			}
+
+		case 218:
+			switch byteToLower(b) {
+			case 'o':
+				st = 219
+			default:
+				return length
+			}
+
+		case 219:
+			switch byteToLower(b) {
+			case 'm':
+				st = 220
+			default:
+				return length
+			}
+
+		case 220:
+			switch byteToLower(b) {
+			case 'b':
+				st = 221
+			default:
+				return length
+			}
+
+		case 221:
+			switch byteToLower(b) {
+			case 'e':
+				st = 222
+			default:
+				return length
+			}
+
+		case 222:
+			switch byteToLower(b) {
+			case 'r':
+				st = 223
+			default:
+				return length
+			}
+
+		case 223:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 224
+			default:
+				return length
+			}
+
+		case 225:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 226
+			default:
+				return length
+			}
+
+		case 227:
+			switch byteToLower(b) {
+			case 'w':
+				length = i + 1
+				st = 228
+			default:
+				return length
+			}
+
+		case 229:
+			switch byteToLower(b) {
+			case 'p':
+				st = 230
+			default:
+				return length
+			}
+
+		case 230:
+			switch byteToLower(b) {
+			case 'p':
+				st = 231
+			default:
+				return length
+			}
+
+		case 231:
+			switch byteToLower(b) {
+			case 'a':
+				st = 232
+			default:
+				return length
+			}
+
+		case 232:
+			switch byteToLower(b) {
+			case 'r':
+				st = 233
+			default:
+				return length
+			}
+
+		case 233:
+			switch byteToLower(b) {
+			case 'i':
+				st = 234
+			default:
+				return length
+			}
+
+		case 234:
+			switch byteToLower(b) {
+			case 'b':
+				st = 235
+			default:
+				return length
+			}
+
+		case 235:
+			switch byteToLower(b) {
+			case 'a':
+				st = 236
+			default:
+				return length
+			}
+
+		case 236:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 237
+			default:
+				return length
+			}
+
+		case 238:
+			switch byteToLower(b) {
+			case 'a':
+				st = 239
+			case 'n':
+				st = 242
+			case 'o':
+				length = i + 1
+				st = 244
+			case 'u':
+				st = 245
+			default:
+				return length
+			}
+
+		case 239:
+			switch byteToLower(b) {
+			case 't':
+				st = 240
+			default:
+				return length
+			}
+
+		case 240:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 241
+			default:
+				return length
+			}
+
+		case 242:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 243
+			default:
+				return length
+			}
+
+		case 245:
+			switch byteToLower(b) {
+			case 't':
+				st = 246
+			default:
+				return length
+			}
+
+		case 246:
+			switch byteToLower(b) {
+			case 'i':
+				st = 247
+			default:
+				return length
+			}
+
+		case 247:
+			switch byteToLower(b) {
+			case 'q':
+				st = 248
+			default:
+				return length
+			}
+
+		case 248:
+			switch byteToLower(b) {
+			case 'u':
+				st = 249
+			default:
+				return length
+			}
+
+		case 249:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 250
+			default:
+				return length
+			}
+
+		case 251:
+			switch byteToLower(b) {
+			case 'i':
+				st = 252
+			case 'o':
+				st = 261
+			case 'u':
+				st = 269
+			default:
+				return length
+			}
+
+		case 252:
+			switch byteToLower(b) {
+			case 'd':
+				st = 253
+			default:
+				return length
+			}
+
+		case 253:
+			switch byteToLower(b) {
+			case 'g':
+				st = 254
+			default:
+				return length
+			}
+
+		case 254:
+			switch byteToLower(b) {
+			case 'e':
+				st = 255
+			default:
+				return length
+			}
+
+		case 255:
+			switch byteToLower(b) {
+			case 's':
+				st = 256
+			default:
+				return length
+			}
+
+		case 256:
+			switch byteToLower(b) {
+			case 't':
+				st = 257
+			default:
+				return length
+			}
+
+		case 257:
+			switch byteToLower(b) {
+			case 'o':
+				st = 258
+			default:
+				return length
+			}
+
+		case 258:
+			switch byteToLower(b) {
+			case 'n':
+				st = 259
+			default:
+				return length
+			}
+
+		case 259:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 260
+			default:
+				return length
+			}
+
+		case 261:
+			switch byteToLower(b) {
+			case 'k':
+				st = 262
+			case 't':
+				st = 265
+			default:
+				return length
+			}
+
+		case 262:
+			switch byteToLower(b) {
+			case 'e':
+				st = 263
+			default:
+				return length
+			}
+
+		case 263:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 264
+			default:
+				return length
+			}
+
+		case 265:
+			switch byteToLower(b) {
+			case 'h':
+				st = 266
+			default:
+				return length
+			}
+
+		case 266:
+			switch byteToLower(b) {
+			case 'e':
+				st = 267
+			default:
+				return length
+			}
+
+		case 267:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 268
+			default:
+				return length
+			}
+
+		case 269:
+			switch byteToLower(b) {
+			case 's':
+				st = 270
+			default:
+				return length
+			}
+
+		case 270:
+			switch byteToLower(b) {
+			case 's':
+				st = 271
+			default:
+				return length
+			}
+
+		case 271:
+			switch byteToLower(b) {
+			case 'e':
+				st = 272
+			default:
+				return length
+			}
+
+		case 272:
+			switch byteToLower(b) {
+			case 'l':
+				st = 273
+			default:
+				return length
+			}
+
+		case 273:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 274
+			default:
+				return length
+			}
+
+		case 277:
+			switch byteToLower(b) {
+			case 'd':
+				st = 278
+			case 'i':
+				st = 284
+			case 's':
+				st = 290
+			case 'z':
+				st = 296
+			default:
+				return length
+			}
+
+		case 278:
+			switch byteToLower(b) {
+			case 'a':
+				st = 279
+			default:
+				return length
+			}
+
+		case 279:
+			switch byteToLower(b) {
+			case 'p':
+				st = 280
+			default:
+				return length
+			}
+
+		case 280:
+			switch byteToLower(b) {
+			case 'e':
+				st = 281
+			default:
+				return length
+			}
+
+		case 281:
+			switch byteToLower(b) {
+			case 's':
+				st = 282
+			default:
+				return length
+			}
+
+		case 282:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 283
+			default:
+				return length
+			}
+
+		case 284:
+			switch byteToLower(b) {
+			case 'l':
+				st = 285
+			default:
+				return length
+			}
+
+		case 285:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 286
+			default:
+				return length
+			}
+
+		case 286:
+			switch byteToLower(b) {
+			case 'e':
+				st = 287
+			default:
+				return length
+			}
+
+		case 287:
+			switch byteToLower(b) {
+			case 'r':
+				st = 288
+			default:
+				return length
+			}
+
+		case 288:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 289
+			default:
+				return length
+			}
+
+		case 290:
+			switch byteToLower(b) {
+			case 'i':
+				st = 291
+			default:
+				return length
+			}
+
+		case 291:
+			switch byteToLower(b) {
+			case 'n':
+				st = 292
+			default:
+				return length
+			}
+
+		case 292:
+			switch byteToLower(b) {
+			case 'e':
+				st = 293
+			default:
+				return length
+			}
+
+		case 293:
+			switch byteToLower(b) {
+			case 's':
+				st = 294
+			default:
+				return length
+			}
+
+		case 294:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 295
+			default:
+				return length
+			}
+
+		case 296:
+			switch byteToLower(b) {
+			case 'z':
+				length = i + 1
+				st = 297
+			default:
+				return length
+			}
+
+		case 301:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 302
+			default:
+				return length
+			}
+
+		case 303:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 304
+			case 'b':
+				st = 366
+			case 'c':
+				length = i + 1
+				st = 368
+			case 'd':
+				length = i + 1
+				st = 369
+			case 'e':
+				st = 370
+			case 'f':
+				length = i + 1
+				st = 378
+			case 'g':
+				length = i + 1
+				st = 381
+			case 'h':
+				length = i + 1
+				st = 382
+			case 'i':
+				length = i + 1
+				st = 409
+			case 'k':
+				length = i + 1
+				st = 417
+			case 'l':
+				length = i + 1
+				st = 418
+			case 'm':
+				length = i + 1
+				st = 443
+			case 'n':
+				length = i + 1
+				st = 444
+			case 'o':
+				length = i + 1
+				st = 445
+			case 'r':
+				length = i + 1
+				st = 532
+			case 'u':
+				length = i + 1
+				st = 552
+			case 'v':
+				length = i + 1
+				st = 561
+			case 'w':
+				length = i + 1
+				st = 562
+			case 'x':
+				length = i + 1
+				st = 563
+			case 'y':
+				length = i + 1
+				st = 564
+			case 'z':
+				length = i + 1
+				st = 570
+			default:
+				return length
+			}
+
+		case 304:
+			switch byteToLower(b) {
+			case 'b':
+				length = i + 1
+				st = 305
+			case 'f':
+				st = 306
+			case 'l':
+				length = i + 1
+				st = 308
+			case 'm':
+				st = 309
+			case 'n':
+				st = 314
+			case 'p':
+				st = 328
+			case 'r':
+				st = 338
+			case 's':
+				st = 354
+			case 't':
+				length = i + 1
+				st = 360
+			default:
+				return length
+			}
+
+		case 306:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 307
+			default:
+				return length
+			}
+
+		case 309:
+			switch byteToLower(b) {
+			case 'e':
+				st = 310
+			case 'p':
+				length = i + 1
+				st = 313
+			default:
+				return length
+			}
+
+		case 310:
+			switch byteToLower(b) {
+			case 'r':
+				st = 311
+			default:
+				return length
+			}
+
+		case 311:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 312
+			default:
+				return length
+			}
+
+		case 314:
+			switch byteToLower(b) {
+			case 'c':
+				st = 315
+			case 'o':
+				st = 326
+			default:
+				return length
+			}
+
+		case 315:
+			switch byteToLower(b) {
+			case 'e':
+				st = 316
+			default:
+				return length
+			}
+
+		case 316:
+			switch byteToLower(b) {
+			case 'r':
+				st = 317
+			default:
+				return length
+			}
+
+		case 317:
+			switch byteToLower(b) {
+			case 'r':
+				st = 318
+			default:
+				return length
+			}
+
+		case 318:
+			switch byteToLower(b) {
+			case 'e':
+				st = 319
+			default:
+				return length
+			}
+
+		case 319:
+			switch byteToLower(b) {
+			case 's':
+				st = 320
+			default:
+				return length
+			}
+
+		case 320:
+			switch byteToLower(b) {
+			case 'e':
+				st = 321
+			default:
+				return length
+			}
+
+		case 321:
+			switch byteToLower(b) {
+			case 'a':
+				st = 322
+			default:
+				return length
+			}
+
+		case 322:
+			switch byteToLower(b) {
+			case 'r':
+				st = 323
+			default:
+				return length
+			}
+
+		case 323:
+			switch byteToLower(b) {
+			case 'c':
+				st = 324
+			default:
+				return length
+			}
+
+		case 324:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 325
+			default:
+				return length
+			}
+
+		case 326:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 327
+			default:
+				return length
+			}
+
+		case 328:
+			switch byteToLower(b) {
+			case 'e':
+				st = 329
+			case 'i':
+				st = 334
+			default:
+				return length
+			}
+
+		case 329:
+			switch byteToLower(b) {
+			case 't':
+				st = 330
+			default:
+				return length
+			}
+
+		case 330:
+			switch byteToLower(b) {
+			case 'o':
+				st = 331
+			default:
+				return length
+			}
+
+		case 331:
+			switch byteToLower(b) {
+			case 'w':
+				st = 332
+			default:
+				return length
+			}
+
+		case 332:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 333
+			default:
+				return length
+			}
+
+		case 334:
+			switch byteToLower(b) {
+			case 't':
+				st = 335
+			default:
+				return length
+			}
+
+		case 335:
+			switch byteToLower(b) {
+			case 'a':
+				st = 336
+			default:
+				return length
+			}
+
+		case 336:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 337
+			default:
+				return length
+			}
+
+		case 338:
+			switch byteToLower(b) {
+			case 'a':
+				st = 339
+			case 'd':
+				st = 343
+			case 'e':
+				length = i + 1
+				st = 345
+			case 's':
+				length = i + 1
+				st = 349
+			case 't':
+				st = 350
+			default:
+				return length
+			}
+
+		case 339:
+			switch byteToLower(b) {
+			case 'v':
+				st = 340
+			default:
+				return length
+			}
+
+		case 340:
+			switch byteToLower(b) {
+			case 'a':
+				st = 341
+			default:
+				return length
+			}
+
+		case 341:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 342
+			default:
+				return length
+			}
+
+		case 343:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 344
+			default:
+				return length
+			}
+
+		case 345:
+			switch byteToLower(b) {
+			case 'e':
+				st = 346
+			default:
+				return length
+			}
+
+		case 346:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 347
+			default:
+				return length
+			}
+
+		case 347:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 348
+			default:
+				return length
+			}
+
+		case 350:
+			switch byteToLower(b) {
+			case 'i':
+				st = 351
+			default:
+				return length
+			}
+
+		case 351:
+			switch byteToLower(b) {
+			case 'e':
+				st = 352
+			default:
+				return length
+			}
+
+		case 352:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 353
+			default:
+				return length
+			}
+
+		case 354:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 355
+			case 'h':
+				length = i + 1
+				st = 356
+			case 'i':
+				st = 357
+			default:
+				return length
+			}
+
+		case 357:
+			switch byteToLower(b) {
+			case 'n':
+				st = 358
+			default:
+				return length
+			}
+
+		case 358:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 359
+			default:
+				return length
+			}
+
+		case 360:
+			switch byteToLower(b) {
+			case 'e':
+				st = 361
+			default:
+				return length
+			}
+
+		case 361:
+			switch byteToLower(b) {
+			case 'r':
+				st = 362
+			default:
+				return length
+			}
+
+		case 362:
+			switch byteToLower(b) {
+			case 'i':
+				st = 363
+			default:
+				return length
+			}
+
+		case 363:
+			switch byteToLower(b) {
+			case 'n':
+				st = 364
+			default:
+				return length
+			}
+
+		case 364:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 365
+			default:
+				return length
+			}
+
+		case 366:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 367
+			default:
+				return length
+			}
+
+		case 370:
+			switch byteToLower(b) {
+			case 'n':
+				st = 371
+			case 'o':
+				length = i + 1
+				st = 375
+			case 'r':
+				st = 376
+			default:
+				return length
+			}
+
+		case 371:
+			switch byteToLower(b) {
+			case 't':
+				st = 372
+			default:
+				return length
+			}
+
+		case 372:
+			switch byteToLower(b) {
+			case 'e':
+				st = 373
+			default:
+				return length
+			}
+
+		case 373:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 374
+			default:
+				return length
+			}
+
+		case 376:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 377
+			default:
+				return length
+			}
+
+		case 378:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 379
+			case 'd':
+				length = i + 1
+				st = 380
+			default:
+				return length
+			}
+
+		case 382:
+			switch byteToLower(b) {
+			case 'a':
+				st = 383
+			case 'e':
+				st = 389
+			case 'l':
+				st = 392
+			case 'r':
+				st = 395
+			case 'u':
+				st = 405
+			default:
+				return length
+			}
+
+		case 383:
+			switch byteToLower(b) {
+			case 'n':
+				st = 384
+			case 't':
+				length = i + 1
+				st = 388
+			default:
+				return length
+			}
+
+		case 384:
+			switch byteToLower(b) {
+			case 'n':
+				st = 385
+			default:
+				return length
+			}
+
+		case 385:
+			switch byteToLower(b) {
+			case 'e':
+				st = 386
+			default:
+				return length
+			}
+
+		case 386:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 387
+			default:
+				return length
+			}
+
+		case 389:
+			switch byteToLower(b) {
+			case 'a':
+				st = 390
+			default:
+				return length
+			}
+
+		case 390:
+			switch byteToLower(b) {
+			case 'p':
+				length = i + 1
+				st = 391
+			default:
+				return length
+			}
+
+		case 392:
+			switch byteToLower(b) {
+			case 'o':
+				st = 393
+			default:
+				return length
+			}
+
+		case 393:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 394
+			default:
+				return length
+			}
+
+		case 395:
+			switch byteToLower(b) {
+			case 'i':
+				st = 396
+			case 'o':
+				st = 402
+			default:
+				return length
+			}
+
+		case 396:
+			switch byteToLower(b) {
+			case 's':
+				st = 397
+			default:
+				return length
+			}
+
+		case 397:
+			switch byteToLower(b) {
+			case 't':
+				st = 398
+			default:
+				return length
+			}
+
+		case 398:
+			switch byteToLower(b) {
+			case 'm':
+				st = 399
+			default:
+				return length
+			}
+
+		case 399:
+			switch byteToLower(b) {
+			case 'a':
+				st = 400
+			default:
+				return length
+			}
+
+		case 400:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 401
+			default:
+				return length
+			}
+
+		case 402:
+			switch byteToLower(b) {
+			case 'm':
+				st = 403
+			default:
+				return length
+			}
+
+		case 403:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 404
+			default:
+				return length
+			}
+
+		case 405:
+			switch byteToLower(b) {
+			case 'r':
+				st = 406
+			default:
+				return length
+			}
+
+		case 406:
+			switch byteToLower(b) {
+			case 'c':
+				st = 407
+			default:
+				return length
+			}
+
+		case 407:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 408
+			default:
+				return length
+			}
+
+		case 409:
+			switch byteToLower(b) {
+			case 's':
+				st = 410
+			case 't':
+				st = 413
+			default:
+				return length
+			}
+
+		case 410:
+			switch byteToLower(b) {
+			case 'c':
+				st = 411
+			default:
+				return length
+			}
+
+		case 411:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 412
+			default:
+				return length
+			}
+
+		case 413:
+			switch byteToLower(b) {
+			case 'i':
+				st = 414
+			case 'y':
+				length = i + 1
+				st = 416
+			default:
+				return length
+			}
+
+		case 414:
+			switch byteToLower(b) {
+			case 'c':
+				length = i + 1
+				st = 415
+			default:
+				return length
+			}
+
+		case 418:
+			switch byteToLower(b) {
+			case 'a':
+				st = 419
+			case 'e':
+				st = 423
+			case 'i':
+				st = 429
+			case 'o':
+				st = 435
+			case 'u':
+				st = 441
+			default:
+				return length
+			}
+
+		case 419:
+			switch byteToLower(b) {
+			case 'i':
+				st = 420
+			default:
+				return length
+			}
+
+		case 420:
+			switch byteToLower(b) {
+			case 'm':
+				st = 421
+			default:
+				return length
+			}
+
+		case 421:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 422
+			default:
+				return length
+			}
+
+		case 423:
+			switch byteToLower(b) {
+			case 'a':
+				st = 424
+			default:
+				return length
+			}
+
+		case 424:
+			switch byteToLower(b) {
+			case 'n':
+				st = 425
+			default:
+				return length
+			}
+
+		case 425:
+			switch byteToLower(b) {
+			case 'i':
+				st = 426
+			default:
+				return length
+			}
+
+		case 426:
+			switch byteToLower(b) {
+			case 'n':
+				st = 427
+			default:
+				return length
+			}
+
+		case 427:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 428
+			default:
+				return length
+			}
+
+		case 429:
+			switch byteToLower(b) {
+			case 'c':
+				st = 430
+			case 'n':
+				st = 432
+			default:
+				return length
+			}
+
+		case 430:
+			switch byteToLower(b) {
+			case 'k':
+				length = i + 1
+				st = 431
+			default:
+				return length
+			}
+
+		case 432:
+			switch byteToLower(b) {
+			case 'i':
+				st = 433
+			default:
+				return length
+			}
+
+		case 433:
+			switch byteToLower(b) {
+			case 'c':
+				length = i + 1
+				st = 434
+			default:
+				return length
+			}
+
+		case 435:
+			switch byteToLower(b) {
+			case 't':
+				st = 436
+			default:
+				return length
+			}
+
+		case 436:
+			switch byteToLower(b) {
+			case 'h':
+				st = 437
+			default:
+				return length
+			}
+
+		case 437:
+			switch byteToLower(b) {
+			case 'i':
+				st = 438
+			default:
+				return length
+			}
+
+		case 438:
+			switch byteToLower(b) {
+			case 'n':
+				st = 439
+			default:
+				return length
+			}
+
+		case 439:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 440
+			default:
+				return length
+			}
+
+		case 441:
+			switch byteToLower(b) {
+			case 'b':
+				length = i + 1
+				st = 442
+			default:
+				return length
+			}
+
+		case 445:
+			switch byteToLower(b) {
+			case 'a':
+				st = 446
+			case 'd':
+				st = 449
+			case 'f':
+				st = 452
+			case 'l':
+				st = 456
+			case 'm':
+				length = i + 1
+				st = 465
+			case 'n':
+				st = 480
+			case 'o':
+				st = 507
+			case 'r':
+				st = 514
+			case 'u':
+				st = 519
+			default:
+				return length
+			}
+
+		case 446:
+			switch byteToLower(b) {
+			case 'c':
+				st = 447
+			default:
+				return length
+			}
+
+		case 447:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 448
+			default:
+				return length
+			}
+
+		case 449:
+			switch byteToLower(b) {
+			case 'e':
+				st = 450
+			default:
+				return length
+			}
+
+		case 450:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 451
+			default:
+				return length
+			}
+
+		case 452:
+			switch byteToLower(b) {
+			case 'f':
+				st = 453
+			default:
+				return length
+			}
+
+		case 453:
+			switch byteToLower(b) {
+			case 'e':
+				st = 454
+			default:
+				return length
+			}
+
+		case 454:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 455
+			default:
+				return length
+			}
+
+		case 456:
+			switch byteToLower(b) {
+			case 'l':
+				st = 457
+			case 'o':
+				st = 461
+			default:
+				return length
+			}
+
+		case 457:
+			switch byteToLower(b) {
+			case 'e':
+				st = 458
+			default:
+				return length
+			}
+
+		case 458:
+			switch byteToLower(b) {
+			case 'g':
+				st = 459
+			default:
+				return length
+			}
+
+		case 459:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 460
+			default:
+				return length
+			}
+
+		case 461:
+			switch byteToLower(b) {
+			case 'g':
+				st = 462
+			default:
+				return length
+			}
+
+		case 462:
+			switch byteToLower(b) {
+			case 'n':
+				st = 463
+			default:
+				return length
+			}
+
+		case 463:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 464
+			default:
+				return length
+			}
+
+		case 465:
+			switch byteToLower(b) {
+			case 'm':
+				st = 466
+			case 'p':
+				st = 472
+			default:
+				return length
+			}
+
+		case 466:
+			switch byteToLower(b) {
+			case 'u':
+				st = 467
+			default:
+				return length
+			}
+
+		case 467:
+			switch byteToLower(b) {
+			case 'n':
+				st = 468
+			default:
+				return length
+			}
+
+		case 468:
+			switch byteToLower(b) {
+			case 'i':
+				st = 469
+			default:
+				return length
+			}
+
+		case 469:
+			switch byteToLower(b) {
+			case 't':
+				st = 470
+			default:
+				return length
+			}
+
+		case 470:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 471
+			default:
+				return length
+			}
+
+		case 472:
+			switch byteToLower(b) {
+			case 'a':
+				st = 473
+			case 'u':
+				st = 476
+			default:
+				return length
+			}
+
+		case 473:
+			switch byteToLower(b) {
+			case 'n':
+				st = 474
+			default:
+				return length
+			}
+
+		case 474:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 475
+			default:
+				return length
+			}
+
+		case 476:
+			switch byteToLower(b) {
+			case 't':
+				st = 477
+			default:
+				return length
+			}
+
+		case 477:
+			switch byteToLower(b) {
+			case 'e':
+				st = 478
+			default:
+				return length
+			}
+
+		case 478:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 479
+			default:
+				return length
+			}
+
+		case 480:
+			switch byteToLower(b) {
+			case 'd':
+				st = 481
+			case 's':
+				st = 484
+			case 't':
+				st = 499
+			default:
+				return length
+			}
+
+		case 481:
+			switch byteToLower(b) {
+			case 'o':
+				st = 482
+			default:
+				return length
+			}
+
+		case 482:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 483
+			default:
+				return length
+			}
+
+		case 484:
+			switch byteToLower(b) {
+			case 't':
+				st = 485
+			case 'u':
+				st = 493
+			default:
+				return length
+			}
+
+		case 485:
+			switch byteToLower(b) {
+			case 'r':
+				st = 486
+			default:
+				return length
+			}
+
+		case 486:
+			switch byteToLower(b) {
+			case 'u':
+				st = 487
+			default:
+				return length
+			}
+
+		case 487:
+			switch byteToLower(b) {
+			case 'c':
+				st = 488
+			default:
+				return length
+			}
+
+		case 488:
+			switch byteToLower(b) {
+			case 't':
+				st = 489
+			default:
+				return length
+			}
+
+		case 489:
+			switch byteToLower(b) {
+			case 'i':
+				st = 490
+			default:
+				return length
+			}
+
+		case 490:
+			switch byteToLower(b) {
+			case 'o':
+				st = 491
+			default:
+				return length
+			}
+
+		case 491:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 492
+			default:
+				return length
+			}
+
+		case 493:
+			switch byteToLower(b) {
+			case 'l':
+				st = 494
+			default:
+				return length
+			}
+
+		case 494:
+			switch byteToLower(b) {
+			case 't':
+				st = 495
+			default:
+				return length
+			}
+
+		case 495:
+			switch byteToLower(b) {
+			case 'i':
+				st = 496
+			default:
+				return length
+			}
+
+		case 496:
+			switch byteToLower(b) {
+			case 'n':
+				st = 497
+			default:
+				return length
+			}
+
+		case 497:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 498
+			default:
+				return length
+			}
+
+		case 499:
+			switch byteToLower(b) {
+			case 'r':
+				st = 500
+			default:
+				return length
+			}
+
+		case 500:
+			switch byteToLower(b) {
+			case 'a':
+				st = 501
+			default:
+				return length
+			}
+
+		case 501:
+			switch byteToLower(b) {
+			case 'c':
+				st = 502
+			default:
+				return length
+			}
+
+		case 502:
+			switch byteToLower(b) {
+			case 't':
+				st = 503
+			default:
+				return length
+			}
+
+		case 503:
+			switch byteToLower(b) {
+			case 'o':
+				st = 504
+			default:
+				return length
+			}
+
+		case 504:
+			switch byteToLower(b) {
+			case 'r':
+				st = 505
+			default:
+				return length
+			}
+
+		case 505:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 506
+			default:
+				return length
+			}
+
+		case 507:
+			switch byteToLower(b) {
+			case 'k':
+				st = 508
+			case 'l':
+				length = i + 1
+				st = 512
+			case 'p':
+				length = i + 1
+				st = 513
+			default:
+				return length
+			}
+
+		case 508:
+			switch byteToLower(b) {
+			case 'i':
+				st = 509
+			default:
+				return length
+			}
+
+		case 509:
+			switch byteToLower(b) {
+			case 'n':
+				st = 510
+			default:
+				return length
+			}
+
+		case 510:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 511
+			default:
+				return length
+			}
+
+		case 514:
+			switch byteToLower(b) {
+			case 's':
+				st = 515
+			default:
+				return length
+			}
+
+		case 515:
+			switch byteToLower(b) {
+			case 'i':
+				st = 516
+			default:
+				return length
+			}
+
+		case 516:
+			switch byteToLower(b) {
+			case 'c':
+				st = 517
+			default:
+				return length
+			}
+
+		case 517:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 518
+			default:
+				return length
+			}
+
+		case 519:
+			switch byteToLower(b) {
+			case 'n':
+				st = 520
+			case 'p':
+				st = 524
+			case 'r':
+				st = 528
+			default:
+				return length
+			}
+
+		case 520:
+			switch byteToLower(b) {
+			case 't':
+				st = 521
+			default:
+				return length
+			}
+
+		case 521:
+			switch byteToLower(b) {
+			case 'r':
+				st = 522
+			default:
+				return length
+			}
+
+		case 522:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 523
+			default:
+				return length
+			}
+
+		case 524:
+			switch byteToLower(b) {
+			case 'o':
+				st = 525
+			default:
+				return length
+			}
+
+		case 525:
+			switch byteToLower(b) {
+			case 'n':
+				st = 526
+			default:
+				return length
+			}
+
+		case 526:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 527
+			default:
+				return length
+			}
+
+		case 528:
+			switch byteToLower(b) {
+			case 's':
+				st = 529
+			default:
+				return length
+			}
+
+		case 529:
+			switch byteToLower(b) {
+			case 'e':
+				st = 530
+			default:
+				return length
+			}
+
+		case 530:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 531
+			default:
+				return length
+			}
+
+		case 532:
+			switch byteToLower(b) {
+			case 'e':
+				st = 533
+			case 'i':
+				st = 541
+			case 's':
+				length = i + 1
+				st = 546
+			case 'u':
+				st = 547
+			default:
+				return length
+			}
+
+		case 533:
+			switch byteToLower(b) {
+			case 'd':
+				st = 534
+			default:
+				return length
+			}
+
+		case 534:
+			switch byteToLower(b) {
+			case 'i':
+				st = 535
+			default:
+				return length
+			}
+
+		case 535:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 536
+			default:
+				return length
+			}
+
+		case 536:
+			switch byteToLower(b) {
+			case 'c':
+				st = 537
+			default:
+				return length
+			}
+
+		case 537:
+			switch byteToLower(b) {
+			case 'a':
+				st = 538
+			default:
+				return length
+			}
+
+		case 538:
+			switch byteToLower(b) {
+			case 'r':
+				st = 539
+			default:
+				return length
+			}
+
+		case 539:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 540
+			default:
+				return length
+			}
+
+		case 541:
+			switch byteToLower(b) {
+			case 'c':
+				st = 542
+			default:
+				return length
+			}
+
+		case 542:
+			switch byteToLower(b) {
+			case 'k':
+				st = 543
+			default:
+				return length
+			}
+
+		case 543:
+			switch byteToLower(b) {
+			case 'e':
+				st = 544
+			default:
+				return length
+			}
+
+		case 544:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 545
+			default:
+				return length
+			}
+
+		case 547:
+			switch byteToLower(b) {
+			case 'i':
+				st = 548
+			default:
+				return length
+			}
+
+		case 548:
+			switch byteToLower(b) {
+			case 's':
+				st = 549
+			default:
+				return length
+			}
+
+		case 549:
+			switch byteToLower(b) {
+			case 'e':
+				st = 550
+			default:
+				return length
+			}
+
+		case 550:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 551
+			default:
+				return length
+			}
+
+		case 552:
+			switch byteToLower(b) {
+			case 'i':
+				st = 553
+			default:
+				return length
+			}
+
+		case 553:
+			switch byteToLower(b) {
+			case 's':
+				st = 554
+			default:
+				return length
+			}
+
+		case 554:
+			switch byteToLower(b) {
+			case 'i':
+				st = 555
+			default:
+				return length
+			}
+
+		case 555:
+			switch byteToLower(b) {
+			case 'n':
+				st = 556
+			default:
+				return length
+			}
+
+		case 556:
+			switch byteToLower(b) {
+			case 'e':
+				st = 557
+			default:
+				return length
+			}
+
+		case 557:
+			switch byteToLower(b) {
+			case 'l':
+				st = 558
+			default:
+				return length
+			}
+
+		case 558:
+			switch byteToLower(b) {
+			case 'l':
+				st = 559
+			default:
+				return length
+			}
+
+		case 559:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 560
+			default:
+				return length
+			}
+
+		case 564:
+			switch byteToLower(b) {
+			case 'm':
+				st = 565
+			case 'o':
+				st = 568
+			default:
+				return length
+			}
+
+		case 565:
+			switch byteToLower(b) {
+			case 'r':
+				st = 566
+			default:
+				return length
+			}
+
+		case 566:
+			switch byteToLower(b) {
+			case 'u':
+				length = i + 1
+				st = 567
+			default:
+				return length
+			}
+
+		case 568:
+			switch byteToLower(b) {
+			case 'u':
+				length = i + 1
+				st = 569
+			default:
+				return length
+			}
+
+		case 571:
+			switch byteToLower(b) {
+			case 'a':
+				st = 572
+			case 'c':
+				st = 589
+			case 'e':
+				length = i + 1
+				st = 592
+			case 'i':
+				st = 624
+			case 'j':
+				length = i + 1
+				st = 651
+			case 'k':
+				length = i + 1
+				st = 652
+			case 'm':
+				length = i + 1
+				st = 653
+			case 'n':
+				st = 654
+			case 'o':
+				length = i + 1
+				st = 656
+			case 'u':
+				st = 677
+			case 'v':
+				st = 682
+			case 'z':
+				length = i + 1
+				st = 685
+			default:
+				return length
+			}
+
+		case 572:
+			switch byteToLower(b) {
+			case 'b':
+				st = 573
+			case 'd':
+				length = i + 1
+				st = 576
+			case 'n':
+				st = 577
+			case 't':
+				st = 580
+			case 'y':
+				length = i + 1
+				st = 588
+			default:
+				return length
+			}
+
+		case 573:
+			switch byteToLower(b) {
+			case 'u':
+				st = 574
+			default:
+				return length
+			}
+
+		case 574:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 575
+			default:
+				return length
+			}
+
+		case 577:
+			switch byteToLower(b) {
+			case 'c':
+				st = 578
+			default:
+				return length
+			}
+
+		case 578:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 579
+			default:
+				return length
+			}
+
+		case 580:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 581
+			case 'i':
+				st = 582
+			case 's':
+				st = 585
+			default:
+				return length
+			}
+
+		case 582:
+			switch byteToLower(b) {
+			case 'n':
+				st = 583
+			default:
+				return length
+			}
+
+		case 583:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 584
+			default:
+				return length
+			}
+
+		case 585:
+			switch byteToLower(b) {
+			case 'u':
+				st = 586
+			default:
+				return length
+			}
+
+		case 586:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 587
+			default:
+				return length
+			}
+
+		case 589:
+			switch byteToLower(b) {
+			case 'l':
+				st = 590
+			default:
+				return length
+			}
+
+		case 590:
+			switch byteToLower(b) {
+			case 'k':
+				length = i + 1
+				st = 591
+			default:
+				return length
+			}
+
+		case 592:
+			switch byteToLower(b) {
+			case 'a':
+				st = 593
+			case 'g':
+				st = 596
+			case 'l':
+				st = 600
+			case 'm':
+				st = 606
+			case 'n':
+				st = 612
+			case 's':
+				st = 619
+			case 'v':
+				length = i + 1
+				st = 623
+			default:
+				return length
+			}
+
+		case 593:
+			switch byteToLower(b) {
+			case 'l':
+				st = 594
+			default:
+				return length
+			}
+
+		case 594:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 595
+			default:
+				return length
+			}
+
+		case 596:
+			switch byteToLower(b) {
+			case 'r':
+				st = 597
+			default:
+				return length
+			}
+
+		case 597:
+			switch byteToLower(b) {
+			case 'e':
+				st = 598
+			default:
+				return length
+			}
+
+		case 598:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 599
+			default:
+				return length
+			}
+
+		case 600:
+			switch byteToLower(b) {
+			case 'i':
+				st = 601
+			default:
+				return length
+			}
+
+		case 601:
+			switch byteToLower(b) {
+			case 'v':
+				st = 602
+			default:
+				return length
+			}
+
+		case 602:
+			switch byteToLower(b) {
+			case 'e':
+				st = 603
+			default:
+				return length
+			}
+
+		case 603:
+			switch byteToLower(b) {
+			case 'r':
+				st = 604
+			default:
+				return length
+			}
+
+		case 604:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 605
+			default:
+				return length
+			}
+
+		case 606:
+			switch byteToLower(b) {
+			case 'o':
+				st = 607
+			default:
+				return length
+			}
+
+		case 607:
+			switch byteToLower(b) {
+			case 'c':
+				st = 608
+			default:
+				return length
+			}
+
+		case 608:
+			switch byteToLower(b) {
+			case 'r':
+				st = 609
+			default:
+				return length
+			}
+
+		case 609:
+			switch byteToLower(b) {
+			case 'a':
+				st = 610
+			default:
+				return length
+			}
+
+		case 610:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 611
+			default:
+				return length
+			}
+
+		case 612:
+			switch byteToLower(b) {
+			case 't':
+				st = 613
+			default:
+				return length
+			}
+
+		case 613:
+			switch byteToLower(b) {
+			case 'a':
+				st = 614
+			case 'i':
+				st = 616
+			default:
+				return length
+			}
+
+		case 614:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 615
+			default:
+				return length
+			}
+
+		case 616:
+			switch byteToLower(b) {
+			case 's':
+				st = 617
+			default:
+				return length
+			}
+
+		case 617:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 618
+			default:
+				return length
+			}
+
+		case 619:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 620
+			default:
+				return length
+			}
+
+		case 620:
+			switch byteToLower(b) {
+			case 'g':
+				st = 621
+			default:
+				return length
+			}
+
+		case 621:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 622
+			default:
+				return length
+			}
+
+		case 624:
+			switch byteToLower(b) {
+			case 'a':
+				st = 625
+			case 'e':
+				st = 631
+			case 'g':
+				st = 633
+			case 'r':
+				st = 638
+			case 's':
+				st = 645
+			default:
+				return length
+			}
+
+		case 625:
+			switch byteToLower(b) {
+			case 'm':
+				st = 626
+			default:
+				return length
+			}
+
+		case 626:
+			switch byteToLower(b) {
+			case 'o':
+				st = 627
+			default:
+				return length
+			}
+
+		case 627:
+			switch byteToLower(b) {
+			case 'n':
+				st = 628
+			default:
+				return length
+			}
+
+		case 628:
+			switch byteToLower(b) {
+			case 'd':
+				st = 629
+			default:
+				return length
+			}
+
+		case 629:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 630
+			default:
+				return length
+			}
+
+		case 631:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 632
+			default:
+				return length
+			}
+
+		case 633:
+			switch byteToLower(b) {
+			case 'i':
+				st = 634
+			default:
+				return length
+			}
+
+		case 634:
+			switch byteToLower(b) {
+			case 't':
+				st = 635
+			default:
+				return length
+			}
+
+		case 635:
+			switch byteToLower(b) {
+			case 'a':
+				st = 636
+			default:
+				return length
+			}
+
+		case 636:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 637
+			default:
+				return length
+			}
+
+		case 638:
+			switch byteToLower(b) {
+			case 'e':
+				st = 639
+			default:
+				return length
+			}
+
+		case 639:
+			switch byteToLower(b) {
+			case 'c':
+				st = 640
+			default:
+				return length
+			}
+
+		case 640:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 641
+			default:
+				return length
+			}
+
+		case 641:
+			switch byteToLower(b) {
+			case 'o':
+				st = 642
+			default:
+				return length
+			}
+
+		case 642:
+			switch byteToLower(b) {
+			case 'r':
+				st = 643
+			default:
+				return length
+			}
+
+		case 643:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 644
+			default:
+				return length
+			}
+
+		case 645:
+			switch byteToLower(b) {
+			case 'c':
+				st = 646
+			default:
+				return length
+			}
+
+		case 646:
+			switch byteToLower(b) {
+			case 'o':
+				st = 647
+			default:
+				return length
+			}
+
+		case 647:
+			switch byteToLower(b) {
+			case 'u':
+				st = 648
+			default:
+				return length
+			}
+
+		case 648:
+			switch byteToLower(b) {
+			case 'n':
+				st = 649
+			default:
+				return length
+			}
+
+		case 649:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 650
+			default:
+				return length
+			}
+
+		case 654:
+			switch byteToLower(b) {
+			case 'p':
+				length = i + 1
+				st = 655
+			default:
+				return length
+			}
+
+		case 656:
+			switch byteToLower(b) {
+			case 'c':
+				st = 657
+			case 'g':
+				length = i + 1
+				st = 659
+			case 'h':
+				st = 660
+			case 'm':
+				st = 662
+			case 'o':
+				st = 667
+			case 'w':
+				st = 671
+			default:
+				return length
+			}
+
+		case 657:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 658
+			default:
+				return length
+			}
+
+		case 660:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 661
+			default:
+				return length
+			}
+
+		case 662:
+			switch byteToLower(b) {
+			case 'a':
+				st = 663
+			default:
+				return length
+			}
+
+		case 663:
+			switch byteToLower(b) {
+			case 'i':
+				st = 664
+			default:
+				return length
+			}
+
+		case 664:
+			switch byteToLower(b) {
+			case 'n':
+				st = 665
+			default:
+				return length
+			}
+
+		case 665:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 666
+			default:
+				return length
+			}
+
+		case 667:
+			switch byteToLower(b) {
+			case 's':
+				st = 668
+			default:
+				return length
+			}
+
+		case 668:
+			switch byteToLower(b) {
+			case 'a':
+				st = 669
+			default:
+				return length
+			}
+
+		case 669:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 670
+			default:
+				return length
+			}
+
+		case 671:
+			switch byteToLower(b) {
+			case 'n':
+				st = 672
+			default:
+				return length
+			}
+
+		case 672:
+			switch byteToLower(b) {
+			case 'l':
+				st = 673
+			default:
+				return length
+			}
+
+		case 673:
+			switch byteToLower(b) {
+			case 'o':
+				st = 674
+			default:
+				return length
+			}
+
+		case 674:
+			switch byteToLower(b) {
+			case 'a':
+				st = 675
+			default:
+				return length
+			}
+
+		case 675:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 676
+			default:
+				return length
+			}
+
+		case 677:
+			switch byteToLower(b) {
+			case 'r':
+				st = 678
+			default:
+				return length
+			}
+
+		case 678:
+			switch byteToLower(b) {
+			case 'b':
+				st = 679
+			default:
+				return length
+			}
+
+		case 679:
+			switch byteToLower(b) {
+			case 'a':
+				st = 680
+			default:
+				return length
+			}
+
+		case 680:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 681
+			default:
+				return length
+			}
+
+		case 682:
+			switch byteToLower(b) {
+			case 'a':
+				st = 683
+			default:
+				return length
+			}
+
+		case 683:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 684
+			default:
+				return length
+			}
+
+		case 686:
+			switch byteToLower(b) {
+			case 'a':
+				st = 687
+			case 'c':
+				length = i + 1
+				st = 692
+			case 'd':
+				st = 693
+			case 'e':
+				length = i + 1
+				st = 701
+			case 'g':
+				length = i + 1
+				st = 702
+			case 'm':
+				st = 703
+			case 'n':
+				st = 711
+			case 'p':
+				st = 734
+			case 'q':
+				st = 738
+			case 'r':
+				length = i + 1
+				st = 746
+			case 's':
+				length = i + 1
+				st = 749
+			case 't':
+				length = i + 1
+				st = 755
+			case 'u':
+				length = i + 1
+				st = 756
+			case 'v':
+				st = 766
+			case 'x':
+				st = 776
+			default:
+				return length
+			}
+
+		case 687:
+			switch byteToLower(b) {
+			case 'r':
+				st = 688
+			case 't':
+				length = i + 1
+				st = 691
+			default:
+				return length
+			}
+
+		case 688:
+			switch byteToLower(b) {
+			case 't':
+				st = 689
+			default:
+				return length
+			}
+
+		case 689:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 690
+			default:
+				return length
+			}
+
+		case 693:
+			switch byteToLower(b) {
+			case 'u':
+				length = i + 1
+				st = 694
+			default:
+				return length
+			}
+
+		case 694:
+			switch byteToLower(b) {
+			case 'c':
+				st = 695
+			default:
+				return length
+			}
+
+		case 695:
+			switch byteToLower(b) {
+			case 'a':
+				st = 696
+			default:
+				return length
+			}
+
+		case 696:
+			switch byteToLower(b) {
+			case 't':
+				st = 697
+			default:
+				return length
+			}
+
+		case 697:
+			switch byteToLower(b) {
+			case 'i':
+				st = 698
+			default:
+				return length
+			}
+
+		case 698:
+			switch byteToLower(b) {
+			case 'o':
+				st = 699
+			default:
+				return length
+			}
+
+		case 699:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 700
+			default:
+				return length
+			}
+
+		case 703:
+			switch byteToLower(b) {
+			case 'a':
+				st = 704
+			case 'e':
+				st = 707
+			default:
+				return length
+			}
+
+		case 704:
+			switch byteToLower(b) {
+			case 'i':
+				st = 705
+			default:
+				return length
+			}
+
+		case 705:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 706
+			default:
+				return length
+			}
+
+		case 707:
+			switch byteToLower(b) {
+			case 'r':
+				st = 708
+			default:
+				return length
+			}
+
+		case 708:
+			switch byteToLower(b) {
+			case 'c':
+				st = 709
+			default:
+				return length
+			}
+
+		case 709:
+			switch byteToLower(b) {
+			case 'k':
+				length = i + 1
+				st = 710
+			default:
+				return length
+			}
+
+		case 711:
+			switch byteToLower(b) {
+			case 'e':
+				st = 712
+			case 'g':
+				st = 716
+			case 't':
+				st = 725
+			default:
+				return length
+			}
+
+		case 712:
+			switch byteToLower(b) {
+			case 'r':
+				st = 713
+			default:
+				return length
+			}
+
+		case 713:
+			switch byteToLower(b) {
+			case 'g':
+				st = 714
+			default:
+				return length
+			}
+
+		case 714:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 715
+			default:
+				return length
+			}
+
+		case 716:
+			switch byteToLower(b) {
+			case 'i':
+				st = 717
+			default:
+				return length
+			}
+
+		case 717:
+			switch byteToLower(b) {
+			case 'n':
+				st = 718
+			default:
+				return length
+			}
+
+		case 718:
+			switch byteToLower(b) {
+			case 'e':
+				st = 719
+			default:
+				return length
+			}
+
+		case 719:
+			switch byteToLower(b) {
+			case 'e':
+				st = 720
+			default:
+				return length
+			}
+
+		case 720:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 721
+			default:
+				return length
+			}
+
+		case 721:
+			switch byteToLower(b) {
+			case 'i':
+				st = 722
+			default:
+				return length
+			}
+
+		case 722:
+			switch byteToLower(b) {
+			case 'n':
+				st = 723
+			default:
+				return length
+			}
+
+		case 723:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 724
+			default:
+				return length
+			}
+
+		case 725:
+			switch byteToLower(b) {
+			case 'e':
+				st = 726
+			default:
+				return length
+			}
+
+		case 726:
+			switch byteToLower(b) {
+			case 'r':
+				st = 727
+			default:
+				return length
+			}
+
+		case 727:
+			switch byteToLower(b) {
+			case 'p':
+				st = 728
+			default:
+				return length
+			}
+
+		case 728:
+			switch byteToLower(b) {
+			case 'r':
+				st = 729
+			default:
+				return length
+			}
+
+		case 729:
+			switch byteToLower(b) {
+			case 'i':
+				st = 730
+			default:
+				return length
+			}
+
+		case 730:
+			switch byteToLower(b) {
+			case 's':
+				st = 731
+			default:
+				return length
+			}
+
+		case 731:
+			switch byteToLower(b) {
+			case 'e':
+				st = 732
+			default:
+				return length
+			}
+
+		case 732:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 733
+			default:
+				return length
+			}
+
+		case 734:
+			switch byteToLower(b) {
+			case 's':
+				st = 735
+			default:
+				return length
+			}
+
+		case 735:
+			switch byteToLower(b) {
+			case 'o':
+				st = 736
+			default:
+				return length
+			}
+
+		case 736:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 737
+			default:
+				return length
+			}
+
+		case 738:
+			switch byteToLower(b) {
+			case 'u':
+				st = 739
+			default:
+				return length
+			}
+
+		case 739:
+			switch byteToLower(b) {
+			case 'i':
+				st = 740
+			default:
+				return length
+			}
+
+		case 740:
+			switch byteToLower(b) {
+			case 'p':
+				st = 741
+			default:
+				return length
+			}
+
+		case 741:
+			switch byteToLower(b) {
+			case 'm':
+				st = 742
+			default:
+				return length
+			}
+
+		case 742:
+			switch byteToLower(b) {
+			case 'e':
+				st = 743
+			default:
+				return length
+			}
+
+		case 743:
+			switch byteToLower(b) {
+			case 'n':
+				st = 744
+			default:
+				return length
+			}
+
+		case 744:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 745
+			default:
+				return length
+			}
+
+		case 746:
+			switch byteToLower(b) {
+			case 'n':
+				st = 747
+			default:
+				return length
+			}
+
+		case 747:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 748
+			default:
+				return length
+			}
+
+		case 749:
+			switch byteToLower(b) {
+			case 'q':
+				length = i + 1
+				st = 750
+			case 't':
+				st = 751
+			default:
+				return length
+			}
+
+		case 751:
+			switch byteToLower(b) {
+			case 'a':
+				st = 752
+			default:
+				return length
+			}
+
+		case 752:
+			switch byteToLower(b) {
+			case 't':
+				st = 753
+			default:
+				return length
+			}
+
+		case 753:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 754
+			default:
+				return length
+			}
+
+		case 756:
+			switch byteToLower(b) {
+			case 'r':
+				st = 757
+			case 's':
+				length = i + 1
+				st = 765
+			default:
+				return length
+			}
+
+		case 757:
+			switch byteToLower(b) {
+			case 'o':
+				st = 758
+			default:
+				return length
+			}
+
+		case 758:
+			switch byteToLower(b) {
+			case 'v':
+				st = 759
+			default:
+				return length
+			}
+
+		case 759:
+			switch byteToLower(b) {
+			case 'i':
+				st = 760
+			default:
+				return length
+			}
+
+		case 760:
+			switch byteToLower(b) {
+			case 's':
+				st = 761
+			default:
+				return length
+			}
+
+		case 761:
+			switch byteToLower(b) {
+			case 'i':
+				st = 762
+			default:
+				return length
+			}
+
+		case 762:
+			switch byteToLower(b) {
+			case 'o':
+				st = 763
+			default:
+				return length
+			}
+
+		case 763:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 764
+			default:
+				return length
+			}
+
+		case 766:
+			switch byteToLower(b) {
+			case 'e':
+				st = 767
+			default:
+				return length
+			}
+
+		case 767:
+			switch byteToLower(b) {
+			case 'n':
+				st = 768
+			case 'r':
+				st = 771
+			default:
+				return length
+			}
+
+		case 768:
+			switch byteToLower(b) {
+			case 't':
+				st = 769
+			default:
+				return length
+			}
+
+		case 769:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 770
+			default:
+				return length
+			}
+
+		case 771:
+			switch byteToLower(b) {
+			case 'b':
+				st = 772
+			default:
+				return length
+			}
+
+		case 772:
+			switch byteToLower(b) {
+			case 'a':
+				st = 773
+			default:
+				return length
+			}
+
+		case 773:
+			switch byteToLower(b) {
+			case 'n':
+				st = 774
+			default:
+				return length
+			}
+
+		case 774:
+			switch byteToLower(b) {
+			case 'k':
+				length = i + 1
+				st = 775
+			default:
+				return length
+			}
+
+		case 776:
+			switch byteToLower(b) {
+			case 'c':
+				st = 777
+			case 'i':
+				st = 783
+			case 'p':
+				st = 785
+			default:
+				return length
+			}
+
+		case 777:
+			switch byteToLower(b) {
+			case 'h':
+				st = 778
+			default:
+				return length
+			}
+
+		case 778:
+			switch byteToLower(b) {
+			case 'a':
+				st = 779
+			default:
+				return length
+			}
+
+		case 779:
+			switch byteToLower(b) {
+			case 'n':
+				st = 780
+			default:
+				return length
+			}
+
+		case 780:
+			switch byteToLower(b) {
+			case 'g':
+				st = 781
+			default:
+				return length
+			}
+
+		case 781:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 782
+			default:
+				return length
+			}
+
+		case 783:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 784
+			default:
+				return length
+			}
+
+		case 785:
+			switch byteToLower(b) {
+			case 'e':
+				st = 786
+			case 'o':
+				st = 789
+			case 'r':
+				st = 793
+			default:
+				return length
+			}
+
+		case 786:
+			switch byteToLower(b) {
+			case 'r':
+				st = 787
+			default:
+				return length
+			}
+
+		case 787:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 788
+			default:
+				return length
+			}
+
+		case 789:
+			switch byteToLower(b) {
+			case 's':
+				st = 790
+			default:
+				return length
+			}
+
+		case 790:
+			switch byteToLower(b) {
+			case 'e':
+				st = 791
+			default:
+				return length
+			}
+
+		case 791:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 792
+			default:
+				return length
+			}
+
+		case 793:
+			switch byteToLower(b) {
+			case 'e':
+				st = 794
+			default:
+				return length
+			}
+
+		case 794:
+			switch byteToLower(b) {
+			case 's':
+				st = 795
+			default:
+				return length
+			}
+
+		case 795:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 796
+			default:
+				return length
+			}
+
+		case 797:
+			switch byteToLower(b) {
+			case 'a':
+				st = 798
+			case 'e':
+				st = 812
+			case 'i':
+				length = i + 1
+				st = 819
+			case 'j':
+				length = i + 1
+				st = 846
+			case 'k':
+				length = i + 1
+				st = 847
+			case 'l':
+				st = 848
+			case 'm':
+				length = i + 1
+				st = 870
+			case 'o':
+				length = i + 1
+				st = 871
+			case 'r':
+				length = i + 1
+				st = 893
+			case 'u':
+				st = 900
+			case 'y':
+				st = 914
+			default:
+				return length
+			}
+
+		case 798:
+			switch byteToLower(b) {
+			case 'i':
+				st = 799
+			case 'n':
+				length = i + 1
+				st = 803
+			case 'r':
+				st = 805
+			case 's':
+				st = 807
+			default:
+				return length
+			}
+
+		case 799:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 800
+			case 't':
+				st = 801
+			default:
+				return length
+			}
+
+		case 801:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 802
+			default:
+				return length
+			}
+
+		case 803:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 804
+			default:
+				return length
+			}
+
+		case 805:
+			switch byteToLower(b) {
+			case 'm':
+				length = i + 1
+				st = 806
+			default:
+				return length
+			}
+
+		case 807:
+			switch byteToLower(b) {
+			case 'h':
+				st = 808
+			default:
+				return length
+			}
+
+		case 808:
+			switch byteToLower(b) {
+			case 'i':
+				st = 809
+			default:
+				return length
+			}
+
+		case 809:
+			switch byteToLower(b) {
+			case 'o':
+				st = 810
+			default:
+				return length
+			}
+
+		case 810:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 811
+			default:
+				return length
+			}
+
+		case 812:
+			switch byteToLower(b) {
+			case 'e':
+				st = 813
+			default:
+				return length
+			}
+
+		case 813:
+			switch byteToLower(b) {
+			case 'd':
+				st = 814
+			default:
+				return length
+			}
+
+		case 814:
+			switch byteToLower(b) {
+			case 'b':
+				st = 815
+			default:
+				return length
+			}
+
+		case 815:
+			switch byteToLower(b) {
+			case 'a':
+				st = 816
+			default:
+				return length
+			}
+
+		case 816:
+			switch byteToLower(b) {
+			case 'c':
+				st = 817
+			default:
+				return length
+			}
+
+		case 817:
+			switch byteToLower(b) {
+			case 'k':
+				length = i + 1
+				st = 818
+			default:
+				return length
+			}
+
+		case 819:
+			switch byteToLower(b) {
+			case 'l':
+				st = 820
+			case 'n':
+				st = 822
+			case 'r':
+				st = 830
+			case 's':
+				st = 836
+			case 't':
+				length = i + 1
+				st = 841
+			default:
+				return length
+			}
+
+		case 820:
+			switch byteToLower(b) {
+			case 'm':
+				length = i + 1
+				st = 821
+			default:
+				return length
+			}
+
+		case 822:
+			switch byteToLower(b) {
+			case 'a':
+				st = 823
+			default:
+				return length
+			}
+
+		case 823:
+			switch byteToLower(b) {
+			case 'n':
+				st = 824
+			default:
+				return length
+			}
+
+		case 824:
+			switch byteToLower(b) {
+			case 'c':
+				st = 825
+			default:
+				return length
+			}
+
+		case 825:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 826
+			case 'i':
+				st = 827
+			default:
+				return length
+			}
+
+		case 827:
+			switch byteToLower(b) {
+			case 'a':
+				st = 828
+			default:
+				return length
+			}
+
+		case 828:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 829
+			default:
+				return length
+			}
+
+		case 830:
+			switch byteToLower(b) {
+			case 'm':
+				st = 831
+			default:
+				return length
+			}
+
+		case 831:
+			switch byteToLower(b) {
+			case 'd':
+				st = 832
+			default:
+				return length
+			}
+
+		case 832:
+			switch byteToLower(b) {
+			case 'a':
+				st = 833
+			default:
+				return length
+			}
+
+		case 833:
+			switch byteToLower(b) {
+			case 'l':
+				st = 834
+			default:
+				return length
+			}
+
+		case 834:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 835
+			default:
+				return length
+			}
+
+		case 836:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 837
+			default:
+				return length
+			}
+
+		case 837:
+			switch byteToLower(b) {
+			case 'i':
+				st = 838
+			default:
+				return length
+			}
+
+		case 838:
+			switch byteToLower(b) {
+			case 'n':
+				st = 839
+			default:
+				return length
+			}
+
+		case 839:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 840
+			default:
+				return length
+			}
+
+		case 841:
+			switch byteToLower(b) {
+			case 'n':
+				st = 842
+			default:
+				return length
+			}
+
+		case 842:
+			switch byteToLower(b) {
+			case 'e':
+				st = 843
+			default:
+				return length
+			}
+
+		case 843:
+			switch byteToLower(b) {
+			case 's':
+				st = 844
+			default:
+				return length
+			}
+
+		case 844:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 845
+			default:
+				return length
+			}
+
+		case 848:
+			switch byteToLower(b) {
+			case 'i':
+				st = 849
+			case 'o':
+				st = 854
+			case 's':
+				st = 863
+			case 'y':
+				length = i + 1
+				st = 869
+			default:
+				return length
+			}
+
+		case 849:
+			switch byteToLower(b) {
+			case 'g':
+				st = 850
+			default:
+				return length
+			}
+
+		case 850:
+			switch byteToLower(b) {
+			case 'h':
+				st = 851
+			default:
+				return length
+			}
+
+		case 851:
+			switch byteToLower(b) {
+			case 't':
+				st = 852
+			default:
+				return length
+			}
+
+		case 852:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 853
+			default:
+				return length
+			}
+
+		case 854:
+			switch byteToLower(b) {
+			case 'r':
+				st = 855
+			case 'w':
+				st = 859
+			default:
+				return length
+			}
+
+		case 855:
+			switch byteToLower(b) {
+			case 'i':
+				st = 856
+			default:
+				return length
+			}
+
+		case 856:
+			switch byteToLower(b) {
+			case 's':
+				st = 857
+			default:
+				return length
+			}
+
+		case 857:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 858
+			default:
+				return length
+			}
+
+		case 859:
+			switch byteToLower(b) {
+			case 'e':
+				st = 860
+			default:
+				return length
+			}
+
+		case 860:
+			switch byteToLower(b) {
+			case 'r':
+				st = 861
+			default:
+				return length
+			}
+
+		case 861:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 862
+			default:
+				return length
+			}
+
+		case 863:
+			switch byteToLower(b) {
+			case 'm':
+				st = 864
+			default:
+				return length
+			}
+
+		case 864:
+			switch byteToLower(b) {
+			case 'i':
+				st = 865
+			default:
+				return length
+			}
+
+		case 865:
+			switch byteToLower(b) {
+			case 'd':
+				st = 866
+			default:
+				return length
+			}
+
+		case 866:
+			switch byteToLower(b) {
+			case 't':
+				st = 867
+			default:
+				return length
+			}
+
+		case 867:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 868
+			default:
+				return length
+			}
+
+		case 871:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 872
+			case 'r':
+				st = 878
+			case 'u':
+				st = 885
+			default:
+				return length
+			}
+
+		case 872:
+			switch byteToLower(b) {
+			case 't':
+				st = 873
+			default:
+				return length
+			}
+
+		case 873:
+			switch byteToLower(b) {
+			case 'b':
+				st = 874
+			default:
+				return length
+			}
+
+		case 874:
+			switch byteToLower(b) {
+			case 'a':
+				st = 875
+			default:
+				return length
+			}
+
+		case 875:
+			switch byteToLower(b) {
+			case 'l':
+				st = 876
+			default:
+				return length
+			}
+
+		case 876:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 877
+			default:
+				return length
+			}
+
+		case 878:
+			switch byteToLower(b) {
+			case 'e':
+				st = 879
+			case 's':
+				st = 881
+			default:
+				return length
+			}
+
+		case 879:
+			switch byteToLower(b) {
+			case 'x':
+				length = i + 1
+				st = 880
+			default:
+				return length
+			}
+
+		case 881:
+			switch byteToLower(b) {
+			case 'a':
+				st = 882
+			default:
+				return length
+			}
+
+		case 882:
+			switch byteToLower(b) {
+			case 'l':
+				st = 883
+			default:
+				return length
+			}
+
+		case 883:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 884
+			default:
+				return length
+			}
+
+		case 885:
+			switch byteToLower(b) {
+			case 'n':
+				st = 886
+			default:
+				return length
+			}
+
+		case 886:
+			switch byteToLower(b) {
+			case 'd':
+				st = 887
+			default:
+				return length
+			}
+
+		case 887:
+			switch byteToLower(b) {
+			case 'a':
+				st = 888
+			default:
+				return length
+			}
+
+		case 888:
+			switch byteToLower(b) {
+			case 't':
+				st = 889
+			default:
+				return length
+			}
+
+		case 889:
+			switch byteToLower(b) {
+			case 'i':
+				st = 890
+			default:
+				return length
+			}
+
+		case 890:
+			switch byteToLower(b) {
+			case 'o':
+				st = 891
+			default:
+				return length
+			}
+
+		case 891:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 892
+			default:
+				return length
+			}
+
+		case 893:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 894
+			case 'o':
+				st = 895
+			default:
+				return length
+			}
+
+		case 895:
+			switch byteToLower(b) {
+			case 'g':
+				st = 896
+			default:
+				return length
+			}
+
+		case 896:
+			switch byteToLower(b) {
+			case 'a':
+				st = 897
+			default:
+				return length
+			}
+
+		case 897:
+			switch byteToLower(b) {
+			case 'n':
+				st = 898
+			default:
+				return length
+			}
+
+		case 898:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 899
+			default:
+				return length
+			}
+
+		case 900:
+			switch byteToLower(b) {
+			case 'n':
+				st = 901
+			case 'r':
+				st = 903
+			case 't':
+				st = 910
+			default:
+				return length
+			}
+
+		case 901:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 902
+			default:
+				return length
+			}
+
+		case 903:
+			switch byteToLower(b) {
+			case 'n':
+				st = 904
+			default:
+				return length
+			}
+
+		case 904:
+			switch byteToLower(b) {
+			case 'i':
+				st = 905
+			default:
+				return length
+			}
+
+		case 905:
+			switch byteToLower(b) {
+			case 't':
+				st = 906
+			default:
+				return length
+			}
+
+		case 906:
+			switch byteToLower(b) {
+			case 'u':
+				st = 907
+			default:
+				return length
+			}
+
+		case 907:
+			switch byteToLower(b) {
+			case 'r':
+				st = 908
+			default:
+				return length
+			}
+
+		case 908:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 909
+			default:
+				return length
+			}
+
+		case 910:
+			switch byteToLower(b) {
+			case 'b':
+				st = 911
+			default:
+				return length
+			}
+
+		case 911:
+			switch byteToLower(b) {
+			case 'o':
+				st = 912
+			default:
+				return length
+			}
+
+		case 912:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 913
+			default:
+				return length
+			}
+
+		case 914:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 915
+			default:
+				return length
+			}
+
+		case 916:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 917
+			case 'b':
+				length = i + 1
+				st = 927
+			case 'd':
+				length = i + 1
+				st = 930
+			case 'e':
+				length = i + 1
+				st = 932
+			case 'f':
+				length = i + 1
+				st = 935
+			case 'g':
+				length = i + 1
+				st = 936
+			case 'h':
+				length = i + 1
+				st = 939
+			case 'i':
+				length = i + 1
+				st = 940
+			case 'l':
+				length = i + 1
+				st = 947
+			case 'm':
+				length = i + 1
+				st = 957
+			case 'n':
+				length = i + 1
+				st = 963
+			case 'o':
+				st = 965
+			case 'p':
+				length = i + 1
+				st = 980
+			case 'q':
+				length = i + 1
+				st = 981
+			case 'r':
+				length = i + 1
+				st = 982
+			case 's':
+				length = i + 1
+				st = 998
+			case 't':
+				length = i + 1
+				st = 999
+			case 'u':
+				length = i + 1
+				st = 1000
+			case 'w':
+				length = i + 1
+				st = 1012
+			case 'y':
+				length = i + 1
+				st = 1013
+			default:
+				return length
+			}
+
+		case 917:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 918
+			case 'r':
+				st = 923
+			default:
+				return length
+			}
+
+		case 918:
+			switch byteToLower(b) {
+			case 'l':
+				st = 919
+			default:
+				return length
+			}
+
+		case 919:
+			switch byteToLower(b) {
+			case 'e':
+				st = 920
+			default:
+				return length
+			}
+
+		case 920:
+			switch byteToLower(b) {
+			case 'r':
+				st = 921
+			default:
+				return length
+			}
+
+		case 921:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 922
+			default:
+				return length
+			}
+
+		case 923:
+			switch byteToLower(b) {
+			case 'd':
+				st = 924
+			default:
+				return length
+			}
+
+		case 924:
+			switch byteToLower(b) {
+			case 'e':
+				st = 925
+			default:
+				return length
+			}
+
+		case 925:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 926
+			default:
+				return length
+			}
+
+		case 927:
+			switch byteToLower(b) {
+			case 'i':
+				st = 928
+			default:
+				return length
+			}
+
+		case 928:
+			switch byteToLower(b) {
+			case 'z':
+				length = i + 1
+				st = 929
+			default:
+				return length
+			}
+
+		case 930:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 931
+			default:
+				return length
+			}
+
+		case 932:
+			switch byteToLower(b) {
+			case 'n':
+				st = 933
+			default:
+				return length
+			}
+
+		case 933:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 934
+			default:
+				return length
+			}
+
+		case 936:
+			switch byteToLower(b) {
+			case 'e':
+				st = 937
+			default:
+				return length
+			}
+
+		case 937:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 938
+			default:
+				return length
+			}
+
+		case 940:
+			switch byteToLower(b) {
+			case 'f':
+				st = 941
+			case 'v':
+				st = 944
+			default:
+				return length
+			}
+
+		case 941:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 942
+			default:
+				return length
+			}
+
+		case 942:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 943
+			default:
+				return length
+			}
+
+		case 944:
+			switch byteToLower(b) {
+			case 'e':
+				st = 945
+			default:
+				return length
+			}
+
+		case 945:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 946
+			default:
+				return length
+			}
+
+		case 947:
+			switch byteToLower(b) {
+			case 'a':
+				st = 948
+			case 'e':
+				length = i + 1
+				st = 951
+			case 'o':
+				st = 952
+			default:
+				return length
+			}
+
+		case 948:
+			switch byteToLower(b) {
+			case 's':
+				st = 949
+			default:
+				return length
+			}
+
+		case 949:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 950
+			default:
+				return length
+			}
+
+		case 952:
+			switch byteToLower(b) {
+			case 'b':
+				st = 953
+			default:
+				return length
+			}
+
+		case 953:
+			switch byteToLower(b) {
+			case 'a':
+				st = 954
+			case 'o':
+				length = i + 1
+				st = 956
+			default:
+				return length
+			}
+
+		case 954:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 955
+			default:
+				return length
+			}
+
+		case 957:
+			switch byteToLower(b) {
+			case 'a':
+				st = 958
+			case 'o':
+				length = i + 1
+				st = 961
+			case 'x':
+				length = i + 1
+				st = 962
+			default:
+				return length
+			}
+
+		case 958:
+			switch byteToLower(b) {
+			case 'i':
+				st = 959
+			default:
+				return length
+			}
+
+		case 959:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 960
+			default:
+				return length
+			}
+
+		case 963:
+			switch byteToLower(b) {
+			case 'u':
+				length = i + 1
+				st = 964
+			default:
+				return length
+			}
+
+		case 965:
+			switch byteToLower(b) {
+			case 'l':
+				st = 966
+			case 'o':
+				length = i + 1
+				st = 974
+			case 'p':
+				length = i + 1
+				st = 978
+			case 'v':
+				length = i + 1
+				st = 979
+			default:
+				return length
+			}
+
+		case 966:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 967
+			case 'f':
+				length = i + 1
+				st = 973
+			default:
+				return length
+			}
+
+		case 967:
+			switch byteToLower(b) {
+			case 'p':
+				st = 968
+			default:
+				return length
+			}
+
+		case 968:
+			switch byteToLower(b) {
+			case 'o':
+				st = 969
+			default:
+				return length
+			}
+
+		case 969:
+			switch byteToLower(b) {
+			case 'i':
+				st = 970
+			default:
+				return length
+			}
+
+		case 970:
+			switch byteToLower(b) {
+			case 'n':
+				st = 971
+			default:
+				return length
+			}
+
+		case 971:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 972
+			default:
+				return length
+			}
+
+		case 974:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 975
+			default:
+				return length
+			}
+
+		case 975:
+			switch byteToLower(b) {
+			case 'l':
+				st = 976
+			default:
+				return length
+			}
+
+		case 976:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 977
+			default:
+				return length
+			}
+
+		case 982:
+			switch byteToLower(b) {
+			case 'a':
+				st = 983
+			case 'e':
+				st = 992
+			case 'i':
+				st = 995
+			default:
+				return length
+			}
+
+		case 983:
+			switch byteToLower(b) {
+			case 'p':
+				st = 984
+			case 't':
+				st = 989
+			default:
+				return length
+			}
+
+		case 984:
+			switch byteToLower(b) {
+			case 'h':
+				st = 985
+			default:
+				return length
+			}
+
+		case 985:
+			switch byteToLower(b) {
+			case 'i':
+				st = 986
+			default:
+				return length
+			}
+
+		case 986:
+			switch byteToLower(b) {
+			case 'c':
+				st = 987
+			default:
+				return length
+			}
+
+		case 987:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 988
+			default:
+				return length
+			}
+
+		case 989:
+			switch byteToLower(b) {
+			case 'i':
+				st = 990
+			default:
+				return length
+			}
+
+		case 990:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 991
+			default:
+				return length
+			}
+
+		case 992:
+			switch byteToLower(b) {
+			case 'e':
+				st = 993
+			default:
+				return length
+			}
+
+		case 993:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 994
+			default:
+				return length
+			}
+
+		case 995:
+			switch byteToLower(b) {
+			case 'p':
+				st = 996
+			default:
+				return length
+			}
+
+		case 996:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 997
+			default:
+				return length
+			}
+
+		case 1000:
+			switch byteToLower(b) {
+			case 'g':
+				st = 1001
+			case 'i':
+				st = 1003
+			case 'r':
+				st = 1010
+			default:
+				return length
+			}
+
+		case 1001:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1002
+			default:
+				return length
+			}
+
+		case 1003:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1004
+			case 't':
+				st = 1006
+			default:
+				return length
+			}
+
+		case 1004:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1005
+			default:
+				return length
+			}
+
+		case 1006:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1007
+			default:
+				return length
+			}
+
+		case 1007:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1008
+			default:
+				return length
+			}
+
+		case 1008:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1009
+			default:
+				return length
+			}
+
+		case 1010:
+			switch byteToLower(b) {
+			case 'u':
+				length = i + 1
+				st = 1011
+			default:
+				return length
+			}
+
+		case 1014:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1015
+			case 'e':
+				st = 1028
+			case 'i':
+				st = 1044
+			case 'k':
+				length = i + 1
+				st = 1055
+			case 'm':
+				length = i + 1
+				st = 1056
+			case 'n':
+				length = i + 1
+				st = 1057
+			case 'o':
+				st = 1058
+			case 'r':
+				length = i + 1
+				st = 1096
+			case 't':
+				length = i + 1
+				st = 1097
+			case 'u':
+				length = i + 1
+				st = 1098
+			default:
+				return length
+			}
+
+		case 1015:
+			switch byteToLower(b) {
+			case 'm':
+				st = 1016
+			case 'n':
+				st = 1021
+			case 'u':
+				st = 1026
+			default:
+				return length
+			}
+
+		case 1016:
+			switch byteToLower(b) {
+			case 'b':
+				st = 1017
+			default:
+				return length
+			}
+
+		case 1017:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1018
+			default:
+				return length
+			}
+
+		case 1018:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1019
+			default:
+				return length
+			}
+
+		case 1019:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 1020
+			default:
+				return length
+			}
+
+		case 1021:
+			switch byteToLower(b) {
+			case 'g':
+				st = 1022
+			default:
+				return length
+			}
+
+		case 1022:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1023
+			default:
+				return length
+			}
+
+		case 1023:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1024
+			default:
+				return length
+			}
+
+		case 1024:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1025
+			default:
+				return length
+			}
+
+		case 1026:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1027
+			default:
+				return length
+			}
+
+		case 1028:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1029
+			case 'l':
+				st = 1037
+			case 'r':
+				st = 1039
+			default:
+				return length
+			}
+
+		case 1029:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1030
+			default:
+				return length
+			}
+
+		case 1030:
+			switch byteToLower(b) {
+			case 't':
+				st = 1031
+			default:
+				return length
+			}
+
+		case 1031:
+			switch byteToLower(b) {
+			case 'h':
+				st = 1032
+			default:
+				return length
+			}
+
+		case 1032:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1033
+			default:
+				return length
+			}
+
+		case 1033:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1034
+			default:
+				return length
+			}
+
+		case 1034:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1035
+			default:
+				return length
+			}
+
+		case 1035:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1036
+			default:
+				return length
+			}
+
+		case 1037:
+			switch byteToLower(b) {
+			case 'p':
+				length = i + 1
+				st = 1038
+			default:
+				return length
+			}
+
+		case 1039:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1040
+			case 'm':
+				st = 1041
+			default:
+				return length
+			}
+
+		case 1041:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1042
+			default:
+				return length
+			}
+
+		case 1042:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1043
+			default:
+				return length
+			}
+
+		case 1044:
+			switch byteToLower(b) {
+			case 'p':
+				st = 1045
+			case 't':
+				st = 1049
+			case 'v':
+				length = i + 1
+				st = 1054
+			default:
+				return length
+			}
+
+		case 1045:
+			switch byteToLower(b) {
+			case 'h':
+				st = 1046
+			default:
+				return length
+			}
+
+		case 1046:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1047
+			default:
+				return length
+			}
+
+		case 1047:
+			switch byteToLower(b) {
+			case 'p':
+				length = i + 1
+				st = 1048
+			default:
+				return length
+			}
+
+		case 1049:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1050
+			default:
+				return length
+			}
+
+		case 1050:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1051
+			default:
+				return length
+			}
+
+		case 1051:
+			switch byteToLower(b) {
+			case 'h':
+				st = 1052
+			default:
+				return length
+			}
+
+		case 1052:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 1053
+			default:
+				return length
+			}
+
+		case 1058:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1059
+			case 'l':
+				st = 1063
+			case 'm':
+				st = 1073
+			case 'n':
+				st = 1081
+			case 'r':
+				st = 1084
+			case 's':
+				st = 1087
+			case 'u':
+				st = 1092
+			case 'w':
+				length = i + 1
+				st = 1095
+			default:
+				return length
+			}
+
+		case 1059:
+			switch byteToLower(b) {
+			case 'k':
+				st = 1060
+			default:
+				return length
+			}
+
+		case 1060:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1061
+			default:
+				return length
+			}
+
+		case 1061:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 1062
+			default:
+				return length
+			}
+
+		case 1063:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1064
+			case 'i':
+				st = 1069
+			default:
+				return length
+			}
+
+		case 1064:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1065
+			default:
+				return length
+			}
+
+		case 1065:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1066
+			default:
+				return length
+			}
+
+		case 1066:
+			switch byteToLower(b) {
+			case 'g':
+				st = 1067
+			default:
+				return length
+			}
+
+		case 1067:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1068
+			default:
+				return length
+			}
+
+		case 1069:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1070
+			default:
+				return length
+			}
+
+		case 1070:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1071
+			default:
+				return length
+			}
+
+		case 1071:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 1072
+			default:
+				return length
+			}
+
+		case 1073:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1074
+			default:
+				return length
+			}
+
+		case 1074:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1075
+			case 's':
+				length = i + 1
+				st = 1080
+			default:
+				return length
+			}
+
+		case 1075:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1076
+			default:
+				return length
+			}
+
+		case 1076:
+			switch byteToLower(b) {
+			case 'p':
+				st = 1077
+			default:
+				return length
+			}
+
+		case 1077:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1078
+			default:
+				return length
+			}
+
+		case 1078:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1079
+			default:
+				return length
+			}
+
+		case 1081:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1082
+			default:
+				return length
+			}
+
+		case 1082:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1083
+			default:
+				return length
+			}
+
+		case 1084:
+			switch byteToLower(b) {
+			case 's':
+				st = 1085
+			default:
+				return length
+			}
+
+		case 1085:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1086
+			default:
+				return length
+			}
+
+		case 1087:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1088
+			default:
+				return length
+			}
+
+		case 1088:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1089
+			default:
+				return length
+			}
+
+		case 1089:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1090
+			default:
+				return length
+			}
+
+		case 1090:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 1091
+			default:
+				return length
+			}
+
+		case 1092:
+			switch byteToLower(b) {
+			case 's':
+				st = 1093
+			default:
+				return length
+			}
+
+		case 1093:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1094
+			default:
+				return length
+			}
+
+		case 1099:
+			switch byteToLower(b) {
+			case '2':
+				st = 1100
+			case 'b':
+				st = 1102
+			case 'c':
+				st = 1104
+			case 'd':
+				length = i + 1
+				st = 1108
+			case 'e':
+				length = i + 1
+				st = 1109
+			case 'f':
+				st = 1110
+			case 'l':
+				length = i + 1
+				st = 1112
+			case 'm':
+				length = i + 1
+				st = 1113
+			case 'n':
+				length = i + 1
+				st = 1122
+			case 'o':
+				length = i + 1
+				st = 1170
+			case 'q':
+				length = i + 1
+				st = 1171
+			case 'r':
+				length = i + 1
+				st = 1172
+			case 's':
+				length = i + 1
+				st = 1176
+			case 't':
+				length = i + 1
+				st = 1177
+			case 'w':
+				st = 1178
+			default:
+				return length
+			}
+
+		case 1100:
+			switch byteToLower(b) {
+			case 'p':
+				length = i + 1
+				st = 1101
+			default:
+				return length
+			}
+
+		case 1102:
+			switch byteToLower(b) {
+			case 'm':
+				length = i + 1
+				st = 1103
+			default:
+				return length
+			}
+
+		case 1104:
+			switch byteToLower(b) {
+			case 'b':
+				st = 1105
+			case 'u':
+				length = i + 1
+				st = 1107
+			default:
+				return length
+			}
+
+		case 1105:
+			switch byteToLower(b) {
+			case 'c':
+				length = i + 1
+				st = 1106
+			default:
+				return length
+			}
+
+		case 1110:
+			switch byteToLower(b) {
+			case 'm':
+				length = i + 1
+				st = 1111
+			default:
+				return length
+			}
+
+		case 1113:
+			switch byteToLower(b) {
+			case 'm':
+				st = 1114
+			default:
+				return length
+			}
+
+		case 1114:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 1115
+			default:
+				return length
+			}
+
+		case 1115:
+			switch byteToLower(b) {
+			case 'b':
+				st = 1116
+			default:
+				return length
+			}
+
+		case 1116:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1117
+			default:
+				return length
+			}
+
+		case 1117:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1118
+			default:
+				return length
+			}
+
+		case 1118:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1119
+			default:
+				return length
+			}
+
+		case 1119:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1120
+			default:
+				return length
+			}
+
+		case 1120:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1121
+			default:
+				return length
+			}
+
+		case 1122:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1123
+			case 'f':
+				st = 1131
+			case 'g':
+				length = i + 1
+				st = 1138
+			case 'k':
+				length = i + 1
+				st = 1139
+			case 's':
+				st = 1140
+			case 't':
+				length = i + 1
+				st = 1150
+			case 'v':
+				st = 1161
+			default:
+				return length
+			}
+
+		case 1123:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1124
+			default:
+				return length
+			}
+
+		case 1124:
+			switch byteToLower(b) {
+			case 's':
+				st = 1125
+			default:
+				return length
+			}
+
+		case 1125:
+			switch byteToLower(b) {
+			case 't':
+				st = 1126
+			default:
+				return length
+			}
+
+		case 1126:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1127
+			default:
+				return length
+			}
+
+		case 1127:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1128
+			default:
+				return length
+			}
+
+		case 1128:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1129
+			default:
+				return length
+			}
+
+		case 1129:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1130
+			default:
+				return length
+			}
+
+		case 1131:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1132
+			case 'o':
+				length = i + 1
+				st = 1137
+			default:
+				return length
+			}
+
+		case 1132:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1133
+			default:
+				return length
+			}
+
+		case 1133:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1134
+			default:
+				return length
+			}
+
+		case 1134:
+			switch byteToLower(b) {
+			case 't':
+				st = 1135
+			default:
+				return length
+			}
+
+		case 1135:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 1136
+			default:
+				return length
+			}
+
+		case 1140:
+			switch byteToLower(b) {
+			case 't':
+				st = 1141
+			case 'u':
+				st = 1147
+			default:
+				return length
+			}
+
+		case 1141:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1142
+			default:
+				return length
+			}
+
+		case 1142:
+			switch byteToLower(b) {
+			case 't':
+				st = 1143
+			default:
+				return length
+			}
+
+		case 1143:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1144
+			default:
+				return length
+			}
+
+		case 1144:
+			switch byteToLower(b) {
+			case 't':
+				st = 1145
+			default:
+				return length
+			}
+
+		case 1145:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1146
+			default:
+				return length
+			}
+
+		case 1147:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1148
+			default:
+				return length
+			}
+
+		case 1148:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1149
+			default:
+				return length
+			}
+
+		case 1150:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1151
+			default:
+				return length
+			}
+
+		case 1151:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1152
+			default:
+				return length
+			}
+
+		case 1152:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1153
+			default:
+				return length
+			}
+
+		case 1153:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1154
+			default:
+				return length
+			}
+
+		case 1154:
+			switch byteToLower(b) {
+			case 't':
+				st = 1155
+			default:
+				return length
+			}
+
+		case 1155:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1156
+			default:
+				return length
+			}
+
+		case 1156:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1157
+			default:
+				return length
+			}
+
+		case 1157:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1158
+			default:
+				return length
+			}
+
+		case 1158:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1159
+			default:
+				return length
+			}
+
+		case 1159:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 1160
+			default:
+				return length
+			}
+
+		case 1161:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1162
+			default:
+				return length
+			}
+
+		case 1162:
+			switch byteToLower(b) {
+			case 's':
+				st = 1163
+			default:
+				return length
+			}
+
+		case 1163:
+			switch byteToLower(b) {
+			case 't':
+				st = 1164
+			default:
+				return length
+			}
+
+		case 1164:
+			switch byteToLower(b) {
+			case 'm':
+				st = 1165
+			default:
+				return length
+			}
+
+		case 1165:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1166
+			default:
+				return length
+			}
+
+		case 1166:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1167
+			default:
+				return length
+			}
+
+		case 1167:
+			switch byteToLower(b) {
+			case 't':
+				st = 1168
+			default:
+				return length
+			}
+
+		case 1168:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1169
+			default:
+				return length
+			}
+
+		case 1172:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1173
+			default:
+				return length
+			}
+
+		case 1173:
+			switch byteToLower(b) {
+			case 's':
+				st = 1174
+			default:
+				return length
+			}
+
+		case 1174:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 1175
+			default:
+				return length
+			}
+
+		case 1178:
+			switch byteToLower(b) {
+			case 'c':
+				length = i + 1
+				st = 1179
+			default:
+				return length
+			}
+
+		case 1180:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1181
+			case 'c':
+				st = 1184
+			case 'e':
+				length = i + 1
+				st = 1186
+			case 'l':
+				st = 1195
+			case 'm':
+				length = i + 1
+				st = 1197
+			case 'o':
+				length = i + 1
+				st = 1198
+			case 'p':
+				length = i + 1
+				st = 1204
+			case 'u':
+				st = 1205
+			default:
+				return length
+			}
+
+		case 1181:
+			switch byteToLower(b) {
+			case 'v':
+				st = 1182
+			default:
+				return length
+			}
+
+		case 1182:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1183
+			default:
+				return length
+			}
+
+		case 1184:
+			switch byteToLower(b) {
+			case 'b':
+				length = i + 1
+				st = 1185
+			default:
+				return length
+			}
+
+		case 1186:
+			switch byteToLower(b) {
+			case 't':
+				st = 1187
+			case 'w':
+				st = 1190
+			default:
+				return length
+			}
+
+		case 1187:
+			switch byteToLower(b) {
+			case 'z':
+				st = 1188
+			default:
+				return length
+			}
+
+		case 1188:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1189
+			default:
+				return length
+			}
+
+		case 1190:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1191
+			default:
+				return length
+			}
+
+		case 1191:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1192
+			default:
+				return length
+			}
+
+		case 1192:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1193
+			default:
+				return length
+			}
+
+		case 1193:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 1194
+			default:
+				return length
+			}
+
+		case 1195:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 1196
+			default:
+				return length
+			}
+
+		case 1198:
+			switch byteToLower(b) {
+			case 'b':
+				st = 1199
+			default:
+				return length
+			}
+
+		case 1199:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1200
+			case 'u':
+				st = 1201
+			default:
+				return length
+			}
+
+		case 1201:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1202
+			default:
+				return length
+			}
+
+		case 1202:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 1203
+			default:
+				return length
+			}
+
+		case 1205:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1206
+			default:
+				return length
+			}
+
+		case 1206:
+			switch byteToLower(b) {
+			case 'g':
+				st = 1207
+			default:
+				return length
+			}
+
+		case 1207:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1208
+			default:
+				return length
+			}
+
+		case 1208:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1209
+			default:
+				return length
+			}
+
+		case 1210:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1211
+			case 'd':
+				st = 1216
+			case 'e':
+				length = i + 1
+				st = 1219
+			case 'g':
+				length = i + 1
+				st = 1220
+			case 'h':
+				length = i + 1
+				st = 1221
+			case 'i':
+				length = i + 1
+				st = 1222
+			case 'm':
+				length = i + 1
+				st = 1231
+			case 'n':
+				length = i + 1
+				st = 1232
+			case 'o':
+				st = 1233
+			case 'p':
+				length = i + 1
+				st = 1242
+			case 'r':
+				length = i + 1
+				st = 1243
+			case 'w':
+				length = i + 1
+				st = 1247
+			case 'y':
+				length = i + 1
+				st = 1248
+			case 'z':
+				length = i + 1
+				st = 1252
+			default:
+				return length
+			}
+
+		case 1211:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1212
+			default:
+				return length
+			}
+
+		case 1212:
+			switch byteToLower(b) {
+			case 'f':
+				st = 1213
+			default:
+				return length
+			}
+
+		case 1213:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1214
+			default:
+				return length
+			}
+
+		case 1214:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1215
+			default:
+				return length
+			}
+
+		case 1216:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1217
+			default:
+				return length
+			}
+
+		case 1217:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 1218
+			default:
+				return length
+			}
+
+		case 1222:
+			switch byteToLower(b) {
+			case 'm':
+				length = i + 1
+				st = 1223
+			case 't':
+				st = 1224
+			case 'w':
+				st = 1229
+			default:
+				return length
+			}
+
+		case 1224:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1225
+			default:
+				return length
+			}
+
+		case 1225:
+			switch byteToLower(b) {
+			case 'h':
+				st = 1226
+			default:
+				return length
+			}
+
+		case 1226:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1227
+			default:
+				return length
+			}
+
+		case 1227:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1228
+			default:
+				return length
+			}
+
+		case 1229:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 1230
+			default:
+				return length
+			}
+
+		case 1233:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1234
+			case 'm':
+				st = 1237
+			default:
+				return length
+			}
+
+		case 1234:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1235
+			default:
+				return length
+			}
+
+		case 1235:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1236
+			default:
+				return length
+			}
+
+		case 1237:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1238
+			default:
+				return length
+			}
+
+		case 1238:
+			switch byteToLower(b) {
+			case 't':
+				st = 1239
+			default:
+				return length
+			}
+
+		case 1239:
+			switch byteToLower(b) {
+			case 's':
+				st = 1240
+			default:
+				return length
+			}
+
+		case 1240:
+			switch byteToLower(b) {
+			case 'u':
+				length = i + 1
+				st = 1241
+			default:
+				return length
+			}
+
+		case 1243:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 1244
+			case 'e':
+				st = 1245
+			default:
+				return length
+			}
+
+		case 1245:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 1246
+			default:
+				return length
+			}
+
+		case 1248:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1249
+			default:
+				return length
+			}
+
+		case 1249:
+			switch byteToLower(b) {
+			case 't':
+				st = 1250
+			default:
+				return length
+			}
+
+		case 1250:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 1251
+			default:
+				return length
+			}
+
+		case 1253:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1254
+			case 'b':
+				length = i + 1
+				st = 1271
+			case 'c':
+				length = i + 1
+				st = 1272
+			case 'd':
+				st = 1273
+			case 'e':
+				st = 1275
+			case 'g':
+				st = 1287
+			case 'i':
+				length = i + 1
+				st = 1290
+			case 'k':
+				length = i + 1
+				st = 1314
+			case 'o':
+				st = 1315
+			case 'r':
+				length = i + 1
+				st = 1333
+			case 's':
+				length = i + 1
+				st = 1334
+			case 't':
+				length = i + 1
+				st = 1335
+			case 'u':
+				length = i + 1
+				st = 1338
+			case 'v':
+				length = i + 1
+				st = 1347
+			case 'y':
+				length = i + 1
+				st = 1348
+			default:
+				return length
+			}
+
+		case 1254:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1255
+			case 'n':
+				st = 1260
+			case 't':
+				length = i + 1
+				st = 1262
+			case 'w':
+				st = 1267
+			default:
+				return length
+			}
+
+		case 1255:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1256
+			default:
+				return length
+			}
+
+		case 1256:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1257
+			default:
+				return length
+			}
+
+		case 1257:
+			switch byteToLower(b) {
+			case 'x':
+				st = 1258
+			default:
+				return length
+			}
+
+		case 1258:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1259
+			default:
+				return length
+			}
+
+		case 1260:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 1261
+			default:
+				return length
+			}
+
+		case 1262:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1263
+			default:
+				return length
+			}
+
+		case 1263:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1264
+			default:
+				return length
+			}
+
+		case 1264:
+			switch byteToLower(b) {
+			case 'b':
+				st = 1265
+			default:
+				return length
+			}
+
+		case 1265:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1266
+			default:
+				return length
+			}
+
+		case 1267:
+			switch byteToLower(b) {
+			case 'y':
+				st = 1268
+			default:
+				return length
+			}
+
+		case 1268:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1269
+			default:
+				return length
+			}
+
+		case 1269:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 1270
+			default:
+				return length
+			}
+
+		case 1273:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1274
+			default:
+				return length
+			}
+
+		case 1275:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1276
+			case 'c':
+				st = 1279
+			case 'g':
+				st = 1284
+			default:
+				return length
+			}
+
+		case 1276:
+			switch byteToLower(b) {
+			case 's':
+				st = 1277
+			default:
+				return length
+			}
+
+		case 1277:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1278
+			default:
+				return length
+			}
+
+		case 1279:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1280
+			default:
+				return length
+			}
+
+		case 1280:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1281
+			default:
+				return length
+			}
+
+		case 1281:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1282
+			default:
+				return length
+			}
+
+		case 1282:
+			switch byteToLower(b) {
+			case 'c':
+				length = i + 1
+				st = 1283
+			default:
+				return length
+			}
+
+		case 1284:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1285
+			default:
+				return length
+			}
+
+		case 1285:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 1286
+			default:
+				return length
+			}
+
+		case 1287:
+			switch byteToLower(b) {
+			case 'b':
+				st = 1288
+			default:
+				return length
+			}
+
+		case 1288:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1289
+			default:
+				return length
+			}
+
+		case 1290:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1291
+			case 'd':
+				st = 1296
+			case 'f':
+				st = 1298
+			case 'g':
+				st = 1300
+			case 'm':
+				st = 1306
+			case 'n':
+				st = 1312
+			default:
+				return length
+			}
+
+		case 1291:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1292
+			default:
+				return length
+			}
+
+		case 1292:
+			switch byteToLower(b) {
+			case 's':
+				st = 1293
+			default:
+				return length
+			}
+
+		case 1293:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1294
+			default:
+				return length
+			}
+
+		case 1294:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1295
+			default:
+				return length
+			}
+
+		case 1296:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 1297
+			default:
+				return length
+			}
+
+		case 1298:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1299
+			default:
+				return length
+			}
+
+		case 1300:
+			switch byteToLower(b) {
+			case 'h':
+				st = 1301
+			default:
+				return length
+			}
+
+		case 1301:
+			switch byteToLower(b) {
+			case 't':
+				st = 1302
+			default:
+				return length
+			}
+
+		case 1302:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1303
+			default:
+				return length
+			}
+
+		case 1303:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1304
+			default:
+				return length
+			}
+
+		case 1304:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 1305
+			default:
+				return length
+			}
+
+		case 1306:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1307
+			case 'o':
+				length = i + 1
+				st = 1311
+			default:
+				return length
+			}
+
+		case 1307:
+			switch byteToLower(b) {
+			case 't':
+				st = 1308
+			default:
+				return length
+			}
+
+		case 1308:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1309
+			default:
+				return length
+			}
+
+		case 1309:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 1310
+			default:
+				return length
+			}
+
+		case 1312:
+			switch byteToLower(b) {
+			case 'k':
+				length = i + 1
+				st = 1313
+			default:
+				return length
+			}
+
+		case 1315:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1316
+			case 'c':
+				st = 1319
+			case 'l':
+				length = i + 1
+				st = 1322
+			case 'n':
+				st = 1323
+			case 't':
+				st = 1327
+			case 'v':
+				st = 1331
+			default:
+				return length
+			}
+
+		case 1316:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1317
+			default:
+				return length
+			}
+
+		case 1317:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1318
+			default:
+				return length
+			}
+
+		case 1319:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1320
+			default:
+				return length
+			}
+
+		case 1320:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 1321
+			default:
+				return length
+			}
+
+		case 1323:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1324
+			default:
+				return length
+			}
+
+		case 1324:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1325
+			default:
+				return length
+			}
+
+		case 1325:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1326
+			default:
+				return length
+			}
+
+		case 1327:
+			switch byteToLower(b) {
+			case 't':
+				st = 1328
+			default:
+				return length
+			}
+
+		case 1328:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1329
+			case 'o':
+				length = i + 1
+				st = 1330
+			default:
+				return length
+			}
+
+		case 1331:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1332
+			default:
+				return length
+			}
+
+		case 1335:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1336
+			default:
+				return length
+			}
+
+		case 1336:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1337
+			default:
+				return length
+			}
+
+		case 1338:
+			switch byteToLower(b) {
+			case 'p':
+				st = 1339
+			case 'x':
+				st = 1342
+			default:
+				return length
+			}
+
+		case 1339:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1340
+			default:
+				return length
+			}
+
+		case 1340:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1341
+			default:
+				return length
+			}
+
+		case 1342:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1343
+			case 'u':
+				st = 1344
+			default:
+				return length
+			}
+
+		case 1344:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1345
+			default:
+				return length
+			}
+
+		case 1345:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 1346
+			default:
+				return length
+			}
+
+		case 1349:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1350
+			case 'b':
+				st = 1383
+			case 'c':
+				length = i + 1
+				st = 1385
+			case 'd':
+				length = i + 1
+				st = 1386
+			case 'e':
+				length = i + 1
+				st = 1387
+			case 'g':
+				length = i + 1
+				st = 1409
+			case 'h':
+				length = i + 1
+				st = 1410
+			case 'i':
+				st = 1411
+			case 'k':
+				length = i + 1
+				st = 1418
+			case 'l':
+				length = i + 1
+				st = 1419
+			case 'm':
+				length = i + 1
+				st = 1420
+			case 'n':
+				length = i + 1
+				st = 1422
+			case 'o':
+				length = i + 1
+				st = 1423
+			case 'p':
+				length = i + 1
+				st = 1460
+			case 'q':
+				length = i + 1
+				st = 1461
+			case 'r':
+				length = i + 1
+				st = 1462
+			case 's':
+				length = i + 1
+				st = 1463
+			case 't':
+				length = i + 1
+				st = 1464
+			case 'u':
+				length = i + 1
+				st = 1468
+			case 'v':
+				length = i + 1
+				st = 1473
+			case 'w':
+				length = i + 1
+				st = 1474
+			case 'x':
+				length = i + 1
+				st = 1475
+			case 'y':
+				length = i + 1
+				st = 1476
+			case 'z':
+				length = i + 1
+				st = 1477
+			default:
+				return length
+			}
+
+		case 1350:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1351
+			case 'i':
+				st = 1355
+			case 'n':
+				st = 1360
+			case 'r':
+				st = 1370
+			default:
+				return length
+			}
+
+		case 1351:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1352
+			default:
+				return length
+			}
+
+		case 1352:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1353
+			default:
+				return length
+			}
+
+		case 1353:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 1354
+			default:
+				return length
+			}
+
+		case 1355:
+			switch byteToLower(b) {
+			case 'f':
+				length = i + 1
+				st = 1356
+			case 's':
+				st = 1357
+			default:
+				return length
+			}
+
+		case 1357:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1358
+			default:
+				return length
+			}
+
+		case 1358:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1359
+			default:
+				return length
+			}
+
+		case 1360:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1361
+			case 'g':
+				st = 1368
+			default:
+				return length
+			}
+
+		case 1361:
+			switch byteToLower(b) {
+			case 'g':
+				st = 1362
+			default:
+				return length
+			}
+
+		case 1362:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1363
+			default:
+				return length
+			}
+
+		case 1363:
+			switch byteToLower(b) {
+			case 'm':
+				st = 1364
+			default:
+				return length
+			}
+
+		case 1364:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1365
+			default:
+				return length
+			}
+
+		case 1365:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1366
+			default:
+				return length
+			}
+
+		case 1366:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1367
+			default:
+				return length
+			}
+
+		case 1368:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 1369
+			default:
+				return length
+			}
+
+		case 1370:
+			switch byteToLower(b) {
+			case 'k':
+				st = 1371
+			case 'r':
+				st = 1378
+			default:
+				return length
+			}
+
+		case 1371:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1372
+			default:
+				return length
+			}
+
+		case 1372:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1373
+			default:
+				return length
+			}
+
+		case 1373:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1374
+			case 's':
+				length = i + 1
+				st = 1377
+			default:
+				return length
+			}
+
+		case 1374:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1375
+			default:
+				return length
+			}
+
+		case 1375:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 1376
+			default:
+				return length
+			}
+
+		case 1378:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1379
+			default:
+				return length
+			}
+
+		case 1379:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1380
+			default:
+				return length
+			}
+
+		case 1380:
+			switch byteToLower(b) {
+			case 't':
+				st = 1381
+			default:
+				return length
+			}
+
+		case 1381:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1382
+			default:
+				return length
+			}
+
+		case 1383:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1384
+			default:
+				return length
+			}
+
+		case 1387:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1388
+			case 'e':
+				st = 1391
+			case 'l':
+				st = 1393
+			case 'm':
+				st = 1400
+			case 'n':
+				length = i + 1
+				st = 1407
+			default:
+				return length
+			}
+
+		case 1388:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1389
+			default:
+				return length
+			}
+
+		case 1389:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1390
+			default:
+				return length
+			}
+
+		case 1391:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1392
+			default:
+				return length
+			}
+
+		case 1393:
+			switch byteToLower(b) {
+			case 'b':
+				st = 1394
+			default:
+				return length
+			}
+
+		case 1394:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1395
+			default:
+				return length
+			}
+
+		case 1395:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1396
+			default:
+				return length
+			}
+
+		case 1396:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1397
+			default:
+				return length
+			}
+
+		case 1397:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1398
+			default:
+				return length
+			}
+
+		case 1398:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1399
+			default:
+				return length
+			}
+
+		case 1400:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1401
+			case 'o':
+				st = 1402
+			default:
+				return length
+			}
+
+		case 1402:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1403
+			default:
+				return length
+			}
+
+		case 1403:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1404
+			default:
+				return length
+			}
+
+		case 1404:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1405
+			default:
+				return length
+			}
+
+		case 1405:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 1406
+			default:
+				return length
+			}
+
+		case 1407:
+			switch byteToLower(b) {
+			case 'u':
+				length = i + 1
+				st = 1408
+			default:
+				return length
+			}
+
+		case 1411:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1412
+			case 'l':
+				length = i + 1
+				st = 1415
+			case 'n':
+				st = 1416
+			default:
+				return length
+			}
+
+		case 1412:
+			switch byteToLower(b) {
+			case 'm':
+				st = 1413
+			default:
+				return length
+			}
+
+		case 1413:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 1414
+			default:
+				return length
+			}
+
+		case 1416:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 1417
+			default:
+				return length
+			}
+
+		case 1420:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1421
+			default:
+				return length
+			}
+
+		case 1423:
+			switch byteToLower(b) {
+			case 'b':
+				st = 1424
+			case 'd':
+				st = 1426
+			case 'e':
+				length = i + 1
+				st = 1428
+			case 'n':
+				st = 1429
+			case 'r':
+				st = 1435
+			case 's':
+				st = 1444
+			case 't':
+				st = 1448
+			case 'v':
+				length = i + 1
+				st = 1457
+			default:
+				return length
+			}
+
+		case 1424:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 1425
+			default:
+				return length
+			}
+
+		case 1426:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1427
+			default:
+				return length
+			}
+
+		case 1429:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1430
+			case 'e':
+				st = 1433
+			default:
+				return length
+			}
+
+		case 1430:
+			switch byteToLower(b) {
+			case 's':
+				st = 1431
+			default:
+				return length
+			}
+
+		case 1431:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 1432
+			default:
+				return length
+			}
+
+		case 1433:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 1434
+			default:
+				return length
+			}
+
+		case 1435:
+			switch byteToLower(b) {
+			case 'm':
+				st = 1436
+			case 't':
+				st = 1439
+			default:
+				return length
+			}
+
+		case 1436:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1437
+			default:
+				return length
+			}
+
+		case 1437:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1438
+			default:
+				return length
+			}
+
+		case 1439:
+			switch byteToLower(b) {
+			case 'g':
+				st = 1440
+			default:
+				return length
+			}
+
+		case 1440:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1441
+			default:
+				return length
+			}
+
+		case 1441:
+			switch byteToLower(b) {
+			case 'g':
+				st = 1442
+			default:
+				return length
+			}
+
+		case 1442:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1443
+			default:
+				return length
+			}
+
+		case 1444:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1445
+			default:
+				return length
+			}
+
+		case 1445:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1446
+			default:
+				return length
+			}
+
+		case 1446:
+			switch byteToLower(b) {
+			case 'w':
+				length = i + 1
+				st = 1447
+			default:
+				return length
+			}
+
+		case 1448:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1449
+			default:
+				return length
+			}
+
+		case 1449:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1450
+			default:
+				return length
+			}
+
+		case 1450:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1451
+			default:
+				return length
+			}
+
+		case 1451:
+			switch byteToLower(b) {
+			case 'y':
+				st = 1452
+			default:
+				return length
+			}
+
+		case 1452:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1453
+			default:
+				return length
+			}
+
+		case 1453:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1454
+			default:
+				return length
+			}
+
+		case 1454:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1455
+			default:
+				return length
+			}
+
+		case 1455:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1456
+			default:
+				return length
+			}
+
+		case 1457:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1458
+			default:
+				return length
+			}
+
+		case 1458:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1459
+			default:
+				return length
+			}
+
+		case 1464:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1465
+			case 'p':
+				st = 1466
+			default:
+				return length
+			}
+
+		case 1466:
+			switch byteToLower(b) {
+			case 'c':
+				length = i + 1
+				st = 1467
+			default:
+				return length
+			}
+
+		case 1468:
+			switch byteToLower(b) {
+			case 's':
+				st = 1469
+			default:
+				return length
+			}
+
+		case 1469:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1470
+			default:
+				return length
+			}
+
+		case 1470:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1471
+			default:
+				return length
+			}
+
+		case 1471:
+			switch byteToLower(b) {
+			case 'm':
+				length = i + 1
+				st = 1472
+			default:
+				return length
+			}
+
+		case 1478:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1479
+			case 'c':
+				length = i + 1
+				st = 1491
+			case 'e':
+				length = i + 1
+				st = 1492
+			case 'f':
+				length = i + 1
+				st = 1509
+			case 'g':
+				length = i + 1
+				st = 1510
+			case 'h':
+				st = 1512
+			case 'i':
+				length = i + 1
+				st = 1514
+			case 'l':
+				length = i + 1
+				st = 1524
+			case 'o':
+				length = i + 1
+				st = 1525
+			case 'p':
+				length = i + 1
+				st = 1526
+			case 'r':
+				length = i + 1
+				st = 1527
+			case 't':
+				st = 1530
+			case 'u':
+				length = i + 1
+				st = 1532
+			case 'y':
+				st = 1533
+			case 'z':
+				length = i + 1
+				st = 1535
+			default:
+				return length
+			}
+
+		case 1479:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1480
+			case 'g':
+				st = 1483
+			case 'm':
+				st = 1487
+			case 'v':
+				st = 1489
+			default:
+				return length
+			}
+
+		case 1480:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1481
+			default:
+				return length
+			}
+
+		case 1481:
+			switch byteToLower(b) {
+			case 'x':
+				length = i + 1
+				st = 1482
+			default:
+				return length
+			}
+
+		case 1483:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1484
+			default:
+				return length
+			}
+
+		case 1484:
+			switch byteToLower(b) {
+			case 'y':
+				st = 1485
+			default:
+				return length
+			}
+
+		case 1485:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1486
+			default:
+				return length
+			}
+
+		case 1487:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1488
+			default:
+				return length
+			}
+
+		case 1489:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 1490
+			default:
+				return length
+			}
+
+		case 1492:
+			switch byteToLower(b) {
+			case 'c':
+				length = i + 1
+				st = 1493
+			case 't':
+				length = i + 1
+				st = 1494
+			case 'u':
+				st = 1499
+			case 'w':
+				length = i + 1
+				st = 1504
+			case 'x':
+				st = 1506
+			default:
+				return length
+			}
+
+		case 1494:
+			switch byteToLower(b) {
+			case 'w':
+				st = 1495
+			default:
+				return length
+			}
+
+		case 1495:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1496
+			default:
+				return length
+			}
+
+		case 1496:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1497
+			default:
+				return length
+			}
+
+		case 1497:
+			switch byteToLower(b) {
+			case 'k':
+				length = i + 1
+				st = 1498
+			default:
+				return length
+			}
+
+		case 1499:
+			switch byteToLower(b) {
+			case 's':
+				st = 1500
+			default:
+				return length
+			}
+
+		case 1500:
+			switch byteToLower(b) {
+			case 't':
+				st = 1501
+			default:
+				return length
+			}
+
+		case 1501:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1502
+			default:
+				return length
+			}
+
+		case 1502:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 1503
+			default:
+				return length
+			}
+
+		case 1504:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1505
+			default:
+				return length
+			}
+
+		case 1506:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1507
+			default:
+				return length
+			}
+
+		case 1507:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1508
+			default:
+				return length
+			}
+
+		case 1510:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 1511
+			default:
+				return length
+			}
+
+		case 1512:
+			switch byteToLower(b) {
+			case 'k':
+				length = i + 1
+				st = 1513
+			default:
+				return length
+			}
+
+		case 1514:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1515
+			case 'n':
+				st = 1517
+			case 's':
+				st = 1520
+			default:
+				return length
+			}
+
+		case 1515:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 1516
+			default:
+				return length
+			}
+
+		case 1517:
+			switch byteToLower(b) {
+			case 'j':
+				st = 1518
+			default:
+				return length
+			}
+
+		case 1518:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1519
+			default:
+				return length
+			}
+
+		case 1520:
+			switch byteToLower(b) {
+			case 's':
+				st = 1521
+			default:
+				return length
+			}
+
+		case 1521:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1522
+			default:
+				return length
+			}
+
+		case 1522:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1523
+			default:
+				return length
+			}
+
+		case 1527:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1528
+			case 'w':
+				length = i + 1
+				st = 1529
+			default:
+				return length
+			}
+
+		case 1530:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1531
+			default:
+				return length
+			}
+
+		case 1533:
+			switch byteToLower(b) {
+			case 'c':
+				length = i + 1
+				st = 1534
+			default:
+				return length
+			}
+
+		case 1536:
+			switch byteToLower(b) {
+			case 'k':
+				st = 1537
+			case 'm':
+				length = i + 1
+				st = 1543
+			case 'n':
+				st = 1544
+			case 'o':
+				st = 1554
+			case 'r':
+				st = 1556
+			case 's':
+				st = 1566
+			case 't':
+				st = 1570
+			case 'v':
+				st = 1575
+			default:
+				return length
+			}
+
+		case 1537:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1538
+			default:
+				return length
+			}
+
+		case 1538:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1539
+			default:
+				return length
+			}
+
+		case 1539:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1540
+			default:
+				return length
+			}
+
+		case 1540:
+			switch byteToLower(b) {
+			case 'w':
+				st = 1541
+			default:
+				return length
+			}
+
+		case 1541:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1542
+			default:
+				return length
+			}
+
+		case 1544:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1545
+			case 'g':
+				length = i + 1
+				st = 1546
+			case 'i':
+				st = 1547
+			case 'l':
+				length = i + 1
+				st = 1550
+			default:
+				return length
+			}
+
+		case 1547:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1548
+			default:
+				return length
+			}
+
+		case 1548:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1549
+			default:
+				return length
+			}
+
+		case 1550:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1551
+			default:
+				return length
+			}
+
+		case 1551:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1552
+			default:
+				return length
+			}
+
+		case 1552:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1553
+			default:
+				return length
+			}
+
+		case 1554:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 1555
+			default:
+				return length
+			}
+
+		case 1556:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1557
+			case 'g':
+				length = i + 1
+				st = 1561
+			default:
+				return length
+			}
+
+		case 1557:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1558
+			default:
+				return length
+			}
+
+		case 1558:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1559
+			default:
+				return length
+			}
+
+		case 1559:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1560
+			default:
+				return length
+			}
+
+		case 1561:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1562
+			default:
+				return length
+			}
+
+		case 1562:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1563
+			default:
+				return length
+			}
+
+		case 1563:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1564
+			default:
+				return length
+			}
+
+		case 1564:
+			switch byteToLower(b) {
+			case 'c':
+				length = i + 1
+				st = 1565
+			default:
+				return length
+			}
+
+		case 1566:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1567
+			default:
+				return length
+			}
+
+		case 1567:
+			switch byteToLower(b) {
+			case 'k':
+				st = 1568
+			default:
+				return length
+			}
+
+		case 1568:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1569
+			default:
+				return length
+			}
+
+		case 1570:
+			switch byteToLower(b) {
+			case 's':
+				st = 1571
+			default:
+				return length
+			}
+
+		case 1571:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1572
+			default:
+				return length
+			}
+
+		case 1572:
+			switch byteToLower(b) {
+			case 'k':
+				st = 1573
+			default:
+				return length
+			}
+
+		case 1573:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1574
+			default:
+				return length
+			}
+
+		case 1575:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 1576
+			default:
+				return length
+			}
+
+		case 1577:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1578
+			case 'e':
+				length = i + 1
+				st = 1596
+			case 'f':
+				length = i + 1
+				st = 1597
+			case 'g':
+				length = i + 1
+				st = 1598
+			case 'h':
+				length = i + 1
+				st = 1599
+			case 'i':
+				st = 1625
+			case 'k':
+				length = i + 1
+				st = 1644
+			case 'l':
+				length = i + 1
+				st = 1645
+			case 'm':
+				length = i + 1
+				st = 1656
+			case 'n':
+				length = i + 1
+				st = 1657
+			case 'o':
+				st = 1658
+			case 'r':
+				length = i + 1
+				st = 1668
+			case 's':
+				length = i + 1
+				st = 1693
+			case 't':
+				length = i + 1
+				st = 1694
+			case 'u':
+				st = 1695
+			case 'w':
+				length = i + 1
+				st = 1697
+			case 'y':
+				length = i + 1
+				st = 1698
+			default:
+				return length
+			}
+
+		case 1578:
+			switch byteToLower(b) {
+			case 'g':
+				st = 1579
+			case 'n':
+				st = 1581
+			case 'r':
+				st = 1586
+			default:
+				return length
+			}
+
+		case 1579:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1580
+			default:
+				return length
+			}
+
+		case 1581:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1582
+			default:
+				return length
+			}
+
+		case 1582:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1583
+			default:
+				return length
+			}
+
+		case 1583:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1584
+			default:
+				return length
+			}
+
+		case 1584:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 1585
+			default:
+				return length
+			}
+
+		case 1586:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1587
+			case 't':
+				st = 1589
+			default:
+				return length
+			}
+
+		case 1587:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1588
+			default:
+				return length
+			}
+
+		case 1589:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1590
+			case 's':
+				length = i + 1
+				st = 1594
+			case 'y':
+				length = i + 1
+				st = 1595
+			default:
+				return length
+			}
+
+		case 1590:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1591
+			default:
+				return length
+			}
+
+		case 1591:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1592
+			default:
+				return length
+			}
+
+		case 1592:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1593
+			default:
+				return length
+			}
+
+		case 1599:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1600
+			case 'i':
+				st = 1606
+			case 'o':
+				st = 1611
+			case 'y':
+				st = 1621
+			default:
+				return length
+			}
+
+		case 1600:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1601
+			default:
+				return length
+			}
+
+		case 1601:
+			switch byteToLower(b) {
+			case 'm':
+				st = 1602
+			default:
+				return length
+			}
+
+		case 1602:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1603
+			default:
+				return length
+			}
+
+		case 1603:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1604
+			default:
+				return length
+			}
+
+		case 1604:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 1605
+			default:
+				return length
+			}
+
+		case 1606:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1607
+			default:
+				return length
+			}
+
+		case 1607:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1608
+			default:
+				return length
+			}
+
+		case 1608:
+			switch byteToLower(b) {
+			case 'p':
+				st = 1609
+			default:
+				return length
+			}
+
+		case 1609:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1610
+			default:
+				return length
+			}
+
+		case 1611:
+			switch byteToLower(b) {
+			case 't':
+				st = 1612
+			default:
+				return length
+			}
+
+		case 1612:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 1613
+			default:
+				return length
+			}
+
+		case 1613:
+			switch byteToLower(b) {
+			case 'g':
+				st = 1614
+			case 's':
+				length = i + 1
+				st = 1620
+			default:
+				return length
+			}
+
+		case 1614:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1615
+			default:
+				return length
+			}
+
+		case 1615:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1616
+			default:
+				return length
+			}
+
+		case 1616:
+			switch byteToLower(b) {
+			case 'p':
+				st = 1617
+			default:
+				return length
+			}
+
+		case 1617:
+			switch byteToLower(b) {
+			case 'h':
+				st = 1618
+			default:
+				return length
+			}
+
+		case 1618:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 1619
+			default:
+				return length
+			}
+
+		case 1621:
+			switch byteToLower(b) {
+			case 's':
+				st = 1622
+			default:
+				return length
+			}
+
+		case 1622:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1623
+			default:
+				return length
+			}
+
+		case 1623:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 1624
+			default:
+				return length
+			}
+
+		case 1625:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1626
+			case 'c':
+				st = 1630
+			case 'n':
+				st = 1639
+			case 'z':
+				st = 1641
+			default:
+				return length
+			}
+
+		case 1626:
+			switch byteToLower(b) {
+			case 'g':
+				st = 1627
+			default:
+				return length
+			}
+
+		case 1627:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1628
+			default:
+				return length
+			}
+
+		case 1628:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1629
+			default:
+				return length
+			}
+
+		case 1630:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1631
+			case 't':
+				st = 1632
+			default:
+				return length
+			}
+
+		case 1632:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1633
+			case 'u':
+				st = 1635
+			default:
+				return length
+			}
+
+		case 1633:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1634
+			default:
+				return length
+			}
+
+		case 1635:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1636
+			default:
+				return length
+			}
+
+		case 1636:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1637
+			default:
+				return length
+			}
+
+		case 1637:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1638
+			default:
+				return length
+			}
+
+		case 1639:
+			switch byteToLower(b) {
+			case 'k':
+				length = i + 1
+				st = 1640
+			default:
+				return length
+			}
+
+		case 1641:
+			switch byteToLower(b) {
+			case 'z':
+				st = 1642
+			default:
+				return length
+			}
+
+		case 1642:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1643
+			default:
+				return length
+			}
+
+		case 1645:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1646
+			case 'u':
+				st = 1649
+			default:
+				return length
+			}
+
+		case 1646:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1647
+			default:
+				return length
+			}
+
+		case 1647:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1648
+			default:
+				return length
+			}
+
+		case 1649:
+			switch byteToLower(b) {
+			case 'm':
+				st = 1650
+			case 's':
+				length = i + 1
+				st = 1655
+			default:
+				return length
+			}
+
+		case 1650:
+			switch byteToLower(b) {
+			case 'b':
+				st = 1651
+			default:
+				return length
+			}
+
+		case 1651:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1652
+			default:
+				return length
+			}
+
+		case 1652:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1653
+			default:
+				return length
+			}
+
+		case 1653:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 1654
+			default:
+				return length
+			}
+
+		case 1658:
+			switch byteToLower(b) {
+			case 'h':
+				st = 1659
+			case 'k':
+				st = 1661
+			case 'r':
+				st = 1664
+			case 's':
+				st = 1666
+			default:
+				return length
+			}
+
+		case 1659:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 1660
+			default:
+				return length
+			}
+
+		case 1661:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1662
+			default:
+				return length
+			}
+
+		case 1662:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 1663
+			default:
+				return length
+			}
+
+		case 1664:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1665
+			default:
+				return length
+			}
+
+		case 1666:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1667
+			default:
+				return length
+			}
+
+		case 1668:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1669
+			case 'e':
+				st = 1672
+			case 'o':
+				length = i + 1
+				st = 1675
+			default:
+				return length
+			}
+
+		case 1669:
+			switch byteToLower(b) {
+			case 'x':
+				st = 1670
+			default:
+				return length
+			}
+
+		case 1670:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 1671
+			default:
+				return length
+			}
+
+		case 1672:
+			switch byteToLower(b) {
+			case 's':
+				st = 1673
+			default:
+				return length
+			}
+
+		case 1673:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1674
+			default:
+				return length
+			}
+
+		case 1675:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 1676
+			case 'f':
+				length = i + 1
+				st = 1684
+			case 'p':
+				st = 1685
+			default:
+				return length
+			}
+
+		case 1676:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1677
+			default:
+				return length
+			}
+
+		case 1677:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1678
+			default:
+				return length
+			}
+
+		case 1678:
+			switch byteToLower(b) {
+			case 't':
+				st = 1679
+			default:
+				return length
+			}
+
+		case 1679:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1680
+			default:
+				return length
+			}
+
+		case 1680:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1681
+			default:
+				return length
+			}
+
+		case 1681:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1682
+			default:
+				return length
+			}
+
+		case 1682:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1683
+			default:
+				return length
+			}
+
+		case 1685:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1686
+			default:
+				return length
+			}
+
+		case 1686:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1687
+			default:
+				return length
+			}
+
+		case 1687:
+			switch byteToLower(b) {
+			case 't':
+				st = 1688
+			default:
+				return length
+			}
+
+		case 1688:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1689
+			case 'y':
+				length = i + 1
+				st = 1692
+			default:
+				return length
+			}
+
+		case 1689:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1690
+			default:
+				return length
+			}
+
+		case 1690:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1691
+			default:
+				return length
+			}
+
+		case 1695:
+			switch byteToLower(b) {
+			case 'b':
+				length = i + 1
+				st = 1696
+			default:
+				return length
+			}
+
+		case 1699:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1700
+			case 'p':
+				st = 1701
+			case 'u':
+				st = 1704
+			default:
+				return length
+			}
+
+		case 1701:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1702
+			default:
+				return length
+			}
+
+		case 1702:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1703
+			default:
+				return length
+			}
+
+		case 1704:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1705
+			default:
+				return length
+			}
+
+		case 1705:
+			switch byteToLower(b) {
+			case 'b':
+				st = 1706
+			default:
+				return length
+			}
+
+		case 1706:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1707
+			default:
+				return length
+			}
+
+		case 1707:
+			switch byteToLower(b) {
+			case 'c':
+				length = i + 1
+				st = 1708
+			default:
+				return length
+			}
+
+		case 1709:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1710
+			case 'e':
+				length = i + 1
+				st = 1715
+			case 'i':
+				st = 1772
+			case 'o':
+				length = i + 1
+				st = 1777
+			case 's':
+				length = i + 1
+				st = 1784
+			case 'u':
+				length = i + 1
+				st = 1787
+			case 'w':
+				length = i + 1
+				st = 1791
+			case 'y':
+				st = 1792
+			default:
+				return length
+			}
+
+		case 1710:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1711
+			default:
+				return length
+			}
+
+		case 1711:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1712
+			default:
+				return length
+			}
+
+		case 1712:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1713
+			default:
+				return length
+			}
+
+		case 1713:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 1714
+			default:
+				return length
+			}
+
+		case 1715:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1716
+			case 'c':
+				st = 1721
+			case 'd':
+				length = i + 1
+				st = 1726
+			case 'h':
+				st = 1732
+			case 'i':
+				st = 1735
+			case 'n':
+				length = i + 1
+				st = 1740
+			case 'p':
+				st = 1745
+			case 's':
+				st = 1759
+			case 'v':
+				st = 1767
+			default:
+				return length
+			}
+
+		case 1716:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1717
+			default:
+				return length
+			}
+
+		case 1717:
+			switch byteToLower(b) {
+			case 't':
+				st = 1718
+			default:
+				return length
+			}
+
+		case 1718:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1719
+			default:
+				return length
+			}
+
+		case 1719:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 1720
+			default:
+				return length
+			}
+
+		case 1721:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1722
+			default:
+				return length
+			}
+
+		case 1722:
+			switch byteToLower(b) {
+			case 'p':
+				st = 1723
+			default:
+				return length
+			}
+
+		case 1723:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1724
+			default:
+				return length
+			}
+
+		case 1724:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1725
+			default:
+				return length
+			}
+
+		case 1726:
+			switch byteToLower(b) {
+			case 's':
+				st = 1727
+			default:
+				return length
+			}
+
+		case 1727:
+			switch byteToLower(b) {
+			case 't':
+				st = 1728
+			default:
+				return length
+			}
+
+		case 1728:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1729
+			default:
+				return length
+			}
+
+		case 1729:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1730
+			default:
+				return length
+			}
+
+		case 1730:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1731
+			default:
+				return length
+			}
+
+		case 1732:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1733
+			default:
+				return length
+			}
+
+		case 1733:
+			switch byteToLower(b) {
+			case 'b':
+				length = i + 1
+				st = 1734
+			default:
+				return length
+			}
+
+		case 1735:
+			switch byteToLower(b) {
+			case 's':
+				st = 1736
+			case 't':
+				length = i + 1
+				st = 1739
+			default:
+				return length
+			}
+
+		case 1736:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1737
+			default:
+				return length
+			}
+
+		case 1737:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1738
+			default:
+				return length
+			}
+
+		case 1740:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1741
+			default:
+				return length
+			}
+
+		case 1741:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1742
+			default:
+				return length
+			}
+
+		case 1742:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1743
+			default:
+				return length
+			}
+
+		case 1743:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1744
+			default:
+				return length
+			}
+
+		case 1745:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1746
+			case 'o':
+				st = 1749
+			case 'u':
+				st = 1752
+			default:
+				return length
+			}
+
+		case 1746:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1747
+			default:
+				return length
+			}
+
+		case 1747:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 1748
+			default:
+				return length
+			}
+
+		case 1749:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1750
+			default:
+				return length
+			}
+
+		case 1750:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1751
+			default:
+				return length
+			}
+
+		case 1752:
+			switch byteToLower(b) {
+			case 'b':
+				st = 1753
+			default:
+				return length
+			}
+
+		case 1753:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1754
+			default:
+				return length
+			}
+
+		case 1754:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1755
+			default:
+				return length
+			}
+
+		case 1755:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1756
+			default:
+				return length
+			}
+
+		case 1756:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1757
+			default:
+				return length
+			}
+
+		case 1757:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 1758
+			default:
+				return length
+			}
+
+		case 1759:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1760
+			default:
+				return length
+			}
+
+		case 1760:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1761
+			default:
+				return length
+			}
+
+		case 1761:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1762
+			default:
+				return length
+			}
+
+		case 1762:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1763
+			default:
+				return length
+			}
+
+		case 1763:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1764
+			default:
+				return length
+			}
+
+		case 1764:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1765
+			default:
+				return length
+			}
+
+		case 1765:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1766
+			default:
+				return length
+			}
+
+		case 1767:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1768
+			default:
+				return length
+			}
+
+		case 1768:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1769
+			default:
+				return length
+			}
+
+		case 1769:
+			switch byteToLower(b) {
+			case 'w':
+				length = i + 1
+				st = 1770
+			default:
+				return length
+			}
+
+		case 1770:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1771
+			default:
+				return length
+			}
+
+		case 1772:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1773
+			case 'o':
+				length = i + 1
+				st = 1775
+			case 'p':
+				length = i + 1
+				st = 1776
+			default:
+				return length
+			}
+
+		case 1773:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 1774
+			default:
+				return length
+			}
+
+		case 1777:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1778
+			case 'd':
+				st = 1781
+			default:
+				return length
+			}
+
+		case 1778:
+			switch byteToLower(b) {
+			case 'k':
+				st = 1779
+			default:
+				return length
+			}
+
+		case 1779:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1780
+			default:
+				return length
+			}
+
+		case 1781:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1782
+			default:
+				return length
+			}
+
+		case 1782:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 1783
+			default:
+				return length
+			}
+
+		case 1784:
+			switch byteToLower(b) {
+			case 'v':
+				st = 1785
+			default:
+				return length
+			}
+
+		case 1785:
+			switch byteToLower(b) {
+			case 'p':
+				length = i + 1
+				st = 1786
+			default:
+				return length
+			}
+
+		case 1787:
+			switch byteToLower(b) {
+			case 'h':
+				st = 1788
+			case 'n':
+				length = i + 1
+				st = 1790
+			default:
+				return length
+			}
+
+		case 1788:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 1789
+			default:
+				return length
+			}
+
+		case 1792:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1793
+			default:
+				return length
+			}
+
+		case 1793:
+			switch byteToLower(b) {
+			case 'k':
+				st = 1794
+			default:
+				return length
+			}
+
+		case 1794:
+			switch byteToLower(b) {
+			case 'y':
+				st = 1795
+			default:
+				return length
+			}
+
+		case 1795:
+			switch byteToLower(b) {
+			case 'u':
+				length = i + 1
+				st = 1796
+			default:
+				return length
+			}
+
+		case 1797:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1798
+			case 'b':
+				length = i + 1
+				st = 1830
+			case 'c':
+				length = i + 1
+				st = 1831
+			case 'd':
+				length = i + 1
+				st = 1864
+			case 'e':
+				length = i + 1
+				st = 1865
+			case 'g':
+				length = i + 1
+				st = 1880
+			case 'h':
+				length = i + 1
+				st = 1881
+			case 'i':
+				length = i + 1
+				st = 1896
+			case 'j':
+				length = i + 1
+				st = 1904
+			case 'k':
+				length = i + 1
+				st = 1905
+			case 'l':
+				length = i + 1
+				st = 1908
+			case 'm':
+				length = i + 1
+				st = 1909
+			case 'n':
+				length = i + 1
+				st = 1910
+			case 'o':
+				length = i + 1
+				st = 1913
+			case 'p':
+				st = 1941
+			case 'r':
+				length = i + 1
+				st = 1961
+			case 't':
+				length = i + 1
+				st = 1962
+			case 'u':
+				length = i + 1
+				st = 1969
+			case 'v':
+				length = i + 1
+				st = 1993
+			case 'w':
+				st = 1994
+			case 'x':
+				length = i + 1
+				st = 1998
+			case 'y':
+				length = i + 1
+				st = 1999
+			case 'z':
+				length = i + 1
+				st = 2009
+			default:
+				return length
+			}
+
+		case 1798:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1799
+			case 'l':
+				st = 1805
+			case 'm':
+				st = 1807
+			case 'n':
+				st = 1812
+			case 'p':
+				length = i + 1
+				st = 1825
+			case 'r':
+				st = 1826
+			case 'x':
+				st = 1828
+			default:
+				return length
+			}
+
+		case 1799:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1800
+			default:
+				return length
+			}
+
+		case 1800:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1801
+			default:
+				return length
+			}
+
+		case 1801:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1802
+			default:
+				return length
+			}
+
+		case 1802:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1803
+			default:
+				return length
+			}
+
+		case 1803:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 1804
+			default:
+				return length
+			}
+
+		case 1805:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1806
+			default:
+				return length
+			}
+
+		case 1807:
+			switch byteToLower(b) {
+			case 's':
+				st = 1808
+			default:
+				return length
+			}
+
+		case 1808:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1809
+			default:
+				return length
+			}
+
+		case 1809:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1810
+			default:
+				return length
+			}
+
+		case 1810:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 1811
+			default:
+				return length
+			}
+
+		case 1812:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1813
+			default:
+				return length
+			}
+
+		case 1813:
+			switch byteToLower(b) {
+			case 'v':
+				st = 1814
+			default:
+				return length
+			}
+
+		case 1814:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1815
+			default:
+				return length
+			}
+
+		case 1815:
+			switch byteToLower(b) {
+			case 'k':
+				length = i + 1
+				st = 1816
+			default:
+				return length
+			}
+
+		case 1816:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1817
+			default:
+				return length
+			}
+
+		case 1817:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1818
+			default:
+				return length
+			}
+
+		case 1818:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1819
+			default:
+				return length
+			}
+
+		case 1819:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1820
+			default:
+				return length
+			}
+
+		case 1820:
+			switch byteToLower(b) {
+			case 'm':
+				st = 1821
+			default:
+				return length
+			}
+
+		case 1821:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1822
+			default:
+				return length
+			}
+
+		case 1822:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1823
+			default:
+				return length
+			}
+
+		case 1823:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1824
+			default:
+				return length
+			}
+
+		case 1826:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 1827
+			default:
+				return length
+			}
+
+		case 1828:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 1829
+			default:
+				return length
+			}
+
+		case 1831:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1832
+			case 'b':
+				length = i + 1
+				st = 1833
+			case 'h':
+				st = 1834
+			case 'i':
+				st = 1857
+			case 'o':
+				st = 1862
+			default:
+				return length
+			}
+
+		case 1834:
+			switch byteToLower(b) {
+			case 'm':
+				st = 1835
+			case 'o':
+				st = 1839
+			case 'u':
+				st = 1850
+			case 'w':
+				st = 1853
+			default:
+				return length
+			}
+
+		case 1835:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1836
+			default:
+				return length
+			}
+
+		case 1836:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1837
+			default:
+				return length
+			}
+
+		case 1837:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1838
+			default:
+				return length
+			}
+
+		case 1839:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1840
+			case 'o':
+				st = 1848
+			default:
+				return length
+			}
+
+		case 1840:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1841
+			default:
+				return length
+			}
+
+		case 1841:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1842
+			default:
+				return length
+			}
+
+		case 1842:
+			switch byteToLower(b) {
+			case 's':
+				st = 1843
+			default:
+				return length
+			}
+
+		case 1843:
+			switch byteToLower(b) {
+			case 'h':
+				st = 1844
+			default:
+				return length
+			}
+
+		case 1844:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1845
+			default:
+				return length
+			}
+
+		case 1845:
+			switch byteToLower(b) {
+			case 'p':
+				st = 1846
+			default:
+				return length
+			}
+
+		case 1846:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1847
+			default:
+				return length
+			}
+
+		case 1848:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 1849
+			default:
+				return length
+			}
+
+		case 1850:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1851
+			default:
+				return length
+			}
+
+		case 1851:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1852
+			default:
+				return length
+			}
+
+		case 1853:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1854
+			default:
+				return length
+			}
+
+		case 1854:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1855
+			default:
+				return length
+			}
+
+		case 1855:
+			switch byteToLower(b) {
+			case 'z':
+				length = i + 1
+				st = 1856
+			default:
+				return length
+			}
+
+		case 1857:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1858
+			default:
+				return length
+			}
+
+		case 1858:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1859
+			default:
+				return length
+			}
+
+		case 1859:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1860
+			default:
+				return length
+			}
+
+		case 1860:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1861
+			default:
+				return length
+			}
+
+		case 1862:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1863
+			default:
+				return length
+			}
+
+		case 1865:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1866
+			case 'n':
+				st = 1868
+			case 'r':
+				st = 1871
+			case 'w':
+				length = i + 1
+				st = 1877
+			case 'x':
+				length = i + 1
+				st = 1878
+			default:
+				return length
+			}
+
+		case 1866:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1867
+			default:
+				return length
+			}
+
+		case 1868:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1869
+			default:
+				return length
+			}
+
+		case 1869:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 1870
+			default:
+				return length
+			}
+
+		case 1871:
+			switch byteToLower(b) {
+			case 'v':
+				st = 1872
+			default:
+				return length
+			}
+
+		case 1872:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1873
+			default:
+				return length
+			}
+
+		case 1873:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1874
+			default:
+				return length
+			}
+
+		case 1874:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1875
+			default:
+				return length
+			}
+
+		case 1875:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1876
+			default:
+				return length
+			}
+
+		case 1878:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 1879
+			default:
+				return length
+			}
+
+		case 1881:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1882
+			case 'o':
+				st = 1887
+			case 'r':
+				st = 1891
+			default:
+				return length
+			}
+
+		case 1882:
+			switch byteToLower(b) {
+			case 'k':
+				st = 1883
+			default:
+				return length
+			}
+
+		case 1883:
+			switch byteToLower(b) {
+			case 's':
+				st = 1884
+			default:
+				return length
+			}
+
+		case 1884:
+			switch byteToLower(b) {
+			case 'h':
+				st = 1885
+			default:
+				return length
+			}
+
+		case 1885:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 1886
+			default:
+				return length
+			}
+
+		case 1887:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1888
+			case 'w':
+				length = i + 1
+				st = 1890
+			default:
+				return length
+			}
+
+		case 1888:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1889
+			default:
+				return length
+			}
+
+		case 1891:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1892
+			default:
+				return length
+			}
+
+		case 1892:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1893
+			default:
+				return length
+			}
+
+		case 1893:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1894
+			default:
+				return length
+			}
+
+		case 1894:
+			switch byteToLower(b) {
+			case 'm':
+				length = i + 1
+				st = 1895
+			default:
+				return length
+			}
+
+		case 1896:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1897
+			case 't':
+				st = 1902
+			default:
+				return length
+			}
+
+		case 1897:
+			switch byteToLower(b) {
+			case 'g':
+				st = 1898
+			default:
+				return length
+			}
+
+		case 1898:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1899
+			default:
+				return length
+			}
+
+		case 1899:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1900
+			default:
+				return length
+			}
+
+		case 1900:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1901
+			default:
+				return length
+			}
+
+		case 1902:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1903
+			default:
+				return length
+			}
+
+		case 1905:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 1906
+			case 'y':
+				length = i + 1
+				st = 1907
+			default:
+				return length
+			}
+
+		case 1910:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1911
+			default:
+				return length
+			}
+
+		case 1911:
+			switch byteToLower(b) {
+			case 'f':
+				length = i + 1
+				st = 1912
+			default:
+				return length
+			}
+
+		case 1913:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1914
+			case 'f':
+				st = 1921
+			case 'h':
+				st = 1927
+			case 'l':
+				st = 1929
+			case 'n':
+				st = 1938
+			case 'y':
+				length = i + 1
+				st = 1940
+			default:
+				return length
+			}
+
+		case 1914:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1915
+			case 'i':
+				st = 1918
+			default:
+				return length
+			}
+
+		case 1915:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1916
+			default:
+				return length
+			}
+
+		case 1916:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 1917
+			default:
+				return length
+			}
+
+		case 1918:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1919
+			default:
+				return length
+			}
+
+		case 1919:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 1920
+			default:
+				return length
+			}
+
+		case 1921:
+			switch byteToLower(b) {
+			case 't':
+				st = 1922
+			default:
+				return length
+			}
+
+		case 1922:
+			switch byteToLower(b) {
+			case 'w':
+				st = 1923
+			default:
+				return length
+			}
+
+		case 1923:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1924
+			default:
+				return length
+			}
+
+		case 1924:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1925
+			default:
+				return length
+			}
+
+		case 1925:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1926
+			default:
+				return length
+			}
+
+		case 1927:
+			switch byteToLower(b) {
+			case 'u':
+				length = i + 1
+				st = 1928
+			default:
+				return length
+			}
+
+		case 1929:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1930
+			case 'u':
+				st = 1932
+			default:
+				return length
+			}
+
+		case 1930:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 1931
+			default:
+				return length
+			}
+
+		case 1932:
+			switch byteToLower(b) {
+			case 't':
+				st = 1933
+			default:
+				return length
+			}
+
+		case 1933:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1934
+			default:
+				return length
+			}
+
+		case 1934:
+			switch byteToLower(b) {
+			case 'o':
+				st = 1935
+			default:
+				return length
+			}
+
+		case 1935:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1936
+			default:
+				return length
+			}
+
+		case 1936:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1937
+			default:
+				return length
+			}
+
+		case 1938:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 1939
+			default:
+				return length
+			}
+
+		case 1941:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1942
+			case 'i':
+				st = 1945
+			case 'r':
+				st = 1950
+			default:
+				return length
+			}
+
+		case 1942:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1943
+			default:
+				return length
+			}
+
+		case 1943:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1944
+			default:
+				return length
+			}
+
+		case 1945:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1946
+			default:
+				return length
+			}
+
+		case 1946:
+			switch byteToLower(b) {
+			case 'g':
+				st = 1947
+			default:
+				return length
+			}
+
+		case 1947:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1948
+			default:
+				return length
+			}
+
+		case 1948:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 1949
+			default:
+				return length
+			}
+
+		case 1950:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1951
+			default:
+				return length
+			}
+
+		case 1951:
+			switch byteToLower(b) {
+			case 'a':
+				st = 1952
+			default:
+				return length
+			}
+
+		case 1952:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1953
+			default:
+				return length
+			}
+
+		case 1953:
+			switch byteToLower(b) {
+			case 'b':
+				st = 1954
+			default:
+				return length
+			}
+
+		case 1954:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1955
+			default:
+				return length
+			}
+
+		case 1955:
+			switch byteToLower(b) {
+			case 't':
+				st = 1956
+			default:
+				return length
+			}
+
+		case 1956:
+			switch byteToLower(b) {
+			case 't':
+				st = 1957
+			default:
+				return length
+			}
+
+		case 1957:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1958
+			default:
+				return length
+			}
+
+		case 1958:
+			switch byteToLower(b) {
+			case 'n':
+				st = 1959
+			default:
+				return length
+			}
+
+		case 1959:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 1960
+			default:
+				return length
+			}
+
+		case 1962:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1963
+			case 'y':
+				st = 1966
+			default:
+				return length
+			}
+
+		case 1963:
+			switch byteToLower(b) {
+			case 'd':
+				st = 1964
+			default:
+				return length
+			}
+
+		case 1964:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 1965
+			default:
+				return length
+			}
+
+		case 1966:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1967
+			default:
+				return length
+			}
+
+		case 1967:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 1968
+			default:
+				return length
+			}
+
+		case 1969:
+			switch byteToLower(b) {
+			case 'c':
+				st = 1970
+			case 'p':
+				st = 1973
+			case 'r':
+				st = 1983
+			case 'z':
+				st = 1989
+			default:
+				return length
+			}
+
+		case 1970:
+			switch byteToLower(b) {
+			case 'k':
+				st = 1971
+			default:
+				return length
+			}
+
+		case 1971:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1972
+			default:
+				return length
+			}
+
+		case 1973:
+			switch byteToLower(b) {
+			case 'p':
+				st = 1974
+			default:
+				return length
+			}
+
+		case 1974:
+			switch byteToLower(b) {
+			case 'l':
+				st = 1975
+			case 'o':
+				st = 1980
+			default:
+				return length
+			}
+
+		case 1975:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1976
+			case 'y':
+				length = i + 1
+				st = 1979
+			default:
+				return length
+			}
+
+		case 1976:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1977
+			default:
+				return length
+			}
+
+		case 1977:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1978
+			default:
+				return length
+			}
+
+		case 1980:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1981
+			default:
+				return length
+			}
+
+		case 1981:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 1982
+			default:
+				return length
+			}
+
+		case 1983:
+			switch byteToLower(b) {
+			case 'f':
+				length = i + 1
+				st = 1984
+			case 'g':
+				st = 1985
+			default:
+				return length
+			}
+
+		case 1985:
+			switch byteToLower(b) {
+			case 'e':
+				st = 1986
+			default:
+				return length
+			}
+
+		case 1986:
+			switch byteToLower(b) {
+			case 'r':
+				st = 1987
+			default:
+				return length
+			}
+
+		case 1987:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 1988
+			default:
+				return length
+			}
+
+		case 1989:
+			switch byteToLower(b) {
+			case 'u':
+				st = 1990
+			default:
+				return length
+			}
+
+		case 1990:
+			switch byteToLower(b) {
+			case 'k':
+				st = 1991
+			default:
+				return length
+			}
+
+		case 1991:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 1992
+			default:
+				return length
+			}
+
+		case 1994:
+			switch byteToLower(b) {
+			case 'i':
+				st = 1995
+			default:
+				return length
+			}
+
+		case 1995:
+			switch byteToLower(b) {
+			case 's':
+				st = 1996
+			default:
+				return length
+			}
+
+		case 1996:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 1997
+			default:
+				return length
+			}
+
+		case 1999:
+			switch byteToLower(b) {
+			case 'd':
+				st = 2000
+			case 's':
+				st = 2004
+			default:
+				return length
+			}
+
+		case 2000:
+			switch byteToLower(b) {
+			case 'n':
+				st = 2001
+			default:
+				return length
+			}
+
+		case 2001:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2002
+			default:
+				return length
+			}
+
+		case 2002:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 2003
+			default:
+				return length
+			}
+
+		case 2004:
+			switch byteToLower(b) {
+			case 't':
+				st = 2005
+			default:
+				return length
+			}
+
+		case 2005:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2006
+			default:
+				return length
+			}
+
+		case 2006:
+			switch byteToLower(b) {
+			case 'm':
+				st = 2007
+			default:
+				return length
+			}
+
+		case 2007:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2008
+			default:
+				return length
+			}
+
+		case 2010:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2011
+			case 'c':
+				length = i + 1
+				st = 2024
+			case 'd':
+				length = i + 1
+				st = 2025
+			case 'e':
+				st = 2026
+			case 'f':
+				length = i + 1
+				st = 2047
+			case 'g':
+				length = i + 1
+				st = 2048
+			case 'h':
+				length = i + 1
+				st = 2049
+			case 'i':
+				st = 2056
+			case 'j':
+				length = i + 1
+				st = 2073
+			case 'k':
+				length = i + 1
+				st = 2074
+			case 'l':
+				length = i + 1
+				st = 2075
+			case 'm':
+				length = i + 1
+				st = 2076
+			case 'n':
+				length = i + 1
+				st = 2077
+			case 'o':
+				length = i + 1
+				st = 2078
+			case 'r':
+				length = i + 1
+				st = 2104
+			case 't':
+				length = i + 1
+				st = 2122
+			case 'u':
+				st = 2123
+			case 'v':
+				length = i + 1
+				st = 2125
+			case 'w':
+				length = i + 1
+				st = 2126
+			case 'z':
+				length = i + 1
+				st = 2127
+			default:
+				return length
+			}
+
+		case 2011:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2012
+			case 't':
+				st = 2016
+			case 'x':
+				length = i + 1
+				st = 2022
+			default:
+				return length
+			}
+
+		case 2012:
+			switch byteToLower(b) {
+			case 'p':
+				st = 2013
+			default:
+				return length
+			}
+
+		case 2013:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2014
+			default:
+				return length
+			}
+
+		case 2014:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 2015
+			default:
+				return length
+			}
+
+		case 2016:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2017
+			case 't':
+				st = 2019
+			default:
+				return length
+			}
+
+		case 2017:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 2018
+			default:
+				return length
+			}
+
+		case 2019:
+			switch byteToLower(b) {
+			case 'o':
+				st = 2020
+			default:
+				return length
+			}
+
+		case 2020:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 2021
+			default:
+				return length
+			}
+
+		case 2022:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 2023
+			default:
+				return length
+			}
+
+		case 2026:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2027
+			case 'c':
+				st = 2029
+			case 'l':
+				length = i + 1
+				st = 2037
+			case 'm':
+				st = 2038
+			case 'n':
+				st = 2043
+			default:
+				return length
+			}
+
+		case 2027:
+			switch byteToLower(b) {
+			case 'm':
+				length = i + 1
+				st = 2028
+			default:
+				return length
+			}
+
+		case 2029:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 2030
+			default:
+				return length
+			}
+
+		case 2030:
+			switch byteToLower(b) {
+			case 'n':
+				st = 2031
+			default:
+				return length
+			}
+
+		case 2031:
+			switch byteToLower(b) {
+			case 'o':
+				st = 2032
+			default:
+				return length
+			}
+
+		case 2032:
+			switch byteToLower(b) {
+			case 'l':
+				st = 2033
+			default:
+				return length
+			}
+
+		case 2033:
+			switch byteToLower(b) {
+			case 'o':
+				st = 2034
+			default:
+				return length
+			}
+
+		case 2034:
+			switch byteToLower(b) {
+			case 'g':
+				st = 2035
+			default:
+				return length
+			}
+
+		case 2035:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 2036
+			default:
+				return length
+			}
+
+		case 2038:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2039
+			default:
+				return length
+			}
+
+		case 2039:
+			switch byteToLower(b) {
+			case 's':
+				st = 2040
+			default:
+				return length
+			}
+
+		case 2040:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2041
+			default:
+				return length
+			}
+
+		case 2041:
+			switch byteToLower(b) {
+			case 'k':
+				length = i + 1
+				st = 2042
+			default:
+				return length
+			}
+
+		case 2043:
+			switch byteToLower(b) {
+			case 'n':
+				st = 2044
+			default:
+				return length
+			}
+
+		case 2044:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2045
+			default:
+				return length
+			}
+
+		case 2045:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2046
+			default:
+				return length
+			}
+
+		case 2049:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 2050
+			case 'e':
+				st = 2051
+			default:
+				return length
+			}
+
+		case 2051:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2052
+			default:
+				return length
+			}
+
+		case 2052:
+			switch byteToLower(b) {
+			case 't':
+				st = 2053
+			default:
+				return length
+			}
+
+		case 2053:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2054
+			default:
+				return length
+			}
+
+		case 2054:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 2055
+			default:
+				return length
+			}
+
+		case 2056:
+			switch byteToLower(b) {
+			case 'c':
+				st = 2057
+			case 'e':
+				st = 2062
+			case 'p':
+				st = 2066
+			case 'r':
+				st = 2068
+			default:
+				return length
+			}
+
+		case 2057:
+			switch byteToLower(b) {
+			case 'k':
+				st = 2058
+			default:
+				return length
+			}
+
+		case 2058:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2059
+			default:
+				return length
+			}
+
+		case 2059:
+			switch byteToLower(b) {
+			case 't':
+				st = 2060
+			default:
+				return length
+			}
+
+		case 2060:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2061
+			default:
+				return length
+			}
+
+		case 2062:
+			switch byteToLower(b) {
+			case 'n':
+				st = 2063
+			default:
+				return length
+			}
+
+		case 2063:
+			switch byteToLower(b) {
+			case 'd':
+				st = 2064
+			default:
+				return length
+			}
+
+		case 2064:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 2065
+			default:
+				return length
+			}
+
+		case 2066:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2067
+			default:
+				return length
+			}
+
+		case 2068:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2069
+			case 'o':
+				st = 2071
+			default:
+				return length
+			}
+
+		case 2069:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2070
+			default:
+				return length
+			}
+
+		case 2071:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 2072
+			default:
+				return length
+			}
+
+		case 2078:
+			switch byteToLower(b) {
+			case 'd':
+				st = 2079
+			case 'k':
+				st = 2082
+			case 'o':
+				st = 2085
+			case 'p':
+				length = i + 1
+				st = 2088
+			case 'r':
+				st = 2089
+			case 's':
+				st = 2092
+			case 'u':
+				st = 2097
+			case 'w':
+				st = 2100
+			case 'y':
+				st = 2102
+			default:
+				return length
+			}
+
+		case 2079:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2080
+			default:
+				return length
+			}
+
+		case 2080:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 2081
+			default:
+				return length
+			}
+
+		case 2082:
+			switch byteToLower(b) {
+			case 'y':
+				st = 2083
+			default:
+				return length
+			}
+
+		case 2083:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 2084
+			default:
+				return length
+			}
+
+		case 2085:
+			switch byteToLower(b) {
+			case 'l':
+				st = 2086
+			default:
+				return length
+			}
+
+		case 2086:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2087
+			default:
+				return length
+			}
+
+		case 2089:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2090
+			default:
+				return length
+			}
+
+		case 2090:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 2091
+			default:
+				return length
+			}
+
+		case 2092:
+			switch byteToLower(b) {
+			case 'h':
+				st = 2093
+			default:
+				return length
+			}
+
+		case 2093:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2094
+			default:
+				return length
+			}
+
+		case 2094:
+			switch byteToLower(b) {
+			case 'b':
+				st = 2095
+			default:
+				return length
+			}
+
+		case 2095:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 2096
+			default:
+				return length
+			}
+
+		case 2097:
+			switch byteToLower(b) {
+			case 'r':
+				st = 2098
+			default:
+				return length
+			}
+
+		case 2098:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2099
+			default:
+				return length
+			}
+
+		case 2100:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 2101
+			default:
+				return length
+			}
+
+		case 2102:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2103
+			default:
+				return length
+			}
+
+		case 2104:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2105
+			case 'u':
+				st = 2119
+			default:
+				return length
+			}
+
+		case 2105:
+			switch byteToLower(b) {
+			case 'd':
+				st = 2106
+			case 'i':
+				st = 2111
+			case 'v':
+				st = 2116
+			default:
+				return length
+			}
+
+		case 2106:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 2107
+			case 'i':
+				st = 2108
+			default:
+				return length
+			}
+
+		case 2108:
+			switch byteToLower(b) {
+			case 'n':
+				st = 2109
+			default:
+				return length
+			}
+
+		case 2109:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 2110
+			default:
+				return length
+			}
+
+		case 2111:
+			switch byteToLower(b) {
+			case 'n':
+				st = 2112
+			default:
+				return length
+			}
+
+		case 2112:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2113
+			default:
+				return length
+			}
+
+		case 2113:
+			switch byteToLower(b) {
+			case 'n':
+				st = 2114
+			default:
+				return length
+			}
+
+		case 2114:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 2115
+			default:
+				return length
+			}
+
+		case 2116:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2117
+			default:
+				return length
+			}
+
+		case 2117:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 2118
+			default:
+				return length
+			}
+
+		case 2119:
+			switch byteToLower(b) {
+			case 's':
+				st = 2120
+			default:
+				return length
+			}
+
+		case 2120:
+			switch byteToLower(b) {
+			case 't':
+				length = i + 1
+				st = 2121
+			default:
+				return length
+			}
+
+		case 2123:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 2124
+			default:
+				return length
+			}
+
+		case 2128:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 2129
+			case 'g':
+				length = i + 1
+				st = 2130
+			case 'k':
+				length = i + 1
+				st = 2131
+			case 'n':
+				st = 2132
+			case 'o':
+				st = 2142
+			case 's':
+				length = i + 1
+				st = 2144
+			case 'y':
+				length = i + 1
+				st = 2145
+			case 'z':
+				length = i + 1
+				st = 2146
+			default:
+				return length
+			}
+
+		case 2132:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2133
+			case 'o':
+				length = i + 1
+				st = 2141
+			default:
+				return length
+			}
+
+		case 2133:
+			switch byteToLower(b) {
+			case 'v':
+				st = 2134
+			default:
+				return length
+			}
+
+		case 2134:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2135
+			default:
+				return length
+			}
+
+		case 2135:
+			switch byteToLower(b) {
+			case 'r':
+				st = 2136
+			default:
+				return length
+			}
+
+		case 2136:
+			switch byteToLower(b) {
+			case 's':
+				st = 2137
+			default:
+				return length
+			}
+
+		case 2137:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2138
+			default:
+				return length
+			}
+
+		case 2138:
+			switch byteToLower(b) {
+			case 't':
+				st = 2139
+			default:
+				return length
+			}
+
+		case 2139:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 2140
+			default:
+				return length
+			}
+
+		case 2142:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 2143
+			default:
+				return length
+			}
+
+		case 2147:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 2148
+			case 'c':
+				length = i + 1
+				st = 2156
+			case 'e':
+				length = i + 1
+				st = 2157
+			case 'g':
+				length = i + 1
+				st = 2178
+			case 'i':
+				length = i + 1
+				st = 2179
+			case 'l':
+				st = 2195
+			case 'n':
+				length = i + 1
+				st = 2204
+			case 'o':
+				st = 2205
+			case 'u':
+				length = i + 1
+				st = 2219
+			default:
+				return length
+			}
+
+		case 2148:
+			switch byteToLower(b) {
+			case 'c':
+				st = 2149
+			default:
+				return length
+			}
+
+		case 2149:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2150
+			default:
+				return length
+			}
+
+		case 2150:
+			switch byteToLower(b) {
+			case 't':
+				st = 2151
+			default:
+				return length
+			}
+
+		case 2151:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2152
+			default:
+				return length
+			}
+
+		case 2152:
+			switch byteToLower(b) {
+			case 'o':
+				st = 2153
+			default:
+				return length
+			}
+
+		case 2153:
+			switch byteToLower(b) {
+			case 'n':
+				st = 2154
+			default:
+				return length
+			}
+
+		case 2154:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2155
+			default:
+				return length
+			}
+
+		case 2157:
+			switch byteToLower(b) {
+			case 'g':
+				st = 2158
+			case 'n':
+				st = 2161
+			case 'r':
+				st = 2167
+			case 't':
+				length = i + 1
+				st = 2177
+			default:
+				return length
+			}
+
+		case 2158:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2159
+			default:
+				return length
+			}
+
+		case 2159:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2160
+			default:
+				return length
+			}
+
+		case 2161:
+			switch byteToLower(b) {
+			case 't':
+				st = 2162
+			default:
+				return length
+			}
+
+		case 2162:
+			switch byteToLower(b) {
+			case 'u':
+				st = 2163
+			default:
+				return length
+			}
+
+		case 2163:
+			switch byteToLower(b) {
+			case 'r':
+				st = 2164
+			default:
+				return length
+			}
+
+		case 2164:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2165
+			default:
+				return length
+			}
+
+		case 2165:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2166
+			default:
+				return length
+			}
+
+		case 2167:
+			switch byteToLower(b) {
+			case 's':
+				st = 2168
+			default:
+				return length
+			}
+
+		case 2168:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2169
+			default:
+				return length
+			}
+
+		case 2169:
+			switch byteToLower(b) {
+			case 'c':
+				st = 2170
+			default:
+				return length
+			}
+
+		case 2170:
+			switch byteToLower(b) {
+			case 'h':
+				st = 2171
+			default:
+				return length
+			}
+
+		case 2171:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2172
+			default:
+				return length
+			}
+
+		case 2172:
+			switch byteToLower(b) {
+			case 'r':
+				st = 2173
+			default:
+				return length
+			}
+
+		case 2173:
+			switch byteToLower(b) {
+			case 'u':
+				st = 2174
+			default:
+				return length
+			}
+
+		case 2174:
+			switch byteToLower(b) {
+			case 'n':
+				st = 2175
+			default:
+				return length
+			}
+
+		case 2175:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 2176
+			default:
+				return length
+			}
+
+		case 2179:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2180
+			case 'd':
+				st = 2184
+			case 'l':
+				st = 2187
+			case 's':
+				st = 2191
+			default:
+				return length
+			}
+
+		case 2180:
+			switch byteToLower(b) {
+			case 'j':
+				st = 2181
+			default:
+				return length
+			}
+
+		case 2181:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2182
+			default:
+				return length
+			}
+
+		case 2182:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2183
+			default:
+				return length
+			}
+
+		case 2184:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2185
+			default:
+				return length
+			}
+
+		case 2185:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 2186
+			default:
+				return length
+			}
+
+		case 2187:
+			switch byteToLower(b) {
+			case 'l':
+				st = 2188
+			default:
+				return length
+			}
+
+		case 2188:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2189
+			default:
+				return length
+			}
+
+		case 2189:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2190
+			default:
+				return length
+			}
+
+		case 2191:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2192
+			default:
+				return length
+			}
+
+		case 2192:
+			switch byteToLower(b) {
+			case 'o':
+				st = 2193
+			default:
+				return length
+			}
+
+		case 2193:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 2194
+			default:
+				return length
+			}
+
+		case 2195:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2196
+			default:
+				return length
+			}
+
+		case 2196:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2197
+			default:
+				return length
+			}
+
+		case 2197:
+			switch byteToLower(b) {
+			case 'n':
+				st = 2198
+			default:
+				return length
+			}
+
+		case 2198:
+			switch byteToLower(b) {
+			case 'd':
+				st = 2199
+			default:
+				return length
+			}
+
+		case 2199:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2200
+			default:
+				return length
+			}
+
+		case 2200:
+			switch byteToLower(b) {
+			case 'r':
+				st = 2201
+			default:
+				return length
+			}
+
+		case 2201:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2202
+			default:
+				return length
+			}
+
+		case 2202:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 2203
+			default:
+				return length
+			}
+
+		case 2205:
+			switch byteToLower(b) {
+			case 'd':
+				st = 2206
+			case 't':
+				st = 2209
+			case 'y':
+				st = 2215
+			default:
+				return length
+			}
+
+		case 2206:
+			switch byteToLower(b) {
+			case 'k':
+				st = 2207
+			default:
+				return length
+			}
+
+		case 2207:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 2208
+			default:
+				return length
+			}
+
+		case 2209:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 2210
+			case 'i':
+				st = 2211
+			case 'o':
+				length = i + 1
+				st = 2214
+			default:
+				return length
+			}
+
+		case 2211:
+			switch byteToLower(b) {
+			case 'n':
+				st = 2212
+			default:
+				return length
+			}
+
+		case 2212:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 2213
+			default:
+				return length
+			}
+
+		case 2215:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2216
+			default:
+				return length
+			}
+
+		case 2216:
+			switch byteToLower(b) {
+			case 'g':
+				st = 2217
+			default:
+				return length
+			}
+
+		case 2217:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 2218
+			default:
+				return length
+			}
+
+		case 2220:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2221
+			case 'e':
+				st = 2233
+			case 'f':
+				length = i + 1
+				st = 2249
+			case 'h':
+				st = 2250
+			case 'i':
+				st = 2256
+			case 'm':
+				st = 2271
+			case 'o':
+				st = 2273
+			case 's':
+				length = i + 1
+				st = 2279
+			case 't':
+				st = 2280
+			default:
+				return length
+			}
+
+		case 2221:
+			switch byteToLower(b) {
+			case 'l':
+				st = 2222
+			case 'n':
+				st = 2228
+			case 't':
+				st = 2230
+			default:
+				return length
+			}
+
+		case 2222:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2223
+			case 't':
+				st = 2225
+			default:
+				return length
+			}
+
+		case 2223:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2224
+			default:
+				return length
+			}
+
+		case 2225:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2226
+			default:
+				return length
+			}
+
+		case 2226:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 2227
+			default:
+				return length
+			}
+
+		case 2228:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 2229
+			default:
+				return length
+			}
+
+		case 2230:
+			switch byteToLower(b) {
+			case 'c':
+				st = 2231
+			default:
+				return length
+			}
+
+		case 2231:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 2232
+			default:
+				return length
+			}
+
+		case 2233:
+			switch byteToLower(b) {
+			case 'b':
+				st = 2234
+			case 'd':
+				length = i + 1
+				st = 2242
+			case 'i':
+				st = 2247
+			default:
+				return length
+			}
+
+		case 2234:
+			switch byteToLower(b) {
+			case 'c':
+				st = 2235
+			case 's':
+				st = 2238
+			default:
+				return length
+			}
+
+		case 2235:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2236
+			default:
+				return length
+			}
+
+		case 2236:
+			switch byteToLower(b) {
+			case 'm':
+				length = i + 1
+				st = 2237
+			default:
+				return length
+			}
+
+		case 2238:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2239
+			default:
+				return length
+			}
+
+		case 2239:
+			switch byteToLower(b) {
+			case 't':
+				st = 2240
+			default:
+				return length
+			}
+
+		case 2240:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 2241
+			default:
+				return length
+			}
+
+		case 2242:
+			switch byteToLower(b) {
+			case 'd':
+				st = 2243
+			default:
+				return length
+			}
+
+		case 2243:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2244
+			default:
+				return length
+			}
+
+		case 2244:
+			switch byteToLower(b) {
+			case 'n':
+				st = 2245
+			default:
+				return length
+			}
+
+		case 2245:
+			switch byteToLower(b) {
+			case 'g':
+				length = i + 1
+				st = 2246
+			default:
+				return length
+			}
+
+		case 2247:
+			switch byteToLower(b) {
+			case 'r':
+				length = i + 1
+				st = 2248
+			default:
+				return length
+			}
+
+		case 2250:
+			switch byteToLower(b) {
+			case 'o':
+				st = 2251
+			default:
+				return length
+			}
+
+		case 2251:
+			switch byteToLower(b) {
+			case 's':
+				st = 2252
+			default:
+				return length
+			}
+
+		case 2252:
+			switch byteToLower(b) {
+			case 'w':
+				st = 2253
+			default:
+				return length
+			}
+
+		case 2253:
+			switch byteToLower(b) {
+			case 'h':
+				st = 2254
+			default:
+				return length
+			}
+
+		case 2254:
+			switch byteToLower(b) {
+			case 'o':
+				length = i + 1
+				st = 2255
+			default:
+				return length
+			}
+
+		case 2256:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2257
+			case 'k':
+				st = 2259
+			case 'l':
+				st = 2261
+			case 'n':
+				length = i + 1
+				st = 2270
+			default:
+				return length
+			}
+
+		case 2257:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 2258
+			default:
+				return length
+			}
+
+		case 2259:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 2260
+			default:
+				return length
+			}
+
+		case 2261:
+			switch byteToLower(b) {
+			case 'l':
+				st = 2262
+			default:
+				return length
+			}
+
+		case 2262:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2263
+			default:
+				return length
+			}
+
+		case 2263:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2264
+			default:
+				return length
+			}
+
+		case 2264:
+			switch byteToLower(b) {
+			case 'm':
+				st = 2265
+			default:
+				return length
+			}
+
+		case 2265:
+			switch byteToLower(b) {
+			case 'h':
+				st = 2266
+			default:
+				return length
+			}
+
+		case 2266:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2267
+			default:
+				return length
+			}
+
+		case 2267:
+			switch byteToLower(b) {
+			case 'l':
+				st = 2268
+			default:
+				return length
+			}
+
+		case 2268:
+			switch byteToLower(b) {
+			case 'l':
+				length = i + 1
+				st = 2269
+			default:
+				return length
+			}
+
+		case 2271:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 2272
+			default:
+				return length
+			}
+
+		case 2273:
+			switch byteToLower(b) {
+			case 'r':
+				st = 2274
+			default:
+				return length
+			}
+
+		case 2274:
+			switch byteToLower(b) {
+			case 'k':
+				length = i + 1
+				st = 2275
+			case 'l':
+				st = 2277
+			default:
+				return length
+			}
+
+		case 2275:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2276
+			default:
+				return length
+			}
+
+		case 2277:
+			switch byteToLower(b) {
+			case 'd':
+				length = i + 1
+				st = 2278
+			default:
+				return length
+			}
+
+		case 2280:
+			switch byteToLower(b) {
+			case 'c':
+				length = i + 1
+				st = 2281
+			case 'f':
+				length = i + 1
+				st = 2282
+			default:
+				return length
+			}
+
+		case 2283:
+			switch byteToLower(b) {
+			case 'b':
+				st = 2284
+			case 'e':
+				st = 2287
+			case 'i':
+				st = 2291
+			case 'x':
+				st = 2293
+			case 'y':
+				st = 2295
+			case 'n':
+				st = 2860
+			default:
+				return length
+			}
+
+		case 2284:
+			switch byteToLower(b) {
+			case 'o':
+				st = 2285
+			default:
+				return length
+			}
+
+		case 2285:
+			switch byteToLower(b) {
+			case 'x':
+				length = i + 1
+				st = 2286
+			default:
+				return length
+			}
+
+		case 2287:
+			switch byteToLower(b) {
+			case 'r':
+				st = 2288
+			default:
+				return length
+			}
+
+		case 2288:
+			switch byteToLower(b) {
+			case 'o':
+				st = 2289
+			default:
+				return length
+			}
+
+		case 2289:
+			switch byteToLower(b) {
+			case 'x':
+				length = i + 1
+				st = 2290
+			default:
+				return length
+			}
+
+		case 2291:
+			switch byteToLower(b) {
+			case 'n':
+				length = i + 1
+				st = 2292
+			default:
+				return length
+			}
+
+		case 2293:
+			switch byteToLower(b) {
+			case 'x':
+				length = i + 1
+				st = 2294
+			default:
+				return length
+			}
+
+		case 2295:
+			switch byteToLower(b) {
+			case 'z':
+				length = i + 1
+				st = 2296
+			default:
+				return length
+			}
+
+		case 2297:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2298
+			case 'e':
+				length = i + 1
+				st = 2307
+			case 'o':
+				st = 2308
+			case 't':
+				length = i + 1
+				st = 2329
+			default:
+				return length
+			}
+
+		case 2298:
+			switch byteToLower(b) {
+			case 'c':
+				st = 2299
+			case 'n':
+				st = 2303
+			default:
+				return length
+			}
+
+		case 2299:
+			switch byteToLower(b) {
+			case 'h':
+				st = 2300
+			default:
+				return length
+			}
+
+		case 2300:
+			switch byteToLower(b) {
+			case 't':
+				st = 2301
+			default:
+				return length
+			}
+
+		case 2301:
+			switch byteToLower(b) {
+			case 's':
+				length = i + 1
+				st = 2302
+			default:
+				return length
+			}
+
+		case 2303:
+			switch byteToLower(b) {
+			case 'd':
+				st = 2304
+			default:
+				return length
+			}
+
+		case 2304:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2305
+			default:
+				return length
+			}
+
+		case 2305:
+			switch byteToLower(b) {
+			case 'x':
+				length = i + 1
+				st = 2306
+			default:
+				return length
+			}
+
+		case 2308:
+			switch byteToLower(b) {
+			case 'd':
+				st = 2309
+			case 'g':
+				st = 2316
+			case 'k':
+				st = 2318
+			case 'u':
+				st = 2324
+			default:
+				return length
+			}
+
+		case 2309:
+			switch byteToLower(b) {
+			case 'o':
+				st = 2310
+			default:
+				return length
+			}
+
+		case 2310:
+			switch byteToLower(b) {
+			case 'b':
+				st = 2311
+			default:
+				return length
+			}
+
+		case 2311:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2312
+			default:
+				return length
+			}
+
+		case 2312:
+			switch byteToLower(b) {
+			case 's':
+				st = 2313
+			default:
+				return length
+			}
+
+		case 2313:
+			switch byteToLower(b) {
+			case 'h':
+				st = 2314
+			default:
+				return length
+			}
+
+		case 2314:
+			switch byteToLower(b) {
+			case 'i':
+				length = i + 1
+				st = 2315
+			default:
+				return length
+			}
+
+		case 2316:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 2317
+			default:
+				return length
+			}
+
+		case 2318:
+			switch byteToLower(b) {
+			case 'o':
+				st = 2319
+			default:
+				return length
+			}
+
+		case 2319:
+			switch byteToLower(b) {
+			case 'h':
+				st = 2320
+			default:
+				return length
+			}
+
+		case 2320:
+			switch byteToLower(b) {
+			case 'a':
+				st = 2321
+			default:
+				return length
+			}
+
+		case 2321:
+			switch byteToLower(b) {
+			case 'm':
+				st = 2322
+			default:
+				return length
+			}
+
+		case 2322:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 2323
+			default:
+				return length
+			}
+
+		case 2324:
+			switch byteToLower(b) {
+			case 't':
+				st = 2325
+			default:
+				return length
+			}
+
+		case 2325:
+			switch byteToLower(b) {
+			case 'u':
+				st = 2326
+			default:
+				return length
+			}
+
+		case 2326:
+			switch byteToLower(b) {
+			case 'b':
+				st = 2327
+			default:
+				return length
+			}
+
+		case 2327:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 2328
+			default:
+				return length
+			}
+
+		case 2330:
+			switch byteToLower(b) {
+			case 'a':
+				length = i + 1
+				st = 2331
+			case 'i':
+				st = 2332
+			case 'k':
+				st = 2334
+			case 'm':
+				length = i + 1
+				st = 2337
+			case 'o':
+				st = 2338
+			case 'u':
+				st = 2341
+			case 'w':
+				length = i + 1
+				st = 2347
+			default:
+				return length
+			}
+
+		case 2332:
+			switch byteToLower(b) {
+			case 'p':
+				length = i + 1
+				st = 2333
+			default:
+				return length
+			}
+
+		case 2334:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2335
+			default:
+				return length
+			}
+
+		case 2335:
+			switch byteToLower(b) {
+			case 'y':
+				length = i + 1
+				st = 2336
+			default:
+				return length
+			}
+
+		case 2338:
+			switch byteToLower(b) {
+			case 'n':
+				st = 2339
+			default:
+				return length
+			}
+
+		case 2339:
+			switch byteToLower(b) {
+			case 'e':
+				length = i + 1
+				st = 2340
+			default:
+				return length
+			}
+
+		case 2341:
+			switch byteToLower(b) {
+			case 'e':
+				st = 2342
+			default:
+				return length
+			}
+
+		case 2342:
+			switch byteToLower(b) {
+			case 'r':
+				st = 2343
+			default:
+				return length
+			}
+
+		case 2343:
+			switch byteToLower(b) {
+			case 'i':
+				st = 2344
+			default:
+				return length
+			}
+
+		case 2344:
+			switch byteToLower(b) {
+			case 'c':
+				st = 2345
+			default:
+				return length
+			}
+
+		case 2345:
+			switch byteToLower(b) {
+			case 'h':
+				length = i + 1
+				st = 2346
+			default:
+				return length
+			}
+
+		case 2348:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2349
+			default:
+				return length
+			}
+
+		case 2350:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2351
+			case '0':
+				st = 2368
+			case '1':
+				st = 2370
+			case '2':
+				st = 2372
+			case '3':
+				st = 2374
+			case '4':
+				st = 2376
+			case '5':
+				st = 2378
+			case '6':
+				st = 2380
+			case '7':
+				st = 2382
+			case '8':
+				st = 2384
+			case '9':
+				st = 2386
+			default:
+				return length
+			}
+
+		case 2352:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2353
+			case '0':
+				st = 2388
+			case '1':
+				st = 2390
+			case '2':
+				st = 2392
+			case '3':
+				st = 2394
+			case '4':
+				st = 2396
+			case '5':
+				st = 2398
+			case '6':
+				st = 2400
+			case '7':
+				st = 2402
+			case '8':
+				st = 2404
+			case '9':
+				st = 2406
+			default:
+				return length
+			}
+
+		case 2354:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2355
+			case '0':
+				st = 2408
+			case '1':
+				st = 2410
+			case '2':
+				st = 2412
+			case '3':
+				st = 2414
+			case '4':
+				st = 2416
+			case '5':
+				st = 2418
+			case '6':
+				st = 2420
+			case '7':
+				st = 2422
+			case '8':
+				st = 2424
+			case '9':
+				st = 2426
+			default:
+				return length
+			}
+
+		case 2356:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2357
+			case '0':
+				st = 2428
+			case '1':
+				st = 2430
+			case '2':
+				st = 2432
+			case '3':
+				st = 2434
+			case '4':
+				st = 2436
+			case '5':
+				st = 2438
+			case '6':
+				st = 2440
+			case '7':
+				st = 2442
+			case '8':
+				st = 2444
+			case '9':
+				st = 2446
+			default:
+				return length
+			}
+
+		case 2358:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2359
+			case '0':
+				st = 2448
+			case '1':
+				st = 2450
+			case '2':
+				st = 2452
+			case '3':
+				st = 2454
+			case '4':
+				st = 2456
+			case '5':
+				st = 2458
+			case '6':
+				st = 2460
+			case '7':
+				st = 2462
+			case '8':
+				st = 2464
+			case '9':
+				st = 2466
+			default:
+				return length
+			}
+
+		case 2360:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2361
+			case '0':
+				st = 2468
+			case '1':
+				st = 2470
+			case '2':
+				st = 2472
+			case '3':
+				st = 2474
+			case '4':
+				st = 2476
+			case '5':
+				st = 2478
+			case '6':
+				st = 2480
+			case '7':
+				st = 2482
+			case '8':
+				st = 2484
+			case '9':
+				st = 2486
+			default:
+				return length
+			}
+
+		case 2362:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2363
+			case '0':
+				st = 2488
+			case '1':
+				st = 2490
+			case '2':
+				st = 2492
+			case '3':
+				st = 2494
+			case '4':
+				st = 2496
+			case '5':
+				st = 2498
+			case '6':
+				st = 2500
+			case '7':
+				st = 2502
+			case '8':
+				st = 2504
+			case '9':
+				st = 2506
+			default:
+				return length
+			}
+
+		case 2364:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2365
+			case '0':
+				st = 2508
+			case '1':
+				st = 2510
+			case '2':
+				st = 2512
+			case '3':
+				st = 2514
+			case '4':
+				st = 2516
+			case '5':
+				st = 2518
+			case '6':
+				st = 2520
+			case '7':
+				st = 2522
+			case '8':
+				st = 2524
+			case '9':
+				st = 2526
+			default:
+				return length
+			}
+
+		case 2366:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2367
+			case '0':
+				st = 2528
+			case '1':
+				st = 2530
+			case '2':
+				st = 2532
+			case '3':
+				st = 2534
+			case '4':
+				st = 2536
+			case '5':
+				st = 2538
+			case '6':
+				st = 2540
+			case '7':
+				st = 2542
+			case '8':
+				st = 2544
+			case '9':
+				st = 2546
+			default:
+				return length
+			}
+
+		case 2368:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2369
+			case '0':
+				st = 2548
+			case '1':
+				st = 2550
+			case '2':
+				st = 2552
+			case '3':
+				st = 2554
+			case '4':
+				st = 2556
+			case '5':
+				st = 2558
+			case '6':
+				st = 2560
+			case '7':
+				st = 2562
+			case '8':
+				st = 2564
+			case '9':
+				st = 2566
+			default:
+				return length
+			}
+
+		case 2370:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2371
+			case '0':
+				st = 2568
+			case '1':
+				st = 2570
+			case '2':
+				st = 2572
+			case '3':
+				st = 2574
+			case '4':
+				st = 2576
+			case '5':
+				st = 2578
+			case '6':
+				st = 2580
+			case '7':
+				st = 2582
+			case '8':
+				st = 2584
+			case '9':
+				st = 2586
+			default:
+				return length
+			}
+
+		case 2372:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2373
+			case '0':
+				st = 2588
+			case '1':
+				st = 2590
+			case '2':
+				st = 2592
+			case '3':
+				st = 2594
+			case '4':
+				st = 2596
+			case '5':
+				st = 2598
+			case '6':
+				st = 2600
+			case '7':
+				st = 2602
+			case '8':
+				st = 2604
+			case '9':
+				st = 2606
+			default:
+				return length
+			}
+
+		case 2374:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2375
+			case '0':
+				st = 2608
+			case '1':
+				st = 2610
+			case '2':
+				st = 2612
+			case '3':
+				st = 2614
+			case '4':
+				st = 2616
+			case '5':
+				st = 2618
+			case '6':
+				st = 2620
+			case '7':
+				st = 2622
+			case '8':
+				st = 2624
+			case '9':
+				st = 2626
+			default:
+				return length
+			}
+
+		case 2376:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2377
+			case '0':
+				st = 2628
+			case '1':
+				st = 2630
+			case '2':
+				st = 2632
+			case '3':
+				st = 2634
+			case '4':
+				st = 2636
+			case '5':
+				st = 2638
+			case '6':
+				st = 2640
+			case '7':
+				st = 2642
+			case '8':
+				st = 2644
+			case '9':
+				st = 2646
+			default:
+				return length
+			}
+
+		case 2378:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2379
+			case '0':
+				st = 2648
+			case '1':
+				st = 2650
+			case '2':
+				st = 2652
+			case '3':
+				st = 2654
+			case '4':
+				st = 2656
+			case '5':
+				st = 2658
+			case '6':
+				st = 2660
+			case '7':
+				st = 2662
+			case '8':
+				st = 2664
+			case '9':
+				st = 2666
+			default:
+				return length
+			}
+
+		case 2380:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2381
+			case '0':
+				st = 2668
+			case '1':
+				st = 2670
+			case '2':
+				st = 2672
+			case '3':
+				st = 2674
+			case '4':
+				st = 2676
+			case '5':
+				st = 2678
+			case '6':
+				st = 2680
+			case '7':
+				st = 2682
+			case '8':
+				st = 2684
+			case '9':
+				st = 2686
+			default:
+				return length
+			}
+
+		case 2382:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2383
+			case '0':
+				st = 2688
+			case '1':
+				st = 2690
+			case '2':
+				st = 2692
+			case '3':
+				st = 2694
+			case '4':
+				st = 2696
+			case '5':
+				st = 2698
+			case '6':
+				st = 2700
+			case '7':
+				st = 2702
+			case '8':
+				st = 2704
+			case '9':
+				st = 2706
+			default:
+				return length
+			}
+
+		case 2384:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2385
+			case '0':
+				st = 2708
+			case '1':
+				st = 2710
+			case '2':
+				st = 2712
+			case '3':
+				st = 2714
+			case '4':
+				st = 2716
+			case '5':
+				st = 2718
+			case '6':
+				st = 2720
+			case '7':
+				st = 2722
+			case '8':
+				st = 2724
+			case '9':
+				st = 2726
+			default:
+				return length
+			}
+
+		case 2386:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2387
+			case '0':
+				st = 2728
+			case '1':
+				st = 2730
+			case '2':
+				st = 2732
+			case '3':
+				st = 2734
+			case '4':
+				st = 2736
+			case '5':
+				st = 2738
+			case '6':
+				st = 2740
+			case '7':
+				st = 2742
+			case '8':
+				st = 2744
+			case '9':
+				st = 2746
+			default:
+				return length
+			}
+
+		case 2388:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2389
+			case '0':
+				st = 2748
+			case '1':
+				st = 2750
+			case '2':
+				st = 2752
+			case '3':
+				st = 2754
+			case '4':
+				st = 2756
+			case '5':
+				st = 2758
+			case '6':
+				st = 2760
+			case '7':
+				st = 2762
+			case '8':
+				st = 2764
+			case '9':
+				st = 2766
+			default:
+				return length
+			}
+
+		case 2390:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2391
+			case '0':
+				st = 2768
+			case '1':
+				st = 2770
+			case '2':
+				st = 2772
+			case '3':
+				st = 2774
+			case '4':
+				st = 2776
+			case '5':
+				st = 2778
+			case '6':
+				st = 2780
+			case '7':
+				st = 2782
+			case '8':
+				st = 2784
+			case '9':
+				st = 2786
+			default:
+				return length
+			}
+
+		case 2392:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2393
+			case '0':
+				st = 2788
+			case '1':
+				st = 2790
+			case '2':
+				st = 2792
+			case '3':
+				st = 2794
+			case '4':
+				st = 2796
+			case '5':
+				st = 2798
+			case '6':
+				st = 2800
+			case '7':
+				st = 2802
+			case '8':
+				st = 2804
+			case '9':
+				st = 2806
+			default:
+				return length
+			}
+
+		case 2394:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2395
+			case '0':
+				st = 2808
+			case '1':
+				st = 2810
+			case '2':
+				st = 2812
+			case '3':
+				st = 2814
+			case '4':
+				st = 2816
+			case '5':
+				st = 2818
+			case '6':
+				st = 2820
+			case '7':
+				st = 2822
+			case '8':
+				st = 2824
+			case '9':
+				st = 2826
+			default:
+				return length
+			}
+
+		case 2396:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2397
+			case '0':
+				st = 2828
+			case '1':
+				st = 2830
+			case '2':
+				st = 2832
+			case '3':
+				st = 2834
+			case '4':
+				st = 2836
+			case '5':
+				st = 2838
+			case '6':
+				st = 2840
+			case '7':
+				st = 2842
+			case '8':
+				st = 2844
+			case '9':
+				st = 2846
+			default:
+				return length
+			}
+
+		case 2398:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2399
+			case '0':
+				st = 2848
+			case '1':
+				st = 2850
+			case '2':
+				st = 2852
+			case '3':
+				st = 2854
+			case '4':
+				st = 2856
+			case '5':
+				st = 2858
+			default:
+				return length
+			}
+
+		case 2400:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2401
+			default:
+				return length
+			}
+
+		case 2402:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2403
+			default:
+				return length
+			}
+
+		case 2404:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2405
+			default:
+				return length
+			}
+
+		case 2406:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2407
+			default:
+				return length
+			}
+
+		case 2408:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2409
+			default:
+				return length
+			}
+
+		case 2410:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2411
+			default:
+				return length
+			}
+
+		case 2412:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2413
+			default:
+				return length
+			}
+
+		case 2414:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2415
+			default:
+				return length
+			}
+
+		case 2416:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2417
+			default:
+				return length
+			}
+
+		case 2418:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2419
+			default:
+				return length
+			}
+
+		case 2420:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2421
+			default:
+				return length
+			}
+
+		case 2422:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2423
+			default:
+				return length
+			}
+
+		case 2424:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2425
+			default:
+				return length
+			}
+
+		case 2426:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2427
+			default:
+				return length
+			}
+
+		case 2428:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2429
+			default:
+				return length
+			}
+
+		case 2430:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2431
+			default:
+				return length
+			}
+
+		case 2432:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2433
+			default:
+				return length
+			}
+
+		case 2434:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2435
+			default:
+				return length
+			}
+
+		case 2436:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2437
+			default:
+				return length
+			}
+
+		case 2438:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2439
+			default:
+				return length
+			}
+
+		case 2440:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2441
+			default:
+				return length
+			}
+
+		case 2442:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2443
+			default:
+				return length
+			}
+
+		case 2444:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2445
+			default:
+				return length
+			}
+
+		case 2446:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2447
+			default:
+				return length
+			}
+
+		case 2448:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2449
+			default:
+				return length
+			}
+
+		case 2450:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2451
+			default:
+				return length
+			}
+
+		case 2452:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2453
+			default:
+				return length
+			}
+
+		case 2454:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2455
+			default:
+				return length
+			}
+
+		case 2456:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2457
+			default:
+				return length
+			}
+
+		case 2458:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2459
+			default:
+				return length
+			}
+
+		case 2460:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2461
+			default:
+				return length
+			}
+
+		case 2462:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2463
+			default:
+				return length
+			}
+
+		case 2464:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2465
+			default:
+				return length
+			}
+
+		case 2466:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2467
+			default:
+				return length
+			}
+
+		case 2468:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2469
+			default:
+				return length
+			}
+
+		case 2470:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2471
+			default:
+				return length
+			}
+
+		case 2472:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2473
+			default:
+				return length
+			}
+
+		case 2474:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2475
+			default:
+				return length
+			}
+
+		case 2476:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2477
+			default:
+				return length
+			}
+
+		case 2478:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2479
+			default:
+				return length
+			}
+
+		case 2480:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2481
+			default:
+				return length
+			}
+
+		case 2482:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2483
+			default:
+				return length
+			}
+
+		case 2484:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2485
+			default:
+				return length
+			}
+
+		case 2486:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2487
+			default:
+				return length
+			}
+
+		case 2488:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2489
+			default:
+				return length
+			}
+
+		case 2490:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2491
+			default:
+				return length
+			}
+
+		case 2492:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2493
+			default:
+				return length
+			}
+
+		case 2494:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2495
+			default:
+				return length
+			}
+
+		case 2496:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2497
+			default:
+				return length
+			}
+
+		case 2498:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2499
+			default:
+				return length
+			}
+
+		case 2500:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2501
+			default:
+				return length
+			}
+
+		case 2502:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2503
+			default:
+				return length
+			}
+
+		case 2504:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2505
+			default:
+				return length
+			}
+
+		case 2506:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2507
+			default:
+				return length
+			}
+
+		case 2508:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2509
+			default:
+				return length
+			}
+
+		case 2510:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2511
+			default:
+				return length
+			}
+
+		case 2512:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2513
+			default:
+				return length
+			}
+
+		case 2514:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2515
+			default:
+				return length
+			}
+
+		case 2516:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2517
+			default:
+				return length
+			}
+
+		case 2518:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2519
+			default:
+				return length
+			}
+
+		case 2520:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2521
+			default:
+				return length
+			}
+
+		case 2522:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2523
+			default:
+				return length
+			}
+
+		case 2524:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2525
+			default:
+				return length
+			}
+
+		case 2526:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2527
+			default:
+				return length
+			}
+
+		case 2528:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2529
+			default:
+				return length
+			}
+
+		case 2530:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2531
+			default:
+				return length
+			}
+
+		case 2532:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2533
+			default:
+				return length
+			}
+
+		case 2534:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2535
+			default:
+				return length
+			}
+
+		case 2536:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2537
+			default:
+				return length
+			}
+
+		case 2538:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2539
+			default:
+				return length
+			}
+
+		case 2540:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2541
+			default:
+				return length
+			}
+
+		case 2542:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2543
+			default:
+				return length
+			}
+
+		case 2544:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2545
+			default:
+				return length
+			}
+
+		case 2546:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2547
+			default:
+				return length
+			}
+
+		case 2548:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2549
+			default:
+				return length
+			}
+
+		case 2550:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2551
+			default:
+				return length
+			}
+
+		case 2552:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2553
+			default:
+				return length
+			}
+
+		case 2554:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2555
+			default:
+				return length
+			}
+
+		case 2556:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2557
+			default:
+				return length
+			}
+
+		case 2558:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2559
+			default:
+				return length
+			}
+
+		case 2560:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2561
+			default:
+				return length
+			}
+
+		case 2562:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2563
+			default:
+				return length
+			}
+
+		case 2564:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2565
+			default:
+				return length
+			}
+
+		case 2566:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2567
+			default:
+				return length
+			}
+
+		case 2568:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2569
+			default:
+				return length
+			}
+
+		case 2570:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2571
+			default:
+				return length
+			}
+
+		case 2572:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2573
+			default:
+				return length
+			}
+
+		case 2574:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2575
+			default:
+				return length
+			}
+
+		case 2576:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2577
+			default:
+				return length
+			}
+
+		case 2578:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2579
+			default:
+				return length
+			}
+
+		case 2580:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2581
+			default:
+				return length
+			}
+
+		case 2582:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2583
+			default:
+				return length
+			}
+
+		case 2584:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2585
+			default:
+				return length
+			}
+
+		case 2586:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2587
+			default:
+				return length
+			}
+
+		case 2588:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2589
+			default:
+				return length
+			}
+
+		case 2590:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2591
+			default:
+				return length
+			}
+
+		case 2592:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2593
+			default:
+				return length
+			}
+
+		case 2594:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2595
+			default:
+				return length
+			}
+
+		case 2596:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2597
+			default:
+				return length
+			}
+
+		case 2598:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2599
+			default:
+				return length
+			}
+
+		case 2600:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2601
+			default:
+				return length
+			}
+
+		case 2602:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2603
+			default:
+				return length
+			}
+
+		case 2604:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2605
+			default:
+				return length
+			}
+
+		case 2606:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2607
+			default:
+				return length
+			}
+
+		case 2608:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2609
+			default:
+				return length
+			}
+
+		case 2610:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2611
+			default:
+				return length
+			}
+
+		case 2612:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2613
+			default:
+				return length
+			}
+
+		case 2614:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2615
+			default:
+				return length
+			}
+
+		case 2616:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2617
+			default:
+				return length
+			}
+
+		case 2618:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2619
+			default:
+				return length
+			}
+
+		case 2620:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2621
+			default:
+				return length
+			}
+
+		case 2622:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2623
+			default:
+				return length
+			}
+
+		case 2624:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2625
+			default:
+				return length
+			}
+
+		case 2626:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2627
+			default:
+				return length
+			}
+
+		case 2628:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2629
+			default:
+				return length
+			}
+
+		case 2630:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2631
+			default:
+				return length
+			}
+
+		case 2632:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2633
+			default:
+				return length
+			}
+
+		case 2634:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2635
+			default:
+				return length
+			}
+
+		case 2636:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2637
+			default:
+				return length
+			}
+
+		case 2638:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2639
+			default:
+				return length
+			}
+
+		case 2640:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2641
+			default:
+				return length
+			}
+
+		case 2642:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2643
+			default:
+				return length
+			}
+
+		case 2644:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2645
+			default:
+				return length
+			}
+
+		case 2646:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2647
+			default:
+				return length
+			}
+
+		case 2648:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2649
+			default:
+				return length
+			}
+
+		case 2650:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2651
+			default:
+				return length
+			}
+
+		case 2652:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2653
+			default:
+				return length
+			}
+
+		case 2654:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2655
+			default:
+				return length
+			}
+
+		case 2656:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2657
+			default:
+				return length
+			}
+
+		case 2658:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2659
+			default:
+				return length
+			}
+
+		case 2660:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2661
+			default:
+				return length
+			}
+
+		case 2662:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2663
+			default:
+				return length
+			}
+
+		case 2664:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2665
+			default:
+				return length
+			}
+
+		case 2666:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2667
+			default:
+				return length
+			}
+
+		case 2668:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2669
+			default:
+				return length
+			}
+
+		case 2670:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2671
+			default:
+				return length
+			}
+
+		case 2672:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2673
+			default:
+				return length
+			}
+
+		case 2674:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2675
+			default:
+				return length
+			}
+
+		case 2676:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2677
+			default:
+				return length
+			}
+
+		case 2678:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2679
+			default:
+				return length
+			}
+
+		case 2680:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2681
+			default:
+				return length
+			}
+
+		case 2682:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2683
+			default:
+				return length
+			}
+
+		case 2684:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2685
+			default:
+				return length
+			}
+
+		case 2686:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2687
+			default:
+				return length
+			}
+
+		case 2688:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2689
+			default:
+				return length
+			}
+
+		case 2690:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2691
+			default:
+				return length
+			}
+
+		case 2692:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2693
+			default:
+				return length
+			}
+
+		case 2694:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2695
+			default:
+				return length
+			}
+
+		case 2696:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2697
+			default:
+				return length
+			}
+
+		case 2698:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2699
+			default:
+				return length
+			}
+
+		case 2700:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2701
+			default:
+				return length
+			}
+
+		case 2702:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2703
+			default:
+				return length
+			}
+
+		case 2704:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2705
+			default:
+				return length
+			}
+
+		case 2706:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2707
+			default:
+				return length
+			}
+
+		case 2708:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2709
+			default:
+				return length
+			}
+
+		case 2710:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2711
+			default:
+				return length
+			}
+
+		case 2712:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2713
+			default:
+				return length
+			}
+
+		case 2714:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2715
+			default:
+				return length
+			}
+
+		case 2716:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2717
+			default:
+				return length
+			}
+
+		case 2718:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2719
+			default:
+				return length
+			}
+
+		case 2720:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2721
+			default:
+				return length
+			}
+
+		case 2722:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2723
+			default:
+				return length
+			}
+
+		case 2724:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2725
+			default:
+				return length
+			}
+
+		case 2726:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2727
+			default:
+				return length
+			}
+
+		case 2728:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2729
+			default:
+				return length
+			}
+
+		case 2730:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2731
+			default:
+				return length
+			}
+
+		case 2732:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2733
+			default:
+				return length
+			}
+
+		case 2734:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2735
+			default:
+				return length
+			}
+
+		case 2736:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2737
+			default:
+				return length
+			}
+
+		case 2738:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2739
+			default:
+				return length
+			}
+
+		case 2740:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2741
+			default:
+				return length
+			}
+
+		case 2742:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2743
+			default:
+				return length
+			}
+
+		case 2744:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2745
+			default:
+				return length
+			}
+
+		case 2746:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2747
+			default:
+				return length
+			}
+
+		case 2748:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2749
+			default:
+				return length
+			}
+
+		case 2750:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2751
+			default:
+				return length
+			}
+
+		case 2752:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2753
+			default:
+				return length
+			}
+
+		case 2754:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2755
+			default:
+				return length
+			}
+
+		case 2756:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2757
+			default:
+				return length
+			}
+
+		case 2758:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2759
+			default:
+				return length
+			}
+
+		case 2760:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2761
+			default:
+				return length
+			}
+
+		case 2762:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2763
+			default:
+				return length
+			}
+
+		case 2764:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2765
+			default:
+				return length
+			}
+
+		case 2766:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2767
+			default:
+				return length
+			}
+
+		case 2768:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2769
+			default:
+				return length
+			}
+
+		case 2770:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2771
+			default:
+				return length
+			}
+
+		case 2772:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2773
+			default:
+				return length
+			}
+
+		case 2774:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2775
+			default:
+				return length
+			}
+
+		case 2776:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2777
+			default:
+				return length
+			}
+
+		case 2778:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2779
+			default:
+				return length
+			}
+
+		case 2780:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2781
+			default:
+				return length
+			}
+
+		case 2782:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2783
+			default:
+				return length
+			}
+
+		case 2784:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2785
+			default:
+				return length
+			}
+
+		case 2786:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2787
+			default:
+				return length
+			}
+
+		case 2788:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2789
+			default:
+				return length
+			}
+
+		case 2790:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2791
+			default:
+				return length
+			}
+
+		case 2792:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2793
+			default:
+				return length
+			}
+
+		case 2794:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2795
+			default:
+				return length
+			}
+
+		case 2796:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2797
+			default:
+				return length
+			}
+
+		case 2798:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2799
+			default:
+				return length
+			}
+
+		case 2800:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2801
+			default:
+				return length
+			}
+
+		case 2802:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2803
+			default:
+				return length
+			}
+
+		case 2804:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2805
+			default:
+				return length
+			}
+
+		case 2806:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2807
+			default:
+				return length
+			}
+
+		case 2808:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2809
+			default:
+				return length
+			}
+
+		case 2810:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2811
+			default:
+				return length
+			}
+
+		case 2812:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2813
+			default:
+				return length
+			}
+
+		case 2814:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2815
+			default:
+				return length
+			}
+
+		case 2816:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2817
+			default:
+				return length
+			}
+
+		case 2818:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2819
+			default:
+				return length
+			}
+
+		case 2820:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2821
+			default:
+				return length
+			}
+
+		case 2822:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2823
+			default:
+				return length
+			}
+
+		case 2824:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2825
+			default:
+				return length
+			}
+
+		case 2826:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2827
+			default:
+				return length
+			}
+
+		case 2828:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2829
+			default:
+				return length
+			}
+
+		case 2830:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2831
+			default:
+				return length
+			}
+
+		case 2832:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2833
+			default:
+				return length
+			}
+
+		case 2834:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2835
+			default:
+				return length
+			}
+
+		case 2836:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2837
+			default:
+				return length
+			}
+
+		case 2838:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2839
+			default:
+				return length
+			}
+
+		case 2840:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2841
+			default:
+				return length
+			}
+
+		case 2842:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2843
+			default:
+				return length
+			}
+
+		case 2844:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2845
+			default:
+				return length
+			}
+
+		case 2846:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2847
+			default:
+				return length
+			}
+
+		case 2848:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2849
+			default:
+				return length
+			}
+
+		case 2850:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2851
+			default:
+				return length
+			}
+
+		case 2852:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2853
+			default:
+				return length
+			}
+
+		case 2854:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2855
+			default:
+				return length
+			}
+
+		case 2856:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2857
+			default:
+				return length
+			}
+
+		case 2858:
+			switch b {
+			case '.':
+				length = i + 1
+				st = 2859
+			default:
+				return length
+			}
+
+		case 2860:
+			switch b {
+			case '-':
+				st = 2861
+			default:
+				return length
+			}
+
+		case 2861:
+			switch b {
+			case '-':
+				length = i + 1
+				st = 2862
+			default:
+				return length
+			}
+
+		}
+	}
+
+	return length
+}
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/genfsm/genfsm.go b/vendor/gitlab.com/golang-commonmark/linkify/genfsm/genfsm.go
new file mode 100644
index 000000000..3602ef409
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/genfsm/genfsm.go
@@ -0,0 +1,162 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"log"
+	"os"
+	"strings"
+)
+
+var output = flag.String("o", "", "Output file")
+
+type node struct {
+	b byte    // byte
+	s int     // state
+	c []*node // children
+	f bool    // final state?
+}
+
+func letter(b byte) bool {
+	return b >= 'a' && b <= 'z' || b >= 'A' && b <= 'Z'
+}
+
+func main() {
+	log.SetFlags(0)
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "Usage: %s [-o output.go] input.txt package.function\n", os.Args[0])
+		flag.PrintDefaults()
+	}
+	flag.Parse()
+	args := flag.Args()
+	if len(args) != 2 {
+		flag.Usage()
+		os.Exit(1)
+	}
+	if !strings.Contains(args[1], ".") {
+		flag.Usage()
+		os.Exit(1)
+	}
+	split := strings.SplitN(args[1], ".", 2)
+	pkg, fun := split[0], split[1]
+
+	f, err := os.Open(args[0])
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f.Close()
+
+	root := &node{}
+	var nodes []*node
+	nodes = append(nodes, root)
+	s := 0 // state
+	scan := bufio.NewScanner(f)
+
+	for scan.Scan() {
+		str := scan.Text()
+
+		cur := root
+		for i := 0; i < len(str); i++ {
+			b := str[i]
+			var n *node
+			found := false
+
+			for _, n = range cur.c {
+				if n.b == b {
+					found = true
+					break
+				}
+			}
+
+			if !found {
+				s++
+				n = &node{b: b, s: s}
+				cur.c = append(cur.c, n)
+				nodes = append(nodes, n)
+			}
+
+			cur = n
+			if i == len(str)-1 {
+				cur.f = true
+			}
+		}
+	}
+
+	buf := bytes.NewBuffer(nil)
+
+	fmt.Fprintf(buf, `// Code generated by genfsm.go. DO NOT EDIT
+
+package %s
+`, pkg)
+	fmt.Fprintf(buf, `
+	func %s(s string) int {
+	st := 0
+	length := -1
+
+	for i := 0; i < len(s); i++ {
+		b := s[i]
+
+		switch st {`, fun)
+
+	for _, n := range nodes {
+		if len(n.c) > 0 {
+			fmt.Fprintf(buf, "case %d:\n", n.s)
+			hasLetter := false
+			for _, c := range n.c {
+				if letter(c.b) {
+					hasLetter = true
+				}
+			}
+			if hasLetter {
+				fmt.Fprintf(buf, "switch byteToLower(b) {\n")
+			} else {
+				fmt.Fprintf(buf, "switch b {\n")
+			}
+
+			for _, c := range n.c {
+				fmt.Fprintf(buf, "case '%c':\n", c.b)
+				if c.f {
+					fmt.Fprintln(buf, "length = i+1")
+				}
+				fmt.Fprintf(buf, "st = %d\n", c.s)
+			}
+
+			fmt.Fprintf(buf, `default:
+			return length
+		}
+
+			`)
+
+		}
+	}
+
+	fmt.Fprintln(buf, `
+		}
+	}
+
+	return length
+}`)
+	source, err := format.Source(buf.Bytes())
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if *output == "" || *output == "-" {
+		os.Stdout.Write(source)
+	} else {
+		out, err := os.OpenFile(*output, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0600)
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer out.Close()
+
+		out.Write(source)
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/genfsm/suffixes.txt b/vendor/gitlab.com/golang-commonmark/linkify/genfsm/suffixes.txt
new file mode 100644
index 000000000..ce6208145
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/genfsm/suffixes.txt
@@ -0,0 +1,1130 @@
+abb
+abbott
+abogado
+ac
+academy
+accenture
+accountant
+accountants
+active
+actor
+ad
+ads
+adult
+ae
+aero
+af
+afl
+ag
+agency
+ai
+aig
+airforce
+al
+allfinanz
+alsace
+am
+amsterdam
+an
+android
+ao
+apartments
+aq
+aquarelle
+ar
+archi
+army
+arpa
+as
+asia
+associates
+at
+attorney
+au
+auction
+audio
+auto
+autos
+aw
+ax
+axa
+az
+ba
+band
+bank
+bar
+barclaycard
+barclays
+bargains
+bauhaus
+bayern
+bb
+bbc
+bbva
+bd
+be
+beer
+berlin
+best
+bf
+bg
+bh
+bi
+bible
+bid
+bike
+bingo
+bio
+bit
+biz
+bj
+black
+blackfriday
+bloomberg
+blue
+bm
+bmw
+bn
+bnpparibas
+bo
+boats
+bond
+boo
+boutique
+br
+bridgestone
+broker
+brother
+brussels
+bs
+bt
+budapest
+build
+builders
+business
+buzz
+bv
+bw
+by
+bz
+bzh
+ca
+cab
+cafe
+cal
+camera
+camp
+cancerresearch
+canon
+capetown
+capital
+caravan
+cards
+care
+career
+careers
+cars
+cartier
+casa
+cash
+casino
+cat
+catering
+cbn
+cc
+cd
+center
+ceo
+cern
+cf
+cfa
+cfd
+cg
+ch
+channel
+chat
+cheap
+chloe
+christmas
+chrome
+church
+ci
+cisco
+citic
+city
+ck
+cl
+claims
+cleaning
+click
+clinic
+clothing
+club
+cm
+cn
+co
+coach
+codes
+coffee
+college
+cologne
+com
+community
+company
+computer
+condos
+construction
+consulting
+contractors
+cooking
+cool
+coop
+corsica
+country
+coupons
+courses
+cr
+credit
+creditcard
+cricket
+crs
+cruises
+cu
+cuisinella
+cv
+cw
+cx
+cy
+cymru
+cyou
+cz
+dabur
+dad
+dance
+date
+dating
+datsun
+day
+dclk
+de
+deals
+degree
+delivery
+democrat
+dental
+dentist
+desi
+design
+dev
+diamonds
+diet
+digital
+direct
+directory
+discount
+dj
+dk
+dm
+dnp
+do
+docs
+dog
+doha
+domains
+doosan
+download
+durban
+dvag
+dz
+earth
+eat
+ec
+edu
+education
+ee
+eg
+email
+emerck
+energy
+engineer
+engineering
+enterprises
+epson
+equipment
+er
+erni
+es
+esq
+estate
+et
+eu
+eurovision
+eus
+events
+everbank
+exchange
+exit
+expert
+exposed
+express
+fail
+faith
+fan
+fans
+farm
+fashion
+feedback
+fi
+film
+finance
+financial
+firmdale
+fish
+fishing
+fit
+fitness
+fj
+fk
+flights
+florist
+flowers
+flsmidth
+fly
+fm
+fo
+foo
+football
+forex
+forsale
+foundation
+fr
+frl
+frogans
+fund
+furniture
+futbol
+fyi
+ga
+gal
+gallery
+garden
+gb
+gbiz
+gd
+gdn
+ge
+gent
+gf
+gg
+ggee
+gh
+gi
+gift
+gifts
+gives
+gl
+glass
+gle
+global
+globo
+gm
+gmail
+gmo
+gmx
+gn
+gnu
+gold
+goldpoint
+golf
+goo
+goog
+google
+gop
+gov
+gp
+gq
+gr
+graphics
+gratis
+green
+gripe
+gs
+gt
+gu
+guge
+guide
+guitars
+guru
+gw
+gy
+hamburg
+hangout
+haus
+healthcare
+help
+here
+hermes
+hiphop
+hitachi
+hiv
+hk
+hm
+hn
+hockey
+holdings
+holiday
+homedepot
+homes
+honda
+horse
+host
+hosting
+house
+how
+hr
+ht
+hu
+i2p
+ibm
+icbc
+icu
+id
+ie
+ifm
+il
+im
+immo
+immobilien
+in
+industries
+infiniti
+info
+ing
+ink
+institute
+insure
+int
+international
+investments
+io
+iq
+ir
+irish
+is
+it
+iwc
+java
+jcb
+je
+jetzt
+jewelry
+jll
+jm
+jo
+jobs
+joburg
+jp
+juegos
+kaufen
+kddi
+ke
+kg
+kh
+ki
+kim
+kitchen
+kiwi
+km
+kn
+koeln
+komatsu
+kp
+kr
+krd
+kred
+kw
+ky
+kyoto
+kz
+la
+lacaixa
+land
+lat
+latrobe
+lawyer
+lb
+lc
+lds
+lease
+leclerc
+legal
+lgbt
+li
+liaison
+lidl
+life
+lighting
+limited
+limo
+link
+lk
+loan
+loans
+local
+lol
+london
+lotte
+lotto
+love
+lr
+ls
+lt
+ltda
+lu
+lupin
+luxe
+luxury
+lv
+ly
+ma
+madrid
+maif
+maison
+management
+mango
+market
+marketing
+markets
+marriott
+mba
+mc
+md
+me
+media
+meet
+melbourne
+meme
+memorial
+men
+menu
+mg
+mh
+miami
+mil
+mini
+mk
+ml
+mm
+mma
+mn
+mo
+mobi
+moda
+moe
+monash
+money
+mormon
+mortgage
+moscow
+motorcycles
+mov
+movie
+mp
+mq
+mr
+ms
+mt
+mtn
+mtpc
+mu
+museum
+mv
+mw
+mx
+my
+mz
+na
+nadex
+nagoya
+name
+navy
+nc
+ne
+nec
+net
+network
+neustar
+new
+news
+nexus
+nf
+ng
+ngo
+nhk
+ni
+nico
+ninja
+nissan
+nl
+no
+np
+nr
+nra
+nrw
+ntt
+nu
+nyc
+nz
+okinawa
+om
+one
+ong
+onion
+onl
+online
+ooo
+oracle
+org
+organic
+osaka
+otsuka
+ovh
+pa
+page
+panerai
+paris
+partners
+parts
+party
+pe
+pf
+pg
+ph
+pharmacy
+philips
+photo
+photography
+photos
+physio
+piaget
+pics
+pictet
+pictures
+pink
+pizza
+pk
+pl
+place
+plumbing
+plus
+pm
+pn
+pohl
+poker
+porn
+post
+pr
+praxi
+press
+pro
+prod
+productions
+prof
+properties
+property
+ps
+pt
+pub
+pw
+py
+qa
+qpon
+quebec
+racing
+re
+realtor
+recipes
+red
+redstone
+rehab
+reise
+reisen
+reit
+ren
+rent
+rentals
+repair
+report
+republican
+rest
+restaurant
+review
+reviews
+rich
+rio
+rip
+ro
+rocks
+rodeo
+rs
+rsvp
+ru
+ruhr
+run
+rw
+ryukyu
+sa
+saarland
+sale
+samsung
+sandvik
+sandvikcoromant
+sap
+sarl
+saxo
+sb
+sc
+sca
+scb
+schmidt
+scholarships
+school
+schule
+schwarz
+science
+scot
+sd
+se
+seat
+sener
+services
+sew
+sex
+sexy
+sg
+sh
+shiksha
+shoes
+show
+shriram
+si
+singles
+site
+sj
+sk
+ski
+sky
+sl
+sm
+sn
+sncf
+so
+soccer
+social
+software
+sohu
+solar
+solutions
+sony
+soy
+space
+spiegel
+spreadbetting
+sr
+st
+study
+style
+su
+sucks
+supplies
+supply
+support
+surf
+surgery
+suzuki
+sv
+swiss
+sx
+sy
+sydney
+systems
+sz
+taipei
+tatar
+tattoo
+tax
+taxi
+tc
+td
+team
+tech
+technology
+tel
+temasek
+tennis
+tf
+tg
+th
+thd
+theater
+tickets
+tienda
+tips
+tires
+tirol
+tj
+tk
+tl
+tm
+tn
+to
+today
+tokyo
+tools
+top
+toray
+toshiba
+tours
+town
+toys
+tr
+trade
+trading
+training
+travel
+trust
+tt
+tui
+tv
+tw
+tz
+ua
+ug
+uk
+university
+uno
+uol
+us
+uy
+uz
+va
+vacations
+vc
+ve
+vegas
+ventures
+versicherung
+vet
+vg
+vi
+viajes
+video
+villas
+vision
+vlaanderen
+vn
+vodka
+vote
+voting
+voto
+voyage
+vu
+wales
+walter
+wang
+watch
+webcam
+website
+wed
+wedding
+weir
+wf
+whoswho
+wien
+wiki
+williamhill
+win
+wme
+work
+works
+world
+ws
+wtc
+wtf
+xbox
+xerox
+xin
+xxx
+xyz
+yachts
+yandex
+ye
+yodobashi
+yoga
+yokohama
+youtube
+yt
+za
+zip
+zkey
+zm
+zone
+zuerich
+zw
+0.
+1.
+2.
+3.
+4.
+5.
+6.
+7.
+8.
+9.
+10.
+11.
+12.
+13.
+14.
+15.
+16.
+17.
+18.
+19.
+20.
+21.
+22.
+23.
+24.
+25.
+26.
+27.
+28.
+29.
+30.
+31.
+32.
+33.
+34.
+35.
+36.
+37.
+38.
+39.
+40.
+41.
+42.
+43.
+44.
+45.
+46.
+47.
+48.
+49.
+50.
+51.
+52.
+53.
+54.
+55.
+56.
+57.
+58.
+59.
+60.
+61.
+62.
+63.
+64.
+65.
+66.
+67.
+68.
+69.
+70.
+71.
+72.
+73.
+74.
+75.
+76.
+77.
+78.
+79.
+80.
+81.
+82.
+83.
+84.
+85.
+86.
+87.
+88.
+89.
+90.
+91.
+92.
+93.
+94.
+95.
+96.
+97.
+98.
+99.
+100.
+101.
+102.
+103.
+104.
+105.
+106.
+107.
+108.
+109.
+110.
+111.
+112.
+113.
+114.
+115.
+116.
+117.
+118.
+119.
+120.
+121.
+122.
+123.
+124.
+125.
+126.
+127.
+128.
+129.
+130.
+131.
+132.
+133.
+134.
+135.
+136.
+137.
+138.
+139.
+140.
+141.
+142.
+143.
+144.
+145.
+146.
+147.
+148.
+149.
+150.
+151.
+152.
+153.
+154.
+155.
+156.
+157.
+158.
+159.
+160.
+161.
+162.
+163.
+164.
+165.
+166.
+167.
+168.
+169.
+170.
+171.
+172.
+173.
+174.
+175.
+176.
+177.
+178.
+179.
+180.
+181.
+182.
+183.
+184.
+185.
+186.
+187.
+188.
+189.
+190.
+191.
+192.
+193.
+194.
+195.
+196.
+197.
+198.
+199.
+200.
+201.
+202.
+203.
+204.
+205.
+206.
+207.
+208.
+209.
+210.
+211.
+212.
+213.
+214.
+215.
+216.
+217.
+218.
+219.
+220.
+221.
+222.
+223.
+224.
+225.
+226.
+227.
+228.
+229.
+230.
+231.
+232.
+233.
+234.
+235.
+236.
+237.
+238.
+239.
+240.
+241.
+242.
+243.
+244.
+245.
+246.
+247.
+248.
+249.
+250.
+251.
+252.
+253.
+254.
+255.
+xn--
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/linkify.go b/vendor/gitlab.com/golang-commonmark/linkify/linkify.go
new file mode 100644
index 000000000..116d56153
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/linkify.go
@@ -0,0 +1,462 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package linkify provides a way to find links in plain text.
+package linkify
+
+import (
+	"strings"
+	"unicode/utf8"
+)
+
+// Link represents a link found in a string with a schema and a position in the string.
+type Link struct {
+	Scheme     string
+	Start, End int
+}
+
+func max(a, b int) int {
+	if a >= b {
+		return a
+	}
+	return b
+}
+
+// Links returns links found in s.
+func Links(s string) (links []Link) {
+	for i := 0; i < len(s)-2; i++ {
+		switch s[i] {
+		case '.': // IP address or domain name
+			if i == 0 {
+				continue // . at the start of a line
+			}
+			if length := match(s[i+1:]); length > 0 {
+				pos := i + 1 + length
+				switch s[pos-1] {
+				case '.': // IP address
+					if pos >= len(s) {
+						continue // . at the end of line
+					}
+					if !digit(s[i-1]) {
+						i = pos
+						continue // . should be preceded by a digit
+					}
+					if !digit(s[pos]) {
+						i = pos
+						continue // . should be followed by a digit
+					}
+
+					// find the start of the IP address
+					j := i - 2
+					m := max(0, j-3)
+					for j >= m && digit(s[j]) {
+						j--
+					}
+					if i-2-j > 2 {
+						i = pos + 1
+						continue // at most 3 digits
+					}
+					start := 0
+					if j >= 0 {
+						r, rlen := utf8.DecodeLastRuneInString(s[:j+1])
+						if !isPunctOrSpaceOrControl(r) {
+							i = pos + 1
+							continue
+						}
+						switch r {
+						case '.', ':', '/', '\\', '-', '_':
+							i = pos + 1
+							continue
+						}
+						start = j + 2 - rlen
+					}
+
+					length, ok := skipIPv4(s[start:])
+					if !ok {
+						i = pos + 1
+						continue
+					}
+					end := start + length
+					if end == len(s) {
+						links = append(links, Link{
+							Scheme: "",
+							Start:  start,
+							End:    end,
+						})
+						return
+					}
+
+					r, _ := utf8.DecodeRuneInString(s[end:])
+					if !isPunctOrSpaceOrControl(r) {
+						continue
+					}
+
+					end = skipPort(s, end)
+					end = skipPath(s, end)
+					end = skipQuery(s, end)
+					end = skipFragment(s, end)
+					end = unskipPunct(s, end)
+
+					if end < len(s) {
+						r, _ = utf8.DecodeRuneInString(s[end:])
+						if !isPunctOrSpaceOrControl(r) || r == '%' {
+							continue
+						}
+					}
+
+					links = append(links, Link{
+						Scheme: "",
+						Start:  start,
+						End:    end,
+					})
+					i = end
+
+				default: // domain name
+					r, _ := utf8.DecodeLastRuneInString(s[:i])
+					if isPunctOrSpaceOrControl(r) {
+						continue
+					}
+
+					if pos == len(s) {
+						start, ok := findHostnameStart(s, i)
+						if !ok {
+							continue
+						}
+						links = append(links, Link{
+							Scheme: "",
+							Start:  start,
+							End:    pos,
+						})
+						return
+					}
+
+					if s[i+1:pos] != "xn--" {
+						r, _ = utf8.DecodeRuneInString(s[pos:])
+						if isLetterOrDigit(r) {
+							continue // should not be followed by a letter or a digit
+						}
+					}
+
+					end, dot, ok := findHostnameEnd(s, pos)
+					if !ok {
+						continue
+					}
+					dot = max(dot, i)
+
+					if !(dot+5 <= len(s) && s[dot+1:dot+5] == "xn--") {
+						if length := match(s[dot+1:]); dot+length+1 != end {
+							continue
+						}
+					}
+
+					start, ok := findHostnameStart(s, i)
+					if !ok {
+						continue
+					}
+
+					end = skipPort(s, end)
+					end = skipPath(s, end)
+					end = skipQuery(s, end)
+					end = skipFragment(s, end)
+					end = unskipPunct(s, end)
+
+					if end < len(s) {
+						r, _ = utf8.DecodeRuneInString(s[end:])
+						if !isPunctOrSpaceOrControl(r) || r == '%' {
+							continue // should be followed by punctuation or space
+						}
+					}
+
+					links = append(links, Link{
+						Scheme: "",
+						Start:  start,
+						End:    end,
+					})
+					i = end
+				}
+			}
+
+		case '/': // schema-less link
+			if s[i+1] != '/' {
+				continue
+			}
+
+			if i > 0 {
+				if s[i-1] == ':' {
+					i++
+					continue // should not be preceded by a colon
+				}
+				r, _ := utf8.DecodeLastRuneInString(s[:i])
+				if !isPunctOrSpaceOrControl(r) {
+					i++
+					continue // should be preceded by punctuation or space
+				}
+			}
+
+			r, _ := utf8.DecodeRuneInString(s[i+2:])
+			if !isLetterOrDigit(r) {
+				i++
+				continue // should be followed by a letter or a digit
+			}
+
+			start := i
+			end, dot, ok := findHostnameEnd(s, i+2)
+			if !ok {
+				continue
+			}
+			if s[i+2:end] != "localhost" {
+				if dot == -1 {
+					continue // no dot
+				}
+				if length, ok := skipIPv4(s[i+2:]); !ok || i+2+length != end {
+					if length := match(s[dot+1:]); dot+length+1 != end {
+						continue
+					}
+				}
+			}
+
+			end = skipPort(s, end)
+			end = skipPath(s, end)
+			end = skipQuery(s, end)
+			end = skipFragment(s, end)
+			end = unskipPunct(s, end)
+
+			if end < len(s) {
+				r, _ = utf8.DecodeRuneInString(s[end:])
+				if !isPunctOrSpaceOrControl(r) || r == '%' {
+					continue // should be followed by punctuation or space
+				}
+			}
+
+			links = append(links, Link{
+				Scheme: "//",
+				Start:  start,
+				End:    end,
+			})
+			i = end
+
+		case ':': // http, https, ftp, mailto or localhost
+			if i < 3 { // at least ftp:
+				continue
+			}
+
+			if i >= 9 && s[i-1] == 't' && s[i-9:i] == "localhost" {
+				j := i - 9
+				if !digit(s[j+10]) {
+					continue
+				}
+				if j > 0 {
+					r, _ := utf8.DecodeLastRuneInString(s[:j])
+					if !isPunctOrSpaceOrControl(r) {
+						i++
+						continue // should be preceded by punctuation or space
+					}
+				}
+
+				start := j
+				pos := j + 9
+				end := skipPort(s, pos)
+				if end == pos {
+					continue // invalid port
+				}
+				end = skipPath(s, end)
+				end = skipQuery(s, end)
+				end = skipFragment(s, end)
+				end = unskipPunct(s, end)
+
+				if end < len(s) {
+					r, _ := utf8.DecodeRuneInString(s[end:])
+					if !isPunctOrSpaceOrControl(r) || r == '%' {
+						i++
+						continue // should be followed by punctuation or space
+					}
+				}
+
+				links = append(links, Link{
+					Scheme: "",
+					Start:  start,
+					End:    end,
+				})
+				i = end
+
+				break
+			}
+
+			j := i - 1
+			var start int
+			var schema string
+
+			switch byteToLower(s[j]) {
+			case 'o': // mailto
+				if j < 5 {
+					continue // too short for mailto
+				}
+				if len(s)-j < 8 {
+					continue // insufficient length after
+				}
+				if strings.ToLower(s[j-5:j+2]) != "mailto:" {
+					continue
+				}
+				r, _ := utf8.DecodeLastRuneInString(s[:j-5])
+				if isLetterOrDigit(r) {
+					continue // should not be preceded by a letter or a digit
+				}
+				r, _ = utf8.DecodeRuneInString(s[j+2:])
+				if !isAllowedInEmail(r) {
+					continue // should be followed by a valid e-mail character
+				}
+
+				start = j - 5
+				end, ok := findEmailEnd(s, j+2)
+				if !ok {
+					continue
+				}
+
+				links = append(links, Link{
+					Scheme: "mailto:",
+					Start:  start,
+					End:    end,
+				})
+				i = end
+				continue // continue processing
+
+			case 'p': // http or ftp
+				if len(s)-j < 8 {
+					continue // insufficient length after
+				}
+				switch byteToLower(s[j-2]) {
+				case 'f':
+					if strings.ToLower(s[j-2:j+4]) != "ftp://" {
+						continue
+					}
+					start = j - 2
+					schema = "ftp:"
+				case 't':
+					if j < 3 {
+						continue
+					}
+					if strings.ToLower(s[j-3:j+4]) != "http://" {
+						continue
+					}
+					start = j - 3
+					schema = "http:"
+				default:
+					continue
+				}
+
+			case 's': // https
+				if j < 4 {
+					continue // too short for https
+				}
+				if len(s)-j < 8 {
+					continue // insufficient length after
+				}
+				start = j - 4
+				if strings.ToLower(s[start:j+4]) != "https://" {
+					continue
+				}
+				schema = "https:"
+
+			default:
+				continue
+			}
+
+			// http, https or ftp
+
+			if start > 0 {
+				r, _ := utf8.DecodeLastRuneInString(s[:start])
+				if !isPunctOrSpaceOrControl(r) {
+					continue // should be preceded by punctuation or space
+				}
+			}
+
+			r, _ := utf8.DecodeRuneInString(s[j+4:])
+			if isPunctOrSpaceOrControl(r) {
+				continue
+			}
+
+			end, dot, ok := findHostnameEnd(s, j+4)
+			if !ok {
+				continue
+			}
+			if s[j+4:end] != "localhost" {
+				if dot == -1 {
+					continue // no dot
+				}
+				if length, ok := skipIPv4(s[j+4:]); !ok || j+4+length != end {
+					if !(dot+5 <= len(s) && s[dot+1:dot+5] == "xn--") {
+						if length := match(s[dot+1:]); dot+length+1 != end {
+							continue
+						}
+					}
+				}
+			}
+
+			end = skipPort(s, end)
+			end = skipPath(s, end)
+			end = skipQuery(s, end)
+			end = skipFragment(s, end)
+			end = unskipPunct(s, end)
+
+			if end < len(s) {
+				r, _ = utf8.DecodeRuneInString(s[end:])
+				if !isPunctOrSpaceOrControl(r) || r == '%' {
+					continue // should be followed by punctuation or space
+				}
+			}
+
+			links = append(links, Link{
+				Scheme: schema,
+				Start:  start,
+				End:    end,
+			})
+			i = end
+
+		case '@': // schema-less e-mail
+			if i == 0 {
+				continue // @ at the start of a line
+			}
+
+			if len(s)-i < 5 {
+				continue // insufficient length after
+			}
+
+			r, _ := utf8.DecodeLastRuneInString(s[:i])
+			if !isAllowedInEmail(r) {
+				continue // should be preceded by a valid e-mail character
+			}
+
+			r, _ = utf8.DecodeRuneInString(s[i+1:])
+			if !isLetterOrDigit(r) {
+				continue // should be followed by a letter or a digit
+			}
+
+			start, ok := findEmailStart(s, i-1)
+			if !ok {
+				continue
+			}
+
+			end, dot, ok := findHostnameEnd(s, i+1)
+			if !ok {
+				continue
+			}
+			if dot == -1 {
+				continue // no dot
+			}
+			if !(dot+5 <= len(s) && s[dot+1:dot+5] == "xn--") {
+				if length := match(s[dot+1:]); dot+length+1 != end {
+					continue
+				}
+			}
+
+			links = append(links, Link{
+				Scheme: "mailto:",
+				Start:  start,
+				End:    end,
+			})
+			i = end
+		}
+	}
+	return
+}
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/linkify_benchmark_test.go b/vendor/gitlab.com/golang-commonmark/linkify/linkify_benchmark_test.go
new file mode 100644
index 000000000..7af3f1ead
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/linkify_benchmark_test.go
@@ -0,0 +1,22 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package linkify
+
+import "testing"
+
+func BenchmarkLinks(b *testing.B) {
+	input := `
+	Check out this link to http://google.com
+You can also email support@example.com to view more.
+
+Some more links: fsf.org http://www.gnu.org/licenses/gpl-3.0.en.html 127.0.0.1
+                 localhost:80	github.com/trending	//reddit.com/r/golang
+mailto:r@golang.org some.nonexistent.host.name flibustahezeous3.onion
+`
+
+	for i := 0; i < b.N; i++ {
+		Links(input)
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/linkify_example_test.go b/vendor/gitlab.com/golang-commonmark/linkify/linkify_example_test.go
new file mode 100644
index 000000000..6e1b870c5
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/linkify_example_test.go
@@ -0,0 +1,34 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package linkify
+
+import "fmt"
+
+func Example() {
+	input := `
+	Check out this link to http://google.com
+You can also email support@example.com to view more.
+
+Some more links: fsf.org http://www.gnu.org/licenses/gpl-3.0.en.html 127.0.0.1
+                 localhost:80	github.com/trending?l=Go	//reddit.com/r/golang
+mailto:r@golang.org some.nonexistent.host.name flibustahezeous3.onion
+`
+	for _, l := range Links(input) {
+		fmt.Printf("Scheme: %-8s  URL: %s\n", l.Scheme, input[l.Start:l.End])
+	}
+
+	// Output:
+	// Scheme: http:     URL: http://google.com
+	// Scheme: mailto:   URL: support@example.com
+	// Scheme:           URL: fsf.org
+	// Scheme: http:     URL: http://www.gnu.org/licenses/gpl-3.0.en.html
+	// Scheme:           URL: 127.0.0.1
+	// Scheme:           URL: localhost:80
+	// Scheme:           URL: github.com/trending?l=Go
+	// Scheme: //        URL: //reddit.com/r/golang
+	// Scheme: mailto:   URL: mailto:r@golang.org
+	// Scheme:           URL: some.nonexistent.host.name
+	// Scheme:           URL: flibustahezeous3.onion
+}
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/linkify_test.go b/vendor/gitlab.com/golang-commonmark/linkify/linkify_test.go
new file mode 100644
index 000000000..5c929342a
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/linkify_test.go
@@ -0,0 +1,383 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package linkify
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestLinks(t *testing.T) {
+	type testCase struct {
+		in   string
+		want []Link
+	}
+	testCases := []testCase{
+		{"", nil},
+
+		// 1
+
+		{"127.0.0.1:8080/path?query=xxx#fragment", []Link{{Scheme: "", Start: 0, End: 38}}},
+		{"127.0.0.1", []Link{{Scheme: "", Start: 0, End: 9}}},
+		{">127.0.0.1<", []Link{{Scheme: "", Start: 1, End: 10}}},
+		{"xxx 127.0.0.1", []Link{{Scheme: "", Start: 4, End: 13}}},
+		{"1.0001.0.1", nil},
+		{"1234.0.0", nil},
+		{"1.2345.0.1", nil},
+		{"1.2.3.4x", nil},
+		{"_127.0.0.1", nil},
+		{"127.0.0_1", nil},
+		{"127.0.0.1/%", nil},
+		{"127.0.0.1%", nil},
+		{"127.0.0._", nil},
+		{"127.0.0", nil},
+		{"127.0._.1", nil},
+		{" _.127.0", nil},
+		{" .127._", nil},
+		{" .127.", nil},
+		{" .127.X", nil},
+		{":234.0.0", nil},
+		{"256.0.0.1", nil},
+		{" X.127.0", nil},
+		{"x234.0.0", nil},
+
+		// 2
+
+		{"google.com!", []Link{{Scheme: "", Start: 0, End: 10}}},
+		{"google.com...", []Link{{Scheme: "", Start: 0, End: 10}}},
+		{"google.com.", []Link{{Scheme: "", Start: 0, End: 10}}},
+		{">google.com<", []Link{{Scheme: "", Start: 1, End: 11}}},
+		{"google.com/?search", []Link{{Scheme: "", Start: 0, End: 18}}},
+		{"some.host.name.com.net.abracadabra", nil},
+		{"some.host.name.com.net.org", []Link{{Scheme: "", Start: 0, End: 26}}},
+		{"some.host.name.com.net.org/", []Link{{Scheme: "", Start: 0, End: 27}}},
+		{"some.host.name.com.net.org/path?query=xxx#fragment", []Link{{Scheme: "", Start: 0, End: 50}}},
+		{"ya.ru", []Link{{Scheme: "", Start: 0, End: 5}}},
+		{"a.r", nil},
+		{".com", nil},
+		{".COM", nil},
+		{"-google.com", nil},
+		{"goo---gle.com", nil},
+		{"google-.com", nil},
+		{"google.com/%", nil},
+		{"google.comXXX", nil},
+		{"GOOGLE.COMXXX", nil},
+		{"images-.google.com", nil},
+		{"\ufffdgoogle.com", nil},
+		{"\x00.com", nil},
+		{"\x00.COM", nil},
+		{"xxx.com.abracadabra", nil},
+		{"XXX.ZZ", nil},
+
+		// 3
+
+		{"a@a.ru", []Link{{Scheme: "mailto:", Start: 0, End: 6}}},
+		{"a.b@golang.org", []Link{{Scheme: "mailto:", Start: 0, End: 14}}},
+		{"a..b@golang.org", []Link{{Scheme: "", Start: 5, End: 15}}},
+		{"r@golang.org", []Link{{Scheme: "mailto:", Start: 0, End: 12}}},
+		{".r@golang.org", []Link{{Scheme: "", Start: 3, End: 13}}},
+		{"@r@golang.org", []Link{{Scheme: "", Start: 3, End: 13}}},
+		{"r.@golang.org", []Link{{Scheme: "", Start: 3, End: 13}}},
+		{"\ufffdr@golang.org", []Link{{Scheme: "", Start: 5, End: 15}}},
+		{"XXX r@golang.org", []Link{{Scheme: "mailto:", Start: 4, End: 16}}},
+		{"XXX .r@golang.org", []Link{{Scheme: "", Start: 7, End: 17}}},
+		{"a@a.r", nil},
+		{"A@A.R", nil},
+		{"@golang", nil},
+		{"@GOOGLE", nil},
+		{"r@golang.", nil},
+		{"r@golang", nil},
+		{"r@golang.zzz", nil},
+		{"r@", nil},
+		{"ROOT@", nil},
+		{"r@\x00golang", nil},
+		{"r\x00@golang", nil},
+		{"R@\x00GOLANG", nil},
+		{"R\x00@GOLANG", nil},
+
+		// 4
+
+		{"//127.0.0.1:80/", []Link{{Scheme: "//", Start: 0, End: 15}}},
+		{"//google.com.", []Link{{Scheme: "//", Start: 0, End: 12}}},
+		{"//ya.ru", []Link{{Scheme: "//", Start: 0, End: 7}}},
+		{"://google.com", nil},
+		{"//google.com%", nil},
+		{"//google", nil},
+		{"//google.zzz", nil},
+		{"//\x00google", nil},
+		{"x//google.com", nil},
+
+		// 5
+
+		{"mailto:a.b.c@golang.org", []Link{{Scheme: "mailto:", Start: 0, End: 23}}},
+		{"mailto:a..b.c@golang.org", []Link{{Scheme: "", Start: 14, End: 24}}},
+		{"mailto:r@golang.org", []Link{{Scheme: "mailto:", Start: 0, End: 19}}},
+		{"mailto:r.@golang.org", []Link{{Scheme: "", Start: 10, End: 20}}},
+		{"mailto:xxxЖ@golang.org", []Link{{Scheme: "", Start: 13, End: 23}}},
+		{"ailto:xxxx", nil},
+		{"AILTO:XXXX", nil},
+		{"mailto:a@a.a", nil},
+		{"MAILTO:A@A.A", nil},
+		{"mailto:a..b.c@golang", nil},
+		{"mailto:a..b.cgolang.org", nil},
+		{"mailto:r@golang", nil},
+		{"mailto:rgolangorg", nil},
+		{"mailto:r@golang.zzz", nil},
+		{"mailto:r@gol", nil},
+		{"mailto:r@", nil},
+		{"mailto:r@xxx", nil},
+		{"mailto:\x00myemail", nil},
+		{"MAILTO:\x00MYEMAIL", nil},
+		{"mailto:xxx@", nil},
+		{"xmailto:myemail", nil},
+		{"XMAILTO:MYEMAIL", nil},
+		{"xxxxxo:myemail", nil},
+		{"XXXXXO:MYEMAIL", nil},
+		{"xailto:myemail", nil},
+
+		// 6
+
+		{"http://127.0.0.1:80/", []Link{{Scheme: "http:", Start: 0, End: 20}}},
+		{"http://google.com/[1(2", []Link{{Scheme: "http:", Start: 0, End: 18}}},
+		{"http://google.com/#[1(2", []Link{{Scheme: "http:", Start: 0, End: 19}}},
+		{"http://google.com/[1](2)", []Link{{Scheme: "http:", Start: 0, End: 24}}},
+		{"http://google.com/#[1](2)", []Link{{Scheme: "http:", Start: 0, End: 25}}},
+		{"http://google.com/[1)", []Link{{Scheme: "http:", Start: 0, End: 18}}},
+		{"http://google.com/#[1)", []Link{{Scheme: "http:", Start: 0, End: 19}}},
+		{"http://google.com ", []Link{{Scheme: "http:", Start: 0, End: 17}}},
+		{"http://google.com--", []Link{{Scheme: "http:", Start: 0, End: 17}}},
+		{"http://google.com-", []Link{{Scheme: "http:", Start: 0, End: 17}}},
+		{"http://google.com!", []Link{{Scheme: "http:", Start: 0, End: 17}}},
+		{"http://google.com...", []Link{{Scheme: "http:", Start: 0, End: 17}}},
+		{"http://google.com.", []Link{{Scheme: "http:", Start: 0, End: 17}}},
+		{"HtTp://gOoGlE.CoM", []Link{{Scheme: "http:", Start: 0, End: 17}}},
+		{"http://google.com/--", []Link{{Scheme: "http:", Start: 0, End: 18}}},
+		{"http://google.com/", []Link{{Scheme: "http:", Start: 0, End: 18}}},
+		{`"http://google.com"`, []Link{{Scheme: "http:", Start: 1, End: 18}}},
+		{">http://google.com<", []Link{{Scheme: "http:", Start: 1, End: 18}}},
+		{"(http://google.com)", []Link{{Scheme: "http:", Start: 1, End: 18}}},
+		{"http://google.com\n", []Link{{Scheme: "http:", Start: 0, End: 17}}},
+		{"http://google.com/?query=[1(2", []Link{{Scheme: "http:", Start: 0, End: 25}}},
+		{"http://google.com/?query=[1](2)", []Link{{Scheme: "http:", Start: 0, End: 31}}},
+		{"http://google.com/?query=[1)", []Link{{Scheme: "http:", Start: 0, End: 25}}},
+		{"http://google.com/?query=)x(", []Link{{Scheme: "http:", Start: 0, End: 25}}},
+		{"http://google.com/?query=]xxx", []Link{{Scheme: "http:", Start: 0, End: 25}}},
+		{"http://google.com/search---", []Link{{Scheme: "http:", Start: 0, End: 24}}},
+		{"http://google.com/search?query=xxx---", []Link{{Scheme: "http:", Start: 0, End: 34}}},
+		{"http://google.com/#toc---", []Link{{Scheme: "http:", Start: 0, End: 22}}},
+		{"http://google.com/]xxx", []Link{{Scheme: "http:", Start: 0, End: 18}}},
+		{"http://google.com/#]xxx", []Link{{Scheme: "http:", Start: 0, End: 19}}},
+		{"http://www.youtube.com/watch?v=EIBRdBVkDHQ.", []Link{{Scheme: "http:", Start: 0, End: 42}}},
+		{"http://goo---gle.com", nil},
+		{"http://google-.com", nil},
+		{"http://google.com\\", nil},
+		{"http:google.com", nil},
+		{"http://google.com/search?q%0z", nil},
+		{"http://google.com/search?q%1", nil},
+		{"http://google.com/search?q%", nil},
+		{"http://google.com/search?q\ufffd", nil},
+		{"http://google.com/search?q=x%78x?/:@#toc\ufffd", nil},
+		{"http://google.com/search?q%z0", nil},
+		{"http://google", nil},
+		{"http://goo\ufffd", nil},
+		{"http://images.google.com.-net", nil},
+		{"http://images.google.com.net.-org", nil},
+		{"http://\x00google", nil},
+		{"HTTP://\x00GOOGLE", nil},
+		{"http://xxx.com.abracadabra", nil},
+		{"http://xxx", nil},
+		{"HTTP://XXX", nil},
+		{"http:xxxxxx", nil},
+		{"HTTP:XXXXXX", nil},
+		{"TP:GOOGLE", nil},
+		{"ttp://google", nil},
+		{"TTP://GOOGLE", nil},
+		{"xhttp://google", nil},
+		{"XHTTP://GOOGLE", nil},
+		{"xttp://google", nil},
+		{"XTTP://GOOGLE", nil},
+
+		// 7
+
+		{"https://google.com/p%61th?%71uery#%66ragment", []Link{{Scheme: "https:", Start: 0, End: 44}}},
+		{"https://\x00google", nil},
+		{"HTTPS://\x00GOOGLE", nil},
+		{"https:XXgoogle", nil},
+		{"HTTPS:XXGOOGLE", nil},
+		{"https://xxx", nil},
+		{"HTTPS://XXX", nil},
+		{"ttps://google", nil},
+		{"TTPS://GOOGLE", nil},
+		{"xhttps://google", nil},
+		{"XHTTPS://GOOGLE", nil},
+		{"xttps://google", nil},
+		{"XTTPS://GOOGLE", nil},
+
+		// 8
+
+		{"ftp://google.com", []Link{{Scheme: "ftp:", Start: 0, End: 16}}},
+		{"fXp://google", nil},
+		{"FXP://GOOGLE", nil},
+		{"tp:google", nil},
+		{"xtp://google", nil},
+		{"XTP://GOOGLE", nil},
+
+		// 9
+
+		{">http://example.com<", []Link{{Scheme: "http:", Start: 1, End: 19}}},
+		{"http://localhost:80/", []Link{{Scheme: "http:", Start: 0, End: 20}}},
+		{">http://localhost:80<", []Link{{Scheme: "http:", Start: 1, End: 20}}},
+		{"localhost:3128/path?query=xxx#fragment", []Link{{Scheme: "", Start: 0, End: 38}}},
+		{"//localhost:80/", []Link{{Scheme: "//", Start: 0, End: 15}}},
+		{"localhost:80/!$&'()*+,;=/:@", []Link{{Scheme: "", Start: 0, End: 27}}},
+		{"localhost:80/#?!$&'()*+,;=/:@", []Link{{Scheme: "", Start: 0, End: 29}}},
+		{"localhos", nil},
+		{"localhost:0", nil},
+		{"localhost:65536", nil},
+		{"localhost:80/#fragment%0", nil},
+		{"localhost:80/#fragment%0z", nil},
+		{"localhost:80/#fragment%", nil},
+		{"localhost:80/#fragment%z0", nil},
+		{"LOCALHOST:80", nil},
+		{"localhost:80/path%0", nil},
+		{"localhost:80/path%0z", nil},
+		{"localhost:80/path%", nil},
+		{"localhost:80/path%z0", nil},
+		{"localhost:80/\ufffd", nil},
+		{"localhost:80\ufffd", nil},
+		{"localhost:", nil},
+		{"localhost:x", nil},
+		{"localhost", nil},
+		{"localhostX:80", nil},
+		{"Xlocalhost:80", nil},
+
+		// 10
+
+		{":00", nil},
+		{"skype://nickname", nil},
+		{"SKYPE://NICKNAME", nil},
+		{"XXX http://google.com r@golang.org localhost:80 mailto:r@golang.org //google.com XXX", []Link{{Scheme: "http:", Start: 4, End: 21}, {Scheme: "mailto:", Start: 22, End: 34}, {Scheme: "", Start: 35, End: 47}, {Scheme: "mailto:", Start: 48, End: 67}, {Scheme: "//", Start: 68, End: 80}}},
+
+		// from twitter-text
+
+		{"badly formatted http://foo!bar.com", []Link{{Start: 27, End: 34}}},
+		{"badly formatted http://foo_bar.com", nil},
+		{"Check out http://example.com/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", []Link{{Scheme: "http:", Start: 10, End: 1529}}},
+		{"Check out http://search.twitter.com/#!/search?q=avro&lang=en", []Link{{Scheme: "http:", Start: 10, End: 60}}},
+		{"Czech out sweet deals at http://mrs.domain-dash.biz ok?", []Link{{Scheme: "http:", Start: 25, End: 51}}},
+		{"Email support@example.com", []Link{{Scheme: "mailto:", Start: 6, End: 25}}},
+		{"example: https://twitter.com/otm_m@\"onmousedown=\"alert('foo')\" style=background-color:yellow;color:yellow;\"/", []Link{{Scheme: "https:", Start: 9, End: 35}}},
+		{"foo@bar.com", []Link{{Scheme: "mailto:", Start: 0, End: 11}}},
+		{"Go to http://example.com/a+ or http://example.com/a-", []Link{{Scheme: "http:", Start: 6, End: 27}, {Scheme: "http:", Start: 31, End: 52}}},
+		{"Go to http://example.com/a+?this=that or http://example.com/a-?this=that", []Link{{Scheme: "http:", Start: 6, End: 37}, {Scheme: "http:", Start: 41, End: 72}}},
+		{"Go to http://example.com/view/slug-url-?foo=bar", []Link{{Scheme: "http:", Start: 6, End: 47}}},
+		{"http://example.com https://sslexample.com http://sub.example.com", []Link{{Scheme: "http:", Start: 0, End: 18}, {Scheme: "https:", Start: 19, End: 41}, {Scheme: "http:", Start: 42, End: 64}}},
+		{"http://example.mobi/path", []Link{{Scheme: "http:", Start: 0, End: 24}}},
+		{"http://foo.com AND https://bar.com AND www.foobar.com", []Link{{Scheme: "http:", Start: 0, End: 14}, {Scheme: "https:", Start: 19, End: 34}, {Scheme: "", Start: 39, End: 53}}},
+		{"http://foo.com/?#foo", []Link{{Scheme: "http:", Start: 0, End: 20}}},
+		{"http://www.example.com/#answer", []Link{{Scheme: "http:", Start: 0, End: 30}}},
+		{"http://www.flickr.com/photos/29674651@N00/4382024406 if you know what's good for you.", []Link{{Scheme: "http:", Start: 0, End: 52}}},
+		{"http://www.flickr.com/photos/29674651@N00/4382024406", []Link{{Scheme: "http:", Start: 0, End: 52}}},
+		{"http://www.flickr.com/photos/29674651@N00/foobar", []Link{{Scheme: "http:", Start: 0, End: 48}}},
+		{"In http://example.com/test, Douglas explains 42.", []Link{{Scheme: "http:", Start: 3, End: 26}}},
+		{"Is http://www.foo-bar.com a valid URL?", []Link{{Scheme: "http:", Start: 3, End: 25}}},
+		{"Is www...foo a valid URL?", nil},
+		{"Is www.foo-bar.com a valid URL?", []Link{{Scheme: "", Start: 3, End: 18}}},
+		{"Is www.-foo.com a valid URL?", nil},
+		{"I think it's proper to end sentences with a period http://tell.me.com. Even when they contain a URL.", []Link{{Scheme: "http:", Start: 51, End: 69}}},
+		{"I think it's proper to end sentences with a period http://tell.me/why?=because.i.want.it. Even when they contain a URL.", []Link{{Scheme: "http:", Start: 51, End: 88}}},
+		{"I think it's proper to end sentences with a period http://tell.me/why. Even when they contain a URL.", []Link{{Scheme: "http:", Start: 51, End: 69}}},
+		{"<link rel='true'>http://example.com</link>", []Link{{Scheme: "http:", Start: 17, End: 35}}},
+		{"Parenthetically bad http://example.com/i_has_a_) thing", []Link{{Scheme: "http:", Start: 20, End: 47}}},
+		{"See: http://example.com/café", []Link{{Scheme: "http:", Start: 5, End: 29}}},
+		{"See: http://example.com/@user", []Link{{Scheme: "http:", Start: 5, End: 29}}},
+		{"See: http://example.com/@user/", []Link{{Scheme: "http:", Start: 5, End: 30}}},
+		{"See: http://example.com/?@user=@user", []Link{{Scheme: "http:", Start: 5, End: 36}}},
+		{"See: http://x.xx.com/@\"style=\"color:pink\"onmouseover=alert(1)//", []Link{{Scheme: "http:", Start: 5, End: 22}}},
+		{"test http://www.example.co.jp", []Link{{Scheme: "http:", Start: 5, End: 29}}},
+		{"test http://www.example.sx", []Link{{Scheme: "http:", Start: 5, End: 26}}},
+		{"text http://example.com,", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		{"text http://example.com;", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		{"text http://example.com:", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		{"text http://example.com!", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		{"text http://example.com?", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		{"text http://example.com.", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		{"text http://example.com'", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		{"text http://example.com", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		{"text http://example.com)", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		{"text http://example.com]", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		{"text http://example.com}", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		{"text:http://example.com", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		{"text !http://example.com", []Link{{Scheme: "http:", Start: 6, End: 24}}},
+		{"text /http://example.com", []Link{{Scheme: "http:", Start: 6, End: 24}}},
+		{"text (http://example.com)", []Link{{Scheme: "http:", Start: 6, End: 24}}},
+		{"text \"http://example.com\"", []Link{{Scheme: "http:", Start: 6, End: 24}}},
+		{"text http://example.com more text", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		{"text =http://example.com", nil},
+		{"text (http://example.com/test)", []Link{{Scheme: "http:", Start: 6, End: 29}}},
+		{`text http://foo.com/("onclick="alert(1)")`, []Link{{Scheme: "http:", Start: 5, End: 20}}},
+		{"text http://msdn.com/S(deadbeef)/page.htm", []Link{{Scheme: "http:", Start: 5, End: 41}}},
+		{"text http://msdn.microsoft.com/ja-jp/library/system.net.httpwebrequest(v=VS.100).aspx", []Link{{Scheme: "http:", Start: 5, End: 85}}},
+		{"text https://rdio.com/artist/50_Cent/album/We_Up/track/We_Up_(Album_Version_(Edited", []Link{{Scheme: "https:", Start: 5, End: 61}}},
+		{"text https://rdio.com/artist/50_Cent/album/We_Up/track/We_Up_(Album_Version_(Edited))/", []Link{{Scheme: "https:", Start: 5, End: 86}}},
+		{"text https://rdio.com/artist/50_Cent/album/We_Up/track/We_Up(URL description with spaces and (parentheses))", []Link{{Scheme: "https:", Start: 5, End: 107}}},
+		{"text http://t.co/gksG6xlq", []Link{{Scheme: "http:", Start: 5, End: 25}}},
+		{"text http://t.co/gksG6xlq text #hashtag text @username", []Link{{Scheme: "http:", Start: 5, End: 25}}},
+		{"text (URL in parentheses http://msdn.com/S(deadbeef))", []Link{{Scheme: "http:", Start: 25, End: 52}}},
+		{"text (URL in parentheses https://rdio.com/artist/50_Cent/album/We_Up/track/We_Up_(Album_Version_(Edited))/)", []Link{{Scheme: "https:", Start: 25, End: 106}}},
+		{"@user Try http:// example.com/path", []Link{{Scheme: "", Start: 18, End: 34}}},
+		{"@user Try http:// example.com/path", []Link{{Scheme: "", Start: 19, End: 35}}},
+
+		// punycode
+
+		{"See also: http://xn--80abe5aohbnkjb.xn--p1ai/", []Link{{Scheme: "http:", Start: 10, End: 45}}},
+		{"xn--80abe5aohbnkjb.xn--p1ai/", []Link{{Scheme: "", Start: 0, End: 28}}},
+		{"admin@xn--80abe5aohbnkjb.xn--p1ai", []Link{{Scheme: "mailto:", Start: 0, End: 33}}},
+		{"mailto:admin@xn--80abe5aohbnkjb.xn--p1ai", []Link{{Scheme: "mailto:", Start: 0, End: 40}}},
+
+		//{"いまなにしてるhttp://example.comいまなにしてる", []Link{}},
+		//{"I enjoy Macintosh Brand computers: http://✪df.ws/ejp", []Link{}},
+		//{"See: http://t.co/abcde's page", []Link{{Scheme: "http:", Start: 5, End: 22}}},
+		//{"text http://example.com=", []Link{{Scheme: "http:", Start: 5, End: 23}}},
+		//{"text http://example.com/pipe|character?yes|pipe|character", []Link{{Scheme: "http:", Start: 5, End: 57}}},
+
+		{"http://☃.net/", []Link{{Scheme: "http:", Start: 0, End: 15}}},
+	}
+	for i, tc := range testCases {
+		got := Links(tc.in)
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("#%d: Links(%q):\n got %#v\nwant %#v", i, tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestParseIPv4(t *testing.T) {
+	type testCase struct {
+		in     string
+		length int
+		ok     bool
+	}
+	testCases := []testCase{
+		{"", 0, false},
+		{"8.8.8.8", 7, true},
+		{"8.8.8.", 0, false},
+		{"8.8.8.xxx", 0, false},
+		{"8.8.8.8xxx", 7, true},
+		{"256.0.0.1", 0, false},
+		{"001.001.001.001", 15, true},
+	}
+	for _, tc := range testCases {
+		length, ok := skipIPv4(tc.in)
+		if ok != tc.ok {
+			s := "failed"
+			if !tc.ok {
+				s = "unexpectedly succeeded"
+			}
+			t.Errorf("skipIPv4(%q) %s", tc.in, s)
+		} else if length != tc.length {
+			t.Errorf("skipIPv4(%q) returned length %d, want %d", tc.in, length, tc.length)
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/url.go b/vendor/gitlab.com/golang-commonmark/linkify/url.go
new file mode 100644
index 000000000..495a7ac48
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/url.go
@@ -0,0 +1,404 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package linkify
+
+import "unicode/utf8"
+
+func atoi3(s string, start int) (int, bool) {
+	n := 0
+	var i int
+	for i = start; i < len(s) && digit(s[i]); i++ {
+		n = n*10 + int(s[i]-'0')
+		if n > 255 {
+			return 0, false
+		}
+	}
+	if i == start {
+		return 0, false
+	}
+	return i, true
+}
+
+func skipIPv4(s string) (_ int, _ bool) {
+	j := 0
+	for i := 0; i < 4; i++ {
+		if j >= len(s) {
+			return
+		}
+		if i > 0 {
+			if s[j] != '.' {
+				return
+			}
+			j++
+		}
+		n, ok := atoi3(s, j)
+		if !ok {
+			return
+		}
+		j = n
+	}
+	return j, true
+}
+
+func atoi5(s string, start int) (int, bool) {
+	n := 0
+	var i int
+	for i = start; i < len(s) && digit(s[i]); i++ {
+		n = n*10 + int(s[i]-'0')
+		if n > 65535 {
+			return 0, false
+		}
+	}
+	if i == start || n == 0 {
+		return 0, false
+	}
+	return i, true
+}
+
+func skipPort(s string, start int) int {
+	if start >= len(s) || s[start] != ':' {
+		return start
+	}
+	end, ok := atoi5(s, start+1)
+	if !ok {
+		return start
+	}
+	return end
+}
+
+func skipPath(s string, start int) int {
+	if start >= len(s) || s[start] != '/' {
+		return start // skip empty path
+	}
+	var stack []rune
+	var notClosedIndex int
+	var nHyphen int
+	end := start + 1
+loop:
+	for end < len(s) {
+		r, rlen := utf8.DecodeRuneInString(s[end:])
+		if r == utf8.RuneError {
+			nHyphen = 0
+			break
+		}
+
+		switch {
+		case isUnreserved(r):
+			if r == '-' {
+				nHyphen++
+				if nHyphen > 1 {
+					break loop
+				}
+			} else {
+				nHyphen = 0
+			}
+		case isSubDelimiter(r) || r == '[' || r == ']':
+			nHyphen = 0
+			switch r {
+			case '[', '(':
+				if len(stack) == 0 {
+					notClosedIndex = end
+				}
+				stack = append(stack, r)
+			case ']', ')':
+				opening := '['
+				if r == ')' {
+					opening = '('
+				}
+				if len(stack) == 0 || stack[len(stack)-1] != opening {
+					break loop
+				}
+				stack = stack[:len(stack)-1]
+			}
+		case r == '/' || r == ':' || r == '@':
+			nHyphen = 0
+		case r == '%':
+			nHyphen = 0
+			if end+2 >= len(s) {
+				break loop
+			}
+			if !(hexDigit(s[end+1]) &&
+				hexDigit(s[end+2])) {
+				break loop
+			}
+			end += 2
+		default:
+			nHyphen = 0
+			if r != ' ' || len(stack) == 0 {
+				break loop
+			}
+		}
+		end += rlen
+	}
+	if len(stack) > 0 {
+		return notClosedIndex
+	}
+	if nHyphen > 0 {
+		return end - nHyphen + 1
+	}
+	return end
+}
+
+func skipQuery(s string, start int) int {
+	if start >= len(s) || s[start] != '?' {
+		return start
+	}
+	var stack []rune
+	var notClosedIndex int
+	var nHyphen int
+	end := start + 1
+loop:
+	for end < len(s) {
+		r, rlen := utf8.DecodeRuneInString(s[end:])
+		if r == utf8.RuneError {
+			nHyphen = 0
+			break
+		}
+
+		switch {
+		case isUnreserved(r):
+			if r == '-' {
+				nHyphen++
+				if nHyphen > 1 {
+					break loop
+				}
+			} else {
+				nHyphen = 0
+			}
+		case isSubDelimiter(r) || r == '[' || r == ']':
+			nHyphen = 0
+			switch r {
+			case '[', '(':
+				if len(stack) == 0 {
+					notClosedIndex = end
+				}
+				stack = append(stack, r)
+			case ']', ')':
+				opening := '['
+				if r == ')' {
+					opening = '('
+				}
+				if len(stack) == 0 || stack[len(stack)-1] != opening {
+					break loop
+				}
+				stack = stack[:len(stack)-1]
+			}
+		case r == '?' || r == '/' || r == ':' || r == '@':
+			nHyphen = 0
+		case r == '%':
+			nHyphen = 0
+			if end+2 >= len(s) {
+				break loop
+			}
+			if !(hexDigit(s[end+1]) &&
+				hexDigit(s[end+2])) {
+				break loop
+			}
+			end += 2
+		default:
+			nHyphen = 0
+			if r != ' ' || len(stack) == 0 {
+				break loop
+			}
+		}
+		end += rlen
+	}
+	if len(stack) > 0 {
+		return notClosedIndex
+	}
+	if nHyphen > 0 {
+		return end - nHyphen + 1
+	}
+	return end
+}
+
+func skipFragment(s string, start int) int {
+	if start >= len(s) || s[start] != '#' {
+		return start
+	}
+	var stack []rune
+	var notClosedIndex int
+	var nHyphen int
+	end := start + 1
+loop:
+	for end < len(s) {
+		r, rlen := utf8.DecodeRuneInString(s[end:])
+		if r == utf8.RuneError {
+			nHyphen = 0
+			break
+		}
+
+		switch {
+		case isUnreserved(r):
+			if r == '-' {
+				nHyphen++
+				if nHyphen > 1 {
+					break loop
+				}
+			} else {
+				nHyphen = 0
+			}
+		case isSubDelimiter(r) || r == '[' || r == ']':
+			nHyphen = 0
+			switch r {
+			case '[', '(':
+				if len(stack) == 0 {
+					notClosedIndex = end
+				}
+				stack = append(stack, r)
+			case ']', ')':
+				opening := '['
+				if r == ')' {
+					opening = '('
+				}
+				if len(stack) == 0 || stack[len(stack)-1] != opening {
+					break loop
+				}
+				stack = stack[:len(stack)-1]
+			}
+		case r == '?' || r == '/' || r == ':' || r == '@':
+			nHyphen = 0
+		case r == '%':
+			nHyphen = 0
+			if end+2 >= len(s) {
+				break loop
+			}
+			if !(hexDigit(s[end+1]) &&
+				hexDigit(s[end+2])) {
+				break loop
+			}
+			end += 2
+		default:
+			nHyphen = 0
+			if r != ' ' || len(stack) == 0 {
+				break loop
+			}
+		}
+		end += rlen
+	}
+	if len(stack) > 0 {
+		return notClosedIndex
+	}
+	if nHyphen > 0 {
+		return end - nHyphen + 1
+	}
+	return end
+}
+
+func unskipPunct(s string, start int) int {
+	end := start - 1
+	if end < 0 || end >= len(s) || !basicPunct[s[end]] {
+		return start
+	}
+	return end
+}
+
+func findHostnameStart(s string, start int) (_ int, _ bool) {
+	end := start
+	lastDot := true
+	nHyphen := 0
+loop:
+	for end > 0 {
+		r, rlen := utf8.DecodeLastRuneInString(s[:end])
+		if r == utf8.RuneError {
+			return
+		}
+
+		switch {
+		case r == '.':
+			if nHyphen > 0 {
+				return
+			}
+			lastDot = true
+		case r == '-':
+			if end == start {
+				return
+			}
+			if lastDot {
+				return
+			}
+			nHyphen++
+			if nHyphen == 3 {
+				return
+			}
+		case r == ':' || r == '/' || r == '\\' || r == '_':
+			return
+		case isPunctOrSpaceOrControl(r):
+			break loop
+		default:
+			lastDot = false
+			nHyphen = 0
+		}
+		end -= rlen
+	}
+	if lastDot || nHyphen > 0 {
+		return
+	}
+	return end, true
+}
+
+func findHostnameEnd(s string, start int) (_ int, _ int, _ bool) {
+	end := start
+	lastDot := false
+	lastDotPos := -1
+	nHyphen := 0
+loop:
+	for end < len(s) {
+		r, rlen := utf8.DecodeRuneInString(s[end:])
+		if r == utf8.RuneError {
+			return
+		}
+
+		switch {
+		case r == '.':
+			if nHyphen > 0 {
+				return
+			}
+			if lastDot {
+				break loop
+			}
+			lastDot = true
+			lastDotPos = end
+			nHyphen = 0
+		case r == '-':
+			lastDot = false
+			if end == start {
+				return
+			}
+			if lastDot {
+				return
+			}
+			nHyphen++
+			if nHyphen == 3 {
+				break loop
+			}
+		case r == '\\' || r == '_':
+			return
+		case isPunctOrSpaceOrControl(r):
+			break loop
+		default:
+			lastDot = false
+			nHyphen = 0
+		}
+		end += rlen
+	}
+
+	if nHyphen > 0 {
+		end -= nHyphen
+	} else if lastDot {
+		if s[end-1] == '.' {
+			end--
+		}
+		lastDotPos = end - 1
+		for lastDotPos >= start && s[lastDotPos] != '.' {
+			lastDotPos--
+		}
+		if lastDotPos < start {
+			lastDotPos = -1
+		}
+	}
+
+	return end, lastDotPos, true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/linkify/util.go b/vendor/gitlab.com/golang-commonmark/linkify/util.go
new file mode 100644
index 000000000..9f70a57f9
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/linkify/util.go
@@ -0,0 +1,20 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package linkify
+
+func digit(b byte) bool {
+	return b >= '0' && b <= '9'
+}
+
+func hexDigit(b byte) bool {
+	return digit(b) || b >= 'a' && b <= 'f' || b >= 'A' && b <= 'F'
+}
+
+func byteToLower(b byte) byte {
+	if b >= 'A' && b <= 'Z' {
+		return b - 'A' + 'a'
+	}
+	return b
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/.gitlab-ci.yml b/vendor/gitlab.com/golang-commonmark/markdown/.gitlab-ci.yml
new file mode 100644
index 000000000..58bdd5c41
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/.gitlab-ci.yml
@@ -0,0 +1,25 @@
+image: golang:1.11
+
+stages:
+  - build
+  - test
+
+before_script:
+  - go get github.com/russross/blackfriday
+  - go get gitlab.com/golang-commonmark/html
+  - go get gitlab.com/golang-commonmark/linkify
+  - go get gitlab.com/golang-commonmark/mdurl
+  - go get gitlab.com/golang-commonmark/puny
+  - go get gitlab.com/opennota/wd
+  - go get gopkg.in/russross/blackfriday.v2
+
+build:
+  stage: build
+  script:
+    - go build ./...
+
+test:
+  stage: test
+  script:
+    - test -z "$(gofmt -l . | tee /dev/stderr)"
+    - go test -cover ./...
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/AUTHORS b/vendor/gitlab.com/golang-commonmark/markdown/AUTHORS
new file mode 100644
index 000000000..041a96ce7
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/AUTHORS
@@ -0,0 +1 @@
+opennota@gmail.com
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/LICENSE b/vendor/gitlab.com/golang-commonmark/markdown/LICENSE
new file mode 100644
index 000000000..9cdcd2016
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/LICENSE
@@ -0,0 +1,10 @@
+Copyright (c) 2015, The Authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE 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 HOLDER 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.
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/README.md b/vendor/gitlab.com/golang-commonmark/markdown/README.md
new file mode 100644
index 000000000..ac2a1de86
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/README.md
@@ -0,0 +1,64 @@
+markdown [![GoDoc](http://godoc.org/gitlab.com/golang-commonmark/markdown?status.svg)](http://godoc.org/gitlab.com/golang-commonmark/markdown) [![License](https://img.shields.io/badge/licence-BSD--2--Clause-blue.svg)](https://opensource.org/licenses/BSD-2-Clause) [![Pipeline status](https://gitlab.com/golang-commonmark/markdown/badges/master/pipeline.svg)](https://gitlab.com/golang-commonmark/markdown/commits/master) [![Coverage report](https://gitlab.com/golang-commonmark/markdown/badges/master/coverage.svg)](https://gitlab.com/golang-commonmark/markdown/commits/master)
+========
+
+Package golang-commonmark/markdown provides a CommonMark-compliant markdown parser and renderer, written in Go.
+
+## Installation
+
+    go get -u gitlab.com/golang-commonmark/markdown
+
+You can also go get [mdtool](https://gitlab.com/golang-commonmark/mdtool), an example command-line tool:
+
+    go get -u gitlab.com/golang-commonmark/mdtool
+
+## Standards support
+
+Currently supported CommonMark spec: [v0.28](http://spec.commonmark.org/0.28/).
+
+## Extensions
+
+Besides the features required by CommonMark, golang-commonmark/markdown supports:
+
+  * Tables (GFM)
+  * Strikethrough (GFM)
+  * Autoconverting plain-text URLs to links
+  * Typographic replacements (smart quotes and other)
+
+## Usage
+
+``` go
+md := markdown.New(markdown.XHTMLOutput(true))
+fmt.Println(md.RenderToString([]byte("Header\n===\nText")))
+```
+
+Check out [the source of mdtool](https://gitlab.com/golang-commonmark/mdtool/blob/master/main.go) for a more complete example.
+
+The following options are currently supported:
+
+  Name            |  Type     |                        Description                          | Default
+  --------------- | --------- | ----------------------------------------------------------- | ---------
+  HTML            | bool      | whether to enable raw HTML                                  | false
+  Tables          | bool      | whether to enable GFM tables                                | true
+  Linkify         | bool      | whether to autoconvert plain-text URLs to links             | true
+  Typographer     | bool      | whether to enable typographic replacements                  | true
+  Quotes          | string / []string | double + single quote replacement pairs for the typographer | “”‘’
+  MaxNesting      | int       | maximum nesting level                                       | 20
+  LangPrefix      | string    | CSS language prefix for fenced blocks                       | language-
+  Breaks          | bool      | whether to convert newlines inside paragraphs into `<br>`   | false
+  XHTMLOutput     | bool      | whether to output XHTML instead of HTML                     | false
+
+## Benchmarks
+
+Rendering spec/spec-0.28.txt on a Intel(R) Core(TM) i5-2400 CPU @ 3.10GHz
+
+    BenchmarkRenderSpecNoHTML         100    10254720 ns/op    2998037 B/op    18225 allocs/op
+    BenchmarkRenderSpec               100    10180241 ns/op    2997307 B/op    18214 allocs/op
+    BenchmarkRenderSpecBlackFriday    200     7241749 ns/op    2834340 B/op    17101 allocs/op
+    BenchmarkRenderSpecBlackFriday2   200     7448256 ns/op    2991202 B/op    16705 allocs/op
+
+## See also
+
+https://github.com/jgm/CommonMark — the reference CommonMark implementations in C and JavaScript,
+  also contains the latest spec and an online demo.
+
+http://talk.commonmark.org — the CommonMark forum, a good place to join together the efforts of the developers.
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/align.go b/vendor/gitlab.com/golang-commonmark/markdown/align.go
new file mode 100644
index 000000000..bcb636007
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/align.go
@@ -0,0 +1,26 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+type Align byte
+
+const (
+	AlignNone = iota
+	AlignLeft
+	AlignCenter
+	AlignRight
+)
+
+func (a Align) String() string {
+	switch a {
+	case AlignLeft:
+		return "left"
+	case AlignCenter:
+		return "center"
+	case AlignRight:
+		return "right"
+	}
+	return ""
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/autolink.go b/vendor/gitlab.com/golang-commonmark/markdown/autolink.go
new file mode 100644
index 000000000..ab51c71b2
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/autolink.go
@@ -0,0 +1,70 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"regexp"
+	"strings"
+)
+
+var (
+	rAutolink = regexp.MustCompile(`^<([a-zA-Z][a-zA-Z0-9+.\-]{1,31}):([^<>\x00-\x20]*)>`)
+	rEmail    = regexp.MustCompile(`^<([a-zA-Z0-9.!#$%&'*+/=?^_{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>`)
+)
+
+func ruleAutolink(s *StateInline, silent bool) bool {
+	pos := s.Pos
+	src := s.Src
+
+	if src[pos] != '<' {
+		return false
+	}
+
+	tail := src[pos:]
+
+	if strings.IndexByte(tail, '>') < 0 {
+		return false
+	}
+
+	link := rAutolink.FindString(tail)
+	if link != "" {
+		link = link[1 : len(link)-1]
+		href := normalizeLink(link)
+		if !validateLink(href) {
+			return false
+		}
+
+		if !silent {
+			s.PushOpeningToken(&LinkOpen{Href: href})
+			s.PushToken(&Text{Content: normalizeLinkText(link)})
+			s.PushClosingToken(&LinkClose{})
+		}
+
+		s.Pos += len(link) + 2
+
+		return true
+	}
+
+	email := rEmail.FindString(tail)
+	if email != "" {
+		email = email[1 : len(email)-1]
+		href := normalizeLink("mailto:" + email)
+		if !validateLink(href) {
+			return false
+		}
+
+		if !silent {
+			s.PushOpeningToken(&LinkOpen{Href: href})
+			s.PushToken(&Text{Content: normalizeLinkText(email)})
+			s.PushClosingToken(&LinkClose{})
+		}
+
+		s.Pos += len(email) + 2
+
+		return true
+	}
+
+	return false
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/backticks.go b/vendor/gitlab.com/golang-commonmark/markdown/backticks.go
new file mode 100644
index 000000000..07f268dcc
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/backticks.go
@@ -0,0 +1,60 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "strings"
+
+func ruleBackticks(s *StateInline, silent bool) bool {
+	pos := s.Pos
+	src := s.Src
+
+	if src[pos] != '`' {
+		return false
+	}
+
+	start := pos
+	pos++
+	max := s.PosMax
+
+	for pos < max && src[pos] == '`' {
+		pos++
+	}
+
+	marker := src[start:pos]
+
+	matchStart := pos
+	matchEnd := pos
+	for {
+		matchStart = strings.IndexByte(src[matchEnd:], '`')
+		if matchStart == -1 {
+			break
+		}
+		matchStart += matchEnd
+
+		matchEnd = matchStart + 1
+
+		for matchEnd < max && src[matchEnd] == '`' {
+			matchEnd++
+		}
+
+		if matchEnd-matchStart == len(marker) {
+			if !silent {
+				s.PushToken(&CodeInline{
+					Content: normalizeInlineCode(src[pos:matchStart]),
+				})
+			}
+			s.Pos = matchEnd
+			return true
+		}
+	}
+
+	if !silent {
+		s.Pending.WriteString(marker)
+	}
+
+	s.Pos += len(marker)
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/balance_pairs.go b/vendor/gitlab.com/golang-commonmark/markdown/balance_pairs.go
new file mode 100644
index 000000000..d5830634a
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/balance_pairs.go
@@ -0,0 +1,43 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+func ruleBalancePairs(s *StateInline) {
+	delimiters := s.Delimiters
+	max := len(delimiters)
+
+	for i := 0; i < max; i++ {
+		lastDelim := delimiters[i]
+
+		if !lastDelim.Close {
+			continue
+		}
+
+		j := i - lastDelim.Jump - 1
+
+		for j >= 0 {
+			currDelim := delimiters[j]
+
+			if currDelim.Open &&
+				currDelim.Marker == lastDelim.Marker &&
+				currDelim.End < 0 &&
+				currDelim.Level == lastDelim.Level {
+				oddMatch := (currDelim.Close || lastDelim.Open) &&
+					currDelim.Length != -1 &&
+					lastDelim.Length != -1 &&
+					(currDelim.Length+lastDelim.Length)%3 == 0
+				if !oddMatch {
+					delimiters[i].Jump = i - j
+					delimiters[i].Open = false
+					delimiters[j].End = i
+					delimiters[j].Jump = 0
+					break
+				}
+			}
+
+			j -= currDelim.Jump + 1
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/blockquote.go b/vendor/gitlab.com/golang-commonmark/markdown/blockquote.go
new file mode 100644
index 000000000..f8ad3626b
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/blockquote.go
@@ -0,0 +1,233 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "unicode/utf8"
+
+var blockquoteTerminatedBy []BlockRule
+
+func ruleBlockQuote(s *StateBlock, startLine, endLine int, silent bool) bool {
+	if s.SCount[startLine]-s.BlkIndent >= 4 {
+		return false
+	}
+
+	pos := s.BMarks[startLine] + s.TShift[startLine]
+	max := s.EMarks[startLine]
+	src := s.Src
+
+	if pos >= max {
+		return false
+	}
+	if src[pos] != '>' {
+		return false
+	}
+	pos++
+
+	if silent {
+		return true
+	}
+
+	initial := s.SCount[startLine] + pos - (s.BMarks[startLine] + s.TShift[startLine])
+	offset := initial
+
+	spaceAfterMarker := false
+	adjustTab := false
+	if pos < max {
+		if src[pos] == ' ' {
+			pos++
+			initial++
+			offset++
+			spaceAfterMarker = true
+		} else if src[pos] == '\t' {
+			spaceAfterMarker = true
+			if (s.BSCount[startLine]+offset)%4 == 3 {
+				pos++
+				initial++
+				offset++
+			} else {
+				adjustTab = true
+			}
+		}
+	}
+
+	oldBMarks := []int{s.BMarks[startLine]}
+	s.BMarks[startLine] = pos
+
+	for pos < max {
+		r, size := utf8.DecodeRuneInString(src[pos:])
+		if runeIsSpace(r) {
+			if r == '\t' {
+				d := 0
+				if adjustTab {
+					d = 1
+				}
+				offset += 4 - (offset+s.BSCount[startLine]+d)%4
+			} else {
+				offset++
+			}
+		} else {
+			break
+		}
+		pos += size
+	}
+
+	oldBSCount := []int{s.BSCount[startLine]}
+	d := 0
+	if spaceAfterMarker {
+		d = 1
+	}
+	s.BSCount[startLine] = s.SCount[startLine] + 1 + d
+
+	lastLineEmpty := pos >= max
+
+	oldSCount := []int{s.SCount[startLine]}
+	s.SCount[startLine] = offset - initial
+
+	oldTShift := []int{s.TShift[startLine]}
+	s.TShift[startLine] = pos - s.BMarks[startLine]
+
+	oldParentType := s.ParentType
+	s.ParentType = ptBlockQuote
+	wasOutdented := false
+
+	oldLineMax := s.LineMax
+
+	nextLine := startLine + 1
+	for ; nextLine < endLine; nextLine++ {
+		if s.SCount[nextLine] < s.BlkIndent {
+			wasOutdented = true
+		}
+		pos = s.BMarks[nextLine] + s.TShift[nextLine]
+		max = s.EMarks[nextLine]
+
+		if pos >= max {
+			break
+		}
+
+		pos++
+		if src[pos-1] == '>' && !wasOutdented {
+			initial = s.SCount[nextLine] + pos + (s.BMarks[nextLine] + s.TShift[nextLine])
+			offset = initial
+
+			if pos >= len(src) || src[pos] != ' ' && src[pos] != '\t' {
+				spaceAfterMarker = true
+			} else if src[pos] == ' ' {
+				pos++
+				initial++
+				offset++
+				adjustTab = false
+				spaceAfterMarker = true
+			} else if src[pos] == '\t' {
+				spaceAfterMarker = true
+
+				if (s.BSCount[nextLine]+offset)%4 == 3 {
+					pos++
+					initial++
+					offset++
+					adjustTab = false
+				} else {
+					adjustTab = true
+				}
+			}
+
+			oldBMarks = append(oldBMarks, s.BMarks[nextLine])
+			s.BMarks[nextLine] = pos
+
+			for pos < max {
+				r, size := utf8.DecodeRuneInString(src[pos:])
+				if runeIsSpace(r) {
+					if r == '\t' {
+						d := 0
+						if adjustTab {
+							d = 1
+						}
+						offset += 4 - (offset+s.BSCount[startLine]+d)%4
+					} else {
+						offset++
+					}
+				} else {
+					break
+				}
+				pos += size
+			}
+
+			lastLineEmpty = pos >= max
+
+			oldBSCount = append(oldBSCount, s.BSCount[nextLine])
+			d := 0
+			if spaceAfterMarker {
+				d = 1
+			}
+			s.BSCount[nextLine] = s.SCount[nextLine] + 1 + d
+
+			oldSCount = append(oldSCount, s.SCount[nextLine])
+			s.SCount[nextLine] = offset - initial
+
+			oldTShift = append(oldTShift, s.TShift[nextLine])
+			s.TShift[nextLine] = pos - s.BMarks[nextLine]
+
+			continue
+		}
+
+		if lastLineEmpty {
+			break
+		}
+
+		terminate := false
+		for _, r := range blockquoteTerminatedBy {
+			if r(s, nextLine, endLine, true) {
+				terminate = true
+				break
+			}
+		}
+
+		if terminate {
+			s.LineMax = nextLine
+
+			if s.BlkIndent != 0 {
+				oldBMarks = append(oldBMarks, s.BMarks[nextLine])
+				oldBSCount = append(oldBSCount, s.BSCount[nextLine])
+				oldTShift = append(oldTShift, s.TShift[nextLine])
+				oldSCount = append(oldSCount, s.SCount[nextLine])
+				s.SCount[nextLine] -= s.BlkIndent
+			}
+
+			break
+		}
+
+		oldBMarks = append(oldBMarks, s.BMarks[nextLine])
+		oldBSCount = append(oldBSCount, s.BSCount[nextLine])
+		oldTShift = append(oldTShift, s.TShift[nextLine])
+		oldSCount = append(oldSCount, s.SCount[nextLine])
+
+		s.SCount[nextLine] = -1
+	}
+
+	oldIndent := s.BlkIndent
+	s.BlkIndent = 0
+
+	tok := &BlockquoteOpen{
+		Map: [2]int{startLine, 0},
+	}
+	s.PushOpeningToken(tok)
+
+	s.Md.Block.Tokenize(s, startLine, nextLine)
+
+	s.PushClosingToken(&BlockquoteClose{})
+
+	s.LineMax = oldLineMax
+	s.ParentType = oldParentType
+	tok.Map[1] = s.Line
+
+	for i := 0; i < len(oldTShift); i++ {
+		s.BMarks[startLine+i] = oldBMarks[i]
+		s.TShift[startLine+i] = oldTShift[i]
+		s.SCount[startLine+i] = oldSCount[i]
+		s.BSCount[startLine+i] = oldBSCount[i]
+	}
+	s.BlkIndent = oldIndent
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/code.go b/vendor/gitlab.com/golang-commonmark/markdown/code.go
new file mode 100644
index 000000000..c6dc574e0
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/code.go
@@ -0,0 +1,37 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+func ruleCode(s *StateBlock, startLine, endLine int, _ bool) bool {
+	if s.SCount[startLine]-s.BlkIndent < 4 {
+		return false
+	}
+
+	nextLine := startLine + 1
+	last := nextLine
+
+	for nextLine < endLine {
+		if s.IsLineEmpty(nextLine) {
+			nextLine++
+			continue
+		}
+
+		if s.SCount[nextLine]-s.BlkIndent >= 4 {
+			nextLine++
+			last = nextLine
+			continue
+		}
+
+		break
+	}
+
+	s.Line = last
+	s.PushToken(&CodeBlock{
+		Content: s.Lines(startLine, last, 4+s.BlkIndent, true),
+		Map:     [2]int{startLine, s.Line},
+	})
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/emphasis.go b/vendor/gitlab.com/golang-commonmark/markdown/emphasis.go
new file mode 100644
index 000000000..ea9cda210
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/emphasis.go
@@ -0,0 +1,89 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+type Delimiter struct {
+	Length int
+	Jump   int
+	Token  int
+	Level  int
+	End    int
+	Open   bool
+	Close  bool
+	Marker byte
+}
+
+func ruleEmphasis(s *StateInline, silent bool) bool {
+	src := s.Src
+	start := s.Pos
+	marker := src[start]
+
+	if silent {
+		return false
+	}
+
+	if marker != '_' && marker != '*' {
+		return false
+	}
+
+	canOpen, canClose, length := s.scanDelims(s.Pos, marker == '*')
+	for i := 0; i < length; i++ {
+		s.PushToken(&Text{Content: string(marker)})
+
+		s.Delimiters = append(s.Delimiters, Delimiter{
+			Marker: marker,
+			Length: length,
+			Jump:   i,
+			Token:  len(s.Tokens) - 1,
+			Level:  s.Level,
+			End:    -1,
+			Open:   canOpen,
+			Close:  canClose,
+		})
+	}
+
+	s.Pos += length
+
+	return true
+}
+
+func ruleEmphasisPostprocess(s *StateInline) {
+	delimiters := s.Delimiters
+	max := len(delimiters)
+	for i := max - 1; i >= 0; i-- {
+		startDelim := delimiters[i]
+		if startDelim.Marker != '_' && startDelim.Marker != '*' {
+			continue
+		}
+
+		if startDelim.End == -1 {
+			continue
+		}
+
+		endDelim := delimiters[startDelim.End]
+
+		isStrong := i > 0 &&
+			delimiters[i-1].End == startDelim.End+1 &&
+			delimiters[i-1].Token == startDelim.Token-1 &&
+			delimiters[startDelim.End+1].Token == endDelim.Token+1 &&
+			delimiters[i-1].Marker == startDelim.Marker
+
+		if isStrong {
+			s.Tokens[startDelim.Token] = &StrongOpen{}
+			s.Tokens[endDelim.Token] = &StrongClose{}
+
+			if text, ok := s.Tokens[delimiters[i-1].Token].(*Text); ok {
+				text.Content = ""
+			}
+			if text, ok := s.Tokens[delimiters[startDelim.End+1].Token].(*Text); ok {
+				text.Content = ""
+			}
+			i--
+		} else {
+			s.Tokens[startDelim.Token] = &EmphasisOpen{}
+			s.Tokens[endDelim.Token] = &EmphasisClose{}
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/entity.go b/vendor/gitlab.com/golang-commonmark/markdown/entity.go
new file mode 100644
index 000000000..fd5fba9c0
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/entity.go
@@ -0,0 +1,35 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "gitlab.com/golang-commonmark/html"
+
+func ruleEntity(s *StateInline, silent bool) bool {
+	pos := s.Pos
+	src := s.Src
+
+	if src[pos] != '&' {
+		return false
+	}
+
+	max := s.PosMax
+
+	if pos+1 < max {
+		if e, n := html.ParseEntity(src[pos:]); n > 0 {
+			if !silent {
+				s.Pending.WriteString(e)
+			}
+			s.Pos += n
+			return true
+		}
+	}
+
+	if !silent {
+		s.Pending.WriteByte('&')
+	}
+	s.Pos++
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/escape.go b/vendor/gitlab.com/golang-commonmark/markdown/escape.go
new file mode 100644
index 000000000..634b9735c
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/escape.go
@@ -0,0 +1,61 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "strings"
+
+func escaped(b byte) bool {
+	return strings.IndexByte("\\!\"#$%&'()*+,./:;<=>?@[]^_`{|}~-", b) != -1
+}
+
+func ruleEscape(s *StateInline, silent bool) bool {
+	pos := s.Pos
+	src := s.Src
+
+	if src[pos] != '\\' {
+		return false
+	}
+
+	pos++
+	max := s.PosMax
+
+	if pos < max {
+		b := src[pos]
+
+		if b < 0x7f && escaped(b) {
+			if !silent {
+				s.Pending.WriteByte(b)
+			}
+			s.Pos += 2
+			return true
+		}
+
+		if b == '\n' {
+			if !silent {
+				s.PushToken(&Hardbreak{})
+			}
+
+			pos++
+
+			for pos < max {
+				b := src[pos]
+				if !byteIsSpace(b) {
+					break
+				}
+				pos++
+			}
+
+			s.Pos = pos
+			return true
+		}
+	}
+
+	if !silent {
+		s.Pending.WriteByte('\\')
+	}
+	s.Pos++
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/fence.go b/vendor/gitlab.com/golang-commonmark/markdown/fence.go
new file mode 100644
index 000000000..04924dc49
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/fence.go
@@ -0,0 +1,102 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "strings"
+
+func ruleFence(s *StateBlock, startLine, endLine int, silent bool) bool {
+	haveEndMarker := false
+	pos := s.BMarks[startLine] + s.TShift[startLine]
+	max := s.EMarks[startLine]
+
+	if s.SCount[startLine]-s.BlkIndent >= 4 {
+		return false
+	}
+	if pos+3 > max {
+		return false
+	}
+
+	src := s.Src
+
+	marker := src[pos]
+	if marker != '~' && marker != '`' {
+		return false
+	}
+
+	mem := pos
+	pos = s.SkipBytes(pos, marker)
+
+	len := pos - mem
+
+	if len < 3 {
+		return false
+	}
+
+	params := strings.TrimSpace(src[pos:max])
+
+	if strings.IndexByte(params, marker) >= 0 {
+		return false
+	}
+
+	if silent {
+		return true
+	}
+
+	nextLine := startLine
+
+	for {
+		nextLine++
+		if nextLine >= endLine {
+			break
+		}
+
+		mem = s.BMarks[nextLine] + s.TShift[nextLine]
+		pos = mem
+		max = s.EMarks[nextLine]
+
+		if pos < max && s.SCount[nextLine] < s.BlkIndent {
+			break
+		}
+
+		if pos >= max || src[pos] != marker {
+			continue
+		}
+
+		if s.SCount[nextLine]-s.BlkIndent >= 4 {
+			continue
+		}
+
+		pos = s.SkipBytes(pos, marker)
+
+		if pos-mem < len {
+			continue
+		}
+
+		pos = s.SkipSpaces(pos)
+
+		if pos < max {
+			continue
+		}
+
+		haveEndMarker = true
+
+		break
+	}
+
+	len = s.SCount[startLine]
+
+	s.Line = nextLine
+	if haveEndMarker {
+		s.Line++
+	}
+
+	s.PushToken(&Fence{
+		Params:  params,
+		Content: s.Lines(startLine+1, nextLine, len, true),
+		Map:     [2]int{startLine, s.Line},
+	})
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/fuzz.go b/vendor/gitlab.com/golang-commonmark/markdown/fuzz.go
new file mode 100644
index 000000000..66ac7697c
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/fuzz.go
@@ -0,0 +1,9 @@
+//+build gofuzz
+
+package markdown
+
+func Fuzz(data []byte) int {
+	md := New(HTML(true))
+	md.Parse(data)
+	return 1
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/heading.go b/vendor/gitlab.com/golang-commonmark/markdown/heading.go
new file mode 100644
index 000000000..a09c4f726
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/heading.go
@@ -0,0 +1,59 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "strings"
+
+func ruleHeading(s *StateBlock, startLine, _ int, silent bool) bool {
+	pos := s.BMarks[startLine] + s.TShift[startLine]
+	max := s.EMarks[startLine]
+	src := s.Src
+
+	if s.SCount[startLine]-s.BlkIndent >= 4 {
+		return false
+	}
+
+	if pos >= max || src[pos] != '#' {
+		return false
+	}
+
+	level := 1
+	pos++
+	for pos < max && src[pos] == '#' && level <= 6 {
+		level++
+		pos++
+	}
+
+	if level > 6 || (pos < max && !byteIsSpace(src[pos])) {
+		return false
+	}
+
+	if silent {
+		return true
+	}
+
+	max = s.SkipSpacesBack(max, pos)
+	tmp := s.SkipBytesBack(max, '#', pos)
+	if tmp > pos && byteIsSpace(src[tmp-1]) {
+		max = tmp
+	}
+
+	s.Line = startLine + 1
+
+	s.PushOpeningToken(&HeadingOpen{
+		HLevel: level,
+		Map:    [2]int{startLine, s.Line},
+	})
+
+	if pos < max {
+		s.PushToken(&Inline{
+			Content: strings.TrimSpace(src[pos:max]),
+			Map:     [2]int{startLine, s.Line},
+		})
+	}
+	s.PushClosingToken(&HeadingClose{HLevel: level})
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/helpers.go b/vendor/gitlab.com/golang-commonmark/markdown/helpers.go
new file mode 100644
index 000000000..d158dfcfb
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/helpers.go
@@ -0,0 +1,164 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+func parseLinkLabel(s *StateInline, start int, disableNested bool) int {
+	src := s.Src
+	labelEnd := -1
+	max := s.PosMax
+	oldPos := s.Pos
+
+	s.Pos = start + 1
+	level := 1
+	found := false
+
+	for s.Pos < max {
+		marker := src[s.Pos]
+
+		if marker == ']' {
+			level--
+			if level == 0 {
+				found = true
+				break
+			}
+		}
+
+		prevPos := s.Pos
+
+		s.Md.Inline.SkipToken(s)
+
+		if marker == '[' {
+			if prevPos == s.Pos-1 {
+				level++
+			} else if disableNested {
+				s.Pos = oldPos
+				return -1
+			}
+		}
+	}
+
+	if found {
+		labelEnd = s.Pos
+	}
+
+	s.Pos = oldPos
+
+	return labelEnd
+}
+
+func parseLinkDestination(s string, pos, max int) (url string, lines, endpos int, ok bool) {
+	start := pos
+	if pos < max && s[pos] == '<' {
+		pos++
+		for pos < max {
+			b := s[pos]
+			if b == '\n' || byteIsSpace(b) {
+				return
+			}
+			if b == '>' {
+				endpos = pos + 1
+				url = unescapeAll(s[start+1 : pos])
+				ok = true
+				return
+			}
+			if b == '\\' && pos+1 < max {
+				pos += 2
+				continue
+			}
+
+			pos++
+		}
+
+		return
+	}
+
+	level := 0
+	for pos < max {
+		b := s[pos]
+
+		if b == ' ' {
+			break
+		}
+
+		if b < 0x20 || b == 0x7f {
+			break
+		}
+
+		if b == '\\' && pos+1 < max {
+			pos += 2
+			continue
+		}
+
+		if b == '(' {
+			level++
+		}
+
+		if b == ')' {
+			if level == 0 {
+				break
+			}
+			level--
+		}
+
+		pos++
+	}
+
+	if start == pos {
+		return
+	}
+	if level != 0 {
+		return
+	}
+
+	url = unescapeAll(s[start:pos])
+	endpos = pos
+	ok = true
+
+	return
+}
+
+func parseLinkTitle(s string, pos, max int) (title string, nlines, endpos int, ok bool) {
+	lines := 0
+	start := pos
+
+	if pos >= max {
+		return
+	}
+
+	marker := s[pos]
+
+	if marker != '"' && marker != '\'' && marker != '(' {
+		return
+	}
+
+	pos++
+
+	if marker == '(' {
+		marker = ')'
+	}
+
+	for pos < max {
+		switch s[pos] {
+		case marker:
+			endpos = pos + 1
+			nlines = lines
+			title = unescapeAll(s[start+1 : pos])
+			ok = true
+			return
+		case '\n':
+			lines++
+		case '\\':
+			if pos+1 < max {
+				pos++
+				if s[pos] == '\n' {
+					lines++
+				}
+			}
+		}
+		pos++
+	}
+
+	return
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/helpers_test.go b/vendor/gitlab.com/golang-commonmark/markdown/helpers_test.go
new file mode 100644
index 000000000..f180b7c4e
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/helpers_test.go
@@ -0,0 +1,71 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "testing"
+
+func TestParseLinkTitle(t *testing.T) {
+	type testCase struct {
+		in             string
+		title          string
+		nlines, endpos int
+		ok             bool
+	}
+	testCases := []testCase{
+		{"(multiline\ntitle)", "multiline\ntitle", 1, 17, true},
+		{`"\"title\""`, `"title"`, 0, 11, true},
+		{`"title"`, "title", 0, 7, true},
+		{`"(title)"`, `(title)`, 0, 9, true},
+		{`("title")`, `"title"`, 0, 9, true},
+		{"", "", 0, 0, false},
+		{`"`, "", 0, 0, false},
+		{"(", "", 0, 0, false},
+		{`(\`, "", 0, 0, false},
+		{"(\\\n", "", 0, 0, false},
+		{`"\"title\"`, "", 0, 0, false},
+		{`"title`, "", 0, 0, false},
+		{`("title"`, "", 0, 0, false},
+		{"x", "", 0, 0, false},
+	}
+	for _, tc := range testCases {
+		title, nlines, endpos, ok := parseLinkTitle(tc.in, 0, len(tc.in))
+		if title != tc.title || nlines != tc.nlines || endpos != tc.endpos || ok != tc.ok {
+			t.Errorf("parseLinkTitle(%q) = (%q, %d, %d, %v), want (%q, %d, %d, %v)", tc.in, title, nlines, endpos, ok, tc.title, tc.nlines, tc.endpos, tc.ok)
+		}
+	}
+}
+
+func TestParseLinkDestination(t *testing.T) {
+	type testCase struct {
+		in     string
+		title  string
+		endpos int
+		ok     bool
+	}
+	testCases := []testCase{
+		{"<\\>>", ">", 4, true},
+		{"http://goo gle.com", "http://goo", 10, true},
+		{"http://google.com", "http://google.com", 17, true},
+		{"http://google.com/search?query=(1)", "http://google.com/search?query=(1)", 34, true},
+		{"http://google.com/search?query=)1(", "http://google.com/search?query=", 31, true},
+		{"http://google.com/search?query=((1))", "http://google.com/search?query=((1))", 36, true},
+		{`http://google.com/search?query=a\ b\ c`, `http://google.com/search?query=a\ b\ c`, 38, true},
+		{"http://goo\x00gle.com", "http://goo", 10, true},
+		{"<link>", "link", 6, true},
+		{"<", "", 0, false},
+		{"<\\>", "", 0, false},
+		{"<\\", "", 0, false},
+		{"", "", 0, false},
+		{"<>", "", 2, true},
+		{"<link", "", 0, false},
+		{"<\n", "", 0, false},
+	}
+	for _, tc := range testCases {
+		title, _, endpos, ok := parseLinkDestination(tc.in, 0, len(tc.in))
+		if title != tc.title || endpos != tc.endpos || ok != tc.ok {
+			t.Errorf("parseLinkDestination(%q) = (%q, %d, %v), want (%q, %d, %v)", tc.in, title, endpos, ok, tc.title, tc.endpos, tc.ok)
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/hr.go b/vendor/gitlab.com/golang-commonmark/markdown/hr.go
new file mode 100644
index 000000000..fe25681d9
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/hr.go
@@ -0,0 +1,54 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+func ruleHR(s *StateBlock, startLine, endLine int, silent bool) bool {
+	pos := s.BMarks[startLine] + s.TShift[startLine]
+	max := s.EMarks[startLine]
+
+	if pos >= max {
+		return false
+	}
+
+	if s.SCount[startLine]-s.BlkIndent >= 4 {
+		return false
+	}
+
+	src := s.Src
+	marker := src[pos]
+	pos++
+
+	if marker != '*' && marker != '-' && marker != '_' {
+		return false
+	}
+
+	cnt := 1
+	for pos < max {
+		ch := src[pos]
+		pos++
+		if ch != marker && !byteIsSpace(ch) {
+			return false
+		}
+		if ch == marker {
+			cnt++
+		}
+	}
+
+	if cnt < 3 {
+		return false
+	}
+
+	if silent {
+		return true
+	}
+
+	s.Line = startLine + 1
+
+	s.PushToken(&Hr{
+		Map: [2]int{startLine, s.Line},
+	})
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/html_block.go b/vendor/gitlab.com/golang-commonmark/markdown/html_block.go
new file mode 100644
index 000000000..98a89499e
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/html_block.go
@@ -0,0 +1,222 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"regexp"
+	"strings"
+)
+
+var (
+	htmlBlocks = []string{
+		"address",
+		"article",
+		"aside",
+		"base",
+		"basefont",
+		"blockquote",
+		"body",
+		"caption",
+		"center",
+		"col",
+		"colgroup",
+		"dd",
+		"details",
+		"dialog",
+		"dir",
+		"div",
+		"dl",
+		"dt",
+		"fieldset",
+		"figcaption",
+		"figure",
+		"footer",
+		"form",
+		"frame",
+		"frameset",
+		"h1",
+		"h2",
+		"h3",
+		"h4",
+		"h5",
+		"h6",
+		"head",
+		"header",
+		"hr",
+		"html",
+		"iframe",
+		"legend",
+		"li",
+		"link",
+		"main",
+		"menu",
+		"menuitem",
+		"meta",
+		"nav",
+		"noframes",
+		"ol",
+		"optgroup",
+		"option",
+		"p",
+		"param",
+		"section",
+		"source",
+		"summary",
+		"table",
+		"tbody",
+		"td",
+		"tfoot",
+		"th",
+		"thead",
+		"title",
+		"tr",
+		"track",
+		"ul",
+	}
+
+	htmlBlocksSet = make(map[string]bool)
+
+	rStartCond1 = regexp.MustCompile(`(?i)^(pre|script|style)([\n\t >]|$)`)
+	rEndCond1   = regexp.MustCompile(`(?i)</(pre|script|style)>`)
+	rStartCond6 = regexp.MustCompile(`(?i)^/?(` + strings.Join(htmlBlocks, "|") + `)(\s|$|>|/>)`)
+	rStartCond7 = regexp.MustCompile(`(?i)^(/[a-z][a-z0-9-]*|[a-z][a-z0-9-]*(\s+[a-z_:][a-z0-9_.:-]*\s*=\s*("[^"]*"|'[^']*'|[ "'=<>\x60]))*\s*/?)>\s*$`)
+)
+
+func init() {
+	for _, tag := range htmlBlocks {
+		htmlBlocksSet[tag] = true
+	}
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func matchTagName(s string) string {
+	if len(s) < 2 {
+		return ""
+	}
+
+	i := 0
+	if s[0] == '/' {
+		i++
+	}
+	start := i
+	max := min(15+i, len(s))
+	for i < max && isLetter(s[i]) {
+		i++
+	}
+	if i >= len(s) {
+		return ""
+	}
+
+	switch s[i] {
+	case ' ', '\n', '/', '>':
+		return strings.ToLower(s[start:i])
+	default:
+		return ""
+	}
+}
+
+func ruleHTMLBlock(s *StateBlock, startLine, endLine int, silent bool) bool {
+	if !s.Md.HTML {
+		return false
+	}
+
+	pos := s.BMarks[startLine] + s.TShift[startLine]
+	max := s.EMarks[startLine]
+
+	if pos+1 >= max {
+		return false
+	}
+
+	src := s.Src
+
+	if src[pos] != '<' {
+		return false
+	}
+
+	pos++
+	b := src[pos]
+	if !htmlSecond(b) {
+		return false
+	}
+
+	nextLine := startLine + 1
+
+	var endCond func(string) bool
+
+	if pos+2 < max && isLetter(b) && rStartCond1.MatchString(src[pos:]) {
+		endCond = func(s string) bool {
+			return rEndCond1.MatchString(s)
+		}
+	} else if strings.HasPrefix(src[pos:], "!--") {
+		endCond = func(s string) bool {
+			return strings.Contains(s, "-->")
+		}
+	} else if b == '?' {
+		endCond = func(s string) bool {
+			return strings.Contains(s, "?>")
+		}
+	} else if b == '!' && pos+1 < max && isUppercaseLetter(src[pos+1]) {
+		endCond = func(s string) bool {
+			return strings.Contains(s, ">")
+		}
+	} else if strings.HasPrefix(src[pos:], "![CDATA[") {
+		endCond = func(s string) bool {
+			return strings.Contains(s, "]]>")
+		}
+	} else if pos+2 < max && (isLetter(b) || b == '/' && isLetter(src[pos+1])) {
+		terminator := true
+		if rStartCond6.MatchString(src[pos:max]) {
+		} else if rStartCond7.MatchString(src[pos:max]) {
+			terminator = false
+		} else {
+			return false
+		}
+		if silent {
+			return terminator
+		}
+		endCond = func(s string) bool {
+			return s == ""
+		}
+	} else {
+		return false
+	}
+
+	if silent {
+		return true
+	}
+
+	if !endCond(src[pos:max]) {
+		for nextLine < endLine {
+			if s.SCount[nextLine] < s.BlkIndent {
+				break
+			}
+
+			pos := s.BMarks[nextLine] + s.TShift[nextLine]
+			max := s.EMarks[nextLine]
+			lineText := src[pos:max]
+			if endCond(lineText) {
+				if pos != max {
+					nextLine++
+				}
+				break
+			}
+			nextLine++
+		}
+	}
+
+	s.Line = nextLine
+	s.PushToken(&HTMLBlock{
+		Content: s.Lines(startLine, nextLine, s.BlkIndent, true),
+		Map:     [2]int{startLine, nextLine},
+	})
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/html_block_test.go b/vendor/gitlab.com/golang-commonmark/markdown/html_block_test.go
new file mode 100644
index 000000000..d062180aa
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/html_block_test.go
@@ -0,0 +1,32 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "testing"
+
+func TestMatchTagName(t *testing.T) {
+	type testCase struct {
+		in   string
+		want string
+	}
+	testCases := []testCase{
+		{"", ""},
+		{"a", ""},
+		{"/a>", "a"},
+		{"a>", "a"},
+		{"A>", "a"},
+		{"a\n", "a"},
+		{"br/>", "br"},
+		{"em", ""},
+		{"waytoolongtobeatag>", ""},
+		{"waytoolongtobeatag", ""},
+	}
+	for _, tc := range testCases {
+		got := matchTagName(tc.in)
+		if got != tc.want {
+			t.Errorf("matchTagName(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/html_inline.go b/vendor/gitlab.com/golang-commonmark/markdown/html_inline.go
new file mode 100644
index 000000000..0de54b202
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/html_inline.go
@@ -0,0 +1,57 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "regexp"
+
+var (
+	attrName     = `[a-zA-Z_:][a-zA-Z0-9:._-]*`
+	unquoted     = "[^\"'=<>`\\x00-\\x20]+"
+	singleQuoted = `'[^']*'`
+	doubleQuoted = `"[^"]*"`
+	attrValue    = `(?:` + unquoted + `|` + singleQuoted + `|` + doubleQuoted + `)`
+	attribute    = `(?:\s+` + attrName + `(?:\s*=\s*` + attrValue + `)?)`
+	openTag      = `<[A-Za-z][A-Za-z0-9-]*` + attribute + `*\s*/?>`
+	closeTag     = `</[A-Za-z][A-Za-z0-9-]*\s*>`
+	comment      = `<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->`
+	processing   = `<[?].*?[?]>`
+	declaration  = `<![A-Z]+\s+[^>]*>`
+	cdata        = `<!\[CDATA\[[\s\S]*?\]\]>`
+	rHTMLTag     = regexp.MustCompile(`^(?:` + openTag + `|` + closeTag + `|` + comment +
+		`|` + processing + `|` + declaration + `|` + cdata + `)`)
+)
+
+func htmlSecond(b byte) bool {
+	return b == '!' || b == '/' || b == '?' || isLetter(b)
+}
+
+func ruleHTMLInline(s *StateInline, silent bool) bool {
+	if !s.Md.HTML {
+		return false
+	}
+
+	pos := s.Pos
+	src := s.Src
+	if pos+2 >= s.PosMax || src[pos] != '<' {
+		return false
+	}
+
+	if !htmlSecond(src[pos+1]) {
+		return false
+	}
+
+	match := rHTMLTag.FindString(src[pos:])
+	if match == "" {
+		return false
+	}
+
+	if !silent {
+		s.PushToken(&HTMLInline{Content: match})
+	}
+
+	s.Pos += len(match)
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/image.go b/vendor/gitlab.com/golang-commonmark/markdown/image.go
new file mode 100644
index 000000000..7f2e67d30
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/image.go
@@ -0,0 +1,131 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+func ruleImage(s *StateInline, silent bool) bool {
+	pos := s.Pos
+	max := s.PosMax
+
+	if pos+2 >= max {
+		return false
+	}
+
+	src := s.Src
+	if src[pos] != '!' || src[pos+1] != '[' {
+		return false
+	}
+
+	labelStart := pos + 2
+	labelEnd := parseLinkLabel(s, pos+1, false)
+	if labelEnd < 0 {
+		return false
+	}
+
+	var href, title, label string
+	oldPos := pos
+	pos = labelEnd + 1
+	if pos < max && src[pos] == '(' {
+		pos++
+		for pos < max {
+			b := src[pos]
+			if !byteIsSpace(b) && b != '\n' {
+				break
+			}
+			pos++
+		}
+		if pos >= max {
+			return false
+		}
+
+		start := pos
+		url, _, endpos, ok := parseLinkDestination(src, pos, s.PosMax)
+		if ok {
+			url = normalizeLink(url)
+			if validateLink(url) {
+				href = url
+				pos = endpos
+			}
+		}
+
+		start = pos
+		for pos < max {
+			b := src[pos]
+			if !byteIsSpace(b) && b != '\n' {
+				break
+			}
+			pos++
+		}
+		if pos >= max {
+			return false
+		}
+
+		title, _, endpos, ok = parseLinkTitle(src, pos, s.PosMax)
+		if pos < max && start != pos && ok {
+			pos = endpos
+			for pos < max {
+				b := src[pos]
+				if !byteIsSpace(b) && b != '\n' {
+					break
+				}
+				pos++
+			}
+		}
+
+		if pos >= max || src[pos] != ')' {
+			s.Pos = oldPos
+			return false
+		}
+
+		pos++
+
+	} else {
+		if s.Env.References == nil {
+			return false
+		}
+
+		if pos < max && src[pos] == '[' {
+			start := pos + 1
+			pos = parseLinkLabel(s, pos, false)
+			if pos >= 0 {
+				label = src[start:pos]
+				pos++
+			} else {
+				pos = labelEnd + 1
+			}
+		} else {
+			pos = labelEnd + 1
+		}
+
+		if label == "" {
+			label = src[labelStart:labelEnd]
+		}
+
+		ref, ok := s.Env.References[normalizeReference(label)]
+		if !ok {
+			s.Pos = oldPos
+			return false
+		}
+
+		href = ref["href"]
+		title = ref["title"]
+	}
+
+	if !silent {
+		content := src[labelStart:labelEnd]
+
+		tokens := s.Md.Inline.Parse(content, s.Md, s.Env)
+
+		s.PushToken(&Image{
+			Src:    href,
+			Title:  title,
+			Tokens: tokens,
+		})
+	}
+
+	s.Pos = pos
+	s.PosMax = max
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/inline.go b/vendor/gitlab.com/golang-commonmark/markdown/inline.go
new file mode 100644
index 000000000..0bed18acf
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/inline.go
@@ -0,0 +1,13 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+func ruleInline(s *StateCore) {
+	for _, tok := range s.Tokens {
+		if tok, ok := tok.(*Inline); ok {
+			tok.Children = s.Md.Inline.Parse(tok.Content, s.Md, s.Env)
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/lheading.go b/vendor/gitlab.com/golang-commonmark/markdown/lheading.go
new file mode 100644
index 000000000..b404066da
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/lheading.go
@@ -0,0 +1,80 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "strings"
+
+func ruleLHeading(s *StateBlock, startLine, endLine int, silent bool) bool {
+	nextLine := startLine + 1
+
+	if s.SCount[startLine]-s.BlkIndent >= 4 {
+		return false
+	}
+
+	oldParentType := s.ParentType
+	s.ParentType = ptParagraph
+	src := s.Src
+
+	var pos int
+	var hLevel int
+outer:
+	for ; nextLine < endLine && !s.IsLineEmpty(nextLine); nextLine++ {
+		if s.SCount[nextLine]-s.BlkIndent > 3 {
+			continue
+		}
+
+		if s.SCount[nextLine] >= s.BlkIndent {
+			pos = s.BMarks[nextLine] + s.TShift[nextLine]
+			max := s.EMarks[nextLine]
+
+			if pos < max {
+				marker := src[pos]
+
+				if marker == '-' || marker == '=' {
+					pos = s.SkipBytes(pos, marker)
+					pos = s.SkipSpaces(pos)
+
+					if pos >= max {
+						hLevel = 1
+						if marker == '-' {
+							hLevel++
+						}
+						break
+					}
+				}
+			}
+		}
+
+		if s.SCount[nextLine] < 0 {
+			continue
+		}
+
+		for _, r := range paragraphTerminatedBy {
+			if r(s, nextLine, endLine, true) {
+				break outer
+			}
+		}
+	}
+
+	if hLevel == 0 {
+		return false
+	}
+
+	s.Line = nextLine + 1
+
+	s.PushOpeningToken(&HeadingOpen{
+		HLevel: hLevel,
+		Map:    [2]int{startLine, s.Line},
+	})
+	s.PushToken(&Inline{
+		Content: strings.TrimSpace(s.Lines(startLine, nextLine, s.BlkIndent, false)),
+		Map:     [2]int{startLine, s.Line - 1},
+	})
+	s.PushClosingToken(&HeadingClose{HLevel: hLevel})
+
+	s.ParentType = oldParentType
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/link.go b/vendor/gitlab.com/golang-commonmark/markdown/link.go
new file mode 100644
index 000000000..8ab2c04bb
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/link.go
@@ -0,0 +1,132 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+func ruleLink(s *StateInline, silent bool) bool {
+	pos := s.Pos
+	oldPos := s.Pos
+	max := s.PosMax
+	start := s.Pos
+	parseReference := true
+	src := s.Src
+
+	if src[pos] != '[' {
+		return false
+	}
+
+	labelStart := pos + 1
+	labelEnd := parseLinkLabel(s, pos, true)
+
+	if labelEnd < 0 {
+		return false
+	}
+
+	pos = labelEnd + 1
+
+	var title, href, label string
+	if pos < max && src[pos] == '(' {
+		parseReference = false
+
+		pos++
+		for pos < max {
+			code := src[pos]
+			if !byteIsSpace(code) && code != '\n' {
+				break
+			}
+			pos++
+		}
+		if pos >= max {
+			return false
+		}
+
+		start = pos
+		url, _, endpos, ok := parseLinkDestination(src, pos, s.PosMax)
+		if ok {
+			url = normalizeLink(url)
+			if validateLink(url) {
+				pos = endpos
+				href = url
+			}
+		}
+
+		start = pos
+		for pos < max {
+			code := src[pos]
+			if !byteIsSpace(code) && code != '\n' {
+				break
+			}
+			pos++
+		}
+
+		title, _, endpos, ok = parseLinkTitle(src, pos, s.PosMax)
+		if pos < max && start != pos && ok {
+			pos = endpos
+			for pos < max {
+				code := src[pos]
+				if !byteIsSpace(code) && code != '\n' {
+					break
+				}
+				pos++
+			}
+		}
+
+		if pos >= max || src[pos] != ')' {
+			parseReference = true
+		}
+
+		pos++
+	}
+
+	if parseReference {
+		if s.Env.References == nil {
+			return false
+		}
+
+		if pos < max && src[pos] == '[' {
+			start := pos + 1
+			pos = parseLinkLabel(s, pos, false)
+			if pos >= 0 {
+				label = src[start:pos]
+				pos++
+			} else {
+				pos = labelEnd + 1
+			}
+		} else {
+			pos = labelEnd + 1
+		}
+
+		if label == "" {
+			label = src[labelStart:labelEnd]
+		}
+
+		ref, ok := s.Env.References[normalizeReference(label)]
+		if !ok {
+			s.Pos = oldPos
+			return false
+		}
+
+		href = ref["href"]
+		title = ref["title"]
+	}
+
+	if !silent {
+		s.Pos = labelStart
+		s.PosMax = labelEnd
+
+		s.PushOpeningToken(&LinkOpen{
+			Href:  href,
+			Title: title,
+		})
+
+		s.Md.Inline.Tokenize(s)
+
+		s.PushClosingToken(&LinkClose{})
+	}
+
+	s.Pos = pos
+	s.PosMax = max
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/linkify.go b/vendor/gitlab.com/golang-commonmark/markdown/linkify.go
new file mode 100644
index 000000000..5935af1be
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/linkify.go
@@ -0,0 +1,131 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"strings"
+
+	"gitlab.com/golang-commonmark/linkify"
+)
+
+func isLinkOpen(s string) bool { return isLetter(s[1]) }
+
+func isLinkClose(s string) bool { return s[1] == '/' }
+
+func ruleLinkify(s *StateCore) {
+	blockTokens := s.Tokens
+
+	if !s.Md.Linkify {
+		return
+	}
+
+	for _, tok := range blockTokens {
+		if tok, ok := tok.(*Inline); ok {
+			tokens := tok.Children
+
+			htmlLinkLevel := 0
+
+			for i := len(tokens) - 1; i >= 0; i-- {
+				currentTok := tokens[i]
+
+				if _, ok := currentTok.(*LinkClose); ok {
+					i--
+					for tokens[i].Level() != currentTok.Level() {
+						if _, ok := tokens[i].(*LinkOpen); ok {
+							break
+						}
+						i--
+					}
+					continue
+				}
+
+				if currentTok, ok := currentTok.(*HTMLInline); ok {
+					if isLinkOpen(currentTok.Content) && htmlLinkLevel > 0 {
+						htmlLinkLevel--
+					}
+					if isLinkClose(currentTok.Content) {
+						htmlLinkLevel++
+					}
+				}
+				if htmlLinkLevel > 0 {
+					continue
+				}
+
+				if currentTok, ok := currentTok.(*Text); ok {
+					text := currentTok.Content
+					links := linkify.Links(text)
+					if len(links) == 0 {
+						continue
+					}
+
+					var nodes []Token
+					level := currentTok.Lvl
+					lastPos := 0
+
+					for _, ln := range links {
+						urlText := text[ln.Start:ln.End]
+						url := urlText
+						if ln.Scheme == "" {
+							url = "http://" + url
+						} else if ln.Scheme == "mailto:" && !strings.HasPrefix(url, "mailto:") {
+							url = "mailto:" + url
+						}
+						url = normalizeLink(url)
+						if !validateLink(url) {
+							continue
+						}
+
+						if ln.Scheme == "" {
+							urlText = strings.TrimPrefix(normalizeLinkText("http://"+urlText), "http://")
+						} else if ln.Scheme == "mailto:" && !strings.HasPrefix(urlText, "mailto:") {
+							urlText = strings.TrimPrefix(normalizeLinkText("mailto:"+urlText), "mailto:")
+						} else {
+							urlText = normalizeLinkText(urlText)
+						}
+
+						pos := ln.Start
+
+						if pos > lastPos {
+							tok := Text{
+								Content: text[lastPos:pos],
+								Lvl:     level,
+							}
+							nodes = append(nodes, &tok)
+						}
+
+						nodes = append(nodes, &LinkOpen{
+							Href: url,
+							Lvl:  level,
+						})
+						nodes = append(nodes, &Text{
+							Content: urlText,
+							Lvl:     level + 1,
+						})
+						nodes = append(nodes, &LinkClose{
+							Lvl: level,
+						})
+
+						lastPos = ln.End
+					}
+
+					if lastPos < len(text) {
+						tok := Text{
+							Content: text[lastPos:],
+							Lvl:     level,
+						}
+						nodes = append(nodes, &tok)
+					}
+
+					children := make([]Token, len(tokens)+len(nodes)-1)
+					copy(children, tokens[:i])
+					copy(children[i:], nodes)
+					copy(children[i+len(nodes):], tokens[i+1:])
+					tok.Children = children
+					tokens = children
+				}
+			}
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/list.go b/vendor/gitlab.com/golang-commonmark/markdown/list.go
new file mode 100644
index 000000000..3b2e02303
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/list.go
@@ -0,0 +1,285 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "strconv"
+
+var listTerminatedBy []BlockRule
+
+func skipBulletListMarker(s *StateBlock, startLine int) int {
+	pos := s.BMarks[startLine] + s.TShift[startLine]
+	max := s.EMarks[startLine]
+	src := s.Src
+
+	if pos >= max {
+		return -1
+	}
+
+	marker := src[pos]
+	if marker != '*' && marker != '-' && marker != '+' {
+		return -1
+	}
+	pos++
+
+	if pos < max && !byteIsSpace(src[pos]) {
+		return -1
+	}
+
+	return pos
+}
+
+func skipOrderedListMarker(s *StateBlock, startLine int) int {
+	start := s.BMarks[startLine] + s.TShift[startLine]
+	pos := start
+	max := s.EMarks[startLine]
+
+	if pos+1 >= max {
+		return -1
+	}
+
+	src := s.Src
+	ch := src[pos]
+	if ch < '0' || ch > '9' {
+		return -1
+	}
+	pos++
+
+	for {
+		if pos >= max {
+			return -1
+		}
+
+		ch = src[pos]
+		pos++
+
+		if ch >= '0' && ch <= '9' {
+			if pos-start >= 10 {
+				return -1
+			}
+			continue
+		}
+
+		if ch == ')' || ch == '.' {
+			break
+		}
+
+		return -1
+	}
+
+	if pos < max && !byteIsSpace(src[pos]) {
+		return -1
+	}
+
+	return pos
+}
+
+func markParagraphsTight(s *StateBlock, idx int) {
+	level := s.Level + 2
+	tokens := s.Tokens
+
+	for i := idx + 2; i < len(tokens)-2; i++ {
+		if tokens[i].Level() == level {
+			if tok, ok := tokens[i].(*ParagraphOpen); ok {
+				tok.Hidden = true
+				i += 2
+				tokens[i].(*ParagraphClose).Hidden = true
+			}
+		}
+	}
+}
+
+func ruleList(s *StateBlock, startLine, endLine int, silent bool) bool {
+	isTerminatingParagraph := false
+	tight := true
+
+	if s.SCount[startLine]-s.BlkIndent >= 4 {
+		return false
+	}
+	src := s.Src
+
+	if silent && s.ParentType == ptParagraph {
+		if s.TShift[startLine] >= s.BlkIndent {
+			isTerminatingParagraph = true
+		}
+	}
+
+	var start int
+	var markerValue int
+
+	isOrdered := false
+	posAfterMarker := skipOrderedListMarker(s, startLine)
+	if posAfterMarker > 0 {
+		isOrdered = true
+		start = s.BMarks[startLine] + s.TShift[startLine]
+		markerValue, _ = strconv.Atoi(src[start : posAfterMarker-1])
+
+		if isTerminatingParagraph && markerValue != 1 {
+			return false
+		}
+	} else {
+		posAfterMarker = skipBulletListMarker(s, startLine)
+		if posAfterMarker < 0 {
+			return false
+		}
+	}
+
+	if isTerminatingParagraph {
+		if s.SkipSpaces(posAfterMarker) >= s.EMarks[startLine] {
+			return false
+		}
+	}
+
+	markerChar := src[posAfterMarker-1]
+
+	if silent {
+		return true
+	}
+
+	tokenIdx := len(s.Tokens)
+
+	var listMap *[2]int
+	if isOrdered {
+		tok := &OrderedListOpen{
+			Order: markerValue,
+			Map:   [2]int{startLine, 0},
+		}
+		s.PushOpeningToken(tok)
+		listMap = &tok.Map
+	} else {
+		tok := &BulletListOpen{
+			Map: [2]int{startLine, 0},
+		}
+		s.PushOpeningToken(tok)
+		listMap = &tok.Map
+	}
+
+	nextLine := startLine
+	prevEmptyEnd := false
+
+	oldParentType := s.ParentType
+	s.ParentType = ptList
+
+	var pos int
+	var contentStart int
+
+outer:
+	for nextLine < endLine {
+		pos = posAfterMarker
+		max := s.EMarks[nextLine]
+
+		initial := s.SCount[nextLine] + posAfterMarker - (s.BMarks[startLine] + s.TShift[startLine])
+		offset := initial
+
+	loop:
+		for pos < max {
+			switch src[pos] {
+			case '\t':
+				offset += 4 - (offset+s.BSCount[nextLine])%4
+			case ' ':
+				offset++
+			default:
+				break loop
+			}
+			pos++
+		}
+
+		contentStart = pos
+
+		indentAfterMarker := 1
+		if contentStart < max {
+			if iam := offset - initial; iam <= 4 {
+				indentAfterMarker = iam
+			}
+		}
+
+		indent := initial + indentAfterMarker
+
+		tok := &ListItemOpen{
+			Map: [2]int{startLine, 0},
+		}
+		s.PushOpeningToken(tok)
+		itemMap := &tok.Map
+
+		oldIndent := s.BlkIndent
+		oldTight := s.Tight
+		oldTShift := s.TShift[startLine]
+		oldLIndent := s.SCount[startLine]
+		s.BlkIndent = indent
+		s.Tight = true
+		s.TShift[startLine] = contentStart - s.BMarks[startLine]
+		s.SCount[startLine] = offset
+
+		if contentStart >= max && s.IsLineEmpty(startLine+1) {
+			s.Line = min(s.Line+2, endLine)
+		} else {
+			s.Md.Block.Tokenize(s, startLine, endLine)
+		}
+
+		if !s.Tight || prevEmptyEnd {
+			tight = false
+		}
+
+		prevEmptyEnd = s.Line-startLine > 1 && s.IsLineEmpty(s.Line-1)
+
+		s.BlkIndent = oldIndent
+		s.TShift[startLine] = oldTShift
+		s.SCount[startLine] = oldLIndent
+		s.Tight = oldTight
+
+		s.PushClosingToken(&ListItemClose{})
+
+		startLine = s.Line
+		nextLine = startLine
+		(*itemMap)[1] = nextLine
+
+		if nextLine >= endLine {
+			break
+		}
+
+		contentStart = s.BMarks[startLine]
+
+		if s.SCount[nextLine] < s.BlkIndent {
+			break
+		}
+
+		for _, r := range listTerminatedBy {
+			if r(s, nextLine, endLine, true) {
+				break outer
+			}
+		}
+
+		if isOrdered {
+			posAfterMarker = skipOrderedListMarker(s, nextLine)
+			if posAfterMarker < 0 {
+				break
+			}
+		} else {
+			posAfterMarker = skipBulletListMarker(s, nextLine)
+			if posAfterMarker < 0 {
+				break
+			}
+		}
+
+		if markerChar != src[posAfterMarker-1] {
+			break
+		}
+	}
+
+	if isOrdered {
+		s.PushClosingToken(&OrderedListClose{})
+	} else {
+		s.PushClosingToken(&BulletListClose{})
+	}
+
+	(*listMap)[1] = nextLine
+	s.Line = nextLine
+	s.ParentType = oldParentType
+
+	if tight {
+		markParagraphsTight(s, tokenIdx)
+	}
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/markdown.go b/vendor/gitlab.com/golang-commonmark/markdown/markdown.go
new file mode 100644
index 000000000..1e37b3aee
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/markdown.go
@@ -0,0 +1,112 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package markdown provides CommonMark-compliant markdown parser and renderer.
+package markdown
+
+import (
+	"bytes"
+	"io"
+)
+
+type Markdown struct {
+	options
+	Block         ParserBlock
+	Inline        ParserInline
+	renderOptions RenderOptions
+}
+
+type RenderOptions struct {
+	LangPrefix string // CSS language class prefix for fenced blocks
+	XHTML      bool   // render as XHTML instead of HTML
+	Breaks     bool   // convert \n in paragraphs into <br>
+	Nofollow   bool   // add rel="nofollow" to the links
+}
+
+type options struct {
+	HTML        bool      // allow raw HTML in the markup
+	Tables      bool      // GFM tables
+	Linkify     bool      // autoconvert URL-like text to links
+	Typographer bool      // enable some typographic replacements
+	Quotes      [4]string // double/single quotes replacement pairs
+	MaxNesting  int       // maximum nesting level
+}
+
+type Environment struct {
+	References map[string]map[string]string
+}
+
+type CoreRule func(*StateCore)
+
+var coreRules []CoreRule
+
+func New(opts ...option) *Markdown {
+	m := &Markdown{
+		options: options{
+			Tables:      true,
+			Linkify:     true,
+			Typographer: true,
+			Quotes:      [4]string{"“", "”", "‘", "’"},
+			MaxNesting:  20,
+		},
+		renderOptions: RenderOptions{LangPrefix: "language-"},
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+func (m *Markdown) Parse(src []byte) []Token {
+	if len(src) == 0 {
+		return nil
+	}
+
+	s := &StateCore{
+		Md:  m,
+		Env: &Environment{},
+	}
+	s.Tokens = m.Block.Parse(src, m, s.Env)
+
+	for _, r := range coreRules {
+		r(s)
+	}
+	return s.Tokens
+}
+
+func (m *Markdown) Render(w io.Writer, src []byte) error {
+	if len(src) == 0 {
+		return nil
+	}
+
+	return NewRenderer(w).Render(m.Parse(src), m.renderOptions)
+}
+
+func (m *Markdown) RenderTokens(w io.Writer, tokens []Token) error {
+	if len(tokens) == 0 {
+		return nil
+	}
+
+	return NewRenderer(w).Render(tokens, m.renderOptions)
+}
+
+func (m *Markdown) RenderToString(src []byte) string {
+	if len(src) == 0 {
+		return ""
+	}
+
+	var buf bytes.Buffer
+	NewRenderer(&buf).Render(m.Parse(src), m.renderOptions)
+	return buf.String()
+}
+
+func (m *Markdown) RenderTokensToString(tokens []Token) string {
+	if len(tokens) == 0 {
+		return ""
+	}
+
+	var buf bytes.Buffer
+	NewRenderer(&buf).Render(tokens, m.renderOptions)
+	return buf.String()
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/markdown_benchmark_test.go b/vendor/gitlab.com/golang-commonmark/markdown/markdown_benchmark_test.go
new file mode 100644
index 000000000..f0299bcc0
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/markdown_benchmark_test.go
@@ -0,0 +1,93 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"io/ioutil"
+	"testing"
+
+	"github.com/russross/blackfriday"
+	blackfriday2 "gopkg.in/russross/blackfriday.v2"
+)
+
+func BenchmarkRenderSpecNoHTML(b *testing.B) {
+	b.StopTimer()
+	data, err := ioutil.ReadFile("spec/spec-0.28.txt")
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	md := New(HTML(false), XHTMLOutput(true))
+	b.StartTimer()
+
+	for i := 0; i < b.N; i++ {
+		md.RenderToString(data)
+	}
+}
+
+func BenchmarkRenderSpec(b *testing.B) {
+	b.StopTimer()
+	data, err := ioutil.ReadFile("spec/spec-0.28.txt")
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	md := New(HTML(true), XHTMLOutput(true))
+	b.StartTimer()
+
+	for i := 0; i < b.N; i++ {
+		md.RenderToString(data)
+	}
+}
+
+func BenchmarkRenderSpecBlackFriday(b *testing.B) {
+	b.StopTimer()
+	data, err := ioutil.ReadFile("spec/spec-0.28.txt")
+	if err != nil {
+		panic(err)
+	}
+
+	renderer := blackfriday.HtmlRenderer(blackfriday.HTML_USE_XHTML|blackfriday.HTML_USE_SMARTYPANTS|blackfriday.HTML_SMARTYPANTS_LATEX_DASHES, "", "")
+	b.StartTimer()
+
+	for i := 0; i < b.N; i++ {
+		blackfriday.Markdown(data, renderer,
+			blackfriday.EXTENSION_NO_INTRA_EMPHASIS|
+				blackfriday.EXTENSION_TABLES|
+				blackfriday.EXTENSION_FENCED_CODE|
+				blackfriday.EXTENSION_AUTOLINK|
+				blackfriday.EXTENSION_STRIKETHROUGH,
+		)
+	}
+}
+
+func BenchmarkRenderSpecBlackFriday2(b *testing.B) {
+	b.StopTimer()
+	data, err := ioutil.ReadFile("spec/spec-0.28.txt")
+	if err != nil {
+		panic(err)
+	}
+
+	renderer := blackfriday2.NewHTMLRenderer(
+		blackfriday2.HTMLRendererParameters{
+			Flags: blackfriday2.Smartypants |
+				blackfriday2.SmartypantsDashes |
+				blackfriday2.SmartypantsLatexDashes |
+				blackfriday2.SmartypantsAngledQuotes,
+		},
+	)
+	b.StartTimer()
+
+	for i := 0; i < b.N; i++ {
+		blackfriday2.Run(data, blackfriday2.WithExtensions(
+			blackfriday2.NoIntraEmphasis|
+				blackfriday2.Tables|
+				blackfriday2.FencedCode|
+				blackfriday2.Autolink|
+				blackfriday2.Strikethrough),
+			blackfriday2.WithRenderer(renderer),
+		)
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/markdown_it_test.go b/vendor/gitlab.com/golang-commonmark/markdown/markdown_it_test.go
new file mode 100644
index 000000000..f00f7a66b
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/markdown_it_test.go
@@ -0,0 +1,587 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"fmt"
+	"testing"
+)
+
+var mditTests = []struct {
+	markdown string
+	want     string
+	filename string
+}{
+	// 0
+	// Issue #246.  Double escaping in ALT
+	{"![&](#)\n", "<p><img src=\"#\" alt=\"&amp;\"></p>\n", "commonmark_extras.txt"},
+
+	// 1
+	// Strip markdown in ALT tags
+	{"\n![*strip* [markdown __in__ alt](#)](#)\n", "<p><img src=\"#\" alt=\"strip markdown in alt\"></p>\n", "commonmark_extras.txt"},
+
+	// 2
+	// Issue #55:
+	{"\n![test]\n\n![test](foo bar)\n", "<p>![test]</p>\n<p>![test](foo bar)</p>\n", "commonmark_extras.txt"},
+
+	// 3
+	// Issue #35. `<` should work as punctuation
+	{"\nan **(:**<br>\n", "<p>an <strong>(:</strong><br></p>\n", "commonmark_extras.txt"},
+
+	// 4
+	// Should unescape only needed things in link destinations/titles:
+	{"\n[test](<\\f\\o\\o\\>\\\\>)\n\n[test](foo \"\\\\\\\"\\b\\a\\r\")\n", "<p><a href=\"%5Cf%5Co%5Co%3E%5C\">test</a></p>\n<p><a href=\"foo\" title=\"\\&quot;\\b\\a\\r\">test</a></p>\n", "commonmark_extras.txt"},
+
+	// 5
+	// Not a closing tag
+	{"\n</ 123>\n", "<p>&lt;/ 123&gt;</p>\n", "commonmark_extras.txt"},
+
+	// 6
+	// Escaping entities in links:
+	{"\n[](<&quot;> \"&amp;&ouml;\")\n\n[](<\\&quot;> \"\\&amp;\\&ouml;\")\n\n[](<\\\\&quot;> \"\\\\&quot;\\\\&ouml;\")\n", "<p><a href=\"%22\" title=\"&amp;ö\"></a></p>\n<p><a href=\"&amp;quot;\" title=\"&amp;amp;&amp;ouml;\"></a></p>\n<p><a href=\"%5C%22\" title=\"\\&quot;\\ö\"></a></p>\n", "commonmark_extras.txt"},
+
+	// 7
+	// Checking combination of replaceEntities and unescapeMd:
+	{"\n~~~ &amp;&bad;\\&amp;\\\\&amp;\njust a funny little fence\n~~~\n", "<pre><code class=\"&amp;&amp;bad;&amp;amp;\\&amp;\">just a funny little fence\n</code></pre>\n", "commonmark_extras.txt"},
+
+	// 8
+	// Underscore between punctuation chars should be able to close emphasis.
+	{"\n_(hai)_.\n", "<p><em>(hai)</em>.</p>\n", "commonmark_extras.txt"},
+
+	// 9
+	// Those are two separate blockquotes:
+	{"\n - > foo\n  > bar\n", "<ul>\n<li>\n<blockquote>\n<p>foo</p>\n</blockquote>\n</li>\n</ul>\n<blockquote>\n<p>bar</p>\n</blockquote>\n", "commonmark_extras.txt"},
+
+	// 10
+	// Blockquote should terminate itself after paragraph continuation
+	{"\n- list\n    > blockquote\nblockquote continuation\n    - next list item\n", "<ul>\n<li>list\n<blockquote>\n<p>blockquote\nblockquote continuation</p>\n</blockquote>\n<ul>\n<li>next list item</li>\n</ul>\n</li>\n</ul>\n", "commonmark_extras.txt"},
+
+	// 11
+	// Regression test (code block + regular paragraph)
+	{"\n>     foo\n> bar\n", "<blockquote>\n<pre><code>foo\n</code></pre>\n<p>bar</p>\n</blockquote>\n", "commonmark_extras.txt"},
+
+	// 12
+	// Blockquotes inside indented lists should terminate correctly
+	{"\n   - a\n     > b\n     ```\n     c\n     ```\n   - d\n", "<ul>\n<li>a\n<blockquote>\n<p>b</p>\n</blockquote>\n<pre><code>c\n</code></pre>\n</li>\n<li>d</li>\n</ul>\n", "commonmark_extras.txt"},
+
+	// 13
+	// Don't output empty class here:
+	{"\n```&#x20;\ntest\n```\n", "<pre><code>test\n</code></pre>\n", "commonmark_extras.txt"},
+
+	// 14
+	// Setext header text supports lazy continuations:
+	{"\n - foo\nbar\n   ===\n", "<ul>\n<li>\n<h1>foo\nbar</h1>\n</li>\n</ul>\n", "commonmark_extras.txt"},
+
+	// 15
+	// But setext header underline doesn't:
+	{"\n - foo\n   bar\n  ===\n", "<ul>\n<li>foo\nbar\n===</li>\n</ul>\n", "commonmark_extras.txt"},
+
+	// 16
+	// Info string in fenced code block can't contain marker used for the fence
+	{"\n~~~test~\n\n~~~test`\n", "<p>~~~test~</p>\n<pre><code class=\"test`\"></code></pre>\n", "commonmark_extras.txt"},
+
+	// 17
+	// Tabs should be stripped from the beginning of the line
+	{"\n foo\n bar\n\tbaz\n", "<p>foo\nbar\nbaz</p>\n", "commonmark_extras.txt"},
+
+	// 18
+	// Tabs should not cause hardbreak, EOL tabs aren't stripped in commonmark 0.27
+	{"\nfoo1\t\nfoo2    \nbar\n", "<p>foo1\t\nfoo2<br>\nbar</p>\n", "commonmark_extras.txt"},
+
+	// 19
+	// List item terminating quote should not be paragraph continuation
+	{"\n1. foo\n   > quote\n2. bar\n", "<ol>\n<li>foo\n<blockquote>\n<p>quote</p>\n</blockquote>\n</li>\n<li>bar</li>\n</ol>\n", "commonmark_extras.txt"},
+
+	// 20
+	// Coverage. Directive can terminate paragraph.
+	{"\na\n<?php\n", "<p>a</p>\n<?php\n", "commonmark_extras.txt"},
+
+	// 21
+	// Coverage. Nested email autolink (silent mode)
+	{"\n*<foo@bar.com>*\n", "<p><em><a href=\"mailto:foo@bar.com\">foo@bar.com</a></em></p>\n", "commonmark_extras.txt"},
+
+	// 22
+	// Coverage. Unpaired nested backtick (silent mode)
+	{"\n*`foo*\n", "<p><em>`foo</em></p>\n", "commonmark_extras.txt"},
+
+	// 23
+	// Coverage. Entities.
+	{"\n*&*\n\n*&#x20;*\n\n*&amp;*\n", "<p><em>&amp;</em></p>\n<p><em> </em></p>\n<p><em>&amp;</em></p>\n", "commonmark_extras.txt"},
+
+	// 24
+	// Coverage. Escape.
+	{"\n*\\a*\n", "<p><em>\\a</em></p>\n", "commonmark_extras.txt"},
+
+	// 25
+	// Coverage. parseLinkDestination
+	{"\n[foo](<\nbar>)\n\n[foo](<bar)\n", "<p>[foo](&lt;\nbar&gt;)</p>\n<p>[foo](&lt;bar)</p>\n", "commonmark_extras.txt"},
+
+	// 26
+	// Coverage. parseLinkTitle
+	{"\n[foo](bar \"ba)\n\n[foo](bar \"ba\\\nz\")\n", "<p>[foo](bar &quot;ba)</p>\n<p><a href=\"bar\" title=\"ba\\\nz\">foo</a></p>\n", "commonmark_extras.txt"},
+
+	// 27
+	// Coverage. Image
+	{"\n![test]( x )\n", "<p><img src=\"x\" alt=\"test\"></p>\n", "commonmark_extras.txt"},
+
+	// 28
+	// Coverage. Image
+	{"![test][foo]\n\n[bar]: 123\n", "<p>![test][foo]</p>\n", "commonmark_extras.txt"},
+
+	// 29
+	// Coverage. Image
+	{"![test][[[\n\n[bar]: 123\n", "<p>![test][[[</p>\n", "commonmark_extras.txt"},
+
+	// 30
+	// Coverage. Image
+	{"![test](\n", "<p>![test](</p>\n", "commonmark_extras.txt"},
+
+	// 31
+	// Coverage. Link
+	{"\n[test](\n", "<p>[test](</p>\n", "commonmark_extras.txt"},
+
+	// 32
+	// Coverage. Reference
+	{"\n[\ntest\\\n]: 123\nfoo\nbar\n", "<p>foo\nbar</p>\n", "commonmark_extras.txt"},
+
+	// 33
+	// Coverage. Reference
+	{"[\ntest\n]\n", "<p>[\ntest\n]</p>\n", "commonmark_extras.txt"},
+
+	// 34
+	// Coverage. Reference
+	{"> [foo]: bar\n[foo]\n", "<blockquote>\n</blockquote>\n<p><a href=\"bar\">foo</a></p>\n", "commonmark_extras.txt"},
+
+	// 35
+	// Coverage. Tabs in blockquotes.
+	{"\n>\t\ttest\n\n >\t\ttest\n\n  >\t\ttest\n\n> ---\n>\t\ttest\n\n > ---\n >\t\ttest\n\n  > ---\n  >\t\ttest\n\n>\t\t\ttest\n\n >\t\t\ttest\n\n  >\t\t\ttest\n\n> ---\n>\t\t\ttest\n\n > ---\n >\t\t\ttest\n\n  > ---\n  >\t\t\ttest\n", "<blockquote>\n<pre><code>  test\n</code></pre>\n</blockquote>\n<blockquote>\n<pre><code> test\n</code></pre>\n</blockquote>\n<blockquote>\n<pre><code>test\n</code></pre>\n</blockquote>\n<blockquote>\n<hr>\n<pre><code>  test\n</code></pre>\n</blockquote>\n<blockquote>\n<hr>\n<pre><code> test\n</code></pre>\n</blockquote>\n<blockquote>\n<hr>\n<pre><code>test\n</code></pre>\n</blockquote>\n<blockquote>\n<pre><code>  \ttest\n</code></pre>\n</blockquote>\n<blockquote>\n<pre><code> \ttest\n</code></pre>\n</blockquote>\n<blockquote>\n<pre><code>\ttest\n</code></pre>\n</blockquote>\n<blockquote>\n<hr>\n<pre><code>  \ttest\n</code></pre>\n</blockquote>\n<blockquote>\n<hr>\n<pre><code> \ttest\n</code></pre>\n</blockquote>\n<blockquote>\n<hr>\n<pre><code>\ttest\n</code></pre>\n</blockquote>\n", "commonmark_extras.txt"},
+
+	// 36
+	// Coverage. Tabs in lists.
+	{"\n1. \tfoo\n\n\t     bar\n", "<ol>\n<li>\n<p>foo</p>\n<pre><code> bar\n</code></pre>\n</li>\n</ol>\n", "commonmark_extras.txt"},
+
+	// 37
+	// Coverage. Various tags not interrupting blockquotes because of indentation:
+	{"\n> foo\n    - - - -\n\n> foo\n    # not a heading\n\n> foo\n    ```\n    not a fence\n    ```\n", "<blockquote>\n<p>foo\n- - - -</p>\n</blockquote>\n<blockquote>\n<p>foo\n# not a heading</p>\n</blockquote>\n<blockquote>\n<p>foo\n<code>not a fence</code></p>\n</blockquote>\n", "commonmark_extras.txt"},
+
+	// 38
+	// Should not throw exception on invalid chars in URL (`*` not allowed in path) [mailformed URI]
+	{"[foo](<&#x25;test>)\n", "<p><a href=\"%25test\">foo</a></p>\n", "fatal.txt"},
+
+	// 39
+	// Should not throw exception on broken utf-8 sequence in URL [mailformed URI]
+	{"\n[foo](%C3)\n", "<p><a href=\"%C3\">foo</a></p>\n", "fatal.txt"},
+
+	// 40
+	// Should not throw exception on broken utf-16 surrogates sequence in URL [mailformed URI]
+	{"\n[foo](&#xD800;)\n", "<p><a href=\"&amp;#xD800;\">foo</a></p>\n", "fatal.txt"},
+
+	// 41
+	// Should not hang comments regexp
+	{"\nfoo <!--- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ->\n\nfoo <!------------------------------------------------------------------->\n", "<p>foo &lt;!— xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx -&gt;</p>\n<p>foo &lt;!-------------------------------------------------------------------&gt;</p>\n", "fatal.txt"},
+
+	// 42
+	// Should not hang cdata regexp
+	{"\nfoo <![CDATA[ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ]>\n", "<p>foo &lt;![CDATA[ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ]&gt;</p>\n", "fatal.txt"},
+
+	// 43
+	// linkify
+	{"url http://www.youtube.com/watch?v=5Jt5GEr4AYg.\n", "<p>url <a href=\"http://www.youtube.com/watch?v=5Jt5GEr4AYg\">http://www.youtube.com/watch?v=5Jt5GEr4AYg</a>.</p>\n", "linkify.txt"},
+
+	// 44
+	// don't touch text in links
+	{"\n[https://example.com](https://example.com)\n", "<p><a href=\"https://example.com\">https://example.com</a></p>\n", "linkify.txt"},
+
+	// 45
+	// don't touch text in autolinks
+	{"\n<https://example.com>\n", "<p><a href=\"https://example.com\">https://example.com</a></p>\n", "linkify.txt"},
+
+	// 46
+	// don't touch text in html <a> tags
+	{"\n<a href=\"https://example.com\">https://example.com</a>\n", "<p><a href=\"https://example.com\">https://example.com</a></p>\n", "linkify.txt"},
+
+	// 47
+	// match links without protocol
+	{"\nwww.example.org\n", "<p><a href=\"http://www.example.org\">www.example.org</a></p>\n", "linkify.txt"},
+
+	// 48
+	// emails
+	{"\ntest@example.com\n\nmailto:test@example.com\n", "<p><a href=\"mailto:test@example.com\">test@example.com</a></p>\n<p><a href=\"mailto:test@example.com\">mailto:test@example.com</a></p>\n", "linkify.txt"},
+
+	// 49
+	// typorgapher should not break href
+	{"\nhttp://example.com/(c)\n", "<p><a href=\"http://example.com/(c)\">http://example.com/(c)</a></p>\n", "linkify.txt"},
+
+	// 50
+	// Encode link destination, decode text inside it:
+	{"<http://example.com/α%CE%B2γ%CE%B4>\n", "<p><a href=\"http://example.com/%CE%B1%CE%B2%CE%B3%CE%B4\">http://example.com/αβγδ</a></p>\n", "normalize.txt"},
+
+	// 51
+	{"\n[foo](http://example.com/α%CE%B2γ%CE%B4)\n", "<p><a href=\"http://example.com/%CE%B1%CE%B2%CE%B3%CE%B4\">foo</a></p>\n", "normalize.txt"},
+
+	// 52
+	// Should decode punycode:
+	{"\n<http://xn--n3h.net/>\n", "<p><a href=\"http://xn--n3h.net/\">http://☃.net/</a></p>\n", "normalize.txt"},
+
+	// 53
+	{"\n<http://☃.net/>\n", "<p><a href=\"http://xn--n3h.net/\">http://☃.net/</a></p>\n", "normalize.txt"},
+
+	// 54
+	// Invalid punycode:
+	{"\n<http://xn--xn.com/>\n", "<p><a href=\"http://xn--xn.com/\">http://xn--xn.com/</a></p>\n", "normalize.txt"},
+
+	// 55
+	// Invalid punycode (non-ascii):
+	{"\n<http://xn--γ.com/>\n", "<p><a href=\"http://xn--xn---emd.com/\">http://xn--γ.com/</a></p>\n", "normalize.txt"},
+
+	// 56
+	// Two slashes should start a domain:
+	{"\n[](//☃.net/)\n", "<p><a href=\"//xn--n3h.net/\"></a></p>\n", "normalize.txt"},
+
+	// 57
+	// Don't encode domains in unknown schemas:
+	{"\n[](skype:γγγ)\n", "<p><a href=\"skype:%CE%B3%CE%B3%CE%B3\"></a></p>\n", "normalize.txt"},
+
+	// 58
+	// Should auto-add protocol to autolinks:
+	{"\ntest google.com foo\n", "<p>test <a href=\"http://google.com\">google.com</a> foo</p>\n", "normalize.txt"},
+
+	// 59
+	// Should support IDN in autolinks:
+	{"\ntest http://xn--n3h.net/ foo\n", "<p>test <a href=\"http://xn--n3h.net/\">http://☃.net/</a> foo</p>\n", "normalize.txt"},
+
+	// 60
+	{"\ntest http://☃.net/ foo\n", "<p>test <a href=\"http://xn--n3h.net/\">http://☃.net/</a> foo</p>\n", "normalize.txt"},
+
+	// 61
+	{"\ntest //xn--n3h.net/ foo\n", "<p>test <a href=\"//xn--n3h.net/\">//☃.net/</a> foo</p>\n", "normalize.txt"},
+
+	// 62
+	{"\ntest xn--n3h.net foo\n", "<p>test <a href=\"http://xn--n3h.net\">☃.net</a> foo</p>\n", "normalize.txt"},
+
+	// 63
+	{"\ntest xn--n3h@xn--n3h.net foo\n", "<p>test <a href=\"mailto:xn--n3h@xn--n3h.net\">xn--n3h@☃.net</a> foo</p>\n", "normalize.txt"},
+
+	// 64
+	{"[__proto__]\n\n[__proto__]: blah\n", "<p><a href=\"blah\"><strong>proto</strong></a></p>\n", "proto.txt"},
+
+	// 65
+	{"\n[hasOwnProperty]\n\n[hasOwnProperty]: blah\n", "<p><a href=\"blah\">hasOwnProperty</a></p>\n", "proto.txt"},
+
+	// 66
+	// Should parse nested quotes:
+	{"\"foo 'bar' baz\"\n\n'foo 'bar' baz'\n", "<p>“foo ‘bar’ baz”</p>\n<p>‘foo ‘bar’ baz’</p>\n", "smartquotes.txt"},
+
+	// 67
+	// Should not overlap quotes:
+	{"\n'foo \"bar' baz\"\n", "<p>‘foo &quot;bar’ baz&quot;</p>\n", "smartquotes.txt"},
+
+	// 68
+	// Should match quotes on the same level:
+	{"\n\"foo *bar* baz\"\n", "<p>“foo <em>bar</em> baz”</p>\n", "smartquotes.txt"},
+
+	// 69
+	// Should handle adjacent nested quotes:
+	{"\n'\"double in single\"'\n\n\"'single in double'\"\n", "<p>‘“double in single”’</p>\n<p>“‘single in double’”</p>\n", "smartquotes.txt"},
+
+	// 70
+	// Should not match quotes on different levels:
+	{"\n*\"foo* bar\"\n\n\"foo *bar\"*\n\n*\"foo* bar *baz\"*\n", "<p><em>&quot;foo</em> bar&quot;</p>\n<p>&quot;foo <em>bar&quot;</em></p>\n<p><em>&quot;foo</em> bar <em>baz&quot;</em></p>\n", "smartquotes.txt"},
+
+	// 71
+	// Smartquotes should not overlap with other tags:
+	{"\n*foo \"bar* *baz\" quux*\n", "<p><em>foo &quot;bar</em> <em>baz&quot; quux</em></p>\n", "smartquotes.txt"},
+
+	// 72
+	// Should try and find matching quote in this case:
+	{"\n\"foo \"bar 'baz\"\n", "<p>&quot;foo “bar 'baz”</p>\n", "smartquotes.txt"},
+
+	// 73
+	// Should not touch 'inches' in quotes:
+	{"\n\"Monitor 21\"\" and \"Monitor\"\"\n", "<p>“Monitor 21&quot;” and “Monitor”&quot;</p>\n", "smartquotes.txt"},
+
+	// 74
+	// Should render an apostrophe as a rsquo:
+	{"\nThis isn't and can't be the best approach to implement this...\n", "<p>This isn’t and can’t be the best approach to implement this…</p>\n", "smartquotes.txt"},
+
+	// 75
+	// Apostrophe could end the word, that's why original smartypants replaces all of them as rsquo:
+	{"\nusers' stuff\n", "<p>users’ stuff</p>\n", "smartquotes.txt"},
+
+	// 76
+	// Quotes between punctuation chars:
+	{"\n\"(hai)\".\n", "<p>“(hai)”.</p>\n", "smartquotes.txt"},
+
+	// 77
+	// Quotes at the start/end of the tokens:
+	{"\n\"*foo* bar\"\n\n\"foo *bar*\"\n\n\"*foo bar*\"\n", "<p>“<em>foo</em> bar”</p>\n<p>“foo <em>bar</em>”</p>\n<p>“<em>foo bar</em>”</p>\n", "smartquotes.txt"},
+
+	// 78
+	// Should treat softbreak as a space:
+	{"\n\"this\"\nand \"that\".\n\n\"this\" and\n\"that\".\n", "<p>“this”\nand “that”.</p>\n<p>“this” and\n“that”.</p>\n", "smartquotes.txt"},
+
+	// 79
+	// Should treat hardbreak as a space:
+	{"\n\"this\"\\\nand \"that\".\n\n\"this\" and\\\n\"that\".\n", "<p>“this”<br>\nand “that”.</p>\n<p>“this” and<br>\n“that”.</p>\n", "smartquotes.txt"},
+
+	// 80
+	{"~~Strikeout~~\n", "<p><s>Strikeout</s></p>\n", "strikethrough.txt"},
+
+	// 81
+	{"\nx ~~~~foo~~ bar~~\n", "<p>x <s><s>foo</s> bar</s></p>\n", "strikethrough.txt"},
+
+	// 82
+	{"\nx ~~foo ~~bar~~~~\n", "<p>x <s>foo <s>bar</s></s></p>\n", "strikethrough.txt"},
+
+	// 83
+	{"\nx ~~~~foo~~~~\n", "<p>x <s><s>foo</s></s></p>\n", "strikethrough.txt"},
+
+	// 84
+	{"\nx ~~a ~~foo~~~~~~~~~~~bar~~ b~~\n\nx ~~a ~~foo~~~~~~~~~~~~bar~~ b~~\n", "<p>x <s>a <s>foo</s></s>~~~<s><s>bar</s> b</s></p>\n<p>x <s>a <s>foo</s></s>~~~~<s><s>bar</s> b</s></p>\n", "strikethrough.txt"},
+
+	// 85
+	// Strikeouts have the same priority as emphases:
+	{"\n**~~test**~~\n\n~~**test~~**\n", "<p><strong>~~test</strong>~~</p>\n<p><s>**test</s>**</p>\n", "strikethrough.txt"},
+
+	// 86
+	// Strikeouts have the same priority as emphases with respect to links:
+	{"\n[~~link]()~~\n\n~~[link~~]()\n", "<p><a href=\"\">~~link</a>~~</p>\n<p>~~<a href=\"\">link~~</a></p>\n", "strikethrough.txt"},
+
+	// 87
+	// Strikeouts have the same priority as emphases with respect to backticks:
+	{"\n~~`code~~`\n\n`~~code`~~\n", "<p>~~<code>code~~</code></p>\n<p><code>~~code</code>~~</p>\n", "strikethrough.txt"},
+
+	// 88
+	// Nested strikeouts:
+	{"\n~~foo ~~bar~~ baz~~\n\n~~f **o ~~o b~~ a** r~~\n", "<p><s>foo <s>bar</s> baz</s></p>\n<p><s>f <strong>o <s>o b</s> a</strong> r</s></p>\n", "strikethrough.txt"},
+
+	// 89
+	// Should not have a whitespace between text and "~~":
+	{"\nfoo ~~ bar ~~ baz\n", "<p>foo ~~ bar ~~ baz</p>\n", "strikethrough.txt"},
+
+	// 90
+	// Newline should be considered a whitespace:
+	{"\n~~test\n~~\n\n~~\ntest~~\n\n~~\ntest\n~~\n", "<p>~~test\n~~</p>\n<p>~~\ntest~~</p>\n<p>~~\ntest\n~~</p>\n", "strikethrough.txt"},
+
+	// 91
+	// From CommonMark test suite, replacing `**` with our marker:
+	{"\na~~\"foo\"~~\n", "<p>a~~“foo”~~</p>\n", "strikethrough.txt"},
+
+	// 92
+	// Simple:
+	{"| Heading 1 | Heading 2\n| --------- | ---------\n| Cell 1    | Cell 2\n| Cell 3    | Cell 4\n", "<table>\n<thead>\n<tr>\n<th>Heading 1</th>\n<th>Heading 2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Cell 1</td>\n<td>Cell 2</td>\n</tr>\n<tr>\n<td>Cell 3</td>\n<td>Cell 4</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 93
+	// Column alignment:
+	{"\n| Header 1 | Header 2 | Header 3 | Header 4 |\n| :------: | -------: | :------- | -------- |\n| Cell 1   | Cell 2   | Cell 3   | Cell 4   |\n| Cell 5   | Cell 6   | Cell 7   | Cell 8   |\n", "<table>\n<thead>\n<tr>\n<th style=\"text-align:center\">Header 1</th>\n<th style=\"text-align:right\">Header 2</th>\n<th style=\"text-align:left\">Header 3</th>\n<th>Header 4</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align:center\">Cell 1</td>\n<td style=\"text-align:right\">Cell 2</td>\n<td style=\"text-align:left\">Cell 3</td>\n<td>Cell 4</td>\n</tr>\n<tr>\n<td style=\"text-align:center\">Cell 5</td>\n<td style=\"text-align:right\">Cell 6</td>\n<td style=\"text-align:left\">Cell 7</td>\n<td>Cell 8</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 94
+	// Nested emphases:
+	{"\nHeader 1|Header 2|Header 3|Header 4\n:-------|:------:|-------:|--------\nCell 1  |Cell 2  |Cell 3  |Cell 4\n*Cell 5*|Cell 6  |Cell 7  |Cell 8\n", "<table>\n<thead>\n<tr>\n<th style=\"text-align:left\">Header 1</th>\n<th style=\"text-align:center\">Header 2</th>\n<th style=\"text-align:right\">Header 3</th>\n<th>Header 4</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align:left\">Cell 1</td>\n<td style=\"text-align:center\">Cell 2</td>\n<td style=\"text-align:right\">Cell 3</td>\n<td>Cell 4</td>\n</tr>\n<tr>\n<td style=\"text-align:left\"><em>Cell 5</em></td>\n<td style=\"text-align:center\">Cell 6</td>\n<td style=\"text-align:right\">Cell 7</td>\n<td>Cell 8</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 95
+	// Nested tables inside blockquotes:
+	{"\n> foo|foo\n> ---|---\n> bar|bar\nbaz|baz\n", "<blockquote>\n<table>\n<thead>\n<tr>\n<th>foo</th>\n<th>foo</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>bar</td>\n<td>bar</td>\n</tr>\n</tbody>\n</table>\n</blockquote>\n<p>baz|baz</p>\n", "tables.txt"},
+
+	// 96
+	// Minimal one-column:
+	{"\n| foo\n|----\n| test2\n", "<table>\n<thead>\n<tr>\n<th>foo</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>test2</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 97
+	// This is parsed as one big table:
+	{"\n-   foo|foo\n---|---\nbar|bar\n", "<table>\n<thead>\n<tr>\n<th>-   foo</th>\n<th>foo</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>bar</td>\n<td>bar</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 98
+	// Second line should not contain symbols except "-", ":", "|" and " ":
+	{"\nfoo|foo\n---|---s\nbar|bar\n", "<p>foo|foo\n—|—s\nbar|bar</p>\n", "tables.txt"},
+
+	// 99
+	// Second line should contain "|" symbol:
+	{"\nfoo|foo\n---:---\nbar|bar\n", "<p>foo|foo\n—:—\nbar|bar</p>\n", "tables.txt"},
+
+	// 100
+	// Second line should not have empty columns in the middle:
+	{"\nfoo|foo\n---||---\nbar|bar\n", "<p>foo|foo\n—||—\nbar|bar</p>\n", "tables.txt"},
+
+	// 101
+	// Wrong alignment symbol position:
+	{"\nfoo|foo\n---|-::-\nbar|bar\n", "<p>foo|foo\n—|-::-\nbar|bar</p>\n", "tables.txt"},
+
+	// 102
+	// Title line should contain "|" symbol:
+	{"\nfoo\n---|---\nbar|bar\n", "<p>foo\n—|—\nbar|bar</p>\n", "tables.txt"},
+
+	// 103
+	// Allow tabs as a separator on 2nd line
+	{"\n|\tfoo\t|\tbar\t|\n|\t---\t|\t---\t|\n|\tbaz\t|\tquux\t|\n", "<table>\n<thead>\n<tr>\n<th>foo</th>\n<th>bar</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>baz</td>\n<td>quux</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 104
+	// Should terminate paragraph:
+	{"\nparagraph\nfoo|foo\n---|---\nbar|bar\n", "<p>paragraph</p>\n<table>\n<thead>\n<tr>\n<th>foo</th>\n<th>foo</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>bar</td>\n<td>bar</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 105
+	// Should be terminated via row without "|" symbol:
+	{"\nfoo|foo\n---|---\nparagraph\n", "<table>\n<thead>\n<tr>\n<th>foo</th>\n<th>foo</th>\n</tr>\n</thead>\n<tbody></tbody>\n</table>\n<p>paragraph</p>\n", "tables.txt"},
+
+	// 106
+	// Delimiter escaping:
+	{"\n| Heading 1 \\\\\\\\| Heading 2\n| --------- | ---------\n| Cell\\|1\\|| Cell\\|2\n\\| Cell\\\\\\|3 \\\\| Cell\\|4\n", "<table>\n<thead>\n<tr>\n<th>Heading 1 \\\\</th>\n<th>Heading 2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Cell|1|</td>\n<td>Cell|2</td>\n</tr>\n<tr>\n<td>| Cell\\|3 \\</td>\n<td>Cell|4</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 107
+	// Pipes inside backticks don't split cells:
+	{"\n| Heading 1 | Heading 2\n| --------- | ---------\n| Cell 1 | Cell 2\n| `Cell|3` | Cell 4\n", "<table>\n<thead>\n<tr>\n<th>Heading 1</th>\n<th>Heading 2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Cell 1</td>\n<td>Cell 2</td>\n</tr>\n<tr>\n<td><code>Cell|3</code></td>\n<td>Cell 4</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 108
+	// Unclosed backticks don't count
+	{"\n| Heading 1 | Heading 2\n| --------- | ---------\n| Cell 1 | Cell 2\n| `Cell 3| Cell 4\n", "<table>\n<thead>\n<tr>\n<th>Heading 1</th>\n<th>Heading 2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Cell 1</td>\n<td>Cell 2</td>\n</tr>\n<tr>\n<td>`Cell 3</td>\n<td>Cell 4</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 109
+	// Another complicated backticks case
+	{"\n| Heading 1 | Heading 2\n| --------- | ---------\n| Cell 1 | Cell 2\n| \\\\\\`|\\\\\\`\n", "<table>\n<thead>\n<tr>\n<th>Heading 1</th>\n<th>Heading 2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Cell 1</td>\n<td>Cell 2</td>\n</tr>\n<tr>\n<td>\\`</td>\n<td>\\`</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 110
+	// `\` in tables should not count as escaped backtick
+	{"\n# | 1 | 2\n--|--|--\nx | `\\` | `x`\n", "<table>\n<thead>\n<tr>\n<th>#</th>\n<th>1</th>\n<th>2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>x</td>\n<td><code>\\</code></td>\n<td><code>x</code></td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 111
+	// Tables should handle escaped backticks
+	{"\n# | 1 | 2\n--|--|--\nx | \\`\\` | `x`\n", "<table>\n<thead>\n<tr>\n<th>#</th>\n<th>1</th>\n<th>2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>x</td>\n<td>``</td>\n<td><code>x</code></td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 112
+	// An amount of rows might be different across the table (issue #171):
+	{"\n| 1 | 2 |\n| :-----: |  :-----: |  :-----: |\n| 3 | 4 | 5 | 6 |\n", "<table>\n<thead>\n<tr>\n<th style=\"text-align:center\">1</th>\n<th style=\"text-align:center\">2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align:center\">3</td>\n<td style=\"text-align:center\">4</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 113
+	// An amount of rows might be different across the table #2:
+	{"\n| 1 | 2 | 3 | 4 |\n| :-----: |  :-----: |  :-----: |  :-----: |\n| 5 | 6 |\n", "<table>\n<thead>\n<tr>\n<th style=\"text-align:center\">1</th>\n<th style=\"text-align:center\">2</th>\n<th style=\"text-align:center\">3</th>\n<th style=\"text-align:center\">4</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align:center\">5</td>\n<td style=\"text-align:center\">6</td>\n<td style=\"text-align:center\"></td>\n<td style=\"text-align:center\"></td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 114
+	// Allow one-column tables (issue #171):
+	{"\n| foo |\n:-----:\n| bar |\n", "<table>\n<thead>\n<tr>\n<th style=\"text-align:center\">foo</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align:center\">bar</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 115
+	// Allow indented tables (issue #325):
+	{"\n  | Col1a | Col2a |\n  | ----- | ----- |\n  | Col1b | Col2b |\n", "<table>\n<thead>\n<tr>\n<th>Col1a</th>\n<th>Col2a</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Col1b</td>\n<td>Col2b</td>\n</tr>\n</tbody>\n</table>\n", "tables.txt"},
+
+	// 116
+	// Tables should not be indented more than 4 spaces (1st line):
+	{"\n    | Col1a | Col2a |\n  | ----- | ----- |\n  | Col1b | Col2b |\n", "<pre><code>| Col1a | Col2a |\n</code></pre>\n<p>| ----- | ----- |\n| Col1b | Col2b |</p>\n", "tables.txt"},
+
+	// 117
+	// Tables should not be indented more than 4 spaces (2nd line):
+	{"\n  | Col1a | Col2a |\n    | ----- | ----- |\n  | Col1b | Col2b |\n", "<p>| Col1a | Col2a |\n| ----- | ----- |\n| Col1b | Col2b |</p>\n", "tables.txt"},
+
+	// 118
+	// Tables should not be indented more than 4 spaces (3rd line):
+	{"\n  | Col1a | Col2a |\n  | ----- | ----- |\n    | Col1b | Col2b |\n", "<table>\n<thead>\n<tr>\n<th>Col1a</th>\n<th>Col2a</th>\n</tr>\n</thead>\n<tbody></tbody>\n</table>\n<pre><code>| Col1b | Col2b |\n</code></pre>\n", "tables.txt"},
+
+	// 119
+	// Allow tables with empty body:
+	{"\n  | Col1a | Col2a |\n  | ----- | ----- |\n", "<table>\n<thead>\n<tr>\n<th>Col1a</th>\n<th>Col2a</th>\n</tr>\n</thead>\n<tbody></tbody>\n</table>\n", "tables.txt"},
+
+	// 120
+	// Align row should be at least as large as any actual rows:
+	{"\nCol1a | Col1b | Col1c\n----- | -----\nCol2a | Col2b | Col2c\n", "<p>Col1a | Col1b | Col1c\n----- | -----\nCol2a | Col2b | Col2c</p>\n", "tables.txt"},
+
+	// 121
+	{"(bad)\n", "<p>(bad)</p>\n", "typographer.txt"},
+
+	// 122
+	// copyright
+	{"\n(c) (C)\n", "<p>© ©</p>\n", "typographer.txt"},
+
+	// 123
+	// reserved
+	{"\n(r) (R)\n", "<p>® ®</p>\n", "typographer.txt"},
+
+	// 124
+	// trademark
+	{"\n(tm) (TM)\n", "<p>™ ™</p>\n", "typographer.txt"},
+
+	// 125
+	// paragraph
+	{"\n(p) (P)\n", "<p>§ §</p>\n", "typographer.txt"},
+
+	// 126
+	// plus-minus
+	{"\n+-5\n", "<p>±5</p>\n", "typographer.txt"},
+
+	// 127
+	// ellipsis
+	{"\ntest.. test... test..... test?..... test!....\n", "<p>test… test… test… test?.. test!..</p>\n", "typographer.txt"},
+
+	// 128
+	// dupes
+	{"\n!!!!!! ???? ,,\n", "<p>!!! ??? ,</p>\n", "typographer.txt"},
+
+	// 129
+	// dashes
+	{"\n---markdownit --- super---\n\nmarkdownit---awesome\n\nabc ----\n\n--markdownit -- super--\n\nmarkdownit--awesome\n", "<p>—markdownit — super—</p>\n<p>markdownit—awesome</p>\n<p>abc ----</p>\n<p>–markdownit – super–</p>\n<p>markdownit–awesome</p>\n", "typographer.txt"},
+
+	// 130
+	{"[normal link](javascript)\n", "<p><a href=\"javascript\">normal link</a></p>\n", "xss.txt"},
+
+	// 131
+	// Should not allow some protocols in links and images
+	{"\n[xss link](javascript:alert(1))\n\n[xss link](JAVASCRIPT:alert(1))\n\n[xss link](vbscript:alert(1))\n\n[xss link](VBSCRIPT:alert(1))\n\n[xss link](file:///123)\n", "<p>[xss link](javascript:alert(1))</p>\n<p>[xss link](JAVASCRIPT:alert(1))</p>\n<p>[xss link](vbscript:alert(1))</p>\n<p>[xss link](VBSCRIPT:alert(1))</p>\n<p>[xss link](file:///123)</p>\n", "xss.txt"},
+
+	// 132
+	{"\n[xss link](&#34;&#62;&#60;script&#62;alert&#40;&#34;xss&#34;&#41;&#60;/script&#62;)\n\n[xss link](&#74;avascript:alert(1))\n\n[xss link](&#x26;#74;avascript:alert(1))\n\n[xss link](\\&#74;avascript:alert(1))\n", "<p><a href=\"%22%3E%3Cscript%3Ealert(%22xss%22)%3C/script%3E\">xss link</a></p>\n<p>[xss link](Javascript:alert(1))</p>\n<p><a href=\"&amp;#74;avascript:alert(1)\">xss link</a></p>\n<p><a href=\"&amp;#74;avascript:alert(1)\">xss link</a></p>\n", "xss.txt"},
+
+	// 133
+	{"\n[xss link](<javascript:alert(1)>)\n", "<p>[xss link](&lt;javascript:alert(1)&gt;)</p>\n", "xss.txt"},
+
+	// 134
+	{"\n[xss link](javascript&#x3A;alert(1))\n", "<p>[xss link](javascript:alert(1))</p>\n", "xss.txt"},
+
+	// 135
+	// Should not allow data-uri except some whitelisted mimes
+	{"\n![](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)\n", "<p><img src=\"data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7\" alt=\"\"></p>\n", "xss.txt"},
+
+	// 136
+	{"\n[xss link](data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K)\n", "<p>[xss link](data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K)</p>\n", "xss.txt"},
+
+	// 137
+	{"\n[normal link](/javascript:link)\n", "<p><a href=\"/javascript:link\">normal link</a></p>\n", "xss.txt"},
+
+	// 138
+	// Image parser use the same code base as link.
+	{"\n![xss link](javascript:alert(1))\n", "<p>![xss link](javascript:alert(1))</p>\n", "xss.txt"},
+
+	// 139
+	// Autolinks
+	{"\n<javascript&#x3A;alert(1)>\n\n<javascript:alert(1)>\n", "<p>&lt;javascript:alert(1)&gt;</p>\n<p>&lt;javascript:alert(1)&gt;</p>\n", "xss.txt"},
+
+	// 140
+	// Linkifier
+	{"\njavascript&#x3A;alert(1)\n\njavascript:alert(1)\n", "<p>javascript:alert(1)</p>\n<p>javascript:alert(1)</p>\n", "xss.txt"},
+
+	// 141
+	// References
+	{"\n[test]: javascript:alert(1)\n", "<p>[test]: javascript:alert(1)</p>\n", "xss.txt"},
+
+	// 142
+	// Make sure we decode entities before split:
+	{"\n```js&#32;custom-class\ntest1\n```\n\n```js&#x0C;custom-class\ntest2\n```\n", "<pre><code class=\"js\">test1\n</code></pre>\n<pre><code class=\"js\">test2\n</code></pre>\n", "xss.txt"},
+}
+
+func TestMarkdownIt(t *testing.T) {
+	for i, test := range mditTests {
+		switch i {
+		case 35: // XXX opennota: investigate
+			continue
+		}
+
+		test := test
+		t.Run(fmt.Sprintf("test #%d", i), func(t *testing.T) {
+			t.Parallel()
+			md := New(HTML(true), LangPrefix(""))
+			got := md.RenderToString([]byte(test.markdown))
+			if got != test.want {
+				t.Errorf("#%d: markdown(%q)\nwant %q\n got %q", i, test.markdown, test.want, got)
+			}
+		})
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/markdown_test.go b/vendor/gitlab.com/golang-commonmark/markdown/markdown_test.go
new file mode 100644
index 000000000..ec2710e26
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/markdown_test.go
@@ -0,0 +1,93 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"gitlab.com/opennota/wd"
+)
+
+type example struct {
+	Filename string
+	Num      int `json:"example"`
+	Markdown string
+	HTML     string
+	Section  string
+}
+
+func loadExamplesFromJSON(fn string) []example {
+	f, err := os.Open(fn)
+	if err != nil {
+		panic(err)
+	}
+
+	var examples []example
+	err = json.NewDecoder(f).Decode(&examples)
+	if err != nil {
+		panic(err)
+	}
+
+	return examples
+}
+
+func render(src string, options ...option) (_ string, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("%v", r)
+		}
+	}()
+	md := New(options...)
+	return md.RenderToString([]byte(src)), nil
+}
+
+func TestCommonMark(t *testing.T) {
+	examples := loadExamplesFromJSON("spec/commonmark-0.28.json")
+	for _, ex := range examples {
+		ex := ex
+		t.Run(fmt.Sprintf("example #%d (%s)", ex.Num, ex.Section), func(t *testing.T) {
+			result, err := render(ex.Markdown, HTML(true), XHTMLOutput(true), Linkify(false), Typographer(false), LangPrefix("language-"))
+			if err != nil {
+				t.Errorf("#%d (%s): PANIC (%v)", ex.Num, ex.Section, err)
+			} else if result != ex.HTML {
+				d := wd.ColouredDiff(ex.HTML, result, false)
+				d = wd.NumberLines(d)
+				t.Errorf("#%d (%s):\n%s", ex.Num, ex.Section, d)
+			}
+		})
+	}
+}
+
+func TestRenderSpec(t *testing.T) {
+	data, err := ioutil.ReadFile("spec/spec-0.28.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	md := New(HTML(true), XHTMLOutput(true))
+	md.RenderToString(data)
+}
+
+func TestFrenchQuoteMarks(t *testing.T) {
+	md := New(Quotes([]string{"« ", " »", "‹ ", " ›"}))
+	got := md.RenderToString([]byte(`"Son 'explication' n'est qu'un mensonge", s'indigna le député.`))
+	want := "<p>« Son ‹ explication › n’est qu’un mensonge », s’indigna le député.</p>\n"
+	if got != want {
+		t.Errorf("want %q, got %q", want, got)
+	}
+}
+
+func TestMultibyteCharAtTheEnd(t *testing.T) {
+	md := New()
+	got := md.RenderToString([]byte("“Test”\nTest\n“Test”"))
+	want := "<p>“Test”\nTest\n“Test”</p>\n"
+	if got != want {
+		t.Errorf("want %q, got %q", want, got)
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/newline.go b/vendor/gitlab.com/golang-commonmark/markdown/newline.go
new file mode 100644
index 000000000..c69fa3d9f
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/newline.go
@@ -0,0 +1,46 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+func ruleNewline(s *StateInline, silent bool) bool {
+	pos := s.Pos
+	src := s.Src
+
+	if src[pos] != '\n' {
+		return false
+	}
+
+	pending := s.Pending.Bytes()
+	pmax := len(pending) - 1
+	max := s.PosMax
+
+	if !silent {
+		if pmax >= 0 && pending[pmax] == ' ' {
+			if pmax >= 1 && pending[pmax-1] == ' ' {
+				pmax -= 2
+				for pmax >= 0 && pending[pmax] == ' ' {
+					pmax--
+				}
+				s.Pending.Truncate(pmax + 1)
+				s.PushToken(&Hardbreak{})
+			} else {
+				s.Pending.Truncate(pmax)
+				s.PushToken(&Softbreak{})
+			}
+		} else {
+			s.PushToken(&Softbreak{})
+		}
+	}
+
+	pos++
+
+	for pos < max && byteIsSpace(src[pos]) {
+		pos++
+	}
+
+	s.Pos = pos
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/options.go b/vendor/gitlab.com/golang-commonmark/markdown/options.go
new file mode 100644
index 000000000..7e5b2cf37
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/options.go
@@ -0,0 +1,77 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+type option func(m *Markdown)
+
+func HTML(b bool) option {
+	return func(m *Markdown) {
+		m.HTML = b
+	}
+}
+
+func Linkify(b bool) option {
+	return func(m *Markdown) {
+		m.Linkify = b
+	}
+}
+
+func Typographer(b bool) option {
+	return func(m *Markdown) {
+		m.Typographer = b
+	}
+}
+
+func Quotes(stringOrArray interface{}) option {
+	if s, ok := stringOrArray.(string); ok {
+		return func(m *Markdown) {
+			for i, r := range []rune(s) {
+				m.Quotes[i] = string(r)
+			}
+		}
+	}
+	a := stringOrArray.([]string)
+	return func(m *Markdown) {
+		for i, s := range a {
+			m.Quotes[i] = s
+		}
+	}
+}
+
+func MaxNesting(n int) option {
+	return func(m *Markdown) {
+		m.MaxNesting = n
+	}
+}
+
+func XHTMLOutput(b bool) option {
+	return func(m *Markdown) {
+		m.renderOptions.XHTML = b
+	}
+}
+
+func Breaks(b bool) option {
+	return func(m *Markdown) {
+		m.renderOptions.Breaks = b
+	}
+}
+
+func LangPrefix(p string) option {
+	return func(m *Markdown) {
+		m.renderOptions.LangPrefix = p
+	}
+}
+
+func Nofollow(b bool) option {
+	return func(m *Markdown) {
+		m.renderOptions.Nofollow = b
+	}
+}
+
+func Tables(b bool) option {
+	return func(m *Markdown) {
+		m.Tables = b
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/options_test.go b/vendor/gitlab.com/golang-commonmark/markdown/options_test.go
new file mode 100644
index 000000000..4d7192abb
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/options_test.go
@@ -0,0 +1,18 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestQuote(t *testing.T) {
+	quotes := "‘’“”"
+	md := New(Quotes(quotes))
+	if strings.Join(md.Quotes[:], "") != quotes {
+		t.Errorf("expected %q, got %q", quotes, md.Quotes)
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/paragraph.go b/vendor/gitlab.com/golang-commonmark/markdown/paragraph.go
new file mode 100644
index 000000000..a3003ef6e
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/paragraph.go
@@ -0,0 +1,51 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "strings"
+
+var paragraphTerminatedBy []BlockRule
+
+func ruleParagraph(s *StateBlock, startLine, _ int, _ bool) bool {
+	nextLine := startLine + 1
+	endLine := s.LineMax
+
+	oldParentType := s.ParentType
+	s.ParentType = ptParagraph
+
+outer:
+	for ; nextLine < endLine && !s.IsLineEmpty(nextLine); nextLine++ {
+		if s.SCount[nextLine]-s.BlkIndent > 3 {
+			continue
+		}
+
+		if s.SCount[nextLine] < 0 {
+			continue
+		}
+
+		for _, r := range paragraphTerminatedBy {
+			if r(s, nextLine, endLine, true) {
+				break outer
+			}
+		}
+	}
+
+	content := strings.TrimSpace(s.Lines(startLine, nextLine, s.BlkIndent, false))
+
+	s.Line = nextLine
+
+	s.PushOpeningToken(&ParagraphOpen{
+		Map: [2]int{startLine, s.Line},
+	})
+	s.PushToken(&Inline{
+		Content: content,
+		Map:     [2]int{startLine, s.Line},
+	})
+	s.PushClosingToken(&ParagraphClose{})
+
+	s.ParentType = oldParentType
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/parser_block.go b/vendor/gitlab.com/golang-commonmark/markdown/parser_block.go
new file mode 100644
index 000000000..8a6ee1ad4
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/parser_block.go
@@ -0,0 +1,159 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"bytes"
+	"unicode/utf8"
+)
+
+type ParserBlock struct{}
+
+type BlockRule func(*StateBlock, int, int, bool) bool
+
+var blockRules []BlockRule
+
+var nl = []byte{'\n'}
+
+func normalizeNewlines(src []byte) ([]byte, int) {
+	if bytes.IndexByte(src, '\r') == -1 {
+		return src, bytes.Count(src, nl)
+	}
+	n := 0
+	buf := make([]byte, 0, len(src))
+	for i := 0; i < len(src); i++ {
+		switch ch := src[i]; ch {
+		case '\n':
+			n++
+			buf = append(buf, '\n')
+		case '\r':
+			buf = append(buf, '\n')
+			n++
+			if i < len(src)-1 && src[i+1] == '\n' {
+				i++
+			}
+		default:
+			buf = append(buf, ch)
+		}
+	}
+	return buf, n
+}
+
+func (b ParserBlock) Parse(src []byte, md *Markdown, env *Environment) []Token {
+	src, n := normalizeNewlines(src)
+	if len(src) == 0 || src[len(src)-1] != '\n' {
+		n++
+	}
+	n++
+
+	indentFound := false
+	start := 0
+	indent := 0
+	offset := 0
+
+	mem := make([]int, 0, n*5)
+	bMarks := mem[0:0:n]
+	eMarks := mem[n : n : n*2]
+	tShift := mem[n*2 : n*2 : n*3]
+	sCount := mem[n*3 : n*3 : n*4]
+	bsCount := mem[n*4 : n*4 : n*5]
+
+	_, lastRuneLen := utf8.DecodeLastRune(src)
+	lastRunePos := len(src) - lastRuneLen
+	for pos, r := range string(src) {
+		if !indentFound {
+			if runeIsSpace(r) {
+				indent++
+				if r == '\t' {
+					offset += 4 - offset%4
+				} else {
+					offset++
+				}
+				continue
+			}
+			indentFound = true
+		}
+
+		if r == '\n' || pos == lastRunePos {
+			if r != '\n' {
+				pos = len(src)
+			}
+			bMarks = append(bMarks, start)
+			eMarks = append(eMarks, pos)
+			tShift = append(tShift, indent)
+			sCount = append(sCount, offset)
+			bsCount = append(bsCount, 0)
+
+			indentFound = false
+			indent = 0
+			offset = 0
+			start = pos + 1
+		}
+	}
+
+	bMarks = append(bMarks, len(src))
+	eMarks = append(eMarks, len(src))
+	tShift = append(tShift, 0)
+	sCount = append(sCount, 0)
+	bsCount = append(bsCount, 0)
+
+	var s StateBlock
+	s.BMarks = bMarks
+	s.EMarks = eMarks
+	s.TShift = tShift
+	s.SCount = sCount
+	s.BSCount = bsCount
+	s.LineMax = n - 1
+	s.Src = string(src)
+	s.Md = md
+	s.Env = env
+
+	b.Tokenize(&s, s.Line, s.LineMax)
+
+	return s.Tokens
+}
+
+func (ParserBlock) Tokenize(s *StateBlock, startLine, endLine int) {
+	line := startLine
+	hasEmptyLines := false
+	maxNesting := s.Md.MaxNesting
+
+	for line < endLine {
+		line = s.SkipEmptyLines(line)
+		s.Line = line
+		if line >= endLine {
+			break
+		}
+
+		if s.SCount[line] < s.BlkIndent {
+			break
+		}
+
+		if s.Level >= maxNesting {
+			s.Line = endLine
+			break
+		}
+
+		for _, r := range blockRules {
+			if r(s, line, endLine, false) {
+				break
+			}
+		}
+
+		s.Tight = !hasEmptyLines
+
+		if s.IsLineEmpty(s.Line - 1) {
+			hasEmptyLines = true
+		}
+
+		line = s.Line
+
+		if line < endLine && s.IsLineEmpty(line) {
+			hasEmptyLines = true
+			line++
+			s.Line = line
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/parser_inline.go b/vendor/gitlab.com/golang-commonmark/markdown/parser_inline.go
new file mode 100644
index 000000000..5e976ebd9
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/parser_inline.go
@@ -0,0 +1,106 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "unicode/utf8"
+
+type ParserInline struct {
+}
+
+type (
+	InlineRule      func(*StateInline, bool) bool
+	PostprocessRule func(*StateInline)
+)
+
+var (
+	inlineRules      []InlineRule
+	postprocessRules []PostprocessRule
+)
+
+func (i ParserInline) Parse(src string, md *Markdown, env *Environment) []Token {
+	if src == "" {
+		return nil
+	}
+
+	var s StateInline
+	s.Src = src
+	s.Md = md
+	s.Env = env
+	s.PosMax = len(src)
+	s.Tokens = s.bootstrap[:0]
+
+	i.Tokenize(&s)
+
+	for _, r := range postprocessRules {
+		r(&s)
+	}
+
+	return s.Tokens
+}
+
+func (ParserInline) Tokenize(s *StateInline) {
+	end := s.PosMax
+	src := s.Src
+	maxNesting := s.Md.MaxNesting
+	ok := false
+
+	for s.Pos < end {
+		if s.Level < maxNesting {
+			for _, rule := range inlineRules {
+				ok = rule(s, false)
+				if ok {
+					break
+				}
+			}
+		}
+
+		if ok {
+			if s.Pos >= end {
+				break
+			}
+			continue
+		}
+
+		r, size := utf8.DecodeRuneInString(src[s.Pos:])
+		s.Pending.WriteRune(r)
+		s.Pos += size
+	}
+
+	if s.Pending.Len() > 0 {
+		s.PushPending()
+	}
+}
+
+func (ParserInline) SkipToken(s *StateInline) {
+	pos := s.Pos
+	if s.Cache != nil {
+		if newPos, ok := s.Cache[pos]; ok {
+			s.Pos = newPos
+			return
+		}
+	} else {
+		s.Cache = make(map[int]int)
+	}
+
+	ok := false
+	if s.Level < s.Md.MaxNesting {
+		for _, r := range inlineRules {
+			s.Level++
+			ok = r(s, true)
+			s.Level--
+			if ok {
+				break
+			}
+		}
+	} else {
+		s.Pos = s.PosMax
+	}
+
+	if !ok {
+		_, size := utf8.DecodeRuneInString(s.Src[s.Pos:])
+		s.Pos += size
+	}
+	s.Cache[pos] = s.Pos
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/plugins.go b/vendor/gitlab.com/golang-commonmark/markdown/plugins.go
new file mode 100644
index 000000000..5ba818cda
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/plugins.go
@@ -0,0 +1,158 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "sort"
+
+type registeredCoreRule struct {
+	id   int
+	rule CoreRule
+}
+
+var registeredCoreRules []registeredCoreRule
+
+type registeredBlockRule struct {
+	id         int
+	rule       BlockRule
+	terminates []int
+}
+
+var registeredBlockRules []registeredBlockRule
+
+type registeredInlineRule struct {
+	id   int
+	rule InlineRule
+}
+
+var registeredInlineRules []registeredInlineRule
+
+type registeredPostprocessRule struct {
+	id   int
+	rule PostprocessRule
+}
+
+var registeredPostprocessRules []registeredPostprocessRule
+
+func indexInt(a []int, n int) int {
+	for i, m := range a {
+		if m == n {
+			return i
+		}
+	}
+	return -1
+}
+
+func RegisterCoreRule(id int, rule CoreRule) {
+	registeredCoreRules = append(registeredCoreRules, registeredCoreRule{
+		id:   id,
+		rule: rule,
+	})
+	sort.Slice(registeredCoreRules, func(i, j int) bool {
+		return registeredCoreRules[i].id < registeredCoreRules[j].id
+	})
+
+	coreRules = coreRules[:0]
+	for _, r := range registeredCoreRules {
+		coreRules = append(coreRules, r.rule)
+	}
+}
+
+func RegisterBlockRule(id int, rule BlockRule, terminates []int) {
+	registeredBlockRules = append(registeredBlockRules, registeredBlockRule{
+		id:         id,
+		rule:       rule,
+		terminates: terminates,
+	})
+	sort.Slice(registeredBlockRules, func(i, j int) bool {
+		return registeredBlockRules[i].id < registeredBlockRules[j].id
+	})
+
+	blockRules = blockRules[:0]
+	blockquoteTerminatedBy = blockquoteTerminatedBy[:0]
+	listTerminatedBy = listTerminatedBy[:0]
+	referenceTerminatedBy = referenceTerminatedBy[:0]
+	paragraphTerminatedBy = paragraphTerminatedBy[:0]
+	for _, r := range registeredBlockRules {
+		blockRules = append(blockRules, r.rule)
+		if indexInt(r.terminates, 400) != -1 {
+			blockquoteTerminatedBy = append(blockquoteTerminatedBy, r.rule)
+		}
+		if indexInt(r.terminates, 600) != -1 {
+			listTerminatedBy = append(listTerminatedBy, r.rule)
+		}
+		if indexInt(r.terminates, 700) != -1 {
+			referenceTerminatedBy = append(referenceTerminatedBy, r.rule)
+		}
+		if indexInt(r.terminates, 1100) != -1 {
+			paragraphTerminatedBy = append(paragraphTerminatedBy, r.rule)
+		}
+	}
+}
+
+func RegisterInlineRule(id int, rule InlineRule) {
+	registeredInlineRules = append(registeredInlineRules, registeredInlineRule{
+		id:   id,
+		rule: rule,
+	})
+	sort.Slice(registeredInlineRules, func(i, j int) bool {
+		return registeredInlineRules[i].id < registeredInlineRules[j].id
+	})
+
+	inlineRules = inlineRules[:0]
+	for _, r := range registeredInlineRules {
+		inlineRules = append(inlineRules, r.rule)
+	}
+}
+
+func RegisterPostprocessRule(id int, rule PostprocessRule) {
+	registeredPostprocessRules = append(registeredPostprocessRules, registeredPostprocessRule{
+		id:   id,
+		rule: rule,
+	})
+	sort.Slice(registeredPostprocessRules, func(i, j int) bool {
+		return registeredPostprocessRules[i].id < registeredPostprocessRules[j].id
+	})
+
+	postprocessRules = postprocessRules[:0]
+	for _, r := range registeredPostprocessRules {
+		postprocessRules = append(postprocessRules, r.rule)
+	}
+}
+
+func init() {
+	RegisterCoreRule(100, ruleInline)
+	RegisterCoreRule(200, ruleLinkify)
+	RegisterCoreRule(300, ruleReplacements)
+	RegisterCoreRule(400, ruleSmartQuotes)
+
+	RegisterBlockRule(100, ruleTable, []int{1100, 700})
+	RegisterBlockRule(200, ruleCode, nil)
+	RegisterBlockRule(300, ruleFence, []int{1100, 700, 400, 600})
+	RegisterBlockRule(400, ruleBlockQuote, []int{1100, 700, 400, 600})
+	RegisterBlockRule(500, ruleHR, []int{1100, 700, 400, 600})
+	RegisterBlockRule(600, ruleList, []int{1100, 700, 400})
+	RegisterBlockRule(700, ruleReference, nil)
+	RegisterBlockRule(800, ruleHeading, []int{1100, 700, 400})
+	RegisterBlockRule(900, ruleLHeading, nil)
+	RegisterBlockRule(1000, ruleHTMLBlock, []int{1100, 700, 400})
+	RegisterBlockRule(1100, ruleParagraph, nil)
+
+	RegisterInlineRule(100, ruleText)
+	RegisterInlineRule(200, ruleNewline)
+	RegisterInlineRule(300, ruleEscape)
+	RegisterInlineRule(400, ruleBackticks)
+	RegisterInlineRule(500, ruleStrikeThrough)
+	RegisterInlineRule(600, ruleEmphasis)
+	RegisterInlineRule(700, ruleLink)
+	RegisterInlineRule(800, ruleImage)
+	RegisterInlineRule(900, ruleAutolink)
+	RegisterInlineRule(1000, ruleHTMLInline)
+	RegisterInlineRule(1100, ruleEntity)
+
+	RegisterPostprocessRule(100, ruleBalancePairs)
+	RegisterPostprocessRule(200, ruleStrikethroughPostprocess)
+	RegisterPostprocessRule(300, ruleEmphasisPostprocess)
+	RegisterPostprocessRule(400, ruleTextCollapse)
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/reference.go b/vendor/gitlab.com/golang-commonmark/markdown/reference.go
new file mode 100644
index 000000000..6e97809e9
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/reference.go
@@ -0,0 +1,173 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "strings"
+
+var referenceTerminatedBy []BlockRule
+
+func ruleReference(s *StateBlock, startLine, _ int, silent bool) bool {
+	lines := 0
+	pos := s.BMarks[startLine] + s.TShift[startLine]
+	max := s.EMarks[startLine]
+	nextLine := startLine + 1
+
+	if s.SCount[startLine]-s.BlkIndent >= 4 {
+		return false
+	}
+
+	src := s.Src
+
+	if src[pos] != '[' {
+		return false
+	}
+
+	pos++
+	for pos < max {
+		if src[pos] == ']' && src[pos-1] != '\\' {
+			if pos+1 == max {
+				return false
+			}
+			if src[pos+1] != ':' {
+				return false
+			}
+			break
+		}
+		pos++
+	}
+
+	endLine := s.LineMax
+
+	oldParentType := s.ParentType
+	s.ParentType = ptReference
+outer:
+	for ; nextLine < endLine && !s.IsLineEmpty(nextLine); nextLine++ {
+		if s.SCount[nextLine]-s.BlkIndent > 3 {
+			continue
+		}
+
+		if s.SCount[nextLine] < 0 {
+			continue
+		}
+
+		for _, r := range referenceTerminatedBy {
+			if r(s, nextLine, endLine, true) {
+				break outer
+			}
+		}
+	}
+
+	str := strings.TrimSpace(s.Lines(startLine, nextLine, s.BlkIndent, false))
+	max = len(str)
+
+	var labelEnd int
+	for pos = 1; pos < max; pos++ {
+		b := str[pos]
+		if b == '[' {
+			return false
+		} else if b == ']' {
+			labelEnd = pos
+			break
+		} else if b == '\n' {
+			lines++
+		} else if b == '\\' {
+			pos++
+			if pos < max && str[pos] == '\n' {
+				lines++
+			}
+		}
+	}
+
+	if labelEnd <= 0 || labelEnd+1 >= max || str[labelEnd+1] != ':' {
+		return false
+	}
+
+	for pos = labelEnd + 2; pos < max; pos++ {
+		b := str[pos]
+		if b == '\n' {
+			lines++
+		} else if !byteIsSpace(b) {
+			break
+		}
+	}
+
+	href, nlines, endpos, ok := parseLinkDestination(str, pos, max)
+	if !ok {
+		return false
+	}
+	href = normalizeLink(href)
+	if !validateLink(href) {
+		return false
+	}
+
+	pos = endpos
+	lines += nlines
+
+	destEndPos := pos
+	destEndLineNo := lines
+
+	start := pos
+	for ; pos < max; pos++ {
+		b := str[pos]
+		if b == '\n' {
+			lines++
+		} else if !byteIsSpace(b) {
+			break
+		}
+	}
+
+	title, nlines, endpos, ok := parseLinkTitle(str, pos, max)
+	if pos < max && start != pos && ok {
+		pos = endpos
+		lines += nlines
+	} else {
+		pos = destEndPos
+		lines = destEndLineNo
+	}
+
+	for pos < max && byteIsSpace(str[pos]) {
+		pos++
+	}
+
+	if pos < max && str[pos] != '\n' {
+		if title != "" {
+			title = ""
+			pos = destEndPos
+			lines = destEndLineNo
+			for pos < max && byteIsSpace(src[pos]) {
+				pos++
+			}
+		}
+	}
+
+	if pos < max && str[pos] != '\n' {
+		return false
+	}
+
+	label := normalizeReference(str[1:labelEnd])
+	if label == "" {
+		return false
+	}
+
+	if silent {
+		return true
+	}
+
+	if s.Env.References == nil {
+		s.Env.References = make(map[string]map[string]string)
+	}
+	if _, ok := s.Env.References[label]; !ok {
+		s.Env.References[label] = map[string]string{
+			"title": title,
+			"href":  href,
+		}
+	}
+
+	s.ParentType = oldParentType
+
+	s.Line = startLine + lines + 1
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/render.go b/vendor/gitlab.com/golang-commonmark/markdown/render.go
new file mode 100644
index 000000000..3955f051c
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/render.go
@@ -0,0 +1,333 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"io"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"gitlab.com/golang-commonmark/html"
+)
+
+type Renderer struct {
+	w *monadicWriter
+}
+
+func NewRenderer(w io.Writer) *Renderer {
+	return &Renderer{newMonadicWriter(w)}
+}
+
+func (r *Renderer) Render(tokens []Token, options RenderOptions) error {
+	for i, tok := range tokens {
+		if tok, ok := tok.(*Inline); ok {
+			r.renderInline(tok.Children, options)
+		} else {
+			r.renderToken(tokens, i, options)
+		}
+	}
+
+	r.w.Flush()
+
+	return r.w.err
+}
+
+func (r *Renderer) renderInline(tokens []Token, o RenderOptions) {
+	for i := range tokens {
+		r.renderToken(tokens, i, o)
+	}
+}
+
+func (r *Renderer) renderInlineAsText(tokens []Token) {
+	for _, tok := range tokens {
+		if text, ok := tok.(*Text); ok {
+			html.WriteEscapedString(r.w, text.Content)
+		} else if img, ok := tok.(*Image); ok {
+			r.renderInlineAsText(img.Tokens)
+		}
+	}
+}
+
+var rNotSpace = regexp.MustCompile(`^\S+`)
+
+func (r *Renderer) renderToken(tokens []Token, idx int, options RenderOptions) {
+	tok := tokens[idx]
+
+	if idx > 0 && tok.Block() && !tok.Closing() {
+		switch t := tokens[idx-1].(type) {
+		case *ParagraphOpen:
+			if t.Hidden {
+				r.w.WriteByte('\n')
+			}
+		case *ParagraphClose:
+			if t.Hidden {
+				r.w.WriteByte('\n')
+			}
+		}
+	}
+
+	switch tok := tok.(type) {
+	case *BlockquoteClose:
+		r.w.WriteString("</blockquote>")
+
+	case *BlockquoteOpen:
+		r.w.WriteString("<blockquote>")
+
+	case *BulletListClose:
+		r.w.WriteString("</ul>")
+
+	case *BulletListOpen:
+		r.w.WriteString("<ul>")
+
+	case *CodeBlock:
+		r.w.WriteString("<pre><code>")
+		html.WriteEscapedString(r.w, tok.Content)
+		r.w.WriteString("</code></pre>")
+
+	case *CodeInline:
+		r.w.WriteString("<code>")
+		html.WriteEscapedString(r.w, tok.Content)
+		r.w.WriteString("</code>")
+
+	case *EmphasisClose:
+		r.w.WriteString("</em>")
+
+	case *EmphasisOpen:
+		r.w.WriteString("<em>")
+
+	case *Fence:
+		r.w.WriteString("<pre><code")
+		if tok.Params != "" {
+			langName := strings.SplitN(unescapeAll(tok.Params), " ", 2)[0]
+			langName = rNotSpace.FindString(langName)
+			if langName != "" {
+				r.w.WriteString(` class="`)
+				r.w.WriteString(options.LangPrefix)
+				html.WriteEscapedString(r.w, langName)
+				r.w.WriteByte('"')
+			}
+		}
+		r.w.WriteByte('>')
+		html.WriteEscapedString(r.w, tok.Content)
+		r.w.WriteString("</code></pre>")
+
+	case *Hardbreak:
+		if options.XHTML {
+			r.w.WriteString("<br />\n")
+		} else {
+			r.w.WriteString("<br>\n")
+		}
+
+	case *HeadingClose:
+		r.w.WriteString("</h")
+		r.w.WriteByte("0123456789"[tok.HLevel])
+		r.w.WriteString(">")
+
+	case *HeadingOpen:
+		r.w.WriteString("<h")
+		r.w.WriteByte("0123456789"[tok.HLevel])
+		r.w.WriteByte('>')
+
+	case *Hr:
+		if options.XHTML {
+			r.w.WriteString("<hr />")
+		} else {
+			r.w.WriteString("<hr>")
+		}
+
+	case *HTMLBlock:
+		r.w.WriteString(tok.Content)
+		return // no newline
+
+	case *HTMLInline:
+		r.w.WriteString(tok.Content)
+
+	case *Image:
+		r.w.WriteString(`<img src="`)
+		html.WriteEscapedString(r.w, tok.Src)
+		r.w.WriteString(`" alt="`)
+		r.renderInlineAsText(tok.Tokens)
+		r.w.WriteByte('"')
+
+		if tok.Title != "" {
+			r.w.WriteString(` title="`)
+			html.WriteEscapedString(r.w, tok.Title)
+			r.w.WriteByte('"')
+		}
+		if options.XHTML {
+			r.w.WriteString(" />")
+		} else {
+			r.w.WriteByte('>')
+		}
+
+	case *LinkClose:
+		r.w.WriteString("</a>")
+
+	case *LinkOpen:
+		r.w.WriteString(`<a href="`)
+		html.WriteEscapedString(r.w, tok.Href)
+		r.w.WriteByte('"')
+		if tok.Title != "" {
+			r.w.WriteString(` title="`)
+			html.WriteEscapedString(r.w, (tok.Title))
+			r.w.WriteByte('"')
+		}
+		if tok.Target != "" {
+			r.w.WriteString(` target="`)
+			html.WriteEscapedString(r.w, tok.Target)
+			r.w.WriteByte('"')
+		}
+		if options.Nofollow {
+			r.w.WriteString(` rel="nofollow"`)
+		}
+		r.w.WriteByte('>')
+
+	case *ListItemClose:
+		r.w.WriteString("</li>")
+
+	case *ListItemOpen:
+		r.w.WriteString("<li>")
+
+	case *OrderedListClose:
+		r.w.WriteString("</ol>")
+
+	case *OrderedListOpen:
+		if tok.Order != 1 {
+			r.w.WriteString(`<ol start="`)
+			r.w.WriteString(strconv.Itoa(tok.Order))
+			r.w.WriteString(`">`)
+		} else {
+			r.w.WriteString("<ol>")
+		}
+
+	case *ParagraphClose:
+		if tok.Hidden {
+			return
+		}
+		if !tok.Tight {
+			r.w.WriteString("</p>")
+		} else if tokens[idx+1].Closing() {
+			return // no newline
+		}
+
+	case *ParagraphOpen:
+		if tok.Hidden {
+			return
+		}
+		if !tok.Tight {
+			r.w.WriteString("<p>")
+		}
+
+	case *Softbreak:
+		if options.Breaks {
+			if options.XHTML {
+				r.w.WriteString("<br />\n")
+			} else {
+				r.w.WriteString("<br>\n")
+			}
+		} else {
+			r.w.WriteByte('\n')
+		}
+		return
+
+	case *StrongClose:
+		r.w.WriteString("</strong>")
+
+	case *StrongOpen:
+		r.w.WriteString("<strong>")
+
+	case *StrikethroughClose:
+		r.w.WriteString("</s>")
+
+	case *StrikethroughOpen:
+		r.w.WriteString("<s>")
+
+	case *TableClose:
+		r.w.WriteString("</table>")
+
+	case *TableOpen:
+		r.w.WriteString("<table>")
+
+	case *TbodyClose:
+		r.w.WriteString("</tbody>")
+
+	case *TbodyOpen:
+		r.w.WriteString("<tbody>")
+
+	case *TdClose:
+		r.w.WriteString("</td>")
+
+	case *TdOpen:
+		if tok.Align != AlignNone {
+			r.w.WriteString(`<td style="text-align:`)
+			r.w.WriteString(tok.Align.String())
+			r.w.WriteString(`">`)
+		} else {
+			r.w.WriteString("<td>")
+		}
+
+	case *Text:
+		html.WriteEscapedString(r.w, tok.Content)
+
+	case *TheadClose:
+		r.w.WriteString("</thead>")
+
+	case *TheadOpen:
+		r.w.WriteString("<thead>")
+
+	case *ThClose:
+		r.w.WriteString("</th>")
+
+	case *ThOpen:
+		if align := tok.Align; align != AlignNone {
+			r.w.WriteString(`<th style="text-align:`)
+			r.w.WriteString(align.String())
+			r.w.WriteString(`">`)
+		} else {
+			r.w.WriteString("<th>")
+		}
+
+	case *TrClose:
+		r.w.WriteString("</tr>")
+
+	case *TrOpen:
+		r.w.WriteString("<tr>")
+
+	default:
+		panic("unknown token type")
+	}
+
+	needLf := false
+	if tok.Block() {
+		needLf = true
+
+		if tok.Opening() {
+			nextTok := tokens[idx+1]
+			blockquote := false
+			switch nextTok := nextTok.(type) {
+			case *Inline:
+				needLf = false
+			case *ParagraphOpen:
+				if nextTok.Tight || nextTok.Hidden {
+					needLf = false
+				}
+			case *ParagraphClose:
+				if nextTok.Tight || nextTok.Hidden {
+					needLf = false
+				}
+			case *BlockquoteClose:
+				blockquote = true
+			}
+			if !blockquote && needLf && nextTok.Closing() && nextTok.Tag() == tok.Tag() {
+				needLf = false
+			}
+		}
+	}
+
+	if needLf {
+		r.w.WriteByte('\n')
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/replacements.go b/vendor/gitlab.com/golang-commonmark/markdown/replacements.go
new file mode 100644
index 000000000..8d67af6ee
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/replacements.go
@@ -0,0 +1,229 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "strings"
+
+func exclquest(b byte) bool {
+	return b == '!' || b == '?'
+}
+
+func byteToLower(b byte) byte {
+	if b >= 'A' && b <= 'Z' {
+		return b - 'A' + 'a'
+	}
+	return b
+}
+
+var replChar = [256]bool{
+	'(': true,
+	'!': true,
+	'+': true,
+	',': true,
+	'-': true,
+	'.': true,
+	'?': true,
+}
+
+func performReplacements(s string) string {
+	var ss []string
+
+	start := 0
+	for i := 0; i < len(s); i++ {
+		b := s[i]
+
+		if replChar[b] {
+
+		outer:
+			switch b {
+			case '(':
+				if i+2 >= len(s) {
+					break
+				}
+
+				b2 := s[i+1]
+
+				b2 = byteToLower(b2)
+				switch b2 {
+				case 'c', 'r', 'p':
+					if s[i+2] != ')' {
+						break outer
+					}
+					switch b2 {
+					case 'c':
+						if start < i {
+							ss = append(ss, s[start:i])
+						}
+						ss = append(ss, "©")
+					case 'r':
+						if start < i {
+							ss = append(ss, s[start:i])
+						}
+						ss = append(ss, "®")
+					case 'p':
+						if start < i {
+							ss = append(ss, s[start:i])
+						}
+						ss = append(ss, "§")
+					}
+					i += 2
+					start = i + 1
+					continue
+
+				case 't':
+					if i+3 >= len(s) {
+						break outer
+					}
+					if s[i+3] != ')' || byteToLower(s[i+2]) != 'm' {
+						break outer
+					}
+					if start < i {
+						ss = append(ss, s[start:i])
+					}
+					ss = append(ss, "™")
+					i += 3
+					start = i + 1
+					continue
+				default:
+					break outer
+				}
+
+			case '+':
+				if i+1 >= len(s) || s[i+1] != '-' {
+					break
+				}
+				if start < i {
+					ss = append(ss, s[start:i])
+				}
+				ss = append(ss, "±")
+				i++
+				start = i + 1
+				continue
+
+			case '.':
+				if i+1 >= len(s) || s[i+1] != '.' {
+					break
+				}
+
+				j := i + 2
+				for j < len(s) && s[j] == '.' {
+					j++
+				}
+				if start < i {
+					ss = append(ss, s[start:i])
+				}
+				if i == 0 || !(s[i-1] == '?' || s[i-1] == '!') {
+					ss = append(ss, "…")
+				} else {
+					ss = append(ss, "..")
+				}
+				i = j - 1
+				start = i + 1
+				continue
+
+			case '?', '!':
+				if i+3 >= len(s) {
+					break
+				}
+				if !(exclquest(s[i+1]) && exclquest(s[i+2]) && exclquest(s[i+3])) {
+					break
+				}
+				if start < i {
+					ss = append(ss, s[start:i])
+				}
+				ss = append(ss, s[i:i+3])
+				j := i + 3
+				for j < len(s) && exclquest(s[j]) {
+					j++
+				}
+				i = j - 1
+				start = i + 1
+				continue
+
+			case ',':
+				if i+1 >= len(s) || s[i+1] != ',' {
+					break
+				}
+				if start < i {
+					ss = append(ss, s[start:i])
+				}
+				ss = append(ss, ",")
+				j := i + 2
+				for j < len(s) && s[j] == ',' {
+					j++
+				}
+				i = j - 1
+				start = i + 1
+				continue
+
+			case '-':
+				if i+1 >= len(s) || s[i+1] != '-' {
+					break
+				}
+				if i+2 >= len(s) || s[i+2] != '-' {
+					if start < i {
+						ss = append(ss, s[start:i])
+					}
+					ss = append(ss, "–")
+					i++
+					start = i + 1
+					continue
+				}
+				if i+3 >= len(s) || s[i+3] != '-' {
+					if start < i {
+						ss = append(ss, s[start:i])
+					}
+					ss = append(ss, "—")
+					i += 2
+					start = i + 1
+					continue
+				}
+
+				j := i + 3
+				for j < len(s) && s[j] == '-' {
+					j++
+				}
+				if start < i {
+					ss = append(ss, s[start:i])
+				}
+				ss = append(ss, s[i:j])
+				i = j - 1
+				start = i + 1
+				continue
+			}
+		}
+	}
+	if ss == nil {
+		return s
+	}
+	if start < len(s) {
+		ss = append(ss, s[start:])
+	}
+	return strings.Join(ss, "")
+}
+
+func ruleReplacements(s *StateCore) {
+	if !s.Md.Typographer {
+		return
+	}
+
+	insideLink := false
+	for _, tok := range s.Tokens {
+		if tok, ok := tok.(*Inline); ok {
+			for _, itok := range tok.Children {
+				switch itok := itok.(type) {
+				case *LinkOpen:
+					insideLink = true
+				case *LinkClose:
+					insideLink = false
+				case *Text:
+					if !insideLink {
+						itok.Content = performReplacements(itok.Content)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/replacements_test.go b/vendor/gitlab.com/golang-commonmark/markdown/replacements_test.go
new file mode 100644
index 000000000..615167619
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/replacements_test.go
@@ -0,0 +1,82 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "testing"
+
+func TestPerformReplacements(t *testing.T) {
+	type testCase struct {
+		in   string
+		want string
+	}
+	testCases := []testCase{
+		{"", ""},
+		{"(c)", "©"},
+		{"(r)", "®"},
+		{"(tm)", "™"},
+		{"(p)", "§"},
+		{"(C)", "©"},
+		{"(R)", "®"},
+		{"(TM)", "™"},
+		{"(P)", "§"},
+		{"+-", "±"},
+		{"..", "…"},
+		{"...", "…"},
+		{"....", "…"},
+		{"!..", "!.."},
+		{"?..", "?.."},
+		{"!...", "!.."},
+		{"?...", "?.."},
+		{",,", ","},
+		{",,,", ","},
+		{"--", "–"},
+		{"---", "—"},
+		{"----", "----"},
+		{"?!!!!!......", "?!!.."},
+		{" (c) ", " © "},
+		{" (r) ", " ® "},
+		{" (tm) ", " ™ "},
+		{" (p) ", " § "},
+		{" +- ", " ± "},
+		{" .. ", " … "},
+		{" ... ", " … "},
+		{" .... ", " … "},
+		{" !.. ", " !.. "},
+		{" ?.. ", " ?.. "},
+		{" !... ", " !.. "},
+		{" ?... ", " ?.. "},
+		{" ,, ", " , "},
+		{" ,,, ", " , "},
+		{" -- ", " – "},
+		{" --- ", " — "},
+		{" ---- ", " ---- "},
+		{"(", "("},
+		{"(c", "(c"},
+		{"(r", "(r"},
+		{"(p", "(p"},
+		{"(t", "(t"},
+		{"(tm", "(tm"},
+		{"(c]", "(c]"},
+		{"(r]", "(r]"},
+		{"(p]", "(p]"},
+		{"(tm]", "(tm]"},
+		{"+", "+"},
+		{"++", "++"},
+		{".", "."},
+		{".2", ".2"},
+		{",", ","},
+		{", ", ", "},
+		{"-", "-"},
+		{"- ", "- "},
+		{"(z)", "(z)"},
+		{"(c)(r)(tm)(p)..?!!!!!.....,,-- --- -- ----", "©®™§…?!!..,– — – ----"},
+	}
+	for _, tc := range testCases {
+		got := performReplacements(tc.in)
+		if got != tc.want {
+			t.Errorf("performReplacements(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/smartquotes.go b/vendor/gitlab.com/golang-commonmark/markdown/smartquotes.go
new file mode 100644
index 000000000..cbfa9c586
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/smartquotes.go
@@ -0,0 +1,256 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+func nextQuoteIndex(s []rune, from int) int {
+	for i := from; i < len(s); i++ {
+		r := s[i]
+		if r == '\'' || r == '"' {
+			return i
+		}
+	}
+	return -1
+}
+
+func firstRune(s string) rune {
+	for _, r := range s {
+		return r
+	}
+	return utf8.RuneError
+}
+
+func replaceQuotes(tokens []Token, s *StateCore) {
+	type stackItem struct {
+		token  int
+		text   []rune
+		pos    int
+		single bool
+		level  int
+	}
+	var stack []stackItem
+	var changed map[int][]rune
+
+	for i, tok := range tokens {
+		thisLevel := tok.Level()
+
+		j := len(stack) - 1
+		for j >= 0 {
+			if stack[j].level <= thisLevel {
+				break
+			}
+			j--
+		}
+		stack = stack[:j+1]
+
+		tok, ok := tok.(*Text)
+		if !ok || !strings.ContainsAny(tok.Content, `"'`) {
+			continue
+		}
+
+		text := []rune(tok.Content)
+		pos := 0
+		max := len(text)
+
+	loop:
+		for pos < max {
+			index := nextQuoteIndex(text, pos)
+			if index < 0 {
+				break
+			}
+
+			canOpen := true
+			canClose := true
+			pos = index + 1
+			isSingle := text[index] == '\''
+
+			lastChar := ' '
+			if index-1 > 0 {
+				lastChar = text[index-1]
+			} else {
+			loop1:
+				for j := i - 1; j >= 0; j-- {
+					switch tok := tokens[j].(type) {
+					case *Softbreak:
+						break loop1
+					case *Hardbreak:
+						break loop1
+					case *Text:
+						lastChar, _ = utf8.DecodeLastRuneInString(tok.Content)
+						break loop1
+					default:
+						continue
+					}
+				}
+			}
+
+			nextChar := ' '
+			if pos < max {
+				nextChar = text[pos]
+			} else {
+			loop2:
+				for j := i + 1; j < len(tokens); j++ {
+					switch tok := tokens[j].(type) {
+					case *Softbreak:
+						break loop2
+					case *Hardbreak:
+						break loop2
+					case *Text:
+						nextChar, _ = utf8.DecodeRuneInString(tok.Content)
+						break loop2
+					default:
+						continue
+					}
+				}
+			}
+
+			isLastPunct := isMdAsciiPunct(lastChar) || unicode.IsPunct(lastChar)
+			isNextPunct := isMdAsciiPunct(nextChar) || unicode.IsPunct(nextChar)
+			isLastWhiteSpace := unicode.IsSpace(lastChar)
+			isNextWhiteSpace := unicode.IsSpace(nextChar)
+
+			if isNextWhiteSpace {
+				canOpen = false
+			} else if isNextPunct {
+				if !(isLastWhiteSpace || isLastPunct) {
+					canOpen = false
+				}
+			}
+
+			if isLastWhiteSpace {
+				canClose = false
+			} else if isLastPunct {
+				if !(isNextWhiteSpace || isNextPunct) {
+					canClose = false
+				}
+			}
+
+			if nextChar == '"' && text[index] == '"' {
+				if lastChar >= '0' && lastChar <= '9' {
+					canClose = false
+					canOpen = false
+				}
+			}
+
+			if canOpen && canClose {
+				canOpen = false
+				canClose = isNextPunct
+			}
+
+			if !canOpen && !canClose {
+				if isSingle {
+					text[index] = '’'
+					if changed == nil {
+						changed = make(map[int][]rune)
+					}
+					changed[i] = text
+				}
+				continue
+			}
+
+			if canClose {
+				for j := len(stack) - 1; j >= 0; j-- {
+					item := stack[j]
+					if item.level < thisLevel {
+						break
+					}
+					if item.single == isSingle && item.level == thisLevel {
+						if changed == nil {
+							changed = make(map[int][]rune)
+						}
+
+						var q1, q2 string
+						if isSingle {
+							q1 = s.Md.options.Quotes[2]
+							q2 = s.Md.options.Quotes[3]
+						} else {
+							q1 = s.Md.options.Quotes[0]
+							q2 = s.Md.options.Quotes[1]
+						}
+
+						if utf8.RuneCountInString(q1) == 1 && utf8.RuneCountInString(q2) == 1 {
+							item.text[item.pos] = firstRune(q1)
+							text[index] = firstRune(q2)
+						} else if tok == tokens[item.token] {
+							newText := make([]rune, 0, len(text)-2+len(q1)+len(q2))
+							newText = append(newText, text[:item.pos]...)
+							newText = append(newText, []rune(q1)...)
+							newText = append(newText, text[item.pos+1:index]...)
+							newText = append(newText, []rune(q2)...)
+							newText = append(newText, text[index+1:]...)
+
+							text = newText
+							item.text = newText
+						} else {
+							newText := make([]rune, 0, len(item.text)-1+len(q1))
+							newText = append(newText, item.text[:item.pos]...)
+							newText = append(newText, []rune(q1)...)
+							newText = append(newText, item.text[item.pos+1:]...)
+							item.text = newText
+
+							newText = make([]rune, 0, len(text)-1+len(q2))
+							newText = append(newText, text[:index]...)
+							newText = append(newText, []rune(q2)...)
+							newText = append(newText, text[index+1:]...)
+
+							text = newText
+						}
+
+						max = len(text)
+
+						if changed == nil {
+							changed = make(map[int][]rune)
+						}
+						changed[i] = text
+						changed[item.token] = item.text
+						stack = stack[:j]
+						continue loop
+					}
+				}
+			}
+
+			if canOpen {
+				stack = append(stack, stackItem{
+					token:  i,
+					text:   text,
+					pos:    index,
+					single: isSingle,
+					level:  thisLevel,
+				})
+			} else if canClose && isSingle {
+				text[index] = '’'
+				if changed == nil {
+					changed = make(map[int][]rune)
+				}
+				changed[i] = text
+			}
+		}
+	}
+
+	if changed != nil {
+		for i, text := range changed {
+			tokens[i].(*Text).Content = string(text)
+		}
+	}
+}
+
+func ruleSmartQuotes(s *StateCore) {
+	if !s.Md.Typographer {
+		return
+	}
+
+	tokens := s.Tokens
+	for i := len(tokens) - 1; i >= 0; i-- {
+		tok := tokens[i]
+		if tok, ok := tok.(*Inline); ok {
+			replaceQuotes(tok.Children, s)
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/smartquotes_test.go b/vendor/gitlab.com/golang-commonmark/markdown/smartquotes_test.go
new file mode 100644
index 000000000..5e46cdcc1
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/smartquotes_test.go
@@ -0,0 +1,27 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "testing"
+
+func TestNextQuoteIndex(t *testing.T) {
+	type testCase struct {
+		in   string
+		from int
+		want int
+	}
+	testCases := []testCase{
+		{"", 0, -1},
+		{`"xxx"`, 0, 0},
+		{`"xxx"`, 1, 4},
+		{"'xxx'", 1, 4},
+	}
+	for _, tc := range testCases {
+		got := nextQuoteIndex([]rune(tc.in), tc.from)
+		if got != tc.want {
+			t.Errorf("nextQuoteIndex(%q, %d) = %d, want %d", tc.in, tc.from, got, tc.want)
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/spec/commonmark-0.28.json b/vendor/gitlab.com/golang-commonmark/markdown/spec/commonmark-0.28.json
new file mode 100644
index 000000000..9ab61d730
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/spec/commonmark-0.28.json
@@ -0,0 +1,4994 @@
+[
+  {
+    "end_line": 355,
+    "section": "Tabs",
+    "html": "<pre><code>foo\tbaz\t\tbim\n</code></pre>\n",
+    "markdown": "\tfoo\tbaz\t\tbim\n",
+    "example": 1,
+    "start_line": 350
+  },
+  {
+    "end_line": 362,
+    "section": "Tabs",
+    "html": "<pre><code>foo\tbaz\t\tbim\n</code></pre>\n",
+    "markdown": "  \tfoo\tbaz\t\tbim\n",
+    "example": 2,
+    "start_line": 357
+  },
+  {
+    "end_line": 371,
+    "section": "Tabs",
+    "html": "<pre><code>a\ta\nὐ\ta\n</code></pre>\n",
+    "markdown": "    a\ta\n    ὐ\ta\n",
+    "example": 3,
+    "start_line": 364
+  },
+  {
+    "end_line": 388,
+    "section": "Tabs",
+    "html": "<ul>\n<li>\n<p>foo</p>\n<p>bar</p>\n</li>\n</ul>\n",
+    "markdown": "  - foo\n\n\tbar\n",
+    "example": 4,
+    "start_line": 377
+  },
+  {
+    "end_line": 402,
+    "section": "Tabs",
+    "html": "<ul>\n<li>\n<p>foo</p>\n<pre><code>  bar\n</code></pre>\n</li>\n</ul>\n",
+    "markdown": "- foo\n\n\t\tbar\n",
+    "example": 5,
+    "start_line": 390
+  },
+  {
+    "end_line": 420,
+    "section": "Tabs",
+    "html": "<blockquote>\n<pre><code>  foo\n</code></pre>\n</blockquote>\n",
+    "markdown": ">\t\tfoo\n",
+    "example": 6,
+    "start_line": 413
+  },
+  {
+    "end_line": 431,
+    "section": "Tabs",
+    "html": "<ul>\n<li>\n<pre><code>  foo\n</code></pre>\n</li>\n</ul>\n",
+    "markdown": "-\t\tfoo\n",
+    "example": 7,
+    "start_line": 422
+  },
+  {
+    "end_line": 441,
+    "section": "Tabs",
+    "html": "<pre><code>foo\nbar\n</code></pre>\n",
+    "markdown": "    foo\n\tbar\n",
+    "example": 8,
+    "start_line": 434
+  },
+  {
+    "end_line": 459,
+    "section": "Tabs",
+    "html": "<ul>\n<li>foo\n<ul>\n<li>bar\n<ul>\n<li>baz</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n",
+    "markdown": " - foo\n   - bar\n\t - baz\n",
+    "example": 9,
+    "start_line": 443
+  },
+  {
+    "end_line": 465,
+    "section": "Tabs",
+    "html": "<h1>Foo</h1>\n",
+    "markdown": "#\tFoo\n",
+    "example": 10,
+    "start_line": 461
+  },
+  {
+    "end_line": 471,
+    "section": "Tabs",
+    "html": "<hr />\n",
+    "markdown": "*\t*\t*\t\n",
+    "example": 11,
+    "start_line": 467
+  },
+  {
+    "end_line": 502,
+    "section": "Precedence",
+    "html": "<ul>\n<li>`one</li>\n<li>two`</li>\n</ul>\n",
+    "markdown": "- `one\n- two`\n",
+    "example": 12,
+    "start_line": 494
+  },
+  {
+    "end_line": 541,
+    "section": "Thematic breaks",
+    "html": "<hr />\n<hr />\n<hr />\n",
+    "markdown": "***\n---\n___\n",
+    "example": 13,
+    "start_line": 533
+  },
+  {
+    "end_line": 550,
+    "section": "Thematic breaks",
+    "html": "<p>+++</p>\n",
+    "markdown": "+++\n",
+    "example": 14,
+    "start_line": 546
+  },
+  {
+    "end_line": 557,
+    "section": "Thematic breaks",
+    "html": "<p>===</p>\n",
+    "markdown": "===\n",
+    "example": 15,
+    "start_line": 553
+  },
+  {
+    "end_line": 570,
+    "section": "Thematic breaks",
+    "html": "<p>--\n**\n__</p>\n",
+    "markdown": "--\n**\n__\n",
+    "example": 16,
+    "start_line": 562
+  },
+  {
+    "end_line": 583,
+    "section": "Thematic breaks",
+    "html": "<hr />\n<hr />\n<hr />\n",
+    "markdown": " ***\n  ***\n   ***\n",
+    "example": 17,
+    "start_line": 575
+  },
+  {
+    "end_line": 593,
+    "section": "Thematic breaks",
+    "html": "<pre><code>***\n</code></pre>\n",
+    "markdown": "    ***\n",
+    "example": 18,
+    "start_line": 588
+  },
+  {
+    "end_line": 602,
+    "section": "Thematic breaks",
+    "html": "<p>Foo\n***</p>\n",
+    "markdown": "Foo\n    ***\n",
+    "example": 19,
+    "start_line": 596
+  },
+  {
+    "end_line": 611,
+    "section": "Thematic breaks",
+    "html": "<hr />\n",
+    "markdown": "_____________________________________\n",
+    "example": 20,
+    "start_line": 607
+  },
+  {
+    "end_line": 620,
+    "section": "Thematic breaks",
+    "html": "<hr />\n",
+    "markdown": " - - -\n",
+    "example": 21,
+    "start_line": 616
+  },
+  {
+    "end_line": 627,
+    "section": "Thematic breaks",
+    "html": "<hr />\n",
+    "markdown": " **  * ** * ** * **\n",
+    "example": 22,
+    "start_line": 623
+  },
+  {
+    "end_line": 634,
+    "section": "Thematic breaks",
+    "html": "<hr />\n",
+    "markdown": "-     -      -      -\n",
+    "example": 23,
+    "start_line": 630
+  },
+  {
+    "end_line": 643,
+    "section": "Thematic breaks",
+    "html": "<hr />\n",
+    "markdown": "- - - -    \n",
+    "example": 24,
+    "start_line": 639
+  },
+  {
+    "end_line": 658,
+    "section": "Thematic breaks",
+    "html": "<p>_ _ _ _ a</p>\n<p>a------</p>\n<p>---a---</p>\n",
+    "markdown": "_ _ _ _ a\n\na------\n\n---a---\n",
+    "example": 25,
+    "start_line": 648
+  },
+  {
+    "end_line": 668,
+    "section": "Thematic breaks",
+    "html": "<p><em>-</em></p>\n",
+    "markdown": " *-*\n",
+    "example": 26,
+    "start_line": 664
+  },
+  {
+    "end_line": 685,
+    "section": "Thematic breaks",
+    "html": "<ul>\n<li>foo</li>\n</ul>\n<hr />\n<ul>\n<li>bar</li>\n</ul>\n",
+    "markdown": "- foo\n***\n- bar\n",
+    "example": 27,
+    "start_line": 673
+  },
+  {
+    "end_line": 698,
+    "section": "Thematic breaks",
+    "html": "<p>Foo</p>\n<hr />\n<p>bar</p>\n",
+    "markdown": "Foo\n***\nbar\n",
+    "example": 28,
+    "start_line": 690
+  },
+  {
+    "end_line": 714,
+    "section": "Thematic breaks",
+    "html": "<h2>Foo</h2>\n<p>bar</p>\n",
+    "markdown": "Foo\n---\nbar\n",
+    "example": 29,
+    "start_line": 707
+  },
+  {
+    "end_line": 732,
+    "section": "Thematic breaks",
+    "html": "<ul>\n<li>Foo</li>\n</ul>\n<hr />\n<ul>\n<li>Bar</li>\n</ul>\n",
+    "markdown": "* Foo\n* * *\n* Bar\n",
+    "example": 30,
+    "start_line": 720
+  },
+  {
+    "end_line": 747,
+    "section": "Thematic breaks",
+    "html": "<ul>\n<li>Foo</li>\n<li>\n<hr />\n</li>\n</ul>\n",
+    "markdown": "- Foo\n- * * *\n",
+    "example": 31,
+    "start_line": 737
+  },
+  {
+    "end_line": 780,
+    "section": "ATX headings",
+    "html": "<h1>foo</h1>\n<h2>foo</h2>\n<h3>foo</h3>\n<h4>foo</h4>\n<h5>foo</h5>\n<h6>foo</h6>\n",
+    "markdown": "# foo\n## foo\n### foo\n#### foo\n##### foo\n###### foo\n",
+    "example": 32,
+    "start_line": 766
+  },
+  {
+    "end_line": 789,
+    "section": "ATX headings",
+    "html": "<p>####### foo</p>\n",
+    "markdown": "####### foo\n",
+    "example": 33,
+    "start_line": 785
+  },
+  {
+    "end_line": 807,
+    "section": "ATX headings",
+    "html": "<p>#5 bolt</p>\n<p>#hashtag</p>\n",
+    "markdown": "#5 bolt\n\n#hashtag\n",
+    "example": 34,
+    "start_line": 800
+  },
+  {
+    "end_line": 816,
+    "section": "ATX headings",
+    "html": "<p>## foo</p>\n",
+    "markdown": "\\## foo\n",
+    "example": 35,
+    "start_line": 812
+  },
+  {
+    "end_line": 825,
+    "section": "ATX headings",
+    "html": "<h1>foo <em>bar</em> *baz*</h1>\n",
+    "markdown": "# foo *bar* \\*baz\\*\n",
+    "example": 36,
+    "start_line": 821
+  },
+  {
+    "end_line": 834,
+    "section": "ATX headings",
+    "html": "<h1>foo</h1>\n",
+    "markdown": "#                  foo                     \n",
+    "example": 37,
+    "start_line": 830
+  },
+  {
+    "end_line": 847,
+    "section": "ATX headings",
+    "html": "<h3>foo</h3>\n<h2>foo</h2>\n<h1>foo</h1>\n",
+    "markdown": " ### foo\n  ## foo\n   # foo\n",
+    "example": 38,
+    "start_line": 839
+  },
+  {
+    "end_line": 857,
+    "section": "ATX headings",
+    "html": "<pre><code># foo\n</code></pre>\n",
+    "markdown": "    # foo\n",
+    "example": 39,
+    "start_line": 852
+  },
+  {
+    "end_line": 866,
+    "section": "ATX headings",
+    "html": "<p>foo\n# bar</p>\n",
+    "markdown": "foo\n    # bar\n",
+    "example": 40,
+    "start_line": 860
+  },
+  {
+    "end_line": 877,
+    "section": "ATX headings",
+    "html": "<h2>foo</h2>\n<h3>bar</h3>\n",
+    "markdown": "## foo ##\n  ###   bar    ###\n",
+    "example": 41,
+    "start_line": 871
+  },
+  {
+    "end_line": 888,
+    "section": "ATX headings",
+    "html": "<h1>foo</h1>\n<h5>foo</h5>\n",
+    "markdown": "# foo ##################################\n##### foo ##\n",
+    "example": 42,
+    "start_line": 882
+  },
+  {
+    "end_line": 897,
+    "section": "ATX headings",
+    "html": "<h3>foo</h3>\n",
+    "markdown": "### foo ###     \n",
+    "example": 43,
+    "start_line": 893
+  },
+  {
+    "end_line": 908,
+    "section": "ATX headings",
+    "html": "<h3>foo ### b</h3>\n",
+    "markdown": "### foo ### b\n",
+    "example": 44,
+    "start_line": 904
+  },
+  {
+    "end_line": 917,
+    "section": "ATX headings",
+    "html": "<h1>foo#</h1>\n",
+    "markdown": "# foo#\n",
+    "example": 45,
+    "start_line": 913
+  },
+  {
+    "end_line": 931,
+    "section": "ATX headings",
+    "html": "<h3>foo ###</h3>\n<h2>foo ###</h2>\n<h1>foo #</h1>\n",
+    "markdown": "### foo \\###\n## foo #\\##\n# foo \\#\n",
+    "example": 46,
+    "start_line": 923
+  },
+  {
+    "end_line": 945,
+    "section": "ATX headings",
+    "html": "<hr />\n<h2>foo</h2>\n<hr />\n",
+    "markdown": "****\n## foo\n****\n",
+    "example": 47,
+    "start_line": 937
+  },
+  {
+    "end_line": 956,
+    "section": "ATX headings",
+    "html": "<p>Foo bar</p>\n<h1>baz</h1>\n<p>Bar foo</p>\n",
+    "markdown": "Foo bar\n# baz\nBar foo\n",
+    "example": 48,
+    "start_line": 948
+  },
+  {
+    "end_line": 969,
+    "section": "ATX headings",
+    "html": "<h2></h2>\n<h1></h1>\n<h3></h3>\n",
+    "markdown": "## \n#\n### ###\n",
+    "example": 49,
+    "start_line": 961
+  },
+  {
+    "end_line": 1013,
+    "section": "Setext headings",
+    "html": "<h1>Foo <em>bar</em></h1>\n<h2>Foo <em>bar</em></h2>\n",
+    "markdown": "Foo *bar*\n=========\n\nFoo *bar*\n---------\n",
+    "example": 50,
+    "start_line": 1004
+  },
+  {
+    "end_line": 1025,
+    "section": "Setext headings",
+    "html": "<h1>Foo <em>bar\nbaz</em></h1>\n",
+    "markdown": "Foo *bar\nbaz*\n====\n",
+    "example": 51,
+    "start_line": 1018
+  },
+  {
+    "end_line": 1039,
+    "section": "Setext headings",
+    "html": "<h2>Foo</h2>\n<h1>Foo</h1>\n",
+    "markdown": "Foo\n-------------------------\n\nFoo\n=\n",
+    "example": 52,
+    "start_line": 1030
+  },
+  {
+    "end_line": 1058,
+    "section": "Setext headings",
+    "html": "<h2>Foo</h2>\n<h2>Foo</h2>\n<h1>Foo</h1>\n",
+    "markdown": "   Foo\n---\n\n  Foo\n-----\n\n  Foo\n  ===\n",
+    "example": 53,
+    "start_line": 1045
+  },
+  {
+    "end_line": 1076,
+    "section": "Setext headings",
+    "html": "<pre><code>Foo\n---\n\nFoo\n</code></pre>\n<hr />\n",
+    "markdown": "    Foo\n    ---\n\n    Foo\n---\n",
+    "example": 54,
+    "start_line": 1063
+  },
+  {
+    "end_line": 1087,
+    "section": "Setext headings",
+    "html": "<h2>Foo</h2>\n",
+    "markdown": "Foo\n   ----      \n",
+    "example": 55,
+    "start_line": 1082
+  },
+  {
+    "end_line": 1098,
+    "section": "Setext headings",
+    "html": "<p>Foo\n---</p>\n",
+    "markdown": "Foo\n    ---\n",
+    "example": 56,
+    "start_line": 1092
+  },
+  {
+    "end_line": 1114,
+    "section": "Setext headings",
+    "html": "<p>Foo\n= =</p>\n<p>Foo</p>\n<hr />\n",
+    "markdown": "Foo\n= =\n\nFoo\n--- -\n",
+    "example": 57,
+    "start_line": 1103
+  },
+  {
+    "end_line": 1124,
+    "section": "Setext headings",
+    "html": "<h2>Foo</h2>\n",
+    "markdown": "Foo  \n-----\n",
+    "example": 58,
+    "start_line": 1119
+  },
+  {
+    "end_line": 1134,
+    "section": "Setext headings",
+    "html": "<h2>Foo\\</h2>\n",
+    "markdown": "Foo\\\n----\n",
+    "example": 59,
+    "start_line": 1129
+  },
+  {
+    "end_line": 1153,
+    "section": "Setext headings",
+    "html": "<h2>`Foo</h2>\n<p>`</p>\n<h2>&lt;a title=&quot;a lot</h2>\n<p>of dashes&quot;/&gt;</p>\n",
+    "markdown": "`Foo\n----\n`\n\n<a title=\"a lot\n---\nof dashes\"/>\n",
+    "example": 60,
+    "start_line": 1140
+  },
+  {
+    "end_line": 1167,
+    "section": "Setext headings",
+    "html": "<blockquote>\n<p>Foo</p>\n</blockquote>\n<hr />\n",
+    "markdown": "> Foo\n---\n",
+    "example": 61,
+    "start_line": 1159
+  },
+  {
+    "end_line": 1180,
+    "section": "Setext headings",
+    "html": "<blockquote>\n<p>foo\nbar\n===</p>\n</blockquote>\n",
+    "markdown": "> foo\nbar\n===\n",
+    "example": 62,
+    "start_line": 1170
+  },
+  {
+    "end_line": 1191,
+    "section": "Setext headings",
+    "html": "<ul>\n<li>Foo</li>\n</ul>\n<hr />\n",
+    "markdown": "- Foo\n---\n",
+    "example": 63,
+    "start_line": 1183
+  },
+  {
+    "end_line": 1205,
+    "section": "Setext headings",
+    "html": "<h2>Foo\nBar</h2>\n",
+    "markdown": "Foo\nBar\n---\n",
+    "example": 64,
+    "start_line": 1198
+  },
+  {
+    "end_line": 1223,
+    "section": "Setext headings",
+    "html": "<hr />\n<h2>Foo</h2>\n<h2>Bar</h2>\n<p>Baz</p>\n",
+    "markdown": "---\nFoo\n---\nBar\n---\nBaz\n",
+    "example": 65,
+    "start_line": 1211
+  },
+  {
+    "end_line": 1233,
+    "section": "Setext headings",
+    "html": "<p>====</p>\n",
+    "markdown": "\n====\n",
+    "example": 66,
+    "start_line": 1228
+  },
+  {
+    "end_line": 1246,
+    "section": "Setext headings",
+    "html": "<hr />\n<hr />\n",
+    "markdown": "---\n---\n",
+    "example": 67,
+    "start_line": 1240
+  },
+  {
+    "end_line": 1257,
+    "section": "Setext headings",
+    "html": "<ul>\n<li>foo</li>\n</ul>\n<hr />\n",
+    "markdown": "- foo\n-----\n",
+    "example": 68,
+    "start_line": 1249
+  },
+  {
+    "end_line": 1267,
+    "section": "Setext headings",
+    "html": "<pre><code>foo\n</code></pre>\n<hr />\n",
+    "markdown": "    foo\n---\n",
+    "example": 69,
+    "start_line": 1260
+  },
+  {
+    "end_line": 1278,
+    "section": "Setext headings",
+    "html": "<blockquote>\n<p>foo</p>\n</blockquote>\n<hr />\n",
+    "markdown": "> foo\n-----\n",
+    "example": 70,
+    "start_line": 1270
+  },
+  {
+    "end_line": 1289,
+    "section": "Setext headings",
+    "html": "<h2>&gt; foo</h2>\n",
+    "markdown": "\\> foo\n------\n",
+    "example": 71,
+    "start_line": 1284
+  },
+  {
+    "end_line": 1325,
+    "section": "Setext headings",
+    "html": "<p>Foo</p>\n<h2>bar</h2>\n<p>baz</p>\n",
+    "markdown": "Foo\n\nbar\n---\nbaz\n",
+    "example": 72,
+    "start_line": 1315
+  },
+  {
+    "end_line": 1343,
+    "section": "Setext headings",
+    "html": "<p>Foo\nbar</p>\n<hr />\n<p>baz</p>\n",
+    "markdown": "Foo\nbar\n\n---\n\nbaz\n",
+    "example": 73,
+    "start_line": 1331
+  },
+  {
+    "end_line": 1359,
+    "section": "Setext headings",
+    "html": "<p>Foo\nbar</p>\n<hr />\n<p>baz</p>\n",
+    "markdown": "Foo\nbar\n* * *\nbaz\n",
+    "example": 74,
+    "start_line": 1349
+  },
+  {
+    "end_line": 1374,
+    "section": "Setext headings",
+    "html": "<p>Foo\nbar\n---\nbaz</p>\n",
+    "markdown": "Foo\nbar\n\\---\nbaz\n",
+    "example": 75,
+    "start_line": 1364
+  },
+  {
+    "end_line": 1399,
+    "section": "Indented code blocks",
+    "html": "<pre><code>a simple\n  indented code block\n</code></pre>\n",
+    "markdown": "    a simple\n      indented code block\n",
+    "example": 76,
+    "start_line": 1392
+  },
+  {
+    "end_line": 1417,
+    "section": "Indented code blocks",
+    "html": "<ul>\n<li>\n<p>foo</p>\n<p>bar</p>\n</li>\n</ul>\n",
+    "markdown": "  - foo\n\n    bar\n",
+    "example": 77,
+    "start_line": 1406
+  },
+  {
+    "end_line": 1433,
+    "section": "Indented code blocks",
+    "html": "<ol>\n<li>\n<p>foo</p>\n<ul>\n<li>bar</li>\n</ul>\n</li>\n</ol>\n",
+    "markdown": "1.  foo\n\n    - bar\n",
+    "example": 78,
+    "start_line": 1420
+  },
+  {
+    "end_line": 1451,
+    "section": "Indented code blocks",
+    "html": "<pre><code>&lt;a/&gt;\n*hi*\n\n- one\n</code></pre>\n",
+    "markdown": "    <a/>\n    *hi*\n\n    - one\n",
+    "example": 79,
+    "start_line": 1440
+  },
+  {
+    "end_line": 1473,
+    "section": "Indented code blocks",
+    "html": "<pre><code>chunk1\n\nchunk2\n\n\n\nchunk3\n</code></pre>\n",
+    "markdown": "    chunk1\n\n    chunk2\n  \n \n \n    chunk3\n",
+    "example": 80,
+    "start_line": 1456
+  },
+  {
+    "end_line": 1488,
+    "section": "Indented code blocks",
+    "html": "<pre><code>chunk1\n  \n  chunk2\n</code></pre>\n",
+    "markdown": "    chunk1\n      \n      chunk2\n",
+    "example": 81,
+    "start_line": 1479
+  },
+  {
+    "end_line": 1501,
+    "section": "Indented code blocks",
+    "html": "<p>Foo\nbar</p>\n",
+    "markdown": "Foo\n    bar\n\n",
+    "example": 82,
+    "start_line": 1494
+  },
+  {
+    "end_line": 1515,
+    "section": "Indented code blocks",
+    "html": "<pre><code>foo\n</code></pre>\n<p>bar</p>\n",
+    "markdown": "    foo\nbar\n",
+    "example": 83,
+    "start_line": 1508
+  },
+  {
+    "end_line": 1536,
+    "section": "Indented code blocks",
+    "html": "<h1>Heading</h1>\n<pre><code>foo\n</code></pre>\n<h2>Heading</h2>\n<pre><code>foo\n</code></pre>\n<hr />\n",
+    "markdown": "# Heading\n    foo\nHeading\n------\n    foo\n----\n",
+    "example": 84,
+    "start_line": 1521
+  },
+  {
+    "end_line": 1548,
+    "section": "Indented code blocks",
+    "html": "<pre><code>    foo\nbar\n</code></pre>\n",
+    "markdown": "        foo\n    bar\n",
+    "example": 85,
+    "start_line": 1541
+  },
+  {
+    "end_line": 1563,
+    "section": "Indented code blocks",
+    "html": "<pre><code>foo\n</code></pre>\n",
+    "markdown": "\n    \n    foo\n    \n\n",
+    "example": 86,
+    "start_line": 1554
+  },
+  {
+    "end_line": 1573,
+    "section": "Indented code blocks",
+    "html": "<pre><code>foo  \n</code></pre>\n",
+    "markdown": "    foo  \n",
+    "example": 87,
+    "start_line": 1568
+  },
+  {
+    "end_line": 1632,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>&lt;\n &gt;\n</code></pre>\n",
+    "markdown": "```\n<\n >\n```\n",
+    "example": 88,
+    "start_line": 1623
+  },
+  {
+    "end_line": 1646,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>&lt;\n &gt;\n</code></pre>\n",
+    "markdown": "~~~\n<\n >\n~~~\n",
+    "example": 89,
+    "start_line": 1637
+  },
+  {
+    "end_line": 1656,
+    "section": "Fenced code blocks",
+    "html": "<p><code>foo</code></p>\n",
+    "markdown": "``\nfoo\n``\n",
+    "example": 90,
+    "start_line": 1650
+  },
+  {
+    "end_line": 1670,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>aaa\n~~~\n</code></pre>\n",
+    "markdown": "```\naaa\n~~~\n```\n",
+    "example": 91,
+    "start_line": 1661
+  },
+  {
+    "end_line": 1682,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>aaa\n```\n</code></pre>\n",
+    "markdown": "~~~\naaa\n```\n~~~\n",
+    "example": 92,
+    "start_line": 1673
+  },
+  {
+    "end_line": 1696,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>aaa\n```\n</code></pre>\n",
+    "markdown": "````\naaa\n```\n``````\n",
+    "example": 93,
+    "start_line": 1687
+  },
+  {
+    "end_line": 1708,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>aaa\n~~~\n</code></pre>\n",
+    "markdown": "~~~~\naaa\n~~~\n~~~~\n",
+    "example": 94,
+    "start_line": 1699
+  },
+  {
+    "end_line": 1718,
+    "section": "Fenced code blocks",
+    "html": "<pre><code></code></pre>\n",
+    "markdown": "```\n",
+    "example": 95,
+    "start_line": 1714
+  },
+  {
+    "end_line": 1731,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>\n```\naaa\n</code></pre>\n",
+    "markdown": "`````\n\n```\naaa\n",
+    "example": 96,
+    "start_line": 1721
+  },
+  {
+    "end_line": 1745,
+    "section": "Fenced code blocks",
+    "html": "<blockquote>\n<pre><code>aaa\n</code></pre>\n</blockquote>\n<p>bbb</p>\n",
+    "markdown": "> ```\n> aaa\n\nbbb\n",
+    "example": 97,
+    "start_line": 1734
+  },
+  {
+    "end_line": 1759,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>\n  \n</code></pre>\n",
+    "markdown": "```\n\n  \n```\n",
+    "example": 98,
+    "start_line": 1750
+  },
+  {
+    "end_line": 1769,
+    "section": "Fenced code blocks",
+    "html": "<pre><code></code></pre>\n",
+    "markdown": "```\n```\n",
+    "example": 99,
+    "start_line": 1764
+  },
+  {
+    "end_line": 1785,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>aaa\naaa\n</code></pre>\n",
+    "markdown": " ```\n aaa\naaa\n```\n",
+    "example": 100,
+    "start_line": 1776
+  },
+  {
+    "end_line": 1799,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>aaa\naaa\naaa\n</code></pre>\n",
+    "markdown": "  ```\naaa\n  aaa\naaa\n  ```\n",
+    "example": 101,
+    "start_line": 1788
+  },
+  {
+    "end_line": 1813,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>aaa\n aaa\naaa\n</code></pre>\n",
+    "markdown": "   ```\n   aaa\n    aaa\n  aaa\n   ```\n",
+    "example": 102,
+    "start_line": 1802
+  },
+  {
+    "end_line": 1827,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>```\naaa\n```\n</code></pre>\n",
+    "markdown": "    ```\n    aaa\n    ```\n",
+    "example": 103,
+    "start_line": 1818
+  },
+  {
+    "end_line": 1840,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>aaa\n</code></pre>\n",
+    "markdown": "```\naaa\n  ```\n",
+    "example": 104,
+    "start_line": 1833
+  },
+  {
+    "end_line": 1850,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>aaa\n</code></pre>\n",
+    "markdown": "   ```\naaa\n  ```\n",
+    "example": 105,
+    "start_line": 1843
+  },
+  {
+    "end_line": 1863,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>aaa\n    ```\n</code></pre>\n",
+    "markdown": "```\naaa\n    ```\n",
+    "example": 106,
+    "start_line": 1855
+  },
+  {
+    "end_line": 1875,
+    "section": "Fenced code blocks",
+    "html": "<p><code></code>\naaa</p>\n",
+    "markdown": "``` ```\naaa\n",
+    "example": 107,
+    "start_line": 1869
+  },
+  {
+    "end_line": 1886,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>aaa\n~~~ ~~\n</code></pre>\n",
+    "markdown": "~~~~~~\naaa\n~~~ ~~\n",
+    "example": 108,
+    "start_line": 1878
+  },
+  {
+    "end_line": 1903,
+    "section": "Fenced code blocks",
+    "html": "<p>foo</p>\n<pre><code>bar\n</code></pre>\n<p>baz</p>\n",
+    "markdown": "foo\n```\nbar\n```\nbaz\n",
+    "example": 109,
+    "start_line": 1892
+  },
+  {
+    "end_line": 1921,
+    "section": "Fenced code blocks",
+    "html": "<h2>foo</h2>\n<pre><code>bar\n</code></pre>\n<h1>baz</h1>\n",
+    "markdown": "foo\n---\n~~~\nbar\n~~~\n# baz\n",
+    "example": 110,
+    "start_line": 1909
+  },
+  {
+    "end_line": 1940,
+    "section": "Fenced code blocks",
+    "html": "<pre><code class=\"language-ruby\">def foo(x)\n  return 3\nend\n</code></pre>\n",
+    "markdown": "```ruby\ndef foo(x)\n  return 3\nend\n```\n",
+    "example": 111,
+    "start_line": 1929
+  },
+  {
+    "end_line": 1954,
+    "section": "Fenced code blocks",
+    "html": "<pre><code class=\"language-ruby\">def foo(x)\n  return 3\nend\n</code></pre>\n",
+    "markdown": "~~~~    ruby startline=3 $%@#$\ndef foo(x)\n  return 3\nend\n~~~~~~~\n",
+    "example": 112,
+    "start_line": 1943
+  },
+  {
+    "end_line": 1962,
+    "section": "Fenced code blocks",
+    "html": "<pre><code class=\"language-;\"></code></pre>\n",
+    "markdown": "````;\n````\n",
+    "example": 113,
+    "start_line": 1957
+  },
+  {
+    "end_line": 1973,
+    "section": "Fenced code blocks",
+    "html": "<p><code>aa</code>\nfoo</p>\n",
+    "markdown": "``` aa ```\nfoo\n",
+    "example": 114,
+    "start_line": 1967
+  },
+  {
+    "end_line": 1985,
+    "section": "Fenced code blocks",
+    "html": "<pre><code>``` aaa\n</code></pre>\n",
+    "markdown": "```\n``` aaa\n```\n",
+    "example": 115,
+    "start_line": 1978
+  },
+  {
+    "end_line": 2070,
+    "section": "HTML blocks",
+    "html": "<table><tr><td>\n<pre>\n**Hello**,\n<p><em>world</em>.\n</pre></p>\n</td></tr></table>\n",
+    "markdown": "<table><tr><td>\n<pre>\n**Hello**,\n\n_world_.\n</pre>\n</td></tr></table>\n",
+    "example": 116,
+    "start_line": 2055
+  },
+  {
+    "end_line": 2103,
+    "section": "HTML blocks",
+    "html": "<table>\n  <tr>\n    <td>\n           hi\n    </td>\n  </tr>\n</table>\n<p>okay.</p>\n",
+    "markdown": "<table>\n  <tr>\n    <td>\n           hi\n    </td>\n  </tr>\n</table>\n\nokay.\n",
+    "example": 117,
+    "start_line": 2084
+  },
+  {
+    "end_line": 2114,
+    "section": "HTML blocks",
+    "html": " <div>\n  *hello*\n         <foo><a>\n",
+    "markdown": " <div>\n  *hello*\n         <foo><a>\n",
+    "example": 118,
+    "start_line": 2106
+  },
+  {
+    "end_line": 2125,
+    "section": "HTML blocks",
+    "html": "</div>\n*foo*\n",
+    "markdown": "</div>\n*foo*\n",
+    "example": 119,
+    "start_line": 2119
+  },
+  {
+    "end_line": 2140,
+    "section": "HTML blocks",
+    "html": "<DIV CLASS=\"foo\">\n<p><em>Markdown</em></p>\n</DIV>\n",
+    "markdown": "<DIV CLASS=\"foo\">\n\n*Markdown*\n\n</DIV>\n",
+    "example": 120,
+    "start_line": 2130
+  },
+  {
+    "end_line": 2154,
+    "section": "HTML blocks",
+    "html": "<div id=\"foo\"\n  class=\"bar\">\n</div>\n",
+    "markdown": "<div id=\"foo\"\n  class=\"bar\">\n</div>\n",
+    "example": 121,
+    "start_line": 2146
+  },
+  {
+    "end_line": 2165,
+    "section": "HTML blocks",
+    "html": "<div id=\"foo\" class=\"bar\n  baz\">\n</div>\n",
+    "markdown": "<div id=\"foo\" class=\"bar\n  baz\">\n</div>\n",
+    "example": 122,
+    "start_line": 2157
+  },
+  {
+    "end_line": 2178,
+    "section": "HTML blocks",
+    "html": "<div>\n*foo*\n<p><em>bar</em></p>\n",
+    "markdown": "<div>\n*foo*\n\n*bar*\n",
+    "example": 123,
+    "start_line": 2169
+  },
+  {
+    "end_line": 2191,
+    "section": "HTML blocks",
+    "html": "<div id=\"foo\"\n*hi*\n",
+    "markdown": "<div id=\"foo\"\n*hi*\n",
+    "example": 124,
+    "start_line": 2185
+  },
+  {
+    "end_line": 2200,
+    "section": "HTML blocks",
+    "html": "<div class\nfoo\n",
+    "markdown": "<div class\nfoo\n",
+    "example": 125,
+    "start_line": 2194
+  },
+  {
+    "end_line": 2212,
+    "section": "HTML blocks",
+    "html": "<div *???-&&&-<---\n*foo*\n",
+    "markdown": "<div *???-&&&-<---\n*foo*\n",
+    "example": 126,
+    "start_line": 2206
+  },
+  {
+    "end_line": 2222,
+    "section": "HTML blocks",
+    "html": "<div><a href=\"bar\">*foo*</a></div>\n",
+    "markdown": "<div><a href=\"bar\">*foo*</a></div>\n",
+    "example": 127,
+    "start_line": 2218
+  },
+  {
+    "end_line": 2233,
+    "section": "HTML blocks",
+    "html": "<table><tr><td>\nfoo\n</td></tr></table>\n",
+    "markdown": "<table><tr><td>\nfoo\n</td></tr></table>\n",
+    "example": 128,
+    "start_line": 2225
+  },
+  {
+    "end_line": 2252,
+    "section": "HTML blocks",
+    "html": "<div></div>\n``` c\nint x = 33;\n```\n",
+    "markdown": "<div></div>\n``` c\nint x = 33;\n```\n",
+    "example": 129,
+    "start_line": 2242
+  },
+  {
+    "end_line": 2267,
+    "section": "HTML blocks",
+    "html": "<a href=\"foo\">\n*bar*\n</a>\n",
+    "markdown": "<a href=\"foo\">\n*bar*\n</a>\n",
+    "example": 130,
+    "start_line": 2259
+  },
+  {
+    "end_line": 2280,
+    "section": "HTML blocks",
+    "html": "<Warning>\n*bar*\n</Warning>\n",
+    "markdown": "<Warning>\n*bar*\n</Warning>\n",
+    "example": 131,
+    "start_line": 2272
+  },
+  {
+    "end_line": 2291,
+    "section": "HTML blocks",
+    "html": "<i class=\"foo\">\n*bar*\n</i>\n",
+    "markdown": "<i class=\"foo\">\n*bar*\n</i>\n",
+    "example": 132,
+    "start_line": 2283
+  },
+  {
+    "end_line": 2300,
+    "section": "HTML blocks",
+    "html": "</ins>\n*bar*\n",
+    "markdown": "</ins>\n*bar*\n",
+    "example": 133,
+    "start_line": 2294
+  },
+  {
+    "end_line": 2317,
+    "section": "HTML blocks",
+    "html": "<del>\n*foo*\n</del>\n",
+    "markdown": "<del>\n*foo*\n</del>\n",
+    "example": 134,
+    "start_line": 2309
+  },
+  {
+    "end_line": 2334,
+    "section": "HTML blocks",
+    "html": "<del>\n<p><em>foo</em></p>\n</del>\n",
+    "markdown": "<del>\n\n*foo*\n\n</del>\n",
+    "example": 135,
+    "start_line": 2324
+  },
+  {
+    "end_line": 2346,
+    "section": "HTML blocks",
+    "html": "<p><del><em>foo</em></del></p>\n",
+    "markdown": "<del>*foo*</del>\n",
+    "example": 136,
+    "start_line": 2342
+  },
+  {
+    "end_line": 2374,
+    "section": "HTML blocks",
+    "html": "<pre language=\"haskell\"><code>\nimport Text.HTML.TagSoup\n\nmain :: IO ()\nmain = print $ parseTags tags\n</code></pre>\n<p>okay</p>\n",
+    "markdown": "<pre language=\"haskell\"><code>\nimport Text.HTML.TagSoup\n\nmain :: IO ()\nmain = print $ parseTags tags\n</code></pre>\nokay\n",
+    "example": 137,
+    "start_line": 2358
+  },
+  {
+    "end_line": 2393,
+    "section": "HTML blocks",
+    "html": "<script type=\"text/javascript\">\n// JavaScript example\n\ndocument.getElementById(\"demo\").innerHTML = \"Hello JavaScript!\";\n</script>\n<p>okay</p>\n",
+    "markdown": "<script type=\"text/javascript\">\n// JavaScript example\n\ndocument.getElementById(\"demo\").innerHTML = \"Hello JavaScript!\";\n</script>\nokay\n",
+    "example": 138,
+    "start_line": 2379
+  },
+  {
+    "end_line": 2414,
+    "section": "HTML blocks",
+    "html": "<style\n  type=\"text/css\">\nh1 {color:red;}\n\np {color:blue;}\n</style>\n<p>okay</p>\n",
+    "markdown": "<style\n  type=\"text/css\">\nh1 {color:red;}\n\np {color:blue;}\n</style>\nokay\n",
+    "example": 139,
+    "start_line": 2398
+  },
+  {
+    "end_line": 2431,
+    "section": "HTML blocks",
+    "html": "<style\n  type=\"text/css\">\n\nfoo\n",
+    "markdown": "<style\n  type=\"text/css\">\n\nfoo\n",
+    "example": 140,
+    "start_line": 2421
+  },
+  {
+    "end_line": 2445,
+    "section": "HTML blocks",
+    "html": "<blockquote>\n<div>\nfoo\n</blockquote>\n<p>bar</p>\n",
+    "markdown": "> <div>\n> foo\n\nbar\n",
+    "example": 141,
+    "start_line": 2434
+  },
+  {
+    "end_line": 2458,
+    "section": "HTML blocks",
+    "html": "<ul>\n<li>\n<div>\n</li>\n<li>foo</li>\n</ul>\n",
+    "markdown": "- <div>\n- foo\n",
+    "example": 142,
+    "start_line": 2448
+  },
+  {
+    "end_line": 2469,
+    "section": "HTML blocks",
+    "html": "<style>p{color:red;}</style>\n<p><em>foo</em></p>\n",
+    "markdown": "<style>p{color:red;}</style>\n*foo*\n",
+    "example": 143,
+    "start_line": 2463
+  },
+  {
+    "end_line": 2478,
+    "section": "HTML blocks",
+    "html": "<!-- foo -->*bar*\n<p><em>baz</em></p>\n",
+    "markdown": "<!-- foo -->*bar*\n*baz*\n",
+    "example": 144,
+    "start_line": 2472
+  },
+  {
+    "end_line": 2492,
+    "section": "HTML blocks",
+    "html": "<script>\nfoo\n</script>1. *bar*\n",
+    "markdown": "<script>\nfoo\n</script>1. *bar*\n",
+    "example": 145,
+    "start_line": 2484
+  },
+  {
+    "end_line": 2509,
+    "section": "HTML blocks",
+    "html": "<!-- Foo\n\nbar\n   baz -->\n<p>okay</p>\n",
+    "markdown": "<!-- Foo\n\nbar\n   baz -->\nokay\n",
+    "example": 146,
+    "start_line": 2497
+  },
+  {
+    "end_line": 2529,
+    "section": "HTML blocks",
+    "html": "<?php\n\n  echo '>';\n\n?>\n<p>okay</p>\n",
+    "markdown": "<?php\n\n  echo '>';\n\n?>\nokay\n",
+    "example": 147,
+    "start_line": 2515
+  },
+  {
+    "end_line": 2538,
+    "section": "HTML blocks",
+    "html": "<!DOCTYPE html>\n",
+    "markdown": "<!DOCTYPE html>\n",
+    "example": 148,
+    "start_line": 2534
+  },
+  {
+    "end_line": 2571,
+    "section": "HTML blocks",
+    "html": "<![CDATA[\nfunction matchwo(a,b)\n{\n  if (a < b && a < 0) then {\n    return 1;\n\n  } else {\n\n    return 0;\n  }\n}\n]]>\n<p>okay</p>\n",
+    "markdown": "<![CDATA[\nfunction matchwo(a,b)\n{\n  if (a < b && a < 0) then {\n    return 1;\n\n  } else {\n\n    return 0;\n  }\n}\n]]>\nokay\n",
+    "example": 149,
+    "start_line": 2543
+  },
+  {
+    "end_line": 2584,
+    "section": "HTML blocks",
+    "html": "  <!-- foo -->\n<pre><code>&lt;!-- foo --&gt;\n</code></pre>\n",
+    "markdown": "  <!-- foo -->\n\n    <!-- foo -->\n",
+    "example": 150,
+    "start_line": 2576
+  },
+  {
+    "end_line": 2595,
+    "section": "HTML blocks",
+    "html": "  <div>\n<pre><code>&lt;div&gt;\n</code></pre>\n",
+    "markdown": "  <div>\n\n    <div>\n",
+    "example": 151,
+    "start_line": 2587
+  },
+  {
+    "end_line": 2611,
+    "section": "HTML blocks",
+    "html": "<p>Foo</p>\n<div>\nbar\n</div>\n",
+    "markdown": "Foo\n<div>\nbar\n</div>\n",
+    "example": 152,
+    "start_line": 2601
+  },
+  {
+    "end_line": 2627,
+    "section": "HTML blocks",
+    "html": "<div>\nbar\n</div>\n*foo*\n",
+    "markdown": "<div>\nbar\n</div>\n*foo*\n",
+    "example": 153,
+    "start_line": 2617
+  },
+  {
+    "end_line": 2640,
+    "section": "HTML blocks",
+    "html": "<p>Foo\n<a href=\"bar\">\nbaz</p>\n",
+    "markdown": "Foo\n<a href=\"bar\">\nbaz\n",
+    "example": 154,
+    "start_line": 2632
+  },
+  {
+    "end_line": 2683,
+    "section": "HTML blocks",
+    "html": "<div>\n<p><em>Emphasized</em> text.</p>\n</div>\n",
+    "markdown": "<div>\n\n*Emphasized* text.\n\n</div>\n",
+    "example": 155,
+    "start_line": 2673
+  },
+  {
+    "end_line": 2694,
+    "section": "HTML blocks",
+    "html": "<div>\n*Emphasized* text.\n</div>\n",
+    "markdown": "<div>\n*Emphasized* text.\n</div>\n",
+    "example": 156,
+    "start_line": 2686
+  },
+  {
+    "end_line": 2728,
+    "section": "HTML blocks",
+    "html": "<table>\n<tr>\n<td>\nHi\n</td>\n</tr>\n</table>\n",
+    "markdown": "<table>\n\n<tr>\n\n<td>\nHi\n</td>\n\n</tr>\n\n</table>\n",
+    "example": 157,
+    "start_line": 2708
+  },
+  {
+    "end_line": 2756,
+    "section": "HTML blocks",
+    "html": "<table>\n  <tr>\n<pre><code>&lt;td&gt;\n  Hi\n&lt;/td&gt;\n</code></pre>\n  </tr>\n</table>\n",
+    "markdown": "<table>\n\n  <tr>\n\n    <td>\n      Hi\n    </td>\n\n  </tr>\n\n</table>\n",
+    "example": 158,
+    "start_line": 2735
+  },
+  {
+    "end_line": 2789,
+    "section": "Link reference definitions",
+    "html": "<p><a href=\"/url\" title=\"title\">foo</a></p>\n",
+    "markdown": "[foo]: /url \"title\"\n\n[foo]\n",
+    "example": 159,
+    "start_line": 2783
+  },
+  {
+    "end_line": 2800,
+    "section": "Link reference definitions",
+    "html": "<p><a href=\"/url\" title=\"the title\">foo</a></p>\n",
+    "markdown": "   [foo]: \n      /url  \n           'the title'  \n\n[foo]\n",
+    "example": 160,
+    "start_line": 2792
+  },
+  {
+    "end_line": 2809,
+    "section": "Link reference definitions",
+    "html": "<p><a href=\"my_(url)\" title=\"title (with parens)\">Foo*bar]</a></p>\n",
+    "markdown": "[Foo*bar\\]]:my_(url) 'title (with parens)'\n\n[Foo*bar\\]]\n",
+    "example": 161,
+    "start_line": 2803
+  },
+  {
+    "end_line": 2820,
+    "section": "Link reference definitions",
+    "html": "<p><a href=\"my%20url\" title=\"title\">Foo bar</a></p>\n",
+    "markdown": "[Foo bar]:\n<my%20url>\n'title'\n\n[Foo bar]\n",
+    "example": 162,
+    "start_line": 2812
+  },
+  {
+    "end_line": 2839,
+    "section": "Link reference definitions",
+    "html": "<p><a href=\"/url\" title=\"\ntitle\nline1\nline2\n\">foo</a></p>\n",
+    "markdown": "[foo]: /url '\ntitle\nline1\nline2\n'\n\n[foo]\n",
+    "example": 163,
+    "start_line": 2825
+  },
+  {
+    "end_line": 2854,
+    "section": "Link reference definitions",
+    "html": "<p>[foo]: /url 'title</p>\n<p>with blank line'</p>\n<p>[foo]</p>\n",
+    "markdown": "[foo]: /url 'title\n\nwith blank line'\n\n[foo]\n",
+    "example": 164,
+    "start_line": 2844
+  },
+  {
+    "end_line": 2866,
+    "section": "Link reference definitions",
+    "html": "<p><a href=\"/url\">foo</a></p>\n",
+    "markdown": "[foo]:\n/url\n\n[foo]\n",
+    "example": 165,
+    "start_line": 2859
+  },
+  {
+    "end_line": 2878,
+    "section": "Link reference definitions",
+    "html": "<p>[foo]:</p>\n<p>[foo]</p>\n",
+    "markdown": "[foo]:\n\n[foo]\n",
+    "example": 166,
+    "start_line": 2871
+  },
+  {
+    "end_line": 2890,
+    "section": "Link reference definitions",
+    "html": "<p><a href=\"/url%5Cbar*baz\" title=\"foo&quot;bar\\baz\">foo</a></p>\n",
+    "markdown": "[foo]: /url\\bar\\*baz \"foo\\\"bar\\baz\"\n\n[foo]\n",
+    "example": 167,
+    "start_line": 2884
+  },
+  {
+    "end_line": 2901,
+    "section": "Link reference definitions",
+    "html": "<p><a href=\"url\">foo</a></p>\n",
+    "markdown": "[foo]\n\n[foo]: url\n",
+    "example": 168,
+    "start_line": 2895
+  },
+  {
+    "end_line": 2914,
+    "section": "Link reference definitions",
+    "html": "<p><a href=\"first\">foo</a></p>\n",
+    "markdown": "[foo]\n\n[foo]: first\n[foo]: second\n",
+    "example": 169,
+    "start_line": 2907
+  },
+  {
+    "end_line": 2926,
+    "section": "Link reference definitions",
+    "html": "<p><a href=\"/url\">Foo</a></p>\n",
+    "markdown": "[FOO]: /url\n\n[Foo]\n",
+    "example": 170,
+    "start_line": 2920
+  },
+  {
+    "end_line": 2935,
+    "section": "Link reference definitions",
+    "html": "<p><a href=\"/%CF%86%CE%BF%CF%85\">αγω</a></p>\n",
+    "markdown": "[ΑΓΩ]: /φου\n\n[αγω]\n",
+    "example": 171,
+    "start_line": 2929
+  },
+  {
+    "end_line": 2944,
+    "section": "Link reference definitions",
+    "html": "",
+    "markdown": "[foo]: /url\n",
+    "example": 172,
+    "start_line": 2941
+  },
+  {
+    "end_line": 2956,
+    "section": "Link reference definitions",
+    "html": "<p>bar</p>\n",
+    "markdown": "[\nfoo\n]: /url\nbar\n",
+    "example": 173,
+    "start_line": 2949
+  },
+  {
+    "end_line": 2966,
+    "section": "Link reference definitions",
+    "html": "<p>[foo]: /url &quot;title&quot; ok</p>\n",
+    "markdown": "[foo]: /url \"title\" ok\n",
+    "example": 174,
+    "start_line": 2962
+  },
+  {
+    "end_line": 2976,
+    "section": "Link reference definitions",
+    "html": "<p>&quot;title&quot; ok</p>\n",
+    "markdown": "[foo]: /url\n\"title\" ok\n",
+    "example": 175,
+    "start_line": 2971
+  },
+  {
+    "end_line": 2990,
+    "section": "Link reference definitions",
+    "html": "<pre><code>[foo]: /url &quot;title&quot;\n</code></pre>\n<p>[foo]</p>\n",
+    "markdown": "    [foo]: /url \"title\"\n\n[foo]\n",
+    "example": 176,
+    "start_line": 2982
+  },
+  {
+    "end_line": 3006,
+    "section": "Link reference definitions",
+    "html": "<pre><code>[foo]: /url\n</code></pre>\n<p>[foo]</p>\n",
+    "markdown": "```\n[foo]: /url\n```\n\n[foo]\n",
+    "example": 177,
+    "start_line": 2996
+  },
+  {
+    "end_line": 3020,
+    "section": "Link reference definitions",
+    "html": "<p>Foo\n[bar]: /baz</p>\n<p>[bar]</p>\n",
+    "markdown": "Foo\n[bar]: /baz\n\n[bar]\n",
+    "example": 178,
+    "start_line": 3011
+  },
+  {
+    "end_line": 3035,
+    "section": "Link reference definitions",
+    "html": "<h1><a href=\"/url\">Foo</a></h1>\n<blockquote>\n<p>bar</p>\n</blockquote>\n",
+    "markdown": "# [Foo]\n[foo]: /url\n> bar\n",
+    "example": 179,
+    "start_line": 3026
+  },
+  {
+    "end_line": 3054,
+    "section": "Link reference definitions",
+    "html": "<p><a href=\"/foo-url\" title=\"foo\">foo</a>,\n<a href=\"/bar-url\" title=\"bar\">bar</a>,\n<a href=\"/baz-url\">baz</a></p>\n",
+    "markdown": "[foo]: /foo-url \"foo\"\n[bar]: /bar-url\n  \"bar\"\n[baz]: /baz-url\n\n[foo],\n[bar],\n[baz]\n",
+    "example": 180,
+    "start_line": 3041
+  },
+  {
+    "end_line": 3070,
+    "section": "Link reference definitions",
+    "html": "<p><a href=\"/url\">foo</a></p>\n<blockquote>\n</blockquote>\n",
+    "markdown": "[foo]\n\n> [foo]: /url\n",
+    "example": 181,
+    "start_line": 3062
+  },
+  {
+    "end_line": 3092,
+    "section": "Paragraphs",
+    "html": "<p>aaa</p>\n<p>bbb</p>\n",
+    "markdown": "aaa\n\nbbb\n",
+    "example": 182,
+    "start_line": 3085
+  },
+  {
+    "end_line": 3108,
+    "section": "Paragraphs",
+    "html": "<p>aaa\nbbb</p>\n<p>ccc\nddd</p>\n",
+    "markdown": "aaa\nbbb\n\nccc\nddd\n",
+    "example": 183,
+    "start_line": 3097
+  },
+  {
+    "end_line": 3121,
+    "section": "Paragraphs",
+    "html": "<p>aaa</p>\n<p>bbb</p>\n",
+    "markdown": "aaa\n\n\nbbb\n",
+    "example": 184,
+    "start_line": 3113
+  },
+  {
+    "end_line": 3132,
+    "section": "Paragraphs",
+    "html": "<p>aaa\nbbb</p>\n",
+    "markdown": "  aaa\n bbb\n",
+    "example": 185,
+    "start_line": 3126
+  },
+  {
+    "end_line": 3146,
+    "section": "Paragraphs",
+    "html": "<p>aaa\nbbb\nccc</p>\n",
+    "markdown": "aaa\n             bbb\n                                       ccc\n",
+    "example": 186,
+    "start_line": 3138
+  },
+  {
+    "end_line": 3158,
+    "section": "Paragraphs",
+    "html": "<p>aaa\nbbb</p>\n",
+    "markdown": "   aaa\nbbb\n",
+    "example": 187,
+    "start_line": 3152
+  },
+  {
+    "end_line": 3168,
+    "section": "Paragraphs",
+    "html": "<pre><code>aaa\n</code></pre>\n<p>bbb</p>\n",
+    "markdown": "    aaa\nbbb\n",
+    "example": 188,
+    "start_line": 3161
+  },
+  {
+    "end_line": 3181,
+    "section": "Paragraphs",
+    "html": "<p>aaa<br />\nbbb</p>\n",
+    "markdown": "aaa     \nbbb     \n",
+    "example": 189,
+    "start_line": 3175
+  },
+  {
+    "end_line": 3204,
+    "section": "Blank lines",
+    "html": "<p>aaa</p>\n<h1>aaa</h1>\n",
+    "markdown": "  \n\naaa\n  \n\n# aaa\n\n  \n",
+    "example": 190,
+    "start_line": 3192
+  },
+  {
+    "end_line": 3268,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<h1>Foo</h1>\n<p>bar\nbaz</p>\n</blockquote>\n",
+    "markdown": "> # Foo\n> bar\n> baz\n",
+    "example": 191,
+    "start_line": 3258
+  },
+  {
+    "end_line": 3283,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<h1>Foo</h1>\n<p>bar\nbaz</p>\n</blockquote>\n",
+    "markdown": "># Foo\n>bar\n> baz\n",
+    "example": 192,
+    "start_line": 3273
+  },
+  {
+    "end_line": 3298,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<h1>Foo</h1>\n<p>bar\nbaz</p>\n</blockquote>\n",
+    "markdown": "   > # Foo\n   > bar\n > baz\n",
+    "example": 193,
+    "start_line": 3288
+  },
+  {
+    "end_line": 3312,
+    "section": "Block quotes",
+    "html": "<pre><code>&gt; # Foo\n&gt; bar\n&gt; baz\n</code></pre>\n",
+    "markdown": "    > # Foo\n    > bar\n    > baz\n",
+    "example": 194,
+    "start_line": 3303
+  },
+  {
+    "end_line": 3328,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<h1>Foo</h1>\n<p>bar\nbaz</p>\n</blockquote>\n",
+    "markdown": "> # Foo\n> bar\nbaz\n",
+    "example": 195,
+    "start_line": 3318
+  },
+  {
+    "end_line": 3344,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<p>bar\nbaz\nfoo</p>\n</blockquote>\n",
+    "markdown": "> bar\nbaz\n> foo\n",
+    "example": 196,
+    "start_line": 3334
+  },
+  {
+    "end_line": 3366,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<p>foo</p>\n</blockquote>\n<hr />\n",
+    "markdown": "> foo\n---\n",
+    "example": 197,
+    "start_line": 3358
+  },
+  {
+    "end_line": 3390,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<ul>\n<li>foo</li>\n</ul>\n</blockquote>\n<ul>\n<li>bar</li>\n</ul>\n",
+    "markdown": "> - foo\n- bar\n",
+    "example": 198,
+    "start_line": 3378
+  },
+  {
+    "end_line": 3406,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<pre><code>foo\n</code></pre>\n</blockquote>\n<pre><code>bar\n</code></pre>\n",
+    "markdown": ">     foo\n    bar\n",
+    "example": 199,
+    "start_line": 3396
+  },
+  {
+    "end_line": 3419,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<pre><code></code></pre>\n</blockquote>\n<p>foo</p>\n<pre><code></code></pre>\n",
+    "markdown": "> ```\nfoo\n```\n",
+    "example": 200,
+    "start_line": 3409
+  },
+  {
+    "end_line": 3433,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<p>foo\n- bar</p>\n</blockquote>\n",
+    "markdown": "> foo\n    - bar\n",
+    "example": 201,
+    "start_line": 3425
+  },
+  {
+    "end_line": 3454,
+    "section": "Block quotes",
+    "html": "<blockquote>\n</blockquote>\n",
+    "markdown": ">\n",
+    "example": 202,
+    "start_line": 3449
+  },
+  {
+    "end_line": 3464,
+    "section": "Block quotes",
+    "html": "<blockquote>\n</blockquote>\n",
+    "markdown": ">\n>  \n> \n",
+    "example": 203,
+    "start_line": 3457
+  },
+  {
+    "end_line": 3477,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<p>foo</p>\n</blockquote>\n",
+    "markdown": ">\n> foo\n>  \n",
+    "example": 204,
+    "start_line": 3469
+  },
+  {
+    "end_line": 3493,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<p>foo</p>\n</blockquote>\n<blockquote>\n<p>bar</p>\n</blockquote>\n",
+    "markdown": "> foo\n\n> bar\n",
+    "example": 205,
+    "start_line": 3482
+  },
+  {
+    "end_line": 3512,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<p>foo\nbar</p>\n</blockquote>\n",
+    "markdown": "> foo\n> bar\n",
+    "example": 206,
+    "start_line": 3504
+  },
+  {
+    "end_line": 3526,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<p>foo</p>\n<p>bar</p>\n</blockquote>\n",
+    "markdown": "> foo\n>\n> bar\n",
+    "example": 207,
+    "start_line": 3517
+  },
+  {
+    "end_line": 3539,
+    "section": "Block quotes",
+    "html": "<p>foo</p>\n<blockquote>\n<p>bar</p>\n</blockquote>\n",
+    "markdown": "foo\n> bar\n",
+    "example": 208,
+    "start_line": 3531
+  },
+  {
+    "end_line": 3557,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<p>aaa</p>\n</blockquote>\n<hr />\n<blockquote>\n<p>bbb</p>\n</blockquote>\n",
+    "markdown": "> aaa\n***\n> bbb\n",
+    "example": 209,
+    "start_line": 3545
+  },
+  {
+    "end_line": 3571,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<p>bar\nbaz</p>\n</blockquote>\n",
+    "markdown": "> bar\nbaz\n",
+    "example": 210,
+    "start_line": 3563
+  },
+  {
+    "end_line": 3583,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<p>bar</p>\n</blockquote>\n<p>baz</p>\n",
+    "markdown": "> bar\n\nbaz\n",
+    "example": 211,
+    "start_line": 3574
+  },
+  {
+    "end_line": 3595,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<p>bar</p>\n</blockquote>\n<p>baz</p>\n",
+    "markdown": "> bar\n>\nbaz\n",
+    "example": 212,
+    "start_line": 3586
+  },
+  {
+    "end_line": 3614,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<blockquote>\n<blockquote>\n<p>foo\nbar</p>\n</blockquote>\n</blockquote>\n</blockquote>\n",
+    "markdown": "> > > foo\nbar\n",
+    "example": 213,
+    "start_line": 3602
+  },
+  {
+    "end_line": 3631,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<blockquote>\n<blockquote>\n<p>foo\nbar\nbaz</p>\n</blockquote>\n</blockquote>\n</blockquote>\n",
+    "markdown": ">>> foo\n> bar\n>>baz\n",
+    "example": 214,
+    "start_line": 3617
+  },
+  {
+    "end_line": 3651,
+    "section": "Block quotes",
+    "html": "<blockquote>\n<pre><code>code\n</code></pre>\n</blockquote>\n<blockquote>\n<p>not code</p>\n</blockquote>\n",
+    "markdown": ">     code\n\n>    not code\n",
+    "example": 215,
+    "start_line": 3639
+  },
+  {
+    "end_line": 3709,
+    "section": "List items",
+    "html": "<p>A paragraph\nwith two lines.</p>\n<pre><code>indented code\n</code></pre>\n<blockquote>\n<p>A block quote.</p>\n</blockquote>\n",
+    "markdown": "A paragraph\nwith two lines.\n\n    indented code\n\n> A block quote.\n",
+    "example": 216,
+    "start_line": 3694
+  },
+  {
+    "end_line": 3735,
+    "section": "List items",
+    "html": "<ol>\n<li>\n<p>A paragraph\nwith two lines.</p>\n<pre><code>indented code\n</code></pre>\n<blockquote>\n<p>A block quote.</p>\n</blockquote>\n</li>\n</ol>\n",
+    "markdown": "1.  A paragraph\n    with two lines.\n\n        indented code\n\n    > A block quote.\n",
+    "example": 217,
+    "start_line": 3716
+  },
+  {
+    "end_line": 3758,
+    "section": "List items",
+    "html": "<ul>\n<li>one</li>\n</ul>\n<p>two</p>\n",
+    "markdown": "- one\n\n two\n",
+    "example": 218,
+    "start_line": 3749
+  },
+  {
+    "end_line": 3772,
+    "section": "List items",
+    "html": "<ul>\n<li>\n<p>one</p>\n<p>two</p>\n</li>\n</ul>\n",
+    "markdown": "- one\n\n  two\n",
+    "example": 219,
+    "start_line": 3761
+  },
+  {
+    "end_line": 3785,
+    "section": "List items",
+    "html": "<ul>\n<li>one</li>\n</ul>\n<pre><code> two\n</code></pre>\n",
+    "markdown": " -    one\n\n     two\n",
+    "example": 220,
+    "start_line": 3775
+  },
+  {
+    "end_line": 3799,
+    "section": "List items",
+    "html": "<ul>\n<li>\n<p>one</p>\n<p>two</p>\n</li>\n</ul>\n",
+    "markdown": " -    one\n\n      two\n",
+    "example": 221,
+    "start_line": 3788
+  },
+  {
+    "end_line": 3825,
+    "section": "List items",
+    "html": "<blockquote>\n<blockquote>\n<ol>\n<li>\n<p>one</p>\n<p>two</p>\n</li>\n</ol>\n</blockquote>\n</blockquote>\n",
+    "markdown": "   > > 1.  one\n>>\n>>     two\n",
+    "example": 222,
+    "start_line": 3810
+  },
+  {
+    "end_line": 3850,
+    "section": "List items",
+    "html": "<blockquote>\n<blockquote>\n<ul>\n<li>one</li>\n</ul>\n<p>two</p>\n</blockquote>\n</blockquote>\n",
+    "markdown": ">>- one\n>>\n  >  > two\n",
+    "example": 223,
+    "start_line": 3837
+  },
+  {
+    "end_line": 3863,
+    "section": "List items",
+    "html": "<p>-one</p>\n<p>2.two</p>\n",
+    "markdown": "-one\n\n2.two\n",
+    "example": 224,
+    "start_line": 3856
+  },
+  {
+    "end_line": 3881,
+    "section": "List items",
+    "html": "<ul>\n<li>\n<p>foo</p>\n<p>bar</p>\n</li>\n</ul>\n",
+    "markdown": "- foo\n\n\n  bar\n",
+    "example": 225,
+    "start_line": 3869
+  },
+  {
+    "end_line": 3908,
+    "section": "List items",
+    "html": "<ol>\n<li>\n<p>foo</p>\n<pre><code>bar\n</code></pre>\n<p>baz</p>\n<blockquote>\n<p>bam</p>\n</blockquote>\n</li>\n</ol>\n",
+    "markdown": "1.  foo\n\n    ```\n    bar\n    ```\n\n    baz\n\n    > bam\n",
+    "example": 226,
+    "start_line": 3886
+  },
+  {
+    "end_line": 3932,
+    "section": "List items",
+    "html": "<ul>\n<li>\n<p>Foo</p>\n<pre><code>bar\n\n\nbaz\n</code></pre>\n</li>\n</ul>\n",
+    "markdown": "- Foo\n\n      bar\n\n\n      baz\n",
+    "example": 227,
+    "start_line": 3914
+  },
+  {
+    "end_line": 3942,
+    "section": "List items",
+    "html": "<ol start=\"123456789\">\n<li>ok</li>\n</ol>\n",
+    "markdown": "123456789. ok\n",
+    "example": 228,
+    "start_line": 3936
+  },
+  {
+    "end_line": 3949,
+    "section": "List items",
+    "html": "<p>1234567890. not ok</p>\n",
+    "markdown": "1234567890. not ok\n",
+    "example": 229,
+    "start_line": 3945
+  },
+  {
+    "end_line": 3960,
+    "section": "List items",
+    "html": "<ol start=\"0\">\n<li>ok</li>\n</ol>\n",
+    "markdown": "0. ok\n",
+    "example": 230,
+    "start_line": 3954
+  },
+  {
+    "end_line": 3969,
+    "section": "List items",
+    "html": "<ol start=\"3\">\n<li>ok</li>\n</ol>\n",
+    "markdown": "003. ok\n",
+    "example": 231,
+    "start_line": 3963
+  },
+  {
+    "end_line": 3978,
+    "section": "List items",
+    "html": "<p>-1. not ok</p>\n",
+    "markdown": "-1. not ok\n",
+    "example": 232,
+    "start_line": 3974
+  },
+  {
+    "end_line": 4010,
+    "section": "List items",
+    "html": "<ul>\n<li>\n<p>foo</p>\n<pre><code>bar\n</code></pre>\n</li>\n</ul>\n",
+    "markdown": "- foo\n\n      bar\n",
+    "example": 233,
+    "start_line": 3998
+  },
+  {
+    "end_line": 4027,
+    "section": "List items",
+    "html": "<ol start=\"10\">\n<li>\n<p>foo</p>\n<pre><code>bar\n</code></pre>\n</li>\n</ol>\n",
+    "markdown": "  10.  foo\n\n           bar\n",
+    "example": 234,
+    "start_line": 4015
+  },
+  {
+    "end_line": 4046,
+    "section": "List items",
+    "html": "<pre><code>indented code\n</code></pre>\n<p>paragraph</p>\n<pre><code>more code\n</code></pre>\n",
+    "markdown": "    indented code\n\nparagraph\n\n    more code\n",
+    "example": 235,
+    "start_line": 4034
+  },
+  {
+    "end_line": 4065,
+    "section": "List items",
+    "html": "<ol>\n<li>\n<pre><code>indented code\n</code></pre>\n<p>paragraph</p>\n<pre><code>more code\n</code></pre>\n</li>\n</ol>\n",
+    "markdown": "1.     indented code\n\n   paragraph\n\n       more code\n",
+    "example": 236,
+    "start_line": 4049
+  },
+  {
+    "end_line": 4087,
+    "section": "List items",
+    "html": "<ol>\n<li>\n<pre><code> indented code\n</code></pre>\n<p>paragraph</p>\n<pre><code>more code\n</code></pre>\n</li>\n</ol>\n",
+    "markdown": "1.      indented code\n\n   paragraph\n\n       more code\n",
+    "example": 237,
+    "start_line": 4071
+  },
+  {
+    "end_line": 4105,
+    "section": "List items",
+    "html": "<p>foo</p>\n<p>bar</p>\n",
+    "markdown": "   foo\n\nbar\n",
+    "example": 238,
+    "start_line": 4098
+  },
+  {
+    "end_line": 4117,
+    "section": "List items",
+    "html": "<ul>\n<li>foo</li>\n</ul>\n<p>bar</p>\n",
+    "markdown": "-    foo\n\n  bar\n",
+    "example": 239,
+    "start_line": 4108
+  },
+  {
+    "end_line": 4136,
+    "section": "List items",
+    "html": "<ul>\n<li>\n<p>foo</p>\n<p>bar</p>\n</li>\n</ul>\n",
+    "markdown": "-  foo\n\n   bar\n",
+    "example": 240,
+    "start_line": 4125
+  },
+  {
+    "end_line": 4174,
+    "section": "List items",
+    "html": "<ul>\n<li>foo</li>\n<li>\n<pre><code>bar\n</code></pre>\n</li>\n<li>\n<pre><code>baz\n</code></pre>\n</li>\n</ul>\n",
+    "markdown": "-\n  foo\n-\n  ```\n  bar\n  ```\n-\n      baz\n",
+    "example": 241,
+    "start_line": 4153
+  },
+  {
+    "end_line": 4186,
+    "section": "List items",
+    "html": "<ul>\n<li>foo</li>\n</ul>\n",
+    "markdown": "-   \n  foo\n",
+    "example": 242,
+    "start_line": 4179
+  },
+  {
+    "end_line": 4202,
+    "section": "List items",
+    "html": "<ul>\n<li></li>\n</ul>\n<p>foo</p>\n",
+    "markdown": "-\n\n  foo\n",
+    "example": 243,
+    "start_line": 4193
+  },
+  {
+    "end_line": 4217,
+    "section": "List items",
+    "html": "<ul>\n<li>foo</li>\n<li></li>\n<li>bar</li>\n</ul>\n",
+    "markdown": "- foo\n-\n- bar\n",
+    "example": 244,
+    "start_line": 4207
+  },
+  {
+    "end_line": 4232,
+    "section": "List items",
+    "html": "<ul>\n<li>foo</li>\n<li></li>\n<li>bar</li>\n</ul>\n",
+    "markdown": "- foo\n-   \n- bar\n",
+    "example": 245,
+    "start_line": 4222
+  },
+  {
+    "end_line": 4247,
+    "section": "List items",
+    "html": "<ol>\n<li>foo</li>\n<li></li>\n<li>bar</li>\n</ol>\n",
+    "markdown": "1. foo\n2.\n3. bar\n",
+    "example": 246,
+    "start_line": 4237
+  },
+  {
+    "end_line": 4258,
+    "section": "List items",
+    "html": "<ul>\n<li></li>\n</ul>\n",
+    "markdown": "*\n",
+    "example": 247,
+    "start_line": 4252
+  },
+  {
+    "end_line": 4273,
+    "section": "List items",
+    "html": "<p>foo\n*</p>\n<p>foo\n1.</p>\n",
+    "markdown": "foo\n*\n\nfoo\n1.\n",
+    "example": 248,
+    "start_line": 4262
+  },
+  {
+    "end_line": 4303,
+    "section": "List items",
+    "html": "<ol>\n<li>\n<p>A paragraph\nwith two lines.</p>\n<pre><code>indented code\n</code></pre>\n<blockquote>\n<p>A block quote.</p>\n</blockquote>\n</li>\n</ol>\n",
+    "markdown": " 1.  A paragraph\n     with two lines.\n\n         indented code\n\n     > A block quote.\n",
+    "example": 249,
+    "start_line": 4284
+  },
+  {
+    "end_line": 4327,
+    "section": "List items",
+    "html": "<ol>\n<li>\n<p>A paragraph\nwith two lines.</p>\n<pre><code>indented code\n</code></pre>\n<blockquote>\n<p>A block quote.</p>\n</blockquote>\n</li>\n</ol>\n",
+    "markdown": "  1.  A paragraph\n      with two lines.\n\n          indented code\n\n      > A block quote.\n",
+    "example": 250,
+    "start_line": 4308
+  },
+  {
+    "end_line": 4351,
+    "section": "List items",
+    "html": "<ol>\n<li>\n<p>A paragraph\nwith two lines.</p>\n<pre><code>indented code\n</code></pre>\n<blockquote>\n<p>A block quote.</p>\n</blockquote>\n</li>\n</ol>\n",
+    "markdown": "   1.  A paragraph\n       with two lines.\n\n           indented code\n\n       > A block quote.\n",
+    "example": 251,
+    "start_line": 4332
+  },
+  {
+    "end_line": 4371,
+    "section": "List items",
+    "html": "<pre><code>1.  A paragraph\n    with two lines.\n\n        indented code\n\n    &gt; A block quote.\n</code></pre>\n",
+    "markdown": "    1.  A paragraph\n        with two lines.\n\n            indented code\n\n        > A block quote.\n",
+    "example": 252,
+    "start_line": 4356
+  },
+  {
+    "end_line": 4405,
+    "section": "List items",
+    "html": "<ol>\n<li>\n<p>A paragraph\nwith two lines.</p>\n<pre><code>indented code\n</code></pre>\n<blockquote>\n<p>A block quote.</p>\n</blockquote>\n</li>\n</ol>\n",
+    "markdown": "  1.  A paragraph\nwith two lines.\n\n          indented code\n\n      > A block quote.\n",
+    "example": 253,
+    "start_line": 4386
+  },
+  {
+    "end_line": 4418,
+    "section": "List items",
+    "html": "<ol>\n<li>A paragraph\nwith two lines.</li>\n</ol>\n",
+    "markdown": "  1.  A paragraph\n    with two lines.\n",
+    "example": 254,
+    "start_line": 4410
+  },
+  {
+    "end_line": 4437,
+    "section": "List items",
+    "html": "<blockquote>\n<ol>\n<li>\n<blockquote>\n<p>Blockquote\ncontinued here.</p>\n</blockquote>\n</li>\n</ol>\n</blockquote>\n",
+    "markdown": "> 1. > Blockquote\ncontinued here.\n",
+    "example": 255,
+    "start_line": 4423
+  },
+  {
+    "end_line": 4454,
+    "section": "List items",
+    "html": "<blockquote>\n<ol>\n<li>\n<blockquote>\n<p>Blockquote\ncontinued here.</p>\n</blockquote>\n</li>\n</ol>\n</blockquote>\n",
+    "markdown": "> 1. > Blockquote\n> continued here.\n",
+    "example": 256,
+    "start_line": 4440
+  },
+  {
+    "end_line": 4488,
+    "section": "List items",
+    "html": "<ul>\n<li>foo\n<ul>\n<li>bar\n<ul>\n<li>baz\n<ul>\n<li>boo</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n",
+    "markdown": "- foo\n  - bar\n    - baz\n      - boo\n",
+    "example": 257,
+    "start_line": 4467
+  },
+  {
+    "end_line": 4505,
+    "section": "List items",
+    "html": "<ul>\n<li>foo</li>\n<li>bar</li>\n<li>baz</li>\n<li>boo</li>\n</ul>\n",
+    "markdown": "- foo\n - bar\n  - baz\n   - boo\n",
+    "example": 258,
+    "start_line": 4493
+  },
+  {
+    "end_line": 4521,
+    "section": "List items",
+    "html": "<ol start=\"10\">\n<li>foo\n<ul>\n<li>bar</li>\n</ul>\n</li>\n</ol>\n",
+    "markdown": "10) foo\n    - bar\n",
+    "example": 259,
+    "start_line": 4510
+  },
+  {
+    "end_line": 4536,
+    "section": "List items",
+    "html": "<ol start=\"10\">\n<li>foo</li>\n</ol>\n<ul>\n<li>bar</li>\n</ul>\n",
+    "markdown": "10) foo\n   - bar\n",
+    "example": 260,
+    "start_line": 4526
+  },
+  {
+    "end_line": 4551,
+    "section": "List items",
+    "html": "<ul>\n<li>\n<ul>\n<li>foo</li>\n</ul>\n</li>\n</ul>\n",
+    "markdown": "- - foo\n",
+    "example": 261,
+    "start_line": 4541
+  },
+  {
+    "end_line": 4568,
+    "section": "List items",
+    "html": "<ol>\n<li>\n<ul>\n<li>\n<ol start=\"2\">\n<li>foo</li>\n</ol>\n</li>\n</ul>\n</li>\n</ol>\n",
+    "markdown": "1. - 2. foo\n",
+    "example": 262,
+    "start_line": 4554
+  },
+  {
+    "end_line": 4587,
+    "section": "List items",
+    "html": "<ul>\n<li>\n<h1>Foo</h1>\n</li>\n<li>\n<h2>Bar</h2>\nbaz</li>\n</ul>\n",
+    "markdown": "- # Foo\n- Bar\n  ---\n  baz\n",
+    "example": 263,
+    "start_line": 4573
+  },
+  {
+    "end_line": 4821,
+    "section": "Lists",
+    "html": "<ul>\n<li>foo</li>\n<li>bar</li>\n</ul>\n<ul>\n<li>baz</li>\n</ul>\n",
+    "markdown": "- foo\n- bar\n+ baz\n",
+    "example": 264,
+    "start_line": 4809
+  },
+  {
+    "end_line": 4836,
+    "section": "Lists",
+    "html": "<ol>\n<li>foo</li>\n<li>bar</li>\n</ol>\n<ol start=\"3\">\n<li>baz</li>\n</ol>\n",
+    "markdown": "1. foo\n2. bar\n3) baz\n",
+    "example": 265,
+    "start_line": 4824
+  },
+  {
+    "end_line": 4853,
+    "section": "Lists",
+    "html": "<p>Foo</p>\n<ul>\n<li>bar</li>\n<li>baz</li>\n</ul>\n",
+    "markdown": "Foo\n- bar\n- baz\n",
+    "example": 266,
+    "start_line": 4843
+  },
+  {
+    "end_line": 4926,
+    "section": "Lists",
+    "html": "<p>The number of windows in my house is\n14.  The number of doors is 6.</p>\n",
+    "markdown": "The number of windows in my house is\n14.  The number of doors is 6.\n",
+    "example": 267,
+    "start_line": 4920
+  },
+  {
+    "end_line": 4938,
+    "section": "Lists",
+    "html": "<p>The number of windows in my house is</p>\n<ol>\n<li>The number of doors is 6.</li>\n</ol>\n",
+    "markdown": "The number of windows in my house is\n1.  The number of doors is 6.\n",
+    "example": 268,
+    "start_line": 4930
+  },
+  {
+    "end_line": 4963,
+    "section": "Lists",
+    "html": "<ul>\n<li>\n<p>foo</p>\n</li>\n<li>\n<p>bar</p>\n</li>\n<li>\n<p>baz</p>\n</li>\n</ul>\n",
+    "markdown": "- foo\n\n- bar\n\n\n- baz\n",
+    "example": 269,
+    "start_line": 4944
+  },
+  {
+    "end_line": 4987,
+    "section": "Lists",
+    "html": "<ul>\n<li>foo\n<ul>\n<li>bar\n<ul>\n<li>\n<p>baz</p>\n<p>bim</p>\n</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n",
+    "markdown": "- foo\n  - bar\n    - baz\n\n\n      bim\n",
+    "example": 270,
+    "start_line": 4965
+  },
+  {
+    "end_line": 5013,
+    "section": "Lists",
+    "html": "<ul>\n<li>foo</li>\n<li>bar</li>\n</ul>\n<!-- -->\n<ul>\n<li>baz</li>\n<li>bim</li>\n</ul>\n",
+    "markdown": "- foo\n- bar\n\n<!-- -->\n\n- baz\n- bim\n",
+    "example": 271,
+    "start_line": 4995
+  },
+  {
+    "end_line": 5039,
+    "section": "Lists",
+    "html": "<ul>\n<li>\n<p>foo</p>\n<p>notcode</p>\n</li>\n<li>\n<p>foo</p>\n</li>\n</ul>\n<!-- -->\n<pre><code>code\n</code></pre>\n",
+    "markdown": "-   foo\n\n    notcode\n\n-   foo\n\n<!-- -->\n\n    code\n",
+    "example": 272,
+    "start_line": 5016
+  },
+  {
+    "end_line": 5069,
+    "section": "Lists",
+    "html": "<ul>\n<li>a</li>\n<li>b</li>\n<li>c</li>\n<li>d</li>\n<li>e</li>\n<li>f</li>\n<li>g</li>\n<li>h</li>\n<li>i</li>\n</ul>\n",
+    "markdown": "- a\n - b\n  - c\n   - d\n    - e\n   - f\n  - g\n - h\n- i\n",
+    "example": 273,
+    "start_line": 5047
+  },
+  {
+    "end_line": 5090,
+    "section": "Lists",
+    "html": "<ol>\n<li>\n<p>a</p>\n</li>\n<li>\n<p>b</p>\n</li>\n<li>\n<p>c</p>\n</li>\n</ol>\n",
+    "markdown": "1. a\n\n  2. b\n\n    3. c\n",
+    "example": 274,
+    "start_line": 5072
+  },
+  {
+    "end_line": 5113,
+    "section": "Lists",
+    "html": "<ul>\n<li>\n<p>a</p>\n</li>\n<li>\n<p>b</p>\n</li>\n<li>\n<p>c</p>\n</li>\n</ul>\n",
+    "markdown": "- a\n- b\n\n- c\n",
+    "example": 275,
+    "start_line": 5096
+  },
+  {
+    "end_line": 5133,
+    "section": "Lists",
+    "html": "<ul>\n<li>\n<p>a</p>\n</li>\n<li></li>\n<li>\n<p>c</p>\n</li>\n</ul>\n",
+    "markdown": "* a\n*\n\n* c\n",
+    "example": 276,
+    "start_line": 5118
+  },
+  {
+    "end_line": 5159,
+    "section": "Lists",
+    "html": "<ul>\n<li>\n<p>a</p>\n</li>\n<li>\n<p>b</p>\n<p>c</p>\n</li>\n<li>\n<p>d</p>\n</li>\n</ul>\n",
+    "markdown": "- a\n- b\n\n  c\n- d\n",
+    "example": 277,
+    "start_line": 5140
+  },
+  {
+    "end_line": 5180,
+    "section": "Lists",
+    "html": "<ul>\n<li>\n<p>a</p>\n</li>\n<li>\n<p>b</p>\n</li>\n<li>\n<p>d</p>\n</li>\n</ul>\n",
+    "markdown": "- a\n- b\n\n  [ref]: /url\n- d\n",
+    "example": 278,
+    "start_line": 5162
+  },
+  {
+    "end_line": 5204,
+    "section": "Lists",
+    "html": "<ul>\n<li>a</li>\n<li>\n<pre><code>b\n\n\n</code></pre>\n</li>\n<li>c</li>\n</ul>\n",
+    "markdown": "- a\n- ```\n  b\n\n\n  ```\n- c\n",
+    "example": 279,
+    "start_line": 5185
+  },
+  {
+    "end_line": 5229,
+    "section": "Lists",
+    "html": "<ul>\n<li>a\n<ul>\n<li>\n<p>b</p>\n<p>c</p>\n</li>\n</ul>\n</li>\n<li>d</li>\n</ul>\n",
+    "markdown": "- a\n  - b\n\n    c\n- d\n",
+    "example": 280,
+    "start_line": 5211
+  },
+  {
+    "end_line": 5249,
+    "section": "Lists",
+    "html": "<ul>\n<li>a\n<blockquote>\n<p>b</p>\n</blockquote>\n</li>\n<li>c</li>\n</ul>\n",
+    "markdown": "* a\n  > b\n  >\n* c\n",
+    "example": 281,
+    "start_line": 5235
+  },
+  {
+    "end_line": 5273,
+    "section": "Lists",
+    "html": "<ul>\n<li>a\n<blockquote>\n<p>b</p>\n</blockquote>\n<pre><code>c\n</code></pre>\n</li>\n<li>d</li>\n</ul>\n",
+    "markdown": "- a\n  > b\n  ```\n  c\n  ```\n- d\n",
+    "example": 282,
+    "start_line": 5255
+  },
+  {
+    "end_line": 5284,
+    "section": "Lists",
+    "html": "<ul>\n<li>a</li>\n</ul>\n",
+    "markdown": "- a\n",
+    "example": 283,
+    "start_line": 5278
+  },
+  {
+    "end_line": 5298,
+    "section": "Lists",
+    "html": "<ul>\n<li>a\n<ul>\n<li>b</li>\n</ul>\n</li>\n</ul>\n",
+    "markdown": "- a\n  - b\n",
+    "example": 284,
+    "start_line": 5287
+  },
+  {
+    "end_line": 5318,
+    "section": "Lists",
+    "html": "<ol>\n<li>\n<pre><code>foo\n</code></pre>\n<p>bar</p>\n</li>\n</ol>\n",
+    "markdown": "1. ```\n   foo\n   ```\n\n   bar\n",
+    "example": 285,
+    "start_line": 5304
+  },
+  {
+    "end_line": 5338,
+    "section": "Lists",
+    "html": "<ul>\n<li>\n<p>foo</p>\n<ul>\n<li>bar</li>\n</ul>\n<p>baz</p>\n</li>\n</ul>\n",
+    "markdown": "* foo\n  * bar\n\n  baz\n",
+    "example": 286,
+    "start_line": 5323
+  },
+  {
+    "end_line": 5366,
+    "section": "Lists",
+    "html": "<ul>\n<li>\n<p>a</p>\n<ul>\n<li>b</li>\n<li>c</li>\n</ul>\n</li>\n<li>\n<p>d</p>\n<ul>\n<li>e</li>\n<li>f</li>\n</ul>\n</li>\n</ul>\n",
+    "markdown": "- a\n  - b\n  - c\n\n- d\n  - e\n  - f\n",
+    "example": 287,
+    "start_line": 5341
+  },
+  {
+    "end_line": 5379,
+    "section": "Inlines",
+    "html": "<p><code>hi</code>lo`</p>\n",
+    "markdown": "`hi`lo`\n",
+    "example": 288,
+    "start_line": 5375
+  },
+  {
+    "end_line": 5393,
+    "section": "Backslash escapes",
+    "html": "<p>!&quot;#$%&amp;'()*+,-./:;&lt;=&gt;?@[\\]^_`{|}~</p>\n",
+    "markdown": "\\!\\\"\\#\\$\\%\\&\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^\\_\\`\\{\\|\\}\\~\n",
+    "example": 289,
+    "start_line": 5389
+  },
+  {
+    "end_line": 5403,
+    "section": "Backslash escapes",
+    "html": "<p>\\\t\\A\\a\\ \\3\\φ\\«</p>\n",
+    "markdown": "\\\t\\A\\a\\ \\3\\φ\\«\n",
+    "example": 290,
+    "start_line": 5399
+  },
+  {
+    "end_line": 5427,
+    "section": "Backslash escapes",
+    "html": "<p>*not emphasized*\n&lt;br/&gt; not a tag\n[not a link](/foo)\n`not code`\n1. not a list\n* not a list\n# not a heading\n[foo]: /url &quot;not a reference&quot;</p>\n",
+    "markdown": "\\*not emphasized*\n\\<br/> not a tag\n\\[not a link](/foo)\n\\`not code`\n1\\. not a list\n\\* not a list\n\\# not a heading\n\\[foo]: /url \"not a reference\"\n",
+    "example": 291,
+    "start_line": 5409
+  },
+  {
+    "end_line": 5436,
+    "section": "Backslash escapes",
+    "html": "<p>\\<em>emphasis</em></p>\n",
+    "markdown": "\\\\*emphasis*\n",
+    "example": 292,
+    "start_line": 5432
+  },
+  {
+    "end_line": 5447,
+    "section": "Backslash escapes",
+    "html": "<p>foo<br />\nbar</p>\n",
+    "markdown": "foo\\\nbar\n",
+    "example": 293,
+    "start_line": 5441
+  },
+  {
+    "end_line": 5457,
+    "section": "Backslash escapes",
+    "html": "<p><code>\\[\\`</code></p>\n",
+    "markdown": "`` \\[\\` ``\n",
+    "example": 294,
+    "start_line": 5453
+  },
+  {
+    "end_line": 5465,
+    "section": "Backslash escapes",
+    "html": "<pre><code>\\[\\]\n</code></pre>\n",
+    "markdown": "    \\[\\]\n",
+    "example": 295,
+    "start_line": 5460
+  },
+  {
+    "end_line": 5475,
+    "section": "Backslash escapes",
+    "html": "<pre><code>\\[\\]\n</code></pre>\n",
+    "markdown": "~~~\n\\[\\]\n~~~\n",
+    "example": 296,
+    "start_line": 5468
+  },
+  {
+    "end_line": 5482,
+    "section": "Backslash escapes",
+    "html": "<p><a href=\"http://example.com?find=%5C*\">http://example.com?find=\\*</a></p>\n",
+    "markdown": "<http://example.com?find=\\*>\n",
+    "example": 297,
+    "start_line": 5478
+  },
+  {
+    "end_line": 5489,
+    "section": "Backslash escapes",
+    "html": "<a href=\"/bar\\/)\">\n",
+    "markdown": "<a href=\"/bar\\/)\">\n",
+    "example": 298,
+    "start_line": 5485
+  },
+  {
+    "end_line": 5499,
+    "section": "Backslash escapes",
+    "html": "<p><a href=\"/bar*\" title=\"ti*tle\">foo</a></p>\n",
+    "markdown": "[foo](/bar\\* \"ti\\*tle\")\n",
+    "example": 299,
+    "start_line": 5495
+  },
+  {
+    "end_line": 5508,
+    "section": "Backslash escapes",
+    "html": "<p><a href=\"/bar*\" title=\"ti*tle\">foo</a></p>\n",
+    "markdown": "[foo]\n\n[foo]: /bar\\* \"ti\\*tle\"\n",
+    "example": 300,
+    "start_line": 5502
+  },
+  {
+    "end_line": 5518,
+    "section": "Backslash escapes",
+    "html": "<pre><code class=\"language-foo+bar\">foo\n</code></pre>\n",
+    "markdown": "``` foo\\+bar\nfoo\n```\n",
+    "example": 301,
+    "start_line": 5511
+  },
+  {
+    "end_line": 5546,
+    "section": "Entity and numeric character references",
+    "html": "<p>  &amp; © Æ Ď\n¾ ℋ ⅆ\n∲ ≧̸</p>\n",
+    "markdown": "&nbsp; &amp; &copy; &AElig; &Dcaron;\n&frac34; &HilbertSpace; &DifferentialD;\n&ClockwiseContourIntegral; &ngE;\n",
+    "example": 302,
+    "start_line": 5538
+  },
+  {
+    "end_line": 5561,
+    "section": "Entity and numeric character references",
+    "html": "<p># Ӓ Ϡ � �</p>\n",
+    "markdown": "&#35; &#1234; &#992; &#98765432; &#0;\n",
+    "example": 303,
+    "start_line": 5557
+  },
+  {
+    "end_line": 5574,
+    "section": "Entity and numeric character references",
+    "html": "<p>&quot; ആ ಫ</p>\n",
+    "markdown": "&#X22; &#XD06; &#xcab;\n",
+    "example": 304,
+    "start_line": 5570
+  },
+  {
+    "end_line": 5585,
+    "section": "Entity and numeric character references",
+    "html": "<p>&amp;nbsp &amp;x; &amp;#; &amp;#x;\n&amp;ThisIsNotDefined; &amp;hi?;</p>\n",
+    "markdown": "&nbsp &x; &#; &#x;\n&ThisIsNotDefined; &hi?;\n",
+    "example": 305,
+    "start_line": 5579
+  },
+  {
+    "end_line": 5596,
+    "section": "Entity and numeric character references",
+    "html": "<p>&amp;copy</p>\n",
+    "markdown": "&copy\n",
+    "example": 306,
+    "start_line": 5592
+  },
+  {
+    "end_line": 5606,
+    "section": "Entity and numeric character references",
+    "html": "<p>&amp;MadeUpEntity;</p>\n",
+    "markdown": "&MadeUpEntity;\n",
+    "example": 307,
+    "start_line": 5602
+  },
+  {
+    "end_line": 5617,
+    "section": "Entity and numeric character references",
+    "html": "<a href=\"&ouml;&ouml;.html\">\n",
+    "markdown": "<a href=\"&ouml;&ouml;.html\">\n",
+    "example": 308,
+    "start_line": 5613
+  },
+  {
+    "end_line": 5624,
+    "section": "Entity and numeric character references",
+    "html": "<p><a href=\"/f%C3%B6%C3%B6\" title=\"föö\">foo</a></p>\n",
+    "markdown": "[foo](/f&ouml;&ouml; \"f&ouml;&ouml;\")\n",
+    "example": 309,
+    "start_line": 5620
+  },
+  {
+    "end_line": 5633,
+    "section": "Entity and numeric character references",
+    "html": "<p><a href=\"/f%C3%B6%C3%B6\" title=\"föö\">foo</a></p>\n",
+    "markdown": "[foo]\n\n[foo]: /f&ouml;&ouml; \"f&ouml;&ouml;\"\n",
+    "example": 310,
+    "start_line": 5627
+  },
+  {
+    "end_line": 5643,
+    "section": "Entity and numeric character references",
+    "html": "<pre><code class=\"language-föö\">foo\n</code></pre>\n",
+    "markdown": "``` f&ouml;&ouml;\nfoo\n```\n",
+    "example": 311,
+    "start_line": 5636
+  },
+  {
+    "end_line": 5653,
+    "section": "Entity and numeric character references",
+    "html": "<p><code>f&amp;ouml;&amp;ouml;</code></p>\n",
+    "markdown": "`f&ouml;&ouml;`\n",
+    "example": 312,
+    "start_line": 5649
+  },
+  {
+    "end_line": 5661,
+    "section": "Entity and numeric character references",
+    "html": "<pre><code>f&amp;ouml;f&amp;ouml;\n</code></pre>\n",
+    "markdown": "    f&ouml;f&ouml;\n",
+    "example": 313,
+    "start_line": 5656
+  },
+  {
+    "end_line": 5682,
+    "section": "Code spans",
+    "html": "<p><code>foo</code></p>\n",
+    "markdown": "`foo`\n",
+    "example": 314,
+    "start_line": 5678
+  },
+  {
+    "end_line": 5692,
+    "section": "Code spans",
+    "html": "<p><code>foo ` bar</code></p>\n",
+    "markdown": "`` foo ` bar  ``\n",
+    "example": 315,
+    "start_line": 5688
+  },
+  {
+    "end_line": 5702,
+    "section": "Code spans",
+    "html": "<p><code>``</code></p>\n",
+    "markdown": "` `` `\n",
+    "example": 316,
+    "start_line": 5698
+  },
+  {
+    "end_line": 5713,
+    "section": "Code spans",
+    "html": "<p><code>foo</code></p>\n",
+    "markdown": "``\nfoo\n``\n",
+    "example": 317,
+    "start_line": 5707
+  },
+  {
+    "end_line": 5724,
+    "section": "Code spans",
+    "html": "<p><code>foo bar baz</code></p>\n",
+    "markdown": "`foo   bar\n  baz`\n",
+    "example": 318,
+    "start_line": 5719
+  },
+  {
+    "end_line": 5734,
+    "section": "Code spans",
+    "html": "<p><code>a  b</code></p>\n",
+    "markdown": "`a  b`\n",
+    "example": 319,
+    "start_line": 5730
+  },
+  {
+    "end_line": 5754,
+    "section": "Code spans",
+    "html": "<p><code>foo `` bar</code></p>\n",
+    "markdown": "`foo `` bar`\n",
+    "example": 320,
+    "start_line": 5750
+  },
+  {
+    "end_line": 5764,
+    "section": "Code spans",
+    "html": "<p><code>foo\\</code>bar`</p>\n",
+    "markdown": "`foo\\`bar`\n",
+    "example": 321,
+    "start_line": 5760
+  },
+  {
+    "end_line": 5780,
+    "section": "Code spans",
+    "html": "<p>*foo<code>*</code></p>\n",
+    "markdown": "*foo`*`\n",
+    "example": 322,
+    "start_line": 5776
+  },
+  {
+    "end_line": 5789,
+    "section": "Code spans",
+    "html": "<p>[not a <code>link](/foo</code>)</p>\n",
+    "markdown": "[not a `link](/foo`)\n",
+    "example": 323,
+    "start_line": 5785
+  },
+  {
+    "end_line": 5799,
+    "section": "Code spans",
+    "html": "<p><code>&lt;a href=&quot;</code>&quot;&gt;`</p>\n",
+    "markdown": "`<a href=\"`\">`\n",
+    "example": 324,
+    "start_line": 5795
+  },
+  {
+    "end_line": 5808,
+    "section": "Code spans",
+    "html": "<p><a href=\"`\">`</p>\n",
+    "markdown": "<a href=\"`\">`\n",
+    "example": 325,
+    "start_line": 5804
+  },
+  {
+    "end_line": 5817,
+    "section": "Code spans",
+    "html": "<p><code>&lt;http://foo.bar.</code>baz&gt;`</p>\n",
+    "markdown": "`<http://foo.bar.`baz>`\n",
+    "example": 326,
+    "start_line": 5813
+  },
+  {
+    "end_line": 5826,
+    "section": "Code spans",
+    "html": "<p><a href=\"http://foo.bar.%60baz\">http://foo.bar.`baz</a>`</p>\n",
+    "markdown": "<http://foo.bar.`baz>`\n",
+    "example": 327,
+    "start_line": 5822
+  },
+  {
+    "end_line": 5836,
+    "section": "Code spans",
+    "html": "<p>```foo``</p>\n",
+    "markdown": "```foo``\n",
+    "example": 328,
+    "start_line": 5832
+  },
+  {
+    "end_line": 5843,
+    "section": "Code spans",
+    "html": "<p>`foo</p>\n",
+    "markdown": "`foo\n",
+    "example": 329,
+    "start_line": 5839
+  },
+  {
+    "end_line": 5852,
+    "section": "Code spans",
+    "html": "<p>`foo<code>bar</code></p>\n",
+    "markdown": "`foo``bar``\n",
+    "example": 330,
+    "start_line": 5848
+  },
+  {
+    "end_line": 6065,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo bar</em></p>\n",
+    "markdown": "*foo bar*\n",
+    "example": 331,
+    "start_line": 6061
+  },
+  {
+    "end_line": 6075,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>a * foo bar*</p>\n",
+    "markdown": "a * foo bar*\n",
+    "example": 332,
+    "start_line": 6071
+  },
+  {
+    "end_line": 6086,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>a*&quot;foo&quot;*</p>\n",
+    "markdown": "a*\"foo\"*\n",
+    "example": 333,
+    "start_line": 6082
+  },
+  {
+    "end_line": 6095,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>* a *</p>\n",
+    "markdown": "* a *\n",
+    "example": 334,
+    "start_line": 6091
+  },
+  {
+    "end_line": 6104,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo<em>bar</em></p>\n",
+    "markdown": "foo*bar*\n",
+    "example": 335,
+    "start_line": 6100
+  },
+  {
+    "end_line": 6111,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>5<em>6</em>78</p>\n",
+    "markdown": "5*6*78\n",
+    "example": 336,
+    "start_line": 6107
+  },
+  {
+    "end_line": 6120,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo bar</em></p>\n",
+    "markdown": "_foo bar_\n",
+    "example": 337,
+    "start_line": 6116
+  },
+  {
+    "end_line": 6130,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>_ foo bar_</p>\n",
+    "markdown": "_ foo bar_\n",
+    "example": 338,
+    "start_line": 6126
+  },
+  {
+    "end_line": 6140,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>a_&quot;foo&quot;_</p>\n",
+    "markdown": "a_\"foo\"_\n",
+    "example": 339,
+    "start_line": 6136
+  },
+  {
+    "end_line": 6149,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo_bar_</p>\n",
+    "markdown": "foo_bar_\n",
+    "example": 340,
+    "start_line": 6145
+  },
+  {
+    "end_line": 6156,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>5_6_78</p>\n",
+    "markdown": "5_6_78\n",
+    "example": 341,
+    "start_line": 6152
+  },
+  {
+    "end_line": 6163,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>пристаням_стремятся_</p>\n",
+    "markdown": "пристаням_стремятся_\n",
+    "example": 342,
+    "start_line": 6159
+  },
+  {
+    "end_line": 6173,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>aa_&quot;bb&quot;_cc</p>\n",
+    "markdown": "aa_\"bb\"_cc\n",
+    "example": 343,
+    "start_line": 6169
+  },
+  {
+    "end_line": 6184,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo-<em>(bar)</em></p>\n",
+    "markdown": "foo-_(bar)_\n",
+    "example": 344,
+    "start_line": 6180
+  },
+  {
+    "end_line": 6196,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>_foo*</p>\n",
+    "markdown": "_foo*\n",
+    "example": 345,
+    "start_line": 6192
+  },
+  {
+    "end_line": 6206,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>*foo bar *</p>\n",
+    "markdown": "*foo bar *\n",
+    "example": 346,
+    "start_line": 6202
+  },
+  {
+    "end_line": 6217,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>*foo bar\n*</p>\n",
+    "markdown": "*foo bar\n*\n",
+    "example": 347,
+    "start_line": 6211
+  },
+  {
+    "end_line": 6228,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>*(*foo)</p>\n",
+    "markdown": "*(*foo)\n",
+    "example": 348,
+    "start_line": 6224
+  },
+  {
+    "end_line": 6238,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>(<em>foo</em>)</em></p>\n",
+    "markdown": "*(*foo*)*\n",
+    "example": 349,
+    "start_line": 6234
+  },
+  {
+    "end_line": 6247,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo</em>bar</p>\n",
+    "markdown": "*foo*bar\n",
+    "example": 350,
+    "start_line": 6243
+  },
+  {
+    "end_line": 6260,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>_foo bar _</p>\n",
+    "markdown": "_foo bar _\n",
+    "example": 351,
+    "start_line": 6256
+  },
+  {
+    "end_line": 6270,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>_(_foo)</p>\n",
+    "markdown": "_(_foo)\n",
+    "example": 352,
+    "start_line": 6266
+  },
+  {
+    "end_line": 6279,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>(<em>foo</em>)</em></p>\n",
+    "markdown": "_(_foo_)_\n",
+    "example": 353,
+    "start_line": 6275
+  },
+  {
+    "end_line": 6288,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>_foo_bar</p>\n",
+    "markdown": "_foo_bar\n",
+    "example": 354,
+    "start_line": 6284
+  },
+  {
+    "end_line": 6295,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>_пристаням_стремятся</p>\n",
+    "markdown": "_пристаням_стремятся\n",
+    "example": 355,
+    "start_line": 6291
+  },
+  {
+    "end_line": 6302,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo_bar_baz</em></p>\n",
+    "markdown": "_foo_bar_baz_\n",
+    "example": 356,
+    "start_line": 6298
+  },
+  {
+    "end_line": 6313,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>(bar)</em>.</p>\n",
+    "markdown": "_(bar)_.\n",
+    "example": 357,
+    "start_line": 6309
+  },
+  {
+    "end_line": 6322,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo bar</strong></p>\n",
+    "markdown": "**foo bar**\n",
+    "example": 358,
+    "start_line": 6318
+  },
+  {
+    "end_line": 6332,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>** foo bar**</p>\n",
+    "markdown": "** foo bar**\n",
+    "example": 359,
+    "start_line": 6328
+  },
+  {
+    "end_line": 6343,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>a**&quot;foo&quot;**</p>\n",
+    "markdown": "a**\"foo\"**\n",
+    "example": 360,
+    "start_line": 6339
+  },
+  {
+    "end_line": 6352,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo<strong>bar</strong></p>\n",
+    "markdown": "foo**bar**\n",
+    "example": 361,
+    "start_line": 6348
+  },
+  {
+    "end_line": 6361,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo bar</strong></p>\n",
+    "markdown": "__foo bar__\n",
+    "example": 362,
+    "start_line": 6357
+  },
+  {
+    "end_line": 6371,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>__ foo bar__</p>\n",
+    "markdown": "__ foo bar__\n",
+    "example": 363,
+    "start_line": 6367
+  },
+  {
+    "end_line": 6381,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>__\nfoo bar__</p>\n",
+    "markdown": "__\nfoo bar__\n",
+    "example": 364,
+    "start_line": 6375
+  },
+  {
+    "end_line": 6391,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>a__&quot;foo&quot;__</p>\n",
+    "markdown": "a__\"foo\"__\n",
+    "example": 365,
+    "start_line": 6387
+  },
+  {
+    "end_line": 6400,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo__bar__</p>\n",
+    "markdown": "foo__bar__\n",
+    "example": 366,
+    "start_line": 6396
+  },
+  {
+    "end_line": 6407,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>5__6__78</p>\n",
+    "markdown": "5__6__78\n",
+    "example": 367,
+    "start_line": 6403
+  },
+  {
+    "end_line": 6414,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>пристаням__стремятся__</p>\n",
+    "markdown": "пристаням__стремятся__\n",
+    "example": 368,
+    "start_line": 6410
+  },
+  {
+    "end_line": 6421,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo, <strong>bar</strong>, baz</strong></p>\n",
+    "markdown": "__foo, __bar__, baz__\n",
+    "example": 369,
+    "start_line": 6417
+  },
+  {
+    "end_line": 6432,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo-<strong>(bar)</strong></p>\n",
+    "markdown": "foo-__(bar)__\n",
+    "example": 370,
+    "start_line": 6428
+  },
+  {
+    "end_line": 6445,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>**foo bar **</p>\n",
+    "markdown": "**foo bar **\n",
+    "example": 371,
+    "start_line": 6441
+  },
+  {
+    "end_line": 6458,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>**(**foo)</p>\n",
+    "markdown": "**(**foo)\n",
+    "example": 372,
+    "start_line": 6454
+  },
+  {
+    "end_line": 6468,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>(<strong>foo</strong>)</em></p>\n",
+    "markdown": "*(**foo**)*\n",
+    "example": 373,
+    "start_line": 6464
+  },
+  {
+    "end_line": 6477,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>Gomphocarpus (<em>Gomphocarpus physocarpus</em>, syn.\n<em>Asclepias physocarpa</em>)</strong></p>\n",
+    "markdown": "**Gomphocarpus (*Gomphocarpus physocarpus*, syn.\n*Asclepias physocarpa*)**\n",
+    "example": 374,
+    "start_line": 6471
+  },
+  {
+    "end_line": 6484,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo &quot;<em>bar</em>&quot; foo</strong></p>\n",
+    "markdown": "**foo \"*bar*\" foo**\n",
+    "example": 375,
+    "start_line": 6480
+  },
+  {
+    "end_line": 6493,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo</strong>bar</p>\n",
+    "markdown": "**foo**bar\n",
+    "example": 376,
+    "start_line": 6489
+  },
+  {
+    "end_line": 6505,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>__foo bar __</p>\n",
+    "markdown": "__foo bar __\n",
+    "example": 377,
+    "start_line": 6501
+  },
+  {
+    "end_line": 6515,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>__(__foo)</p>\n",
+    "markdown": "__(__foo)\n",
+    "example": 378,
+    "start_line": 6511
+  },
+  {
+    "end_line": 6525,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>(<strong>foo</strong>)</em></p>\n",
+    "markdown": "_(__foo__)_\n",
+    "example": 379,
+    "start_line": 6521
+  },
+  {
+    "end_line": 6534,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>__foo__bar</p>\n",
+    "markdown": "__foo__bar\n",
+    "example": 380,
+    "start_line": 6530
+  },
+  {
+    "end_line": 6541,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>__пристаням__стремятся</p>\n",
+    "markdown": "__пристаням__стремятся\n",
+    "example": 381,
+    "start_line": 6537
+  },
+  {
+    "end_line": 6548,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo__bar__baz</strong></p>\n",
+    "markdown": "__foo__bar__baz__\n",
+    "example": 382,
+    "start_line": 6544
+  },
+  {
+    "end_line": 6559,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>(bar)</strong>.</p>\n",
+    "markdown": "__(bar)__.\n",
+    "example": 383,
+    "start_line": 6555
+  },
+  {
+    "end_line": 6571,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo <a href=\"/url\">bar</a></em></p>\n",
+    "markdown": "*foo [bar](/url)*\n",
+    "example": 384,
+    "start_line": 6567
+  },
+  {
+    "end_line": 6580,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo\nbar</em></p>\n",
+    "markdown": "*foo\nbar*\n",
+    "example": 385,
+    "start_line": 6574
+  },
+  {
+    "end_line": 6590,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo <strong>bar</strong> baz</em></p>\n",
+    "markdown": "_foo __bar__ baz_\n",
+    "example": 386,
+    "start_line": 6586
+  },
+  {
+    "end_line": 6597,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo <em>bar</em> baz</em></p>\n",
+    "markdown": "_foo _bar_ baz_\n",
+    "example": 387,
+    "start_line": 6593
+  },
+  {
+    "end_line": 6604,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em><em>foo</em> bar</em></p>\n",
+    "markdown": "__foo_ bar_\n",
+    "example": 388,
+    "start_line": 6600
+  },
+  {
+    "end_line": 6611,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo <em>bar</em></em></p>\n",
+    "markdown": "*foo *bar**\n",
+    "example": 389,
+    "start_line": 6607
+  },
+  {
+    "end_line": 6618,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo <strong>bar</strong> baz</em></p>\n",
+    "markdown": "*foo **bar** baz*\n",
+    "example": 390,
+    "start_line": 6614
+  },
+  {
+    "end_line": 6624,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo<strong>bar</strong>baz</em></p>\n",
+    "markdown": "*foo**bar**baz*\n",
+    "example": 391,
+    "start_line": 6620
+  },
+  {
+    "end_line": 6649,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em><strong>foo</strong> bar</em></p>\n",
+    "markdown": "***foo** bar*\n",
+    "example": 392,
+    "start_line": 6645
+  },
+  {
+    "end_line": 6656,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo <strong>bar</strong></em></p>\n",
+    "markdown": "*foo **bar***\n",
+    "example": 393,
+    "start_line": 6652
+  },
+  {
+    "end_line": 6663,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo<strong>bar</strong></em></p>\n",
+    "markdown": "*foo**bar***\n",
+    "example": 394,
+    "start_line": 6659
+  },
+  {
+    "end_line": 6672,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo <strong>bar <em>baz</em> bim</strong> bop</em></p>\n",
+    "markdown": "*foo **bar *baz* bim** bop*\n",
+    "example": 395,
+    "start_line": 6668
+  },
+  {
+    "end_line": 6679,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo <a href=\"/url\"><em>bar</em></a></em></p>\n",
+    "markdown": "*foo [*bar*](/url)*\n",
+    "example": 396,
+    "start_line": 6675
+  },
+  {
+    "end_line": 6688,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>** is not an empty emphasis</p>\n",
+    "markdown": "** is not an empty emphasis\n",
+    "example": 397,
+    "start_line": 6684
+  },
+  {
+    "end_line": 6695,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>**** is not an empty strong emphasis</p>\n",
+    "markdown": "**** is not an empty strong emphasis\n",
+    "example": 398,
+    "start_line": 6691
+  },
+  {
+    "end_line": 6708,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo <a href=\"/url\">bar</a></strong></p>\n",
+    "markdown": "**foo [bar](/url)**\n",
+    "example": 399,
+    "start_line": 6704
+  },
+  {
+    "end_line": 6717,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo\nbar</strong></p>\n",
+    "markdown": "**foo\nbar**\n",
+    "example": 400,
+    "start_line": 6711
+  },
+  {
+    "end_line": 6727,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo <em>bar</em> baz</strong></p>\n",
+    "markdown": "__foo _bar_ baz__\n",
+    "example": 401,
+    "start_line": 6723
+  },
+  {
+    "end_line": 6734,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo <strong>bar</strong> baz</strong></p>\n",
+    "markdown": "__foo __bar__ baz__\n",
+    "example": 402,
+    "start_line": 6730
+  },
+  {
+    "end_line": 6741,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong><strong>foo</strong> bar</strong></p>\n",
+    "markdown": "____foo__ bar__\n",
+    "example": 403,
+    "start_line": 6737
+  },
+  {
+    "end_line": 6748,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo <strong>bar</strong></strong></p>\n",
+    "markdown": "**foo **bar****\n",
+    "example": 404,
+    "start_line": 6744
+  },
+  {
+    "end_line": 6755,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo <em>bar</em> baz</strong></p>\n",
+    "markdown": "**foo *bar* baz**\n",
+    "example": 405,
+    "start_line": 6751
+  },
+  {
+    "end_line": 6762,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo<em>bar</em>baz</strong></p>\n",
+    "markdown": "**foo*bar*baz**\n",
+    "example": 406,
+    "start_line": 6758
+  },
+  {
+    "end_line": 6769,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong><em>foo</em> bar</strong></p>\n",
+    "markdown": "***foo* bar**\n",
+    "example": 407,
+    "start_line": 6765
+  },
+  {
+    "end_line": 6776,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo <em>bar</em></strong></p>\n",
+    "markdown": "**foo *bar***\n",
+    "example": 408,
+    "start_line": 6772
+  },
+  {
+    "end_line": 6787,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo <em>bar <strong>baz</strong>\nbim</em> bop</strong></p>\n",
+    "markdown": "**foo *bar **baz**\nbim* bop**\n",
+    "example": 409,
+    "start_line": 6781
+  },
+  {
+    "end_line": 6794,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo <a href=\"/url\"><em>bar</em></a></strong></p>\n",
+    "markdown": "**foo [*bar*](/url)**\n",
+    "example": 410,
+    "start_line": 6790
+  },
+  {
+    "end_line": 6803,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>__ is not an empty emphasis</p>\n",
+    "markdown": "__ is not an empty emphasis\n",
+    "example": 411,
+    "start_line": 6799
+  },
+  {
+    "end_line": 6810,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>____ is not an empty strong emphasis</p>\n",
+    "markdown": "____ is not an empty strong emphasis\n",
+    "example": 412,
+    "start_line": 6806
+  },
+  {
+    "end_line": 6820,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo ***</p>\n",
+    "markdown": "foo ***\n",
+    "example": 413,
+    "start_line": 6816
+  },
+  {
+    "end_line": 6827,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo <em>*</em></p>\n",
+    "markdown": "foo *\\**\n",
+    "example": 414,
+    "start_line": 6823
+  },
+  {
+    "end_line": 6834,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo <em>_</em></p>\n",
+    "markdown": "foo *_*\n",
+    "example": 415,
+    "start_line": 6830
+  },
+  {
+    "end_line": 6841,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo *****</p>\n",
+    "markdown": "foo *****\n",
+    "example": 416,
+    "start_line": 6837
+  },
+  {
+    "end_line": 6848,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo <strong>*</strong></p>\n",
+    "markdown": "foo **\\***\n",
+    "example": 417,
+    "start_line": 6844
+  },
+  {
+    "end_line": 6855,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo <strong>_</strong></p>\n",
+    "markdown": "foo **_**\n",
+    "example": 418,
+    "start_line": 6851
+  },
+  {
+    "end_line": 6866,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>*<em>foo</em></p>\n",
+    "markdown": "**foo*\n",
+    "example": 419,
+    "start_line": 6862
+  },
+  {
+    "end_line": 6873,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo</em>*</p>\n",
+    "markdown": "*foo**\n",
+    "example": 420,
+    "start_line": 6869
+  },
+  {
+    "end_line": 6880,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>*<strong>foo</strong></p>\n",
+    "markdown": "***foo**\n",
+    "example": 421,
+    "start_line": 6876
+  },
+  {
+    "end_line": 6887,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>***<em>foo</em></p>\n",
+    "markdown": "****foo*\n",
+    "example": 422,
+    "start_line": 6883
+  },
+  {
+    "end_line": 6894,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo</strong>*</p>\n",
+    "markdown": "**foo***\n",
+    "example": 423,
+    "start_line": 6890
+  },
+  {
+    "end_line": 6901,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo</em>***</p>\n",
+    "markdown": "*foo****\n",
+    "example": 424,
+    "start_line": 6897
+  },
+  {
+    "end_line": 6911,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo ___</p>\n",
+    "markdown": "foo ___\n",
+    "example": 425,
+    "start_line": 6907
+  },
+  {
+    "end_line": 6918,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo <em>_</em></p>\n",
+    "markdown": "foo _\\__\n",
+    "example": 426,
+    "start_line": 6914
+  },
+  {
+    "end_line": 6925,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo <em>*</em></p>\n",
+    "markdown": "foo _*_\n",
+    "example": 427,
+    "start_line": 6921
+  },
+  {
+    "end_line": 6932,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo _____</p>\n",
+    "markdown": "foo _____\n",
+    "example": 428,
+    "start_line": 6928
+  },
+  {
+    "end_line": 6939,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo <strong>_</strong></p>\n",
+    "markdown": "foo __\\___\n",
+    "example": 429,
+    "start_line": 6935
+  },
+  {
+    "end_line": 6946,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>foo <strong>*</strong></p>\n",
+    "markdown": "foo __*__\n",
+    "example": 430,
+    "start_line": 6942
+  },
+  {
+    "end_line": 6953,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>_<em>foo</em></p>\n",
+    "markdown": "__foo_\n",
+    "example": 431,
+    "start_line": 6949
+  },
+  {
+    "end_line": 6964,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo</em>_</p>\n",
+    "markdown": "_foo__\n",
+    "example": 432,
+    "start_line": 6960
+  },
+  {
+    "end_line": 6971,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>_<strong>foo</strong></p>\n",
+    "markdown": "___foo__\n",
+    "example": 433,
+    "start_line": 6967
+  },
+  {
+    "end_line": 6978,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>___<em>foo</em></p>\n",
+    "markdown": "____foo_\n",
+    "example": 434,
+    "start_line": 6974
+  },
+  {
+    "end_line": 6985,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo</strong>_</p>\n",
+    "markdown": "__foo___\n",
+    "example": 435,
+    "start_line": 6981
+  },
+  {
+    "end_line": 6992,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo</em>___</p>\n",
+    "markdown": "_foo____\n",
+    "example": 436,
+    "start_line": 6988
+  },
+  {
+    "end_line": 7002,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo</strong></p>\n",
+    "markdown": "**foo**\n",
+    "example": 437,
+    "start_line": 6998
+  },
+  {
+    "end_line": 7009,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em><em>foo</em></em></p>\n",
+    "markdown": "*_foo_*\n",
+    "example": 438,
+    "start_line": 7005
+  },
+  {
+    "end_line": 7016,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong>foo</strong></p>\n",
+    "markdown": "__foo__\n",
+    "example": 439,
+    "start_line": 7012
+  },
+  {
+    "end_line": 7023,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em><em>foo</em></em></p>\n",
+    "markdown": "_*foo*_\n",
+    "example": 440,
+    "start_line": 7019
+  },
+  {
+    "end_line": 7033,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong><strong>foo</strong></strong></p>\n",
+    "markdown": "****foo****\n",
+    "example": 441,
+    "start_line": 7029
+  },
+  {
+    "end_line": 7040,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong><strong>foo</strong></strong></p>\n",
+    "markdown": "____foo____\n",
+    "example": 442,
+    "start_line": 7036
+  },
+  {
+    "end_line": 7051,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><strong><strong><strong>foo</strong></strong></strong></p>\n",
+    "markdown": "******foo******\n",
+    "example": 443,
+    "start_line": 7047
+  },
+  {
+    "end_line": 7060,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em><strong>foo</strong></em></p>\n",
+    "markdown": "***foo***\n",
+    "example": 444,
+    "start_line": 7056
+  },
+  {
+    "end_line": 7067,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em><strong><strong>foo</strong></strong></em></p>\n",
+    "markdown": "_____foo_____\n",
+    "example": 445,
+    "start_line": 7063
+  },
+  {
+    "end_line": 7076,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo _bar</em> baz_</p>\n",
+    "markdown": "*foo _bar* baz_\n",
+    "example": 446,
+    "start_line": 7072
+  },
+  {
+    "end_line": 7083,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>foo <strong>bar *baz bim</strong> bam</em></p>\n",
+    "markdown": "*foo __bar *baz bim__ bam*\n",
+    "example": 447,
+    "start_line": 7079
+  },
+  {
+    "end_line": 7092,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>**foo <strong>bar baz</strong></p>\n",
+    "markdown": "**foo **bar baz**\n",
+    "example": 448,
+    "start_line": 7088
+  },
+  {
+    "end_line": 7099,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>*foo <em>bar baz</em></p>\n",
+    "markdown": "*foo *bar baz*\n",
+    "example": 449,
+    "start_line": 7095
+  },
+  {
+    "end_line": 7108,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>*<a href=\"/url\">bar*</a></p>\n",
+    "markdown": "*[bar*](/url)\n",
+    "example": 450,
+    "start_line": 7104
+  },
+  {
+    "end_line": 7115,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>_foo <a href=\"/url\">bar_</a></p>\n",
+    "markdown": "_foo [bar_](/url)\n",
+    "example": 451,
+    "start_line": 7111
+  },
+  {
+    "end_line": 7122,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>*<img src=\"foo\" title=\"*\"/></p>\n",
+    "markdown": "*<img src=\"foo\" title=\"*\"/>\n",
+    "example": 452,
+    "start_line": 7118
+  },
+  {
+    "end_line": 7129,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>**<a href=\"**\"></p>\n",
+    "markdown": "**<a href=\"**\">\n",
+    "example": 453,
+    "start_line": 7125
+  },
+  {
+    "end_line": 7136,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>__<a href=\"__\"></p>\n",
+    "markdown": "__<a href=\"__\">\n",
+    "example": 454,
+    "start_line": 7132
+  },
+  {
+    "end_line": 7143,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>a <code>*</code></em></p>\n",
+    "markdown": "*a `*`*\n",
+    "example": 455,
+    "start_line": 7139
+  },
+  {
+    "end_line": 7150,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p><em>a <code>_</code></em></p>\n",
+    "markdown": "_a `_`_\n",
+    "example": 456,
+    "start_line": 7146
+  },
+  {
+    "end_line": 7157,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>**a<a href=\"http://foo.bar/?q=**\">http://foo.bar/?q=**</a></p>\n",
+    "markdown": "**a<http://foo.bar/?q=**>\n",
+    "example": 457,
+    "start_line": 7153
+  },
+  {
+    "end_line": 7164,
+    "section": "Emphasis and strong emphasis",
+    "html": "<p>__a<a href=\"http://foo.bar/?q=__\">http://foo.bar/?q=__</a></p>\n",
+    "markdown": "__a<http://foo.bar/?q=__>\n",
+    "example": 458,
+    "start_line": 7160
+  },
+  {
+    "end_line": 7245,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\" title=\"title\">link</a></p>\n",
+    "markdown": "[link](/uri \"title\")\n",
+    "example": 459,
+    "start_line": 7241
+  },
+  {
+    "end_line": 7254,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\">link</a></p>\n",
+    "markdown": "[link](/uri)\n",
+    "example": 460,
+    "start_line": 7250
+  },
+  {
+    "end_line": 7263,
+    "section": "Links",
+    "html": "<p><a href=\"\">link</a></p>\n",
+    "markdown": "[link]()\n",
+    "example": 461,
+    "start_line": 7259
+  },
+  {
+    "end_line": 7270,
+    "section": "Links",
+    "html": "<p><a href=\"\">link</a></p>\n",
+    "markdown": "[link](<>)\n",
+    "example": 462,
+    "start_line": 7266
+  },
+  {
+    "end_line": 7280,
+    "section": "Links",
+    "html": "<p>[link](/my uri)</p>\n",
+    "markdown": "[link](/my uri)\n",
+    "example": 463,
+    "start_line": 7276
+  },
+  {
+    "end_line": 7287,
+    "section": "Links",
+    "html": "<p>[link](&lt;/my uri&gt;)</p>\n",
+    "markdown": "[link](</my uri>)\n",
+    "example": 464,
+    "start_line": 7283
+  },
+  {
+    "end_line": 7296,
+    "section": "Links",
+    "html": "<p>[link](foo\nbar)</p>\n",
+    "markdown": "[link](foo\nbar)\n",
+    "example": 465,
+    "start_line": 7290
+  },
+  {
+    "end_line": 7305,
+    "section": "Links",
+    "html": "<p>[link](<foo\nbar>)</p>\n",
+    "markdown": "[link](<foo\nbar>)\n",
+    "example": 466,
+    "start_line": 7299
+  },
+  {
+    "end_line": 7313,
+    "section": "Links",
+    "html": "<p><a href=\"(foo)\">link</a></p>\n",
+    "markdown": "[link](\\(foo\\))\n",
+    "example": 467,
+    "start_line": 7309
+  },
+  {
+    "end_line": 7322,
+    "section": "Links",
+    "html": "<p><a href=\"foo(and(bar))\">link</a></p>\n",
+    "markdown": "[link](foo(and(bar)))\n",
+    "example": 468,
+    "start_line": 7318
+  },
+  {
+    "end_line": 7331,
+    "section": "Links",
+    "html": "<p><a href=\"foo(and(bar)\">link</a></p>\n",
+    "markdown": "[link](foo\\(and\\(bar\\))\n",
+    "example": 469,
+    "start_line": 7327
+  },
+  {
+    "end_line": 7338,
+    "section": "Links",
+    "html": "<p><a href=\"foo(and(bar)\">link</a></p>\n",
+    "markdown": "[link](<foo(and(bar)>)\n",
+    "example": 470,
+    "start_line": 7334
+  },
+  {
+    "end_line": 7348,
+    "section": "Links",
+    "html": "<p><a href=\"foo):\">link</a></p>\n",
+    "markdown": "[link](foo\\)\\:)\n",
+    "example": 471,
+    "start_line": 7344
+  },
+  {
+    "end_line": 7363,
+    "section": "Links",
+    "html": "<p><a href=\"#fragment\">link</a></p>\n<p><a href=\"http://example.com#fragment\">link</a></p>\n<p><a href=\"http://example.com?foo=3#frag\">link</a></p>\n",
+    "markdown": "[link](#fragment)\n\n[link](http://example.com#fragment)\n\n[link](http://example.com?foo=3#frag)\n",
+    "example": 472,
+    "start_line": 7353
+  },
+  {
+    "end_line": 7373,
+    "section": "Links",
+    "html": "<p><a href=\"foo%5Cbar\">link</a></p>\n",
+    "markdown": "[link](foo\\bar)\n",
+    "example": 473,
+    "start_line": 7369
+  },
+  {
+    "end_line": 7389,
+    "section": "Links",
+    "html": "<p><a href=\"foo%20b%C3%A4\">link</a></p>\n",
+    "markdown": "[link](foo%20b&auml;)\n",
+    "example": 474,
+    "start_line": 7385
+  },
+  {
+    "end_line": 7400,
+    "section": "Links",
+    "html": "<p><a href=\"%22title%22\">link</a></p>\n",
+    "markdown": "[link](\"title\")\n",
+    "example": 475,
+    "start_line": 7396
+  },
+  {
+    "end_line": 7413,
+    "section": "Links",
+    "html": "<p><a href=\"/url\" title=\"title\">link</a>\n<a href=\"/url\" title=\"title\">link</a>\n<a href=\"/url\" title=\"title\">link</a></p>\n",
+    "markdown": "[link](/url \"title\")\n[link](/url 'title')\n[link](/url (title))\n",
+    "example": 476,
+    "start_line": 7405
+  },
+  {
+    "end_line": 7423,
+    "section": "Links",
+    "html": "<p><a href=\"/url\" title=\"title &quot;&quot;\">link</a></p>\n",
+    "markdown": "[link](/url \"title \\\"&quot;\")\n",
+    "example": 477,
+    "start_line": 7419
+  },
+  {
+    "end_line": 7433,
+    "section": "Links",
+    "html": "<p><a href=\"/url%C2%A0%22title%22\">link</a></p>\n",
+    "markdown": "[link](/url \"title\")\n",
+    "example": 478,
+    "start_line": 7429
+  },
+  {
+    "end_line": 7442,
+    "section": "Links",
+    "html": "<p>[link](/url &quot;title &quot;and&quot; title&quot;)</p>\n",
+    "markdown": "[link](/url \"title \"and\" title\")\n",
+    "example": 479,
+    "start_line": 7438
+  },
+  {
+    "end_line": 7451,
+    "section": "Links",
+    "html": "<p><a href=\"/url\" title=\"title &quot;and&quot; title\">link</a></p>\n",
+    "markdown": "[link](/url 'title \"and\" title')\n",
+    "example": 480,
+    "start_line": 7447
+  },
+  {
+    "end_line": 7476,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\" title=\"title\">link</a></p>\n",
+    "markdown": "[link](   /uri\n  \"title\"  )\n",
+    "example": 481,
+    "start_line": 7471
+  },
+  {
+    "end_line": 7486,
+    "section": "Links",
+    "html": "<p>[link] (/uri)</p>\n",
+    "markdown": "[link] (/uri)\n",
+    "example": 482,
+    "start_line": 7482
+  },
+  {
+    "end_line": 7496,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\">link [foo [bar]]</a></p>\n",
+    "markdown": "[link [foo [bar]]](/uri)\n",
+    "example": 483,
+    "start_line": 7492
+  },
+  {
+    "end_line": 7503,
+    "section": "Links",
+    "html": "<p>[link] bar](/uri)</p>\n",
+    "markdown": "[link] bar](/uri)\n",
+    "example": 484,
+    "start_line": 7499
+  },
+  {
+    "end_line": 7510,
+    "section": "Links",
+    "html": "<p>[link <a href=\"/uri\">bar</a></p>\n",
+    "markdown": "[link [bar](/uri)\n",
+    "example": 485,
+    "start_line": 7506
+  },
+  {
+    "end_line": 7517,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\">link [bar</a></p>\n",
+    "markdown": "[link \\[bar](/uri)\n",
+    "example": 486,
+    "start_line": 7513
+  },
+  {
+    "end_line": 7526,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>\n",
+    "markdown": "[link *foo **bar** `#`*](/uri)\n",
+    "example": 487,
+    "start_line": 7522
+  },
+  {
+    "end_line": 7533,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\"><img src=\"moon.jpg\" alt=\"moon\" /></a></p>\n",
+    "markdown": "[![moon](moon.jpg)](/uri)\n",
+    "example": 488,
+    "start_line": 7529
+  },
+  {
+    "end_line": 7542,
+    "section": "Links",
+    "html": "<p>[foo <a href=\"/uri\">bar</a>](/uri)</p>\n",
+    "markdown": "[foo [bar](/uri)](/uri)\n",
+    "example": 489,
+    "start_line": 7538
+  },
+  {
+    "end_line": 7549,
+    "section": "Links",
+    "html": "<p>[foo <em>[bar <a href=\"/uri\">baz</a>](/uri)</em>](/uri)</p>\n",
+    "markdown": "[foo *[bar [baz](/uri)](/uri)*](/uri)\n",
+    "example": 490,
+    "start_line": 7545
+  },
+  {
+    "end_line": 7556,
+    "section": "Links",
+    "html": "<p><img src=\"uri3\" alt=\"[foo](uri2)\" /></p>\n",
+    "markdown": "![[[foo](uri1)](uri2)](uri3)\n",
+    "example": 491,
+    "start_line": 7552
+  },
+  {
+    "end_line": 7566,
+    "section": "Links",
+    "html": "<p>*<a href=\"/uri\">foo*</a></p>\n",
+    "markdown": "*[foo*](/uri)\n",
+    "example": 492,
+    "start_line": 7562
+  },
+  {
+    "end_line": 7573,
+    "section": "Links",
+    "html": "<p><a href=\"baz*\">foo *bar</a></p>\n",
+    "markdown": "[foo *bar](baz*)\n",
+    "example": 493,
+    "start_line": 7569
+  },
+  {
+    "end_line": 7583,
+    "section": "Links",
+    "html": "<p><em>foo [bar</em> baz]</p>\n",
+    "markdown": "*foo [bar* baz]\n",
+    "example": 494,
+    "start_line": 7579
+  },
+  {
+    "end_line": 7593,
+    "section": "Links",
+    "html": "<p>[foo <bar attr=\"](baz)\"></p>\n",
+    "markdown": "[foo <bar attr=\"](baz)\">\n",
+    "example": 495,
+    "start_line": 7589
+  },
+  {
+    "end_line": 7600,
+    "section": "Links",
+    "html": "<p>[foo<code>](/uri)</code></p>\n",
+    "markdown": "[foo`](/uri)`\n",
+    "example": 496,
+    "start_line": 7596
+  },
+  {
+    "end_line": 7607,
+    "section": "Links",
+    "html": "<p>[foo<a href=\"http://example.com/?search=%5D(uri)\">http://example.com/?search=](uri)</a></p>\n",
+    "markdown": "[foo<http://example.com/?search=](uri)>\n",
+    "example": 497,
+    "start_line": 7603
+  },
+  {
+    "end_line": 7647,
+    "section": "Links",
+    "html": "<p><a href=\"/url\" title=\"title\">foo</a></p>\n",
+    "markdown": "[foo][bar]\n\n[bar]: /url \"title\"\n",
+    "example": 498,
+    "start_line": 7641
+  },
+  {
+    "end_line": 7662,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\">link [foo [bar]]</a></p>\n",
+    "markdown": "[link [foo [bar]]][ref]\n\n[ref]: /uri\n",
+    "example": 499,
+    "start_line": 7656
+  },
+  {
+    "end_line": 7671,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\">link [bar</a></p>\n",
+    "markdown": "[link \\[bar][ref]\n\n[ref]: /uri\n",
+    "example": 500,
+    "start_line": 7665
+  },
+  {
+    "end_line": 7682,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>\n",
+    "markdown": "[link *foo **bar** `#`*][ref]\n\n[ref]: /uri\n",
+    "example": 501,
+    "start_line": 7676
+  },
+  {
+    "end_line": 7691,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\"><img src=\"moon.jpg\" alt=\"moon\" /></a></p>\n",
+    "markdown": "[![moon](moon.jpg)][ref]\n\n[ref]: /uri\n",
+    "example": 502,
+    "start_line": 7685
+  },
+  {
+    "end_line": 7702,
+    "section": "Links",
+    "html": "<p>[foo <a href=\"/uri\">bar</a>]<a href=\"/uri\">ref</a></p>\n",
+    "markdown": "[foo [bar](/uri)][ref]\n\n[ref]: /uri\n",
+    "example": 503,
+    "start_line": 7696
+  },
+  {
+    "end_line": 7711,
+    "section": "Links",
+    "html": "<p>[foo <em>bar <a href=\"/uri\">baz</a></em>]<a href=\"/uri\">ref</a></p>\n",
+    "markdown": "[foo *bar [baz][ref]*][ref]\n\n[ref]: /uri\n",
+    "example": 504,
+    "start_line": 7705
+  },
+  {
+    "end_line": 7726,
+    "section": "Links",
+    "html": "<p>*<a href=\"/uri\">foo*</a></p>\n",
+    "markdown": "*[foo*][ref]\n\n[ref]: /uri\n",
+    "example": 505,
+    "start_line": 7720
+  },
+  {
+    "end_line": 7735,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\">foo *bar</a></p>\n",
+    "markdown": "[foo *bar][ref]\n\n[ref]: /uri\n",
+    "example": 506,
+    "start_line": 7729
+  },
+  {
+    "end_line": 7747,
+    "section": "Links",
+    "html": "<p>[foo <bar attr=\"][ref]\"></p>\n",
+    "markdown": "[foo <bar attr=\"][ref]\">\n\n[ref]: /uri\n",
+    "example": 507,
+    "start_line": 7741
+  },
+  {
+    "end_line": 7756,
+    "section": "Links",
+    "html": "<p>[foo<code>][ref]</code></p>\n",
+    "markdown": "[foo`][ref]`\n\n[ref]: /uri\n",
+    "example": 508,
+    "start_line": 7750
+  },
+  {
+    "end_line": 7765,
+    "section": "Links",
+    "html": "<p>[foo<a href=\"http://example.com/?search=%5D%5Bref%5D\">http://example.com/?search=][ref]</a></p>\n",
+    "markdown": "[foo<http://example.com/?search=][ref]>\n\n[ref]: /uri\n",
+    "example": 509,
+    "start_line": 7759
+  },
+  {
+    "end_line": 7776,
+    "section": "Links",
+    "html": "<p><a href=\"/url\" title=\"title\">foo</a></p>\n",
+    "markdown": "[foo][BaR]\n\n[bar]: /url \"title\"\n",
+    "example": 510,
+    "start_line": 7770
+  },
+  {
+    "end_line": 7787,
+    "section": "Links",
+    "html": "<p><a href=\"/url\">Толпой</a> is a Russian word.</p>\n",
+    "markdown": "[Толпой][Толпой] is a Russian word.\n\n[ТОЛПОЙ]: /url\n",
+    "example": 511,
+    "start_line": 7781
+  },
+  {
+    "end_line": 7800,
+    "section": "Links",
+    "html": "<p><a href=\"/url\">Baz</a></p>\n",
+    "markdown": "[Foo\n  bar]: /url\n\n[Baz][Foo bar]\n",
+    "example": 512,
+    "start_line": 7793
+  },
+  {
+    "end_line": 7812,
+    "section": "Links",
+    "html": "<p>[foo] <a href=\"/url\" title=\"title\">bar</a></p>\n",
+    "markdown": "[foo] [bar]\n\n[bar]: /url \"title\"\n",
+    "example": 513,
+    "start_line": 7806
+  },
+  {
+    "end_line": 7823,
+    "section": "Links",
+    "html": "<p>[foo]\n<a href=\"/url\" title=\"title\">bar</a></p>\n",
+    "markdown": "[foo]\n[bar]\n\n[bar]: /url \"title\"\n",
+    "example": 514,
+    "start_line": 7815
+  },
+  {
+    "end_line": 7864,
+    "section": "Links",
+    "html": "<p><a href=\"/url1\">bar</a></p>\n",
+    "markdown": "[foo]: /url1\n\n[foo]: /url2\n\n[bar][foo]\n",
+    "example": 515,
+    "start_line": 7856
+  },
+  {
+    "end_line": 7877,
+    "section": "Links",
+    "html": "<p>[bar][foo!]</p>\n",
+    "markdown": "[bar][foo\\!]\n\n[foo!]: /url\n",
+    "example": 516,
+    "start_line": 7871
+  },
+  {
+    "end_line": 7890,
+    "section": "Links",
+    "html": "<p>[foo][ref[]</p>\n<p>[ref[]: /uri</p>\n",
+    "markdown": "[foo][ref[]\n\n[ref[]: /uri\n",
+    "example": 517,
+    "start_line": 7883
+  },
+  {
+    "end_line": 7900,
+    "section": "Links",
+    "html": "<p>[foo][ref[bar]]</p>\n<p>[ref[bar]]: /uri</p>\n",
+    "markdown": "[foo][ref[bar]]\n\n[ref[bar]]: /uri\n",
+    "example": 518,
+    "start_line": 7893
+  },
+  {
+    "end_line": 7910,
+    "section": "Links",
+    "html": "<p>[[[foo]]]</p>\n<p>[[[foo]]]: /url</p>\n",
+    "markdown": "[[[foo]]]\n\n[[[foo]]]: /url\n",
+    "example": 519,
+    "start_line": 7903
+  },
+  {
+    "end_line": 7919,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\">foo</a></p>\n",
+    "markdown": "[foo][ref\\[]\n\n[ref\\[]: /uri\n",
+    "example": 520,
+    "start_line": 7913
+  },
+  {
+    "end_line": 7930,
+    "section": "Links",
+    "html": "<p><a href=\"/uri\">bar\\</a></p>\n",
+    "markdown": "[bar\\\\]: /uri\n\n[bar\\\\]\n",
+    "example": 521,
+    "start_line": 7924
+  },
+  {
+    "end_line": 7942,
+    "section": "Links",
+    "html": "<p>[]</p>\n<p>[]: /uri</p>\n",
+    "markdown": "[]\n\n[]: /uri\n",
+    "example": 522,
+    "start_line": 7935
+  },
+  {
+    "end_line": 7956,
+    "section": "Links",
+    "html": "<p>[\n]</p>\n<p>[\n]: /uri</p>\n",
+    "markdown": "[\n ]\n\n[\n ]: /uri\n",
+    "example": 523,
+    "start_line": 7945
+  },
+  {
+    "end_line": 7974,
+    "section": "Links",
+    "html": "<p><a href=\"/url\" title=\"title\">foo</a></p>\n",
+    "markdown": "[foo][]\n\n[foo]: /url \"title\"\n",
+    "example": 524,
+    "start_line": 7968
+  },
+  {
+    "end_line": 7983,
+    "section": "Links",
+    "html": "<p><a href=\"/url\" title=\"title\"><em>foo</em> bar</a></p>\n",
+    "markdown": "[*foo* bar][]\n\n[*foo* bar]: /url \"title\"\n",
+    "example": 525,
+    "start_line": 7977
+  },
+  {
+    "end_line": 7994,
+    "section": "Links",
+    "html": "<p><a href=\"/url\" title=\"title\">Foo</a></p>\n",
+    "markdown": "[Foo][]\n\n[foo]: /url \"title\"\n",
+    "example": 526,
+    "start_line": 7988
+  },
+  {
+    "end_line": 8009,
+    "section": "Links",
+    "html": "<p><a href=\"/url\" title=\"title\">foo</a>\n[]</p>\n",
+    "markdown": "[foo] \n[]\n\n[foo]: /url \"title\"\n",
+    "example": 527,
+    "start_line": 8001
+  },
+  {
+    "end_line": 8027,
+    "section": "Links",
+    "html": "<p><a href=\"/url\" title=\"title\">foo</a></p>\n",
+    "markdown": "[foo]\n\n[foo]: /url \"title\"\n",
+    "example": 528,
+    "start_line": 8021
+  },
+  {
+    "end_line": 8036,
+    "section": "Links",
+    "html": "<p><a href=\"/url\" title=\"title\"><em>foo</em> bar</a></p>\n",
+    "markdown": "[*foo* bar]\n\n[*foo* bar]: /url \"title\"\n",
+    "example": 529,
+    "start_line": 8030
+  },
+  {
+    "end_line": 8045,
+    "section": "Links",
+    "html": "<p>[<a href=\"/url\" title=\"title\"><em>foo</em> bar</a>]</p>\n",
+    "markdown": "[[*foo* bar]]\n\n[*foo* bar]: /url \"title\"\n",
+    "example": 530,
+    "start_line": 8039
+  },
+  {
+    "end_line": 8054,
+    "section": "Links",
+    "html": "<p>[[bar <a href=\"/url\">foo</a></p>\n",
+    "markdown": "[[bar [foo]\n\n[foo]: /url\n",
+    "example": 531,
+    "start_line": 8048
+  },
+  {
+    "end_line": 8065,
+    "section": "Links",
+    "html": "<p><a href=\"/url\" title=\"title\">Foo</a></p>\n",
+    "markdown": "[Foo]\n\n[foo]: /url \"title\"\n",
+    "example": 532,
+    "start_line": 8059
+  },
+  {
+    "end_line": 8076,
+    "section": "Links",
+    "html": "<p><a href=\"/url\">foo</a> bar</p>\n",
+    "markdown": "[foo] bar\n\n[foo]: /url\n",
+    "example": 533,
+    "start_line": 8070
+  },
+  {
+    "end_line": 8088,
+    "section": "Links",
+    "html": "<p>[foo]</p>\n",
+    "markdown": "\\[foo]\n\n[foo]: /url \"title\"\n",
+    "example": 534,
+    "start_line": 8082
+  },
+  {
+    "end_line": 8100,
+    "section": "Links",
+    "html": "<p>*<a href=\"/url\">foo*</a></p>\n",
+    "markdown": "[foo*]: /url\n\n*[foo*]\n",
+    "example": 535,
+    "start_line": 8094
+  },
+  {
+    "end_line": 8113,
+    "section": "Links",
+    "html": "<p><a href=\"/url2\">foo</a></p>\n",
+    "markdown": "[foo][bar]\n\n[foo]: /url1\n[bar]: /url2\n",
+    "example": 536,
+    "start_line": 8106
+  },
+  {
+    "end_line": 8121,
+    "section": "Links",
+    "html": "<p><a href=\"/url1\">foo</a></p>\n",
+    "markdown": "[foo][]\n\n[foo]: /url1\n",
+    "example": 537,
+    "start_line": 8115
+  },
+  {
+    "end_line": 8131,
+    "section": "Links",
+    "html": "<p><a href=\"\">foo</a></p>\n",
+    "markdown": "[foo]()\n\n[foo]: /url1\n",
+    "example": 538,
+    "start_line": 8125
+  },
+  {
+    "end_line": 8139,
+    "section": "Links",
+    "html": "<p><a href=\"/url1\">foo</a>(not a link)</p>\n",
+    "markdown": "[foo](not a link)\n\n[foo]: /url1\n",
+    "example": 539,
+    "start_line": 8133
+  },
+  {
+    "end_line": 8150,
+    "section": "Links",
+    "html": "<p>[foo]<a href=\"/url\">bar</a></p>\n",
+    "markdown": "[foo][bar][baz]\n\n[baz]: /url\n",
+    "example": 540,
+    "start_line": 8144
+  },
+  {
+    "end_line": 8163,
+    "section": "Links",
+    "html": "<p><a href=\"/url2\">foo</a><a href=\"/url1\">baz</a></p>\n",
+    "markdown": "[foo][bar][baz]\n\n[baz]: /url1\n[bar]: /url2\n",
+    "example": 541,
+    "start_line": 8156
+  },
+  {
+    "end_line": 8176,
+    "section": "Links",
+    "html": "<p>[foo]<a href=\"/url1\">bar</a></p>\n",
+    "markdown": "[foo][bar][baz]\n\n[baz]: /url1\n[foo]: /url2\n",
+    "example": 542,
+    "start_line": 8169
+  },
+  {
+    "end_line": 8196,
+    "section": "Images",
+    "html": "<p><img src=\"/url\" alt=\"foo\" title=\"title\" /></p>\n",
+    "markdown": "![foo](/url \"title\")\n",
+    "example": 543,
+    "start_line": 8192
+  },
+  {
+    "end_line": 8205,
+    "section": "Images",
+    "html": "<p><img src=\"train.jpg\" alt=\"foo bar\" title=\"train &amp; tracks\" /></p>\n",
+    "markdown": "![foo *bar*]\n\n[foo *bar*]: train.jpg \"train & tracks\"\n",
+    "example": 544,
+    "start_line": 8199
+  },
+  {
+    "end_line": 8212,
+    "section": "Images",
+    "html": "<p><img src=\"/url2\" alt=\"foo bar\" /></p>\n",
+    "markdown": "![foo ![bar](/url)](/url2)\n",
+    "example": 545,
+    "start_line": 8208
+  },
+  {
+    "end_line": 8219,
+    "section": "Images",
+    "html": "<p><img src=\"/url2\" alt=\"foo bar\" /></p>\n",
+    "markdown": "![foo [bar](/url)](/url2)\n",
+    "example": 546,
+    "start_line": 8215
+  },
+  {
+    "end_line": 8235,
+    "section": "Images",
+    "html": "<p><img src=\"train.jpg\" alt=\"foo bar\" title=\"train &amp; tracks\" /></p>\n",
+    "markdown": "![foo *bar*][]\n\n[foo *bar*]: train.jpg \"train & tracks\"\n",
+    "example": 547,
+    "start_line": 8229
+  },
+  {
+    "end_line": 8244,
+    "section": "Images",
+    "html": "<p><img src=\"train.jpg\" alt=\"foo bar\" title=\"train &amp; tracks\" /></p>\n",
+    "markdown": "![foo *bar*][foobar]\n\n[FOOBAR]: train.jpg \"train & tracks\"\n",
+    "example": 548,
+    "start_line": 8238
+  },
+  {
+    "end_line": 8251,
+    "section": "Images",
+    "html": "<p><img src=\"train.jpg\" alt=\"foo\" /></p>\n",
+    "markdown": "![foo](train.jpg)\n",
+    "example": 549,
+    "start_line": 8247
+  },
+  {
+    "end_line": 8258,
+    "section": "Images",
+    "html": "<p>My <img src=\"/path/to/train.jpg\" alt=\"foo bar\" title=\"title\" /></p>\n",
+    "markdown": "My ![foo bar](/path/to/train.jpg  \"title\"   )\n",
+    "example": 550,
+    "start_line": 8254
+  },
+  {
+    "end_line": 8265,
+    "section": "Images",
+    "html": "<p><img src=\"url\" alt=\"foo\" /></p>\n",
+    "markdown": "![foo](<url>)\n",
+    "example": 551,
+    "start_line": 8261
+  },
+  {
+    "end_line": 8272,
+    "section": "Images",
+    "html": "<p><img src=\"/url\" alt=\"\" /></p>\n",
+    "markdown": "![](/url)\n",
+    "example": 552,
+    "start_line": 8268
+  },
+  {
+    "end_line": 8283,
+    "section": "Images",
+    "html": "<p><img src=\"/url\" alt=\"foo\" /></p>\n",
+    "markdown": "![foo][bar]\n\n[bar]: /url\n",
+    "example": 553,
+    "start_line": 8277
+  },
+  {
+    "end_line": 8292,
+    "section": "Images",
+    "html": "<p><img src=\"/url\" alt=\"foo\" /></p>\n",
+    "markdown": "![foo][bar]\n\n[BAR]: /url\n",
+    "example": 554,
+    "start_line": 8286
+  },
+  {
+    "end_line": 8303,
+    "section": "Images",
+    "html": "<p><img src=\"/url\" alt=\"foo\" title=\"title\" /></p>\n",
+    "markdown": "![foo][]\n\n[foo]: /url \"title\"\n",
+    "example": 555,
+    "start_line": 8297
+  },
+  {
+    "end_line": 8312,
+    "section": "Images",
+    "html": "<p><img src=\"/url\" alt=\"foo bar\" title=\"title\" /></p>\n",
+    "markdown": "![*foo* bar][]\n\n[*foo* bar]: /url \"title\"\n",
+    "example": 556,
+    "start_line": 8306
+  },
+  {
+    "end_line": 8323,
+    "section": "Images",
+    "html": "<p><img src=\"/url\" alt=\"Foo\" title=\"title\" /></p>\n",
+    "markdown": "![Foo][]\n\n[foo]: /url \"title\"\n",
+    "example": 557,
+    "start_line": 8317
+  },
+  {
+    "end_line": 8337,
+    "section": "Images",
+    "html": "<p><img src=\"/url\" alt=\"foo\" title=\"title\" />\n[]</p>\n",
+    "markdown": "![foo] \n[]\n\n[foo]: /url \"title\"\n",
+    "example": 558,
+    "start_line": 8329
+  },
+  {
+    "end_line": 8348,
+    "section": "Images",
+    "html": "<p><img src=\"/url\" alt=\"foo\" title=\"title\" /></p>\n",
+    "markdown": "![foo]\n\n[foo]: /url \"title\"\n",
+    "example": 559,
+    "start_line": 8342
+  },
+  {
+    "end_line": 8357,
+    "section": "Images",
+    "html": "<p><img src=\"/url\" alt=\"foo bar\" title=\"title\" /></p>\n",
+    "markdown": "![*foo* bar]\n\n[*foo* bar]: /url \"title\"\n",
+    "example": 560,
+    "start_line": 8351
+  },
+  {
+    "end_line": 8369,
+    "section": "Images",
+    "html": "<p>![[foo]]</p>\n<p>[[foo]]: /url &quot;title&quot;</p>\n",
+    "markdown": "![[foo]]\n\n[[foo]]: /url \"title\"\n",
+    "example": 561,
+    "start_line": 8362
+  },
+  {
+    "end_line": 8380,
+    "section": "Images",
+    "html": "<p><img src=\"/url\" alt=\"Foo\" title=\"title\" /></p>\n",
+    "markdown": "![Foo]\n\n[foo]: /url \"title\"\n",
+    "example": 562,
+    "start_line": 8374
+  },
+  {
+    "end_line": 8392,
+    "section": "Images",
+    "html": "<p>![foo]</p>\n",
+    "markdown": "!\\[foo]\n\n[foo]: /url \"title\"\n",
+    "example": 563,
+    "start_line": 8386
+  },
+  {
+    "end_line": 8404,
+    "section": "Images",
+    "html": "<p>!<a href=\"/url\" title=\"title\">foo</a></p>\n",
+    "markdown": "\\![foo]\n\n[foo]: /url \"title\"\n",
+    "example": 564,
+    "start_line": 8398
+  },
+  {
+    "end_line": 8435,
+    "section": "Autolinks",
+    "html": "<p><a href=\"http://foo.bar.baz\">http://foo.bar.baz</a></p>\n",
+    "markdown": "<http://foo.bar.baz>\n",
+    "example": 565,
+    "start_line": 8431
+  },
+  {
+    "end_line": 8442,
+    "section": "Autolinks",
+    "html": "<p><a href=\"http://foo.bar.baz/test?q=hello&amp;id=22&amp;boolean\">http://foo.bar.baz/test?q=hello&amp;id=22&amp;boolean</a></p>\n",
+    "markdown": "<http://foo.bar.baz/test?q=hello&id=22&boolean>\n",
+    "example": 566,
+    "start_line": 8438
+  },
+  {
+    "end_line": 8449,
+    "section": "Autolinks",
+    "html": "<p><a href=\"irc://foo.bar:2233/baz\">irc://foo.bar:2233/baz</a></p>\n",
+    "markdown": "<irc://foo.bar:2233/baz>\n",
+    "example": 567,
+    "start_line": 8445
+  },
+  {
+    "end_line": 8458,
+    "section": "Autolinks",
+    "html": "<p><a href=\"MAILTO:FOO@BAR.BAZ\">MAILTO:FOO@BAR.BAZ</a></p>\n",
+    "markdown": "<MAILTO:FOO@BAR.BAZ>\n",
+    "example": 568,
+    "start_line": 8454
+  },
+  {
+    "end_line": 8470,
+    "section": "Autolinks",
+    "html": "<p><a href=\"a+b+c:d\">a+b+c:d</a></p>\n",
+    "markdown": "<a+b+c:d>\n",
+    "example": 569,
+    "start_line": 8466
+  },
+  {
+    "end_line": 8477,
+    "section": "Autolinks",
+    "html": "<p><a href=\"made-up-scheme://foo,bar\">made-up-scheme://foo,bar</a></p>\n",
+    "markdown": "<made-up-scheme://foo,bar>\n",
+    "example": 570,
+    "start_line": 8473
+  },
+  {
+    "end_line": 8484,
+    "section": "Autolinks",
+    "html": "<p><a href=\"http://../\">http://../</a></p>\n",
+    "markdown": "<http://../>\n",
+    "example": 571,
+    "start_line": 8480
+  },
+  {
+    "end_line": 8491,
+    "section": "Autolinks",
+    "html": "<p><a href=\"localhost:5001/foo\">localhost:5001/foo</a></p>\n",
+    "markdown": "<localhost:5001/foo>\n",
+    "example": 572,
+    "start_line": 8487
+  },
+  {
+    "end_line": 8500,
+    "section": "Autolinks",
+    "html": "<p>&lt;http://foo.bar/baz bim&gt;</p>\n",
+    "markdown": "<http://foo.bar/baz bim>\n",
+    "example": 573,
+    "start_line": 8496
+  },
+  {
+    "end_line": 8509,
+    "section": "Autolinks",
+    "html": "<p><a href=\"http://example.com/%5C%5B%5C\">http://example.com/\\[\\</a></p>\n",
+    "markdown": "<http://example.com/\\[\\>\n",
+    "example": 574,
+    "start_line": 8505
+  },
+  {
+    "end_line": 8531,
+    "section": "Autolinks",
+    "html": "<p><a href=\"mailto:foo@bar.example.com\">foo@bar.example.com</a></p>\n",
+    "markdown": "<foo@bar.example.com>\n",
+    "example": 575,
+    "start_line": 8527
+  },
+  {
+    "end_line": 8538,
+    "section": "Autolinks",
+    "html": "<p><a href=\"mailto:foo+special@Bar.baz-bar0.com\">foo+special@Bar.baz-bar0.com</a></p>\n",
+    "markdown": "<foo+special@Bar.baz-bar0.com>\n",
+    "example": 576,
+    "start_line": 8534
+  },
+  {
+    "end_line": 8547,
+    "section": "Autolinks",
+    "html": "<p>&lt;foo+@bar.example.com&gt;</p>\n",
+    "markdown": "<foo\\+@bar.example.com>\n",
+    "example": 577,
+    "start_line": 8543
+  },
+  {
+    "end_line": 8556,
+    "section": "Autolinks",
+    "html": "<p>&lt;&gt;</p>\n",
+    "markdown": "<>\n",
+    "example": 578,
+    "start_line": 8552
+  },
+  {
+    "end_line": 8563,
+    "section": "Autolinks",
+    "html": "<p>&lt; http://foo.bar &gt;</p>\n",
+    "markdown": "< http://foo.bar >\n",
+    "example": 579,
+    "start_line": 8559
+  },
+  {
+    "end_line": 8570,
+    "section": "Autolinks",
+    "html": "<p>&lt;m:abc&gt;</p>\n",
+    "markdown": "<m:abc>\n",
+    "example": 580,
+    "start_line": 8566
+  },
+  {
+    "end_line": 8577,
+    "section": "Autolinks",
+    "html": "<p>&lt;foo.bar.baz&gt;</p>\n",
+    "markdown": "<foo.bar.baz>\n",
+    "example": 581,
+    "start_line": 8573
+  },
+  {
+    "end_line": 8584,
+    "section": "Autolinks",
+    "html": "<p>http://example.com</p>\n",
+    "markdown": "http://example.com\n",
+    "example": 582,
+    "start_line": 8580
+  },
+  {
+    "end_line": 8591,
+    "section": "Autolinks",
+    "html": "<p>foo@bar.example.com</p>\n",
+    "markdown": "foo@bar.example.com\n",
+    "example": 583,
+    "start_line": 8587
+  },
+  {
+    "end_line": 8673,
+    "section": "Raw HTML",
+    "html": "<p><a><bab><c2c></p>\n",
+    "markdown": "<a><bab><c2c>\n",
+    "example": 584,
+    "start_line": 8669
+  },
+  {
+    "end_line": 8682,
+    "section": "Raw HTML",
+    "html": "<p><a/><b2/></p>\n",
+    "markdown": "<a/><b2/>\n",
+    "example": 585,
+    "start_line": 8678
+  },
+  {
+    "end_line": 8693,
+    "section": "Raw HTML",
+    "html": "<p><a  /><b2\ndata=\"foo\" ></p>\n",
+    "markdown": "<a  /><b2\ndata=\"foo\" >\n",
+    "example": 586,
+    "start_line": 8687
+  },
+  {
+    "end_line": 8704,
+    "section": "Raw HTML",
+    "html": "<p><a foo=\"bar\" bam = 'baz <em>\"</em>'\n_boolean zoop:33=zoop:33 /></p>\n",
+    "markdown": "<a foo=\"bar\" bam = 'baz <em>\"</em>'\n_boolean zoop:33=zoop:33 />\n",
+    "example": 587,
+    "start_line": 8698
+  },
+  {
+    "end_line": 8713,
+    "section": "Raw HTML",
+    "html": "<p>Foo <responsive-image src=\"foo.jpg\" /></p>\n",
+    "markdown": "Foo <responsive-image src=\"foo.jpg\" />\n",
+    "example": 588,
+    "start_line": 8709
+  },
+  {
+    "end_line": 8722,
+    "section": "Raw HTML",
+    "html": "<p>&lt;33&gt; &lt;__&gt;</p>\n",
+    "markdown": "<33> <__>\n",
+    "example": 589,
+    "start_line": 8718
+  },
+  {
+    "end_line": 8731,
+    "section": "Raw HTML",
+    "html": "<p>&lt;a h*#ref=&quot;hi&quot;&gt;</p>\n",
+    "markdown": "<a h*#ref=\"hi\">\n",
+    "example": 590,
+    "start_line": 8727
+  },
+  {
+    "end_line": 8740,
+    "section": "Raw HTML",
+    "html": "<p>&lt;a href=&quot;hi'&gt; &lt;a href=hi'&gt;</p>\n",
+    "markdown": "<a href=\"hi'> <a href=hi'>\n",
+    "example": 591,
+    "start_line": 8736
+  },
+  {
+    "end_line": 8751,
+    "section": "Raw HTML",
+    "html": "<p>&lt; a&gt;&lt;\nfoo&gt;&lt;bar/ &gt;</p>\n",
+    "markdown": "< a><\nfoo><bar/ >\n",
+    "example": 592,
+    "start_line": 8745
+  },
+  {
+    "end_line": 8760,
+    "section": "Raw HTML",
+    "html": "<p>&lt;a href='bar'title=title&gt;</p>\n",
+    "markdown": "<a href='bar'title=title>\n",
+    "example": 593,
+    "start_line": 8756
+  },
+  {
+    "end_line": 8769,
+    "section": "Raw HTML",
+    "html": "<p></a></foo ></p>\n",
+    "markdown": "</a></foo >\n",
+    "example": 594,
+    "start_line": 8765
+  },
+  {
+    "end_line": 8778,
+    "section": "Raw HTML",
+    "html": "<p>&lt;/a href=&quot;foo&quot;&gt;</p>\n",
+    "markdown": "</a href=\"foo\">\n",
+    "example": 595,
+    "start_line": 8774
+  },
+  {
+    "end_line": 8789,
+    "section": "Raw HTML",
+    "html": "<p>foo <!-- this is a\ncomment - with hyphen --></p>\n",
+    "markdown": "foo <!-- this is a\ncomment - with hyphen -->\n",
+    "example": 596,
+    "start_line": 8783
+  },
+  {
+    "end_line": 8796,
+    "section": "Raw HTML",
+    "html": "<p>foo &lt;!-- not a comment -- two hyphens --&gt;</p>\n",
+    "markdown": "foo <!-- not a comment -- two hyphens -->\n",
+    "example": 597,
+    "start_line": 8792
+  },
+  {
+    "end_line": 8808,
+    "section": "Raw HTML",
+    "html": "<p>foo &lt;!--&gt; foo --&gt;</p>\n<p>foo &lt;!-- foo---&gt;</p>\n",
+    "markdown": "foo <!--> foo -->\n\nfoo <!-- foo--->\n",
+    "example": 598,
+    "start_line": 8801
+  },
+  {
+    "end_line": 8817,
+    "section": "Raw HTML",
+    "html": "<p>foo <?php echo $a; ?></p>\n",
+    "markdown": "foo <?php echo $a; ?>\n",
+    "example": 599,
+    "start_line": 8813
+  },
+  {
+    "end_line": 8826,
+    "section": "Raw HTML",
+    "html": "<p>foo <!ELEMENT br EMPTY></p>\n",
+    "markdown": "foo <!ELEMENT br EMPTY>\n",
+    "example": 600,
+    "start_line": 8822
+  },
+  {
+    "end_line": 8835,
+    "section": "Raw HTML",
+    "html": "<p>foo <![CDATA[>&<]]></p>\n",
+    "markdown": "foo <![CDATA[>&<]]>\n",
+    "example": 601,
+    "start_line": 8831
+  },
+  {
+    "end_line": 8845,
+    "section": "Raw HTML",
+    "html": "<p>foo <a href=\"&ouml;\"></p>\n",
+    "markdown": "foo <a href=\"&ouml;\">\n",
+    "example": 602,
+    "start_line": 8841
+  },
+  {
+    "end_line": 8854,
+    "section": "Raw HTML",
+    "html": "<p>foo <a href=\"\\*\"></p>\n",
+    "markdown": "foo <a href=\"\\*\">\n",
+    "example": 603,
+    "start_line": 8850
+  },
+  {
+    "end_line": 8861,
+    "section": "Raw HTML",
+    "html": "<p>&lt;a href=&quot;&quot;&quot;&gt;</p>\n",
+    "markdown": "<a href=\"\\\"\">\n",
+    "example": 604,
+    "start_line": 8857
+  },
+  {
+    "end_line": 8877,
+    "section": "Hard line breaks",
+    "html": "<p>foo<br />\nbaz</p>\n",
+    "markdown": "foo  \nbaz\n",
+    "example": 605,
+    "start_line": 8871
+  },
+  {
+    "end_line": 8889,
+    "section": "Hard line breaks",
+    "html": "<p>foo<br />\nbaz</p>\n",
+    "markdown": "foo\\\nbaz\n",
+    "example": 606,
+    "start_line": 8883
+  },
+  {
+    "end_line": 8900,
+    "section": "Hard line breaks",
+    "html": "<p>foo<br />\nbaz</p>\n",
+    "markdown": "foo       \nbaz\n",
+    "example": 607,
+    "start_line": 8894
+  },
+  {
+    "end_line": 8911,
+    "section": "Hard line breaks",
+    "html": "<p>foo<br />\nbar</p>\n",
+    "markdown": "foo  \n     bar\n",
+    "example": 608,
+    "start_line": 8905
+  },
+  {
+    "end_line": 8920,
+    "section": "Hard line breaks",
+    "html": "<p>foo<br />\nbar</p>\n",
+    "markdown": "foo\\\n     bar\n",
+    "example": 609,
+    "start_line": 8914
+  },
+  {
+    "end_line": 8932,
+    "section": "Hard line breaks",
+    "html": "<p><em>foo<br />\nbar</em></p>\n",
+    "markdown": "*foo  \nbar*\n",
+    "example": 610,
+    "start_line": 8926
+  },
+  {
+    "end_line": 8941,
+    "section": "Hard line breaks",
+    "html": "<p><em>foo<br />\nbar</em></p>\n",
+    "markdown": "*foo\\\nbar*\n",
+    "example": 611,
+    "start_line": 8935
+  },
+  {
+    "end_line": 8951,
+    "section": "Hard line breaks",
+    "html": "<p><code>code span</code></p>\n",
+    "markdown": "`code  \nspan`\n",
+    "example": 612,
+    "start_line": 8946
+  },
+  {
+    "end_line": 8959,
+    "section": "Hard line breaks",
+    "html": "<p><code>code\\ span</code></p>\n",
+    "markdown": "`code\\\nspan`\n",
+    "example": 613,
+    "start_line": 8954
+  },
+  {
+    "end_line": 8970,
+    "section": "Hard line breaks",
+    "html": "<p><a href=\"foo  \nbar\"></p>\n",
+    "markdown": "<a href=\"foo  \nbar\">\n",
+    "example": 614,
+    "start_line": 8964
+  },
+  {
+    "end_line": 8979,
+    "section": "Hard line breaks",
+    "html": "<p><a href=\"foo\\\nbar\"></p>\n",
+    "markdown": "<a href=\"foo\\\nbar\">\n",
+    "example": 615,
+    "start_line": 8973
+  },
+  {
+    "end_line": 8990,
+    "section": "Hard line breaks",
+    "html": "<p>foo\\</p>\n",
+    "markdown": "foo\\\n",
+    "example": 616,
+    "start_line": 8986
+  },
+  {
+    "end_line": 8997,
+    "section": "Hard line breaks",
+    "html": "<p>foo</p>\n",
+    "markdown": "foo  \n",
+    "example": 617,
+    "start_line": 8993
+  },
+  {
+    "end_line": 9004,
+    "section": "Hard line breaks",
+    "html": "<h3>foo\\</h3>\n",
+    "markdown": "### foo\\\n",
+    "example": 618,
+    "start_line": 9000
+  },
+  {
+    "end_line": 9011,
+    "section": "Hard line breaks",
+    "html": "<h3>foo</h3>\n",
+    "markdown": "### foo  \n",
+    "example": 619,
+    "start_line": 9007
+  },
+  {
+    "end_line": 9028,
+    "section": "Soft line breaks",
+    "html": "<p>foo\nbaz</p>\n",
+    "markdown": "foo\nbaz\n",
+    "example": 620,
+    "start_line": 9022
+  },
+  {
+    "end_line": 9040,
+    "section": "Soft line breaks",
+    "html": "<p>foo\nbaz</p>\n",
+    "markdown": "foo \n baz\n",
+    "example": 621,
+    "start_line": 9034
+  },
+  {
+    "end_line": 9058,
+    "section": "Textual content",
+    "html": "<p>hello $.;'there</p>\n",
+    "markdown": "hello $.;'there\n",
+    "example": 622,
+    "start_line": 9054
+  },
+  {
+    "end_line": 9065,
+    "section": "Textual content",
+    "html": "<p>Foo χρῆν</p>\n",
+    "markdown": "Foo χρῆν\n",
+    "example": 623,
+    "start_line": 9061
+  },
+  {
+    "end_line": 9074,
+    "section": "Textual content",
+    "html": "<p>Multiple     spaces</p>\n",
+    "markdown": "Multiple     spaces\n",
+    "example": 624,
+    "start_line": 9070
+  }
+]
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/spec/spec-0.28.txt b/vendor/gitlab.com/golang-commonmark/markdown/spec/spec-0.28.txt
new file mode 100644
index 000000000..9fd584139
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/spec/spec-0.28.txt
@@ -0,0 +1,9414 @@
+---
+title: CommonMark Spec
+author: John MacFarlane
+version: 0.28
+date: '2017-08-01'
+license: '[CC-BY-SA 4.0](http://creativecommons.org/licenses/by-sa/4.0/)'
+...
+
+# Introduction
+
+## What is Markdown?
+
+Markdown is a plain text format for writing structured documents,
+based on conventions for indicating formatting in email
+and usenet posts.  It was developed by John Gruber (with
+help from Aaron Swartz) and released in 2004 in the form of a
+[syntax description](http://daringfireball.net/projects/markdown/syntax)
+and a Perl script (`Markdown.pl`) for converting Markdown to
+HTML.  In the next decade, dozens of implementations were
+developed in many languages.  Some extended the original
+Markdown syntax with conventions for footnotes, tables, and
+other document elements.  Some allowed Markdown documents to be
+rendered in formats other than HTML.  Websites like Reddit,
+StackOverflow, and GitHub had millions of people using Markdown.
+And Markdown started to be used beyond the web, to author books,
+articles, slide shows, letters, and lecture notes.
+
+What distinguishes Markdown from many other lightweight markup
+syntaxes, which are often easier to write, is its readability.
+As Gruber writes:
+
+> The overriding design goal for Markdown's formatting syntax is
+> to make it as readable as possible. The idea is that a
+> Markdown-formatted document should be publishable as-is, as
+> plain text, without looking like it's been marked up with tags
+> or formatting instructions.
+> (<http://daringfireball.net/projects/markdown/>)
+
+The point can be illustrated by comparing a sample of
+[AsciiDoc](http://www.methods.co.nz/asciidoc/) with
+an equivalent sample of Markdown.  Here is a sample of
+AsciiDoc from the AsciiDoc manual:
+
+```
+1. List item one.
++
+List item one continued with a second paragraph followed by an
+Indented block.
++
+.................
+$ ls *.sh
+$ mv *.sh ~/tmp
+.................
++
+List item continued with a third paragraph.
+
+2. List item two continued with an open block.
++
+--
+This paragraph is part of the preceding list item.
+
+a. This list is nested and does not require explicit item
+continuation.
++
+This paragraph is part of the preceding list item.
+
+b. List item b.
+
+This paragraph belongs to item two of the outer list.
+--
+```
+
+And here is the equivalent in Markdown:
+```
+1.  List item one.
+
+    List item one continued with a second paragraph followed by an
+    Indented block.
+
+        $ ls *.sh
+        $ mv *.sh ~/tmp
+
+    List item continued with a third paragraph.
+
+2.  List item two continued with an open block.
+
+    This paragraph is part of the preceding list item.
+
+    1. This list is nested and does not require explicit item continuation.
+
+       This paragraph is part of the preceding list item.
+
+    2. List item b.
+
+    This paragraph belongs to item two of the outer list.
+```
+
+The AsciiDoc version is, arguably, easier to write. You don't need
+to worry about indentation.  But the Markdown version is much easier
+to read.  The nesting of list items is apparent to the eye in the
+source, not just in the processed document.
+
+## Why is a spec needed?
+
+John Gruber's [canonical description of Markdown's
+syntax](http://daringfireball.net/projects/markdown/syntax)
+does not specify the syntax unambiguously.  Here are some examples of
+questions it does not answer:
+
+1.  How much indentation is needed for a sublist?  The spec says that
+    continuation paragraphs need to be indented four spaces, but is
+    not fully explicit about sublists.  It is natural to think that
+    they, too, must be indented four spaces, but `Markdown.pl` does
+    not require that.  This is hardly a "corner case," and divergences
+    between implementations on this issue often lead to surprises for
+    users in real documents. (See [this comment by John
+    Gruber](http://article.gmane.org/gmane.text.markdown.general/1997).)
+
+2.  Is a blank line needed before a block quote or heading?
+    Most implementations do not require the blank line.  However,
+    this can lead to unexpected results in hard-wrapped text, and
+    also to ambiguities in parsing (note that some implementations
+    put the heading inside the blockquote, while others do not).
+    (John Gruber has also spoken [in favor of requiring the blank
+    lines](http://article.gmane.org/gmane.text.markdown.general/2146).)
+
+3.  Is a blank line needed before an indented code block?
+    (`Markdown.pl` requires it, but this is not mentioned in the
+    documentation, and some implementations do not require it.)
+
+    ``` markdown
+    paragraph
+        code?
+    ```
+
+4.  What is the exact rule for determining when list items get
+    wrapped in `<p>` tags?  Can a list be partially "loose" and partially
+    "tight"?  What should we do with a list like this?
+
+    ``` markdown
+    1. one
+
+    2. two
+    3. three
+    ```
+
+    Or this?
+
+    ``` markdown
+    1.  one
+        - a
+
+        - b
+    2.  two
+    ```
+
+    (There are some relevant comments by John Gruber
+    [here](http://article.gmane.org/gmane.text.markdown.general/2554).)
+
+5.  Can list markers be indented?  Can ordered list markers be right-aligned?
+
+    ``` markdown
+     8. item 1
+     9. item 2
+    10. item 2a
+    ```
+
+6.  Is this one list with a thematic break in its second item,
+    or two lists separated by a thematic break?
+
+    ``` markdown
+    * a
+    * * * * *
+    * b
+    ```
+
+7.  When list markers change from numbers to bullets, do we have
+    two lists or one?  (The Markdown syntax description suggests two,
+    but the perl scripts and many other implementations produce one.)
+
+    ``` markdown
+    1. fee
+    2. fie
+    -  foe
+    -  fum
+    ```
+
+8.  What are the precedence rules for the markers of inline structure?
+    For example, is the following a valid link, or does the code span
+    take precedence ?
+
+    ``` markdown
+    [a backtick (`)](/url) and [another backtick (`)](/url).
+    ```
+
+9.  What are the precedence rules for markers of emphasis and strong
+    emphasis?  For example, how should the following be parsed?
+
+    ``` markdown
+    *foo *bar* baz*
+    ```
+
+10. What are the precedence rules between block-level and inline-level
+    structure?  For example, how should the following be parsed?
+
+    ``` markdown
+    - `a long code span can contain a hyphen like this
+      - and it can screw things up`
+    ```
+
+11. Can list items include section headings?  (`Markdown.pl` does not
+    allow this, but does allow blockquotes to include headings.)
+
+    ``` markdown
+    - # Heading
+    ```
+
+12. Can list items be empty?
+
+    ``` markdown
+    * a
+    *
+    * b
+    ```
+
+13. Can link references be defined inside block quotes or list items?
+
+    ``` markdown
+    > Blockquote [foo].
+    >
+    > [foo]: /url
+    ```
+
+14. If there are multiple definitions for the same reference, which takes
+    precedence?
+
+    ``` markdown
+    [foo]: /url1
+    [foo]: /url2
+
+    [foo][]
+    ```
+
+In the absence of a spec, early implementers consulted `Markdown.pl`
+to resolve these ambiguities.  But `Markdown.pl` was quite buggy, and
+gave manifestly bad results in many cases, so it was not a
+satisfactory replacement for a spec.
+
+Because there is no unambiguous spec, implementations have diverged
+considerably.  As a result, users are often surprised to find that
+a document that renders one way on one system (say, a github wiki)
+renders differently on another (say, converting to docbook using
+pandoc).  To make matters worse, because nothing in Markdown counts
+as a "syntax error," the divergence often isn't discovered right away.
+
+## About this document
+
+This document attempts to specify Markdown syntax unambiguously.
+It contains many examples with side-by-side Markdown and
+HTML.  These are intended to double as conformance tests.  An
+accompanying script `spec_tests.py` can be used to run the tests
+against any Markdown program:
+
+    python test/spec_tests.py --spec spec.txt --program PROGRAM
+
+Since this document describes how Markdown is to be parsed into
+an abstract syntax tree, it would have made sense to use an abstract
+representation of the syntax tree instead of HTML.  But HTML is capable
+of representing the structural distinctions we need to make, and the
+choice of HTML for the tests makes it possible to run the tests against
+an implementation without writing an abstract syntax tree renderer.
+
+This document is generated from a text file, `spec.txt`, written
+in Markdown with a small extension for the side-by-side tests.
+The script `tools/makespec.py` can be used to convert `spec.txt` into
+HTML or CommonMark (which can then be converted into other formats).
+
+In the examples, the `→` character is used to represent tabs.
+
+# Preliminaries
+
+## Characters and lines
+
+Any sequence of [characters] is a valid CommonMark
+document.
+
+A [character](@) is a Unicode code point.  Although some
+code points (for example, combining accents) do not correspond to
+characters in an intuitive sense, all code points count as characters
+for purposes of this spec.
+
+This spec does not specify an encoding; it thinks of lines as composed
+of [characters] rather than bytes.  A conforming parser may be limited
+to a certain encoding.
+
+A [line](@) is a sequence of zero or more [characters]
+other than newline (`U+000A`) or carriage return (`U+000D`),
+followed by a [line ending] or by the end of file.
+
+A [line ending](@) is a newline (`U+000A`), a carriage return
+(`U+000D`) not followed by a newline, or a carriage return and a
+following newline.
+
+A line containing no characters, or a line containing only spaces
+(`U+0020`) or tabs (`U+0009`), is called a [blank line](@).
+
+The following definitions of character classes will be used in this spec:
+
+A [whitespace character](@) is a space
+(`U+0020`), tab (`U+0009`), newline (`U+000A`), line tabulation (`U+000B`),
+form feed (`U+000C`), or carriage return (`U+000D`).
+
+[Whitespace](@) is a sequence of one or more [whitespace
+characters].
+
+A [Unicode whitespace character](@) is
+any code point in the Unicode `Zs` general category, or a tab (`U+0009`),
+carriage return (`U+000D`), newline (`U+000A`), or form feed
+(`U+000C`).
+
+[Unicode whitespace](@) is a sequence of one
+or more [Unicode whitespace characters].
+
+A [space](@) is `U+0020`.
+
+A [non-whitespace character](@) is any character
+that is not a [whitespace character].
+
+An [ASCII punctuation character](@)
+is `!`, `"`, `#`, `$`, `%`, `&`, `'`, `(`, `)`,
+`*`, `+`, `,`, `-`, `.`, `/`, `:`, `;`, `<`, `=`, `>`, `?`, `@`,
+`[`, `\`, `]`, `^`, `_`, `` ` ``, `{`, `|`, `}`, or `~`.
+
+A [punctuation character](@) is an [ASCII
+punctuation character] or anything in
+the general Unicode categories  `Pc`, `Pd`, `Pe`, `Pf`, `Pi`, `Po`, or `Ps`.
+
+## Tabs
+
+Tabs in lines are not expanded to [spaces].  However,
+in contexts where whitespace helps to define block structure,
+tabs behave as if they were replaced by spaces with a tab stop
+of 4 characters.
+
+Thus, for example, a tab can be used instead of four spaces
+in an indented code block.  (Note, however, that internal
+tabs are passed through as literal tabs, not expanded to
+spaces.)
+
+```````````````````````````````` example
+→foo→baz→→bim
+.
+<pre><code>foo→baz→→bim
+</code></pre>
+````````````````````````````````
+
+```````````````````````````````` example
+  →foo→baz→→bim
+.
+<pre><code>foo→baz→→bim
+</code></pre>
+````````````````````````````````
+
+```````````````````````````````` example
+    a→a
+    ὐ→a
+.
+<pre><code>a→a
+ὐ→a
+</code></pre>
+````````````````````````````````
+
+In the following example, a continuation paragraph of a list
+item is indented with a tab; this has exactly the same effect
+as indentation with four spaces would:
+
+```````````````````````````````` example
+  - foo
+
+→bar
+.
+<ul>
+<li>
+<p>foo</p>
+<p>bar</p>
+</li>
+</ul>
+````````````````````````````````
+
+```````````````````````````````` example
+- foo
+
+→→bar
+.
+<ul>
+<li>
+<p>foo</p>
+<pre><code>  bar
+</code></pre>
+</li>
+</ul>
+````````````````````````````````
+
+Normally the `>` that begins a block quote may be followed
+optionally by a space, which is not considered part of the
+content.  In the following case `>` is followed by a tab,
+which is treated as if it were expanded into three spaces.
+Since one of these spaces is considered part of the
+delimiter, `foo` is considered to be indented six spaces
+inside the block quote context, so we get an indented
+code block starting with two spaces.
+
+```````````````````````````````` example
+>→→foo
+.
+<blockquote>
+<pre><code>  foo
+</code></pre>
+</blockquote>
+````````````````````````````````
+
+```````````````````````````````` example
+-→→foo
+.
+<ul>
+<li>
+<pre><code>  foo
+</code></pre>
+</li>
+</ul>
+````````````````````````````````
+
+
+```````````````````````````````` example
+    foo
+→bar
+.
+<pre><code>foo
+bar
+</code></pre>
+````````````````````````````````
+
+```````````````````````````````` example
+ - foo
+   - bar
+→ - baz
+.
+<ul>
+<li>foo
+<ul>
+<li>bar
+<ul>
+<li>baz</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+````````````````````````````````
+
+```````````````````````````````` example
+#→Foo
+.
+<h1>Foo</h1>
+````````````````````````````````
+
+```````````````````````````````` example
+*→*→*→
+.
+<hr />
+````````````````````````````````
+
+
+## Insecure characters
+
+For security reasons, the Unicode character `U+0000` must be replaced
+with the REPLACEMENT CHARACTER (`U+FFFD`).
+
+# Blocks and inlines
+
+We can think of a document as a sequence of
+[blocks](@)---structural elements like paragraphs, block
+quotations, lists, headings, rules, and code blocks.  Some blocks (like
+block quotes and list items) contain other blocks; others (like
+headings and paragraphs) contain [inline](@) content---text,
+links, emphasized text, images, code spans, and so on.
+
+## Precedence
+
+Indicators of block structure always take precedence over indicators
+of inline structure.  So, for example, the following is a list with
+two items, not a list with one item containing a code span:
+
+```````````````````````````````` example
+- `one
+- two`
+.
+<ul>
+<li>`one</li>
+<li>two`</li>
+</ul>
+````````````````````````````````
+
+
+This means that parsing can proceed in two steps:  first, the block
+structure of the document can be discerned; second, text lines inside
+paragraphs, headings, and other block constructs can be parsed for inline
+structure.  The second step requires information about link reference
+definitions that will be available only at the end of the first
+step.  Note that the first step requires processing lines in sequence,
+but the second can be parallelized, since the inline parsing of
+one block element does not affect the inline parsing of any other.
+
+## Container blocks and leaf blocks
+
+We can divide blocks into two types:
+[container block](@)s,
+which can contain other blocks, and [leaf block](@)s,
+which cannot.
+
+# Leaf blocks
+
+This section describes the different kinds of leaf block that make up a
+Markdown document.
+
+## Thematic breaks
+
+A line consisting of 0-3 spaces of indentation, followed by a sequence
+of three or more matching `-`, `_`, or `*` characters, each followed
+optionally by any number of spaces, forms a
+[thematic break](@).
+
+```````````````````````````````` example
+***
+---
+___
+.
+<hr />
+<hr />
+<hr />
+````````````````````````````````
+
+
+Wrong characters:
+
+```````````````````````````````` example
++++
+.
+<p>+++</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+===
+.
+<p>===</p>
+````````````````````````````````
+
+
+Not enough characters:
+
+```````````````````````````````` example
+--
+**
+__
+.
+<p>--
+**
+__</p>
+````````````````````````````````
+
+
+One to three spaces indent are allowed:
+
+```````````````````````````````` example
+ ***
+  ***
+   ***
+.
+<hr />
+<hr />
+<hr />
+````````````````````````````````
+
+
+Four spaces is too many:
+
+```````````````````````````````` example
+    ***
+.
+<pre><code>***
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+Foo
+    ***
+.
+<p>Foo
+***</p>
+````````````````````````````````
+
+
+More than three characters may be used:
+
+```````````````````````````````` example
+_____________________________________
+.
+<hr />
+````````````````````````````````
+
+
+Spaces are allowed between the characters:
+
+```````````````````````````````` example
+ - - -
+.
+<hr />
+````````````````````````````````
+
+
+```````````````````````````````` example
+ **  * ** * ** * **
+.
+<hr />
+````````````````````````````````
+
+
+```````````````````````````````` example
+-     -      -      -
+.
+<hr />
+````````````````````````````````
+
+
+Spaces are allowed at the end:
+
+```````````````````````````````` example
+- - - -    
+.
+<hr />
+````````````````````````````````
+
+
+However, no other characters may occur in the line:
+
+```````````````````````````````` example
+_ _ _ _ a
+
+a------
+
+---a---
+.
+<p>_ _ _ _ a</p>
+<p>a------</p>
+<p>---a---</p>
+````````````````````````````````
+
+
+It is required that all of the [non-whitespace characters] be the same.
+So, this is not a thematic break:
+
+```````````````````````````````` example
+ *-*
+.
+<p><em>-</em></p>
+````````````````````````````````
+
+
+Thematic breaks do not need blank lines before or after:
+
+```````````````````````````````` example
+- foo
+***
+- bar
+.
+<ul>
+<li>foo</li>
+</ul>
+<hr />
+<ul>
+<li>bar</li>
+</ul>
+````````````````````````````````
+
+
+Thematic breaks can interrupt a paragraph:
+
+```````````````````````````````` example
+Foo
+***
+bar
+.
+<p>Foo</p>
+<hr />
+<p>bar</p>
+````````````````````````````````
+
+
+If a line of dashes that meets the above conditions for being a
+thematic break could also be interpreted as the underline of a [setext
+heading], the interpretation as a
+[setext heading] takes precedence. Thus, for example,
+this is a setext heading, not a paragraph followed by a thematic break:
+
+```````````````````````````````` example
+Foo
+---
+bar
+.
+<h2>Foo</h2>
+<p>bar</p>
+````````````````````````````````
+
+
+When both a thematic break and a list item are possible
+interpretations of a line, the thematic break takes precedence:
+
+```````````````````````````````` example
+* Foo
+* * *
+* Bar
+.
+<ul>
+<li>Foo</li>
+</ul>
+<hr />
+<ul>
+<li>Bar</li>
+</ul>
+````````````````````````````````
+
+
+If you want a thematic break in a list item, use a different bullet:
+
+```````````````````````````````` example
+- Foo
+- * * *
+.
+<ul>
+<li>Foo</li>
+<li>
+<hr />
+</li>
+</ul>
+````````````````````````````````
+
+
+## ATX headings
+
+An [ATX heading](@)
+consists of a string of characters, parsed as inline content, between an
+opening sequence of 1--6 unescaped `#` characters and an optional
+closing sequence of any number of unescaped `#` characters.
+The opening sequence of `#` characters must be followed by a
+[space] or by the end of line. The optional closing sequence of `#`s must be
+preceded by a [space] and may be followed by spaces only.  The opening
+`#` character may be indented 0-3 spaces.  The raw contents of the
+heading are stripped of leading and trailing spaces before being parsed
+as inline content.  The heading level is equal to the number of `#`
+characters in the opening sequence.
+
+Simple headings:
+
+```````````````````````````````` example
+# foo
+## foo
+### foo
+#### foo
+##### foo
+###### foo
+.
+<h1>foo</h1>
+<h2>foo</h2>
+<h3>foo</h3>
+<h4>foo</h4>
+<h5>foo</h5>
+<h6>foo</h6>
+````````````````````````````````
+
+
+More than six `#` characters is not a heading:
+
+```````````````````````````````` example
+####### foo
+.
+<p>####### foo</p>
+````````````````````````````````
+
+
+At least one space is required between the `#` characters and the
+heading's contents, unless the heading is empty.  Note that many
+implementations currently do not require the space.  However, the
+space was required by the
+[original ATX implementation](http://www.aaronsw.com/2002/atx/atx.py),
+and it helps prevent things like the following from being parsed as
+headings:
+
+```````````````````````````````` example
+#5 bolt
+
+#hashtag
+.
+<p>#5 bolt</p>
+<p>#hashtag</p>
+````````````````````````````````
+
+
+This is not a heading, because the first `#` is escaped:
+
+```````````````````````````````` example
+\## foo
+.
+<p>## foo</p>
+````````````````````````````````
+
+
+Contents are parsed as inlines:
+
+```````````````````````````````` example
+# foo *bar* \*baz\*
+.
+<h1>foo <em>bar</em> *baz*</h1>
+````````````````````````````````
+
+
+Leading and trailing blanks are ignored in parsing inline content:
+
+```````````````````````````````` example
+#                  foo                     
+.
+<h1>foo</h1>
+````````````````````````````````
+
+
+One to three spaces indentation are allowed:
+
+```````````````````````````````` example
+ ### foo
+  ## foo
+   # foo
+.
+<h3>foo</h3>
+<h2>foo</h2>
+<h1>foo</h1>
+````````````````````````````````
+
+
+Four spaces are too much:
+
+```````````````````````````````` example
+    # foo
+.
+<pre><code># foo
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo
+    # bar
+.
+<p>foo
+# bar</p>
+````````````````````````````````
+
+
+A closing sequence of `#` characters is optional:
+
+```````````````````````````````` example
+## foo ##
+  ###   bar    ###
+.
+<h2>foo</h2>
+<h3>bar</h3>
+````````````````````````````````
+
+
+It need not be the same length as the opening sequence:
+
+```````````````````````````````` example
+# foo ##################################
+##### foo ##
+.
+<h1>foo</h1>
+<h5>foo</h5>
+````````````````````````````````
+
+
+Spaces are allowed after the closing sequence:
+
+```````````````````````````````` example
+### foo ###     
+.
+<h3>foo</h3>
+````````````````````````````````
+
+
+A sequence of `#` characters with anything but [spaces] following it
+is not a closing sequence, but counts as part of the contents of the
+heading:
+
+```````````````````````````````` example
+### foo ### b
+.
+<h3>foo ### b</h3>
+````````````````````````````````
+
+
+The closing sequence must be preceded by a space:
+
+```````````````````````````````` example
+# foo#
+.
+<h1>foo#</h1>
+````````````````````````````````
+
+
+Backslash-escaped `#` characters do not count as part
+of the closing sequence:
+
+```````````````````````````````` example
+### foo \###
+## foo #\##
+# foo \#
+.
+<h3>foo ###</h3>
+<h2>foo ###</h2>
+<h1>foo #</h1>
+````````````````````````````````
+
+
+ATX headings need not be separated from surrounding content by blank
+lines, and they can interrupt paragraphs:
+
+```````````````````````````````` example
+****
+## foo
+****
+.
+<hr />
+<h2>foo</h2>
+<hr />
+````````````````````````````````
+
+
+```````````````````````````````` example
+Foo bar
+# baz
+Bar foo
+.
+<p>Foo bar</p>
+<h1>baz</h1>
+<p>Bar foo</p>
+````````````````````````````````
+
+
+ATX headings can be empty:
+
+```````````````````````````````` example
+## 
+#
+### ###
+.
+<h2></h2>
+<h1></h1>
+<h3></h3>
+````````````````````````````````
+
+
+## Setext headings
+
+A [setext heading](@) consists of one or more
+lines of text, each containing at least one [non-whitespace
+character], with no more than 3 spaces indentation, followed by
+a [setext heading underline].  The lines of text must be such
+that, were they not followed by the setext heading underline,
+they would be interpreted as a paragraph:  they cannot be
+interpretable as a [code fence], [ATX heading][ATX headings],
+[block quote][block quotes], [thematic break][thematic breaks],
+[list item][list items], or [HTML block][HTML blocks].
+
+A [setext heading underline](@) is a sequence of
+`=` characters or a sequence of `-` characters, with no more than 3
+spaces indentation and any number of trailing spaces.  If a line
+containing a single `-` can be interpreted as an
+empty [list items], it should be interpreted this way
+and not as a [setext heading underline].
+
+The heading is a level 1 heading if `=` characters are used in
+the [setext heading underline], and a level 2 heading if `-`
+characters are used.  The contents of the heading are the result
+of parsing the preceding lines of text as CommonMark inline
+content.
+
+In general, a setext heading need not be preceded or followed by a
+blank line.  However, it cannot interrupt a paragraph, so when a
+setext heading comes after a paragraph, a blank line is needed between
+them.
+
+Simple examples:
+
+```````````````````````````````` example
+Foo *bar*
+=========
+
+Foo *bar*
+---------
+.
+<h1>Foo <em>bar</em></h1>
+<h2>Foo <em>bar</em></h2>
+````````````````````````````````
+
+
+The content of the header may span more than one line:
+
+```````````````````````````````` example
+Foo *bar
+baz*
+====
+.
+<h1>Foo <em>bar
+baz</em></h1>
+````````````````````````````````
+
+
+The underlining can be any length:
+
+```````````````````````````````` example
+Foo
+-------------------------
+
+Foo
+=
+.
+<h2>Foo</h2>
+<h1>Foo</h1>
+````````````````````````````````
+
+
+The heading content can be indented up to three spaces, and need
+not line up with the underlining:
+
+```````````````````````````````` example
+   Foo
+---
+
+  Foo
+-----
+
+  Foo
+  ===
+.
+<h2>Foo</h2>
+<h2>Foo</h2>
+<h1>Foo</h1>
+````````````````````````````````
+
+
+Four spaces indent is too much:
+
+```````````````````````````````` example
+    Foo
+    ---
+
+    Foo
+---
+.
+<pre><code>Foo
+---
+
+Foo
+</code></pre>
+<hr />
+````````````````````````````````
+
+
+The setext heading underline can be indented up to three spaces, and
+may have trailing spaces:
+
+```````````````````````````````` example
+Foo
+   ----      
+.
+<h2>Foo</h2>
+````````````````````````````````
+
+
+Four spaces is too much:
+
+```````````````````````````````` example
+Foo
+    ---
+.
+<p>Foo
+---</p>
+````````````````````````````````
+
+
+The setext heading underline cannot contain internal spaces:
+
+```````````````````````````````` example
+Foo
+= =
+
+Foo
+--- -
+.
+<p>Foo
+= =</p>
+<p>Foo</p>
+<hr />
+````````````````````````````````
+
+
+Trailing spaces in the content line do not cause a line break:
+
+```````````````````````````````` example
+Foo  
+-----
+.
+<h2>Foo</h2>
+````````````````````````````````
+
+
+Nor does a backslash at the end:
+
+```````````````````````````````` example
+Foo\
+----
+.
+<h2>Foo\</h2>
+````````````````````````````````
+
+
+Since indicators of block structure take precedence over
+indicators of inline structure, the following are setext headings:
+
+```````````````````````````````` example
+`Foo
+----
+`
+
+<a title="a lot
+---
+of dashes"/>
+.
+<h2>`Foo</h2>
+<p>`</p>
+<h2>&lt;a title=&quot;a lot</h2>
+<p>of dashes&quot;/&gt;</p>
+````````````````````````````````
+
+
+The setext heading underline cannot be a [lazy continuation
+line] in a list item or block quote:
+
+```````````````````````````````` example
+> Foo
+---
+.
+<blockquote>
+<p>Foo</p>
+</blockquote>
+<hr />
+````````````````````````````````
+
+
+```````````````````````````````` example
+> foo
+bar
+===
+.
+<blockquote>
+<p>foo
+bar
+===</p>
+</blockquote>
+````````````````````````````````
+
+
+```````````````````````````````` example
+- Foo
+---
+.
+<ul>
+<li>Foo</li>
+</ul>
+<hr />
+````````````````````````````````
+
+
+A blank line is needed between a paragraph and a following
+setext heading, since otherwise the paragraph becomes part
+of the heading's content:
+
+```````````````````````````````` example
+Foo
+Bar
+---
+.
+<h2>Foo
+Bar</h2>
+````````````````````````````````
+
+
+But in general a blank line is not required before or after
+setext headings:
+
+```````````````````````````````` example
+---
+Foo
+---
+Bar
+---
+Baz
+.
+<hr />
+<h2>Foo</h2>
+<h2>Bar</h2>
+<p>Baz</p>
+````````````````````````````````
+
+
+Setext headings cannot be empty:
+
+```````````````````````````````` example
+
+====
+.
+<p>====</p>
+````````````````````````````````
+
+
+Setext heading text lines must not be interpretable as block
+constructs other than paragraphs.  So, the line of dashes
+in these examples gets interpreted as a thematic break:
+
+```````````````````````````````` example
+---
+---
+.
+<hr />
+<hr />
+````````````````````````````````
+
+
+```````````````````````````````` example
+- foo
+-----
+.
+<ul>
+<li>foo</li>
+</ul>
+<hr />
+````````````````````````````````
+
+
+```````````````````````````````` example
+    foo
+---
+.
+<pre><code>foo
+</code></pre>
+<hr />
+````````````````````````````````
+
+
+```````````````````````````````` example
+> foo
+-----
+.
+<blockquote>
+<p>foo</p>
+</blockquote>
+<hr />
+````````````````````````````````
+
+
+If you want a heading with `> foo` as its literal text, you can
+use backslash escapes:
+
+```````````````````````````````` example
+\> foo
+------
+.
+<h2>&gt; foo</h2>
+````````````````````````````````
+
+
+**Compatibility note:**  Most existing Markdown implementations
+do not allow the text of setext headings to span multiple lines.
+But there is no consensus about how to interpret
+
+``` markdown
+Foo
+bar
+---
+baz
+```
+
+One can find four different interpretations:
+
+1. paragraph "Foo", heading "bar", paragraph "baz"
+2. paragraph "Foo bar", thematic break, paragraph "baz"
+3. paragraph "Foo bar --- baz"
+4. heading "Foo bar", paragraph "baz"
+
+We find interpretation 4 most natural, and interpretation 4
+increases the expressive power of CommonMark, by allowing
+multiline headings.  Authors who want interpretation 1 can
+put a blank line after the first paragraph:
+
+```````````````````````````````` example
+Foo
+
+bar
+---
+baz
+.
+<p>Foo</p>
+<h2>bar</h2>
+<p>baz</p>
+````````````````````````````````
+
+
+Authors who want interpretation 2 can put blank lines around
+the thematic break,
+
+```````````````````````````````` example
+Foo
+bar
+
+---
+
+baz
+.
+<p>Foo
+bar</p>
+<hr />
+<p>baz</p>
+````````````````````````````````
+
+
+or use a thematic break that cannot count as a [setext heading
+underline], such as
+
+```````````````````````````````` example
+Foo
+bar
+* * *
+baz
+.
+<p>Foo
+bar</p>
+<hr />
+<p>baz</p>
+````````````````````````````````
+
+
+Authors who want interpretation 3 can use backslash escapes:
+
+```````````````````````````````` example
+Foo
+bar
+\---
+baz
+.
+<p>Foo
+bar
+---
+baz</p>
+````````````````````````````````
+
+
+## Indented code blocks
+
+An [indented code block](@) is composed of one or more
+[indented chunks] separated by blank lines.
+An [indented chunk](@) is a sequence of non-blank lines,
+each indented four or more spaces. The contents of the code block are
+the literal contents of the lines, including trailing
+[line endings], minus four spaces of indentation.
+An indented code block has no [info string].
+
+An indented code block cannot interrupt a paragraph, so there must be
+a blank line between a paragraph and a following indented code block.
+(A blank line is not needed, however, between a code block and a following
+paragraph.)
+
+```````````````````````````````` example
+    a simple
+      indented code block
+.
+<pre><code>a simple
+  indented code block
+</code></pre>
+````````````````````````````````
+
+
+If there is any ambiguity between an interpretation of indentation
+as a code block and as indicating that material belongs to a [list
+item][list items], the list item interpretation takes precedence:
+
+```````````````````````````````` example
+  - foo
+
+    bar
+.
+<ul>
+<li>
+<p>foo</p>
+<p>bar</p>
+</li>
+</ul>
+````````````````````````````````
+
+
+```````````````````````````````` example
+1.  foo
+
+    - bar
+.
+<ol>
+<li>
+<p>foo</p>
+<ul>
+<li>bar</li>
+</ul>
+</li>
+</ol>
+````````````````````````````````
+
+
+
+The contents of a code block are literal text, and do not get parsed
+as Markdown:
+
+```````````````````````````````` example
+    <a/>
+    *hi*
+
+    - one
+.
+<pre><code>&lt;a/&gt;
+*hi*
+
+- one
+</code></pre>
+````````````````````````````````
+
+
+Here we have three chunks separated by blank lines:
+
+```````````````````````````````` example
+    chunk1
+
+    chunk2
+  
+ 
+ 
+    chunk3
+.
+<pre><code>chunk1
+
+chunk2
+
+
+
+chunk3
+</code></pre>
+````````````````````````````````
+
+
+Any initial spaces beyond four will be included in the content, even
+in interior blank lines:
+
+```````````````````````````````` example
+    chunk1
+      
+      chunk2
+.
+<pre><code>chunk1
+  
+  chunk2
+</code></pre>
+````````````````````````````````
+
+
+An indented code block cannot interrupt a paragraph.  (This
+allows hanging indents and the like.)
+
+```````````````````````````````` example
+Foo
+    bar
+
+.
+<p>Foo
+bar</p>
+````````````````````````````````
+
+
+However, any non-blank line with fewer than four leading spaces ends
+the code block immediately.  So a paragraph may occur immediately
+after indented code:
+
+```````````````````````````````` example
+    foo
+bar
+.
+<pre><code>foo
+</code></pre>
+<p>bar</p>
+````````````````````````````````
+
+
+And indented code can occur immediately before and after other kinds of
+blocks:
+
+```````````````````````````````` example
+# Heading
+    foo
+Heading
+------
+    foo
+----
+.
+<h1>Heading</h1>
+<pre><code>foo
+</code></pre>
+<h2>Heading</h2>
+<pre><code>foo
+</code></pre>
+<hr />
+````````````````````````````````
+
+
+The first line can be indented more than four spaces:
+
+```````````````````````````````` example
+        foo
+    bar
+.
+<pre><code>    foo
+bar
+</code></pre>
+````````````````````````````````
+
+
+Blank lines preceding or following an indented code block
+are not included in it:
+
+```````````````````````````````` example
+
+    
+    foo
+    
+
+.
+<pre><code>foo
+</code></pre>
+````````````````````````````````
+
+
+Trailing spaces are included in the code block's content:
+
+```````````````````````````````` example
+    foo  
+.
+<pre><code>foo  
+</code></pre>
+````````````````````````````````
+
+
+
+## Fenced code blocks
+
+A [code fence](@) is a sequence
+of at least three consecutive backtick characters (`` ` ``) or
+tildes (`~`).  (Tildes and backticks cannot be mixed.)
+A [fenced code block](@)
+begins with a code fence, indented no more than three spaces.
+
+The line with the opening code fence may optionally contain some text
+following the code fence; this is trimmed of leading and trailing
+spaces and called the [info string](@).
+The [info string] may not contain any backtick
+characters.  (The reason for this restriction is that otherwise
+some inline code would be incorrectly interpreted as the
+beginning of a fenced code block.)
+
+The content of the code block consists of all subsequent lines, until
+a closing [code fence] of the same type as the code block
+began with (backticks or tildes), and with at least as many backticks
+or tildes as the opening code fence.  If the leading code fence is
+indented N spaces, then up to N spaces of indentation are removed from
+each line of the content (if present).  (If a content line is not
+indented, it is preserved unchanged.  If it is indented less than N
+spaces, all of the indentation is removed.)
+
+The closing code fence may be indented up to three spaces, and may be
+followed only by spaces, which are ignored.  If the end of the
+containing block (or document) is reached and no closing code fence
+has been found, the code block contains all of the lines after the
+opening code fence until the end of the containing block (or
+document).  (An alternative spec would require backtracking in the
+event that a closing code fence is not found.  But this makes parsing
+much less efficient, and there seems to be no real down side to the
+behavior described here.)
+
+A fenced code block may interrupt a paragraph, and does not require
+a blank line either before or after.
+
+The content of a code fence is treated as literal text, not parsed
+as inlines.  The first word of the [info string] is typically used to
+specify the language of the code sample, and rendered in the `class`
+attribute of the `code` tag.  However, this spec does not mandate any
+particular treatment of the [info string].
+
+Here is a simple example with backticks:
+
+```````````````````````````````` example
+```
+<
+ >
+```
+.
+<pre><code>&lt;
+ &gt;
+</code></pre>
+````````````````````````````````
+
+
+With tildes:
+
+```````````````````````````````` example
+~~~
+<
+ >
+~~~
+.
+<pre><code>&lt;
+ &gt;
+</code></pre>
+````````````````````````````````
+
+Fewer than three backticks is not enough:
+
+```````````````````````````````` example
+``
+foo
+``
+.
+<p><code>foo</code></p>
+````````````````````````````````
+
+The closing code fence must use the same character as the opening
+fence:
+
+```````````````````````````````` example
+```
+aaa
+~~~
+```
+.
+<pre><code>aaa
+~~~
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+~~~
+aaa
+```
+~~~
+.
+<pre><code>aaa
+```
+</code></pre>
+````````````````````````````````
+
+
+The closing code fence must be at least as long as the opening fence:
+
+```````````````````````````````` example
+````
+aaa
+```
+``````
+.
+<pre><code>aaa
+```
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+~~~~
+aaa
+~~~
+~~~~
+.
+<pre><code>aaa
+~~~
+</code></pre>
+````````````````````````````````
+
+
+Unclosed code blocks are closed by the end of the document
+(or the enclosing [block quote][block quotes] or [list item][list items]):
+
+```````````````````````````````` example
+```
+.
+<pre><code></code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+`````
+
+```
+aaa
+.
+<pre><code>
+```
+aaa
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+> ```
+> aaa
+
+bbb
+.
+<blockquote>
+<pre><code>aaa
+</code></pre>
+</blockquote>
+<p>bbb</p>
+````````````````````````````````
+
+
+A code block can have all empty lines as its content:
+
+```````````````````````````````` example
+```
+
+  
+```
+.
+<pre><code>
+  
+</code></pre>
+````````````````````````````````
+
+
+A code block can be empty:
+
+```````````````````````````````` example
+```
+```
+.
+<pre><code></code></pre>
+````````````````````````````````
+
+
+Fences can be indented.  If the opening fence is indented,
+content lines will have equivalent opening indentation removed,
+if present:
+
+```````````````````````````````` example
+ ```
+ aaa
+aaa
+```
+.
+<pre><code>aaa
+aaa
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+  ```
+aaa
+  aaa
+aaa
+  ```
+.
+<pre><code>aaa
+aaa
+aaa
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+   ```
+   aaa
+    aaa
+  aaa
+   ```
+.
+<pre><code>aaa
+ aaa
+aaa
+</code></pre>
+````````````````````````````````
+
+
+Four spaces indentation produces an indented code block:
+
+```````````````````````````````` example
+    ```
+    aaa
+    ```
+.
+<pre><code>```
+aaa
+```
+</code></pre>
+````````````````````````````````
+
+
+Closing fences may be indented by 0-3 spaces, and their indentation
+need not match that of the opening fence:
+
+```````````````````````````````` example
+```
+aaa
+  ```
+.
+<pre><code>aaa
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+   ```
+aaa
+  ```
+.
+<pre><code>aaa
+</code></pre>
+````````````````````````````````
+
+
+This is not a closing fence, because it is indented 4 spaces:
+
+```````````````````````````````` example
+```
+aaa
+    ```
+.
+<pre><code>aaa
+    ```
+</code></pre>
+````````````````````````````````
+
+
+
+Code fences (opening and closing) cannot contain internal spaces:
+
+```````````````````````````````` example
+``` ```
+aaa
+.
+<p><code></code>
+aaa</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+~~~~~~
+aaa
+~~~ ~~
+.
+<pre><code>aaa
+~~~ ~~
+</code></pre>
+````````````````````````````````
+
+
+Fenced code blocks can interrupt paragraphs, and can be followed
+directly by paragraphs, without a blank line between:
+
+```````````````````````````````` example
+foo
+```
+bar
+```
+baz
+.
+<p>foo</p>
+<pre><code>bar
+</code></pre>
+<p>baz</p>
+````````````````````````````````
+
+
+Other blocks can also occur before and after fenced code blocks
+without an intervening blank line:
+
+```````````````````````````````` example
+foo
+---
+~~~
+bar
+~~~
+# baz
+.
+<h2>foo</h2>
+<pre><code>bar
+</code></pre>
+<h1>baz</h1>
+````````````````````````````````
+
+
+An [info string] can be provided after the opening code fence.
+Opening and closing spaces will be stripped, and the first word, prefixed
+with `language-`, is used as the value for the `class` attribute of the
+`code` element within the enclosing `pre` element.
+
+```````````````````````````````` example
+```ruby
+def foo(x)
+  return 3
+end
+```
+.
+<pre><code class="language-ruby">def foo(x)
+  return 3
+end
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+~~~~    ruby startline=3 $%@#$
+def foo(x)
+  return 3
+end
+~~~~~~~
+.
+<pre><code class="language-ruby">def foo(x)
+  return 3
+end
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+````;
+````
+.
+<pre><code class="language-;"></code></pre>
+````````````````````````````````
+
+
+[Info strings] for backtick code blocks cannot contain backticks:
+
+```````````````````````````````` example
+``` aa ```
+foo
+.
+<p><code>aa</code>
+foo</p>
+````````````````````````````````
+
+
+Closing code fences cannot have [info strings]:
+
+```````````````````````````````` example
+```
+``` aaa
+```
+.
+<pre><code>``` aaa
+</code></pre>
+````````````````````````````````
+
+
+
+## HTML blocks
+
+An [HTML block](@) is a group of lines that is treated
+as raw HTML (and will not be escaped in HTML output).
+
+There are seven kinds of [HTML block], which can be defined
+by their start and end conditions.  The block begins with a line that
+meets a [start condition](@) (after up to three spaces
+optional indentation).  It ends with the first subsequent line that
+meets a matching [end condition](@), or the last line of
+the document or other [container block]), if no line is encountered that meets the
+[end condition].  If the first line meets both the [start condition]
+and the [end condition], the block will contain just that line.
+
+1.  **Start condition:**  line begins with the string `<script`,
+`<pre`, or `<style` (case-insensitive), followed by whitespace,
+the string `>`, or the end of the line.\
+**End condition:**  line contains an end tag
+`</script>`, `</pre>`, or `</style>` (case-insensitive; it
+need not match the start tag).
+
+2.  **Start condition:** line begins with the string `<!--`.\
+**End condition:**  line contains the string `-->`.
+
+3.  **Start condition:** line begins with the string `<?`.\
+**End condition:** line contains the string `?>`.
+
+4.  **Start condition:** line begins with the string `<!`
+followed by an uppercase ASCII letter.\
+**End condition:** line contains the character `>`.
+
+5.  **Start condition:**  line begins with the string
+`<![CDATA[`.\
+**End condition:** line contains the string `]]>`.
+
+6.  **Start condition:** line begins the string `<` or `</`
+followed by one of the strings (case-insensitive) `address`,
+`article`, `aside`, `base`, `basefont`, `blockquote`, `body`,
+`caption`, `center`, `col`, `colgroup`, `dd`, `details`, `dialog`,
+`dir`, `div`, `dl`, `dt`, `fieldset`, `figcaption`, `figure`,
+`footer`, `form`, `frame`, `frameset`,
+`h1`, `h2`, `h3`, `h4`, `h5`, `h6`, `head`, `header`, `hr`,
+`html`, `iframe`, `legend`, `li`, `link`, `main`, `menu`, `menuitem`,
+`meta`, `nav`, `noframes`, `ol`, `optgroup`, `option`, `p`, `param`,
+`section`, `source`, `summary`, `table`, `tbody`, `td`,
+`tfoot`, `th`, `thead`, `title`, `tr`, `track`, `ul`, followed
+by [whitespace], the end of the line, the string `>`, or
+the string `/>`.\
+**End condition:** line is followed by a [blank line].
+
+7.  **Start condition:**  line begins with a complete [open tag]
+or [closing tag] (with any [tag name] other than `script`,
+`style`, or `pre`) followed only by [whitespace]
+or the end of the line.\
+**End condition:** line is followed by a [blank line].
+
+HTML blocks continue until they are closed by their appropriate
+[end condition], or the last line of the document or other [container block].
+This means any HTML **within an HTML block** that might otherwise be recognised
+as a start condition will be ignored by the parser and passed through as-is,
+without changing the parser's state.
+
+For instance, `<pre>` within a HTML block started by `<table>` will not affect
+the parser state; as the HTML block was started in by start condition 6, it
+will end at any blank line. This can be surprising:
+
+```````````````````````````````` example
+<table><tr><td>
+<pre>
+**Hello**,
+
+_world_.
+</pre>
+</td></tr></table>
+.
+<table><tr><td>
+<pre>
+**Hello**,
+<p><em>world</em>.
+</pre></p>
+</td></tr></table>
+````````````````````````````````
+
+In this case, the HTML block is terminated by the newline — the `**hello**`
+text remains verbatim — and regular parsing resumes, with a paragraph,
+emphasised `world` and inline and block HTML following.
+
+All types of [HTML blocks] except type 7 may interrupt
+a paragraph.  Blocks of type 7 may not interrupt a paragraph.
+(This restriction is intended to prevent unwanted interpretation
+of long tags inside a wrapped paragraph as starting HTML blocks.)
+
+Some simple examples follow.  Here are some basic HTML blocks
+of type 6:
+
+```````````````````````````````` example
+<table>
+  <tr>
+    <td>
+           hi
+    </td>
+  </tr>
+</table>
+
+okay.
+.
+<table>
+  <tr>
+    <td>
+           hi
+    </td>
+  </tr>
+</table>
+<p>okay.</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+ <div>
+  *hello*
+         <foo><a>
+.
+ <div>
+  *hello*
+         <foo><a>
+````````````````````````````````
+
+
+A block can also start with a closing tag:
+
+```````````````````````````````` example
+</div>
+*foo*
+.
+</div>
+*foo*
+````````````````````````````````
+
+
+Here we have two HTML blocks with a Markdown paragraph between them:
+
+```````````````````````````````` example
+<DIV CLASS="foo">
+
+*Markdown*
+
+</DIV>
+.
+<DIV CLASS="foo">
+<p><em>Markdown</em></p>
+</DIV>
+````````````````````````````````
+
+
+The tag on the first line can be partial, as long
+as it is split where there would be whitespace:
+
+```````````````````````````````` example
+<div id="foo"
+  class="bar">
+</div>
+.
+<div id="foo"
+  class="bar">
+</div>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<div id="foo" class="bar
+  baz">
+</div>
+.
+<div id="foo" class="bar
+  baz">
+</div>
+````````````````````````````````
+
+
+An open tag need not be closed:
+```````````````````````````````` example
+<div>
+*foo*
+
+*bar*
+.
+<div>
+*foo*
+<p><em>bar</em></p>
+````````````````````````````````
+
+
+
+A partial tag need not even be completed (garbage
+in, garbage out):
+
+```````````````````````````````` example
+<div id="foo"
+*hi*
+.
+<div id="foo"
+*hi*
+````````````````````````````````
+
+
+```````````````````````````````` example
+<div class
+foo
+.
+<div class
+foo
+````````````````````````````````
+
+
+The initial tag doesn't even need to be a valid
+tag, as long as it starts like one:
+
+```````````````````````````````` example
+<div *???-&&&-<---
+*foo*
+.
+<div *???-&&&-<---
+*foo*
+````````````````````````````````
+
+
+In type 6 blocks, the initial tag need not be on a line by
+itself:
+
+```````````````````````````````` example
+<div><a href="bar">*foo*</a></div>
+.
+<div><a href="bar">*foo*</a></div>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<table><tr><td>
+foo
+</td></tr></table>
+.
+<table><tr><td>
+foo
+</td></tr></table>
+````````````````````````````````
+
+
+Everything until the next blank line or end of document
+gets included in the HTML block.  So, in the following
+example, what looks like a Markdown code block
+is actually part of the HTML block, which continues until a blank
+line or the end of the document is reached:
+
+```````````````````````````````` example
+<div></div>
+``` c
+int x = 33;
+```
+.
+<div></div>
+``` c
+int x = 33;
+```
+````````````````````````````````
+
+
+To start an [HTML block] with a tag that is *not* in the
+list of block-level tags in (6), you must put the tag by
+itself on the first line (and it must be complete):
+
+```````````````````````````````` example
+<a href="foo">
+*bar*
+</a>
+.
+<a href="foo">
+*bar*
+</a>
+````````````````````````````````
+
+
+In type 7 blocks, the [tag name] can be anything:
+
+```````````````````````````````` example
+<Warning>
+*bar*
+</Warning>
+.
+<Warning>
+*bar*
+</Warning>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<i class="foo">
+*bar*
+</i>
+.
+<i class="foo">
+*bar*
+</i>
+````````````````````````````````
+
+
+```````````````````````````````` example
+</ins>
+*bar*
+.
+</ins>
+*bar*
+````````````````````````````````
+
+
+These rules are designed to allow us to work with tags that
+can function as either block-level or inline-level tags.
+The `<del>` tag is a nice example.  We can surround content with
+`<del>` tags in three different ways.  In this case, we get a raw
+HTML block, because the `<del>` tag is on a line by itself:
+
+```````````````````````````````` example
+<del>
+*foo*
+</del>
+.
+<del>
+*foo*
+</del>
+````````````````````````````````
+
+
+In this case, we get a raw HTML block that just includes
+the `<del>` tag (because it ends with the following blank
+line).  So the contents get interpreted as CommonMark:
+
+```````````````````````````````` example
+<del>
+
+*foo*
+
+</del>
+.
+<del>
+<p><em>foo</em></p>
+</del>
+````````````````````````````````
+
+
+Finally, in this case, the `<del>` tags are interpreted
+as [raw HTML] *inside* the CommonMark paragraph.  (Because
+the tag is not on a line by itself, we get inline HTML
+rather than an [HTML block].)
+
+```````````````````````````````` example
+<del>*foo*</del>
+.
+<p><del><em>foo</em></del></p>
+````````````````````````````````
+
+
+HTML tags designed to contain literal content
+(`script`, `style`, `pre`), comments, processing instructions,
+and declarations are treated somewhat differently.
+Instead of ending at the first blank line, these blocks
+end at the first line containing a corresponding end tag.
+As a result, these blocks can contain blank lines:
+
+A pre tag (type 1):
+
+```````````````````````````````` example
+<pre language="haskell"><code>
+import Text.HTML.TagSoup
+
+main :: IO ()
+main = print $ parseTags tags
+</code></pre>
+okay
+.
+<pre language="haskell"><code>
+import Text.HTML.TagSoup
+
+main :: IO ()
+main = print $ parseTags tags
+</code></pre>
+<p>okay</p>
+````````````````````````````````
+
+
+A script tag (type 1):
+
+```````````````````````````````` example
+<script type="text/javascript">
+// JavaScript example
+
+document.getElementById("demo").innerHTML = "Hello JavaScript!";
+</script>
+okay
+.
+<script type="text/javascript">
+// JavaScript example
+
+document.getElementById("demo").innerHTML = "Hello JavaScript!";
+</script>
+<p>okay</p>
+````````````````````````````````
+
+
+A style tag (type 1):
+
+```````````````````````````````` example
+<style
+  type="text/css">
+h1 {color:red;}
+
+p {color:blue;}
+</style>
+okay
+.
+<style
+  type="text/css">
+h1 {color:red;}
+
+p {color:blue;}
+</style>
+<p>okay</p>
+````````````````````````````````
+
+
+If there is no matching end tag, the block will end at the
+end of the document (or the enclosing [block quote][block quotes]
+or [list item][list items]):
+
+```````````````````````````````` example
+<style
+  type="text/css">
+
+foo
+.
+<style
+  type="text/css">
+
+foo
+````````````````````````````````
+
+
+```````````````````````````````` example
+> <div>
+> foo
+
+bar
+.
+<blockquote>
+<div>
+foo
+</blockquote>
+<p>bar</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+- <div>
+- foo
+.
+<ul>
+<li>
+<div>
+</li>
+<li>foo</li>
+</ul>
+````````````````````````````````
+
+
+The end tag can occur on the same line as the start tag:
+
+```````````````````````````````` example
+<style>p{color:red;}</style>
+*foo*
+.
+<style>p{color:red;}</style>
+<p><em>foo</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<!-- foo -->*bar*
+*baz*
+.
+<!-- foo -->*bar*
+<p><em>baz</em></p>
+````````````````````````````````
+
+
+Note that anything on the last line after the
+end tag will be included in the [HTML block]:
+
+```````````````````````````````` example
+<script>
+foo
+</script>1. *bar*
+.
+<script>
+foo
+</script>1. *bar*
+````````````````````````````````
+
+
+A comment (type 2):
+
+```````````````````````````````` example
+<!-- Foo
+
+bar
+   baz -->
+okay
+.
+<!-- Foo
+
+bar
+   baz -->
+<p>okay</p>
+````````````````````````````````
+
+
+
+A processing instruction (type 3):
+
+```````````````````````````````` example
+<?php
+
+  echo '>';
+
+?>
+okay
+.
+<?php
+
+  echo '>';
+
+?>
+<p>okay</p>
+````````````````````````````````
+
+
+A declaration (type 4):
+
+```````````````````````````````` example
+<!DOCTYPE html>
+.
+<!DOCTYPE html>
+````````````````````````````````
+
+
+CDATA (type 5):
+
+```````````````````````````````` example
+<![CDATA[
+function matchwo(a,b)
+{
+  if (a < b && a < 0) then {
+    return 1;
+
+  } else {
+
+    return 0;
+  }
+}
+]]>
+okay
+.
+<![CDATA[
+function matchwo(a,b)
+{
+  if (a < b && a < 0) then {
+    return 1;
+
+  } else {
+
+    return 0;
+  }
+}
+]]>
+<p>okay</p>
+````````````````````````````````
+
+
+The opening tag can be indented 1-3 spaces, but not 4:
+
+```````````````````````````````` example
+  <!-- foo -->
+
+    <!-- foo -->
+.
+  <!-- foo -->
+<pre><code>&lt;!-- foo --&gt;
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+  <div>
+
+    <div>
+.
+  <div>
+<pre><code>&lt;div&gt;
+</code></pre>
+````````````````````````````````
+
+
+An HTML block of types 1--6 can interrupt a paragraph, and need not be
+preceded by a blank line.
+
+```````````````````````````````` example
+Foo
+<div>
+bar
+</div>
+.
+<p>Foo</p>
+<div>
+bar
+</div>
+````````````````````````````````
+
+
+However, a following blank line is needed, except at the end of
+a document, and except for blocks of types 1--5, above:
+
+```````````````````````````````` example
+<div>
+bar
+</div>
+*foo*
+.
+<div>
+bar
+</div>
+*foo*
+````````````````````````````````
+
+
+HTML blocks of type 7 cannot interrupt a paragraph:
+
+```````````````````````````````` example
+Foo
+<a href="bar">
+baz
+.
+<p>Foo
+<a href="bar">
+baz</p>
+````````````````````````````````
+
+
+This rule differs from John Gruber's original Markdown syntax
+specification, which says:
+
+> The only restrictions are that block-level HTML elements —
+> e.g. `<div>`, `<table>`, `<pre>`, `<p>`, etc. — must be separated from
+> surrounding content by blank lines, and the start and end tags of the
+> block should not be indented with tabs or spaces.
+
+In some ways Gruber's rule is more restrictive than the one given
+here:
+
+- It requires that an HTML block be preceded by a blank line.
+- It does not allow the start tag to be indented.
+- It requires a matching end tag, which it also does not allow to
+  be indented.
+
+Most Markdown implementations (including some of Gruber's own) do not
+respect all of these restrictions.
+
+There is one respect, however, in which Gruber's rule is more liberal
+than the one given here, since it allows blank lines to occur inside
+an HTML block.  There are two reasons for disallowing them here.
+First, it removes the need to parse balanced tags, which is
+expensive and can require backtracking from the end of the document
+if no matching end tag is found. Second, it provides a very simple
+and flexible way of including Markdown content inside HTML tags:
+simply separate the Markdown from the HTML using blank lines:
+
+Compare:
+
+```````````````````````````````` example
+<div>
+
+*Emphasized* text.
+
+</div>
+.
+<div>
+<p><em>Emphasized</em> text.</p>
+</div>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<div>
+*Emphasized* text.
+</div>
+.
+<div>
+*Emphasized* text.
+</div>
+````````````````````````````````
+
+
+Some Markdown implementations have adopted a convention of
+interpreting content inside tags as text if the open tag has
+the attribute `markdown=1`.  The rule given above seems a simpler and
+more elegant way of achieving the same expressive power, which is also
+much simpler to parse.
+
+The main potential drawback is that one can no longer paste HTML
+blocks into Markdown documents with 100% reliability.  However,
+*in most cases* this will work fine, because the blank lines in
+HTML are usually followed by HTML block tags.  For example:
+
+```````````````````````````````` example
+<table>
+
+<tr>
+
+<td>
+Hi
+</td>
+
+</tr>
+
+</table>
+.
+<table>
+<tr>
+<td>
+Hi
+</td>
+</tr>
+</table>
+````````````````````````````````
+
+
+There are problems, however, if the inner tags are indented
+*and* separated by spaces, as then they will be interpreted as
+an indented code block:
+
+```````````````````````````````` example
+<table>
+
+  <tr>
+
+    <td>
+      Hi
+    </td>
+
+  </tr>
+
+</table>
+.
+<table>
+  <tr>
+<pre><code>&lt;td&gt;
+  Hi
+&lt;/td&gt;
+</code></pre>
+  </tr>
+</table>
+````````````````````````````````
+
+
+Fortunately, blank lines are usually not necessary and can be
+deleted.  The exception is inside `<pre>` tags, but as described
+above, raw HTML blocks starting with `<pre>` *can* contain blank
+lines.
+
+## Link reference definitions
+
+A [link reference definition](@)
+consists of a [link label], indented up to three spaces, followed
+by a colon (`:`), optional [whitespace] (including up to one
+[line ending]), a [link destination],
+optional [whitespace] (including up to one
+[line ending]), and an optional [link
+title], which if it is present must be separated
+from the [link destination] by [whitespace].
+No further [non-whitespace characters] may occur on the line.
+
+A [link reference definition]
+does not correspond to a structural element of a document.  Instead, it
+defines a label which can be used in [reference links]
+and reference-style [images] elsewhere in the document.  [Link
+reference definitions] can come either before or after the links that use
+them.
+
+```````````````````````````````` example
+[foo]: /url "title"
+
+[foo]
+.
+<p><a href="/url" title="title">foo</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+   [foo]: 
+      /url  
+           'the title'  
+
+[foo]
+.
+<p><a href="/url" title="the title">foo</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[Foo*bar\]]:my_(url) 'title (with parens)'
+
+[Foo*bar\]]
+.
+<p><a href="my_(url)" title="title (with parens)">Foo*bar]</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[Foo bar]:
+<my%20url>
+'title'
+
+[Foo bar]
+.
+<p><a href="my%20url" title="title">Foo bar</a></p>
+````````````````````````````````
+
+
+The title may extend over multiple lines:
+
+```````````````````````````````` example
+[foo]: /url '
+title
+line1
+line2
+'
+
+[foo]
+.
+<p><a href="/url" title="
+title
+line1
+line2
+">foo</a></p>
+````````````````````````````````
+
+
+However, it may not contain a [blank line]:
+
+```````````````````````````````` example
+[foo]: /url 'title
+
+with blank line'
+
+[foo]
+.
+<p>[foo]: /url 'title</p>
+<p>with blank line'</p>
+<p>[foo]</p>
+````````````````````````````````
+
+
+The title may be omitted:
+
+```````````````````````````````` example
+[foo]:
+/url
+
+[foo]
+.
+<p><a href="/url">foo</a></p>
+````````````````````````````````
+
+
+The link destination may not be omitted:
+
+```````````````````````````````` example
+[foo]:
+
+[foo]
+.
+<p>[foo]:</p>
+<p>[foo]</p>
+````````````````````````````````
+
+
+Both title and destination can contain backslash escapes
+and literal backslashes:
+
+```````````````````````````````` example
+[foo]: /url\bar\*baz "foo\"bar\baz"
+
+[foo]
+.
+<p><a href="/url%5Cbar*baz" title="foo&quot;bar\baz">foo</a></p>
+````````````````````````````````
+
+
+A link can come before its corresponding definition:
+
+```````````````````````````````` example
+[foo]
+
+[foo]: url
+.
+<p><a href="url">foo</a></p>
+````````````````````````````````
+
+
+If there are several matching definitions, the first one takes
+precedence:
+
+```````````````````````````````` example
+[foo]
+
+[foo]: first
+[foo]: second
+.
+<p><a href="first">foo</a></p>
+````````````````````````````````
+
+
+As noted in the section on [Links], matching of labels is
+case-insensitive (see [matches]).
+
+```````````````````````````````` example
+[FOO]: /url
+
+[Foo]
+.
+<p><a href="/url">Foo</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[ΑΓΩ]: /φου
+
+[αγω]
+.
+<p><a href="/%CF%86%CE%BF%CF%85">αγω</a></p>
+````````````````````````````````
+
+
+Here is a link reference definition with no corresponding link.
+It contributes nothing to the document.
+
+```````````````````````````````` example
+[foo]: /url
+.
+````````````````````````````````
+
+
+Here is another one:
+
+```````````````````````````````` example
+[
+foo
+]: /url
+bar
+.
+<p>bar</p>
+````````````````````````````````
+
+
+This is not a link reference definition, because there are
+[non-whitespace characters] after the title:
+
+```````````````````````````````` example
+[foo]: /url "title" ok
+.
+<p>[foo]: /url &quot;title&quot; ok</p>
+````````````````````````````````
+
+
+This is a link reference definition, but it has no title:
+
+```````````````````````````````` example
+[foo]: /url
+"title" ok
+.
+<p>&quot;title&quot; ok</p>
+````````````````````````````````
+
+
+This is not a link reference definition, because it is indented
+four spaces:
+
+```````````````````````````````` example
+    [foo]: /url "title"
+
+[foo]
+.
+<pre><code>[foo]: /url &quot;title&quot;
+</code></pre>
+<p>[foo]</p>
+````````````````````````````````
+
+
+This is not a link reference definition, because it occurs inside
+a code block:
+
+```````````````````````````````` example
+```
+[foo]: /url
+```
+
+[foo]
+.
+<pre><code>[foo]: /url
+</code></pre>
+<p>[foo]</p>
+````````````````````````````````
+
+
+A [link reference definition] cannot interrupt a paragraph.
+
+```````````````````````````````` example
+Foo
+[bar]: /baz
+
+[bar]
+.
+<p>Foo
+[bar]: /baz</p>
+<p>[bar]</p>
+````````````````````````````````
+
+
+However, it can directly follow other block elements, such as headings
+and thematic breaks, and it need not be followed by a blank line.
+
+```````````````````````````````` example
+# [Foo]
+[foo]: /url
+> bar
+.
+<h1><a href="/url">Foo</a></h1>
+<blockquote>
+<p>bar</p>
+</blockquote>
+````````````````````````````````
+
+
+Several [link reference definitions]
+can occur one after another, without intervening blank lines.
+
+```````````````````````````````` example
+[foo]: /foo-url "foo"
+[bar]: /bar-url
+  "bar"
+[baz]: /baz-url
+
+[foo],
+[bar],
+[baz]
+.
+<p><a href="/foo-url" title="foo">foo</a>,
+<a href="/bar-url" title="bar">bar</a>,
+<a href="/baz-url">baz</a></p>
+````````````````````````````````
+
+
+[Link reference definitions] can occur
+inside block containers, like lists and block quotations.  They
+affect the entire document, not just the container in which they
+are defined:
+
+```````````````````````````````` example
+[foo]
+
+> [foo]: /url
+.
+<p><a href="/url">foo</a></p>
+<blockquote>
+</blockquote>
+````````````````````````````````
+
+
+
+## Paragraphs
+
+A sequence of non-blank lines that cannot be interpreted as other
+kinds of blocks forms a [paragraph](@).
+The contents of the paragraph are the result of parsing the
+paragraph's raw content as inlines.  The paragraph's raw content
+is formed by concatenating the lines and removing initial and final
+[whitespace].
+
+A simple example with two paragraphs:
+
+```````````````````````````````` example
+aaa
+
+bbb
+.
+<p>aaa</p>
+<p>bbb</p>
+````````````````````````````````
+
+
+Paragraphs can contain multiple lines, but no blank lines:
+
+```````````````````````````````` example
+aaa
+bbb
+
+ccc
+ddd
+.
+<p>aaa
+bbb</p>
+<p>ccc
+ddd</p>
+````````````````````````````````
+
+
+Multiple blank lines between paragraph have no effect:
+
+```````````````````````````````` example
+aaa
+
+
+bbb
+.
+<p>aaa</p>
+<p>bbb</p>
+````````````````````````````````
+
+
+Leading spaces are skipped:
+
+```````````````````````````````` example
+  aaa
+ bbb
+.
+<p>aaa
+bbb</p>
+````````````````````````````````
+
+
+Lines after the first may be indented any amount, since indented
+code blocks cannot interrupt paragraphs.
+
+```````````````````````````````` example
+aaa
+             bbb
+                                       ccc
+.
+<p>aaa
+bbb
+ccc</p>
+````````````````````````````````
+
+
+However, the first line may be indented at most three spaces,
+or an indented code block will be triggered:
+
+```````````````````````````````` example
+   aaa
+bbb
+.
+<p>aaa
+bbb</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+    aaa
+bbb
+.
+<pre><code>aaa
+</code></pre>
+<p>bbb</p>
+````````````````````````````````
+
+
+Final spaces are stripped before inline parsing, so a paragraph
+that ends with two or more spaces will not end with a [hard line
+break]:
+
+```````````````````````````````` example
+aaa     
+bbb     
+.
+<p>aaa<br />
+bbb</p>
+````````````````````````````````
+
+
+## Blank lines
+
+[Blank lines] between block-level elements are ignored,
+except for the role they play in determining whether a [list]
+is [tight] or [loose].
+
+Blank lines at the beginning and end of the document are also ignored.
+
+```````````````````````````````` example
+  
+
+aaa
+  
+
+# aaa
+
+  
+.
+<p>aaa</p>
+<h1>aaa</h1>
+````````````````````````````````
+
+
+
+# Container blocks
+
+A [container block] is a block that has other
+blocks as its contents.  There are two basic kinds of container blocks:
+[block quotes] and [list items].
+[Lists] are meta-containers for [list items].
+
+We define the syntax for container blocks recursively.  The general
+form of the definition is:
+
+> If X is a sequence of blocks, then the result of
+> transforming X in such-and-such a way is a container of type Y
+> with these blocks as its content.
+
+So, we explain what counts as a block quote or list item by explaining
+how these can be *generated* from their contents. This should suffice
+to define the syntax, although it does not give a recipe for *parsing*
+these constructions.  (A recipe is provided below in the section entitled
+[A parsing strategy](#appendix-a-parsing-strategy).)
+
+## Block quotes
+
+A [block quote marker](@)
+consists of 0-3 spaces of initial indent, plus (a) the character `>` together
+with a following space, or (b) a single character `>` not followed by a space.
+
+The following rules define [block quotes]:
+
+1.  **Basic case.**  If a string of lines *Ls* constitute a sequence
+    of blocks *Bs*, then the result of prepending a [block quote
+    marker] to the beginning of each line in *Ls*
+    is a [block quote](#block-quotes) containing *Bs*.
+
+2.  **Laziness.**  If a string of lines *Ls* constitute a [block
+    quote](#block-quotes) with contents *Bs*, then the result of deleting
+    the initial [block quote marker] from one or
+    more lines in which the next [non-whitespace character] after the [block
+    quote marker] is [paragraph continuation
+    text] is a block quote with *Bs* as its content.
+    [Paragraph continuation text](@) is text
+    that will be parsed as part of the content of a paragraph, but does
+    not occur at the beginning of the paragraph.
+
+3.  **Consecutiveness.**  A document cannot contain two [block
+    quotes] in a row unless there is a [blank line] between them.
+
+Nothing else counts as a [block quote](#block-quotes).
+
+Here is a simple example:
+
+```````````````````````````````` example
+> # Foo
+> bar
+> baz
+.
+<blockquote>
+<h1>Foo</h1>
+<p>bar
+baz</p>
+</blockquote>
+````````````````````````````````
+
+
+The spaces after the `>` characters can be omitted:
+
+```````````````````````````````` example
+># Foo
+>bar
+> baz
+.
+<blockquote>
+<h1>Foo</h1>
+<p>bar
+baz</p>
+</blockquote>
+````````````````````````````````
+
+
+The `>` characters can be indented 1-3 spaces:
+
+```````````````````````````````` example
+   > # Foo
+   > bar
+ > baz
+.
+<blockquote>
+<h1>Foo</h1>
+<p>bar
+baz</p>
+</blockquote>
+````````````````````````````````
+
+
+Four spaces gives us a code block:
+
+```````````````````````````````` example
+    > # Foo
+    > bar
+    > baz
+.
+<pre><code>&gt; # Foo
+&gt; bar
+&gt; baz
+</code></pre>
+````````````````````````````````
+
+
+The Laziness clause allows us to omit the `>` before
+[paragraph continuation text]:
+
+```````````````````````````````` example
+> # Foo
+> bar
+baz
+.
+<blockquote>
+<h1>Foo</h1>
+<p>bar
+baz</p>
+</blockquote>
+````````````````````````````````
+
+
+A block quote can contain some lazy and some non-lazy
+continuation lines:
+
+```````````````````````````````` example
+> bar
+baz
+> foo
+.
+<blockquote>
+<p>bar
+baz
+foo</p>
+</blockquote>
+````````````````````````````````
+
+
+Laziness only applies to lines that would have been continuations of
+paragraphs had they been prepended with [block quote markers].
+For example, the `> ` cannot be omitted in the second line of
+
+``` markdown
+> foo
+> ---
+```
+
+without changing the meaning:
+
+```````````````````````````````` example
+> foo
+---
+.
+<blockquote>
+<p>foo</p>
+</blockquote>
+<hr />
+````````````````````````````````
+
+
+Similarly, if we omit the `> ` in the second line of
+
+``` markdown
+> - foo
+> - bar
+```
+
+then the block quote ends after the first line:
+
+```````````````````````````````` example
+> - foo
+- bar
+.
+<blockquote>
+<ul>
+<li>foo</li>
+</ul>
+</blockquote>
+<ul>
+<li>bar</li>
+</ul>
+````````````````````````````````
+
+
+For the same reason, we can't omit the `> ` in front of
+subsequent lines of an indented or fenced code block:
+
+```````````````````````````````` example
+>     foo
+    bar
+.
+<blockquote>
+<pre><code>foo
+</code></pre>
+</blockquote>
+<pre><code>bar
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+> ```
+foo
+```
+.
+<blockquote>
+<pre><code></code></pre>
+</blockquote>
+<p>foo</p>
+<pre><code></code></pre>
+````````````````````````````````
+
+
+Note that in the following case, we have a [lazy
+continuation line]:
+
+```````````````````````````````` example
+> foo
+    - bar
+.
+<blockquote>
+<p>foo
+- bar</p>
+</blockquote>
+````````````````````````````````
+
+
+To see why, note that in
+
+```markdown
+> foo
+>     - bar
+```
+
+the `- bar` is indented too far to start a list, and can't
+be an indented code block because indented code blocks cannot
+interrupt paragraphs, so it is [paragraph continuation text].
+
+A block quote can be empty:
+
+```````````````````````````````` example
+>
+.
+<blockquote>
+</blockquote>
+````````````````````````````````
+
+
+```````````````````````````````` example
+>
+>  
+> 
+.
+<blockquote>
+</blockquote>
+````````````````````````````````
+
+
+A block quote can have initial or final blank lines:
+
+```````````````````````````````` example
+>
+> foo
+>  
+.
+<blockquote>
+<p>foo</p>
+</blockquote>
+````````````````````````````````
+
+
+A blank line always separates block quotes:
+
+```````````````````````````````` example
+> foo
+
+> bar
+.
+<blockquote>
+<p>foo</p>
+</blockquote>
+<blockquote>
+<p>bar</p>
+</blockquote>
+````````````````````````````````
+
+
+(Most current Markdown implementations, including John Gruber's
+original `Markdown.pl`, will parse this example as a single block quote
+with two paragraphs.  But it seems better to allow the author to decide
+whether two block quotes or one are wanted.)
+
+Consecutiveness means that if we put these block quotes together,
+we get a single block quote:
+
+```````````````````````````````` example
+> foo
+> bar
+.
+<blockquote>
+<p>foo
+bar</p>
+</blockquote>
+````````````````````````````````
+
+
+To get a block quote with two paragraphs, use:
+
+```````````````````````````````` example
+> foo
+>
+> bar
+.
+<blockquote>
+<p>foo</p>
+<p>bar</p>
+</blockquote>
+````````````````````````````````
+
+
+Block quotes can interrupt paragraphs:
+
+```````````````````````````````` example
+foo
+> bar
+.
+<p>foo</p>
+<blockquote>
+<p>bar</p>
+</blockquote>
+````````````````````````````````
+
+
+In general, blank lines are not needed before or after block
+quotes:
+
+```````````````````````````````` example
+> aaa
+***
+> bbb
+.
+<blockquote>
+<p>aaa</p>
+</blockquote>
+<hr />
+<blockquote>
+<p>bbb</p>
+</blockquote>
+````````````````````````````````
+
+
+However, because of laziness, a blank line is needed between
+a block quote and a following paragraph:
+
+```````````````````````````````` example
+> bar
+baz
+.
+<blockquote>
+<p>bar
+baz</p>
+</blockquote>
+````````````````````````````````
+
+
+```````````````````````````````` example
+> bar
+
+baz
+.
+<blockquote>
+<p>bar</p>
+</blockquote>
+<p>baz</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+> bar
+>
+baz
+.
+<blockquote>
+<p>bar</p>
+</blockquote>
+<p>baz</p>
+````````````````````````````````
+
+
+It is a consequence of the Laziness rule that any number
+of initial `>`s may be omitted on a continuation line of a
+nested block quote:
+
+```````````````````````````````` example
+> > > foo
+bar
+.
+<blockquote>
+<blockquote>
+<blockquote>
+<p>foo
+bar</p>
+</blockquote>
+</blockquote>
+</blockquote>
+````````````````````````````````
+
+
+```````````````````````````````` example
+>>> foo
+> bar
+>>baz
+.
+<blockquote>
+<blockquote>
+<blockquote>
+<p>foo
+bar
+baz</p>
+</blockquote>
+</blockquote>
+</blockquote>
+````````````````````````````````
+
+
+When including an indented code block in a block quote,
+remember that the [block quote marker] includes
+both the `>` and a following space.  So *five spaces* are needed after
+the `>`:
+
+```````````````````````````````` example
+>     code
+
+>    not code
+.
+<blockquote>
+<pre><code>code
+</code></pre>
+</blockquote>
+<blockquote>
+<p>not code</p>
+</blockquote>
+````````````````````````````````
+
+
+
+## List items
+
+A [list marker](@) is a
+[bullet list marker] or an [ordered list marker].
+
+A [bullet list marker](@)
+is a `-`, `+`, or `*` character.
+
+An [ordered list marker](@)
+is a sequence of 1--9 arabic digits (`0-9`), followed by either a
+`.` character or a `)` character.  (The reason for the length
+limit is that with 10 digits we start seeing integer overflows
+in some browsers.)
+
+The following rules define [list items]:
+
+1.  **Basic case.**  If a sequence of lines *Ls* constitute a sequence of
+    blocks *Bs* starting with a [non-whitespace character] and not separated
+    from each other by more than one blank line, and *M* is a list
+    marker of width *W* followed by 1 ≤ *N* ≤ 4 spaces, then the result
+    of prepending *M* and the following spaces to the first line of
+    *Ls*, and indenting subsequent lines of *Ls* by *W + N* spaces, is a
+    list item with *Bs* as its contents.  The type of the list item
+    (bullet or ordered) is determined by the type of its list marker.
+    If the list item is ordered, then it is also assigned a start
+    number, based on the ordered list marker.
+
+    Exceptions:
+
+    1. When the first list item in a [list] interrupts
+       a paragraph---that is, when it starts on a line that would
+       otherwise count as [paragraph continuation text]---then (a)
+       the lines *Ls* must not begin with a blank line, and (b) if
+       the list item is ordered, the start number must be 1.
+    2. If any line is a [thematic break][thematic breaks] then
+       that line is not a list item.
+
+For example, let *Ls* be the lines
+
+```````````````````````````````` example
+A paragraph
+with two lines.
+
+    indented code
+
+> A block quote.
+.
+<p>A paragraph
+with two lines.</p>
+<pre><code>indented code
+</code></pre>
+<blockquote>
+<p>A block quote.</p>
+</blockquote>
+````````````````````````````````
+
+
+And let *M* be the marker `1.`, and *N* = 2.  Then rule #1 says
+that the following is an ordered list item with start number 1,
+and the same contents as *Ls*:
+
+```````````````````````````````` example
+1.  A paragraph
+    with two lines.
+
+        indented code
+
+    > A block quote.
+.
+<ol>
+<li>
+<p>A paragraph
+with two lines.</p>
+<pre><code>indented code
+</code></pre>
+<blockquote>
+<p>A block quote.</p>
+</blockquote>
+</li>
+</ol>
+````````````````````````````````
+
+
+The most important thing to notice is that the position of
+the text after the list marker determines how much indentation
+is needed in subsequent blocks in the list item.  If the list
+marker takes up two spaces, and there are three spaces between
+the list marker and the next [non-whitespace character], then blocks
+must be indented five spaces in order to fall under the list
+item.
+
+Here are some examples showing how far content must be indented to be
+put under the list item:
+
+```````````````````````````````` example
+- one
+
+ two
+.
+<ul>
+<li>one</li>
+</ul>
+<p>two</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+- one
+
+  two
+.
+<ul>
+<li>
+<p>one</p>
+<p>two</p>
+</li>
+</ul>
+````````````````````````````````
+
+
+```````````````````````````````` example
+ -    one
+
+     two
+.
+<ul>
+<li>one</li>
+</ul>
+<pre><code> two
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+ -    one
+
+      two
+.
+<ul>
+<li>
+<p>one</p>
+<p>two</p>
+</li>
+</ul>
+````````````````````````````````
+
+
+It is tempting to think of this in terms of columns:  the continuation
+blocks must be indented at least to the column of the first
+[non-whitespace character] after the list marker. However, that is not quite right.
+The spaces after the list marker determine how much relative indentation
+is needed.  Which column this indentation reaches will depend on
+how the list item is embedded in other constructions, as shown by
+this example:
+
+```````````````````````````````` example
+   > > 1.  one
+>>
+>>     two
+.
+<blockquote>
+<blockquote>
+<ol>
+<li>
+<p>one</p>
+<p>two</p>
+</li>
+</ol>
+</blockquote>
+</blockquote>
+````````````````````````````````
+
+
+Here `two` occurs in the same column as the list marker `1.`,
+but is actually contained in the list item, because there is
+sufficient indentation after the last containing blockquote marker.
+
+The converse is also possible.  In the following example, the word `two`
+occurs far to the right of the initial text of the list item, `one`, but
+it is not considered part of the list item, because it is not indented
+far enough past the blockquote marker:
+
+```````````````````````````````` example
+>>- one
+>>
+  >  > two
+.
+<blockquote>
+<blockquote>
+<ul>
+<li>one</li>
+</ul>
+<p>two</p>
+</blockquote>
+</blockquote>
+````````````````````````````````
+
+
+Note that at least one space is needed between the list marker and
+any following content, so these are not list items:
+
+```````````````````````````````` example
+-one
+
+2.two
+.
+<p>-one</p>
+<p>2.two</p>
+````````````````````````````````
+
+
+A list item may contain blocks that are separated by more than
+one blank line.
+
+```````````````````````````````` example
+- foo
+
+
+  bar
+.
+<ul>
+<li>
+<p>foo</p>
+<p>bar</p>
+</li>
+</ul>
+````````````````````````````````
+
+
+A list item may contain any kind of block:
+
+```````````````````````````````` example
+1.  foo
+
+    ```
+    bar
+    ```
+
+    baz
+
+    > bam
+.
+<ol>
+<li>
+<p>foo</p>
+<pre><code>bar
+</code></pre>
+<p>baz</p>
+<blockquote>
+<p>bam</p>
+</blockquote>
+</li>
+</ol>
+````````````````````````````````
+
+
+A list item that contains an indented code block will preserve
+empty lines within the code block verbatim.
+
+```````````````````````````````` example
+- Foo
+
+      bar
+
+
+      baz
+.
+<ul>
+<li>
+<p>Foo</p>
+<pre><code>bar
+
+
+baz
+</code></pre>
+</li>
+</ul>
+````````````````````````````````
+
+Note that ordered list start numbers must be nine digits or less:
+
+```````````````````````````````` example
+123456789. ok
+.
+<ol start="123456789">
+<li>ok</li>
+</ol>
+````````````````````````````````
+
+
+```````````````````````````````` example
+1234567890. not ok
+.
+<p>1234567890. not ok</p>
+````````````````````````````````
+
+
+A start number may begin with 0s:
+
+```````````````````````````````` example
+0. ok
+.
+<ol start="0">
+<li>ok</li>
+</ol>
+````````````````````````````````
+
+
+```````````````````````````````` example
+003. ok
+.
+<ol start="3">
+<li>ok</li>
+</ol>
+````````````````````````````````
+
+
+A start number may not be negative:
+
+```````````````````````````````` example
+-1. not ok
+.
+<p>-1. not ok</p>
+````````````````````````````````
+
+
+
+2.  **Item starting with indented code.**  If a sequence of lines *Ls*
+    constitute a sequence of blocks *Bs* starting with an indented code
+    block and not separated from each other by more than one blank line,
+    and *M* is a list marker of width *W* followed by
+    one space, then the result of prepending *M* and the following
+    space to the first line of *Ls*, and indenting subsequent lines of
+    *Ls* by *W + 1* spaces, is a list item with *Bs* as its contents.
+    If a line is empty, then it need not be indented.  The type of the
+    list item (bullet or ordered) is determined by the type of its list
+    marker.  If the list item is ordered, then it is also assigned a
+    start number, based on the ordered list marker.
+
+An indented code block will have to be indented four spaces beyond
+the edge of the region where text will be included in the list item.
+In the following case that is 6 spaces:
+
+```````````````````````````````` example
+- foo
+
+      bar
+.
+<ul>
+<li>
+<p>foo</p>
+<pre><code>bar
+</code></pre>
+</li>
+</ul>
+````````````````````````````````
+
+
+And in this case it is 11 spaces:
+
+```````````````````````````````` example
+  10.  foo
+
+           bar
+.
+<ol start="10">
+<li>
+<p>foo</p>
+<pre><code>bar
+</code></pre>
+</li>
+</ol>
+````````````````````````````````
+
+
+If the *first* block in the list item is an indented code block,
+then by rule #2, the contents must be indented *one* space after the
+list marker:
+
+```````````````````````````````` example
+    indented code
+
+paragraph
+
+    more code
+.
+<pre><code>indented code
+</code></pre>
+<p>paragraph</p>
+<pre><code>more code
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+1.     indented code
+
+   paragraph
+
+       more code
+.
+<ol>
+<li>
+<pre><code>indented code
+</code></pre>
+<p>paragraph</p>
+<pre><code>more code
+</code></pre>
+</li>
+</ol>
+````````````````````````````````
+
+
+Note that an additional space indent is interpreted as space
+inside the code block:
+
+```````````````````````````````` example
+1.      indented code
+
+   paragraph
+
+       more code
+.
+<ol>
+<li>
+<pre><code> indented code
+</code></pre>
+<p>paragraph</p>
+<pre><code>more code
+</code></pre>
+</li>
+</ol>
+````````````````````````````````
+
+
+Note that rules #1 and #2 only apply to two cases:  (a) cases
+in which the lines to be included in a list item begin with a
+[non-whitespace character], and (b) cases in which
+they begin with an indented code
+block.  In a case like the following, where the first block begins with
+a three-space indent, the rules do not allow us to form a list item by
+indenting the whole thing and prepending a list marker:
+
+```````````````````````````````` example
+   foo
+
+bar
+.
+<p>foo</p>
+<p>bar</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+-    foo
+
+  bar
+.
+<ul>
+<li>foo</li>
+</ul>
+<p>bar</p>
+````````````````````````````````
+
+
+This is not a significant restriction, because when a block begins
+with 1-3 spaces indent, the indentation can always be removed without
+a change in interpretation, allowing rule #1 to be applied.  So, in
+the above case:
+
+```````````````````````````````` example
+-  foo
+
+   bar
+.
+<ul>
+<li>
+<p>foo</p>
+<p>bar</p>
+</li>
+</ul>
+````````````````````````````````
+
+
+3.  **Item starting with a blank line.**  If a sequence of lines *Ls*
+    starting with a single [blank line] constitute a (possibly empty)
+    sequence of blocks *Bs*, not separated from each other by more than
+    one blank line, and *M* is a list marker of width *W*,
+    then the result of prepending *M* to the first line of *Ls*, and
+    indenting subsequent lines of *Ls* by *W + 1* spaces, is a list
+    item with *Bs* as its contents.
+    If a line is empty, then it need not be indented.  The type of the
+    list item (bullet or ordered) is determined by the type of its list
+    marker.  If the list item is ordered, then it is also assigned a
+    start number, based on the ordered list marker.
+
+Here are some list items that start with a blank line but are not empty:
+
+```````````````````````````````` example
+-
+  foo
+-
+  ```
+  bar
+  ```
+-
+      baz
+.
+<ul>
+<li>foo</li>
+<li>
+<pre><code>bar
+</code></pre>
+</li>
+<li>
+<pre><code>baz
+</code></pre>
+</li>
+</ul>
+````````````````````````````````
+
+When the list item starts with a blank line, the number of spaces
+following the list marker doesn't change the required indentation:
+
+```````````````````````````````` example
+-   
+  foo
+.
+<ul>
+<li>foo</li>
+</ul>
+````````````````````````````````
+
+
+A list item can begin with at most one blank line.
+In the following example, `foo` is not part of the list
+item:
+
+```````````````````````````````` example
+-
+
+  foo
+.
+<ul>
+<li></li>
+</ul>
+<p>foo</p>
+````````````````````````````````
+
+
+Here is an empty bullet list item:
+
+```````````````````````````````` example
+- foo
+-
+- bar
+.
+<ul>
+<li>foo</li>
+<li></li>
+<li>bar</li>
+</ul>
+````````````````````````````````
+
+
+It does not matter whether there are spaces following the [list marker]:
+
+```````````````````````````````` example
+- foo
+-   
+- bar
+.
+<ul>
+<li>foo</li>
+<li></li>
+<li>bar</li>
+</ul>
+````````````````````````````````
+
+
+Here is an empty ordered list item:
+
+```````````````````````````````` example
+1. foo
+2.
+3. bar
+.
+<ol>
+<li>foo</li>
+<li></li>
+<li>bar</li>
+</ol>
+````````````````````````````````
+
+
+A list may start or end with an empty list item:
+
+```````````````````````````````` example
+*
+.
+<ul>
+<li></li>
+</ul>
+````````````````````````````````
+
+However, an empty list item cannot interrupt a paragraph:
+
+```````````````````````````````` example
+foo
+*
+
+foo
+1.
+.
+<p>foo
+*</p>
+<p>foo
+1.</p>
+````````````````````````````````
+
+
+4.  **Indentation.**  If a sequence of lines *Ls* constitutes a list item
+    according to rule #1, #2, or #3, then the result of indenting each line
+    of *Ls* by 1-3 spaces (the same for each line) also constitutes a
+    list item with the same contents and attributes.  If a line is
+    empty, then it need not be indented.
+
+Indented one space:
+
+```````````````````````````````` example
+ 1.  A paragraph
+     with two lines.
+
+         indented code
+
+     > A block quote.
+.
+<ol>
+<li>
+<p>A paragraph
+with two lines.</p>
+<pre><code>indented code
+</code></pre>
+<blockquote>
+<p>A block quote.</p>
+</blockquote>
+</li>
+</ol>
+````````````````````````````````
+
+
+Indented two spaces:
+
+```````````````````````````````` example
+  1.  A paragraph
+      with two lines.
+
+          indented code
+
+      > A block quote.
+.
+<ol>
+<li>
+<p>A paragraph
+with two lines.</p>
+<pre><code>indented code
+</code></pre>
+<blockquote>
+<p>A block quote.</p>
+</blockquote>
+</li>
+</ol>
+````````````````````````````````
+
+
+Indented three spaces:
+
+```````````````````````````````` example
+   1.  A paragraph
+       with two lines.
+
+           indented code
+
+       > A block quote.
+.
+<ol>
+<li>
+<p>A paragraph
+with two lines.</p>
+<pre><code>indented code
+</code></pre>
+<blockquote>
+<p>A block quote.</p>
+</blockquote>
+</li>
+</ol>
+````````````````````````````````
+
+
+Four spaces indent gives a code block:
+
+```````````````````````````````` example
+    1.  A paragraph
+        with two lines.
+
+            indented code
+
+        > A block quote.
+.
+<pre><code>1.  A paragraph
+    with two lines.
+
+        indented code
+
+    &gt; A block quote.
+</code></pre>
+````````````````````````````````
+
+
+
+5.  **Laziness.**  If a string of lines *Ls* constitute a [list
+    item](#list-items) with contents *Bs*, then the result of deleting
+    some or all of the indentation from one or more lines in which the
+    next [non-whitespace character] after the indentation is
+    [paragraph continuation text] is a
+    list item with the same contents and attributes.  The unindented
+    lines are called
+    [lazy continuation line](@)s.
+
+Here is an example with [lazy continuation lines]:
+
+```````````````````````````````` example
+  1.  A paragraph
+with two lines.
+
+          indented code
+
+      > A block quote.
+.
+<ol>
+<li>
+<p>A paragraph
+with two lines.</p>
+<pre><code>indented code
+</code></pre>
+<blockquote>
+<p>A block quote.</p>
+</blockquote>
+</li>
+</ol>
+````````````````````````````````
+
+
+Indentation can be partially deleted:
+
+```````````````````````````````` example
+  1.  A paragraph
+    with two lines.
+.
+<ol>
+<li>A paragraph
+with two lines.</li>
+</ol>
+````````````````````````````````
+
+
+These examples show how laziness can work in nested structures:
+
+```````````````````````````````` example
+> 1. > Blockquote
+continued here.
+.
+<blockquote>
+<ol>
+<li>
+<blockquote>
+<p>Blockquote
+continued here.</p>
+</blockquote>
+</li>
+</ol>
+</blockquote>
+````````````````````````````````
+
+
+```````````````````````````````` example
+> 1. > Blockquote
+> continued here.
+.
+<blockquote>
+<ol>
+<li>
+<blockquote>
+<p>Blockquote
+continued here.</p>
+</blockquote>
+</li>
+</ol>
+</blockquote>
+````````````````````````````````
+
+
+
+6.  **That's all.** Nothing that is not counted as a list item by rules
+    #1--5 counts as a [list item](#list-items).
+
+The rules for sublists follow from the general rules above.  A sublist
+must be indented the same number of spaces a paragraph would need to be
+in order to be included in the list item.
+
+So, in this case we need two spaces indent:
+
+```````````````````````````````` example
+- foo
+  - bar
+    - baz
+      - boo
+.
+<ul>
+<li>foo
+<ul>
+<li>bar
+<ul>
+<li>baz
+<ul>
+<li>boo</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+````````````````````````````````
+
+
+One is not enough:
+
+```````````````````````````````` example
+- foo
+ - bar
+  - baz
+   - boo
+.
+<ul>
+<li>foo</li>
+<li>bar</li>
+<li>baz</li>
+<li>boo</li>
+</ul>
+````````````````````````````````
+
+
+Here we need four, because the list marker is wider:
+
+```````````````````````````````` example
+10) foo
+    - bar
+.
+<ol start="10">
+<li>foo
+<ul>
+<li>bar</li>
+</ul>
+</li>
+</ol>
+````````````````````````````````
+
+
+Three is not enough:
+
+```````````````````````````````` example
+10) foo
+   - bar
+.
+<ol start="10">
+<li>foo</li>
+</ol>
+<ul>
+<li>bar</li>
+</ul>
+````````````````````````````````
+
+
+A list may be the first block in a list item:
+
+```````````````````````````````` example
+- - foo
+.
+<ul>
+<li>
+<ul>
+<li>foo</li>
+</ul>
+</li>
+</ul>
+````````````````````````````````
+
+
+```````````````````````````````` example
+1. - 2. foo
+.
+<ol>
+<li>
+<ul>
+<li>
+<ol start="2">
+<li>foo</li>
+</ol>
+</li>
+</ul>
+</li>
+</ol>
+````````````````````````````````
+
+
+A list item can contain a heading:
+
+```````````````````````````````` example
+- # Foo
+- Bar
+  ---
+  baz
+.
+<ul>
+<li>
+<h1>Foo</h1>
+</li>
+<li>
+<h2>Bar</h2>
+baz</li>
+</ul>
+````````````````````````````````
+
+
+### Motivation
+
+John Gruber's Markdown spec says the following about list items:
+
+1. "List markers typically start at the left margin, but may be indented
+   by up to three spaces. List markers must be followed by one or more
+   spaces or a tab."
+
+2. "To make lists look nice, you can wrap items with hanging indents....
+   But if you don't want to, you don't have to."
+
+3. "List items may consist of multiple paragraphs. Each subsequent
+   paragraph in a list item must be indented by either 4 spaces or one
+   tab."
+
+4. "It looks nice if you indent every line of the subsequent paragraphs,
+   but here again, Markdown will allow you to be lazy."
+
+5. "To put a blockquote within a list item, the blockquote's `>`
+   delimiters need to be indented."
+
+6. "To put a code block within a list item, the code block needs to be
+   indented twice — 8 spaces or two tabs."
+
+These rules specify that a paragraph under a list item must be indented
+four spaces (presumably, from the left margin, rather than the start of
+the list marker, but this is not said), and that code under a list item
+must be indented eight spaces instead of the usual four.  They also say
+that a block quote must be indented, but not by how much; however, the
+example given has four spaces indentation.  Although nothing is said
+about other kinds of block-level content, it is certainly reasonable to
+infer that *all* block elements under a list item, including other
+lists, must be indented four spaces.  This principle has been called the
+*four-space rule*.
+
+The four-space rule is clear and principled, and if the reference
+implementation `Markdown.pl` had followed it, it probably would have
+become the standard.  However, `Markdown.pl` allowed paragraphs and
+sublists to start with only two spaces indentation, at least on the
+outer level.  Worse, its behavior was inconsistent: a sublist of an
+outer-level list needed two spaces indentation, but a sublist of this
+sublist needed three spaces.  It is not surprising, then, that different
+implementations of Markdown have developed very different rules for
+determining what comes under a list item.  (Pandoc and python-Markdown,
+for example, stuck with Gruber's syntax description and the four-space
+rule, while discount, redcarpet, marked, PHP Markdown, and others
+followed `Markdown.pl`'s behavior more closely.)
+
+Unfortunately, given the divergences between implementations, there
+is no way to give a spec for list items that will be guaranteed not
+to break any existing documents.  However, the spec given here should
+correctly handle lists formatted with either the four-space rule or
+the more forgiving `Markdown.pl` behavior, provided they are laid out
+in a way that is natural for a human to read.
+
+The strategy here is to let the width and indentation of the list marker
+determine the indentation necessary for blocks to fall under the list
+item, rather than having a fixed and arbitrary number.  The writer can
+think of the body of the list item as a unit which gets indented to the
+right enough to fit the list marker (and any indentation on the list
+marker).  (The laziness rule, #5, then allows continuation lines to be
+unindented if needed.)
+
+This rule is superior, we claim, to any rule requiring a fixed level of
+indentation from the margin.  The four-space rule is clear but
+unnatural. It is quite unintuitive that
+
+``` markdown
+- foo
+
+  bar
+
+  - baz
+```
+
+should be parsed as two lists with an intervening paragraph,
+
+``` html
+<ul>
+<li>foo</li>
+</ul>
+<p>bar</p>
+<ul>
+<li>baz</li>
+</ul>
+```
+
+as the four-space rule demands, rather than a single list,
+
+``` html
+<ul>
+<li>
+<p>foo</p>
+<p>bar</p>
+<ul>
+<li>baz</li>
+</ul>
+</li>
+</ul>
+```
+
+The choice of four spaces is arbitrary.  It can be learned, but it is
+not likely to be guessed, and it trips up beginners regularly.
+
+Would it help to adopt a two-space rule?  The problem is that such
+a rule, together with the rule allowing 1--3 spaces indentation of the
+initial list marker, allows text that is indented *less than* the
+original list marker to be included in the list item. For example,
+`Markdown.pl` parses
+
+``` markdown
+   - one
+
+  two
+```
+
+as a single list item, with `two` a continuation paragraph:
+
+``` html
+<ul>
+<li>
+<p>one</p>
+<p>two</p>
+</li>
+</ul>
+```
+
+and similarly
+
+``` markdown
+>   - one
+>
+>  two
+```
+
+as
+
+``` html
+<blockquote>
+<ul>
+<li>
+<p>one</p>
+<p>two</p>
+</li>
+</ul>
+</blockquote>
+```
+
+This is extremely unintuitive.
+
+Rather than requiring a fixed indent from the margin, we could require
+a fixed indent (say, two spaces, or even one space) from the list marker (which
+may itself be indented).  This proposal would remove the last anomaly
+discussed.  Unlike the spec presented above, it would count the following
+as a list item with a subparagraph, even though the paragraph `bar`
+is not indented as far as the first paragraph `foo`:
+
+``` markdown
+ 10. foo
+
+   bar  
+```
+
+Arguably this text does read like a list item with `bar` as a subparagraph,
+which may count in favor of the proposal.  However, on this proposal indented
+code would have to be indented six spaces after the list marker.  And this
+would break a lot of existing Markdown, which has the pattern:
+
+``` markdown
+1.  foo
+
+        indented code
+```
+
+where the code is indented eight spaces.  The spec above, by contrast, will
+parse this text as expected, since the code block's indentation is measured
+from the beginning of `foo`.
+
+The one case that needs special treatment is a list item that *starts*
+with indented code.  How much indentation is required in that case, since
+we don't have a "first paragraph" to measure from?  Rule #2 simply stipulates
+that in such cases, we require one space indentation from the list marker
+(and then the normal four spaces for the indented code).  This will match the
+four-space rule in cases where the list marker plus its initial indentation
+takes four spaces (a common case), but diverge in other cases.
+
+## Lists
+
+A [list](@) is a sequence of one or more
+list items [of the same type].  The list items
+may be separated by any number of blank lines.
+
+Two list items are [of the same type](@)
+if they begin with a [list marker] of the same type.
+Two list markers are of the
+same type if (a) they are bullet list markers using the same character
+(`-`, `+`, or `*`) or (b) they are ordered list numbers with the same
+delimiter (either `.` or `)`).
+
+A list is an [ordered list](@)
+if its constituent list items begin with
+[ordered list markers], and a
+[bullet list](@) if its constituent list
+items begin with [bullet list markers].
+
+The [start number](@)
+of an [ordered list] is determined by the list number of
+its initial list item.  The numbers of subsequent list items are
+disregarded.
+
+A list is [loose](@) if any of its constituent
+list items are separated by blank lines, or if any of its constituent
+list items directly contain two block-level elements with a blank line
+between them.  Otherwise a list is [tight](@).
+(The difference in HTML output is that paragraphs in a loose list are
+wrapped in `<p>` tags, while paragraphs in a tight list are not.)
+
+Changing the bullet or ordered list delimiter starts a new list:
+
+```````````````````````````````` example
+- foo
+- bar
++ baz
+.
+<ul>
+<li>foo</li>
+<li>bar</li>
+</ul>
+<ul>
+<li>baz</li>
+</ul>
+````````````````````````````````
+
+
+```````````````````````````````` example
+1. foo
+2. bar
+3) baz
+.
+<ol>
+<li>foo</li>
+<li>bar</li>
+</ol>
+<ol start="3">
+<li>baz</li>
+</ol>
+````````````````````````````````
+
+
+In CommonMark, a list can interrupt a paragraph. That is,
+no blank line is needed to separate a paragraph from a following
+list:
+
+```````````````````````````````` example
+Foo
+- bar
+- baz
+.
+<p>Foo</p>
+<ul>
+<li>bar</li>
+<li>baz</li>
+</ul>
+````````````````````````````````
+
+`Markdown.pl` does not allow this, through fear of triggering a list
+via a numeral in a hard-wrapped line:
+
+``` markdown
+The number of windows in my house is
+14.  The number of doors is 6.
+```
+
+Oddly, though, `Markdown.pl` *does* allow a blockquote to
+interrupt a paragraph, even though the same considerations might
+apply.
+
+In CommonMark, we do allow lists to interrupt paragraphs, for
+two reasons.  First, it is natural and not uncommon for people
+to start lists without blank lines:
+
+``` markdown
+I need to buy
+- new shoes
+- a coat
+- a plane ticket
+```
+
+Second, we are attracted to a
+
+> [principle of uniformity](@):
+> if a chunk of text has a certain
+> meaning, it will continue to have the same meaning when put into a
+> container block (such as a list item or blockquote).
+
+(Indeed, the spec for [list items] and [block quotes] presupposes
+this principle.) This principle implies that if
+
+``` markdown
+  * I need to buy
+    - new shoes
+    - a coat
+    - a plane ticket
+```
+
+is a list item containing a paragraph followed by a nested sublist,
+as all Markdown implementations agree it is (though the paragraph
+may be rendered without `<p>` tags, since the list is "tight"),
+then
+
+``` markdown
+I need to buy
+- new shoes
+- a coat
+- a plane ticket
+```
+
+by itself should be a paragraph followed by a nested sublist.
+
+Since it is well established Markdown practice to allow lists to
+interrupt paragraphs inside list items, the [principle of
+uniformity] requires us to allow this outside list items as
+well.  ([reStructuredText](http://docutils.sourceforge.net/rst.html)
+takes a different approach, requiring blank lines before lists
+even inside other list items.)
+
+In order to solve of unwanted lists in paragraphs with
+hard-wrapped numerals, we allow only lists starting with `1` to
+interrupt paragraphs.  Thus,
+
+```````````````````````````````` example
+The number of windows in my house is
+14.  The number of doors is 6.
+.
+<p>The number of windows in my house is
+14.  The number of doors is 6.</p>
+````````````````````````````````
+
+We may still get an unintended result in cases like
+
+```````````````````````````````` example
+The number of windows in my house is
+1.  The number of doors is 6.
+.
+<p>The number of windows in my house is</p>
+<ol>
+<li>The number of doors is 6.</li>
+</ol>
+````````````````````````````````
+
+but this rule should prevent most spurious list captures.
+
+There can be any number of blank lines between items:
+
+```````````````````````````````` example
+- foo
+
+- bar
+
+
+- baz
+.
+<ul>
+<li>
+<p>foo</p>
+</li>
+<li>
+<p>bar</p>
+</li>
+<li>
+<p>baz</p>
+</li>
+</ul>
+````````````````````````````````
+
+```````````````````````````````` example
+- foo
+  - bar
+    - baz
+
+
+      bim
+.
+<ul>
+<li>foo
+<ul>
+<li>bar
+<ul>
+<li>
+<p>baz</p>
+<p>bim</p>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+````````````````````````````````
+
+
+To separate consecutive lists of the same type, or to separate a
+list from an indented code block that would otherwise be parsed
+as a subparagraph of the final list item, you can insert a blank HTML
+comment:
+
+```````````````````````````````` example
+- foo
+- bar
+
+<!-- -->
+
+- baz
+- bim
+.
+<ul>
+<li>foo</li>
+<li>bar</li>
+</ul>
+<!-- -->
+<ul>
+<li>baz</li>
+<li>bim</li>
+</ul>
+````````````````````````````````
+
+
+```````````````````````````````` example
+-   foo
+
+    notcode
+
+-   foo
+
+<!-- -->
+
+    code
+.
+<ul>
+<li>
+<p>foo</p>
+<p>notcode</p>
+</li>
+<li>
+<p>foo</p>
+</li>
+</ul>
+<!-- -->
+<pre><code>code
+</code></pre>
+````````````````````````````````
+
+
+List items need not be indented to the same level.  The following
+list items will be treated as items at the same list level,
+since none is indented enough to belong to the previous list
+item:
+
+```````````````````````````````` example
+- a
+ - b
+  - c
+   - d
+    - e
+   - f
+  - g
+ - h
+- i
+.
+<ul>
+<li>a</li>
+<li>b</li>
+<li>c</li>
+<li>d</li>
+<li>e</li>
+<li>f</li>
+<li>g</li>
+<li>h</li>
+<li>i</li>
+</ul>
+````````````````````````````````
+
+
+```````````````````````````````` example
+1. a
+
+  2. b
+
+    3. c
+.
+<ol>
+<li>
+<p>a</p>
+</li>
+<li>
+<p>b</p>
+</li>
+<li>
+<p>c</p>
+</li>
+</ol>
+````````````````````````````````
+
+
+This is a loose list, because there is a blank line between
+two of the list items:
+
+```````````````````````````````` example
+- a
+- b
+
+- c
+.
+<ul>
+<li>
+<p>a</p>
+</li>
+<li>
+<p>b</p>
+</li>
+<li>
+<p>c</p>
+</li>
+</ul>
+````````````````````````````````
+
+
+So is this, with a empty second item:
+
+```````````````````````````````` example
+* a
+*
+
+* c
+.
+<ul>
+<li>
+<p>a</p>
+</li>
+<li></li>
+<li>
+<p>c</p>
+</li>
+</ul>
+````````````````````````````````
+
+
+These are loose lists, even though there is no space between the items,
+because one of the items directly contains two block-level elements
+with a blank line between them:
+
+```````````````````````````````` example
+- a
+- b
+
+  c
+- d
+.
+<ul>
+<li>
+<p>a</p>
+</li>
+<li>
+<p>b</p>
+<p>c</p>
+</li>
+<li>
+<p>d</p>
+</li>
+</ul>
+````````````````````````````````
+
+
+```````````````````````````````` example
+- a
+- b
+
+  [ref]: /url
+- d
+.
+<ul>
+<li>
+<p>a</p>
+</li>
+<li>
+<p>b</p>
+</li>
+<li>
+<p>d</p>
+</li>
+</ul>
+````````````````````````````````
+
+
+This is a tight list, because the blank lines are in a code block:
+
+```````````````````````````````` example
+- a
+- ```
+  b
+
+
+  ```
+- c
+.
+<ul>
+<li>a</li>
+<li>
+<pre><code>b
+
+
+</code></pre>
+</li>
+<li>c</li>
+</ul>
+````````````````````````````````
+
+
+This is a tight list, because the blank line is between two
+paragraphs of a sublist.  So the sublist is loose while
+the outer list is tight:
+
+```````````````````````````````` example
+- a
+  - b
+
+    c
+- d
+.
+<ul>
+<li>a
+<ul>
+<li>
+<p>b</p>
+<p>c</p>
+</li>
+</ul>
+</li>
+<li>d</li>
+</ul>
+````````````````````````````````
+
+
+This is a tight list, because the blank line is inside the
+block quote:
+
+```````````````````````````````` example
+* a
+  > b
+  >
+* c
+.
+<ul>
+<li>a
+<blockquote>
+<p>b</p>
+</blockquote>
+</li>
+<li>c</li>
+</ul>
+````````````````````````````````
+
+
+This list is tight, because the consecutive block elements
+are not separated by blank lines:
+
+```````````````````````````````` example
+- a
+  > b
+  ```
+  c
+  ```
+- d
+.
+<ul>
+<li>a
+<blockquote>
+<p>b</p>
+</blockquote>
+<pre><code>c
+</code></pre>
+</li>
+<li>d</li>
+</ul>
+````````````````````````````````
+
+
+A single-paragraph list is tight:
+
+```````````````````````````````` example
+- a
+.
+<ul>
+<li>a</li>
+</ul>
+````````````````````````````````
+
+
+```````````````````````````````` example
+- a
+  - b
+.
+<ul>
+<li>a
+<ul>
+<li>b</li>
+</ul>
+</li>
+</ul>
+````````````````````````````````
+
+
+This list is loose, because of the blank line between the
+two block elements in the list item:
+
+```````````````````````````````` example
+1. ```
+   foo
+   ```
+
+   bar
+.
+<ol>
+<li>
+<pre><code>foo
+</code></pre>
+<p>bar</p>
+</li>
+</ol>
+````````````````````````````````
+
+
+Here the outer list is loose, the inner list tight:
+
+```````````````````````````````` example
+* foo
+  * bar
+
+  baz
+.
+<ul>
+<li>
+<p>foo</p>
+<ul>
+<li>bar</li>
+</ul>
+<p>baz</p>
+</li>
+</ul>
+````````````````````````````````
+
+
+```````````````````````````````` example
+- a
+  - b
+  - c
+
+- d
+  - e
+  - f
+.
+<ul>
+<li>
+<p>a</p>
+<ul>
+<li>b</li>
+<li>c</li>
+</ul>
+</li>
+<li>
+<p>d</p>
+<ul>
+<li>e</li>
+<li>f</li>
+</ul>
+</li>
+</ul>
+````````````````````````````````
+
+
+# Inlines
+
+Inlines are parsed sequentially from the beginning of the character
+stream to the end (left to right, in left-to-right languages).
+Thus, for example, in
+
+```````````````````````````````` example
+`hi`lo`
+.
+<p><code>hi</code>lo`</p>
+````````````````````````````````
+
+
+`hi` is parsed as code, leaving the backtick at the end as a literal
+backtick.
+
+## Backslash escapes
+
+Any ASCII punctuation character may be backslash-escaped:
+
+```````````````````````````````` example
+\!\"\#\$\%\&\'\(\)\*\+\,\-\.\/\:\;\<\=\>\?\@\[\\\]\^\_\`\{\|\}\~
+.
+<p>!&quot;#$%&amp;'()*+,-./:;&lt;=&gt;?@[\]^_`{|}~</p>
+````````````````````````````````
+
+
+Backslashes before other characters are treated as literal
+backslashes:
+
+```````````````````````````````` example
+\→\A\a\ \3\φ\«
+.
+<p>\→\A\a\ \3\φ\«</p>
+````````````````````````````````
+
+
+Escaped characters are treated as regular characters and do
+not have their usual Markdown meanings:
+
+```````````````````````````````` example
+\*not emphasized*
+\<br/> not a tag
+\[not a link](/foo)
+\`not code`
+1\. not a list
+\* not a list
+\# not a heading
+\[foo]: /url "not a reference"
+.
+<p>*not emphasized*
+&lt;br/&gt; not a tag
+[not a link](/foo)
+`not code`
+1. not a list
+* not a list
+# not a heading
+[foo]: /url &quot;not a reference&quot;</p>
+````````````````````````````````
+
+
+If a backslash is itself escaped, the following character is not:
+
+```````````````````````````````` example
+\\*emphasis*
+.
+<p>\<em>emphasis</em></p>
+````````````````````````````````
+
+
+A backslash at the end of the line is a [hard line break]:
+
+```````````````````````````````` example
+foo\
+bar
+.
+<p>foo<br />
+bar</p>
+````````````````````````````````
+
+
+Backslash escapes do not work in code blocks, code spans, autolinks, or
+raw HTML:
+
+```````````````````````````````` example
+`` \[\` ``
+.
+<p><code>\[\`</code></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+    \[\]
+.
+<pre><code>\[\]
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+~~~
+\[\]
+~~~
+.
+<pre><code>\[\]
+</code></pre>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<http://example.com?find=\*>
+.
+<p><a href="http://example.com?find=%5C*">http://example.com?find=\*</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<a href="/bar\/)">
+.
+<a href="/bar\/)">
+````````````````````````````````
+
+
+But they work in all other contexts, including URLs and link titles,
+link references, and [info strings] in [fenced code blocks]:
+
+```````````````````````````````` example
+[foo](/bar\* "ti\*tle")
+.
+<p><a href="/bar*" title="ti*tle">foo</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo]
+
+[foo]: /bar\* "ti\*tle"
+.
+<p><a href="/bar*" title="ti*tle">foo</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+``` foo\+bar
+foo
+```
+.
+<pre><code class="language-foo+bar">foo
+</code></pre>
+````````````````````````````````
+
+
+
+## Entity and numeric character references
+
+All valid HTML entity references and numeric character
+references, except those occuring in code blocks and code spans,
+are recognized as such and treated as equivalent to the
+corresponding Unicode characters.  Conforming CommonMark parsers
+need not store information about whether a particular character
+was represented in the source using a Unicode character or
+an entity reference.
+
+[Entity references](@) consist of `&` + any of the valid
+HTML5 entity names + `;`. The
+document <https://html.spec.whatwg.org/multipage/entities.json>
+is used as an authoritative source for the valid entity
+references and their corresponding code points.
+
+```````````````````````````````` example
+&nbsp; &amp; &copy; &AElig; &Dcaron;
+&frac34; &HilbertSpace; &DifferentialD;
+&ClockwiseContourIntegral; &ngE;
+.
+<p>  &amp; © Æ Ď
+¾ ℋ ⅆ
+∲ ≧̸</p>
+````````````````````````````````
+
+
+[Decimal numeric character
+references](@)
+consist of `&#` + a string of 1--8 arabic digits + `;`. A
+numeric character reference is parsed as the corresponding
+Unicode character. Invalid Unicode code points will be replaced by
+the REPLACEMENT CHARACTER (`U+FFFD`).  For security reasons,
+the code point `U+0000` will also be replaced by `U+FFFD`.
+
+```````````````````````````````` example
+&#35; &#1234; &#992; &#98765432; &#0;
+.
+<p># Ӓ Ϡ � �</p>
+````````````````````````````````
+
+
+[Hexadecimal numeric character
+references](@) consist of `&#` +
+either `X` or `x` + a string of 1-8 hexadecimal digits + `;`.
+They too are parsed as the corresponding Unicode character (this
+time specified with a hexadecimal numeral instead of decimal).
+
+```````````````````````````````` example
+&#X22; &#XD06; &#xcab;
+.
+<p>&quot; ആ ಫ</p>
+````````````````````````````````
+
+
+Here are some nonentities:
+
+```````````````````````````````` example
+&nbsp &x; &#; &#x;
+&ThisIsNotDefined; &hi?;
+.
+<p>&amp;nbsp &amp;x; &amp;#; &amp;#x;
+&amp;ThisIsNotDefined; &amp;hi?;</p>
+````````````````````````````````
+
+
+Although HTML5 does accept some entity references
+without a trailing semicolon (such as `&copy`), these are not
+recognized here, because it makes the grammar too ambiguous:
+
+```````````````````````````````` example
+&copy
+.
+<p>&amp;copy</p>
+````````````````````````````````
+
+
+Strings that are not on the list of HTML5 named entities are not
+recognized as entity references either:
+
+```````````````````````````````` example
+&MadeUpEntity;
+.
+<p>&amp;MadeUpEntity;</p>
+````````````````````````````````
+
+
+Entity and numeric character references are recognized in any
+context besides code spans or code blocks, including
+URLs, [link titles], and [fenced code block][] [info strings]:
+
+```````````````````````````````` example
+<a href="&ouml;&ouml;.html">
+.
+<a href="&ouml;&ouml;.html">
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo](/f&ouml;&ouml; "f&ouml;&ouml;")
+.
+<p><a href="/f%C3%B6%C3%B6" title="föö">foo</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo]
+
+[foo]: /f&ouml;&ouml; "f&ouml;&ouml;"
+.
+<p><a href="/f%C3%B6%C3%B6" title="föö">foo</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+``` f&ouml;&ouml;
+foo
+```
+.
+<pre><code class="language-föö">foo
+</code></pre>
+````````````````````````````````
+
+
+Entity and numeric character references are treated as literal
+text in code spans and code blocks:
+
+```````````````````````````````` example
+`f&ouml;&ouml;`
+.
+<p><code>f&amp;ouml;&amp;ouml;</code></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+    f&ouml;f&ouml;
+.
+<pre><code>f&amp;ouml;f&amp;ouml;
+</code></pre>
+````````````````````````````````
+
+
+## Code spans
+
+A [backtick string](@)
+is a string of one or more backtick characters (`` ` ``) that is neither
+preceded nor followed by a backtick.
+
+A [code span](@) begins with a backtick string and ends with
+a backtick string of equal length.  The contents of the code span are
+the characters between the two backtick strings, with leading and
+trailing spaces and [line endings] removed, and
+[whitespace] collapsed to single spaces.
+
+This is a simple code span:
+
+```````````````````````````````` example
+`foo`
+.
+<p><code>foo</code></p>
+````````````````````````````````
+
+
+Here two backticks are used, because the code contains a backtick.
+This example also illustrates stripping of leading and trailing spaces:
+
+```````````````````````````````` example
+`` foo ` bar  ``
+.
+<p><code>foo ` bar</code></p>
+````````````````````````````````
+
+
+This example shows the motivation for stripping leading and trailing
+spaces:
+
+```````````````````````````````` example
+` `` `
+.
+<p><code>``</code></p>
+````````````````````````````````
+
+
+[Line endings] are treated like spaces:
+
+```````````````````````````````` example
+``
+foo
+``
+.
+<p><code>foo</code></p>
+````````````````````````````````
+
+
+Interior spaces and [line endings] are collapsed into
+single spaces, just as they would be by a browser:
+
+```````````````````````````````` example
+`foo   bar
+  baz`
+.
+<p><code>foo bar baz</code></p>
+````````````````````````````````
+
+
+Not all [Unicode whitespace] (for instance, non-breaking space) is
+collapsed, however:
+
+```````````````````````````````` example
+`a  b`
+.
+<p><code>a  b</code></p>
+````````````````````````````````
+
+
+Q: Why not just leave the spaces, since browsers will collapse them
+anyway?  A:  Because we might be targeting a non-HTML format, and we
+shouldn't rely on HTML-specific rendering assumptions.
+
+(Existing implementations differ in their treatment of internal
+spaces and [line endings].  Some, including `Markdown.pl` and
+`showdown`, convert an internal [line ending] into a
+`<br />` tag.  But this makes things difficult for those who like to
+hard-wrap their paragraphs, since a line break in the midst of a code
+span will cause an unintended line break in the output.  Others just
+leave internal spaces as they are, which is fine if only HTML is being
+targeted.)
+
+```````````````````````````````` example
+`foo `` bar`
+.
+<p><code>foo `` bar</code></p>
+````````````````````````````````
+
+
+Note that backslash escapes do not work in code spans. All backslashes
+are treated literally:
+
+```````````````````````````````` example
+`foo\`bar`
+.
+<p><code>foo\</code>bar`</p>
+````````````````````````````````
+
+
+Backslash escapes are never needed, because one can always choose a
+string of *n* backtick characters as delimiters, where the code does
+not contain any strings of exactly *n* backtick characters.
+
+Code span backticks have higher precedence than any other inline
+constructs except HTML tags and autolinks.  Thus, for example, this is
+not parsed as emphasized text, since the second `*` is part of a code
+span:
+
+```````````````````````````````` example
+*foo`*`
+.
+<p>*foo<code>*</code></p>
+````````````````````````````````
+
+
+And this is not parsed as a link:
+
+```````````````````````````````` example
+[not a `link](/foo`)
+.
+<p>[not a <code>link](/foo</code>)</p>
+````````````````````````````````
+
+
+Code spans, HTML tags, and autolinks have the same precedence.
+Thus, this is code:
+
+```````````````````````````````` example
+`<a href="`">`
+.
+<p><code>&lt;a href=&quot;</code>&quot;&gt;`</p>
+````````````````````````````````
+
+
+But this is an HTML tag:
+
+```````````````````````````````` example
+<a href="`">`
+.
+<p><a href="`">`</p>
+````````````````````````````````
+
+
+And this is code:
+
+```````````````````````````````` example
+`<http://foo.bar.`baz>`
+.
+<p><code>&lt;http://foo.bar.</code>baz&gt;`</p>
+````````````````````````````````
+
+
+But this is an autolink:
+
+```````````````````````````````` example
+<http://foo.bar.`baz>`
+.
+<p><a href="http://foo.bar.%60baz">http://foo.bar.`baz</a>`</p>
+````````````````````````````````
+
+
+When a backtick string is not closed by a matching backtick string,
+we just have literal backticks:
+
+```````````````````````````````` example
+```foo``
+.
+<p>```foo``</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+`foo
+.
+<p>`foo</p>
+````````````````````````````````
+
+The following case also illustrates the need for opening and
+closing backtick strings to be equal in length:
+
+```````````````````````````````` example
+`foo``bar``
+.
+<p>`foo<code>bar</code></p>
+````````````````````````````````
+
+
+## Emphasis and strong emphasis
+
+John Gruber's original [Markdown syntax
+description](http://daringfireball.net/projects/markdown/syntax#em) says:
+
+> Markdown treats asterisks (`*`) and underscores (`_`) as indicators of
+> emphasis. Text wrapped with one `*` or `_` will be wrapped with an HTML
+> `<em>` tag; double `*`'s or `_`'s will be wrapped with an HTML `<strong>`
+> tag.
+
+This is enough for most users, but these rules leave much undecided,
+especially when it comes to nested emphasis.  The original
+`Markdown.pl` test suite makes it clear that triple `***` and
+`___` delimiters can be used for strong emphasis, and most
+implementations have also allowed the following patterns:
+
+``` markdown
+***strong emph***
+***strong** in emph*
+***emph* in strong**
+**in strong *emph***
+*in emph **strong***
+```
+
+The following patterns are less widely supported, but the intent
+is clear and they are useful (especially in contexts like bibliography
+entries):
+
+``` markdown
+*emph *with emph* in it*
+**strong **with strong** in it**
+```
+
+Many implementations have also restricted intraword emphasis to
+the `*` forms, to avoid unwanted emphasis in words containing
+internal underscores.  (It is best practice to put these in code
+spans, but users often do not.)
+
+``` markdown
+internal emphasis: foo*bar*baz
+no emphasis: foo_bar_baz
+```
+
+The rules given below capture all of these patterns, while allowing
+for efficient parsing strategies that do not backtrack.
+
+First, some definitions.  A [delimiter run](@) is either
+a sequence of one or more `*` characters that is not preceded or
+followed by a non-backslash-escaped `*` character, or a sequence
+of one or more `_` characters that is not preceded or followed by
+a non-backslash-escaped `_` character.
+
+A [left-flanking delimiter run](@) is
+a [delimiter run] that is (a) not followed by [Unicode whitespace],
+and (b) not followed by a [punctuation character], or
+preceded by [Unicode whitespace] or a [punctuation character].
+For purposes of this definition, the beginning and the end of
+the line count as Unicode whitespace.
+
+A [right-flanking delimiter run](@) is
+a [delimiter run] that is (a) not preceded by [Unicode whitespace],
+and (b) not preceded by a [punctuation character], or
+followed by [Unicode whitespace] or a [punctuation character].
+For purposes of this definition, the beginning and the end of
+the line count as Unicode whitespace.
+
+Here are some examples of delimiter runs.
+
+  - left-flanking but not right-flanking:
+
+    ```
+    ***abc
+      _abc
+    **"abc"
+     _"abc"
+    ```
+
+  - right-flanking but not left-flanking:
+
+    ```
+     abc***
+     abc_
+    "abc"**
+    "abc"_
+    ```
+
+  - Both left and right-flanking:
+
+    ```
+     abc***def
+    "abc"_"def"
+    ```
+
+  - Neither left nor right-flanking:
+
+    ```
+    abc *** def
+    a _ b
+    ```
+
+(The idea of distinguishing left-flanking and right-flanking
+delimiter runs based on the character before and the character
+after comes from Roopesh Chander's
+[vfmd](http://www.vfmd.org/vfmd-spec/specification/#procedure-for-identifying-emphasis-tags).
+vfmd uses the terminology "emphasis indicator string" instead of "delimiter
+run," and its rules for distinguishing left- and right-flanking runs
+are a bit more complex than the ones given here.)
+
+The following rules define emphasis and strong emphasis:
+
+1.  A single `*` character [can open emphasis](@)
+    iff (if and only if) it is part of a [left-flanking delimiter run].
+
+2.  A single `_` character [can open emphasis] iff
+    it is part of a [left-flanking delimiter run]
+    and either (a) not part of a [right-flanking delimiter run]
+    or (b) part of a [right-flanking delimiter run]
+    preceded by punctuation.
+
+3.  A single `*` character [can close emphasis](@)
+    iff it is part of a [right-flanking delimiter run].
+
+4.  A single `_` character [can close emphasis] iff
+    it is part of a [right-flanking delimiter run]
+    and either (a) not part of a [left-flanking delimiter run]
+    or (b) part of a [left-flanking delimiter run]
+    followed by punctuation.
+
+5.  A double `**` [can open strong emphasis](@)
+    iff it is part of a [left-flanking delimiter run].
+
+6.  A double `__` [can open strong emphasis] iff
+    it is part of a [left-flanking delimiter run]
+    and either (a) not part of a [right-flanking delimiter run]
+    or (b) part of a [right-flanking delimiter run]
+    preceded by punctuation.
+
+7.  A double `**` [can close strong emphasis](@)
+    iff it is part of a [right-flanking delimiter run].
+
+8.  A double `__` [can close strong emphasis] iff
+    it is part of a [right-flanking delimiter run]
+    and either (a) not part of a [left-flanking delimiter run]
+    or (b) part of a [left-flanking delimiter run]
+    followed by punctuation.
+
+9.  Emphasis begins with a delimiter that [can open emphasis] and ends
+    with a delimiter that [can close emphasis], and that uses the same
+    character (`_` or `*`) as the opening delimiter.  The
+    opening and closing delimiters must belong to separate
+    [delimiter runs].  If one of the delimiters can both
+    open and close emphasis, then the sum of the lengths of the
+    delimiter runs containing the opening and closing delimiters
+    must not be a multiple of 3.
+
+10. Strong emphasis begins with a delimiter that
+    [can open strong emphasis] and ends with a delimiter that
+    [can close strong emphasis], and that uses the same character
+    (`_` or `*`) as the opening delimiter.  The
+    opening and closing delimiters must belong to separate
+    [delimiter runs].  If one of the delimiters can both open
+    and close strong emphasis, then the sum of the lengths of
+    the delimiter runs containing the opening and closing
+    delimiters must not be a multiple of 3.
+
+11. A literal `*` character cannot occur at the beginning or end of
+    `*`-delimited emphasis or `**`-delimited strong emphasis, unless it
+    is backslash-escaped.
+
+12. A literal `_` character cannot occur at the beginning or end of
+    `_`-delimited emphasis or `__`-delimited strong emphasis, unless it
+    is backslash-escaped.
+
+Where rules 1--12 above are compatible with multiple parsings,
+the following principles resolve ambiguity:
+
+13. The number of nestings should be minimized. Thus, for example,
+    an interpretation `<strong>...</strong>` is always preferred to
+    `<em><em>...</em></em>`.
+
+14. An interpretation `<em><strong>...</strong></em>` is always
+    preferred to `<strong><em>...</em></strong>`.
+
+15. When two potential emphasis or strong emphasis spans overlap,
+    so that the second begins before the first ends and ends after
+    the first ends, the first takes precedence. Thus, for example,
+    `*foo _bar* baz_` is parsed as `<em>foo _bar</em> baz_` rather
+    than `*foo <em>bar* baz</em>`.
+
+16. When there are two potential emphasis or strong emphasis spans
+    with the same closing delimiter, the shorter one (the one that
+    opens later) takes precedence. Thus, for example,
+    `**foo **bar baz**` is parsed as `**foo <strong>bar baz</strong>`
+    rather than `<strong>foo **bar baz</strong>`.
+
+17. Inline code spans, links, images, and HTML tags group more tightly
+    than emphasis.  So, when there is a choice between an interpretation
+    that contains one of these elements and one that does not, the
+    former always wins.  Thus, for example, `*[foo*](bar)` is
+    parsed as `*<a href="bar">foo*</a>` rather than as
+    `<em>[foo</em>](bar)`.
+
+These rules can be illustrated through a series of examples.
+
+Rule 1:
+
+```````````````````````````````` example
+*foo bar*
+.
+<p><em>foo bar</em></p>
+````````````````````````````````
+
+
+This is not emphasis, because the opening `*` is followed by
+whitespace, and hence not part of a [left-flanking delimiter run]:
+
+```````````````````````````````` example
+a * foo bar*
+.
+<p>a * foo bar*</p>
+````````````````````````````````
+
+
+This is not emphasis, because the opening `*` is preceded
+by an alphanumeric and followed by punctuation, and hence
+not part of a [left-flanking delimiter run]:
+
+```````````````````````````````` example
+a*"foo"*
+.
+<p>a*&quot;foo&quot;*</p>
+````````````````````````````````
+
+
+Unicode nonbreaking spaces count as whitespace, too:
+
+```````````````````````````````` example
+* a *
+.
+<p>* a *</p>
+````````````````````````````````
+
+
+Intraword emphasis with `*` is permitted:
+
+```````````````````````````````` example
+foo*bar*
+.
+<p>foo<em>bar</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+5*6*78
+.
+<p>5<em>6</em>78</p>
+````````````````````````````````
+
+
+Rule 2:
+
+```````````````````````````````` example
+_foo bar_
+.
+<p><em>foo bar</em></p>
+````````````````````````````````
+
+
+This is not emphasis, because the opening `_` is followed by
+whitespace:
+
+```````````````````````````````` example
+_ foo bar_
+.
+<p>_ foo bar_</p>
+````````````````````````````````
+
+
+This is not emphasis, because the opening `_` is preceded
+by an alphanumeric and followed by punctuation:
+
+```````````````````````````````` example
+a_"foo"_
+.
+<p>a_&quot;foo&quot;_</p>
+````````````````````````````````
+
+
+Emphasis with `_` is not allowed inside words:
+
+```````````````````````````````` example
+foo_bar_
+.
+<p>foo_bar_</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+5_6_78
+.
+<p>5_6_78</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+пристаням_стремятся_
+.
+<p>пристаням_стремятся_</p>
+````````````````````````````````
+
+
+Here `_` does not generate emphasis, because the first delimiter run
+is right-flanking and the second left-flanking:
+
+```````````````````````````````` example
+aa_"bb"_cc
+.
+<p>aa_&quot;bb&quot;_cc</p>
+````````````````````````````````
+
+
+This is emphasis, even though the opening delimiter is
+both left- and right-flanking, because it is preceded by
+punctuation:
+
+```````````````````````````````` example
+foo-_(bar)_
+.
+<p>foo-<em>(bar)</em></p>
+````````````````````````````````
+
+
+Rule 3:
+
+This is not emphasis, because the closing delimiter does
+not match the opening delimiter:
+
+```````````````````````````````` example
+_foo*
+.
+<p>_foo*</p>
+````````````````````````````````
+
+
+This is not emphasis, because the closing `*` is preceded by
+whitespace:
+
+```````````````````````````````` example
+*foo bar *
+.
+<p>*foo bar *</p>
+````````````````````````````````
+
+
+A newline also counts as whitespace:
+
+```````````````````````````````` example
+*foo bar
+*
+.
+<p>*foo bar
+*</p>
+````````````````````````````````
+
+
+This is not emphasis, because the second `*` is
+preceded by punctuation and followed by an alphanumeric
+(hence it is not part of a [right-flanking delimiter run]:
+
+```````````````````````````````` example
+*(*foo)
+.
+<p>*(*foo)</p>
+````````````````````````````````
+
+
+The point of this restriction is more easily appreciated
+with this example:
+
+```````````````````````````````` example
+*(*foo*)*
+.
+<p><em>(<em>foo</em>)</em></p>
+````````````````````````````````
+
+
+Intraword emphasis with `*` is allowed:
+
+```````````````````````````````` example
+*foo*bar
+.
+<p><em>foo</em>bar</p>
+````````````````````````````````
+
+
+
+Rule 4:
+
+This is not emphasis, because the closing `_` is preceded by
+whitespace:
+
+```````````````````````````````` example
+_foo bar _
+.
+<p>_foo bar _</p>
+````````````````````````````````
+
+
+This is not emphasis, because the second `_` is
+preceded by punctuation and followed by an alphanumeric:
+
+```````````````````````````````` example
+_(_foo)
+.
+<p>_(_foo)</p>
+````````````````````````````````
+
+
+This is emphasis within emphasis:
+
+```````````````````````````````` example
+_(_foo_)_
+.
+<p><em>(<em>foo</em>)</em></p>
+````````````````````````````````
+
+
+Intraword emphasis is disallowed for `_`:
+
+```````````````````````````````` example
+_foo_bar
+.
+<p>_foo_bar</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+_пристаням_стремятся
+.
+<p>_пристаням_стремятся</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+_foo_bar_baz_
+.
+<p><em>foo_bar_baz</em></p>
+````````````````````````````````
+
+
+This is emphasis, even though the closing delimiter is
+both left- and right-flanking, because it is followed by
+punctuation:
+
+```````````````````````````````` example
+_(bar)_.
+.
+<p><em>(bar)</em>.</p>
+````````````````````````````````
+
+
+Rule 5:
+
+```````````````````````````````` example
+**foo bar**
+.
+<p><strong>foo bar</strong></p>
+````````````````````````````````
+
+
+This is not strong emphasis, because the opening delimiter is
+followed by whitespace:
+
+```````````````````````````````` example
+** foo bar**
+.
+<p>** foo bar**</p>
+````````````````````````````````
+
+
+This is not strong emphasis, because the opening `**` is preceded
+by an alphanumeric and followed by punctuation, and hence
+not part of a [left-flanking delimiter run]:
+
+```````````````````````````````` example
+a**"foo"**
+.
+<p>a**&quot;foo&quot;**</p>
+````````````````````````````````
+
+
+Intraword strong emphasis with `**` is permitted:
+
+```````````````````````````````` example
+foo**bar**
+.
+<p>foo<strong>bar</strong></p>
+````````````````````````````````
+
+
+Rule 6:
+
+```````````````````````````````` example
+__foo bar__
+.
+<p><strong>foo bar</strong></p>
+````````````````````````````````
+
+
+This is not strong emphasis, because the opening delimiter is
+followed by whitespace:
+
+```````````````````````````````` example
+__ foo bar__
+.
+<p>__ foo bar__</p>
+````````````````````````````````
+
+
+A newline counts as whitespace:
+```````````````````````````````` example
+__
+foo bar__
+.
+<p>__
+foo bar__</p>
+````````````````````````````````
+
+
+This is not strong emphasis, because the opening `__` is preceded
+by an alphanumeric and followed by punctuation:
+
+```````````````````````````````` example
+a__"foo"__
+.
+<p>a__&quot;foo&quot;__</p>
+````````````````````````````````
+
+
+Intraword strong emphasis is forbidden with `__`:
+
+```````````````````````````````` example
+foo__bar__
+.
+<p>foo__bar__</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+5__6__78
+.
+<p>5__6__78</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+пристаням__стремятся__
+.
+<p>пристаням__стремятся__</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+__foo, __bar__, baz__
+.
+<p><strong>foo, <strong>bar</strong>, baz</strong></p>
+````````````````````````````````
+
+
+This is strong emphasis, even though the opening delimiter is
+both left- and right-flanking, because it is preceded by
+punctuation:
+
+```````````````````````````````` example
+foo-__(bar)__
+.
+<p>foo-<strong>(bar)</strong></p>
+````````````````````````````````
+
+
+
+Rule 7:
+
+This is not strong emphasis, because the closing delimiter is preceded
+by whitespace:
+
+```````````````````````````````` example
+**foo bar **
+.
+<p>**foo bar **</p>
+````````````````````````````````
+
+
+(Nor can it be interpreted as an emphasized `*foo bar *`, because of
+Rule 11.)
+
+This is not strong emphasis, because the second `**` is
+preceded by punctuation and followed by an alphanumeric:
+
+```````````````````````````````` example
+**(**foo)
+.
+<p>**(**foo)</p>
+````````````````````````````````
+
+
+The point of this restriction is more easily appreciated
+with these examples:
+
+```````````````````````````````` example
+*(**foo**)*
+.
+<p><em>(<strong>foo</strong>)</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+**Gomphocarpus (*Gomphocarpus physocarpus*, syn.
+*Asclepias physocarpa*)**
+.
+<p><strong>Gomphocarpus (<em>Gomphocarpus physocarpus</em>, syn.
+<em>Asclepias physocarpa</em>)</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+**foo "*bar*" foo**
+.
+<p><strong>foo &quot;<em>bar</em>&quot; foo</strong></p>
+````````````````````````````````
+
+
+Intraword emphasis:
+
+```````````````````````````````` example
+**foo**bar
+.
+<p><strong>foo</strong>bar</p>
+````````````````````````````````
+
+
+Rule 8:
+
+This is not strong emphasis, because the closing delimiter is
+preceded by whitespace:
+
+```````````````````````````````` example
+__foo bar __
+.
+<p>__foo bar __</p>
+````````````````````````````````
+
+
+This is not strong emphasis, because the second `__` is
+preceded by punctuation and followed by an alphanumeric:
+
+```````````````````````````````` example
+__(__foo)
+.
+<p>__(__foo)</p>
+````````````````````````````````
+
+
+The point of this restriction is more easily appreciated
+with this example:
+
+```````````````````````````````` example
+_(__foo__)_
+.
+<p><em>(<strong>foo</strong>)</em></p>
+````````````````````````````````
+
+
+Intraword strong emphasis is forbidden with `__`:
+
+```````````````````````````````` example
+__foo__bar
+.
+<p>__foo__bar</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+__пристаням__стремятся
+.
+<p>__пристаням__стремятся</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+__foo__bar__baz__
+.
+<p><strong>foo__bar__baz</strong></p>
+````````````````````````````````
+
+
+This is strong emphasis, even though the closing delimiter is
+both left- and right-flanking, because it is followed by
+punctuation:
+
+```````````````````````````````` example
+__(bar)__.
+.
+<p><strong>(bar)</strong>.</p>
+````````````````````````````````
+
+
+Rule 9:
+
+Any nonempty sequence of inline elements can be the contents of an
+emphasized span.
+
+```````````````````````````````` example
+*foo [bar](/url)*
+.
+<p><em>foo <a href="/url">bar</a></em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*foo
+bar*
+.
+<p><em>foo
+bar</em></p>
+````````````````````````````````
+
+
+In particular, emphasis and strong emphasis can be nested
+inside emphasis:
+
+```````````````````````````````` example
+_foo __bar__ baz_
+.
+<p><em>foo <strong>bar</strong> baz</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+_foo _bar_ baz_
+.
+<p><em>foo <em>bar</em> baz</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+__foo_ bar_
+.
+<p><em><em>foo</em> bar</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*foo *bar**
+.
+<p><em>foo <em>bar</em></em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*foo **bar** baz*
+.
+<p><em>foo <strong>bar</strong> baz</em></p>
+````````````````````````````````
+
+```````````````````````````````` example
+*foo**bar**baz*
+.
+<p><em>foo<strong>bar</strong>baz</em></p>
+````````````````````````````````
+
+Note that in the preceding case, the interpretation
+
+``` markdown
+<p><em>foo</em><em>bar<em></em>baz</em></p>
+```
+
+
+is precluded by the condition that a delimiter that
+can both open and close (like the `*` after `foo`)
+cannot form emphasis if the sum of the lengths of
+the delimiter runs containing the opening and
+closing delimiters is a multiple of 3.
+
+The same condition ensures that the following
+cases are all strong emphasis nested inside
+emphasis, even when the interior spaces are
+omitted:
+
+
+```````````````````````````````` example
+***foo** bar*
+.
+<p><em><strong>foo</strong> bar</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*foo **bar***
+.
+<p><em>foo <strong>bar</strong></em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*foo**bar***
+.
+<p><em>foo<strong>bar</strong></em></p>
+````````````````````````````````
+
+
+Indefinite levels of nesting are possible:
+
+```````````````````````````````` example
+*foo **bar *baz* bim** bop*
+.
+<p><em>foo <strong>bar <em>baz</em> bim</strong> bop</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*foo [*bar*](/url)*
+.
+<p><em>foo <a href="/url"><em>bar</em></a></em></p>
+````````````````````````````````
+
+
+There can be no empty emphasis or strong emphasis:
+
+```````````````````````````````` example
+** is not an empty emphasis
+.
+<p>** is not an empty emphasis</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+**** is not an empty strong emphasis
+.
+<p>**** is not an empty strong emphasis</p>
+````````````````````````````````
+
+
+
+Rule 10:
+
+Any nonempty sequence of inline elements can be the contents of an
+strongly emphasized span.
+
+```````````````````````````````` example
+**foo [bar](/url)**
+.
+<p><strong>foo <a href="/url">bar</a></strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+**foo
+bar**
+.
+<p><strong>foo
+bar</strong></p>
+````````````````````````````````
+
+
+In particular, emphasis and strong emphasis can be nested
+inside strong emphasis:
+
+```````````````````````````````` example
+__foo _bar_ baz__
+.
+<p><strong>foo <em>bar</em> baz</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+__foo __bar__ baz__
+.
+<p><strong>foo <strong>bar</strong> baz</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+____foo__ bar__
+.
+<p><strong><strong>foo</strong> bar</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+**foo **bar****
+.
+<p><strong>foo <strong>bar</strong></strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+**foo *bar* baz**
+.
+<p><strong>foo <em>bar</em> baz</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+**foo*bar*baz**
+.
+<p><strong>foo<em>bar</em>baz</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+***foo* bar**
+.
+<p><strong><em>foo</em> bar</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+**foo *bar***
+.
+<p><strong>foo <em>bar</em></strong></p>
+````````````````````````````````
+
+
+Indefinite levels of nesting are possible:
+
+```````````````````````````````` example
+**foo *bar **baz**
+bim* bop**
+.
+<p><strong>foo <em>bar <strong>baz</strong>
+bim</em> bop</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+**foo [*bar*](/url)**
+.
+<p><strong>foo <a href="/url"><em>bar</em></a></strong></p>
+````````````````````````````````
+
+
+There can be no empty emphasis or strong emphasis:
+
+```````````````````````````````` example
+__ is not an empty emphasis
+.
+<p>__ is not an empty emphasis</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+____ is not an empty strong emphasis
+.
+<p>____ is not an empty strong emphasis</p>
+````````````````````````````````
+
+
+
+Rule 11:
+
+```````````````````````````````` example
+foo ***
+.
+<p>foo ***</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo *\**
+.
+<p>foo <em>*</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo *_*
+.
+<p>foo <em>_</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo *****
+.
+<p>foo *****</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo **\***
+.
+<p>foo <strong>*</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo **_**
+.
+<p>foo <strong>_</strong></p>
+````````````````````````````````
+
+
+Note that when delimiters do not match evenly, Rule 11 determines
+that the excess literal `*` characters will appear outside of the
+emphasis, rather than inside it:
+
+```````````````````````````````` example
+**foo*
+.
+<p>*<em>foo</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*foo**
+.
+<p><em>foo</em>*</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+***foo**
+.
+<p>*<strong>foo</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+****foo*
+.
+<p>***<em>foo</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+**foo***
+.
+<p><strong>foo</strong>*</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*foo****
+.
+<p><em>foo</em>***</p>
+````````````````````````````````
+
+
+
+Rule 12:
+
+```````````````````````````````` example
+foo ___
+.
+<p>foo ___</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo _\__
+.
+<p>foo <em>_</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo _*_
+.
+<p>foo <em>*</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo _____
+.
+<p>foo _____</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo __\___
+.
+<p>foo <strong>_</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo __*__
+.
+<p>foo <strong>*</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+__foo_
+.
+<p>_<em>foo</em></p>
+````````````````````````````````
+
+
+Note that when delimiters do not match evenly, Rule 12 determines
+that the excess literal `_` characters will appear outside of the
+emphasis, rather than inside it:
+
+```````````````````````````````` example
+_foo__
+.
+<p><em>foo</em>_</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+___foo__
+.
+<p>_<strong>foo</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+____foo_
+.
+<p>___<em>foo</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+__foo___
+.
+<p><strong>foo</strong>_</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+_foo____
+.
+<p><em>foo</em>___</p>
+````````````````````````````````
+
+
+Rule 13 implies that if you want emphasis nested directly inside
+emphasis, you must use different delimiters:
+
+```````````````````````````````` example
+**foo**
+.
+<p><strong>foo</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*_foo_*
+.
+<p><em><em>foo</em></em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+__foo__
+.
+<p><strong>foo</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+_*foo*_
+.
+<p><em><em>foo</em></em></p>
+````````````````````````````````
+
+
+However, strong emphasis within strong emphasis is possible without
+switching delimiters:
+
+```````````````````````````````` example
+****foo****
+.
+<p><strong><strong>foo</strong></strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+____foo____
+.
+<p><strong><strong>foo</strong></strong></p>
+````````````````````````````````
+
+
+
+Rule 13 can be applied to arbitrarily long sequences of
+delimiters:
+
+```````````````````````````````` example
+******foo******
+.
+<p><strong><strong><strong>foo</strong></strong></strong></p>
+````````````````````````````````
+
+
+Rule 14:
+
+```````````````````````````````` example
+***foo***
+.
+<p><em><strong>foo</strong></em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+_____foo_____
+.
+<p><em><strong><strong>foo</strong></strong></em></p>
+````````````````````````````````
+
+
+Rule 15:
+
+```````````````````````````````` example
+*foo _bar* baz_
+.
+<p><em>foo _bar</em> baz_</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*foo __bar *baz bim__ bam*
+.
+<p><em>foo <strong>bar *baz bim</strong> bam</em></p>
+````````````````````````````````
+
+
+Rule 16:
+
+```````````````````````````````` example
+**foo **bar baz**
+.
+<p>**foo <strong>bar baz</strong></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*foo *bar baz*
+.
+<p>*foo <em>bar baz</em></p>
+````````````````````````````````
+
+
+Rule 17:
+
+```````````````````````````````` example
+*[bar*](/url)
+.
+<p>*<a href="/url">bar*</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+_foo [bar_](/url)
+.
+<p>_foo <a href="/url">bar_</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*<img src="foo" title="*"/>
+.
+<p>*<img src="foo" title="*"/></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+**<a href="**">
+.
+<p>**<a href="**"></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+__<a href="__">
+.
+<p>__<a href="__"></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*a `*`*
+.
+<p><em>a <code>*</code></em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+_a `_`_
+.
+<p><em>a <code>_</code></em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+**a<http://foo.bar/?q=**>
+.
+<p>**a<a href="http://foo.bar/?q=**">http://foo.bar/?q=**</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+__a<http://foo.bar/?q=__>
+.
+<p>__a<a href="http://foo.bar/?q=__">http://foo.bar/?q=__</a></p>
+````````````````````````````````
+
+
+
+## Links
+
+A link contains [link text] (the visible text), a [link destination]
+(the URI that is the link destination), and optionally a [link title].
+There are two basic kinds of links in Markdown.  In [inline links] the
+destination and title are given immediately after the link text.  In
+[reference links] the destination and title are defined elsewhere in
+the document.
+
+A [link text](@) consists of a sequence of zero or more
+inline elements enclosed by square brackets (`[` and `]`).  The
+following rules apply:
+
+- Links may not contain other links, at any level of nesting. If
+  multiple otherwise valid link definitions appear nested inside each
+  other, the inner-most definition is used.
+
+- Brackets are allowed in the [link text] only if (a) they
+  are backslash-escaped or (b) they appear as a matched pair of brackets,
+  with an open bracket `[`, a sequence of zero or more inlines, and
+  a close bracket `]`.
+
+- Backtick [code spans], [autolinks], and raw [HTML tags] bind more tightly
+  than the brackets in link text.  Thus, for example,
+  `` [foo`]` `` could not be a link text, since the second `]`
+  is part of a code span.
+
+- The brackets in link text bind more tightly than markers for
+  [emphasis and strong emphasis]. Thus, for example, `*[foo*](url)` is a link.
+
+A [link destination](@) consists of either
+
+- a sequence of zero or more characters between an opening `<` and a
+  closing `>` that contains no spaces, line breaks, or unescaped
+  `<` or `>` characters, or
+
+- a nonempty sequence of characters that does not include
+  ASCII space or control characters, and includes parentheses
+  only if (a) they are backslash-escaped or (b) they are part of
+  a balanced pair of unescaped parentheses.  (Implementations
+  may impose limits on parentheses nesting to avoid performance
+  issues, but at least three levels of nesting should be supported.)
+
+A [link title](@)  consists of either
+
+- a sequence of zero or more characters between straight double-quote
+  characters (`"`), including a `"` character only if it is
+  backslash-escaped, or
+
+- a sequence of zero or more characters between straight single-quote
+  characters (`'`), including a `'` character only if it is
+  backslash-escaped, or
+
+- a sequence of zero or more characters between matching parentheses
+  (`(...)`), including a `)` character only if it is backslash-escaped.
+
+Although [link titles] may span multiple lines, they may not contain
+a [blank line].
+
+An [inline link](@) consists of a [link text] followed immediately
+by a left parenthesis `(`, optional [whitespace], an optional
+[link destination], an optional [link title] separated from the link
+destination by [whitespace], optional [whitespace], and a right
+parenthesis `)`. The link's text consists of the inlines contained
+in the [link text] (excluding the enclosing square brackets).
+The link's URI consists of the link destination, excluding enclosing
+`<...>` if present, with backslash-escapes in effect as described
+above.  The link's title consists of the link title, excluding its
+enclosing delimiters, with backslash-escapes in effect as described
+above.
+
+Here is a simple inline link:
+
+```````````````````````````````` example
+[link](/uri "title")
+.
+<p><a href="/uri" title="title">link</a></p>
+````````````````````````````````
+
+
+The title may be omitted:
+
+```````````````````````````````` example
+[link](/uri)
+.
+<p><a href="/uri">link</a></p>
+````````````````````````````````
+
+
+Both the title and the destination may be omitted:
+
+```````````````````````````````` example
+[link]()
+.
+<p><a href="">link</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[link](<>)
+.
+<p><a href="">link</a></p>
+````````````````````````````````
+
+
+The destination cannot contain spaces or line breaks,
+even if enclosed in pointy brackets:
+
+```````````````````````````````` example
+[link](/my uri)
+.
+<p>[link](/my uri)</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[link](</my uri>)
+.
+<p>[link](&lt;/my uri&gt;)</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[link](foo
+bar)
+.
+<p>[link](foo
+bar)</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[link](<foo
+bar>)
+.
+<p>[link](<foo
+bar>)</p>
+````````````````````````````````
+
+Parentheses inside the link destination may be escaped:
+
+```````````````````````````````` example
+[link](\(foo\))
+.
+<p><a href="(foo)">link</a></p>
+````````````````````````````````
+
+Any number of parentheses are allowed without escaping, as long as they are
+balanced:
+
+```````````````````````````````` example
+[link](foo(and(bar)))
+.
+<p><a href="foo(and(bar))">link</a></p>
+````````````````````````````````
+
+However, if you have unbalanced parentheses, you need to escape or use the
+`<...>` form:
+
+```````````````````````````````` example
+[link](foo\(and\(bar\))
+.
+<p><a href="foo(and(bar)">link</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[link](<foo(and(bar)>)
+.
+<p><a href="foo(and(bar)">link</a></p>
+````````````````````````````````
+
+
+Parentheses and other symbols can also be escaped, as usual
+in Markdown:
+
+```````````````````````````````` example
+[link](foo\)\:)
+.
+<p><a href="foo):">link</a></p>
+````````````````````````````````
+
+
+A link can contain fragment identifiers and queries:
+
+```````````````````````````````` example
+[link](#fragment)
+
+[link](http://example.com#fragment)
+
+[link](http://example.com?foo=3#frag)
+.
+<p><a href="#fragment">link</a></p>
+<p><a href="http://example.com#fragment">link</a></p>
+<p><a href="http://example.com?foo=3#frag">link</a></p>
+````````````````````````````````
+
+
+Note that a backslash before a non-escapable character is
+just a backslash:
+
+```````````````````````````````` example
+[link](foo\bar)
+.
+<p><a href="foo%5Cbar">link</a></p>
+````````````````````````````````
+
+
+URL-escaping should be left alone inside the destination, as all
+URL-escaped characters are also valid URL characters. Entity and
+numerical character references in the destination will be parsed
+into the corresponding Unicode code points, as usual.  These may
+be optionally URL-escaped when written as HTML, but this spec
+does not enforce any particular policy for rendering URLs in
+HTML or other formats.  Renderers may make different decisions
+about how to escape or normalize URLs in the output.
+
+```````````````````````````````` example
+[link](foo%20b&auml;)
+.
+<p><a href="foo%20b%C3%A4">link</a></p>
+````````````````````````````````
+
+
+Note that, because titles can often be parsed as destinations,
+if you try to omit the destination and keep the title, you'll
+get unexpected results:
+
+```````````````````````````````` example
+[link]("title")
+.
+<p><a href="%22title%22">link</a></p>
+````````````````````````````````
+
+
+Titles may be in single quotes, double quotes, or parentheses:
+
+```````````````````````````````` example
+[link](/url "title")
+[link](/url 'title')
+[link](/url (title))
+.
+<p><a href="/url" title="title">link</a>
+<a href="/url" title="title">link</a>
+<a href="/url" title="title">link</a></p>
+````````````````````````````````
+
+
+Backslash escapes and entity and numeric character references
+may be used in titles:
+
+```````````````````````````````` example
+[link](/url "title \"&quot;")
+.
+<p><a href="/url" title="title &quot;&quot;">link</a></p>
+````````````````````````````````
+
+
+Titles must be separated from the link using a [whitespace].
+Other [Unicode whitespace] like non-breaking space doesn't work.
+
+```````````````````````````````` example
+[link](/url "title")
+.
+<p><a href="/url%C2%A0%22title%22">link</a></p>
+````````````````````````````````
+
+
+Nested balanced quotes are not allowed without escaping:
+
+```````````````````````````````` example
+[link](/url "title "and" title")
+.
+<p>[link](/url &quot;title &quot;and&quot; title&quot;)</p>
+````````````````````````````````
+
+
+But it is easy to work around this by using a different quote type:
+
+```````````````````````````````` example
+[link](/url 'title "and" title')
+.
+<p><a href="/url" title="title &quot;and&quot; title">link</a></p>
+````````````````````````````````
+
+
+(Note:  `Markdown.pl` did allow double quotes inside a double-quoted
+title, and its test suite included a test demonstrating this.
+But it is hard to see a good rationale for the extra complexity this
+brings, since there are already many ways---backslash escaping,
+entity and numeric character references, or using a different
+quote type for the enclosing title---to write titles containing
+double quotes.  `Markdown.pl`'s handling of titles has a number
+of other strange features.  For example, it allows single-quoted
+titles in inline links, but not reference links.  And, in
+reference links but not inline links, it allows a title to begin
+with `"` and end with `)`.  `Markdown.pl` 1.0.1 even allows
+titles with no closing quotation mark, though 1.0.2b8 does not.
+It seems preferable to adopt a simple, rational rule that works
+the same way in inline links and link reference definitions.)
+
+[Whitespace] is allowed around the destination and title:
+
+```````````````````````````````` example
+[link](   /uri
+  "title"  )
+.
+<p><a href="/uri" title="title">link</a></p>
+````````````````````````````````
+
+
+But it is not allowed between the link text and the
+following parenthesis:
+
+```````````````````````````````` example
+[link] (/uri)
+.
+<p>[link] (/uri)</p>
+````````````````````````````````
+
+
+The link text may contain balanced brackets, but not unbalanced ones,
+unless they are escaped:
+
+```````````````````````````````` example
+[link [foo [bar]]](/uri)
+.
+<p><a href="/uri">link [foo [bar]]</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[link] bar](/uri)
+.
+<p>[link] bar](/uri)</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[link [bar](/uri)
+.
+<p>[link <a href="/uri">bar</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[link \[bar](/uri)
+.
+<p><a href="/uri">link [bar</a></p>
+````````````````````````````````
+
+
+The link text may contain inline content:
+
+```````````````````````````````` example
+[link *foo **bar** `#`*](/uri)
+.
+<p><a href="/uri">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[![moon](moon.jpg)](/uri)
+.
+<p><a href="/uri"><img src="moon.jpg" alt="moon" /></a></p>
+````````````````````````````````
+
+
+However, links may not contain other links, at any level of nesting.
+
+```````````````````````````````` example
+[foo [bar](/uri)](/uri)
+.
+<p>[foo <a href="/uri">bar</a>](/uri)</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo *[bar [baz](/uri)](/uri)*](/uri)
+.
+<p>[foo <em>[bar <a href="/uri">baz</a>](/uri)</em>](/uri)</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+![[[foo](uri1)](uri2)](uri3)
+.
+<p><img src="uri3" alt="[foo](uri2)" /></p>
+````````````````````````````````
+
+
+These cases illustrate the precedence of link text grouping over
+emphasis grouping:
+
+```````````````````````````````` example
+*[foo*](/uri)
+.
+<p>*<a href="/uri">foo*</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo *bar](baz*)
+.
+<p><a href="baz*">foo *bar</a></p>
+````````````````````````````````
+
+
+Note that brackets that *aren't* part of links do not take
+precedence:
+
+```````````````````````````````` example
+*foo [bar* baz]
+.
+<p><em>foo [bar</em> baz]</p>
+````````````````````````````````
+
+
+These cases illustrate the precedence of HTML tags, code spans,
+and autolinks over link grouping:
+
+```````````````````````````````` example
+[foo <bar attr="](baz)">
+.
+<p>[foo <bar attr="](baz)"></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo`](/uri)`
+.
+<p>[foo<code>](/uri)</code></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo<http://example.com/?search=](uri)>
+.
+<p>[foo<a href="http://example.com/?search=%5D(uri)">http://example.com/?search=](uri)</a></p>
+````````````````````````````````
+
+
+There are three kinds of [reference link](@)s:
+[full](#full-reference-link), [collapsed](#collapsed-reference-link),
+and [shortcut](#shortcut-reference-link).
+
+A [full reference link](@)
+consists of a [link text] immediately followed by a [link label]
+that [matches] a [link reference definition] elsewhere in the document.
+
+A [link label](@)  begins with a left bracket (`[`) and ends
+with the first right bracket (`]`) that is not backslash-escaped.
+Between these brackets there must be at least one [non-whitespace character].
+Unescaped square bracket characters are not allowed inside the
+opening and closing square brackets of [link labels].  A link
+label can have at most 999 characters inside the square
+brackets.
+
+One label [matches](@)
+another just in case their normalized forms are equal.  To normalize a
+label, strip off the opening and closing brackets,
+perform the *Unicode case fold*, strip leading and trailing
+[whitespace] and collapse consecutive internal
+[whitespace] to a single space.  If there are multiple
+matching reference link definitions, the one that comes first in the
+document is used.  (It is desirable in such cases to emit a warning.)
+
+The contents of the first link label are parsed as inlines, which are
+used as the link's text.  The link's URI and title are provided by the
+matching [link reference definition].
+
+Here is a simple example:
+
+```````````````````````````````` example
+[foo][bar]
+
+[bar]: /url "title"
+.
+<p><a href="/url" title="title">foo</a></p>
+````````````````````````````````
+
+
+The rules for the [link text] are the same as with
+[inline links].  Thus:
+
+The link text may contain balanced brackets, but not unbalanced ones,
+unless they are escaped:
+
+```````````````````````````````` example
+[link [foo [bar]]][ref]
+
+[ref]: /uri
+.
+<p><a href="/uri">link [foo [bar]]</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[link \[bar][ref]
+
+[ref]: /uri
+.
+<p><a href="/uri">link [bar</a></p>
+````````````````````````````````
+
+
+The link text may contain inline content:
+
+```````````````````````````````` example
+[link *foo **bar** `#`*][ref]
+
+[ref]: /uri
+.
+<p><a href="/uri">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[![moon](moon.jpg)][ref]
+
+[ref]: /uri
+.
+<p><a href="/uri"><img src="moon.jpg" alt="moon" /></a></p>
+````````````````````````````````
+
+
+However, links may not contain other links, at any level of nesting.
+
+```````````````````````````````` example
+[foo [bar](/uri)][ref]
+
+[ref]: /uri
+.
+<p>[foo <a href="/uri">bar</a>]<a href="/uri">ref</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo *bar [baz][ref]*][ref]
+
+[ref]: /uri
+.
+<p>[foo <em>bar <a href="/uri">baz</a></em>]<a href="/uri">ref</a></p>
+````````````````````````````````
+
+
+(In the examples above, we have two [shortcut reference links]
+instead of one [full reference link].)
+
+The following cases illustrate the precedence of link text grouping over
+emphasis grouping:
+
+```````````````````````````````` example
+*[foo*][ref]
+
+[ref]: /uri
+.
+<p>*<a href="/uri">foo*</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo *bar][ref]
+
+[ref]: /uri
+.
+<p><a href="/uri">foo *bar</a></p>
+````````````````````````````````
+
+
+These cases illustrate the precedence of HTML tags, code spans,
+and autolinks over link grouping:
+
+```````````````````````````````` example
+[foo <bar attr="][ref]">
+
+[ref]: /uri
+.
+<p>[foo <bar attr="][ref]"></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo`][ref]`
+
+[ref]: /uri
+.
+<p>[foo<code>][ref]</code></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo<http://example.com/?search=][ref]>
+
+[ref]: /uri
+.
+<p>[foo<a href="http://example.com/?search=%5D%5Bref%5D">http://example.com/?search=][ref]</a></p>
+````````````````````````````````
+
+
+Matching is case-insensitive:
+
+```````````````````````````````` example
+[foo][BaR]
+
+[bar]: /url "title"
+.
+<p><a href="/url" title="title">foo</a></p>
+````````````````````````````````
+
+
+Unicode case fold is used:
+
+```````````````````````````````` example
+[Толпой][Толпой] is a Russian word.
+
+[ТОЛПОЙ]: /url
+.
+<p><a href="/url">Толпой</a> is a Russian word.</p>
+````````````````````````````````
+
+
+Consecutive internal [whitespace] is treated as one space for
+purposes of determining matching:
+
+```````````````````````````````` example
+[Foo
+  bar]: /url
+
+[Baz][Foo bar]
+.
+<p><a href="/url">Baz</a></p>
+````````````````````````````````
+
+
+No [whitespace] is allowed between the [link text] and the
+[link label]:
+
+```````````````````````````````` example
+[foo] [bar]
+
+[bar]: /url "title"
+.
+<p>[foo] <a href="/url" title="title">bar</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo]
+[bar]
+
+[bar]: /url "title"
+.
+<p>[foo]
+<a href="/url" title="title">bar</a></p>
+````````````````````````````````
+
+
+This is a departure from John Gruber's original Markdown syntax
+description, which explicitly allows whitespace between the link
+text and the link label.  It brings reference links in line with
+[inline links], which (according to both original Markdown and
+this spec) cannot have whitespace after the link text.  More
+importantly, it prevents inadvertent capture of consecutive
+[shortcut reference links]. If whitespace is allowed between the
+link text and the link label, then in the following we will have
+a single reference link, not two shortcut reference links, as
+intended:
+
+``` markdown
+[foo]
+[bar]
+
+[foo]: /url1
+[bar]: /url2
+```
+
+(Note that [shortcut reference links] were introduced by Gruber
+himself in a beta version of `Markdown.pl`, but never included
+in the official syntax description.  Without shortcut reference
+links, it is harmless to allow space between the link text and
+link label; but once shortcut references are introduced, it is
+too dangerous to allow this, as it frequently leads to
+unintended results.)
+
+When there are multiple matching [link reference definitions],
+the first is used:
+
+```````````````````````````````` example
+[foo]: /url1
+
+[foo]: /url2
+
+[bar][foo]
+.
+<p><a href="/url1">bar</a></p>
+````````````````````````````````
+
+
+Note that matching is performed on normalized strings, not parsed
+inline content.  So the following does not match, even though the
+labels define equivalent inline content:
+
+```````````````````````````````` example
+[bar][foo\!]
+
+[foo!]: /url
+.
+<p>[bar][foo!]</p>
+````````````````````````````````
+
+
+[Link labels] cannot contain brackets, unless they are
+backslash-escaped:
+
+```````````````````````````````` example
+[foo][ref[]
+
+[ref[]: /uri
+.
+<p>[foo][ref[]</p>
+<p>[ref[]: /uri</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo][ref[bar]]
+
+[ref[bar]]: /uri
+.
+<p>[foo][ref[bar]]</p>
+<p>[ref[bar]]: /uri</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[[[foo]]]
+
+[[[foo]]]: /url
+.
+<p>[[[foo]]]</p>
+<p>[[[foo]]]: /url</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[foo][ref\[]
+
+[ref\[]: /uri
+.
+<p><a href="/uri">foo</a></p>
+````````````````````````````````
+
+
+Note that in this example `]` is not backslash-escaped:
+
+```````````````````````````````` example
+[bar\\]: /uri
+
+[bar\\]
+.
+<p><a href="/uri">bar\</a></p>
+````````````````````````````````
+
+
+A [link label] must contain at least one [non-whitespace character]:
+
+```````````````````````````````` example
+[]
+
+[]: /uri
+.
+<p>[]</p>
+<p>[]: /uri</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[
+ ]
+
+[
+ ]: /uri
+.
+<p>[
+]</p>
+<p>[
+]: /uri</p>
+````````````````````````````````
+
+
+A [collapsed reference link](@)
+consists of a [link label] that [matches] a
+[link reference definition] elsewhere in the
+document, followed by the string `[]`.
+The contents of the first link label are parsed as inlines,
+which are used as the link's text.  The link's URI and title are
+provided by the matching reference link definition.  Thus,
+`[foo][]` is equivalent to `[foo][foo]`.
+
+```````````````````````````````` example
+[foo][]
+
+[foo]: /url "title"
+.
+<p><a href="/url" title="title">foo</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[*foo* bar][]
+
+[*foo* bar]: /url "title"
+.
+<p><a href="/url" title="title"><em>foo</em> bar</a></p>
+````````````````````````````````
+
+
+The link labels are case-insensitive:
+
+```````````````````````````````` example
+[Foo][]
+
+[foo]: /url "title"
+.
+<p><a href="/url" title="title">Foo</a></p>
+````````````````````````````````
+
+
+
+As with full reference links, [whitespace] is not
+allowed between the two sets of brackets:
+
+```````````````````````````````` example
+[foo] 
+[]
+
+[foo]: /url "title"
+.
+<p><a href="/url" title="title">foo</a>
+[]</p>
+````````````````````````````````
+
+
+A [shortcut reference link](@)
+consists of a [link label] that [matches] a
+[link reference definition] elsewhere in the
+document and is not followed by `[]` or a link label.
+The contents of the first link label are parsed as inlines,
+which are used as the link's text.  The link's URI and title
+are provided by the matching link reference definition.
+Thus, `[foo]` is equivalent to `[foo][]`.
+
+```````````````````````````````` example
+[foo]
+
+[foo]: /url "title"
+.
+<p><a href="/url" title="title">foo</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[*foo* bar]
+
+[*foo* bar]: /url "title"
+.
+<p><a href="/url" title="title"><em>foo</em> bar</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[[*foo* bar]]
+
+[*foo* bar]: /url "title"
+.
+<p>[<a href="/url" title="title"><em>foo</em> bar</a>]</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+[[bar [foo]
+
+[foo]: /url
+.
+<p>[[bar <a href="/url">foo</a></p>
+````````````````````````````````
+
+
+The link labels are case-insensitive:
+
+```````````````````````````````` example
+[Foo]
+
+[foo]: /url "title"
+.
+<p><a href="/url" title="title">Foo</a></p>
+````````````````````````````````
+
+
+A space after the link text should be preserved:
+
+```````````````````````````````` example
+[foo] bar
+
+[foo]: /url
+.
+<p><a href="/url">foo</a> bar</p>
+````````````````````````````````
+
+
+If you just want bracketed text, you can backslash-escape the
+opening bracket to avoid links:
+
+```````````````````````````````` example
+\[foo]
+
+[foo]: /url "title"
+.
+<p>[foo]</p>
+````````````````````````````````
+
+
+Note that this is a link, because a link label ends with the first
+following closing bracket:
+
+```````````````````````````````` example
+[foo*]: /url
+
+*[foo*]
+.
+<p>*<a href="/url">foo*</a></p>
+````````````````````````````````
+
+
+Full and compact references take precedence over shortcut
+references:
+
+```````````````````````````````` example
+[foo][bar]
+
+[foo]: /url1
+[bar]: /url2
+.
+<p><a href="/url2">foo</a></p>
+````````````````````````````````
+
+```````````````````````````````` example
+[foo][]
+
+[foo]: /url1
+.
+<p><a href="/url1">foo</a></p>
+````````````````````````````````
+
+Inline links also take precedence:
+
+```````````````````````````````` example
+[foo]()
+
+[foo]: /url1
+.
+<p><a href="">foo</a></p>
+````````````````````````````````
+
+```````````````````````````````` example
+[foo](not a link)
+
+[foo]: /url1
+.
+<p><a href="/url1">foo</a>(not a link)</p>
+````````````````````````````````
+
+In the following case `[bar][baz]` is parsed as a reference,
+`[foo]` as normal text:
+
+```````````````````````````````` example
+[foo][bar][baz]
+
+[baz]: /url
+.
+<p>[foo]<a href="/url">bar</a></p>
+````````````````````````````````
+
+
+Here, though, `[foo][bar]` is parsed as a reference, since
+`[bar]` is defined:
+
+```````````````````````````````` example
+[foo][bar][baz]
+
+[baz]: /url1
+[bar]: /url2
+.
+<p><a href="/url2">foo</a><a href="/url1">baz</a></p>
+````````````````````````````````
+
+
+Here `[foo]` is not parsed as a shortcut reference, because it
+is followed by a link label (even though `[bar]` is not defined):
+
+```````````````````````````````` example
+[foo][bar][baz]
+
+[baz]: /url1
+[foo]: /url2
+.
+<p>[foo]<a href="/url1">bar</a></p>
+````````````````````````````````
+
+
+
+## Images
+
+Syntax for images is like the syntax for links, with one
+difference. Instead of [link text], we have an
+[image description](@).  The rules for this are the
+same as for [link text], except that (a) an
+image description starts with `![` rather than `[`, and
+(b) an image description may contain links.
+An image description has inline elements
+as its contents.  When an image is rendered to HTML,
+this is standardly used as the image's `alt` attribute.
+
+```````````````````````````````` example
+![foo](/url "title")
+.
+<p><img src="/url" alt="foo" title="title" /></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+![foo *bar*]
+
+[foo *bar*]: train.jpg "train & tracks"
+.
+<p><img src="train.jpg" alt="foo bar" title="train &amp; tracks" /></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+![foo ![bar](/url)](/url2)
+.
+<p><img src="/url2" alt="foo bar" /></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+![foo [bar](/url)](/url2)
+.
+<p><img src="/url2" alt="foo bar" /></p>
+````````````````````````````````
+
+
+Though this spec is concerned with parsing, not rendering, it is
+recommended that in rendering to HTML, only the plain string content
+of the [image description] be used.  Note that in
+the above example, the alt attribute's value is `foo bar`, not `foo
+[bar](/url)` or `foo <a href="/url">bar</a>`.  Only the plain string
+content is rendered, without formatting.
+
+```````````````````````````````` example
+![foo *bar*][]
+
+[foo *bar*]: train.jpg "train & tracks"
+.
+<p><img src="train.jpg" alt="foo bar" title="train &amp; tracks" /></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+![foo *bar*][foobar]
+
+[FOOBAR]: train.jpg "train & tracks"
+.
+<p><img src="train.jpg" alt="foo bar" title="train &amp; tracks" /></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+![foo](train.jpg)
+.
+<p><img src="train.jpg" alt="foo" /></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+My ![foo bar](/path/to/train.jpg  "title"   )
+.
+<p>My <img src="/path/to/train.jpg" alt="foo bar" title="title" /></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+![foo](<url>)
+.
+<p><img src="url" alt="foo" /></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+![](/url)
+.
+<p><img src="/url" alt="" /></p>
+````````````````````````````````
+
+
+Reference-style:
+
+```````````````````````````````` example
+![foo][bar]
+
+[bar]: /url
+.
+<p><img src="/url" alt="foo" /></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+![foo][bar]
+
+[BAR]: /url
+.
+<p><img src="/url" alt="foo" /></p>
+````````````````````````````````
+
+
+Collapsed:
+
+```````````````````````````````` example
+![foo][]
+
+[foo]: /url "title"
+.
+<p><img src="/url" alt="foo" title="title" /></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+![*foo* bar][]
+
+[*foo* bar]: /url "title"
+.
+<p><img src="/url" alt="foo bar" title="title" /></p>
+````````````````````````````````
+
+
+The labels are case-insensitive:
+
+```````````````````````````````` example
+![Foo][]
+
+[foo]: /url "title"
+.
+<p><img src="/url" alt="Foo" title="title" /></p>
+````````````````````````````````
+
+
+As with reference links, [whitespace] is not allowed
+between the two sets of brackets:
+
+```````````````````````````````` example
+![foo] 
+[]
+
+[foo]: /url "title"
+.
+<p><img src="/url" alt="foo" title="title" />
+[]</p>
+````````````````````````````````
+
+
+Shortcut:
+
+```````````````````````````````` example
+![foo]
+
+[foo]: /url "title"
+.
+<p><img src="/url" alt="foo" title="title" /></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+![*foo* bar]
+
+[*foo* bar]: /url "title"
+.
+<p><img src="/url" alt="foo bar" title="title" /></p>
+````````````````````````````````
+
+
+Note that link labels cannot contain unescaped brackets:
+
+```````````````````````````````` example
+![[foo]]
+
+[[foo]]: /url "title"
+.
+<p>![[foo]]</p>
+<p>[[foo]]: /url &quot;title&quot;</p>
+````````````````````````````````
+
+
+The link labels are case-insensitive:
+
+```````````````````````````````` example
+![Foo]
+
+[foo]: /url "title"
+.
+<p><img src="/url" alt="Foo" title="title" /></p>
+````````````````````````````````
+
+
+If you just want a literal `!` followed by bracketed text, you can
+backslash-escape the opening `[`:
+
+```````````````````````````````` example
+!\[foo]
+
+[foo]: /url "title"
+.
+<p>![foo]</p>
+````````````````````````````````
+
+
+If you want a link after a literal `!`, backslash-escape the
+`!`:
+
+```````````````````````````````` example
+\![foo]
+
+[foo]: /url "title"
+.
+<p>!<a href="/url" title="title">foo</a></p>
+````````````````````````````````
+
+
+## Autolinks
+
+[Autolink](@)s are absolute URIs and email addresses inside
+`<` and `>`. They are parsed as links, with the URL or email address
+as the link label.
+
+A [URI autolink](@) consists of `<`, followed by an
+[absolute URI] not containing `<`, followed by `>`.  It is parsed as
+a link to the URI, with the URI as the link's label.
+
+An [absolute URI](@),
+for these purposes, consists of a [scheme] followed by a colon (`:`)
+followed by zero or more characters other than ASCII
+[whitespace] and control characters, `<`, and `>`.  If
+the URI includes these characters, they must be percent-encoded
+(e.g. `%20` for a space).
+
+For purposes of this spec, a [scheme](@) is any sequence
+of 2--32 characters beginning with an ASCII letter and followed
+by any combination of ASCII letters, digits, or the symbols plus
+("+"), period ("."), or hyphen ("-").
+
+Here are some valid autolinks:
+
+```````````````````````````````` example
+<http://foo.bar.baz>
+.
+<p><a href="http://foo.bar.baz">http://foo.bar.baz</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<http://foo.bar.baz/test?q=hello&id=22&boolean>
+.
+<p><a href="http://foo.bar.baz/test?q=hello&amp;id=22&amp;boolean">http://foo.bar.baz/test?q=hello&amp;id=22&amp;boolean</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<irc://foo.bar:2233/baz>
+.
+<p><a href="irc://foo.bar:2233/baz">irc://foo.bar:2233/baz</a></p>
+````````````````````````````````
+
+
+Uppercase is also fine:
+
+```````````````````````````````` example
+<MAILTO:FOO@BAR.BAZ>
+.
+<p><a href="MAILTO:FOO@BAR.BAZ">MAILTO:FOO@BAR.BAZ</a></p>
+````````````````````````````````
+
+
+Note that many strings that count as [absolute URIs] for
+purposes of this spec are not valid URIs, because their
+schemes are not registered or because of other problems
+with their syntax:
+
+```````````````````````````````` example
+<a+b+c:d>
+.
+<p><a href="a+b+c:d">a+b+c:d</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<made-up-scheme://foo,bar>
+.
+<p><a href="made-up-scheme://foo,bar">made-up-scheme://foo,bar</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<http://../>
+.
+<p><a href="http://../">http://../</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<localhost:5001/foo>
+.
+<p><a href="localhost:5001/foo">localhost:5001/foo</a></p>
+````````````````````````````````
+
+
+Spaces are not allowed in autolinks:
+
+```````````````````````````````` example
+<http://foo.bar/baz bim>
+.
+<p>&lt;http://foo.bar/baz bim&gt;</p>
+````````````````````````````````
+
+
+Backslash-escapes do not work inside autolinks:
+
+```````````````````````````````` example
+<http://example.com/\[\>
+.
+<p><a href="http://example.com/%5C%5B%5C">http://example.com/\[\</a></p>
+````````````````````````````````
+
+
+An [email autolink](@)
+consists of `<`, followed by an [email address],
+followed by `>`.  The link's label is the email address,
+and the URL is `mailto:` followed by the email address.
+
+An [email address](@),
+for these purposes, is anything that matches
+the [non-normative regex from the HTML5
+spec](https://html.spec.whatwg.org/multipage/forms.html#e-mail-state-(type=email)):
+
+    /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?
+    (?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
+
+Examples of email autolinks:
+
+```````````````````````````````` example
+<foo@bar.example.com>
+.
+<p><a href="mailto:foo@bar.example.com">foo@bar.example.com</a></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<foo+special@Bar.baz-bar0.com>
+.
+<p><a href="mailto:foo+special@Bar.baz-bar0.com">foo+special@Bar.baz-bar0.com</a></p>
+````````````````````````````````
+
+
+Backslash-escapes do not work inside email autolinks:
+
+```````````````````````````````` example
+<foo\+@bar.example.com>
+.
+<p>&lt;foo+@bar.example.com&gt;</p>
+````````````````````````````````
+
+
+These are not autolinks:
+
+```````````````````````````````` example
+<>
+.
+<p>&lt;&gt;</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+< http://foo.bar >
+.
+<p>&lt; http://foo.bar &gt;</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<m:abc>
+.
+<p>&lt;m:abc&gt;</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<foo.bar.baz>
+.
+<p>&lt;foo.bar.baz&gt;</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+http://example.com
+.
+<p>http://example.com</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo@bar.example.com
+.
+<p>foo@bar.example.com</p>
+````````````````````````````````
+
+
+## Raw HTML
+
+Text between `<` and `>` that looks like an HTML tag is parsed as a
+raw HTML tag and will be rendered in HTML without escaping.
+Tag and attribute names are not limited to current HTML tags,
+so custom tags (and even, say, DocBook tags) may be used.
+
+Here is the grammar for tags:
+
+A [tag name](@) consists of an ASCII letter
+followed by zero or more ASCII letters, digits, or
+hyphens (`-`).
+
+An [attribute](@) consists of [whitespace],
+an [attribute name], and an optional
+[attribute value specification].
+
+An [attribute name](@)
+consists of an ASCII letter, `_`, or `:`, followed by zero or more ASCII
+letters, digits, `_`, `.`, `:`, or `-`.  (Note:  This is the XML
+specification restricted to ASCII.  HTML5 is laxer.)
+
+An [attribute value specification](@)
+consists of optional [whitespace],
+a `=` character, optional [whitespace], and an [attribute
+value].
+
+An [attribute value](@)
+consists of an [unquoted attribute value],
+a [single-quoted attribute value], or a [double-quoted attribute value].
+
+An [unquoted attribute value](@)
+is a nonempty string of characters not
+including spaces, `"`, `'`, `=`, `<`, `>`, or `` ` ``.
+
+A [single-quoted attribute value](@)
+consists of `'`, zero or more
+characters not including `'`, and a final `'`.
+
+A [double-quoted attribute value](@)
+consists of `"`, zero or more
+characters not including `"`, and a final `"`.
+
+An [open tag](@) consists of a `<` character, a [tag name],
+zero or more [attributes], optional [whitespace], an optional `/`
+character, and a `>` character.
+
+A [closing tag](@) consists of the string `</`, a
+[tag name], optional [whitespace], and the character `>`.
+
+An [HTML comment](@) consists of `<!--` + *text* + `-->`,
+where *text* does not start with `>` or `->`, does not end with `-`,
+and does not contain `--`.  (See the
+[HTML5 spec](http://www.w3.org/TR/html5/syntax.html#comments).)
+
+A [processing instruction](@)
+consists of the string `<?`, a string
+of characters not including the string `?>`, and the string
+`?>`.
+
+A [declaration](@) consists of the
+string `<!`, a name consisting of one or more uppercase ASCII letters,
+[whitespace], a string of characters not including the
+character `>`, and the character `>`.
+
+A [CDATA section](@) consists of
+the string `<![CDATA[`, a string of characters not including the string
+`]]>`, and the string `]]>`.
+
+An [HTML tag](@) consists of an [open tag], a [closing tag],
+an [HTML comment], a [processing instruction], a [declaration],
+or a [CDATA section].
+
+Here are some simple open tags:
+
+```````````````````````````````` example
+<a><bab><c2c>
+.
+<p><a><bab><c2c></p>
+````````````````````````````````
+
+
+Empty elements:
+
+```````````````````````````````` example
+<a/><b2/>
+.
+<p><a/><b2/></p>
+````````````````````````````````
+
+
+[Whitespace] is allowed:
+
+```````````````````````````````` example
+<a  /><b2
+data="foo" >
+.
+<p><a  /><b2
+data="foo" ></p>
+````````````````````````````````
+
+
+With attributes:
+
+```````````````````````````````` example
+<a foo="bar" bam = 'baz <em>"</em>'
+_boolean zoop:33=zoop:33 />
+.
+<p><a foo="bar" bam = 'baz <em>"</em>'
+_boolean zoop:33=zoop:33 /></p>
+````````````````````````````````
+
+
+Custom tag names can be used:
+
+```````````````````````````````` example
+Foo <responsive-image src="foo.jpg" />
+.
+<p>Foo <responsive-image src="foo.jpg" /></p>
+````````````````````````````````
+
+
+Illegal tag names, not parsed as HTML:
+
+```````````````````````````````` example
+<33> <__>
+.
+<p>&lt;33&gt; &lt;__&gt;</p>
+````````````````````````````````
+
+
+Illegal attribute names:
+
+```````````````````````````````` example
+<a h*#ref="hi">
+.
+<p>&lt;a h*#ref=&quot;hi&quot;&gt;</p>
+````````````````````````````````
+
+
+Illegal attribute values:
+
+```````````````````````````````` example
+<a href="hi'> <a href=hi'>
+.
+<p>&lt;a href=&quot;hi'&gt; &lt;a href=hi'&gt;</p>
+````````````````````````````````
+
+
+Illegal [whitespace]:
+
+```````````````````````````````` example
+< a><
+foo><bar/ >
+.
+<p>&lt; a&gt;&lt;
+foo&gt;&lt;bar/ &gt;</p>
+````````````````````````````````
+
+
+Missing [whitespace]:
+
+```````````````````````````````` example
+<a href='bar'title=title>
+.
+<p>&lt;a href='bar'title=title&gt;</p>
+````````````````````````````````
+
+
+Closing tags:
+
+```````````````````````````````` example
+</a></foo >
+.
+<p></a></foo ></p>
+````````````````````````````````
+
+
+Illegal attributes in closing tag:
+
+```````````````````````````````` example
+</a href="foo">
+.
+<p>&lt;/a href=&quot;foo&quot;&gt;</p>
+````````````````````````````````
+
+
+Comments:
+
+```````````````````````````````` example
+foo <!-- this is a
+comment - with hyphen -->
+.
+<p>foo <!-- this is a
+comment - with hyphen --></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo <!-- not a comment -- two hyphens -->
+.
+<p>foo &lt;!-- not a comment -- two hyphens --&gt;</p>
+````````````````````````````````
+
+
+Not comments:
+
+```````````````````````````````` example
+foo <!--> foo -->
+
+foo <!-- foo--->
+.
+<p>foo &lt;!--&gt; foo --&gt;</p>
+<p>foo &lt;!-- foo---&gt;</p>
+````````````````````````````````
+
+
+Processing instructions:
+
+```````````````````````````````` example
+foo <?php echo $a; ?>
+.
+<p>foo <?php echo $a; ?></p>
+````````````````````````````````
+
+
+Declarations:
+
+```````````````````````````````` example
+foo <!ELEMENT br EMPTY>
+.
+<p>foo <!ELEMENT br EMPTY></p>
+````````````````````````````````
+
+
+CDATA sections:
+
+```````````````````````````````` example
+foo <![CDATA[>&<]]>
+.
+<p>foo <![CDATA[>&<]]></p>
+````````````````````````````````
+
+
+Entity and numeric character references are preserved in HTML
+attributes:
+
+```````````````````````````````` example
+foo <a href="&ouml;">
+.
+<p>foo <a href="&ouml;"></p>
+````````````````````````````````
+
+
+Backslash escapes do not work in HTML attributes:
+
+```````````````````````````````` example
+foo <a href="\*">
+.
+<p>foo <a href="\*"></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<a href="\"">
+.
+<p>&lt;a href=&quot;&quot;&quot;&gt;</p>
+````````````````````````````````
+
+
+## Hard line breaks
+
+A line break (not in a code span or HTML tag) that is preceded
+by two or more spaces and does not occur at the end of a block
+is parsed as a [hard line break](@) (rendered
+in HTML as a `<br />` tag):
+
+```````````````````````````````` example
+foo  
+baz
+.
+<p>foo<br />
+baz</p>
+````````````````````````````````
+
+
+For a more visible alternative, a backslash before the
+[line ending] may be used instead of two spaces:
+
+```````````````````````````````` example
+foo\
+baz
+.
+<p>foo<br />
+baz</p>
+````````````````````````````````
+
+
+More than two spaces can be used:
+
+```````````````````````````````` example
+foo       
+baz
+.
+<p>foo<br />
+baz</p>
+````````````````````````````````
+
+
+Leading spaces at the beginning of the next line are ignored:
+
+```````````````````````````````` example
+foo  
+     bar
+.
+<p>foo<br />
+bar</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo\
+     bar
+.
+<p>foo<br />
+bar</p>
+````````````````````````````````
+
+
+Line breaks can occur inside emphasis, links, and other constructs
+that allow inline content:
+
+```````````````````````````````` example
+*foo  
+bar*
+.
+<p><em>foo<br />
+bar</em></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+*foo\
+bar*
+.
+<p><em>foo<br />
+bar</em></p>
+````````````````````````````````
+
+
+Line breaks do not occur inside code spans
+
+```````````````````````````````` example
+`code  
+span`
+.
+<p><code>code span</code></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+`code\
+span`
+.
+<p><code>code\ span</code></p>
+````````````````````````````````
+
+
+or HTML tags:
+
+```````````````````````````````` example
+<a href="foo  
+bar">
+.
+<p><a href="foo  
+bar"></p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+<a href="foo\
+bar">
+.
+<p><a href="foo\
+bar"></p>
+````````````````````````````````
+
+
+Hard line breaks are for separating inline content within a block.
+Neither syntax for hard line breaks works at the end of a paragraph or
+other block element:
+
+```````````````````````````````` example
+foo\
+.
+<p>foo\</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+foo  
+.
+<p>foo</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+### foo\
+.
+<h3>foo\</h3>
+````````````````````````````````
+
+
+```````````````````````````````` example
+### foo  
+.
+<h3>foo</h3>
+````````````````````````````````
+
+
+## Soft line breaks
+
+A regular line break (not in a code span or HTML tag) that is not
+preceded by two or more spaces or a backslash is parsed as a
+[softbreak](@).  (A softbreak may be rendered in HTML either as a
+[line ending] or as a space. The result will be the same in
+browsers. In the examples here, a [line ending] will be used.)
+
+```````````````````````````````` example
+foo
+baz
+.
+<p>foo
+baz</p>
+````````````````````````````````
+
+
+Spaces at the end of the line and beginning of the next line are
+removed:
+
+```````````````````````````````` example
+foo 
+ baz
+.
+<p>foo
+baz</p>
+````````````````````````````````
+
+
+A conforming parser may render a soft line break in HTML either as a
+line break or as a space.
+
+A renderer may also provide an option to render soft line breaks
+as hard line breaks.
+
+## Textual content
+
+Any characters not given an interpretation by the above rules will
+be parsed as plain textual content.
+
+```````````````````````````````` example
+hello $.;'there
+.
+<p>hello $.;'there</p>
+````````````````````````````````
+
+
+```````````````````````````````` example
+Foo χρῆν
+.
+<p>Foo χρῆν</p>
+````````````````````````````````
+
+
+Internal spaces are preserved verbatim:
+
+```````````````````````````````` example
+Multiple     spaces
+.
+<p>Multiple     spaces</p>
+````````````````````````````````
+
+
+<!-- END TESTS -->
+
+# Appendix: A parsing strategy
+
+In this appendix we describe some features of the parsing strategy
+used in the CommonMark reference implementations.
+
+## Overview
+
+Parsing has two phases:
+
+1. In the first phase, lines of input are consumed and the block
+structure of the document---its division into paragraphs, block quotes,
+list items, and so on---is constructed.  Text is assigned to these
+blocks but not parsed. Link reference definitions are parsed and a
+map of links is constructed.
+
+2. In the second phase, the raw text contents of paragraphs and headings
+are parsed into sequences of Markdown inline elements (strings,
+code spans, links, emphasis, and so on), using the map of link
+references constructed in phase 1.
+
+At each point in processing, the document is represented as a tree of
+**blocks**.  The root of the tree is a `document` block.  The `document`
+may have any number of other blocks as **children**.  These children
+may, in turn, have other blocks as children.  The last child of a block
+is normally considered **open**, meaning that subsequent lines of input
+can alter its contents.  (Blocks that are not open are **closed**.)
+Here, for example, is a possible document tree, with the open blocks
+marked by arrows:
+
+``` tree
+-> document
+  -> block_quote
+       paragraph
+         "Lorem ipsum dolor\nsit amet."
+    -> list (type=bullet tight=true bullet_char=-)
+         list_item
+           paragraph
+             "Qui *quodsi iracundia*"
+      -> list_item
+        -> paragraph
+             "aliquando id"
+```
+
+## Phase 1: block structure
+
+Each line that is processed has an effect on this tree.  The line is
+analyzed and, depending on its contents, the document may be altered
+in one or more of the following ways:
+
+1. One or more open blocks may be closed.
+2. One or more new blocks may be created as children of the
+   last open block.
+3. Text may be added to the last (deepest) open block remaining
+   on the tree.
+
+Once a line has been incorporated into the tree in this way,
+it can be discarded, so input can be read in a stream.
+
+For each line, we follow this procedure:
+
+1. First we iterate through the open blocks, starting with the
+root document, and descending through last children down to the last
+open block.  Each block imposes a condition that the line must satisfy
+if the block is to remain open.  For example, a block quote requires a
+`>` character.  A paragraph requires a non-blank line.
+In this phase we may match all or just some of the open
+blocks.  But we cannot close unmatched blocks yet, because we may have a
+[lazy continuation line].
+
+2.  Next, after consuming the continuation markers for existing
+blocks, we look for new block starts (e.g. `>` for a block quote).
+If we encounter a new block start, we close any blocks unmatched
+in step 1 before creating the new block as a child of the last
+matched block.
+
+3.  Finally, we look at the remainder of the line (after block
+markers like `>`, list markers, and indentation have been consumed).
+This is text that can be incorporated into the last open
+block (a paragraph, code block, heading, or raw HTML).
+
+Setext headings are formed when we see a line of a paragraph
+that is a [setext heading underline].
+
+Reference link definitions are detected when a paragraph is closed;
+the accumulated text lines are parsed to see if they begin with
+one or more reference link definitions.  Any remainder becomes a
+normal paragraph.
+
+We can see how this works by considering how the tree above is
+generated by four lines of Markdown:
+
+``` markdown
+> Lorem ipsum dolor
+sit amet.
+> - Qui *quodsi iracundia*
+> - aliquando id
+```
+
+At the outset, our document model is just
+
+``` tree
+-> document
+```
+
+The first line of our text,
+
+``` markdown
+> Lorem ipsum dolor
+```
+
+causes a `block_quote` block to be created as a child of our
+open `document` block, and a `paragraph` block as a child of
+the `block_quote`.  Then the text is added to the last open
+block, the `paragraph`:
+
+``` tree
+-> document
+  -> block_quote
+    -> paragraph
+         "Lorem ipsum dolor"
+```
+
+The next line,
+
+``` markdown
+sit amet.
+```
+
+is a "lazy continuation" of the open `paragraph`, so it gets added
+to the paragraph's text:
+
+``` tree
+-> document
+  -> block_quote
+    -> paragraph
+         "Lorem ipsum dolor\nsit amet."
+```
+
+The third line,
+
+``` markdown
+> - Qui *quodsi iracundia*
+```
+
+causes the `paragraph` block to be closed, and a new `list` block
+opened as a child of the `block_quote`.  A `list_item` is also
+added as a child of the `list`, and a `paragraph` as a child of
+the `list_item`.  The text is then added to the new `paragraph`:
+
+``` tree
+-> document
+  -> block_quote
+       paragraph
+         "Lorem ipsum dolor\nsit amet."
+    -> list (type=bullet tight=true bullet_char=-)
+      -> list_item
+        -> paragraph
+             "Qui *quodsi iracundia*"
+```
+
+The fourth line,
+
+``` markdown
+> - aliquando id
+```
+
+causes the `list_item` (and its child the `paragraph`) to be closed,
+and a new `list_item` opened up as child of the `list`.  A `paragraph`
+is added as a child of the new `list_item`, to contain the text.
+We thus obtain the final tree:
+
+``` tree
+-> document
+  -> block_quote
+       paragraph
+         "Lorem ipsum dolor\nsit amet."
+    -> list (type=bullet tight=true bullet_char=-)
+         list_item
+           paragraph
+             "Qui *quodsi iracundia*"
+      -> list_item
+        -> paragraph
+             "aliquando id"
+```
+
+## Phase 2: inline structure
+
+Once all of the input has been parsed, all open blocks are closed.
+
+We then "walk the tree," visiting every node, and parse raw
+string contents of paragraphs and headings as inlines.  At this
+point we have seen all the link reference definitions, so we can
+resolve reference links as we go.
+
+``` tree
+document
+  block_quote
+    paragraph
+      str "Lorem ipsum dolor"
+      softbreak
+      str "sit amet."
+    list (type=bullet tight=true bullet_char=-)
+      list_item
+        paragraph
+          str "Qui "
+          emph
+            str "quodsi iracundia"
+      list_item
+        paragraph
+          str "aliquando id"
+```
+
+Notice how the [line ending] in the first paragraph has
+been parsed as a `softbreak`, and the asterisks in the first list item
+have become an `emph`.
+
+### An algorithm for parsing nested emphasis and links
+
+By far the trickiest part of inline parsing is handling emphasis,
+strong emphasis, links, and images.  This is done using the following
+algorithm.
+
+When we're parsing inlines and we hit either
+
+- a run of `*` or `_` characters, or
+- a `[` or `![`
+
+we insert a text node with these symbols as its literal content, and we
+add a pointer to this text node to the [delimiter stack](@).
+
+The [delimiter stack] is a doubly linked list.  Each
+element contains a pointer to a text node, plus information about
+
+- the type of delimiter (`[`, `![`, `*`, `_`)
+- the number of delimiters,
+- whether the delimiter is "active" (all are active to start), and
+- whether the delimiter is a potential opener, a potential closer,
+  or both (which depends on what sort of characters precede
+  and follow the delimiters).
+
+When we hit a `]` character, we call the *look for link or image*
+procedure (see below).
+
+When we hit the end of the input, we call the *process emphasis*
+procedure (see below), with `stack_bottom` = NULL.
+
+#### *look for link or image*
+
+Starting at the top of the delimiter stack, we look backwards
+through the stack for an opening `[` or `![` delimiter.
+
+- If we don't find one, we return a literal text node `]`.
+
+- If we do find one, but it's not *active*, we remove the inactive
+  delimiter from the stack, and return a literal text node `]`.
+
+- If we find one and it's active, then we parse ahead to see if
+  we have an inline link/image, reference link/image, compact reference
+  link/image, or shortcut reference link/image.
+
+  + If we don't, then we remove the opening delimiter from the
+    delimiter stack and return a literal text node `]`.
+
+  + If we do, then
+
+    * We return a link or image node whose children are the inlines
+      after the text node pointed to by the opening delimiter.
+
+    * We run *process emphasis* on these inlines, with the `[` opener
+      as `stack_bottom`.
+
+    * We remove the opening delimiter.
+
+    * If we have a link (and not an image), we also set all
+      `[` delimiters before the opening delimiter to *inactive*.  (This
+      will prevent us from getting links within links.)
+
+#### *process emphasis*
+
+Parameter `stack_bottom` sets a lower bound to how far we
+descend in the [delimiter stack].  If it is NULL, we can
+go all the way to the bottom.  Otherwise, we stop before
+visiting `stack_bottom`.
+
+Let `current_position` point to the element on the [delimiter stack]
+just above `stack_bottom` (or the first element if `stack_bottom`
+is NULL).
+
+We keep track of the `openers_bottom` for each delimiter
+type (`*`, `_`).  Initialize this to `stack_bottom`.
+
+Then we repeat the following until we run out of potential
+closers:
+
+- Move `current_position` forward in the delimiter stack (if needed)
+  until we find the first potential closer with delimiter `*` or `_`.
+  (This will be the potential closer closest
+  to the beginning of the input -- the first one in parse order.)
+
+- Now, look back in the stack (staying above `stack_bottom` and
+  the `openers_bottom` for this delimiter type) for the
+  first matching potential opener ("matching" means same delimiter).
+
+- If one is found:
+
+  + Figure out whether we have emphasis or strong emphasis:
+    if both closer and opener spans have length >= 2, we have
+    strong, otherwise regular.
+
+  + Insert an emph or strong emph node accordingly, after
+    the text node corresponding to the opener.
+
+  + Remove any delimiters between the opener and closer from
+    the delimiter stack.
+
+  + Remove 1 (for regular emph) or 2 (for strong emph) delimiters
+    from the opening and closing text nodes.  If they become empty
+    as a result, remove them and remove the corresponding element
+    of the delimiter stack.  If the closing node is removed, reset
+    `current_position` to the next element in the stack.
+
+- If none in found:
+
+  + Set `openers_bottom` to the element before `current_position`.
+    (We know that there are no openers for this kind of closer up to and
+    including this point, so this puts a lower bound on future searches.)
+
+  + If the closer at `current_position` is not a potential opener,
+    remove it from the delimiter stack (since we know it can't
+    be a closer either).
+
+  + Advance `current_position` to the next element in the stack.
+
+After we're done, we remove all delimiters above `stack_bottom` from the
+delimiter stack.
+
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/state_block.go b/vendor/gitlab.com/golang-commonmark/markdown/state_block.go
new file mode 100644
index 000000000..e1142416f
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/state_block.go
@@ -0,0 +1,141 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import "strings"
+
+const (
+	ptRoot = iota
+	ptList
+	ptBlockQuote
+	ptParagraph
+	ptReference
+)
+
+type StateBlock struct {
+	StateCore
+
+	BMarks     []int // offsets of the line beginnings
+	EMarks     []int // offsets of the line endings
+	TShift     []int // indents for each line
+	SCount     []int
+	BSCount    []int
+	BlkIndent  int  // required block content indent (in a list etc.)
+	Line       int  // line index in the source string
+	LineMax    int  // number of lines
+	Tight      bool // loose or tight mode for lists
+	ParentType byte // parent block type
+	Level      int
+}
+
+func (s *StateBlock) IsLineEmpty(n int) bool {
+	return s.BMarks[n]+s.TShift[n] >= s.EMarks[n]
+}
+
+func (s *StateBlock) SkipEmptyLines(from int) int {
+	for from < s.LineMax && s.IsLineEmpty(from) {
+		from++
+	}
+	return from
+}
+
+func (s *StateBlock) SkipSpaces(pos int) int {
+	src := s.Src
+	for pos < len(src) && byteIsSpace(src[pos]) {
+		pos++
+	}
+	return pos
+}
+
+func (s *StateBlock) SkipBytes(pos int, b byte) int {
+	src := s.Src
+	for pos < len(src) && src[pos] == b {
+		pos++
+	}
+	return pos
+}
+
+func (s *StateBlock) SkipBytesBack(pos int, b byte, min int) int {
+	for pos > min {
+		pos--
+		if s.Src[pos] != b {
+			return pos + 1
+		}
+	}
+	return pos
+}
+
+func (s *StateBlock) SkipSpacesBack(pos int, min int) int {
+	for pos > min {
+		pos--
+		if !byteIsSpace(s.Src[pos]) {
+			return pos + 1
+		}
+	}
+	return pos
+}
+
+func (s *StateBlock) Lines(begin, end, indent int, keepLastLf bool) string {
+	if begin == end {
+		return ""
+	}
+
+	src := s.Src
+
+	queue := make([]string, end-begin)
+
+	for i, line := 0, begin; line < end; i, line = i+1, line+1 {
+		lineIndent := 0
+		lineStart := s.BMarks[line]
+		first := lineStart
+		last := s.EMarks[line]
+		if (line+1 < end || keepLastLf) && last < len(src) {
+			last++
+		}
+
+		for first < last && lineIndent < indent {
+			ch := src[first]
+
+			if byteIsSpace(ch) {
+				if ch == '\t' {
+					lineIndent += 4 - (lineIndent+s.BSCount[line])%4
+				} else {
+					lineIndent++
+				}
+			} else if first-lineStart < s.TShift[line] {
+				lineIndent++
+			} else {
+				break
+			}
+
+			first++
+		}
+
+		if lineIndent > indent {
+			queue[i] = strings.Repeat(" ", lineIndent-indent) + src[first:last]
+		} else {
+			queue[i] = src[first:last]
+		}
+	}
+
+	return strings.Join(queue, "")
+}
+
+func (s *StateBlock) PushToken(tok Token) {
+	tok.SetLevel(s.Level)
+	s.Tokens = append(s.Tokens, tok)
+}
+
+func (s *StateBlock) PushOpeningToken(tok Token) {
+	tok.SetLevel(s.Level)
+	s.Level++
+	s.Tokens = append(s.Tokens, tok)
+}
+
+func (s *StateBlock) PushClosingToken(tok Token) {
+	s.Level--
+	tok.SetLevel(s.Level)
+	s.Tokens = append(s.Tokens, tok)
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/state_core.go b/vendor/gitlab.com/golang-commonmark/markdown/state_core.go
new file mode 100644
index 000000000..24e517562
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/state_core.go
@@ -0,0 +1,13 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+type StateCore struct {
+	Src       string
+	Tokens    []Token
+	bootstrap [3]Token
+	Md        *Markdown
+	Env       *Environment
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/state_inline.go b/vendor/gitlab.com/golang-commonmark/markdown/state_inline.go
new file mode 100644
index 000000000..4bc08cf51
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/state_inline.go
@@ -0,0 +1,116 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"bytes"
+	"unicode"
+	"unicode/utf8"
+)
+
+type StateInline struct {
+	StateCore
+
+	Pos          int
+	PosMax       int
+	Level        int
+	Pending      bytes.Buffer
+	PendingLevel int
+	Delimiters   []Delimiter
+
+	Cache map[int]int
+}
+
+func (s *StateInline) PushToken(tok Token) {
+	if s.Pending.Len() > 0 {
+		s.PushPending()
+	}
+	tok.SetLevel(s.Level)
+	s.PendingLevel = s.Level
+	s.Tokens = append(s.Tokens, tok)
+}
+
+func (s *StateInline) PushOpeningToken(tok Token) {
+	if s.Pending.Len() > 0 {
+		s.PushPending()
+	}
+	tok.SetLevel(s.Level)
+	s.Level++
+	s.PendingLevel = s.Level
+	s.Tokens = append(s.Tokens, tok)
+}
+
+func (s *StateInline) PushClosingToken(tok Token) {
+	if s.Pending.Len() > 0 {
+		s.PushPending()
+	}
+	s.Level--
+	tok.SetLevel(s.Level)
+	s.PendingLevel = s.Level
+	s.Tokens = append(s.Tokens, tok)
+}
+
+func (s *StateInline) PushPending() {
+	s.Tokens = append(s.Tokens, &Text{
+		Content: s.Pending.String(),
+		Lvl:     s.PendingLevel,
+	})
+	s.Pending.Reset()
+}
+
+func (s *StateInline) scanDelims(start int, canSplitWord bool) (canOpen bool, canClose bool, length int) {
+	pos := start
+	max := s.PosMax
+	src := s.Src
+	marker := src[start]
+	leftFlanking, rightFlanking := true, true
+
+	lastChar := ' '
+	if start > 0 {
+		lastChar, _ = utf8.DecodeLastRuneInString(src[:start])
+	}
+
+	for pos < max && src[pos] == marker {
+		pos++
+	}
+	length = pos - start
+
+	nextChar := ' '
+	if pos < max {
+		nextChar, _ = utf8.DecodeRuneInString(src[pos:])
+	}
+
+	isLastPunct := isMdAsciiPunct(lastChar) || unicode.IsPunct(lastChar)
+	isNextPunct := isMdAsciiPunct(nextChar) || unicode.IsPunct(nextChar)
+
+	isLastWhiteSpace := unicode.IsSpace(lastChar)
+	isNextWhiteSpace := unicode.IsSpace(nextChar)
+
+	if isNextWhiteSpace {
+		leftFlanking = false
+	} else if isNextPunct {
+		if !(isLastWhiteSpace || isLastPunct) {
+			leftFlanking = false
+		}
+	}
+
+	if isLastWhiteSpace {
+		rightFlanking = false
+	} else if isLastPunct {
+		if !(isNextWhiteSpace || isNextPunct) {
+			rightFlanking = false
+		}
+	}
+
+	if !canSplitWord {
+		canOpen = leftFlanking && (!rightFlanking || isLastPunct)
+		canClose = rightFlanking && (!leftFlanking || isNextPunct)
+	} else {
+		canOpen = leftFlanking
+		canClose = rightFlanking
+	}
+
+	return
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/strikethrough.go b/vendor/gitlab.com/golang-commonmark/markdown/strikethrough.go
new file mode 100644
index 000000000..180799452
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/strikethrough.go
@@ -0,0 +1,101 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+func ruleStrikeThrough(s *StateInline, silent bool) bool {
+	src := s.Src
+	start := s.Pos
+	marker := src[start]
+
+	if silent {
+		return false
+	}
+
+	if src[start] != '~' {
+		return false
+	}
+
+	canOpen, canClose, length := s.scanDelims(start, true)
+	origLength := length
+	ch := string(marker)
+	if length < 2 {
+		return false
+	}
+
+	if length%2 != 0 {
+		s.PushToken(&Text{
+			Content: ch,
+		})
+		length--
+	}
+
+	for i := 0; i < length; i += 2 {
+		s.PushToken(&Text{
+			Content: ch + ch,
+		})
+
+		s.Delimiters = append(s.Delimiters, Delimiter{
+			Marker: marker,
+			Length: -1,
+			Jump:   i,
+			Token:  len(s.Tokens) - 1,
+			Level:  s.Level,
+			End:    -1,
+			Open:   canOpen,
+			Close:  canClose,
+		})
+	}
+
+	s.Pos += origLength
+
+	return true
+
+}
+
+func ruleStrikethroughPostprocess(s *StateInline) {
+	var loneMarkers []int
+	delimiters := s.Delimiters
+	max := len(delimiters)
+
+	for i := 0; i < max; i++ {
+		startDelim := delimiters[i]
+
+		if startDelim.Marker != '~' {
+			continue
+		}
+
+		if startDelim.End == -1 {
+			continue
+		}
+
+		endDelim := delimiters[startDelim.End]
+
+		s.Tokens[startDelim.Token] = &StrikethroughOpen{}
+		s.Tokens[endDelim.Token] = &StrikethroughClose{}
+
+		if text, ok := s.Tokens[endDelim.Token-1].(*Text); ok && text.Content == "~" {
+			loneMarkers = append(loneMarkers, endDelim.Token-1)
+		}
+	}
+
+	for len(loneMarkers) > 0 {
+		i := loneMarkers[len(loneMarkers)-1]
+		loneMarkers = loneMarkers[:len(loneMarkers)-1]
+		j := i + 1
+
+		for j < len(s.Tokens) {
+			if _, ok := s.Tokens[j].(*StrikethroughClose); !ok {
+				break
+			}
+			j++
+		}
+
+		j--
+
+		if i != j {
+			s.Tokens[i], s.Tokens[j] = s.Tokens[j], s.Tokens[i]
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/table.go b/vendor/gitlab.com/golang-commonmark/markdown/table.go
new file mode 100644
index 000000000..52ee176ef
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/table.go
@@ -0,0 +1,229 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"regexp"
+	"strings"
+)
+
+func getLine(s *StateBlock, line int) string {
+	pos := s.BMarks[line] + s.BlkIndent
+	max := s.EMarks[line]
+	if pos >= max {
+		return ""
+	}
+	return s.Src[pos:max]
+}
+
+func escapedSplit(s string) (result []string) {
+	pos := 0
+	escapes := 0
+	lastPos := 0
+	backTicked := false
+	lastBackTick := 0
+
+	for pos < len(s) {
+		ch := s[pos]
+		if ch == '`' {
+			if backTicked {
+				backTicked = false
+				lastBackTick = pos
+			} else if escapes%2 == 0 {
+				backTicked = true
+				lastBackTick = pos
+			}
+		} else if ch == '|' && (escapes%2 == 0) && !backTicked {
+			result = append(result, s[lastPos:pos])
+			lastPos = pos + 1
+		}
+
+		if ch == '\\' {
+			escapes++
+		} else {
+			escapes = 0
+		}
+
+		pos++
+
+		if pos == len(s) && backTicked {
+			backTicked = false
+			pos = lastBackTick + 1
+		}
+	}
+
+	return append(result, s[lastPos:])
+}
+
+var rColumn = regexp.MustCompile("^:?-+:?$")
+
+func ruleTable(s *StateBlock, startLine, endLine int, silent bool) bool {
+	if !s.Md.Tables {
+		return false
+	}
+
+	if startLine+2 > endLine {
+		return false
+	}
+
+	nextLine := startLine + 1
+
+	if s.SCount[nextLine] < s.BlkIndent {
+		return false
+	}
+
+	if s.SCount[nextLine]-s.BlkIndent >= 4 {
+		return false
+	}
+
+	pos := s.BMarks[nextLine] + s.TShift[nextLine]
+	if pos >= s.EMarks[nextLine] {
+		return false
+	}
+
+	src := s.Src
+	ch := src[pos]
+	pos++
+
+	if ch != '|' && ch != '-' && ch != ':' {
+		return false
+	}
+
+	for pos < s.EMarks[nextLine] {
+		ch = src[pos]
+		if ch != '|' && ch != '-' && ch != ':' && !byteIsSpace(ch) {
+			return false
+		}
+		pos++
+	}
+
+	//
+
+	lineText := getLine(s, startLine+1)
+
+	columns := strings.Split(lineText, "|")
+	var aligns []Align
+	for i := 0; i < len(columns); i++ {
+		t := strings.TrimSpace(columns[i])
+		if t == "" {
+			if i == 0 || i == len(columns)-1 {
+				continue
+			}
+			return false
+		}
+
+		if !rColumn.MatchString(t) {
+			return false
+		}
+
+		if t[len(t)-1] == ':' {
+			if t[0] == ':' {
+				aligns = append(aligns, AlignCenter)
+			} else {
+				aligns = append(aligns, AlignRight)
+			}
+		} else if t[0] == ':' {
+			aligns = append(aligns, AlignLeft)
+		} else {
+			aligns = append(aligns, AlignNone)
+		}
+	}
+
+	lineText = strings.TrimSpace(getLine(s, startLine))
+	if strings.IndexByte(lineText, '|') == -1 {
+		return false
+	}
+	if s.SCount[startLine]-s.BlkIndent >= 4 {
+		return false
+	}
+	columns = escapedSplit(strings.TrimSuffix(strings.TrimPrefix(lineText, "|"), "|"))
+	columnCount := len(columns)
+	if columnCount > len(aligns) {
+		return false
+	}
+
+	if silent {
+		return true
+	}
+
+	tableTok := &TableOpen{
+		Map: [2]int{startLine, 0},
+	}
+	s.PushOpeningToken(tableTok)
+	s.PushOpeningToken(&TheadOpen{
+		Map: [2]int{startLine, startLine + 1},
+	})
+	s.PushOpeningToken(&TrOpen{
+		Map: [2]int{startLine, startLine + 1},
+	})
+
+	for i := 0; i < len(columns); i++ {
+		s.PushOpeningToken(&ThOpen{
+			Align: aligns[i],
+			Map:   [2]int{startLine, startLine + 1},
+		})
+		s.PushToken(&Inline{
+			Content: strings.TrimSpace(columns[i]),
+			Map:     [2]int{startLine, startLine + 1},
+		})
+		s.PushClosingToken(&ThClose{})
+	}
+
+	s.PushClosingToken(&TrClose{})
+	s.PushClosingToken(&TheadClose{})
+
+	tbodyTok := &TbodyOpen{
+		Map: [2]int{startLine + 2, 0},
+	}
+	s.PushOpeningToken(tbodyTok)
+
+	for nextLine = startLine + 2; nextLine < endLine; nextLine++ {
+		if s.SCount[nextLine] < s.BlkIndent {
+			break
+		}
+
+		lineText = strings.TrimSpace(getLine(s, nextLine))
+		if strings.IndexByte(lineText, '|') == -1 {
+			break
+		}
+		if s.SCount[nextLine]-s.BlkIndent >= 4 {
+			break
+		}
+		columns = escapedSplit(strings.TrimPrefix(strings.TrimSuffix(lineText, "|"), "|"))
+
+		if len(columns) < len(aligns) {
+			columns = append(columns, make([]string, len(aligns)-len(columns))...)
+		} else if len(columns) > len(aligns) {
+			columns = columns[:len(aligns)]
+		}
+
+		s.PushOpeningToken(&TrOpen{})
+		for i := 0; i < columnCount; i++ {
+			tdOpen := TdOpen{}
+			if i < len(aligns) {
+				tdOpen.Align = aligns[i]
+			}
+			s.PushOpeningToken(&tdOpen)
+
+			inline := Inline{}
+			if i < len(columns) {
+				inline.Content = strings.TrimSpace(columns[i])
+			}
+			s.PushToken(&inline)
+
+			s.PushClosingToken(&TdClose{})
+		}
+		s.PushClosingToken(&TrClose{})
+	}
+
+	s.PushClosingToken(&TbodyClose{})
+	s.PushClosingToken(&TableClose{})
+
+	tableTok.Map[1] = nextLine
+	tbodyTok.Map[1] = nextLine
+	s.Line = nextLine
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/table_fsm.go b/vendor/gitlab.com/golang-commonmark/markdown/table_fsm.go
new file mode 100644
index 000000000..b605e45c7
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/table_fsm.go
@@ -0,0 +1,108 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+func isHeaderLine(s string) bool {
+	if s == "" {
+		return false
+	}
+
+	st := 0
+	n := 0
+	for i := 0; i < len(s); i++ {
+		b := s[i]
+		switch st {
+		case 0: // initial state
+			switch b {
+			case '|':
+				st = 1
+			case ':':
+				st = 2
+			case '-':
+				st = 3
+				n++
+			case ' ':
+				break
+			default:
+				return false
+			}
+
+		case 1: // |
+			switch b {
+			case ' ':
+				break
+			case ':':
+				st = 2
+			case '-':
+				st = 3
+				n++
+			default:
+				return false
+			}
+
+		case 2: // |:
+			switch b {
+			case ' ':
+				break
+			case '-':
+				st = 3
+				n++
+			default:
+				return false
+			}
+
+		case 3: // |:-
+			switch b {
+			case '-':
+				break
+			case ':':
+				st = 4
+			case '|':
+				st = 5
+			case ' ':
+				st = 6
+			default:
+				return false
+			}
+
+		case 4: // |:---:
+			switch b {
+			case ' ':
+				break
+			case '|':
+				st = 5
+			default:
+				return false
+			}
+
+		case 5: // |:---:|
+			switch b {
+			case ' ':
+				break
+			case ':':
+				st = 2
+			case '-':
+				st = 3
+				n++
+			default:
+				return false
+			}
+
+		case 6: // |:--- SPACE
+			switch b {
+			case ' ':
+				break
+			case ':':
+				st = 4
+			case '|':
+				st = 5
+			default:
+				return false
+			}
+		}
+	}
+
+	return n >= 1
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/table_test.go b/vendor/gitlab.com/golang-commonmark/markdown/table_test.go
new file mode 100644
index 000000000..d2a9d5d41
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/table_test.go
@@ -0,0 +1,87 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestEscapedSplit(t *testing.T) {
+	type testCase struct {
+		in   string
+		want []string
+	}
+	testCases := []testCase{
+		{"", []string{""}},
+		{" a | b | c ", []string{" a ", " b ", " c "}},
+		{"| a | b | c |", []string{"", " a ", " b ", " c ", ""}},
+		{` a \| b | c `, []string{` a \| b `, " c "}},
+		{` a \| b \| c `, []string{` a \| b \| c `}},
+		{" `a \\| b` | c ", []string{" `a \\| b` ", " c "}},
+		{` a \\| b | c `, []string{` a \\`, " b ", " c "}},
+		{" `a | b | c ", []string{" `a ", " b ", " c "}},
+		{" a | `b | c ", []string{" a ", " `b ", " c "}},
+		{" a | `b | c` ", []string{" a ", " `b | c` "}},
+	}
+	for _, tc := range testCases {
+		got := escapedSplit(tc.in)
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("escapedSplit(%q):\n got %#v\nwant %#v", tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestIsHeaderLine(t *testing.T) {
+	type testCase struct {
+		in   string
+		want bool
+	}
+	testCases := []testCase{
+		{"|:--- % |", false},
+		{"|:---:|  %", false},
+		{"|:---:|%", false},
+		{"|:---:%|", false},
+		{"|:---%|", false},
+		{"|:-%--|", false},
+		{"|:%---|", false},
+		{"|%---|", false},
+		{"", false},
+		{"%|---|", false},
+		{"| --- | --- |", true},
+		{"| --- |", true},
+		{"| --- : |", true},
+		{"| : --- |", true},
+		{"| : --- : |", true},
+		{"|---|---|", true},
+		{"|---|", true},
+		{"|---:|", true},
+		{"|:---|", true},
+		{"|:---  |", true},
+		{"|:---:|  ", true},
+		{"|:---:|", true},
+		{" |---| ", true},
+		{"---|---", true},
+		{"---:|---:", true},
+		{"---:|:---:", true},
+		{"---:|:---", true},
+		{"---:", true},
+		{"---", true},
+		{":---|---:", true},
+		{":---|:---:", true},
+		{":---|:---", true},
+		{":---:|---:", true},
+		{":---:|:---:", true},
+		{":---:|:---", true},
+		{":---:", true},
+		{":---", true},
+	}
+	for _, tc := range testCases {
+		got := isHeaderLine(tc.in)
+		if got != tc.want {
+			t.Errorf("isHeaderLine(%q) = %v, want %v", tc.in, got, tc.want)
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/text.go b/vendor/gitlab.com/golang-commonmark/markdown/text.go
new file mode 100644
index 000000000..ae98e7435
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/text.go
@@ -0,0 +1,52 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+var terminatorCharTable = [256]bool{
+	'\n': true,
+	'!':  true,
+	'#':  true,
+	'$':  true,
+	'%':  true,
+	'&':  true,
+	'*':  true,
+	'+':  true,
+	'-':  true,
+	':':  true,
+	'<':  true,
+	'=':  true,
+	'>':  true,
+	'@':  true,
+	'[':  true,
+	'\\': true,
+	']':  true,
+	'^':  true,
+	'_':  true,
+	'`':  true,
+	'{':  true,
+	'}':  true,
+	'~':  true,
+}
+
+func ruleText(s *StateInline, silent bool) bool {
+	pos := s.Pos
+	max := s.PosMax
+	src := s.Src
+
+	for pos < max && !terminatorCharTable[src[pos]] {
+		pos++
+	}
+	if pos == s.Pos {
+		return false
+	}
+
+	if !silent {
+		s.Pending.WriteString(src[s.Pos:pos])
+	}
+
+	s.Pos = pos
+
+	return true
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/text_collapse.go b/vendor/gitlab.com/golang-commonmark/markdown/text_collapse.go
new file mode 100644
index 000000000..25b98b808
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/text_collapse.go
@@ -0,0 +1,42 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+func ruleTextCollapse(s *StateInline) {
+	level := 0
+	tokens := s.Tokens
+	max := len(tokens)
+
+	curr := 0
+	last := 0
+	for ; curr < max; curr++ {
+		tok := tokens[curr]
+		if tok.Opening() {
+			level++
+		} else if tok.Closing() {
+			level--
+		}
+
+		tok.SetLevel(level)
+
+		if text, ok := tok.(*Text); ok && curr+1 < max {
+			if text2, ok := tokens[curr+1].(*Text); ok {
+				text2.Content = text.Content + text2.Content
+				continue
+			}
+		}
+
+		if curr != last {
+			tokens[last] = tokens[curr]
+		}
+		last++
+	}
+
+	if curr != last {
+		tokens = tokens[:last]
+	}
+
+	s.Tokens = tokens
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/token.go b/vendor/gitlab.com/golang-commonmark/markdown/token.go
new file mode 100644
index 000000000..1b14e5fe7
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/token.go
@@ -0,0 +1,753 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+type Token interface {
+	Tag() string
+	Opening() bool
+	Closing() bool
+	Block() bool
+	Level() int
+	SetLevel(lvl int)
+}
+
+type BlockquoteOpen struct {
+	Map [2]int
+	Lvl int
+}
+
+type BlockquoteClose struct {
+	Lvl int
+}
+
+type BulletListOpen struct {
+	Map [2]int
+	Lvl int
+}
+
+type BulletListClose struct {
+	Lvl int
+}
+
+type OrderedListOpen struct {
+	Order int
+	Map   [2]int
+	Lvl   int
+}
+
+type OrderedListClose struct {
+	Lvl int
+}
+
+type ListItemOpen struct {
+	Map [2]int
+	Lvl int
+}
+
+type ListItemClose struct {
+	Lvl int
+}
+
+type CodeBlock struct {
+	Content string
+	Map     [2]int
+	Lvl     int
+}
+
+type CodeInline struct {
+	Content string
+	Lvl     int
+}
+
+type EmphasisOpen struct {
+	Lvl int
+}
+
+type EmphasisClose struct {
+	Lvl int
+}
+
+type StrongOpen struct {
+	Lvl int
+}
+
+type StrongClose struct {
+	Lvl int
+}
+
+type StrikethroughOpen struct {
+	Lvl int
+}
+
+type StrikethroughClose struct {
+	Lvl int
+}
+
+type Fence struct {
+	Params  string
+	Content string
+	Map     [2]int
+	Lvl     int
+}
+
+type Softbreak struct {
+	Lvl int
+}
+
+type Hardbreak struct {
+	Lvl int
+}
+
+type HeadingOpen struct {
+	HLevel int
+	Map    [2]int
+	Lvl    int
+}
+
+type HeadingClose struct {
+	HLevel int
+	Lvl    int
+}
+
+type HTMLBlock struct {
+	Content string
+	Map     [2]int
+	Lvl     int
+}
+
+type HTMLInline struct {
+	Content string
+	Lvl     int
+}
+
+type Hr struct {
+	Map [2]int
+	Lvl int
+}
+
+type Image struct {
+	Src    string
+	Title  string
+	Tokens []Token
+	Lvl    int
+}
+
+type Inline struct {
+	Content  string
+	Map      [2]int
+	Children []Token
+	Lvl      int
+}
+
+type LinkOpen struct {
+	Href   string
+	Title  string
+	Target string
+	Lvl    int
+}
+
+type LinkClose struct {
+	Lvl int
+}
+
+type ParagraphOpen struct {
+	Tight  bool
+	Hidden bool
+	Map    [2]int
+	Lvl    int
+}
+
+type ParagraphClose struct {
+	Tight  bool
+	Hidden bool
+	Lvl    int
+}
+
+type TableOpen struct {
+	Map [2]int
+	Lvl int
+}
+
+type TableClose struct {
+	Lvl int
+}
+
+type TheadOpen struct {
+	Map [2]int
+	Lvl int
+}
+
+type TheadClose struct {
+	Lvl int
+}
+
+type TrOpen struct {
+	Map [2]int
+	Lvl int
+}
+
+type TrClose struct {
+	Lvl int
+}
+
+type ThOpen struct {
+	Align Align
+	Map   [2]int
+	Lvl   int
+}
+
+type ThClose struct {
+	Lvl int
+}
+
+type TbodyOpen struct {
+	Map [2]int
+	Lvl int
+}
+
+type TbodyClose struct {
+	Lvl int
+}
+
+type TdOpen struct {
+	Align Align
+	Map   [2]int
+	Lvl   int
+}
+
+type TdClose struct {
+	Lvl int
+}
+
+type Text struct {
+	Content string
+	Lvl     int
+}
+
+var htags = []string{
+	"",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+}
+
+func (t *BlockquoteOpen) Level() int { return t.Lvl }
+
+func (t *BlockquoteClose) Level() int { return t.Lvl }
+
+func (t *BulletListOpen) Level() int { return t.Lvl }
+
+func (t *BulletListClose) Level() int { return t.Lvl }
+
+func (t *OrderedListOpen) Level() int { return t.Lvl }
+
+func (t *OrderedListClose) Level() int { return t.Lvl }
+
+func (t *ListItemOpen) Level() int { return t.Lvl }
+
+func (t *ListItemClose) Level() int { return t.Lvl }
+
+func (t *CodeBlock) Level() int { return t.Lvl }
+
+func (t *CodeInline) Level() int { return t.Lvl }
+
+func (t *EmphasisOpen) Level() int { return t.Lvl }
+
+func (t *EmphasisClose) Level() int { return t.Lvl }
+
+func (t *StrongOpen) Level() int { return t.Lvl }
+
+func (t *StrongClose) Level() int { return t.Lvl }
+
+func (t *StrikethroughOpen) Level() int { return t.Lvl }
+
+func (t *StrikethroughClose) Level() int { return t.Lvl }
+
+func (t *Fence) Level() int { return t.Lvl }
+
+func (t *Softbreak) Level() int { return t.Lvl }
+
+func (t *Hardbreak) Level() int { return t.Lvl }
+
+func (t *HeadingOpen) Level() int { return t.Lvl }
+
+func (t *HeadingClose) Level() int { return t.Lvl }
+
+func (t *HTMLBlock) Level() int { return t.Lvl }
+
+func (t *HTMLInline) Level() int { return t.Lvl }
+
+func (t *Hr) Level() int { return t.Lvl }
+
+func (t *Image) Level() int { return t.Lvl }
+
+func (t *Inline) Level() int { return t.Lvl }
+
+func (t *LinkOpen) Level() int { return t.Lvl }
+
+func (t *LinkClose) Level() int { return t.Lvl }
+
+func (t *ParagraphOpen) Level() int { return t.Lvl }
+
+func (t *ParagraphClose) Level() int { return t.Lvl }
+
+func (t *TableOpen) Level() int { return t.Lvl }
+
+func (t *TableClose) Level() int { return t.Lvl }
+
+func (t *TheadOpen) Level() int { return t.Lvl }
+
+func (t *TheadClose) Level() int { return t.Lvl }
+
+func (t *TrOpen) Level() int { return t.Lvl }
+
+func (t *TrClose) Level() int { return t.Lvl }
+
+func (t *ThOpen) Level() int { return t.Lvl }
+
+func (t *ThClose) Level() int { return t.Lvl }
+
+func (t *TbodyOpen) Level() int { return t.Lvl }
+
+func (t *TbodyClose) Level() int { return t.Lvl }
+
+func (t *TdOpen) Level() int { return t.Lvl }
+
+func (t *TdClose) Level() int { return t.Lvl }
+
+func (t *Text) Level() int { return t.Lvl }
+
+func (t *BlockquoteOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *BlockquoteClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *BulletListOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *BulletListClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *OrderedListOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *OrderedListClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *ListItemOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *ListItemClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *CodeBlock) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *CodeInline) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *EmphasisOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *EmphasisClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *StrongOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *StrongClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *StrikethroughOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *StrikethroughClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *Fence) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *Softbreak) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *Hardbreak) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *HeadingOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *HeadingClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *HTMLBlock) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *HTMLInline) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *Hr) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *Image) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *Inline) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *LinkOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *LinkClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *ParagraphOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *ParagraphClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *TableOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *TableClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *TheadOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *TheadClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *TrOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *TrClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *ThOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *ThClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *TbodyOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *TbodyClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *TdOpen) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *TdClose) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *Text) SetLevel(lvl int) { t.Lvl = lvl }
+
+func (t *BlockquoteOpen) Opening() bool { return true }
+
+func (t *BlockquoteClose) Opening() bool { return false }
+
+func (t *BulletListOpen) Opening() bool { return true }
+
+func (t *BulletListClose) Opening() bool { return false }
+
+func (t *OrderedListOpen) Opening() bool { return true }
+
+func (t *OrderedListClose) Opening() bool { return false }
+
+func (t *ListItemOpen) Opening() bool { return true }
+
+func (t *ListItemClose) Opening() bool { return false }
+
+func (t *CodeBlock) Opening() bool { return false }
+
+func (t *CodeInline) Opening() bool { return false }
+
+func (t *EmphasisOpen) Opening() bool { return true }
+
+func (t *EmphasisClose) Opening() bool { return false }
+
+func (t *StrongOpen) Opening() bool { return true }
+
+func (t *StrongClose) Opening() bool { return false }
+
+func (t *StrikethroughOpen) Opening() bool { return true }
+
+func (t *StrikethroughClose) Opening() bool { return false }
+
+func (t *Fence) Opening() bool { return false }
+
+func (t *Softbreak) Opening() bool { return false }
+
+func (t *Hardbreak) Opening() bool { return false }
+
+func (t *HeadingOpen) Opening() bool { return true }
+
+func (t *HeadingClose) Opening() bool { return false }
+
+func (t *HTMLBlock) Opening() bool { return false }
+
+func (t *HTMLInline) Opening() bool { return false }
+
+func (t *Hr) Opening() bool { return false }
+
+func (t *Image) Opening() bool { return false }
+
+func (t *Inline) Opening() bool { return false }
+
+func (t *LinkOpen) Opening() bool { return true }
+
+func (t *LinkClose) Opening() bool { return false }
+
+func (t *ParagraphOpen) Opening() bool { return true }
+
+func (t *ParagraphClose) Opening() bool { return false }
+
+func (t *TableOpen) Opening() bool { return true }
+
+func (t *TableClose) Opening() bool { return false }
+
+func (t *TheadOpen) Opening() bool { return true }
+
+func (t *TheadClose) Opening() bool { return false }
+
+func (t *TrOpen) Opening() bool { return true }
+
+func (t *TrClose) Opening() bool { return false }
+
+func (t *ThOpen) Opening() bool { return true }
+
+func (t *ThClose) Opening() bool { return false }
+
+func (t *TbodyOpen) Opening() bool { return true }
+
+func (t *TbodyClose) Opening() bool { return false }
+
+func (t *TdOpen) Opening() bool { return true }
+
+func (t *TdClose) Opening() bool { return false }
+
+func (t *Text) Opening() bool { return false }
+
+func (t *BlockquoteOpen) Closing() bool { return false }
+
+func (t *BlockquoteClose) Closing() bool { return true }
+
+func (t *BulletListOpen) Closing() bool { return false }
+
+func (t *BulletListClose) Closing() bool { return true }
+
+func (t *OrderedListOpen) Closing() bool { return false }
+
+func (t *OrderedListClose) Closing() bool { return true }
+
+func (t *ListItemOpen) Closing() bool { return false }
+
+func (t *ListItemClose) Closing() bool { return true }
+
+func (t *CodeBlock) Closing() bool { return false }
+
+func (t *CodeInline) Closing() bool { return false }
+
+func (t *EmphasisOpen) Closing() bool { return false }
+
+func (t *EmphasisClose) Closing() bool { return true }
+
+func (t *StrongOpen) Closing() bool { return false }
+
+func (t *StrongClose) Closing() bool { return true }
+
+func (t *StrikethroughOpen) Closing() bool { return false }
+
+func (t *StrikethroughClose) Closing() bool { return true }
+
+func (t *Fence) Closing() bool { return false }
+
+func (t *Softbreak) Closing() bool { return false }
+
+func (t *Hardbreak) Closing() bool { return false }
+
+func (t *HeadingOpen) Closing() bool { return false }
+
+func (t *HeadingClose) Closing() bool { return true }
+
+func (t *HTMLBlock) Closing() bool { return false }
+
+func (t *HTMLInline) Closing() bool { return false }
+
+func (t *Hr) Closing() bool { return false }
+
+func (t *Image) Closing() bool { return false }
+
+func (t *Inline) Closing() bool { return false }
+
+func (t *LinkOpen) Closing() bool { return false }
+
+func (t *LinkClose) Closing() bool { return true }
+
+func (t *ParagraphOpen) Closing() bool { return false }
+
+func (t *ParagraphClose) Closing() bool { return true }
+
+func (t *TableOpen) Closing() bool { return false }
+
+func (t *TableClose) Closing() bool { return true }
+
+func (t *TheadOpen) Closing() bool { return false }
+
+func (t *TheadClose) Closing() bool { return true }
+
+func (t *TrOpen) Closing() bool { return false }
+
+func (t *TrClose) Closing() bool { return true }
+
+func (t *ThOpen) Closing() bool { return false }
+
+func (t *ThClose) Closing() bool { return true }
+
+func (t *TbodyOpen) Closing() bool { return false }
+
+func (t *TbodyClose) Closing() bool { return true }
+
+func (t *TdOpen) Closing() bool { return false }
+
+func (t *TdClose) Closing() bool { return true }
+
+func (t *Text) Closing() bool { return false }
+
+func (t *BlockquoteOpen) Block() bool { return true }
+
+func (t *BlockquoteClose) Block() bool { return true }
+
+func (t *BulletListOpen) Block() bool { return true }
+
+func (t *BulletListClose) Block() bool { return true }
+
+func (t *OrderedListOpen) Block() bool { return true }
+
+func (t *OrderedListClose) Block() bool { return true }
+
+func (t *ListItemOpen) Block() bool { return true }
+
+func (t *ListItemClose) Block() bool { return true }
+
+func (t *CodeBlock) Block() bool { return true }
+
+func (t *CodeInline) Block() bool { return false }
+
+func (t *EmphasisOpen) Block() bool { return false }
+
+func (t *EmphasisClose) Block() bool { return false }
+
+func (t *StrongOpen) Block() bool { return false }
+
+func (t *StrongClose) Block() bool { return false }
+
+func (t *StrikethroughOpen) Block() bool { return false }
+
+func (t *StrikethroughClose) Block() bool { return false }
+
+func (t *Fence) Block() bool { return true }
+
+func (t *Softbreak) Block() bool { return false }
+
+func (t *Hardbreak) Block() bool { return false }
+
+func (t *HeadingOpen) Block() bool { return true }
+
+func (t *HeadingClose) Block() bool { return true }
+
+func (t *HTMLBlock) Block() bool { return true }
+
+func (t *HTMLInline) Block() bool { return false }
+
+func (t *Hr) Block() bool { return true }
+
+func (t *Image) Block() bool { return false }
+
+func (t *Inline) Block() bool { return false }
+
+func (t *LinkOpen) Block() bool { return false }
+
+func (t *LinkClose) Block() bool { return false }
+
+func (t *ParagraphOpen) Block() bool { return true }
+
+func (t *ParagraphClose) Block() bool { return true }
+
+func (t *TableOpen) Block() bool { return true }
+
+func (t *TableClose) Block() bool { return true }
+
+func (t *TheadOpen) Block() bool { return true }
+
+func (t *TheadClose) Block() bool { return true }
+
+func (t *TrOpen) Block() bool { return true }
+
+func (t *TrClose) Block() bool { return true }
+
+func (t *ThOpen) Block() bool { return true }
+
+func (t *ThClose) Block() bool { return true }
+
+func (t *TbodyOpen) Block() bool { return true }
+
+func (t *TbodyClose) Block() bool { return true }
+
+func (t *TdOpen) Block() bool { return true }
+
+func (t *TdClose) Block() bool { return true }
+
+func (t *Text) Block() bool { return false }
+
+func (t *BlockquoteOpen) Tag() string { return "blockquote" }
+
+func (t *BlockquoteClose) Tag() string { return "blockquote" }
+
+func (t *BulletListOpen) Tag() string { return "ul" }
+
+func (t *BulletListClose) Tag() string { return "ul" }
+
+func (t *OrderedListOpen) Tag() string { return "ol" }
+
+func (t *OrderedListClose) Tag() string { return "ol" }
+
+func (t *ListItemOpen) Tag() string { return "li" }
+
+func (t *ListItemClose) Tag() string { return "li" }
+
+func (t *CodeBlock) Tag() string { return "code" }
+
+func (t *CodeInline) Tag() string { return "code" }
+
+func (t *EmphasisOpen) Tag() string { return "em" }
+
+func (t *EmphasisClose) Tag() string { return "em" }
+
+func (t *StrongOpen) Tag() string { return "strong" }
+
+func (t *StrongClose) Tag() string { return "strong" }
+
+func (t *StrikethroughOpen) Tag() string { return "s" }
+
+func (t *StrikethroughClose) Tag() string { return "s" }
+
+func (t *Fence) Tag() string { return "code" }
+
+func (t *Softbreak) Tag() string { return "br" }
+
+func (t *Hardbreak) Tag() string { return "br" }
+
+func (t *HeadingOpen) Tag() string { return htags[t.HLevel] }
+
+func (t *HeadingClose) Tag() string { return htags[t.HLevel] }
+
+func (t *HTMLBlock) Tag() string { return "" }
+
+func (t *HTMLInline) Tag() string { return "" }
+
+func (t *Hr) Tag() string { return "hr" }
+
+func (t *Image) Tag() string { return "img" }
+
+func (t *Inline) Tag() string { return "" }
+
+func (t *LinkOpen) Tag() string { return "a" }
+
+func (t *LinkClose) Tag() string { return "a" }
+
+func (t *ParagraphOpen) Tag() string { return "p" }
+
+func (t *ParagraphClose) Tag() string { return "p" }
+
+func (t *TableOpen) Tag() string { return "table" }
+
+func (t *TableClose) Tag() string { return "table" }
+
+func (t *TheadOpen) Tag() string { return "thead" }
+
+func (t *TheadClose) Tag() string { return "thead" }
+
+func (t *TrOpen) Tag() string { return "tr" }
+
+func (t *TrClose) Tag() string { return "tr" }
+
+func (t *ThOpen) Tag() string { return "th" }
+
+func (t *ThClose) Tag() string { return "th" }
+
+func (t *TbodyOpen) Tag() string { return "tbody" }
+
+func (t *TbodyClose) Tag() string { return "tbody" }
+
+func (t *TdOpen) Tag() string { return "td" }
+
+func (t *TdClose) Tag() string { return "td" }
+
+func (t *Text) Tag() string { return "" }
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/urlschema.go b/vendor/gitlab.com/golang-commonmark/markdown/urlschema.go
new file mode 100644
index 000000000..06b9e6a1b
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/urlschema.go
@@ -0,0 +1,185 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+var urlSchemas = []string{
+	"aaa",
+	"aaas",
+	"about",
+	"acap",
+	"adiumxtra",
+	"afp",
+	"afs",
+	"aim",
+	"apt",
+	"attachment",
+	"aw",
+	"beshare",
+	"bitcoin",
+	"bolo",
+	"callto",
+	"cap",
+	"chrome",
+	"chrome-extension",
+	"cid",
+	"coap",
+	"com-eventbrite-attendee",
+	"content",
+	"crid",
+	"cvs",
+	"data",
+	"dav",
+	"dict",
+	"dlna-playcontainer",
+	"dlna-playsingle",
+	"dns",
+	"doi",
+	"dtn",
+	"dvb",
+	"ed2k",
+	"facetime",
+	"feed",
+	"file",
+	"finger",
+	"fish",
+	"ftp",
+	"geo",
+	"gg",
+	"git",
+	"gizmoproject",
+	"go",
+	"gopher",
+	"gtalk",
+	"h323",
+	"hcp",
+	"http",
+	"https",
+	"iax",
+	"icap",
+	"icon",
+	"im",
+	"imap",
+	"info",
+	"ipn",
+	"ipp",
+	"irc",
+	"irc6",
+	"ircs",
+	"iris",
+	"iris.beep",
+	"iris.lwz",
+	"iris.xpc",
+	"iris.xpcs",
+	"itms",
+	"jar",
+	"javascript",
+	"jms",
+	"keyparc",
+	"lastfm",
+	"ldap",
+	"ldaps",
+	"magnet",
+	"mailto",
+	"maps",
+	"market",
+	"message",
+	"mid",
+	"mms",
+	"ms-help",
+	"msnim",
+	"msrp",
+	"msrps",
+	"mtqp",
+	"mumble",
+	"mupdate",
+	"mvn",
+	"news",
+	"nfs",
+	"ni",
+	"nih",
+	"nntp",
+	"notes",
+	"oid",
+	"opaquelocktoken",
+	"palm",
+	"paparazzi",
+	"platform",
+	"pop",
+	"pres",
+	"proxy",
+	"psyc",
+	"query",
+	"res",
+	"resource",
+	"rmi",
+	"rsync",
+	"rtmp",
+	"rtsp",
+	"secondlife",
+	"service",
+	"session",
+	"sftp",
+	"sgn",
+	"shttp",
+	"sieve",
+	"sip",
+	"sips",
+	"skype",
+	"smb",
+	"sms",
+	"snmp",
+	"soap.beep",
+	"soap.beeps",
+	"soldat",
+	"spotify",
+	"ssh",
+	"steam",
+	"svn",
+	"tag",
+	"teamspeak",
+	"tel",
+	"telnet",
+	"tftp",
+	"things",
+	"thismessage",
+	"tip",
+	"tn3270",
+	"tv",
+	"udp",
+	"unreal",
+	"urn",
+	"ut2004",
+	"vemmi",
+	"ventrilo",
+	"view-source",
+	"webcal",
+	"ws",
+	"wss",
+	"wtai",
+	"wyciwyg",
+	"xcon",
+	"xcon-userid",
+	"xfire",
+	"xmlrpc.beep",
+	"xmlrpc.beeps",
+	"xmpp",
+	"xri",
+	"ymsgr",
+	"z39.50r",
+	"z39.50s",
+}
+
+var urlSchemasSet = make(map[string]bool)
+
+func init() {
+	for _, s := range urlSchemas {
+		urlSchemasSet[s] = true
+	}
+}
+
+func matchSchema(s string) bool {
+	_, ok := urlSchemasSet[s]
+	return ok
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/util.go b/vendor/gitlab.com/golang-commonmark/markdown/util.go
new file mode 100644
index 000000000..d821202c4
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/util.go
@@ -0,0 +1,264 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"bytes"
+	"regexp"
+	"strings"
+	"unicode"
+
+	"gitlab.com/golang-commonmark/html"
+	"gitlab.com/golang-commonmark/mdurl"
+	"gitlab.com/golang-commonmark/puny"
+)
+
+func runeIsSpace(r rune) bool {
+	return r == ' ' || r == '\t'
+}
+
+func byteIsSpace(b byte) bool {
+	return b == ' ' || b == '\t'
+}
+
+func isLetter(b byte) bool {
+	return b >= 'a' && b <= 'z' || b >= 'A' && b <= 'Z'
+}
+
+func isUppercaseLetter(b byte) bool {
+	return b >= 'A' && b <= 'Z'
+}
+
+func mdpunct(b byte) bool {
+	return strings.IndexByte("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", b) != -1
+}
+
+func isMdAsciiPunct(r rune) bool {
+	if r > 0x7e {
+		return false
+	}
+	return mdpunct(byte(r))
+}
+
+func recodeHostnameFor(proto string) bool {
+	switch proto {
+	case "http", "https", "mailto":
+		return true
+	}
+	return false
+}
+
+func normalizeLink(url string) string {
+	parsed, err := mdurl.Parse(url)
+	if err != nil {
+		return ""
+	}
+
+	if parsed.Host != "" && (parsed.Scheme == "" || recodeHostnameFor(parsed.Scheme)) {
+		parsed.Host = puny.ToASCII(parsed.Host)
+	}
+
+	parsed.Scheme = parsed.RawScheme
+
+	return mdurl.Encode(parsed.String())
+}
+
+func normalizeLinkText(url string) string {
+	parsed, err := mdurl.Parse(url)
+	if err != nil {
+		return ""
+	}
+
+	if parsed.Host != "" && (parsed.Scheme == "" || recodeHostnameFor(parsed.Scheme)) {
+		parsed.Host = puny.ToUnicode(parsed.Host)
+	}
+
+	parsed.Scheme = parsed.RawScheme
+
+	return mdurl.Decode(parsed.String())
+}
+
+var badProtos = []string{"file", "javascript", "vbscript"}
+
+var rGoodData = regexp.MustCompile(`^data:image/(gif|png|jpeg|webp);`)
+
+func removeSpecial(s string) string {
+	i := 0
+	for i < len(s) && !(s[i] <= 0x20 || s[i] == 0x7f) {
+		i++
+	}
+	if i >= len(s) {
+		return s
+	}
+	buf := make([]byte, len(s))
+	j := 0
+	for i := 0; i < len(s); i++ {
+		if !(s[i] <= 0x20 || s[i] == 0x7f) {
+			buf[j] = s[i]
+			j++
+		}
+	}
+	return string(buf[:j])
+}
+
+func validateLink(url string) bool {
+	str := strings.TrimSpace(url)
+	str = strings.ToLower(str)
+
+	if strings.IndexByte(str, ':') >= 0 {
+		proto := strings.SplitN(str, ":", 2)[0]
+		proto = removeSpecial(proto)
+		for _, p := range badProtos {
+			if proto == p {
+				return false
+			}
+		}
+		if proto == "data" && !rGoodData.MatchString(str) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func unescapeAll(s string) string {
+	anyChanges := false
+	i := 0
+	for i < len(s)-1 {
+		b := s[i]
+		if b == '\\' {
+			if mdpunct(s[i+1]) {
+				anyChanges = true
+				break
+			}
+		} else if b == '&' {
+			if e, n := html.ParseEntity(s[i:]); n > 0 && e != html.BadEntity {
+				anyChanges = true
+				break
+			}
+		}
+		i++
+	}
+
+	if !anyChanges {
+		return s
+	}
+
+	buf := make([]byte, len(s))
+	copy(buf[:i], s)
+	j := i
+	for i < len(s) {
+		b := s[i]
+		if b == '\\' {
+			if i+1 < len(s) {
+				b = s[i+1]
+				if mdpunct(b) {
+					buf[j] = b
+					j++
+				} else {
+					buf[j] = '\\'
+					j++
+					buf[j] = b
+					j++
+				}
+				i += 2
+				continue
+			}
+		} else if b == '&' {
+			if e, n := html.ParseEntity(s[i:]); n > 0 && e != html.BadEntity {
+				if len(e) > n && len(buf) == len(s) {
+					newBuf := make([]byte, cap(buf)*2)
+					copy(newBuf[:j], buf)
+					buf = newBuf
+				}
+				j += copy(buf[j:], e)
+				i += n
+				continue
+			}
+		}
+		buf[j] = b
+		j++
+		i++
+	}
+
+	return string(buf[:j])
+}
+
+func normalizeInlineCode(s string) string {
+	if s == "" {
+		return ""
+	}
+
+	byteFuckery := false
+	i := 0
+	for i < len(s)-1 {
+		b := s[i]
+		if b == '\n' {
+			byteFuckery = true
+			break
+		}
+		if b == ' ' {
+			i++
+			b = s[i]
+			if b == ' ' || b == '\n' {
+				i--
+				byteFuckery = true
+				break
+			}
+		}
+		i++
+	}
+
+	if !byteFuckery {
+		return strings.TrimSpace(s)
+	}
+
+	buf := make([]byte, len(s))
+	copy(buf[:i], s)
+	buf[i] = ' '
+	i++
+	j := i
+	lastSpace := true
+	for i < len(s) {
+		b := s[i]
+		switch b {
+		case ' ', '\n':
+			if lastSpace {
+				break
+			}
+
+			buf[j] = ' '
+			lastSpace = true
+			j++
+		default:
+			buf[j] = b
+			lastSpace = false
+			j++
+		}
+
+		i++
+	}
+
+	return string(bytes.TrimSpace(buf[:j]))
+}
+
+func normalizeReference(s string) string {
+	var buf bytes.Buffer
+	lastSpace := false
+	for _, r := range s {
+		if unicode.IsSpace(r) {
+			if !lastSpace {
+				buf.WriteByte(' ')
+				lastSpace = true
+			}
+			continue
+		}
+
+		buf.WriteRune(unicode.ToLower(r))
+		lastSpace = false
+	}
+
+	return string(bytes.TrimSpace(buf.Bytes()))
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/util_test.go b/vendor/gitlab.com/golang-commonmark/markdown/util_test.go
new file mode 100644
index 000000000..10b165dc7
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/util_test.go
@@ -0,0 +1,195 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"testing"
+)
+
+func TestUnescapeAll(t *testing.T) {
+	type testCase struct {
+		in   string
+		want string
+	}
+	testCases := []testCase{
+		{"", ""},
+		{`foo \`, `foo \`},
+		{`\f\o\o`, `\f\o\o`},
+		{`\!\"\#\$\%\&\'\(\)\*\+\,\-\.\/\:\;\<\=\>\?\@\[\\\]\^\_\{\|\}\~`, "!\"#$%&'()*+,-./:;<=>?@[\\]^_{|}~"},
+		{`\foo b\#a\r`, `\foo b#a\r`},
+		{"&amp;", "&"},
+		{`\&amp;`, "&amp;"},
+		{"&quot;&amp;&quot;", `"&"`},
+		{"&nLt;&nGt;", "\u226a\u20d2\u226b\u20d2"},
+	}
+	for _, tc := range testCases {
+		got := unescapeAll(tc.in)
+		if got != tc.want {
+			t.Errorf("unescapeAll(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestNormalizeInlineCode(t *testing.T) {
+	type testCase struct {
+		in   string
+		want string
+	}
+	testCases := []testCase{
+		{"", ""},
+		{"    ", ""},
+		{"\n", ""},
+		{"\n\n", ""},
+		{"\nfoo\n", "foo"},
+		{"foo bar", "foo bar"},
+		{"foo\nbar", "foo bar"},
+		{"foo\n\nbar", "foo bar"},
+		{"foo  bar", "foo bar"},
+		{"foo  \nbar", "foo bar"},
+		{"  foo  ", "foo"},
+		{"    foo   bar\n  baz\n  foo\n\n", "foo bar baz foo"},
+	}
+	for _, tc := range testCases {
+		got := normalizeInlineCode(tc.in)
+		if got != tc.want {
+			t.Errorf("normalizeInlineCode(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestValidateLink(t *testing.T) {
+	type testCase struct {
+		in   string
+		want bool
+	}
+	testCases := []testCase{
+		{"", true},
+		{"http://google.com", true},
+		{"javascript:alert(1)", false},
+		{"Javascript:alert(1)", false},
+		{"  javascript:alert(1)", false},
+		{"\x09javascript:alert(1)", false},
+		{"\x00javascript:alert(1)", false},
+		// {"&#9;javascript:alert(1)", false},
+		{"&#1;javascript:alert(1)", true},
+		// {"&#x6a;avascript:alert(1)", false},
+		// {"&#x4a;avascript:alert(1)", false},
+		{"&#x26;#x6a;avascript:alert(1)", true},
+		// {"javascript&#x3a;alert(1)", false},
+		{"vbscript:alert(1)", false},
+		{"file:///home", false},
+		{"data:text/html;base64,", false},
+		{"data:image/jpeg;base64,", true},
+		{"data:image/gif;base64,", true},
+		{"data:image/png;base64,", true},
+		{"data:image/webp;base64,", true},
+	}
+	for _, tc := range testCases {
+		got := validateLink(tc.in)
+		if got != tc.want {
+			t.Errorf("validateLink(%q) = %v, want %v", tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestIsMarkdownPunct(t *testing.T) {
+	type testCase struct {
+		in   string
+		want bool
+	}
+	testCases := []testCase{
+		{"!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", true},
+		{" \x7f0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZабвгдеёжзийклмнопрстуфхцчшщьыъэюяАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЫЪЭЮЯ", false},
+	}
+	for _, tc := range testCases {
+		for _, r := range tc.in {
+			got := isMdAsciiPunct(r)
+			if got != tc.want {
+				t.Errorf("isMarkdownPunct(%c) = %v, want %v", r, got, tc.want)
+			}
+		}
+	}
+}
+
+func TestNormalizeLink(t *testing.T) {
+	type testCase struct {
+		in   string
+		want string
+	}
+	testCases := []testCase{
+		{"", ""},
+		// {"http://google.com/s%65arch", "http://google.com/search"},
+		{"http://google.com/search?query=%5B%5D", "http://google.com/search?query=%5B%5D"},
+		{"//google.com", "//google.com"},
+		{"http://%XX", "http://%25XX"},
+	}
+	for _, tc := range testCases {
+		got := normalizeLink(tc.in)
+		if got != tc.want {
+			t.Errorf("normalizeLink(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestNormalizeLinkText(t *testing.T) {
+	type testCase struct {
+		in   string
+		want string
+	}
+	testCases := []testCase{
+		{"", ""},
+		{"http://google.com/s%65arch", "http://google.com/search"},
+		{"http://google.com/search%XX", "http://google.com/search%XX"},
+		// {"http://google.com/search%80", "http://google.com/search%80"},
+	}
+	for _, tc := range testCases {
+		got := normalizeLinkText(tc.in)
+		if got != tc.want {
+			t.Errorf("normalizeLinkText(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestNormalizeReference(t *testing.T) {
+	type testCase struct {
+		in   string
+		want string
+	}
+	testCases := []testCase{
+		{"", ""},
+		{"  r  e  f  ", "r e f"},
+		{"  ref  ", "ref"},
+		{" ref ", "ref"},
+		{"ref", "ref"},
+		{"REF", "ref"},
+		{"r\u00a0e\u00a0f", "r e f"},
+	}
+	for _, tc := range testCases {
+		got := normalizeReference(tc.in)
+		if got != tc.want {
+			t.Errorf("normalizeReference(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestRemoveSpecial(t *testing.T) {
+	type testCase struct {
+		in   string
+		want string
+	}
+	testCases := []testCase{
+		{"", ""},
+		{"javascript", "javascript"},
+		{"javascript\x00", "javascript"},
+		{"\x00javascript", "javascript"},
+		{"\x00java\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x20script\x7f", "javascript"},
+	}
+	for _, tc := range testCases {
+		got := removeSpecial(tc.in)
+		if got != tc.want {
+			t.Errorf("removeSpecial(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/markdown/writer.go b/vendor/gitlab.com/golang-commonmark/markdown/writer.go
new file mode 100644
index 000000000..886a1de45
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/markdown/writer.go
@@ -0,0 +1,69 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package markdown
+
+import (
+	"bufio"
+	"io"
+)
+
+type writer interface {
+	Write([]byte) (int, error)
+	WriteByte(byte) error
+	WriteString(string) (int, error)
+	Flush() error
+}
+
+type monadicWriter struct {
+	writer
+	err error
+}
+
+func newMonadicWriter(w io.Writer) *monadicWriter {
+	if w, ok := w.(writer); ok {
+		return &monadicWriter{writer: w}
+	}
+	return &monadicWriter{writer: bufio.NewWriter(w)}
+}
+
+func (w *monadicWriter) Write(p []byte) (n int, err error) {
+	if w.err != nil {
+		return
+	}
+
+	n, err = w.writer.Write(p)
+	w.err = err
+	return
+}
+
+func (w *monadicWriter) WriteByte(b byte) (err error) {
+	if w.err != nil {
+		return
+	}
+
+	err = w.writer.WriteByte(b)
+	w.err = err
+	return
+}
+
+func (w *monadicWriter) WriteString(s string) (n int, err error) {
+	if w.err != nil {
+		return
+	}
+
+	n, err = w.writer.WriteString(s)
+	w.err = err
+	return
+}
+
+func (w *monadicWriter) Flush() (err error) {
+	if w.err != nil {
+		return
+	}
+
+	err = w.writer.Flush()
+	w.err = err
+	return
+}
diff --git a/vendor/gitlab.com/golang-commonmark/mdurl/.gitlab-ci.yml b/vendor/gitlab.com/golang-commonmark/mdurl/.gitlab-ci.yml
new file mode 100644
index 000000000..aaf2cbddf
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/mdurl/.gitlab-ci.yml
@@ -0,0 +1,16 @@
+image: golang:1.11
+
+stages:
+  - build
+  - test
+
+build:
+  stage: build
+  script:
+    - go build ./...
+
+test:
+  stage: test
+  script:
+    - test -z "$(gofmt -l . | tee /dev/stderr)"
+    - go test ./...
diff --git a/vendor/gitlab.com/golang-commonmark/mdurl/LICENSE b/vendor/gitlab.com/golang-commonmark/mdurl/LICENSE
new file mode 100644
index 000000000..9cdcd2016
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/mdurl/LICENSE
@@ -0,0 +1,10 @@
+Copyright (c) 2015, The Authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE 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 HOLDER 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.
diff --git a/vendor/gitlab.com/golang-commonmark/mdurl/README.md b/vendor/gitlab.com/golang-commonmark/mdurl/README.md
new file mode 100644
index 000000000..ff4adc147
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/mdurl/README.md
@@ -0,0 +1,8 @@
+mdurl [![License](https://img.shields.io/badge/licence-BSD--2--Clause-blue.svg)](https://opensource.org/licenses/BSD-2-Clause) [![GoDoc](http://godoc.org/gitlab.com/golang-commonmark/mdurl?status.svg)](http://godoc.org/gitlab.com/golang-commonmark/mdurl) [![Pipeline status](https://gitlab.com/golang-commonmark/mdurl/badges/master/pipeline.svg)](https://gitlab.com/golang-commonmark/mdurl/commits/master)
+=====
+
+Package mdurl provides functions for parsing, decoding and encoding URLs.
+
+## Install
+
+    go get -u gitlab.com/golang-commonmark/mdurl
diff --git a/vendor/gitlab.com/golang-commonmark/mdurl/decode.go b/vendor/gitlab.com/golang-commonmark/mdurl/decode.go
new file mode 100644
index 000000000..91430b74c
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/mdurl/decode.go
@@ -0,0 +1,80 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mdurl
+
+import (
+	"bytes"
+	"unicode/utf8"
+)
+
+func advance(s string, pos int) (byte, int) {
+	if pos >= len(s) {
+		return 0, len(s) + 1
+	}
+	if s[pos] != '%' {
+		return s[pos], pos + 1
+	}
+	if pos+2 < len(s) &&
+		hexDigit(s[pos+1]) &&
+		hexDigit(s[pos+2]) {
+		return unhex(s[pos+1])<<4 | unhex(s[pos+2]), pos + 3
+	}
+	return '%', pos + 1
+}
+
+// Decode decodes a percent-encoded URL.
+// Invalid percent-encoded sequences are left as is.
+// Invalid UTF-8 sequences are replaced with U+FFFD.
+func Decode(rawurl string) string {
+	var buf bytes.Buffer
+	i := 0
+	const replacement = "\xEF\xBF\xBD"
+outer:
+	for i < len(rawurl) {
+		r, rlen := utf8.DecodeRuneInString(rawurl[i:])
+		if r == '%' && i+2 < len(rawurl) &&
+			hexDigit(rawurl[i+1]) &&
+			hexDigit(rawurl[i+2]) {
+			b := unhex(rawurl[i+1])<<4 | unhex(rawurl[i+2])
+			if b < 0x80 {
+				buf.WriteByte(b)
+				i += 3
+				continue
+			}
+			var n int
+			if b&0xe0 == 0xc0 {
+				n = 1
+			} else if b&0xf0 == 0xe0 {
+				n = 2
+			} else if b&0xf8 == 0xf0 {
+				n = 3
+			}
+			if n == 0 {
+				buf.WriteString(replacement)
+				i += 3
+				continue
+			}
+			rb := make([]byte, n+1)
+			rb[0] = b
+			j := i + 3
+			for k := 0; k < n; k++ {
+				b, j = advance(rawurl, j)
+				if j > len(rawurl) || b&0xc0 != 0x80 {
+					buf.WriteString(replacement)
+					i += 3
+					continue outer
+				}
+				rb[k+1] = b
+			}
+			r, _ := utf8.DecodeRune(rb)
+			buf.WriteRune(r)
+			i = j
+			continue
+		}
+		buf.WriteRune(r)
+		i += rlen
+	}
+	return buf.String()
+}
diff --git a/vendor/gitlab.com/golang-commonmark/mdurl/encode.go b/vendor/gitlab.com/golang-commonmark/mdurl/encode.go
new file mode 100644
index 000000000..5596e8d3d
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/mdurl/encode.go
@@ -0,0 +1,53 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mdurl
+
+import (
+	"bytes"
+	"strings"
+	"unicode/utf8"
+)
+
+// Encode percent-encodes rawurl, avoiding double encoding.
+// It doesn't touch:
+// - alphanumeric characters ([0-9a-zA-Z]);
+// - percent-encoded characters (%[0-9a-fA-F]{2});
+// - excluded characters ([;/?:@&=+$,-_.!~*'()#]).
+// Invalid UTF-8 sequences are replaced with U+FFFD.
+func Encode(rawurl string) string {
+	const hexdigit = "0123456789ABCDEF"
+	var buf bytes.Buffer
+	i := 0
+	for i < len(rawurl) {
+		r, rlen := utf8.DecodeRuneInString(rawurl[i:])
+		if r >= 0x80 {
+			for j, n := i, i+rlen; j < n; j++ {
+				b := rawurl[j]
+				buf.WriteByte('%')
+				buf.WriteByte(hexdigit[(b>>4)&0xf])
+				buf.WriteByte(hexdigit[b&0xf])
+			}
+		} else if r == '%' {
+			if i+2 < len(rawurl) &&
+				hexDigit(rawurl[i+1]) &&
+				hexDigit(rawurl[i+2]) {
+				buf.WriteByte('%')
+				buf.WriteByte(byteToUpper(rawurl[i+1]))
+				buf.WriteByte(byteToUpper(rawurl[i+2]))
+				i += 2
+			} else {
+				buf.WriteString("%25")
+			}
+		} else if strings.IndexByte("!#$&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~", byte(r)) == -1 {
+			buf.WriteByte('%')
+			buf.WriteByte(hexdigit[(r>>4)&0xf])
+			buf.WriteByte(hexdigit[r&0xf])
+		} else {
+			buf.WriteByte(byte(r))
+		}
+		i += rlen
+	}
+	return buf.String()
+}
diff --git a/vendor/gitlab.com/golang-commonmark/mdurl/parse.go b/vendor/gitlab.com/golang-commonmark/mdurl/parse.go
new file mode 100644
index 000000000..595fcdeaf
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/mdurl/parse.go
@@ -0,0 +1,146 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mdurl
+
+import (
+	"errors"
+	"strings"
+)
+
+// ErrMissingScheme error is returned by Parse if the passed URL starts with a colon.
+var ErrMissingScheme = errors.New("missing protocol scheme")
+
+var slashedProtocol = map[string]bool{
+	"http":   true,
+	"https":  true,
+	"ftp":    true,
+	"gopher": true,
+	"file":   true,
+}
+
+func split(s string, c byte) (string, string, bool) {
+	i := strings.IndexByte(s, c)
+	if i < 0 {
+		return s, "", false
+	}
+	return s[:i], s[i+1:], true
+}
+
+func findScheme(s string) (int, error) {
+	if s == "" {
+		return 0, nil
+	}
+
+	b := s[0]
+	if b == ':' {
+		return 0, ErrMissingScheme
+	}
+	if !letter(b) {
+		return 0, nil
+	}
+
+	for i := 1; i < len(s); i++ {
+		b := s[i]
+		switch {
+		case b == ':':
+			return i, nil
+		case strings.IndexByte("+-.0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", b) != -1:
+			// do nothing
+		default:
+			return 0, nil
+		}
+	}
+
+	return 0, nil
+}
+
+// Parse parses rawurl into a URL structure.
+func Parse(rawurl string) (*URL, error) {
+	n, err := findScheme(rawurl)
+	if err != nil {
+		return nil, err
+	}
+
+	var url URL
+	rest := rawurl
+	hostless := false
+	if n > 0 {
+		url.RawScheme = rest[:n]
+		url.Scheme, rest = strings.ToLower(rest[:n]), rest[n+1:]
+		if url.Scheme == "javascript" {
+			hostless = true
+		}
+	}
+
+	if !hostless && strings.HasPrefix(rest, "//") {
+		url.Slashes, rest = true, rest[2:]
+	}
+
+	if !hostless && (url.Slashes || (url.Scheme != "" && !slashedProtocol[url.Scheme])) {
+		hostEnd := strings.IndexAny(rest, "#/?")
+		atSign := -1
+		i := hostEnd
+		if i == -1 {
+			i = len(rest) - 1
+		}
+		for i >= 0 {
+			if rest[i] == '@' {
+				atSign = i
+				break
+			}
+			i--
+		}
+
+		if atSign != -1 {
+			url.Auth, rest = rest[:atSign], rest[atSign+1:]
+		}
+
+		hostEnd = strings.IndexAny(rest, "\t\r\n \"#%'/;<>?\\^`{|}")
+		if hostEnd == -1 {
+			hostEnd = len(rest)
+		}
+		if hostEnd > 0 && hostEnd < len(rest) && rest[hostEnd-1] == ':' {
+			hostEnd--
+		}
+		host := rest[:hostEnd]
+
+		if len(host) > 1 {
+			b := host[hostEnd-1]
+			if digit(b) {
+				for i := len(host) - 2; i >= 0; i-- {
+					b := host[i]
+					if b == ':' {
+						url.Host, url.Port = host[:i], host[i+1:]
+						break
+					}
+					if !digit(b) {
+						break
+					}
+				}
+			} else if b == ':' {
+				host = host[:hostEnd-1]
+				hostEnd--
+			}
+		}
+		if url.Port == "" {
+			url.Host = host
+		}
+		rest = rest[hostEnd:]
+
+		if ipv6 := len(url.Host) > 2 &&
+			url.Host[0] == '[' &&
+			url.Host[len(url.Host)-1] == ']'; ipv6 {
+			url.Host = url.Host[1 : len(url.Host)-1]
+			url.IPv6 = true
+		} else if i := strings.IndexByte(url.Host, ':'); i >= 0 {
+			url.Host, rest = url.Host[:i], url.Host[i:]+rest
+		}
+	}
+
+	rest, url.Fragment, url.HasFragment = split(rest, '#')
+	url.Path, url.RawQuery, url.HasQuery = split(rest, '?')
+
+	return &url, nil
+}
diff --git a/vendor/gitlab.com/golang-commonmark/mdurl/url.go b/vendor/gitlab.com/golang-commonmark/mdurl/url.go
new file mode 100644
index 000000000..72c3f58aa
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/mdurl/url.go
@@ -0,0 +1,101 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package url provides functions for parsing, decoding and encoding URLs.
+package mdurl
+
+// A URL represents a parsed URL.
+type URL struct {
+	Scheme      string
+	RawScheme   string
+	Slashes     bool
+	Auth        string
+	Host        string
+	Port        string
+	Path        string
+	RawQuery    string
+	HasQuery    bool
+	Fragment    string
+	HasFragment bool
+	IPv6        bool
+}
+
+// String reassembles the URL into a URL string.
+func (u *URL) String() string {
+	size := len(u.Path)
+	if u.Scheme != "" {
+		size += len(u.Scheme) + 1
+	}
+	if u.Slashes {
+		size += 2
+	}
+	if u.Auth != "" {
+		size += len(u.Auth) + 1
+	}
+	if u.Host != "" {
+		size += len(u.Host)
+		if u.IPv6 {
+			size += 2
+		}
+	}
+	if u.Port != "" {
+		size += len(u.Port) + 1
+	}
+	if u.HasQuery {
+		size += len(u.RawQuery) + 1
+	}
+	if u.HasFragment {
+		size += len(u.Fragment) + 1
+	}
+	if size == 0 {
+		return ""
+	}
+
+	buf := make([]byte, size)
+	i := 0
+	if u.Scheme != "" {
+		i += copy(buf, u.Scheme)
+		buf[i] = ':'
+		i++
+	}
+	if u.Slashes {
+		buf[i] = '/'
+		i++
+		buf[i] = '/'
+		i++
+	}
+	if u.Auth != "" {
+		i += copy(buf[i:], u.Auth)
+		buf[i] = '@'
+		i++
+	}
+	if u.Host != "" {
+		if u.IPv6 {
+			buf[i] = '['
+			i++
+			i += copy(buf[i:], u.Host)
+			buf[i] = ']'
+			i++
+		} else {
+			i += copy(buf[i:], u.Host)
+		}
+	}
+	if u.Port != "" {
+		buf[i] = ':'
+		i++
+		i += copy(buf[i:], u.Port)
+	}
+	i += copy(buf[i:], u.Path)
+	if u.HasQuery {
+		buf[i] = '?'
+		i++
+		i += copy(buf[i:], u.RawQuery)
+	}
+	if u.HasFragment {
+		buf[i] = '#'
+		i++
+		i += copy(buf[i:], u.Fragment)
+	}
+	return string(buf)
+}
diff --git a/vendor/gitlab.com/golang-commonmark/mdurl/url_benchmark_test.go b/vendor/gitlab.com/golang-commonmark/mdurl/url_benchmark_test.go
new file mode 100644
index 000000000..5ae034985
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/mdurl/url_benchmark_test.go
@@ -0,0 +1,153 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mdurl
+
+import "testing"
+
+var slashedProtocolArray = [...]string{
+	"http", "https", "ftp", "gopher", "file",
+}
+
+var slashedProtocolSlice = []string{
+	"http", "https", "ftp", "gopher", "file",
+}
+
+func BenchmarkMapAccess(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_ = slashedProtocol["http"]
+		_ = slashedProtocol["file"]
+	}
+}
+
+func BenchmarkArrayAccess(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, p := range slashedProtocolArray {
+			if p == "http" {
+				break
+			}
+		}
+		for _, p := range slashedProtocolArray {
+			if p == "file" {
+				break
+			}
+		}
+	}
+}
+
+func BenchmarkSliceAccess(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, p := range slashedProtocolSlice {
+			if p == "http" {
+				break
+			}
+		}
+		for _, p := range slashedProtocolSlice {
+			if p == "file" {
+				break
+			}
+		}
+	}
+}
+
+func (u *URL) StringWithAppend() string {
+	size := len(u.Path)
+	if u.Scheme != "" {
+		size += len(u.Scheme) + 1
+	}
+	if u.Slashes {
+		size += 2
+	}
+	if u.Auth != "" {
+		size += len(u.Auth) + 1
+	}
+	if u.Host != "" {
+		size += len(u.Host)
+		if u.IPv6 {
+			size += 2
+		}
+	}
+	if u.Port != "" {
+		size += len(u.Port) + 1
+	}
+	if u.RawQuery != "" {
+		size += len(u.RawQuery) + 1
+	}
+	if u.Fragment != "" {
+		size += len(u.Fragment) + 1
+	}
+	if size == 0 {
+		return ""
+	}
+
+	buf := make([]byte, 0, size)
+	if u.Scheme != "" {
+		buf = append(buf, u.Scheme...)
+		buf = append(buf, ':')
+	}
+	if u.Slashes {
+		buf = append(buf, '/', '/')
+	}
+	if u.Auth != "" {
+		buf = append(buf, u.Auth...)
+		buf = append(buf, '@')
+	}
+	if u.Host != "" {
+		if u.IPv6 {
+			buf = append(buf, '[')
+			buf = append(buf, u.Host...)
+			buf = append(buf, ']')
+		} else {
+			buf = append(buf, u.Host...)
+		}
+	}
+	if u.Port != "" {
+		buf = append(buf, ':')
+		buf = append(buf, u.Port...)
+	}
+	buf = append(buf, u.Path...)
+	if u.RawQuery != "" {
+		buf = append(buf, '?')
+		buf = append(buf, u.RawQuery...)
+	}
+	if u.Fragment != "" {
+		buf = append(buf, '#')
+		buf = append(buf, u.Fragment...)
+	}
+	return string(buf)
+}
+
+func BenchmarkString(b *testing.B) {
+	url := URL{
+		Scheme:   "http",
+		Slashes:  true,
+		Auth:     "admin:password",
+		Host:     "example.com",
+		Port:     "80",
+		Path:     "/path",
+		RawQuery: "query",
+		Fragment: "frag",
+		IPv6:     false,
+	}
+	for i := 0; i < b.N; i++ {
+		url.String()
+	}
+}
+
+func BenchmarkStringWithAppend(b *testing.B) {
+	url := URL{
+		Scheme:   "http",
+		Slashes:  true,
+		Auth:     "admin:password",
+		Host:     "example.com",
+		Port:     "80",
+		Path:     "/path",
+		RawQuery: "query",
+		Fragment: "frag",
+		IPv6:     false,
+	}
+	for i := 0; i < b.N; i++ {
+		url.StringWithAppend()
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/mdurl/url_test.go b/vendor/gitlab.com/golang-commonmark/mdurl/url_test.go
new file mode 100644
index 000000000..6538acfe9
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/mdurl/url_test.go
@@ -0,0 +1,1112 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mdurl
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestFindScheme(t *testing.T) {
+	type testCase struct {
+		in   string
+		want int
+		err  error
+	}
+	testCases := []testCase{
+		{in: "", want: 0},
+		{in: ":ptth", err: ErrMissingScheme},
+		{in: "0http://", want: 0},
+		{in: "h!ttp://", want: 0},
+		{in: "http", want: 0},
+		{in: "http://", want: 4},
+		{in: "ed2k://", want: 4},
+	}
+	for _, tc := range testCases {
+		got, err := findScheme(tc.in)
+		if err != nil {
+			if err != tc.err {
+				t.Errorf("findScheme(%q): want error %v, got %v", tc.in, tc.err, err)
+			}
+		} else {
+			if got != tc.want {
+				t.Errorf("findScheme(%q) = %d, want %d", tc.in, got, tc.want)
+			}
+		}
+	}
+}
+
+func TestParse(t *testing.T) {
+	type testCase struct {
+		in   string
+		want URL
+		err  error
+	}
+	testCases := []testCase{
+		{in: "", want: URL{}},
+		{
+			in: "http://example.com:",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "example.com",
+				Path:      ":",
+			},
+		},
+		{
+			in: "git+ssh://git@github.com:npm/npm",
+			want: URL{
+				Scheme:    "git+ssh",
+				RawScheme: "git+ssh",
+				Slashes:   true,
+				Auth:      "git",
+				Host:      "github.com",
+				Path:      ":npm/npm",
+			},
+		},
+		{
+			in: "coap:[fedc:ba98:7654:3210:fedc:ba98:7654:3210]:61616/s/stopButton",
+			want: URL{
+				Scheme:    "coap",
+				RawScheme: "coap",
+				Host:      "fedc:ba98:7654:3210:fedc:ba98:7654:3210",
+				Port:      "61616",
+				Path:      "/s/stopButton",
+				IPv6:      true,
+			},
+		},
+		{
+			in: "file://foo/etc/passwd",
+			want: URL{
+				Scheme:    "file",
+				RawScheme: "file",
+				Slashes:   true,
+				Host:      "foo",
+				Path:      "/etc/passwd",
+			},
+		},
+		{
+			in: "/foo/bar?baz=quux#frag",
+			want: URL{
+				Path:        "/foo/bar",
+				RawQuery:    "baz=quux",
+				HasQuery:    true,
+				Fragment:    "frag",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "javascript:alert(\"hello\");",
+			want: URL{
+				Scheme:    "javascript",
+				RawScheme: "javascript",
+				Path:      "alert(\"hello\");",
+			},
+		},
+		{
+			in: "www.example.com",
+			want: URL{
+				Path: "www.example.com",
+			},
+		},
+		{
+			in: "coap://[1080:0:0:0:8:800:200C:417A]:61616/",
+			want: URL{
+				Scheme:    "coap",
+				RawScheme: "coap",
+				Slashes:   true,
+				Host:      "1080:0:0:0:8:800:200C:417A",
+				Port:      "61616",
+				Path:      "/",
+				IPv6:      true,
+			},
+		},
+		{
+			in: "http://user@www.example.com/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "user",
+				Host:      "www.example.com",
+				Path:      "/",
+			},
+		},
+		{
+			in: "http://x.y.com+a/b/c",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "x.y.com+a",
+				Path:      "/b/c",
+			},
+		},
+		{
+			in: "http://➡.ws/➡",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "➡.ws",
+				Path:      "/➡",
+			},
+		},
+		{
+			in: "http://user:pass@-lovemonsterz.tumblr.com:80/rss",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "user:pass",
+				Host:      "-lovemonsterz.tumblr.com",
+				Port:      "80",
+				Path:      "/rss",
+			},
+		},
+		{
+			in: "http://a@b?@c",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "a",
+				Host:      "b",
+				RawQuery:  "@c",
+				HasQuery:  true,
+			},
+		},
+		{
+			in: "HtTp://x.y.cOm;A/b/c?d=e#f g<h>i",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "HtTp",
+				Slashes:     true,
+				Host:        "x.y.cOm",
+				Path:        ";A/b/c",
+				RawQuery:    "d=e",
+				HasQuery:    true,
+				Fragment:    "f g<h>i",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "file:///etc/node/",
+			want: URL{
+				Scheme:    "file",
+				RawScheme: "file",
+				Slashes:   true,
+				Path:      "/etc/node/",
+			},
+		},
+		{
+			in: "http://atpass:foo%40bar@127.0.0.1:8080/path?search=foo#bar",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Auth:        "atpass:foo%40bar",
+				Host:        "127.0.0.1",
+				Port:        "8080",
+				Path:        "/path",
+				RawQuery:    "search=foo",
+				HasQuery:    true,
+				Fragment:    "bar",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "svn+ssh://foo/bar",
+			want: URL{
+				Scheme:    "svn+ssh",
+				RawScheme: "svn+ssh",
+				Slashes:   true,
+				Host:      "foo",
+				Path:      "/bar",
+			},
+		},
+		{
+			in: "http://user:password@[3ffe:2a00:100:7031::1]:8080",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "user:password",
+				Host:      "3ffe:2a00:100:7031::1",
+				Port:      "8080",
+				IPv6:      true,
+			},
+		},
+		{
+			in: "mailto:foo@bar.com?subject=hello",
+			want: URL{
+				Scheme:    "mailto",
+				RawScheme: "mailto",
+				Auth:      "foo",
+				Host:      "bar.com",
+				RawQuery:  "subject=hello",
+				HasQuery:  true,
+			},
+		},
+		{
+			in: "http://_jabber._tcp.google.com/test",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "_jabber._tcp.google.com",
+				Path:      "/test",
+			},
+		},
+		{
+			in: "git+http://github.com/joyent/node.git",
+			want: URL{
+				Scheme:    "git+http",
+				RawScheme: "git+http",
+				Slashes:   true,
+				Host:      "github.com",
+				Path:      "/joyent/node.git",
+			},
+		},
+		{
+			in: "coap://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]",
+			want: URL{
+				Scheme:    "coap",
+				RawScheme: "coap",
+				Slashes:   true,
+				Host:      "FEDC:BA98:7654:3210:FEDC:BA98:7654:3210",
+				IPv6:      true,
+			},
+		},
+		{
+			in: "http://example.com#frag=?bar/#frag",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Host:        "example.com",
+				Fragment:    "frag=?bar/#frag",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "http://example.com:?a=b",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "example.com",
+				Path:      ":",
+				RawQuery:  "a=b",
+				HasQuery:  true,
+			},
+		},
+		{
+			in: "http://user:pass@_jabber._tcp.google.com:80/test",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "user:pass",
+				Host:      "_jabber._tcp.google.com",
+				Port:      "80",
+				Path:      "/test",
+			},
+		},
+		{
+			in: "http://example.com?foo=/bar/#frag",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Host:        "example.com",
+				RawQuery:    "foo=/bar/",
+				HasQuery:    true,
+				Fragment:    "frag",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "HTTP://www.example.com/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "HTTP",
+				Slashes:   true,
+				Host:      "www.example.com",
+				Path:      "/",
+			},
+		},
+		{
+			in: "http://USER:PW@www.ExAmPlE.com/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "USER:PW",
+				Host:      "www.ExAmPlE.com",
+				Path:      "/",
+			},
+		},
+		{
+			in: "<http://goo.corn/bread> Is a URL!",
+			want: URL{
+				Path: "<http://goo.corn/bread> Is a URL!",
+			},
+		},
+		{
+			in: "file://foo/etc/node/",
+			want: URL{
+				Scheme:    "file",
+				RawScheme: "file",
+				Slashes:   true,
+				Host:      "foo",
+				Path:      "/etc/node/",
+			},
+		},
+		{
+			in: "dash-test://foo/bar",
+			want: URL{
+				Scheme:    "dash-test",
+				RawScheme: "dash-test",
+				Slashes:   true,
+				Host:      "foo",
+				Path:      "/bar",
+			},
+		},
+		{
+			in: "http://atpass:foo%40bar@127.0.0.1/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "atpass:foo%40bar",
+				Host:      "127.0.0.1",
+				Path:      "/",
+			},
+		},
+		{
+			in: "coap:u:p@[::1]:61616/.well-known/r?n=Temperature",
+			want: URL{
+				Scheme:    "coap",
+				RawScheme: "coap",
+				Auth:      "u:p",
+				Host:      "::1",
+				Port:      "61616",
+				Path:      "/.well-known/r",
+				RawQuery:  "n=Temperature",
+				HasQuery:  true,
+				IPv6:      true,
+			},
+		},
+		{
+			in: "http://user:pw@www.ExAmPlE.com/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "user:pw",
+				Host:      "www.ExAmPlE.com",
+				Path:      "/",
+			},
+		},
+		{
+			in: "http://example.Bücher.com/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "example.Bücher.com",
+				Path:      "/",
+			},
+		},
+		{
+			in: "[fe80::1]",
+			want: URL{
+				Path: "[fe80::1]",
+			},
+		},
+		{
+			in: "http://a.com/a/b/c?s#h",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Host:        "a.com",
+				Path:        "/a/b/c",
+				RawQuery:    "s",
+				HasQuery:    true,
+				Fragment:    "h",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "http://ex.com/foo%3F100%m%23r?abc=the%231?&foo=bar#frag",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Host:        "ex.com",
+				Path:        "/foo%3F100%m%23r",
+				RawQuery:    "abc=the%231?&foo=bar",
+				HasQuery:    true,
+				Fragment:    "frag",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "http://ex.com/fooA100%mBr?abc=the%231?&foo=bar#frag",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Host:        "ex.com",
+				Path:        "/fooA100%mBr",
+				RawQuery:    "abc=the%231?&foo=bar",
+				HasQuery:    true,
+				Fragment:    "frag",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "http://x/p/\"quoted\"",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "x",
+				Path:      "/p/\"quoted\"",
+			},
+		},
+		{
+			in: "dot.test://foo/bar",
+			want: URL{
+				Scheme:    "dot.test",
+				RawScheme: "dot.test",
+				Slashes:   true,
+				Host:      "foo",
+				Path:      "/bar",
+			},
+		},
+		{
+			in: "http://SÉLIER.COM/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "SÉLIER.COM",
+				Path:      "/",
+			},
+		},
+		{
+			in: "http://example.com?foo=bar#frag",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Host:        "example.com",
+				RawQuery:    "foo=bar",
+				HasQuery:    true,
+				Fragment:    "frag",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "http://google.com\" onload=\"alert(42)/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "google.com",
+				Path:      "\" onload=\"alert(42)/",
+			},
+		},
+		{
+			in: "http://a@b@c/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "a@b",
+				Host:      "c",
+				Path:      "/",
+			},
+		},
+		{
+			in: "http://example.com?foo=@bar#frag",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Host:        "example.com",
+				RawQuery:    "foo=@bar",
+				HasQuery:    true,
+				Fragment:    "frag",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "//some_path",
+			want: URL{
+				Slashes: true,
+				Host:    "some_path",
+			},
+		},
+		{
+			in: "xmpp:isaacschlueter@jabber.org",
+			want: URL{
+				Scheme:    "xmpp",
+				RawScheme: "xmpp",
+				Auth:      "isaacschlueter",
+				Host:      "jabber.org",
+			},
+		},
+		{
+			in: "dot.test:foo/bar",
+			want: URL{
+				Scheme:    "dot.test",
+				RawScheme: "dot.test",
+				Host:      "foo",
+				Path:      "/bar",
+			},
+		},
+		{
+			in: "http://example.com:/a/b.html",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "example.com",
+				Path:      ":/a/b.html",
+			},
+		},
+		{
+			in: "http://user:pass@_jabber._tcp.google.com/test",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "user:pass",
+				Host:      "_jabber._tcp.google.com",
+				Path:      "/test",
+			},
+		},
+		{
+			in: "http://x.com/path?that\"s#all, folks",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Host:        "x.com",
+				Path:        "/path",
+				RawQuery:    "that\"s",
+				HasQuery:    true,
+				Fragment:    "all, folks",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "http://www.narwhaljs.org/blog/categories?id=news",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "www.narwhaljs.org",
+				Path:      "/blog/categories",
+				RawQuery:  "id=news",
+				HasQuery:  true,
+			},
+		},
+		{
+			in: "file://localhost/etc/node/",
+			want: URL{
+				Scheme:    "file",
+				RawScheme: "file",
+				Slashes:   true,
+				Host:      "localhost",
+				Path:      "/etc/node/",
+			},
+		},
+		{
+			in: "http:/baz/../foo/bar",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Path:      "/baz/../foo/bar",
+			},
+		},
+		{
+			in: "http://user:pass@-lovemonsterz.tumblr.com/rss",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "user:pass",
+				Host:      "-lovemonsterz.tumblr.com",
+				Path:      "/rss",
+			},
+		},
+		{
+			in: "http://x:1/\" <>\"`/{}|\\^~`/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "x",
+				Port:      "1",
+				Path:      "/\" <>\"`/{}|\\^~`/",
+			},
+		},
+		{
+			in: "http://www.ExAmPlE.com/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "www.ExAmPlE.com",
+				Path:      "/",
+			},
+		},
+		{
+			in: "http://user%3Apw@www.example.com/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "user%3Apw",
+				Host:      "www.example.com",
+				Path:      "/",
+			},
+		},
+		{
+			in: "http://user:pass@mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "user:pass",
+				Host:      "mt0.google.com",
+				Path:      "/vt/lyrs=m@114",
+				RawQuery:  "??&hl=en&src=api&x=2&y=2&z=3&s=",
+				HasQuery:  true,
+			},
+		},
+		{
+			in: "http:/foo/bar?baz=quux#frag",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Path:        "/foo/bar",
+				RawQuery:    "baz=quux",
+				HasQuery:    true,
+				Fragment:    "frag",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "http://example.com:#abc",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Host:        "example.com",
+				Path:        ":",
+				Fragment:    "abc",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "http://-lovemonsterz.tumblr.com:80/rss",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "-lovemonsterz.tumblr.com",
+				Port:      "80",
+				Path:      "/rss",
+			},
+		},
+		{
+			in: "http://example.com?foo=?bar/#frag",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Host:        "example.com",
+				RawQuery:    "foo=?bar/",
+				HasQuery:    true,
+				Fragment:    "frag",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "http://user:pass@example.com:8000/foo/bar?baz=quux#frag",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Auth:        "user:pass",
+				Host:        "example.com",
+				Port:        "8000",
+				Path:        "/foo/bar",
+				RawQuery:    "baz=quux",
+				HasQuery:    true,
+				Fragment:    "frag",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "dash-test:foo/bar",
+			want: URL{
+				Scheme:    "dash-test",
+				RawScheme: "dash-test",
+				Host:      "foo",
+				Path:      "/bar",
+			},
+		},
+		{
+			in: "http://bucket_name.s3.amazonaws.com/image.jpg",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "bucket_name.s3.amazonaws.com",
+				Path:      "/image.jpg",
+			},
+		},
+		{
+			in: "local1@domain1",
+			want: URL{
+				Path: "local1@domain1",
+			},
+		},
+		{
+			in: "http://-lovemonsterz.tumblr.com/rss",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "-lovemonsterz.tumblr.com",
+				Path:      "/rss",
+			},
+		},
+		{
+			in: "HTTP://www.example.com",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "HTTP",
+				Slashes:   true,
+				Host:      "www.example.com",
+			},
+		},
+		{
+			in: "//user:pass@example.com:8000/foo/bar?baz=quux#frag",
+			want: URL{
+				Slashes:     true,
+				Auth:        "user:pass",
+				Host:        "example.com",
+				Port:        "8000",
+				Path:        "/foo/bar",
+				RawQuery:    "baz=quux",
+				HasQuery:    true,
+				Fragment:    "frag",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "http://_jabber._tcp.google.com:80/test",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "_jabber._tcp.google.com",
+				Port:      "80",
+				Path:      "/test",
+			},
+		},
+		{
+			in: "http://a\r\" \t\n<\"b:b@c\r\nd/e?f",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "a\r\" \t\n<\"b:b",
+				Host:      "c",
+				Path:      "\r\nd/e",
+				RawQuery:  "f",
+				HasQuery:  true,
+			},
+		},
+		{
+			in: "file://localhost/etc/passwd",
+			want: URL{
+				Scheme:    "file",
+				RawScheme: "file",
+				Slashes:   true,
+				Host:      "localhost",
+				Path:      "/etc/passwd",
+			},
+		},
+		{
+			in: "http://www.Äffchen.cOm;A/b/c?d=e#f g<h>i",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Host:        "www.Äffchen.cOm",
+				Path:        ";A/b/c",
+				RawQuery:    "d=e",
+				HasQuery:    true,
+				Fragment:    "f g<h>i",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "http://ليهمابتكلموشعربي؟.ي؟/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "ليهمابتكلموشعربي؟.ي؟",
+				Path:      "/",
+			},
+		},
+		{
+			in: "HtTp://x.y.cOm;a/b/c?d=e#f g<h>i",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "HtTp",
+				Slashes:     true,
+				Host:        "x.y.cOm",
+				Path:        ";a/b/c",
+				RawQuery:    "d=e",
+				HasQuery:    true,
+				Fragment:    "f g<h>i",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "http://x...y...#p",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Host:        "x...y...",
+				Fragment:    "p",
+				HasFragment: true,
+			},
+		},
+		{
+			in: "http://mt0.google.com/vt/lyrs=m@114&hl=en&src=api&x=2&y=2&z=3&s=",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "mt0.google.com",
+				Path:      "/vt/lyrs=m@114&hl=en&src=api&x=2&y=2&z=3&s=",
+			},
+		},
+		{
+			in: "http://mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "mt0.google.com",
+				Path:      "/vt/lyrs=m@114",
+				RawQuery:  "??&hl=en&src=api&x=2&y=2&z=3&s=",
+				HasQuery:  true,
+			},
+		},
+		{
+			in: "file:///etc/passwd",
+			want: URL{
+				Scheme:    "file",
+				RawScheme: "file",
+				Slashes:   true,
+				Path:      "/etc/passwd",
+			},
+		},
+		{
+			in: "http://[fe80::1]:/a/b?a=b#abc",
+			want: URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Host:        "fe80::1",
+				Path:        ":/a/b",
+				RawQuery:    "a=b",
+				HasQuery:    true,
+				Fragment:    "abc",
+				HasFragment: true,
+				IPv6:        true,
+			},
+		},
+		{
+			in: "HTTP://X.COM/Y",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "HTTP",
+				Slashes:   true,
+				Host:      "X.COM",
+				Path:      "/Y",
+			},
+		},
+		{
+			in: "http://www.日本語.com/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "www.日本語.com",
+				Path:      "/",
+			},
+		},
+		{
+			in: "http://www.Äffchen.com/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Host:      "www.Äffchen.com",
+				Path:      "/",
+			},
+		},
+		{
+			in: "coap://u:p@[::192.9.5.5]:61616/.well-known/r?n=Temperature",
+			want: URL{
+				Scheme:    "coap",
+				RawScheme: "coap",
+				Slashes:   true,
+				Auth:      "u:p",
+				Host:      "::192.9.5.5",
+				Port:      "61616",
+				Path:      "/.well-known/r",
+				RawQuery:  "n=Temperature",
+				HasQuery:  true,
+				IPv6:      true,
+			},
+		},
+		{
+			in: "http://atslash%2F%40:%2F%40@foo/",
+			want: URL{
+				Scheme:    "http",
+				RawScheme: "http",
+				Slashes:   true,
+				Auth:      "atslash%2F%40:%2F%40",
+				Host:      "foo",
+				Path:      "/",
+			},
+		},
+		{
+			in:  ":ptth",
+			err: ErrMissingScheme,
+		},
+	}
+	for _, tc := range testCases {
+		got, err := Parse(tc.in)
+		if err != nil {
+			if err != tc.err {
+				t.Errorf("Parse(%q): want error %v, got %v", tc.in, tc.err, err)
+			}
+		} else {
+			if *got != tc.want {
+				t.Errorf("Parse(%q):\n got %#v\nwant %#v", tc.in, *got, tc.want)
+			}
+		}
+	}
+}
+
+func TestEncode(t *testing.T) {
+	type testCase struct {
+		in   string
+		want string
+	}
+	testCases := []testCase{
+		{"", ""},
+		{";/?:@&=+$,-_.!~*'()#012azAZ", ";/?:@&=+$,-_.!~*'()#012azAZ"},
+		{" `%^{}\"<>\\", "%20%60%25%5E%7B%7D%22%3C%3E%5C"},
+		{"%7e%25%7E", "%7E%25%7E"},
+		{"%1g%z2%", "%251g%25z2%25"},
+		{"процесс", "%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81"},
+	}
+	for _, tc := range testCases {
+		got := Encode(tc.in)
+		if got != tc.want {
+			t.Errorf("Encode(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestDecode(t *testing.T) {
+	type testCase struct {
+		in   string
+		want string
+	}
+	testCases := []testCase{
+		{"", ""},
+		{"a%2520b", "a%20b"},
+		{"%7e", "~"},
+		{"%1g%z2%", "%1g%z2%"},
+		{"%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81", "процесс"},
+		{"%D0", "\xEF\xBF\xBD"},
+		{"%D0%25", "\xEF\xBF\xBD%"},
+		{"%D0%", "\xEF\xBF\xBD%"},
+		{"%D0%1g", "\xEF\xBF\xBD%1g"},
+		{"%D0%1g", "\xEF\xBF\xBD%1g"},
+		{"%D0\xBF", "п"},
+		{"%D0%BF", "п"},
+		{"%D0\x25", "\xEF\xBF\xBD%"},
+		{"%80%81%82%83%84%85%86%87%88%89%8A%8B%8C%8D%8E%8F%90%91%92%93%94%95%96%97%98%99%9A%9B%9C%9D%9E%9F%A0%A1%A2%A3%A4%A5%A6%A7%A8%A9%AA%AB%AC%AD%AE%AF%B0%B1%B2%B3%B4%B5%B6%B7%B8%B9%BA%BB%BC%BD%BE%BF%F8%F9%FA%FB%FC%FD%FE", strings.Repeat("\xEF\xBF\xBD", 71)},
+		{"%e3%81%84%e3%81%be%e3%81%aa%e3%81%ab%e3%81%97%e3%81%a6%e3%82%8b", "いまなにしてる"},
+		{"%f0%90%80%80", "\U00010000"},
+	}
+	for _, tc := range testCases {
+		got := Decode(tc.in)
+		if got != tc.want {
+			t.Errorf("Decode(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestString(t *testing.T) {
+	type testCase struct {
+		in   URL
+		want string
+	}
+	testCases := []testCase{
+		{URL{}, ""},
+		{
+			URL{
+				Scheme:      "http",
+				RawScheme:   "http",
+				Slashes:     true,
+				Auth:        "admin:password",
+				Host:        "example.com",
+				Port:        "80",
+				Path:        "/path",
+				RawQuery:    "query",
+				HasQuery:    true,
+				Fragment:    "frag",
+				HasFragment: true,
+				IPv6:        false,
+			},
+			"http://admin:password@example.com:80/path?query#frag",
+		},
+		{
+			URL{
+				Host: "::1",
+				IPv6: true,
+			},
+			"[::1]",
+		},
+	}
+	for _, tc := range testCases {
+		got := tc.in.String()
+		if got != tc.want {
+			t.Errorf("String(%#v):\n got %q\nwant %q", tc.in, got, tc.want)
+		}
+	}
+}
diff --git a/vendor/gitlab.com/golang-commonmark/mdurl/util.go b/vendor/gitlab.com/golang-commonmark/mdurl/util.go
new file mode 100644
index 000000000..0fd3ff331
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/mdurl/util.go
@@ -0,0 +1,36 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mdurl
+
+func hexDigit(b byte) bool {
+	return digit(b) || b >= 'a' && b <= 'f' || b >= 'A' && b <= 'F'
+}
+
+func unhex(b byte) byte {
+	switch {
+	case digit(b):
+		return b - '0'
+	case b >= 'a' && b <= 'f':
+		return b - 'a' + 10
+	case b >= 'A' && b <= 'F':
+		return b - 'A' + 10
+	}
+	panic("unhex: not a hex digit")
+}
+
+func letter(b byte) bool {
+	return b >= 'a' && b <= 'z' || b >= 'A' && b <= 'Z'
+}
+
+func digit(b byte) bool {
+	return b >= '0' && b <= '9'
+}
+
+func byteToUpper(b byte) byte {
+	if b >= 'a' && b <= 'z' {
+		return b - 'a' + 'A'
+	}
+	return b
+}
diff --git a/vendor/gitlab.com/golang-commonmark/puny/.gitlab-ci.yml b/vendor/gitlab.com/golang-commonmark/puny/.gitlab-ci.yml
new file mode 100644
index 000000000..aaf2cbddf
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/puny/.gitlab-ci.yml
@@ -0,0 +1,16 @@
+image: golang:1.11
+
+stages:
+  - build
+  - test
+
+build:
+  stage: build
+  script:
+    - go build ./...
+
+test:
+  stage: test
+  script:
+    - test -z "$(gofmt -l . | tee /dev/stderr)"
+    - go test ./...
diff --git a/vendor/gitlab.com/golang-commonmark/puny/LICENSE b/vendor/gitlab.com/golang-commonmark/puny/LICENSE
new file mode 100644
index 000000000..9cdcd2016
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/puny/LICENSE
@@ -0,0 +1,10 @@
+Copyright (c) 2015, The Authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE 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 HOLDER 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.
diff --git a/vendor/gitlab.com/golang-commonmark/puny/README.md b/vendor/gitlab.com/golang-commonmark/puny/README.md
new file mode 100644
index 000000000..1496b554f
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/puny/README.md
@@ -0,0 +1,8 @@
+puny [![License](https://img.shields.io/badge/licence-BSD--2--Clause-blue.svg)](https://opensource.org/licenses/BSD-2-Clause) [![GoDoc](http://godoc.org/gitlab.com/golang-commonmark/puny?status.svg)](http://godoc.org/gitlab.com/golang-commonmark/puny) [![Pipeline status](https://gitlab.com/golang-commonmark/puny/badges/master/pipeline.svg)](https://gitlab.com/golang-commonmark/puny/commits/master)
+====
+
+Package puny provides functions for encoding/decoding to/from punycode.
+
+## Install
+
+    go get -u gitlab.com/golang-commonmark/puny
diff --git a/vendor/gitlab.com/golang-commonmark/puny/puny.go b/vendor/gitlab.com/golang-commonmark/puny/puny.go
new file mode 100644
index 000000000..8f71402c1
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/puny/puny.go
@@ -0,0 +1,287 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package puny provides functions for encoding/decoding to/from punycode.
+package puny
+
+import (
+	"errors"
+	"strings"
+	"unicode/utf8"
+)
+
+const (
+	maxInt32      int32 = 2147483647
+	base          int32 = 36
+	tMin          int32 = 1
+	baseMinusTMin       = base - tMin
+	tMax          int32 = 26
+	skew          int32 = 38
+	damp          int32 = 700
+	initialBias   int32 = 72
+	initialN      int32 = 128
+)
+
+var (
+	ErrOverflow     = errors.New("overflow: input needs wider integers to process")
+	ErrNotBasic     = errors.New("illegal input >= 0x80 (not a basic code point)")
+	ErrInvalidInput = errors.New("invalid input")
+)
+
+func adapt(delta, numPoints int32, firstTime bool) int32 {
+	if firstTime {
+		delta /= damp
+	} else {
+		delta /= 2
+	}
+	delta += delta / numPoints
+	k := int32(0)
+	for delta > baseMinusTMin*tMax/2 {
+		delta = delta / baseMinusTMin
+		k += base
+	}
+	return k + (baseMinusTMin+1)*delta/(delta+skew)
+}
+
+func basicToDigit(b byte) int32 {
+	switch {
+	case b >= '0' && b <= '9':
+		return int32(b - 22)
+	case b >= 'A' && b <= 'Z':
+		return int32(b - 'A')
+	case b >= 'a' && b <= 'z':
+		return int32(b - 'a')
+	}
+	return base
+}
+
+func digitToBasic(digit int32) byte {
+	switch {
+	case digit >= 0 && digit <= 25:
+		return byte(digit) + 'a'
+	case digit >= 26 && digit <= 35:
+		return byte(digit) - 26 + '0'
+	}
+	panic("unreachable")
+}
+
+func lastIndex(s string, c byte) int {
+	for i := len(s) - 1; i >= 0; i-- {
+		if s[i] == c {
+			return i
+		}
+	}
+	return -1
+}
+
+func ascii(s string) bool {
+	for _, r := range s {
+		if r > 0x7e {
+			return false
+		}
+	}
+	return true
+}
+
+// Decode converts a Punycode string of ASCII-only symbols to a string of Unicode symbols.
+func Decode(s string) (string, error) {
+	basic := lastIndex(s, '-')
+	output := make([]rune, 0, len(s))
+	for i := 0; i < basic; i++ {
+		b := s[i]
+		if b >= 0x80 {
+			return "", ErrNotBasic
+		}
+		output = append(output, rune(b))
+	}
+
+	i, n, bias, pos := int32(0), initialN, initialBias, basic+1
+
+	for pos < len(s) {
+		oldi, w, k := i, int32(1), base
+		for {
+			digit := basicToDigit(s[pos])
+			pos++
+
+			if digit >= base || digit > (maxInt32-i)/w {
+				return "", ErrOverflow
+			}
+
+			i += digit * w
+
+			t := k - bias
+			if t < tMin {
+				t = tMin
+			} else if t > tMax {
+				t = tMax
+			}
+
+			if digit < t {
+				break
+			}
+
+			if pos == len(s) {
+				return "", ErrInvalidInput
+			}
+
+			baseMinusT := base - t
+			if w > maxInt32/baseMinusT {
+				return "", ErrOverflow
+			}
+
+			w *= baseMinusT
+			k += base
+		}
+
+		out := int32(len(output) + 1)
+		bias = adapt(i-oldi, out, oldi == 0)
+
+		if i/out > maxInt32-n {
+			return "", ErrOverflow
+		}
+
+		n += i / out
+		i %= out
+
+		output = append(output, 0)
+		copy(output[i+1:], output[i:])
+		output[i] = rune(n)
+
+		i++
+	}
+
+	return string(output), nil
+}
+
+// Encode converts a string of Unicode symbols (e.g. a domain name label) to a
+// Punycode string of ASCII-only symbols.
+func Encode(input string) (string, error) {
+	n := initialN
+	delta := int32(0)
+	bias := initialBias
+
+	var output []byte
+	runes := 0
+	for _, r := range input {
+		if r >= 0x80 {
+			runes++
+			continue
+		}
+		output = append(output, byte(r))
+	}
+
+	basicLength := len(output)
+	handledCPCount := basicLength
+
+	if basicLength > 0 {
+		output = append(output, '-')
+	}
+
+	for runes > 0 {
+		m := maxInt32
+		for _, r := range input {
+			if r >= n && r < m {
+				m = r
+			}
+		}
+
+		handledCPCountPlusOne := int32(handledCPCount + 1)
+		if m-n > (maxInt32-delta)/handledCPCountPlusOne {
+			return "", ErrOverflow
+		}
+
+		delta += (m - n) * handledCPCountPlusOne
+		n = m
+
+		for _, r := range input {
+			if r < n {
+				delta++
+				if delta < 0 {
+					return "", ErrOverflow
+				}
+				continue
+			}
+			if r > n {
+				continue
+			}
+			q := delta
+			for k := base; ; k += base {
+				t := k - bias
+				if t < tMin {
+					t = tMin
+				} else if t > tMax {
+					t = tMax
+				}
+				if q < t {
+					break
+				}
+				qMinusT := q - t
+				baseMinusT := base - t
+				output = append(output, digitToBasic(t+qMinusT%baseMinusT))
+				q = qMinusT / baseMinusT
+			}
+
+			output = append(output, digitToBasic(q))
+			bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength)
+			delta = 0
+			handledCPCount++
+			runes--
+		}
+		delta++
+		n++
+	}
+	return string(output), nil
+}
+
+func sep(r rune) bool { return r == '.' || r == '。' || r == '．' || r == '｡' }
+
+func mapLabels(s string, fn func(string) string) string {
+	var result string
+	i := strings.IndexByte(s, '@')
+	if i != -1 {
+		result = s[:i+1]
+		s = s[i+1:]
+	}
+	var labels []string
+	start := 0
+	for i, r := range s {
+		if !sep(r) {
+			continue
+		}
+		labels = append(labels, fn(s[start:i]))
+		start = i + utf8.RuneLen(r)
+	}
+	labels = append(labels, fn(s[start:]))
+	return result + strings.Join(labels, ".")
+}
+
+// ToUnicode converts a Punycode string representing a domain name or an email address
+// to Unicode. Only the Punycoded parts of the input will be converted.
+func ToUnicode(s string) string {
+	return mapLabels(s, func(s string) string {
+		if !strings.HasPrefix(s, "xn--") {
+			return s
+		}
+		d, err := Decode(strings.ToLower(s[4:]))
+		if err != nil {
+			return s
+		}
+		return d
+	})
+}
+
+// ToASCII converts a Unicode string representing a domain name or an email address to
+// Punycode. Only the non-ASCII parts of the domain name will be converted.
+func ToASCII(s string) string {
+	return mapLabels(s, func(s string) string {
+		if ascii(s) {
+			return s
+		}
+		d, err := Encode(s)
+		if err != nil {
+			return s
+		}
+		return "xn--" + d
+	})
+}
diff --git a/vendor/gitlab.com/golang-commonmark/puny/puny_test.go b/vendor/gitlab.com/golang-commonmark/puny/puny_test.go
new file mode 100644
index 000000000..5eb318bd9
--- /dev/null
+++ b/vendor/gitlab.com/golang-commonmark/puny/puny_test.go
@@ -0,0 +1,237 @@
+// Copyright 2015 The Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found encoded the LICENSE file.
+
+package puny
+
+import "testing"
+
+type testCase struct {
+	desc    string
+	encoded string
+	decoded string
+}
+
+var testStrings = []testCase{
+	{encoded: "maana-pta", decoded: "mañana"},
+	{
+		encoded: "", decoded: "",
+	},
+	{
+		desc:    "a single basic code point",
+		encoded: "Bach-",
+		decoded: "Bach",
+	},
+	{
+		desc:    "a single non-ASCII character",
+		encoded: "tda",
+		decoded: "ü",
+	},
+	{
+		desc:    "multiple non-ASCII characters",
+		encoded: "4can8av2009b",
+		decoded: "üëäö♥",
+	},
+	{
+		desc:    "mix of ASCII and non-ASCII characters",
+		encoded: "bcher-kva",
+		decoded: "bücher",
+	},
+	{
+		desc:    "long string with both ASCII and non-ASCII characters",
+		encoded: "Willst du die Blthe des frhen, die Frchte des spteren Jahres-x9e96lkal",
+		decoded: "Willst du die Blüthe des frühen, die Früchte des späteren Jahres",
+	},
+	{
+		desc:    "Arabic (Egyptian)",
+		encoded: "egbpdaj6bu4bxfgehfvwxn",
+		decoded: "ليهمابتكلموشعربي؟",
+	},
+	{
+		desc:    "Chinese (simplified)",
+		encoded: "ihqwcrb4cv8a8dqg056pqjye",
+		decoded: "他们为什么不说中文",
+	},
+	{
+		desc:    "Chinese (traditional)",
+		encoded: "ihqwctvzc91f659drss3x8bo0yb",
+		decoded: "他們爲什麽不說中文",
+	},
+	{
+		desc:    "Czech",
+		encoded: "Proprostnemluvesky-uyb24dma41a",
+		decoded: "Pročprostěnemluvíčesky",
+	},
+	{
+		desc:    "Hebrew",
+		encoded: "4dbcagdahymbxekheh6e0a7fei0b",
+		decoded: "למההםפשוטלאמדבריםעברית",
+	},
+	{
+		desc:    "Hindi (Devanagari)",
+		encoded: "i1baa7eci9glrd9b2ae1bj0hfcgg6iyaf8o0a1dig0cd",
+		decoded: "यहलोगहिन्दीक्योंनहींबोलसकतेहैं",
+	},
+	{
+		desc:    "Japanese (kanji and hiragana)",
+		encoded: "n8jok5ay5dzabd5bym9f0cm5685rrjetr6pdxa",
+		decoded: "なぜみんな日本語を話してくれないのか",
+	},
+	{
+		desc:    "Korean (Hangul syllables)",
+		encoded: "989aomsvi5e83db1d2a355cv1e0vak1dwrv93d5xbh15a0dt30a5jpsd879ccm6fea98c",
+		decoded: "세계의모든사람들이한국어를이해한다면얼마나좋을까",
+	},
+	{
+		desc:    "Russian (Cyrillic)",
+		encoded: "b1abfaaepdrnnbgefbadotcwatmq2g4l",
+		decoded: "почемужеонинеговорятпорусски",
+	},
+	{
+		desc:    "Spanish",
+		encoded: "PorqunopuedensimplementehablarenEspaol-fmd56a",
+		decoded: "PorquénopuedensimplementehablarenEspañol",
+	},
+	{
+		desc:    "Vietnamese",
+		encoded: "TisaohkhngthchnitingVit-kjcr8268qyxafd2f1b9g",
+		decoded: "TạisaohọkhôngthểchỉnóitiếngViệt",
+	},
+	{
+		encoded: "3B-ww4c5e180e575a65lsy2b",
+		decoded: "3年B組金八先生",
+	},
+	{
+		encoded: "-with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n",
+		decoded: "安室奈美恵-with-SUPER-MONKEYS",
+	},
+	{
+		encoded: "Hello-Another-Way--fc4qua05auwb3674vfr0b",
+		decoded: "Hello-Another-Way-それぞれの場所",
+	},
+	{
+		encoded: "2-u9tlzr9756bt3uc0v",
+		decoded: "ひとつ屋根の下2",
+	},
+	{
+		encoded: "MajiKoi5-783gue6qz075azm5e",
+		decoded: "MajiでKoiする5秒前",
+	},
+	{
+		encoded: "de-jg4avhby1noc0d",
+		decoded: "パフィーdeルンバ",
+	},
+	{
+		encoded: "d9juau41awczczp",
+		decoded: "そのスピードで",
+	},
+	{
+		desc:    "ASCII string that breaks the existing rules for host-name labels",
+		encoded: "-> $1.00 <--",
+		decoded: "-> $1.00 <-",
+	},
+}
+var testDomains = []testCase{
+	{
+		decoded: "mañana.com",
+		encoded: "xn--maana-pta.com",
+	},
+	{ // https://github.com/bestiejs/punycode.js/issues/17
+		decoded: "example.com.",
+		encoded: "example.com.",
+	},
+	{
+		decoded: "bücher.com",
+		encoded: "xn--bcher-kva.com",
+	},
+	{
+		decoded: "café.com",
+		encoded: "xn--caf-dma.com",
+	},
+	{
+		decoded: "☃-⌘.com",
+		encoded: "xn----dqo34k.com",
+	},
+	{
+		decoded: "퐀☃-⌘.com",
+		encoded: "xn----dqo34kn65z.com",
+	},
+	{
+		desc:    "Emoji",
+		decoded: "💩.la",
+		encoded: "xn--ls8h.la",
+	},
+	{
+		desc:    "Non-printable ASCII",
+		decoded: "\x00\x01\x02foo.bar",
+		encoded: "\x00\x01\x02foo.bar",
+	},
+}
+
+var testSeparators = []testCase{
+	{
+		desc:    "Using U+002E as separator",
+		decoded: "mañana.com",
+		encoded: "xn--maana-pta.com",
+	},
+	{
+		desc:    "Using U+3002 as separator",
+		decoded: "mañana\u3002com",
+		encoded: "xn--maana-pta.com",
+	},
+	{
+		desc:    "Using U+FF0E as separator",
+		decoded: "mañana\uFF0Ecom",
+		encoded: "xn--maana-pta.com",
+	},
+	{
+		desc:    "Using U+FF61 as separator",
+		decoded: "mañana\uFF61com",
+		encoded: "xn--maana-pta.com",
+	},
+}
+
+func TestDecode(t *testing.T) {
+	for _, tc := range testStrings {
+		got, _ := Decode(tc.encoded)
+		if got != tc.decoded {
+			t.Errorf("Decode(%q) = %q, want %q", tc.encoded, got, tc.decoded)
+		}
+	}
+}
+
+func TestEncode(t *testing.T) {
+	for _, tc := range testStrings {
+		got, _ := Encode(tc.decoded)
+		if got != tc.encoded {
+			t.Errorf("Encode(%q) = %q, want %q", tc.decoded, got, tc.encoded)
+		}
+	}
+}
+
+func TestToUnicode(t *testing.T) {
+	for _, tc := range testDomains {
+		got := ToUnicode(tc.encoded)
+		if got != tc.decoded {
+			t.Errorf("ToUnicode(%q) = %q, want %q", tc.encoded, got, tc.decoded)
+		}
+	}
+}
+
+func TestToASCII(t *testing.T) {
+	for _, tc := range testDomains {
+		got := ToASCII(tc.decoded)
+		if got != tc.encoded {
+			t.Errorf("ToASCII(%q) = %q, want %q", tc.decoded, got, tc.encoded)
+		}
+	}
+}
+
+func TestSeparators(t *testing.T) {
+	for _, tc := range testSeparators {
+		got := ToASCII(tc.decoded)
+		if got != tc.encoded {
+			t.Errorf("ToASCII(%q) = %q, want %q", tc.decoded, got, tc.encoded)
+		}
+	}
+}

From bd2da76c565b05ab67bc2bc4f51eca83ab76ffbc Mon Sep 17 00:00:00 2001
From: Bobby Brennan <bobby.brennan@gmail.com>
Date: Wed, 8 May 2019 14:54:31 +0000
Subject: [PATCH 2/2] Add explanations for each error

first pass

add info links to dashboard
---
 main.go                                       |  20 +-
 pkg/dashboard/assets/css/check-details.css    |  12 +
 pkg/dashboard/assets/css/dashboard.css        | 227 +++++++++++++++++
 pkg/dashboard/assets/css/main.css             | 241 +-----------------
 pkg/dashboard/dashboard.go                    |  79 ++++--
 pkg/dashboard/helpers.go                      |   5 +
 pkg/dashboard/templates/check-details.gohtml  |  17 ++
 pkg/dashboard/templates/dashboard.gohtml      |  22 +-
 pkg/dashboard/templates/head.gohtml           |  14 +
 pkg/dashboard/templates/main.gohtml           |  19 +-
 .../{header.gohtml => navbar.gohtml}          |  12 +-
 11 files changed, 392 insertions(+), 276 deletions(-)
 create mode 100644 pkg/dashboard/assets/css/check-details.css
 create mode 100644 pkg/dashboard/assets/css/dashboard.css
 create mode 100644 pkg/dashboard/templates/check-details.gohtml
 create mode 100644 pkg/dashboard/templates/head.gohtml
 rename pkg/dashboard/templates/{header.gohtml => navbar.gohtml} (55%)

diff --git a/main.go b/main.go
index c773caddd..9573ad7e7 100644
--- a/main.go
+++ b/main.go
@@ -22,7 +22,9 @@ import (
 	"io/ioutil"
 	"net/http"
 	"os"
+	"strings"
 
+	"github.com/gorilla/mux"
 	conf "github.com/reactiveops/fairwinds/pkg/config"
 	"github.com/reactiveops/fairwinds/pkg/dashboard"
 	"github.com/reactiveops/fairwinds/pkg/kube"
@@ -84,18 +86,24 @@ func main() {
 }
 
 func startDashboardServer(c conf.Configuration, k *kube.ResourceProvider, port int) {
-	http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
+	router := mux.NewRouter()
+	router.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
 		w.Write([]byte("OK"))
 	})
-	http.HandleFunc("/results.json", func(w http.ResponseWriter, r *http.Request) {
+	router.HandleFunc("/results.json", func(w http.ResponseWriter, r *http.Request) {
 		dashboard.EndpointHandler(w, r, c, k)
 	})
-	http.HandleFunc("/favicon.ico", func(w http.ResponseWriter, r *http.Request) {
+	router.HandleFunc("/favicon.ico", func(w http.ResponseWriter, r *http.Request) {
 		http.ServeFile(w, r, "public/favicon.ico")
 	})
+	router.HandleFunc("/details/{category}", func(w http.ResponseWriter, r *http.Request) {
+		vars := mux.Vars(r)
+		category := vars["category"]
+		category = strings.Replace(category, ".md", "", -1)
+		dashboard.DetailsHandler(w, r, category)
+	})
 	fileServer := http.FileServer(dashboard.GetAssetBox())
-	http.Handle("/static/", http.StripPrefix("/static/", fileServer))
-	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+	router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		if r.URL.Path != "/" {
 			http.NotFound(w, r)
 			return
@@ -108,6 +116,8 @@ func startDashboardServer(c conf.Configuration, k *kube.ResourceProvider, port i
 		}
 		dashboard.MainHandler(w, r, auditData)
 	})
+	http.Handle("/static/", http.StripPrefix("/static/", fileServer))
+	http.Handle("/", router)
 
 	logrus.Infof("Starting Fairwinds dashboard server on port %d", port)
 	logrus.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port), nil))
diff --git a/pkg/dashboard/assets/css/check-details.css b/pkg/dashboard/assets/css/check-details.css
new file mode 100644
index 000000000..84f14afe8
--- /dev/null
+++ b/pkg/dashboard/assets/css/check-details.css
@@ -0,0 +1,12 @@
+th, td {
+  padding: 4px 8px;
+  vertical-align: top;
+}
+
+body {
+  font-family: "Helvetica", "Arial", sans-serif
+}
+
+h1, h2, h3, h4, h5, h6 {
+  font-family: "Muli", "Helvetica", "Arial", sans-serif
+}
diff --git a/pkg/dashboard/assets/css/dashboard.css b/pkg/dashboard/assets/css/dashboard.css
new file mode 100644
index 000000000..fee58230f
--- /dev/null
+++ b/pkg/dashboard/assets/css/dashboard.css
@@ -0,0 +1,227 @@
+.charts {
+  height: 405px;
+}
+
+.card.cluster {
+  margin-top: 15px;
+}
+
+.card.namespace {
+  padding: 10px 20px;
+}
+
+.card h3 {
+  margin: 0;
+  font-weight: 300;
+  font-size: 28px;
+  padding: 15px 20px 20px;
+}
+
+.namespace h3 strong {
+  margin: 0;
+  font-weight: bold;
+}
+
+.cluster-overview {
+  height: 204px;
+}
+
+.cluster-overview .cluster-score {
+  width: 200px;
+  display: inline-block;
+  margin-left: 20px;
+}
+
+.cluster-overview .cluster-score .weather {
+    font-size: 90px;
+    color: #444;
+    margin-bottom: 15px;
+}
+
+.cluster-overview .cluster-score .sailing-message {
+  font-size: 16px;
+  line-height: 28px;
+  margin-left: 7px;
+  font-weight: 300;
+  color: #555;
+}
+
+.cluster-overview .cluster-score .scores {
+  font-size: 16px;
+  margin-top: 10px;
+}
+
+.cluster .expandable-table ul.message-list {
+  margin: 10px 26px;
+}
+
+#clusterScoreChart {
+  width: 550px;
+  position: relative;
+  top: -227px;
+  left: 120px;
+}
+
+.cluster-overview .result-messages {
+  margin: 0 20px;
+  display: inline-block;
+  position: relative;
+  left: -100px;
+  top: -45px;
+}
+
+.cluster-overview .result-messages ul {
+  position: relative;
+  top: 0px;
+  left: 400px;
+  font-size: 20px;
+  line-height: 35px;
+}
+
+.card.cluster .expandable-table {
+  margin-top: 20px;
+}
+
+.card.cluster .detail-label {
+  display: inline-block;
+  min-width: 140px;
+  font-weight: bold;
+}
+
+.expandable-table {
+  width: 100%;
+  border-spacing: 0;
+  border-collapse: collapse;
+}
+
+.expandable-table tr {
+  height: 50px;
+}
+
+.expandable-table td {
+  padding: 15px 20px;
+  margin: 0;
+  font-size: 18px;
+  border-top: 1px solid #eee;
+}
+
+.expandable-table .resource-info .name {
+  cursor: pointer;
+}
+
+.expandable-table .resource-info .caret-expander {
+  display: inline-block;
+  width: 15px;
+  height: 15px;
+  margin-right: 10px;
+  background-image: url('../images/caret-right.svg');
+  background-size: 13px auto;
+  background-repeat: no-repeat;
+  background-position: 2px center;
+}
+
+.expandable-table .resource-info.expanded .caret-expander {
+  background-image: url('../images/caret-bottom.svg');
+  background-position: center 2px;
+}
+
+.expandable-table .resource-info .expandable-content {
+  display: none;
+}
+
+.expandable-table .resource-info.expanded .expandable-content {
+  display: block;
+}
+
+.namespace .resource-info .result-messages {
+  color: #6a6a6a;
+}
+
+.namespace .result-messages h4 {
+  font-weight: bold;
+  font-size: 15px;
+  margin: 15px 25px 6px;
+}
+
+ul.message-list {
+  list-style-type: none;
+  font-size: 13px;
+  line-height: 20px;
+  margin: 5px 35px;
+  padding: 0;
+  color: #6a6a6a;
+}
+
+ul.message-list li {
+  margin-bottom: 5px;
+}
+
+ul.message-list li i.message-icon {
+  display: inline-block;
+  margin-right: 7px;
+  text-align: center;
+  width: 20px;
+  font-size: 17px;
+  font-weight: bold;
+  position: relative;
+  bottom: -3px;
+}
+
+.result-messages .success i.message-icon {
+  color: #8BD2DC;
+}
+
+.result-messages .warning i.message-icon {
+  color: #f26c21;
+}
+
+.result-messages .error i.message-icon {
+  color: #a11f4c;
+}
+
+a.more-info {
+  color: #6a6a6a;
+  text-decoration: none;
+}
+
+.namespace .status-bar {
+  vertical-align: top;
+  padding-top: 18px;
+}
+.namespace .status-bar .status {
+  float: right;
+  animation: fadeIn 2s;
+}
+
+.cluster .status {
+  width: 280px;
+}
+.namespace .status {
+  width: 200px;
+}
+
+.status div {
+  height: 15px;
+  border-radius: 10px;
+}
+
+.status .passing {
+  background-color: #8BD2DC;
+  float: left;
+}
+
+.status .warning {
+  background-color: #f26c21;
+  float: left;
+}
+
+.status .failing {
+  background-color: #a11f4c;
+  width: 100%;
+}
+
+@keyframes fadeIn {
+  0% {opacity: 0;}
+  100% {opacity: 1;}
+}
+
diff --git a/pkg/dashboard/assets/css/main.css b/pkg/dashboard/assets/css/main.css
index 70fe0ecad..4ce90b859 100644
--- a/pkg/dashboard/assets/css/main.css
+++ b/pkg/dashboard/assets/css/main.css
@@ -2,50 +2,47 @@ body {
   margin: 0;
   font-family: 'Muli', 'Helvetica', 'Arial', sans-serif;
   background: #f5f5f5;
+  line-height: 1.3rem;
 }
 
-.header {
+.navbar {
   padding: 20px 20px 0;
 }
 
-.header .header-content {
+.navbar .navbar-content {
   margin: 0 auto;
   width: 900px;
 }
 
-.header .header-right {
+.navbar .navbar-right {
   padding: 15px;
   float: right;
 }
 
-.header .logo {
+.navbar .logo {
   width: 280px;
 }
 
-.header span.oss-text {
+.navbar span.oss-text {
   color: #23103A;
   display: block;
   font-size: 11px;
   margin: 3px 0;
 }
 
-.header a {
+.navbar a {
   text-decoration: none;
 }
 
-.header .ro-logo {
+.navbar .ro-logo {
   height: 40px;
 }
 
-.dashboard-content {
+.main-content {
   width: 960px;
   margin: 0 auto;
 }
 
-.charts {
-  height: 405px;
-}
-
 .card {
   margin: 25px 20px;
   padding: 20px;
@@ -55,225 +52,6 @@ body {
   border-radius: 5px;
 }
 
-.card.cluster {
-  margin-top: 15px;
-}
-
-
-.card.namespace {
-  padding: 10px 20px;
-}
-
-.card h3 {
-  margin: 0;
-  font-weight: 300;
-  font-size: 28px;
-  padding: 15px 20px 20px;
-}
-
-.namespace h3 strong {
-  margin: 0;
-  font-weight: bold;
-}
-
-.cluster-overview {
-  height: 204px;
-}
-
-.cluster-overview .cluster-score {
-  width: 200px;
-  display: inline-block;
-  margin-left: 20px;
-}
-
-.cluster-overview .cluster-score .weather {
-    font-size: 90px;
-    color: #444;
-    margin-bottom: 15px;
-}
-
-.cluster-overview .cluster-score .sailing-message {
-  font-size: 16px;
-  line-height: 28px;
-  margin-left: 7px;
-  font-weight: 300;
-  color: #555;
-}
-
-.cluster-overview .cluster-score .scores {
-  font-size: 16px;
-  margin-top: 10px;
-}
-
-.cluster .expandable-table ul.message-list {
-  margin: 10px 26px;
-}
-
-#clusterScoreChart {
-  width: 550px;
-  position: relative;
-  top: -242px;
-  left: 120px;
-}
-
-.cluster-overview .result-messages {
-  margin: 0 20px;
-  display: inline-block;
-  position: relative;
-  left: -100px;
-  top: -45px;
-}
-
-.cluster-overview .result-messages ul {
-  position: relative;
-  top: 0px;
-  left: 400px;
-  font-size: 20px;
-  line-height: 35px;
-}
-
-.card.cluster .expandable-table {
-  margin-top: 20px;
-}
-
-.card.cluster .detail-label {
-  display: inline-block;
-  min-width: 140px;
-  font-weight: bold;
-}
-
-.expandable-table {
-  width: 100%;
-  border-spacing: 0;
-  border-collapse: collapse;
-}
-
-.expandable-table tr {
-  height: 50px;
-}
-
-.expandable-table td {
-  padding: 15px 20px;
-  margin: 0;
-  font-size: 18px;
-  border-top: 1px solid #eee;
-}
-
-.expandable-table .resource-info .name {
-  cursor: pointer;
-}
-
-.expandable-table .resource-info .caret-expander {
-  display: inline-block;
-  width: 15px;
-  height: 15px;
-  margin-right: 10px;
-  background-image: url('../images/caret-right.svg');
-  background-size: 13px auto;
-  background-repeat: no-repeat;
-  background-position: 2px center;
-}
-
-.expandable-table .resource-info.expanded .caret-expander {
-  background-image: url('../images/caret-bottom.svg');
-  background-position: center 2px;
-}
-
-.expandable-table .resource-info .expandable-content {
-  display: none;
-}
-
-.expandable-table .resource-info.expanded .expandable-content {
-  display: block;
-}
-
-.namespace .resource-info .result-messages {
-  color: #6a6a6a;
-}
-
-.namespace .result-messages h4 {
-  font-weight: bold;
-  font-size: 15px;
-  margin: 15px 25px 6px;
-}
-
-ul.message-list {
-  list-style-type: none;
-  font-size: 13px;
-  line-height: 20px;
-  margin: 5px 35px;
-  padding: 0;
-  color: #6a6a6a;
-}
-
-ul.message-list li {
-  margin-bottom: 5px;
-}
-
-ul.message-list li i {
-  display: inline-block;
-  margin-right: 7px;
-  text-align: center;
-  width: 20px;
-  font-size: 17px;
-  font-weight: bold;
-  position: relative;
-  bottom: -3px;
-}
-
-.result-messages .success i {
-  color: #8BD2DC;
-}
-
-.result-messages .warning i {
-  color: #f26c21;
-}
-
-.result-messages .error i {
-  color: #a11f4c;
-}
-
-.namespace .status-bar {
-  vertical-align: top;
-  padding-top: 18px;
-}
-.namespace .status-bar .status {
-  float: right;
-  animation: fadeIn 2s;
-}
-
-.cluster .status {
-  width: 280px;
-}
-.namespace .status {
-  width: 200px;
-}
-
-.status div {
-  height: 15px;
-  border-radius: 10px;
-}
-
-.status .passing {
-  background-color: #8BD2DC;
-  float: left;
-}
-
-.status .warning {
-  background-color: #f26c21;
-  float: left;
-}
-
-.status .failing {
-  background-color: #a11f4c;
-  width: 100%;
-}
-
-@keyframes fadeIn {
-  0% {opacity: 0;}
-  100% {opacity: 1;}
-}
-
 .footer {
   text-align: center;
   padding-top: 10px;
@@ -288,3 +66,4 @@ ul.message-list li i {
 .footer a:hover {
   text-decoration: underline;
 }
+
diff --git a/pkg/dashboard/dashboard.go b/pkg/dashboard/dashboard.go
index 5be8d4b9c..0d46f4f1d 100644
--- a/pkg/dashboard/dashboard.go
+++ b/pkg/dashboard/dashboard.go
@@ -25,24 +25,30 @@ import (
 	"github.com/reactiveops/fairwinds/pkg/kube"
 	"github.com/reactiveops/fairwinds/pkg/validator"
 	"github.com/sirupsen/logrus"
+	"gitlab.com/golang-commonmark/markdown"
 )
 
 const (
 	// MainTemplateName is the main template
 	MainTemplateName = "main.gohtml"
-	// HeaderTemplateName contains the navbar
-	HeaderTemplateName = "header.gohtml"
+	// HeadTemplateName contains styles and meta info
+	HeadTemplateName = "head.gohtml"
+	// NavbarTemplateName contains the navbar
+	NavbarTemplateName = "navbar.gohtml"
 	// PreambleTemplateName contains an empty preamble that can be overridden
 	PreambleTemplateName = "preamble.gohtml"
 	// DashboardTemplateName contains the content of the dashboard
 	DashboardTemplateName = "dashboard.gohtml"
 	// FooterTemplateName contains the footer
 	FooterTemplateName = "footer.gohtml"
+	// CheckDetailsTemplateName is a page for rendering details about a given check
+	CheckDetailsTemplateName = "check-details.gohtml"
 )
 
 var (
 	templateBox = (*packr.Box)(nil)
 	assetBox    = (*packr.Box)(nil)
+	markdownBox = (*packr.Box)(nil)
 )
 
 // GetAssetBox returns a binary-friendly set of assets packaged from disk
@@ -61,6 +67,14 @@ func GetTemplateBox() *packr.Box {
 	return templateBox
 }
 
+// GetMarkdownBox returns a binary-friendly set of markdown files with error details
+func GetMarkdownBox() *packr.Box {
+	if markdownBox == (*packr.Box)(nil) {
+		markdownBox = packr.New("Markdown", "../../docs")
+	}
+	return markdownBox
+}
+
 // TemplateData is passed to the dashboard HTML template
 type TemplateData struct {
 	AuditData validator.AuditData
@@ -77,16 +91,22 @@ func GetBaseTemplate(name string) (*template.Template, error) {
 		"getGrade":        getGrade,
 		"getScore":        getScore,
 		"getIcon":         getIcon,
+		"getCategoryLink": getCategoryLink,
 	})
 
-	templateBox := GetTemplateBox()
 	templateFileNames := []string{
 		DashboardTemplateName,
-		HeaderTemplateName,
+		HeadTemplateName,
+		NavbarTemplateName,
 		PreambleTemplateName,
 		FooterTemplateName,
 		MainTemplateName,
 	}
+	return parseTemplateFiles(tmpl, templateFileNames)
+}
+
+func parseTemplateFiles(tmpl *template.Template, templateFileNames []string) (*template.Template, error) {
+	templateBox := GetTemplateBox()
 	for _, fname := range templateFileNames {
 		templateFile, err := templateBox.Find(fname)
 		if err != nil {
@@ -101,6 +121,16 @@ func GetBaseTemplate(name string) (*template.Template, error) {
 	return tmpl, nil
 }
 
+func writeTemplate(tmpl *template.Template, data *TemplateData, w http.ResponseWriter) {
+	buf := &bytes.Buffer{}
+	err := tmpl.Execute(buf, data)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	buf.WriteTo(w)
+}
+
 // MainHandler gets template data and renders the dashboard with it.
 func MainHandler(w http.ResponseWriter, r *http.Request, auditData validator.AuditData) {
 	jsonData, err := json.Marshal(auditData)
@@ -120,23 +150,14 @@ func MainHandler(w http.ResponseWriter, r *http.Request, auditData validator.Aud
 		http.Error(w, "Error getting template data", 500)
 		return
 	}
-
-	buf := &bytes.Buffer{}
-	err = tmpl.ExecuteTemplate(buf, "main", templateData)
-
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	buf.WriteTo(w)
+	writeTemplate(tmpl, &templateData, w)
 }
 
 // EndpointHandler gets template data and renders json with it.
 func EndpointHandler(w http.ResponseWriter, r *http.Request, c conf.Configuration, kubeResources *kube.ResourceProvider) {
 	templateData, err := validator.RunAudit(c, kubeResources)
 	if err != nil {
-		http.Error(w, "Error Fetching Deployments", 500)
+		http.Error(w, "Error Fetching Deployments", http.StatusInternalServerError)
 		return
 	}
 
@@ -144,3 +165,31 @@ func EndpointHandler(w http.ResponseWriter, r *http.Request, c conf.Configuratio
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(templateData)
 }
+
+// DetailsHandler returns details for a given error type
+func DetailsHandler(w http.ResponseWriter, r *http.Request, category string) {
+	box := GetMarkdownBox()
+	contents, err := box.Find(category + ".md")
+	if err != nil {
+		http.Error(w, "Error details not found for category "+category, http.StatusNotFound)
+		return
+	}
+	md := markdown.New(markdown.XHTMLOutput(true))
+	detailsHTML := "{{ define \"details\" }}" + md.RenderToString(contents) + "{{ end }}"
+
+	templateFileNames := []string{
+		HeadTemplateName,
+		NavbarTemplateName,
+		CheckDetailsTemplateName,
+		FooterTemplateName,
+	}
+	tmpl := template.New("check-details")
+	tmpl, err = parseTemplateFiles(tmpl, templateFileNames)
+	if err != nil {
+		logrus.Printf("Error getting template data %v", err)
+		http.Error(w, "Error getting template data", 500)
+		return
+	}
+	tmpl.Parse(detailsHTML)
+	writeTemplate(tmpl, nil, w)
+}
diff --git a/pkg/dashboard/helpers.go b/pkg/dashboard/helpers.go
index fa37adbda..065bd8b6b 100644
--- a/pkg/dashboard/helpers.go
+++ b/pkg/dashboard/helpers.go
@@ -16,6 +16,7 @@ package dashboard
 
 import (
 	"github.com/reactiveops/fairwinds/pkg/validator"
+	"strings"
 )
 
 func getWarningWidth(counts validator.CountSummary, fullWidth int) uint {
@@ -26,6 +27,10 @@ func getSuccessWidth(counts validator.CountSummary, fullWidth int) uint {
 	return uint(float64(counts.Successes) / float64(counts.Successes+counts.Warnings+counts.Errors) * float64(fullWidth))
 }
 
+func getCategoryLink(category string) string {
+	return strings.Replace(strings.ToLower(category), " ", "-", -1)
+}
+
 func getGrade(rs validator.ResultSummary) string {
 	score := getScore(rs)
 	if score >= 97 {
diff --git a/pkg/dashboard/templates/check-details.gohtml b/pkg/dashboard/templates/check-details.gohtml
new file mode 100644
index 000000000..15352169f
--- /dev/null
+++ b/pkg/dashboard/templates/check-details.gohtml
@@ -0,0 +1,17 @@
+<!doctype html>
+<html>
+
+<head>
+  {{ template "head" . }}
+  <link rel="stylesheet" href="/static/css/check-details.css">
+</head>
+
+<body>
+  {{ template "navbar" . }}
+  <div class="main-content">
+    <div class="card">
+      {{ template "details" . }}
+    </div>
+  </div>
+</body>
+</html>
diff --git a/pkg/dashboard/templates/dashboard.gohtml b/pkg/dashboard/templates/dashboard.gohtml
index 42d831657..719633b6d 100644
--- a/pkg/dashboard/templates/dashboard.gohtml
+++ b/pkg/dashboard/templates/dashboard.gohtml
@@ -9,9 +9,9 @@
       </div>
       <div class="result-messages">
         <ul class="message-list">
-          <li class="success"><i class="fas fa-check"></i> {{ .AuditData.ClusterSummary.Results.Totals.Successes }} checks passed</li>
-          <li class="warning"><i class="fas fa-exclamation"></i> {{ .AuditData.ClusterSummary.Results.Totals.Warnings }} checks had warnings</li>
-          <li class="error"><i class="fas fa-times"></i> {{ .AuditData.ClusterSummary.Results.Totals.Errors }} checks had errors</li>
+          <li class="success"><i class="message-icon fas fa-check"></i> {{ .AuditData.ClusterSummary.Results.Totals.Successes }} checks passed</li>
+          <li class="warning"><i class="message-icon fas fa-exclamation"></i> {{ .AuditData.ClusterSummary.Results.Totals.Warnings }} checks had warnings</li>
+          <li class="error"><i class="message-icon fas fa-times"></i> {{ .AuditData.ClusterSummary.Results.Totals.Errors }} checks had errors</li>
         </ul>
       </div>
       <canvas id="clusterScoreChart"></canvas>
@@ -82,7 +82,13 @@
                     <h4>Pod Spec:</h4>
                     <ul class="message-list">
                       {{ range $message := .PodResult.Messages}}
-                        <li class="{{ .Type }}"><i class="{{ getIcon $message }}"></i> {{ .Message }}</li>
+                        <li class="{{ .Type }}">
+                          <i class="message-icon {{ getIcon $message }}"></i>
+                          <a class="more-info" href="/details/{{ getCategoryLink .Category }}">
+                            <i class="far fa-question-circle"></i>
+                          </a>
+                          <span class="message">{{ .Message }}</span>
+                        </li>
                       {{ end }}
                     </ul>
                   </div>
@@ -91,7 +97,13 @@
                       <h4>Container: {{ .Name }}</h4>
                       <ul class="message-list">
                         {{ range $message := .Messages}}
-                          <li class="{{ .Type }}"><i class="{{ getIcon $message }}"></i> {{ .Message }}</li>
+                          <li class="{{ .Type }}">
+                            <i class="message-icon {{ getIcon $message }}"></i>
+                            <a class="more-info" href="/details/{{ getCategoryLink .Category }}">
+                              <i class="far fa-question-circle"></i>
+                            </a>
+                            <span class="message">{{ .Message }}</span>
+                          </li>
                         {{ end }}
                       </ul>
                     </div>
diff --git a/pkg/dashboard/templates/head.gohtml b/pkg/dashboard/templates/head.gohtml
new file mode 100644
index 000000000..45b3b461f
--- /dev/null
+++ b/pkg/dashboard/templates/head.gohtml
@@ -0,0 +1,14 @@
+{{ define "head" }}
+  <meta charset="utf-8">
+  <meta http-equiv="x-ua-compatible" content="ie=edge">
+  <title>Fairwinds</title>
+  <meta name="description" content="">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+
+  <link rel="icon" type="image/png" href="/static/favicon-32x32.png" sizes="32x32" />
+  <link rel="icon" type="image/png" href="/static/favicon-16x16.png" sizes="16x16" />
+  <link href="https://fonts.googleapis.com/css?family=Muli:300,400,700" rel="stylesheet">
+  <link rel="stylesheet" href="/static/css/normalize.css">
+  <link rel="stylesheet" href="/static/css/main.css">
+  <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css" integrity="sha384-fnmOCqbTlWIlj8LyTjo7mOUStjsKC4pOpQbqyi7RrhN7udi9RwhKkMHpvLbHG9Sr" crossorigin="anonymous">
+{{ end }}
diff --git a/pkg/dashboard/templates/main.gohtml b/pkg/dashboard/templates/main.gohtml
index 086868b0b..6761744ff 100644
--- a/pkg/dashboard/templates/main.gohtml
+++ b/pkg/dashboard/templates/main.gohtml
@@ -2,19 +2,8 @@
 <html>
 
 <head>
-  <meta charset="utf-8">
-  <meta http-equiv="x-ua-compatible" content="ie=edge">
-  <title>Fairwinds</title>
-  <meta name="description" content="">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-
-  <link rel="icon" type="image/png" href="/static/favicon-32x32.png" sizes="32x32" />
-  <link rel="icon" type="image/png" href="/static/favicon-16x16.png" sizes="16x16" />
-  <link href="https://fonts.googleapis.com/css?family=Muli:300,400,700" rel="stylesheet">
-  <link rel="stylesheet" href="/static/css/normalize.css">
-  <link rel="stylesheet" href="/static/css/main.css">
-  <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css" integrity="sha384-fnmOCqbTlWIlj8LyTjo7mOUStjsKC4pOpQbqyi7RrhN7udi9RwhKkMHpvLbHG9Sr" crossorigin="anonymous">
-
+  {{ template "head" . }}
+  <link rel="stylesheet" href="/static/css/dashboard.css">
   <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.7.2/Chart.min.js"></script>
   <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/cash/3.0.0-beta.3/cash.min.js"></script>
   <script>
@@ -24,8 +13,8 @@
 </head>
 
 <body>
-  {{ template "header" . }}
-  <div class="dashboard-content">
+  {{ template "navbar" . }}
+  <div class="main-content">
     {{ template "preamble" . }}
     {{ template "dashboard" . }}
   </div>
diff --git a/pkg/dashboard/templates/header.gohtml b/pkg/dashboard/templates/navbar.gohtml
similarity index 55%
rename from pkg/dashboard/templates/header.gohtml
rename to pkg/dashboard/templates/navbar.gohtml
index 1144b12cb..a83d0430d 100644
--- a/pkg/dashboard/templates/header.gohtml
+++ b/pkg/dashboard/templates/navbar.gohtml
@@ -1,8 +1,10 @@
-{{define "header"}}
-  <div class="header">
-    <div class="header-content">
-      <img class="logo" src="/static/images/polaris-logo.png" alt="Polaris" />
-      <div class="header-right">
+{{define "navbar"}}
+  <div class="navbar">
+    <div class="navbar-content">
+      <a href="/">
+        <img class="logo" src="/static/images/polaris-logo.png" alt="Polaris" />
+      </a>
+      <div class="navbar-right">
         <a href="https://reactiveops.com?source=fairwinds" target="_blank">
           <span class="oss-text">Open Source Project By</span>
           <img class="ro-logo" src="/static/images/ro-logo.png" alt="ReactiveOps" />