From 4121ae50b5d79600d6a309f4730071d5aad712c6 Mon Sep 17 00:00:00 2001
From: Patrick Van Stee <patrick@vanstee.me>
Date: Wed, 15 Apr 2020 21:00:18 -0400
Subject: [PATCH] Modify parsing functions and config structs to accept hcl
 changes

Signed-off-by: Patrick Van Stee <patrick@vanstee.me>
---
 bake/bake.go                                  |  176 +-
 bake/bake_test.go                             |   12 +-
 bake/compose.go                               |   13 +-
 bake/compose_test.go                          |   50 +-
 bake/hcl.go                                   |    6 +-
 bake/hcl_test.go                              |   22 +-
 commands/bake.go                              |    2 +-
 .../apparentlymart/go-textseg/LICENSE         |   95 +
 .../go-textseg/textseg/all_tokens.go          |   30 +
 .../go-textseg/textseg/generate.go            |    7 +
 .../go-textseg/textseg/grapheme_clusters.go   | 5276 +++++++++++++++
 .../go-textseg/textseg/grapheme_clusters.rl   |  132 +
 .../textseg/grapheme_clusters_table.rl        | 1583 +++++
 .../go-textseg/textseg/tables.go              | 5700 +++++++++++++++++
 .../go-textseg/textseg/unicode2ragel.rb       |  335 +
 .../go-textseg/textseg/utf8_seqs.go           |   19 +
 vendor/github.com/google/go-cmp/LICENSE       |   27 +
 .../github.com/google/go-cmp/cmp/compare.go   |  616 ++
 .../google/go-cmp/cmp/export_panic.go         |   15 +
 .../google/go-cmp/cmp/export_unsafe.go        |   23 +
 .../go-cmp/cmp/internal/diff/debug_disable.go |   17 +
 .../go-cmp/cmp/internal/diff/debug_enable.go  |  122 +
 .../google/go-cmp/cmp/internal/diff/diff.go   |  372 ++
 .../google/go-cmp/cmp/internal/flags/flags.go |    9 +
 .../cmp/internal/flags/toolchain_legacy.go    |   10 +
 .../cmp/internal/flags/toolchain_recent.go    |   10 +
 .../go-cmp/cmp/internal/function/func.go      |   99 +
 .../cmp/internal/value/pointer_purego.go      |   23 +
 .../cmp/internal/value/pointer_unsafe.go      |   26 +
 .../google/go-cmp/cmp/internal/value/sort.go  |  106 +
 .../google/go-cmp/cmp/internal/value/zero.go  |   48 +
 .../github.com/google/go-cmp/cmp/options.go   |  524 ++
 vendor/github.com/google/go-cmp/cmp/path.go   |  308 +
 vendor/github.com/google/go-cmp/cmp/report.go |   51 +
 .../google/go-cmp/cmp/report_compare.go       |  296 +
 .../google/go-cmp/cmp/report_reflect.go       |  278 +
 .../google/go-cmp/cmp/report_slices.go        |  333 +
 .../google/go-cmp/cmp/report_text.go          |  387 ++
 .../google/go-cmp/cmp/report_value.go         |  121 +
 .../hcl/v2/ext/customdecode/README.md         |  209 +
 .../hcl/v2/ext/customdecode/customdecode.go   |   56 +
 .../v2/ext/customdecode/expression_type.go    |  146 +
 .../hashicorp/hcl/v2/gohcl/decode.go          |  322 +
 .../github.com/hashicorp/hcl/v2/gohcl/doc.go  |   57 +
 .../hashicorp/hcl/v2/gohcl/encode.go          |  191 +
 .../hashicorp/hcl/v2/gohcl/schema.go          |  174 +
 .../hashicorp/hcl/v2/gohcl/types.go           |   16 +
 .../hashicorp/hcl/v2/hclsimple/hclsimple.go   |  108 +
 .../hashicorp/hcl/v2/hclsyntax/diagnostics.go |   23 +
 .../hashicorp/hcl/v2/hclsyntax/didyoumean.go  |   24 +
 .../hashicorp/hcl/v2/hclsyntax/doc.go         |    7 +
 .../hashicorp/hcl/v2/hclsyntax/expression.go  | 1491 +++++
 .../hcl/v2/hclsyntax/expression_ops.go        |  268 +
 .../hcl/v2/hclsyntax/expression_template.go   |  220 +
 .../hcl/v2/hclsyntax/expression_vars.go       |   76 +
 .../hashicorp/hcl/v2/hclsyntax/file.go        |   20 +
 .../hashicorp/hcl/v2/hclsyntax/generate.go    |    9 +
 .../hashicorp/hcl/v2/hclsyntax/keywords.go    |   21 +
 .../hashicorp/hcl/v2/hclsyntax/navigation.go  |   59 +
 .../hashicorp/hcl/v2/hclsyntax/node.go        |   22 +
 .../hashicorp/hcl/v2/hclsyntax/parser.go      | 2055 ++++++
 .../hcl/v2/hclsyntax/parser_template.go       |  799 +++
 .../hcl/v2/hclsyntax/parser_traversal.go      |  159 +
 .../hashicorp/hcl/v2/hclsyntax/peeker.go      |  212 +
 .../hashicorp/hcl/v2/hclsyntax/public.go      |  171 +
 .../hcl/v2/hclsyntax/scan_string_lit.go       |  301 +
 .../hcl/v2/hclsyntax/scan_string_lit.rl       |  105 +
 .../hashicorp/hcl/v2/hclsyntax/scan_tokens.go | 5265 +++++++++++++++
 .../hashicorp/hcl/v2/hclsyntax/scan_tokens.rl |  395 ++
 .../hashicorp/hcl/v2/hclsyntax/spec.md        |  941 +++
 .../hashicorp/hcl/v2/hclsyntax/structure.go   |  394 ++
 .../hcl/v2/hclsyntax/structure_at_pos.go      |  118 +
 .../hashicorp/hcl/v2/hclsyntax/token.go       |  320 +
 .../hcl/v2/hclsyntax/token_type_string.go     |  131 +
 .../hcl/v2/hclsyntax/unicode2ragel.rb         |  335 +
 .../hcl/v2/hclsyntax/unicode_derived.rl       | 2135 ++++++
 .../hashicorp/hcl/v2/hclsyntax/variables.go   |   86 +
 .../hashicorp/hcl/v2/hclsyntax/walk.go        |   41 +
 .../hashicorp/hcl/v2/hclwrite/ast.go          |  121 +
 .../hcl/v2/hclwrite/ast_attribute.go          |   48 +
 .../hashicorp/hcl/v2/hclwrite/ast_block.go    |  118 +
 .../hashicorp/hcl/v2/hclwrite/ast_body.go     |  239 +
 .../hcl/v2/hclwrite/ast_expression.go         |  224 +
 .../hashicorp/hcl/v2/hclwrite/doc.go          |   11 +
 .../hashicorp/hcl/v2/hclwrite/format.go       |  463 ++
 .../hashicorp/hcl/v2/hclwrite/generate.go     |  252 +
 .../hcl/v2/hclwrite/native_node_sorter.go     |   23 +
 .../hashicorp/hcl/v2/hclwrite/node.go         |  260 +
 .../hashicorp/hcl/v2/hclwrite/parser.go       |  599 ++
 .../hashicorp/hcl/v2/hclwrite/public.go       |   44 +
 .../hashicorp/hcl/v2/hclwrite/tokens.go       |  122 +
 .../github.com/hashicorp/hcl/v2/json/ast.go   |  121 +
 .../hashicorp/hcl/v2/json/didyoumean.go       |   33 +
 .../github.com/hashicorp/hcl/v2/json/doc.go   |   12 +
 .../hashicorp/hcl/v2/json/navigation.go       |   70 +
 .../hashicorp/hcl/v2/json/parser.go           |  496 ++
 .../hashicorp/hcl/v2/json/peeker.go           |   25 +
 .../hashicorp/hcl/v2/json/public.go           |   94 +
 .../hashicorp/hcl/v2/json/scanner.go          |  306 +
 .../github.com/hashicorp/hcl/v2/json/spec.md  |  405 ++
 .../hashicorp/hcl/v2/json/structure.go        |  637 ++
 .../hashicorp/hcl/v2/json/tokentype_string.go |   29 +
 .../go-cty/cty/function/stdlib/bool.go        |   78 +
 .../go-cty/cty/function/stdlib/bytes.go       |  112 +
 .../go-cty/cty/function/stdlib/collection.go  |  140 +
 .../zclconf/go-cty/cty/function/stdlib/csv.go |   93 +
 .../go-cty/cty/function/stdlib/datetime.go    |  385 ++
 .../zclconf/go-cty/cty/function/stdlib/doc.go |   13 +
 .../go-cty/cty/function/stdlib/format.go      |  517 ++
 .../go-cty/cty/function/stdlib/format_fsm.go  |  374 ++
 .../go-cty/cty/function/stdlib/format_fsm.rl  |  198 +
 .../go-cty/cty/function/stdlib/general.go     |  107 +
 .../go-cty/cty/function/stdlib/json.go        |   72 +
 .../go-cty/cty/function/stdlib/number.go      |  438 ++
 .../go-cty/cty/function/stdlib/regexp.go      |  233 +
 .../go-cty/cty/function/stdlib/sequence.go    |  218 +
 .../zclconf/go-cty/cty/function/stdlib/set.go |  195 +
 .../go-cty/cty/function/stdlib/string.go      |  234 +
 .../zclconf/go-cty/cty/gocty/doc.go           |    7 +
 .../zclconf/go-cty/cty/gocty/helpers.go       |   43 +
 .../github.com/zclconf/go-cty/cty/gocty/in.go |  548 ++
 .../zclconf/go-cty/cty/gocty/out.go           |  686 ++
 .../zclconf/go-cty/cty/gocty/type_implied.go  |  108 +
 .../github.com/zclconf/go-cty/cty/json/doc.go |   11 +
 .../zclconf/go-cty/cty/json/marshal.go        |  193 +
 .../zclconf/go-cty/cty/json/simple.go         |   41 +
 .../zclconf/go-cty/cty/json/type.go           |   23 +
 .../zclconf/go-cty/cty/json/type_implied.go   |  170 +
 .../zclconf/go-cty/cty/json/unmarshal.go      |  459 ++
 .../zclconf/go-cty/cty/json/value.go          |   65 +
 vendor/modules.txt                            |   17 +
 131 files changed, 45183 insertions(+), 108 deletions(-)
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/LICENSE
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/all_tokens.go
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/generate.go
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.go
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.rl
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters_table.rl
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/tables.go
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/unicode2ragel.rb
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/utf8_seqs.go
 create mode 100644 vendor/github.com/google/go-cmp/LICENSE
 create mode 100644 vendor/github.com/google/go-cmp/cmp/compare.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/export_panic.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/export_unsafe.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/internal/diff/debug_disable.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/internal/diff/debug_enable.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/internal/diff/diff.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/internal/flags/flags.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/internal/flags/toolchain_legacy.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/internal/flags/toolchain_recent.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/internal/function/func.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/internal/value/pointer_purego.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/internal/value/pointer_unsafe.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/internal/value/sort.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/internal/value/zero.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/options.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/path.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/report.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/report_compare.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/report_reflect.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/report_slices.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/report_text.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/report_value.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/ext/customdecode/README.md
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/ext/customdecode/customdecode.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/ext/customdecode/expression_type.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/gohcl/decode.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/gohcl/doc.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/gohcl/encode.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/gohcl/schema.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/gohcl/types.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsimple/hclsimple.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/diagnostics.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/didyoumean.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/doc.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_ops.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_template.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_vars.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/file.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/generate.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/keywords.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/navigation.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/node.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_template.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_traversal.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/peeker.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/public.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.rl
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.rl
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/spec.md
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure_at_pos.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/token.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/token_type_string.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode2ragel.rb
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode_derived.rl
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/variables.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/walk.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/ast.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_attribute.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_block.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_body.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_expression.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/doc.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/format.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/generate.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/native_node_sorter.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/node.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/parser.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/public.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/tokens.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/ast.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/didyoumean.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/doc.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/navigation.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/parser.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/peeker.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/public.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/scanner.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/spec.md
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/structure.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/tokentype_string.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/gocty/doc.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/gocty/in.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/gocty/out.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/doc.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/marshal.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/simple.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/type.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/type_implied.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/value.go

diff --git a/bake/bake.go b/bake/bake.go
index c2a1554c..9263f5ba 100644
--- a/bake/bake.go
+++ b/bake/bake.go
@@ -15,7 +15,7 @@ import (
 	"github.com/pkg/errors"
 )
 
-func ReadTargets(ctx context.Context, files, targets, overrides []string) (map[string]Target, error) {
+func ReadTargets(ctx context.Context, files, targets, overrides []string) (map[string]*Target, error) {
 	var c Config
 	for _, f := range files {
 		cfg, err := ParseFile(f)
@@ -28,7 +28,7 @@ func ReadTargets(ctx context.Context, files, targets, overrides []string) (map[s
 	if err != nil {
 		return nil, err
 	}
-	m := map[string]Target{}
+	m := map[string]*Target{}
 	for _, n := range targets {
 		for _, n := range c.ResolveGroup(n) {
 			t, err := c.ResolveTarget(n, o)
@@ -36,7 +36,7 @@ func ReadTargets(ctx context.Context, files, targets, overrides []string) (map[s
 				return nil, err
 			}
 			if t != nil {
-				m[n] = *t
+				m[n] = t
 			}
 		}
 	}
@@ -55,12 +55,12 @@ func ParseFile(fn string) (*Config, error) {
 	}
 
 	if strings.HasSuffix(fnl, ".json") || strings.HasSuffix(fnl, ".hcl") {
-		return ParseHCL(dt)
+		return ParseHCL(dt, fn)
 	}
 
 	cfg, err := ParseCompose(dt)
 	if err != nil {
-		cfg, err2 := ParseHCL(dt)
+		cfg, err2 := ParseHCL(dt, fn)
 		if err2 != nil {
 			return nil, errors.Errorf("failed to parse %s: parsing yaml: %s, parsing hcl: %s", fn, err.Error(), err2.Error())
 		}
@@ -70,55 +70,76 @@ func ParseFile(fn string) (*Config, error) {
 }
 
 type Config struct {
-	Group  map[string]Group
-	Target map[string]Target
+	Groups  []*Group  `hcl:"group,block"`
+	Targets []*Target `hcl:"target,block"`
 }
 
 func mergeConfig(c1, c2 Config) Config {
-	for k, g := range c2.Group {
-		if c1.Group == nil {
-			c1.Group = map[string]Group{}
+	if c1.Groups == nil {
+		c1.Groups = []*Group{}
+	}
+
+	for _, g2 := range c2.Groups {
+		var g1 *Group
+		for _, g := range c1.Groups {
+			if g2.Name == g.Name {
+				g1 = g
+				break
+			}
 		}
-		if g1, exists := c1.Group[k]; exists {
-		nextTarget:
-			for _, t := range g.Targets {
-				for _, t2 := range g1.Targets {
-					if t == t2 {
-						continue nextTarget
-					}
+		if g1 == nil {
+			c1.Groups = append(c1.Groups, g2)
+			continue
+		}
+
+	nextTarget:
+		for _, t2 := range g2.Targets {
+			for _, t1 := range g1.Targets {
+				if t1 == t2 {
+					continue nextTarget
 				}
-				g1.Targets = append(g1.Targets, t)
 			}
-			c1.Group[k] = g1
-		} else {
-			c1.Group[k] = g
+			g1.Targets = append(g1.Targets, t2)
 		}
+		c1.Groups = append(c1.Groups, g1)
 	}
 
-	for k, t := range c2.Target {
-		if c1.Target == nil {
-			c1.Target = map[string]Target{}
+	if c1.Targets == nil {
+		c1.Targets = []*Target{}
+	}
+
+	for _, t2 := range c2.Targets {
+		var t1 *Target
+		for _, t := range c1.Targets {
+			if t2.Name == t.Name {
+				t1 = t
+				break
+			}
 		}
-		if base, ok := c1.Target[k]; ok {
-			t = merge(base, t)
+		if t1 != nil {
+			t2 = merge(t1, t2)
 		}
-		c1.Target[k] = t
+		c1.Targets = append(c1.Targets, t2)
 	}
+
 	return c1
 }
 
 func (c Config) expandTargets(pattern string) ([]string, error) {
-	if _, ok := c.Target[pattern]; ok {
-		return []string{pattern}, nil
+	for _, target := range c.Targets {
+		if target.Name == pattern {
+			return []string{pattern}, nil
+		}
 	}
+
 	var names []string
-	for name := range c.Target {
-		ok, err := path.Match(pattern, name)
+	for _, target := range c.Targets {
+		ok, err := path.Match(pattern, target.Name)
 		if err != nil {
 			return nil, errors.Wrapf(err, "could not match targets with '%s'", pattern)
 		}
 		if ok {
-			names = append(names, name)
+			names = append(names, target.Name)
 		}
 	}
 	if len(names) == 0 {
@@ -127,8 +148,8 @@ func (c Config) expandTargets(pattern string) ([]string, error) {
 	return names, nil
 }
 
-func (c Config) newOverrides(v []string) (map[string]Target, error) {
-	m := map[string]Target{}
+func (c Config) newOverrides(v []string) (map[string]*Target, error) {
+	m := map[string]*Target{}
 	for _, v := range v {
 
 		parts := strings.SplitN(v, "=", 2)
@@ -148,7 +169,10 @@ func (c Config) newOverrides(v []string) (map[string]Target, error) {
 		}
 
 		for _, name := range names {
-			t := m[name]
+			t, ok := m[name]
+			if !ok {
+				t = &Target{}
+			}
 
 			switch keys[1] {
 			case "context":
@@ -224,8 +248,14 @@ func (c Config) group(name string, visited map[string]struct{}) []string {
 	if _, ok := visited[name]; ok {
 		return nil
 	}
-	g, ok := c.Group[name]
-	if !ok {
+	var g *Group
+	for _, group := range c.Groups {
+		if group.Name == name {
+			g = group
+			break
+		}
+	}
+	if g == nil {
 		return []string{name}
 	}
 	visited[name] = struct{}{}
@@ -236,7 +266,7 @@ func (c Config) group(name string, visited map[string]struct{}) []string {
 	return targets
 }
 
-func (c Config) ResolveTarget(name string, overrides map[string]Target) (*Target, error) {
+func (c Config) ResolveTarget(name string, overrides map[string]*Target) (*Target, error) {
 	t, err := c.target(name, map[string]struct{}{}, overrides)
 	if err != nil {
 		return nil, err
@@ -252,54 +282,66 @@ func (c Config) ResolveTarget(name string, overrides map[string]Target) (*Target
 	return t, nil
 }
 
-func (c Config) target(name string, visited map[string]struct{}, overrides map[string]Target) (*Target, error) {
+func (c Config) target(name string, visited map[string]struct{}, overrides map[string]*Target) (*Target, error) {
 	if _, ok := visited[name]; ok {
 		return nil, nil
 	}
 	visited[name] = struct{}{}
-	t, ok := c.Target[name]
-	if !ok {
+	var t *Target
+	for _, target := range c.Targets {
+		if target.Name == name {
+			t = target
+			break
+		}
+	}
+	if t == nil {
 		return nil, errors.Errorf("failed to find target %s", name)
 	}
-	var tt Target
+	tt := &Target{}
 	for _, name := range t.Inherits {
 		t, err := c.target(name, visited, overrides)
 		if err != nil {
 			return nil, err
 		}
 		if t != nil {
-			tt = merge(tt, *t)
+			tt = merge(tt, t)
 		}
 	}
 	t.Inherits = nil
-	tt = merge(merge(merge(defaultTarget(), tt), t), overrides[name])
+	tt = merge(merge(defaultTarget(), tt), t)
+	if override, ok := overrides[name]; ok {
+		tt = merge(tt, override)
+	}
 	tt.normalize()
-	return &tt, nil
+	return tt, nil
 }
 
 type Group struct {
-	Targets []string
+	Name    string   `json:"-" hcl:"name,label"`
+	Targets []string `json:"targets" hcl:"targets"`
 	// Target // TODO?
 }
 
 type Target struct {
+	Name string `json:"-" hcl:"name,label"`
+
 	// Inherits is the only field that cannot be overridden with --set
-	Inherits []string `json:"inherits,omitempty" hcl:"inherits,omitempty"`
-
-	Context    *string           `json:"context,omitempty" hcl:"context,omitempty"`
-	Dockerfile *string           `json:"dockerfile,omitempty" hcl:"dockerfile,omitempty"`
-	Args       map[string]string `json:"args,omitempty" hcl:"args,omitempty"`
-	Labels     map[string]string `json:"labels,omitempty" hcl:"labels,omitempty"`
-	Tags       []string          `json:"tags,omitempty" hcl:"tags,omitempty"`
-	CacheFrom  []string          `json:"cache-from,omitempty"  hcl:"cache-from,omitempty"`
-	CacheTo    []string          `json:"cache-to,omitempty"  hcl:"cache-to,omitempty"`
-	Target     *string           `json:"target,omitempty" hcl:"target,omitempty"`
-	Secrets    []string          `json:"secret,omitempty" hcl:"secret,omitempty"`
-	SSH        []string          `json:"ssh,omitempty" hcl:"ssh,omitempty"`
-	Platforms  []string          `json:"platforms,omitempty" hcl:"platforms,omitempty"`
-	Outputs    []string          `json:"output,omitempty" hcl:"output,omitempty"`
-	Pull       bool              `json:"pull,omitempty": hcl:"pull,omitempty"`
-	NoCache    bool              `json:"no-cache,omitempty": hcl:"no-cache,omitempty"`
+	Inherits []string `json:"inherits,omitempty" hcl:"inherits,optional"`
+
+	Context    *string           `json:"context,omitempty" hcl:"context,optional"`
+	Dockerfile *string           `json:"dockerfile,omitempty" hcl:"dockerfile,optional"`
+	Args       map[string]string `json:"args,omitempty" hcl:"args,optional"`
+	Labels     map[string]string `json:"labels,omitempty" hcl:"labels,optional"`
+	Tags       []string          `json:"tags,omitempty" hcl:"tags,optional"`
+	CacheFrom  []string          `json:"cache-from,omitempty"  hcl:"cache-from,optional"`
+	CacheTo    []string          `json:"cache-to,omitempty"  hcl:"cache-to,optional"`
+	Target     *string           `json:"target,omitempty" hcl:"target,optional"`
+	Secrets    []string          `json:"secret,omitempty" hcl:"secret,optional"`
+	SSH        []string          `json:"ssh,omitempty" hcl:"ssh,optional"`
+	Platforms  []string          `json:"platforms,omitempty" hcl:"platforms,optional"`
+	Outputs    []string          `json:"output,omitempty" hcl:"output,optional"`
+	Pull       bool              `json:"pull,omitempty": hcl:"pull,optional"`
+	NoCache    bool              `json:"no-cache,omitempty": hcl:"no-cache,optional"`
 	// IMPORTANT: if you add more fields here, do not forget to update newOverrides and README.
 }
 
@@ -313,7 +355,7 @@ func (t *Target) normalize() {
 	t.Outputs = removeDupes(t.Outputs)
 }
 
-func TargetsToBuildOpt(m map[string]Target) (map[string]build.Options, error) {
+func TargetsToBuildOpt(m map[string]*Target) (map[string]build.Options, error) {
 	m2 := make(map[string]build.Options, len(m))
 	for k, v := range m {
 		bo, err := toBuildOpt(v)
@@ -325,7 +367,7 @@ func TargetsToBuildOpt(m map[string]Target) (map[string]build.Options, error) {
 	return m2, nil
 }
 
-func toBuildOpt(t Target) (*build.Options, error) {
+func toBuildOpt(t *Target) (*build.Options, error) {
 	if v := t.Context; v != nil && *v == "-" {
 		return nil, errors.Errorf("context from stdin not allowed in bake")
 	}
@@ -403,11 +445,11 @@ func toBuildOpt(t Target) (*build.Options, error) {
 	return bo, nil
 }
 
-func defaultTarget() Target {
-	return Target{}
+func defaultTarget() *Target {
+	return &Target{}
 }
 
-func merge(t1, t2 Target) Target {
+func merge(t1, t2 *Target) *Target {
 	if t2.Context != nil {
 		t1.Context = t2.Context
 	}
diff --git a/bake/bake_test.go b/bake/bake_test.go
index 6c741caa..7c296756 100644
--- a/bake/bake_test.go
+++ b/bake/bake_test.go
@@ -19,7 +19,7 @@ func TestReadTargets(t *testing.T) {
 	fp := filepath.Join(tmpdir, "config.hcl")
 	err = ioutil.WriteFile(fp, []byte(`
 target "webDEP" {
-	args {
+	args = {
 		VAR_INHERITED = "webDEP"
 		VAR_BOTH = "webDEP"
 	}
@@ -27,7 +27,7 @@ target "webDEP" {
 
 target "webapp" {
 	dockerfile = "Dockerfile.webapp"
-	args {
+	args = {
 		VAR_BOTH = "webapp"
 	}
 	inherits = ["webDEP"]
@@ -108,7 +108,7 @@ target "webapp" {
 
 	t.Run("PatternOverride", func(t *testing.T) {
 		// same check for two cases
-		multiTargetCheck := func(t *testing.T, m map[string]Target, err error) {
+		multiTargetCheck := func(t *testing.T, m map[string]*Target, err error) {
 			require.NoError(t, err)
 			require.Equal(t, 2, len(m))
 			require.Equal(t, "foo", *m["webapp"].Dockerfile)
@@ -121,7 +121,7 @@ target "webapp" {
 			name      string
 			targets   []string
 			overrides []string
-			check     func(*testing.T, map[string]Target, error)
+			check     func(*testing.T, map[string]*Target, error)
 		}{
 			{
 				name:      "multi target single pattern",
@@ -139,7 +139,7 @@ target "webapp" {
 				name:      "single target",
 				targets:   []string{"webapp"},
 				overrides: []string{"web*.dockerfile=foo"},
-				check: func(t *testing.T, m map[string]Target, err error) {
+				check: func(t *testing.T, m map[string]*Target, err error) {
 					require.NoError(t, err)
 					require.Equal(t, 1, len(m))
 					require.Equal(t, "foo", *m["webapp"].Dockerfile)
@@ -150,7 +150,7 @@ target "webapp" {
 				name:      "nomatch",
 				targets:   []string{"webapp"},
 				overrides: []string{"nomatch*.dockerfile=foo"},
-				check: func(t *testing.T, m map[string]Target, err error) {
+				check: func(t *testing.T, m map[string]*Target, err error) {
 					// NOTE: I am unsure whether failing to match should always error out
 					// instead of simply skipping that override.
 					// Let's enforce the error and we can relax it later if users complain.
diff --git a/bake/compose.go b/bake/compose.go
index 36a86812..d79cd6a6 100644
--- a/bake/compose.go
+++ b/bake/compose.go
@@ -46,10 +46,10 @@ func ParseCompose(dt []byte) (*Config, error) {
 	var c Config
 	var zeroBuildConfig composetypes.BuildConfig
 	if len(cfg.Services) > 0 {
-		c.Group = map[string]Group{}
-		c.Target = map[string]Target{}
+		c.Groups = []*Group{}
+		c.Targets = []*Target{}
 
-		var g Group
+		g := &Group{Name: "default"}
 
 		for _, s := range cfg.Services {
 
@@ -72,7 +72,8 @@ func ParseCompose(dt []byte) (*Config, error) {
 				dockerfilePathP = &dockerfilePath
 			}
 			g.Targets = append(g.Targets, s.Name)
-			t := Target{
+			t := &Target{
+				Name:       s.Name,
 				Context:    contextPathP,
 				Dockerfile: dockerfilePathP,
 				Labels:     s.Build.Labels,
@@ -87,9 +88,9 @@ func ParseCompose(dt []byte) (*Config, error) {
 			if s.Image != "" {
 				t.Tags = []string{s.Image}
 			}
-			c.Target[s.Name] = t
+			c.Targets = append(c.Targets, t)
 		}
-		c.Group["default"] = g
+		c.Groups = append(c.Groups, g)
 
 	}
 
diff --git a/bake/compose_test.go b/bake/compose_test.go
index 94bf235d..63c4ae35 100644
--- a/bake/compose_test.go
+++ b/bake/compose_test.go
@@ -27,17 +27,23 @@ services:
 	c, err := ParseCompose(dt)
 	require.NoError(t, err)
 
-	require.Equal(t, 1, len(c.Group))
-	sort.Strings(c.Group["default"].Targets)
-	require.Equal(t, []string{"db", "webapp"}, c.Group["default"].Targets)
-
-	require.Equal(t, 2, len(c.Target))
-	require.Equal(t, "./db", *c.Target["db"].Context)
-
-	require.Equal(t, "./dir", *c.Target["webapp"].Context)
-	require.Equal(t, "Dockerfile-alternate", *c.Target["webapp"].Dockerfile)
-	require.Equal(t, 1, len(c.Target["webapp"].Args))
-	require.Equal(t, "123", c.Target["webapp"].Args["buildno"])
+	require.Equal(t, 1, len(c.Groups))
+	require.Equal(t, c.Groups[0].Name, "default")
+	sort.Strings(c.Groups[0].Targets)
+	require.Equal(t, []string{"db", "webapp"}, c.Groups[0].Targets)
+
+	require.Equal(t, 2, len(c.Targets))
+	sort.Slice(c.Targets, func(i, j int) bool {
+		return c.Targets[i].Name < c.Targets[j].Name
+	})
+	require.Equal(t, "db", c.Targets[0].Name)
+	require.Equal(t, "./db", *c.Targets[0].Context)
+
+	require.Equal(t, "webapp", c.Targets[1].Name)
+	require.Equal(t, "./dir", *c.Targets[1].Context)
+	require.Equal(t, "Dockerfile-alternate", *c.Targets[1].Dockerfile)
+	require.Equal(t, 1, len(c.Targets[1].Args))
+	require.Equal(t, "123", c.Targets[1].Args["buildno"])
 }
 
 func TestNoBuildOutOfTreeService(t *testing.T) {
@@ -52,7 +58,7 @@ services:
 `)
 	c, err := ParseCompose(dt)
 	require.NoError(t, err)
-	require.Equal(t, 1, len(c.Group))
+	require.Equal(t, 1, len(c.Groups))
 }
 
 func TestParseComposeTarget(t *testing.T) {
@@ -73,8 +79,14 @@ services:
 	c, err := ParseCompose(dt)
 	require.NoError(t, err)
 
-	require.Equal(t, "db", *c.Target["db"].Target)
-	require.Equal(t, "webapp", *c.Target["webapp"].Target)
+	require.Equal(t, 2, len(c.Targets))
+	sort.Slice(c.Targets, func(i, j int) bool {
+		return c.Targets[i].Name < c.Targets[j].Name
+	})
+	require.Equal(t, "db", c.Targets[0].Name)
+	require.Equal(t, "db", *c.Targets[0].Target)
+	require.Equal(t, "webapp", c.Targets[1].Name)
+	require.Equal(t, "webapp", *c.Targets[1].Target)
 }
 
 func TestComposeBuildWithoutContext(t *testing.T) {
@@ -93,8 +105,14 @@ services:
 
 	c, err := ParseCompose(dt)
 	require.NoError(t, err)
-	require.Equal(t, "db", *c.Target["db"].Target)
-	require.Equal(t, "webapp", *c.Target["webapp"].Target)
+	require.Equal(t, 2, len(c.Targets))
+	sort.Slice(c.Targets, func(i, j int) bool {
+		return c.Targets[i].Name < c.Targets[j].Name
+	})
+	require.Equal(t, c.Targets[0].Name, "db")
+	require.Equal(t, "db", *c.Targets[0].Target)
+	require.Equal(t, c.Targets[1].Name, "webapp")
+	require.Equal(t, "webapp", *c.Targets[1].Target)
 }
 
 func TestBogusCompose(t *testing.T) {
diff --git a/bake/hcl.go b/bake/hcl.go
index 898b932f..714fbb2f 100644
--- a/bake/hcl.go
+++ b/bake/hcl.go
@@ -1,10 +1,10 @@
 package bake
 
-import "github.com/hashicorp/hcl"
+import "github.com/hashicorp/hcl/v2/hclsimple"
 
-func ParseHCL(dt []byte) (*Config, error) {
+func ParseHCL(dt []byte, fn string) (*Config, error) {
 	var c Config
-	if err := hcl.Unmarshal(dt, &c); err != nil {
+	if err := hclsimple.Decode(fn, dt, nil, &c); err != nil {
 		return nil, err
 	}
 	return &c, nil
diff --git a/bake/hcl_test.go b/bake/hcl_test.go
index 5e4fc001..ec6e2bc3 100644
--- a/bake/hcl_test.go
+++ b/bake/hcl_test.go
@@ -40,18 +40,22 @@ func TestParseHCL(t *testing.T) {
 	}
 	`)
 
-	c, err := ParseHCL(dt)
+	c, err := ParseHCL(dt, "docker-bake.hcl")
 	require.NoError(t, err)
 
-	require.Equal(t, 1, len(c.Group))
-	require.Equal(t, []string{"db", "webapp"}, c.Group["default"].Targets)
+	require.Equal(t, 1, len(c.Groups))
+	require.Equal(t, "default", c.Groups[0].Name)
+	require.Equal(t, []string{"db", "webapp"}, c.Groups[0].Targets)
 
-	require.Equal(t, 4, len(c.Target))
-	require.Equal(t, "./db", *c.Target["db"].Context)
+	require.Equal(t, 4, len(c.Targets))
+	require.Equal(t, c.Targets[0].Name, "db")
+	require.Equal(t, "./db", *c.Targets[0].Context)
 
-	require.Equal(t, 1, len(c.Target["webapp"].Args))
-	require.Equal(t, "123", c.Target["webapp"].Args["buildno"])
+	require.Equal(t, c.Targets[1].Name, "webapp")
+	require.Equal(t, 1, len(c.Targets[1].Args))
+	require.Equal(t, "123", c.Targets[1].Args["buildno"])
 
-	require.Equal(t, 2, len(c.Target["cross"].Platforms))
-	require.Equal(t, []string{"linux/amd64", "linux/arm64"}, c.Target["cross"].Platforms)
+	require.Equal(t, c.Targets[2].Name, "cross")
+	require.Equal(t, 2, len(c.Targets[2].Platforms))
+	require.Equal(t, []string{"linux/amd64", "linux/arm64"}, c.Targets[2].Platforms)
 }
diff --git a/commands/bake.go b/commands/bake.go
index e60735c0..e25f088d 100644
--- a/commands/bake.go
+++ b/commands/bake.go
@@ -59,7 +59,7 @@ func runBake(dockerCli command.Cli, targets []string, in bakeOptions) error {
 	}
 
 	if in.printOnly {
-		dt, err := json.MarshalIndent(map[string]map[string]bake.Target{"target": m}, "", "   ")
+		dt, err := json.MarshalIndent(map[string]map[string]*bake.Target{"target": m}, "", "   ")
 		if err != nil {
 			return err
 		}
diff --git a/vendor/github.com/apparentlymart/go-textseg/LICENSE b/vendor/github.com/apparentlymart/go-textseg/LICENSE
new file mode 100644
index 00000000..684b03b4
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/LICENSE
@@ -0,0 +1,95 @@
+Copyright (c) 2017 Martin Atkins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---------
+
+Unicode table generation programs are under a separate copyright and license:
+
+Copyright (c) 2014 Couchbase, Inc.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+except in compliance with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the
+License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the specific language governing permissions
+and limitations under the License.
+
+---------
+
+Grapheme break data is provided as part of the Unicode character database,
+copright 2016 Unicode, Inc, which is provided with the following license:
+
+Unicode Data Files include all data files under the directories
+http://www.unicode.org/Public/, http://www.unicode.org/reports/,
+http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and
+http://www.unicode.org/utility/trac/browser/.
+
+Unicode Data Files do not include PDF online code charts under the
+directory http://www.unicode.org/Public/.
+
+Software includes any source code published in the Unicode Standard
+or under the directories
+http://www.unicode.org/Public/, http://www.unicode.org/reports/,
+http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and
+http://www.unicode.org/utility/trac/browser/.
+
+NOTICE TO USER: Carefully read the following legal agreement.
+BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S
+DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"),
+YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT.
+IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE
+THE DATA FILES OR SOFTWARE.
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 1991-2017 Unicode, Inc. All rights reserved.
+Distributed under the Terms of Use in http://www.unicode.org/copyright.html.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Unicode data files and any associated documentation
+(the "Data Files") or Unicode software and any associated documentation
+(the "Software") to deal in the Data Files or Software
+without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, and/or sell copies of
+the Data Files or Software, and to permit persons to whom the Data Files
+or Software are furnished to do so, provided that either
+(a) this copyright and permission notice appear with all copies
+of the Data Files or Software, or
+(b) this copyright and permission notice appear in associated
+Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT OF THIRD PARTY RIGHTS.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
+NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
+DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder
+shall not be used in advertising or otherwise to promote the sale,
+use or other dealings in these Data Files or Software without prior
+written authorization of the copyright holder.
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/all_tokens.go b/vendor/github.com/apparentlymart/go-textseg/textseg/all_tokens.go
new file mode 100644
index 00000000..5752e9ef
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/all_tokens.go
@@ -0,0 +1,30 @@
+package textseg
+
+import (
+	"bufio"
+	"bytes"
+)
+
+// AllTokens is a utility that uses a bufio.SplitFunc to produce a slice of
+// all of the recognized tokens in the given buffer.
+func AllTokens(buf []byte, splitFunc bufio.SplitFunc) ([][]byte, error) {
+	scanner := bufio.NewScanner(bytes.NewReader(buf))
+	scanner.Split(splitFunc)
+	var ret [][]byte
+	for scanner.Scan() {
+		ret = append(ret, scanner.Bytes())
+	}
+	return ret, scanner.Err()
+}
+
+// TokenCount is a utility that uses a bufio.SplitFunc to count the number of
+// recognized tokens in the given buffer.
+func TokenCount(buf []byte, splitFunc bufio.SplitFunc) (int, error) {
+	scanner := bufio.NewScanner(bytes.NewReader(buf))
+	scanner.Split(splitFunc)
+	var ret int
+	for scanner.Scan() {
+		ret++
+	}
+	return ret, scanner.Err()
+}
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/generate.go b/vendor/github.com/apparentlymart/go-textseg/textseg/generate.go
new file mode 100644
index 00000000..81f3a747
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/generate.go
@@ -0,0 +1,7 @@
+package textseg
+
+//go:generate go run make_tables.go -output tables.go
+//go:generate go run make_test_tables.go -output tables_test.go
+//go:generate ruby unicode2ragel.rb --url=http://www.unicode.org/Public/9.0.0/ucd/auxiliary/GraphemeBreakProperty.txt -m GraphemeCluster -p "Prepend,CR,LF,Control,Extend,Regional_Indicator,SpacingMark,L,V,T,LV,LVT,E_Base,E_Modifier,ZWJ,Glue_After_Zwj,E_Base_GAZ" -o grapheme_clusters_table.rl
+//go:generate ragel -Z grapheme_clusters.rl
+//go:generate gofmt -w grapheme_clusters.go
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.go b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.go
new file mode 100644
index 00000000..012bc690
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.go
@@ -0,0 +1,5276 @@
+
+// line 1 "grapheme_clusters.rl"
+package textseg
+
+import (
+    "errors"
+    "unicode/utf8"
+)
+
+// Generated from grapheme_clusters.rl. DO NOT EDIT
+
+// line 13 "grapheme_clusters.go"
+var _graphclust_actions []byte = []byte{
+	0, 1, 0, 1, 4, 1, 9, 1, 10, 
+	1, 11, 1, 12, 1, 13, 1, 14, 
+	1, 15, 1, 16, 1, 17, 1, 18, 
+	1, 19, 1, 20, 1, 21, 2, 1, 
+	7, 2, 1, 8, 2, 2, 3, 2, 
+	5, 1, 3, 0, 1, 8, 3, 5, 
+	0, 1, 3, 5, 1, 6, 
+}
+
+var _graphclust_key_offsets []int16 = []int16{
+	0, 0, 1, 3, 5, 7, 10, 15, 
+	17, 20, 28, 31, 33, 35, 37, 67, 
+	75, 77, 81, 84, 89, 94, 104, 116, 
+	122, 127, 137, 140, 147, 151, 159, 169, 
+	173, 181, 183, 191, 194, 196, 201, 203, 
+	210, 212, 220, 221, 242, 246, 252, 257, 
+	259, 263, 267, 269, 273, 275, 278, 282, 
+	284, 291, 293, 297, 301, 305, 307, 309, 
+	318, 322, 327, 329, 335, 337, 338, 340, 
+	341, 343, 345, 347, 349, 364, 368, 370, 
+	372, 377, 381, 385, 387, 389, 393, 397, 
+	399, 403, 410, 415, 419, 422, 423, 427, 
+	434, 439, 440, 441, 443, 452, 454, 477, 
+	481, 483, 487, 491, 492, 496, 500, 503, 
+	505, 510, 523, 525, 527, 529, 531, 535, 
+	539, 541, 543, 545, 549, 553, 557, 559, 
+	561, 563, 565, 566, 568, 574, 580, 586, 
+	588, 592, 596, 601, 604, 614, 616, 618, 
+	621, 623, 625, 627, 629, 632, 637, 639, 
+	642, 650, 653, 655, 657, 659, 690, 698, 
+	700, 704, 711, 723, 730, 744, 750, 768, 
+	779, 785, 797, 800, 809, 814, 824, 830, 
+	844, 850, 862, 874, 878, 880, 886, 888, 
+	895, 898, 906, 907, 928, 937, 945, 951, 
+	953, 957, 961, 966, 972, 974, 977, 990, 
+	995, 1009, 1011, 1020, 1027, 1038, 1048, 1056, 
+	1067, 1071, 1076, 1078, 1080, 1082, 1083, 1085, 
+	1087, 1089, 1091, 1106, 1110, 1112, 1114, 1122, 
+	1130, 1132, 1136, 1147, 1150, 1160, 1164, 1171, 
+	1179, 1185, 1188, 1189, 1193, 1200, 1205, 1206, 
+	1207, 1209, 1218, 1220, 1243, 1248, 1250, 1259, 
+	1264, 1265, 1274, 1280, 1290, 1295, 1302, 1316, 
+	1320, 1325, 1336, 1339, 1349, 1353, 1362, 1364, 
+	1372, 1379, 1385, 1392, 1396, 1398, 1400, 1402, 
+	1403, 1405, 1411, 1419, 1425, 1427, 1431, 1435, 
+	1440, 1443, 1453, 1455, 1457, 1458, 1460, 1461, 
+	1467, 1469, 1471, 1471, 1472, 1473, 1474, 1480, 
+	1482, 1484, 1484, 1490, 1492, 1497, 1502, 1504, 
+	1506, 1508, 1511, 1516, 1518, 1521, 1529, 1532, 
+	1534, 1536, 1538, 1568, 1576, 1578, 1582, 1585, 
+	1590, 1595, 1605, 1617, 1623, 1628, 1638, 1641, 
+	1648, 1652, 1660, 1670, 1674, 1682, 1684, 1692, 
+	1695, 1697, 1702, 1704, 1711, 1713, 1721, 1722, 
+	1743, 1747, 1753, 1758, 1760, 1764, 1768, 1770, 
+	1774, 1776, 1779, 1783, 1785, 1792, 1794, 1798, 
+	1802, 1806, 1808, 1810, 1819, 1823, 1828, 1830, 
+	1836, 1838, 1839, 1841, 1842, 1844, 1846, 1848, 
+	1850, 1865, 1869, 1871, 1873, 1878, 1882, 1886, 
+	1888, 1890, 1894, 1898, 1900, 1904, 1911, 1916, 
+	1920, 1923, 1924, 1928, 1935, 1940, 1941, 1942, 
+	1944, 1953, 1955, 1978, 1982, 1984, 1988, 1992, 
+	1993, 1997, 2001, 2004, 2006, 2011, 2024, 2026, 
+	2028, 2030, 2032, 2036, 2040, 2042, 2044, 2046, 
+	2050, 2054, 2058, 2060, 2062, 2064, 2066, 2067, 
+	2069, 2075, 2081, 2087, 2089, 2093, 2097, 2102, 
+	2105, 2115, 2117, 2119, 2122, 2124, 2126, 2128, 
+	2130, 2133, 2138, 2140, 2143, 2151, 2154, 2156, 
+	2158, 2160, 2191, 2199, 2201, 2205, 2212, 2224, 
+	2231, 2245, 2251, 2269, 2280, 2286, 2298, 2301, 
+	2310, 2315, 2325, 2331, 2345, 2351, 2363, 2375, 
+	2379, 2381, 2387, 2389, 2396, 2399, 2407, 2408, 
+	2429, 2438, 2446, 2452, 2454, 2458, 2462, 2467, 
+	2473, 2475, 2478, 2491, 2496, 2510, 2512, 2521, 
+	2528, 2539, 2549, 2557, 2568, 2572, 2577, 2579, 
+	2581, 2583, 2584, 2586, 2588, 2590, 2592, 2607, 
+	2611, 2613, 2615, 2623, 2631, 2633, 2637, 2648, 
+	2651, 2661, 2665, 2672, 2680, 2686, 2689, 2690, 
+	2694, 2701, 2706, 2707, 2708, 2710, 2719, 2721, 
+	2744, 2749, 2751, 2760, 2765, 2766, 2775, 2781, 
+	2791, 2796, 2803, 2817, 2821, 2826, 2837, 2840, 
+	2850, 2854, 2863, 2865, 2873, 2880, 2886, 2893, 
+	2897, 2899, 2901, 2903, 2904, 2906, 2912, 2920, 
+	2926, 2928, 2932, 2936, 2941, 2944, 2954, 2956, 
+	2958, 2959, 2961, 2962, 2968, 2970, 2972, 2972, 
+	2973, 2974, 2975, 2981, 2983, 2985, 2985, 2991, 
+	2993, 2997, 3003, 3006, 3009, 3013, 3016, 3019, 
+	3026, 3028, 3052, 3054, 3078, 3080, 3082, 3105, 
+	3107, 3109, 3110, 3112, 3114, 3116, 3122, 3124, 
+	3156, 3160, 3165, 3188, 3190, 3192, 3194, 3196, 
+	3199, 3201, 3203, 3207, 3207, 3263, 3319, 3350, 
+	3355, 3359, 3366, 3374, 3378, 3381, 3384, 3390, 
+	3392, 3412, 3418, 3423, 3425, 3427, 3430, 3432, 
+	3434, 3438, 3494, 3550, 3581, 3586, 3594, 3598, 
+	3600, 3605, 3611, 3615, 3618, 3624, 3627, 3631, 
+	3634, 3638, 3651, 3655, 3662, 3663, 3665, 3668, 
+	3678, 3698, 3705, 3709, 3716, 3726, 3733, 3736, 
+	3751, 3753, 3756, 3761, 3763, 3766, 3769, 3773, 
+	3776, 3779, 3786, 3788, 3790, 3792, 3794, 3797, 
+	3802, 3804, 3807, 3815, 3818, 3820, 3822, 3824, 
+	3854, 3862, 3864, 3868, 3871, 3876, 3881, 3891, 
+	3903, 3909, 3914, 3924, 3927, 3934, 3938, 3946, 
+	3956, 3960, 3968, 3970, 3978, 3981, 3983, 3988, 
+	3990, 3997, 3999, 4007, 4008, 4029, 4033, 4039, 
+	4044, 4046, 4050, 4054, 4056, 4060, 4062, 4065, 
+	4069, 4071, 4078, 4080, 4084, 4088, 4092, 4094, 
+	4096, 4105, 4109, 4114, 4116, 4122, 4124, 4125, 
+	4127, 4128, 4130, 4132, 4134, 4136, 4151, 4155, 
+	4157, 4159, 4164, 4168, 4172, 4174, 4176, 4180, 
+	4184, 4186, 4190, 4197, 4202, 4206, 4209, 4210, 
+	4214, 4221, 4226, 4227, 4228, 4230, 4239, 4241, 
+	4264, 4268, 4270, 4274, 4278, 4279, 4283, 4287, 
+	4290, 4292, 4297, 4310, 4312, 4314, 4316, 4318, 
+	4322, 4326, 4328, 4330, 4332, 4336, 4340, 4344, 
+	4346, 4348, 4350, 4352, 4353, 4355, 4361, 4367, 
+	4373, 4375, 4379, 4383, 4388, 4391, 4401, 4403, 
+	4405, 4408, 4410, 4412, 4414, 4416, 4419, 4424, 
+	4426, 4429, 4437, 4440, 4442, 4444, 4446, 4477, 
+	4485, 4487, 4491, 4498, 4510, 4517, 4531, 4537, 
+	4555, 4566, 4572, 4584, 4587, 4596, 4601, 4611, 
+	4617, 4631, 4637, 4649, 4661, 4665, 4667, 4673, 
+	4675, 4682, 4685, 4693, 4694, 4715, 4724, 4732, 
+	4738, 4740, 4744, 4748, 4753, 4759, 4761, 4764, 
+	4777, 4782, 4796, 4798, 4807, 4814, 4825, 4835, 
+	4843, 4854, 4858, 4863, 4865, 4867, 4869, 4870, 
+	4872, 4874, 4876, 4878, 4893, 4897, 4899, 4901, 
+	4909, 4917, 4919, 4923, 4934, 4937, 4947, 4951, 
+	4958, 4966, 4972, 4975, 4976, 4980, 4987, 4992, 
+	4993, 4994, 4996, 5005, 5007, 5030, 5035, 5037, 
+	5046, 5051, 5052, 5061, 5067, 5077, 5082, 5089, 
+	5103, 5107, 5112, 5123, 5126, 5136, 5140, 5149, 
+	5151, 5159, 5166, 5172, 5179, 5183, 5185, 5187, 
+	5189, 5190, 5192, 5198, 5206, 5212, 5214, 5218, 
+	5222, 5227, 5230, 5240, 5242, 5244, 5245, 5247, 
+	5248, 5254, 5256, 5258, 5258, 5259, 5260, 5261, 
+	5267, 5269, 5271, 5271, 5277, 5301, 5303, 5327, 
+	5329, 5331, 5354, 5356, 5358, 5359, 5361, 5363, 
+	5365, 5371, 5373, 5405, 5409, 5414, 5437, 5439, 
+	5441, 5443, 5445, 5448, 5450, 5452, 5456, 5456, 
+	5512, 5568, 5599, 5604, 5607, 5614, 5626, 5628, 
+	5630, 5632, 5635, 5640, 5642, 5645, 5653, 5656, 
+	5658, 5660, 5662, 5692, 5700, 5702, 5706, 5709, 
+	5714, 5719, 5729, 5741, 5747, 5752, 5762, 5765, 
+	5772, 5776, 5784, 5794, 5798, 5806, 5808, 5816, 
+	5819, 5821, 5826, 5828, 5835, 5837, 5845, 5846, 
+	5867, 5871, 5877, 5882, 5884, 5888, 5892, 5894, 
+	5898, 5900, 5903, 5907, 5909, 5916, 5918, 5922, 
+	5926, 5930, 5932, 5934, 5943, 5947, 5952, 5954, 
+	5956, 5958, 5959, 5961, 5963, 5965, 5967, 5982, 
+	5986, 5988, 5990, 5995, 5999, 6003, 6005, 6007, 
+	6011, 6015, 6017, 6021, 6028, 6033, 6037, 6040, 
+	6041, 6045, 6051, 6056, 6057, 6058, 6060, 6069, 
+	6071, 6094, 6098, 6100, 6104, 6108, 6109, 6113, 
+	6117, 6120, 6122, 6127, 6140, 6142, 6144, 6146, 
+	6148, 6152, 6156, 6158, 6160, 6162, 6166, 6170, 
+	6174, 6176, 6178, 6180, 6182, 6183, 6185, 6191, 
+	6197, 6203, 6205, 6209, 6213, 6218, 6221, 6231, 
+	6233, 6235, 6236, 6242, 6244, 6246, 6246, 6252, 
+	6253, 6260, 6263, 6265, 6267, 6269, 6271, 6274, 
+	6279, 6281, 6284, 6292, 6295, 6297, 6299, 6301, 
+	6332, 6340, 6342, 6346, 6353, 6365, 6372, 6386, 
+	6392, 6410, 6421, 6427, 6439, 6442, 6451, 6456, 
+	6466, 6472, 6486, 6492, 6504, 6516, 6520, 6522, 
+	6528, 6530, 6537, 6540, 6548, 6549, 6570, 6579, 
+	6587, 6593, 6595, 6599, 6603, 6608, 6614, 6616, 
+	6619, 6632, 6637, 6651, 6653, 6662, 6669, 6680, 
+	6690, 6698, 6709, 6713, 6718, 6720, 6722, 6724, 
+	6725, 6727, 6729, 6731, 6733, 6748, 6752, 6754, 
+	6756, 6764, 6772, 6774, 6778, 6789, 6792, 6802, 
+	6806, 6813, 6821, 6827, 6830, 6831, 6835, 6842, 
+	6847, 6848, 6849, 6851, 6860, 6862, 6885, 6890, 
+	6892, 6901, 6906, 6907, 6916, 6922, 6932, 6937, 
+	6944, 6958, 6962, 6967, 6978, 6981, 6991, 6995, 
+	7004, 7006, 7014, 7021, 7027, 7034, 7038, 7040, 
+	7042, 7044, 7045, 7047, 7053, 7061, 7067, 7069, 
+	7073, 7077, 7082, 7085, 7095, 7097, 7099, 7100, 
+	7102, 7103, 7109, 7111, 7113, 7113, 7114, 7115, 
+	7121, 7124, 7126, 7128, 7130, 7133, 7138, 7140, 
+	7143, 7151, 7154, 7156, 7158, 7160, 7191, 7199, 
+	7201, 7205, 7212, 7214, 7216, 7218, 7221, 7226, 
+	7228, 7231, 7239, 7242, 7244, 7246, 7248, 7278, 
+	7286, 7288, 7292, 7295, 7300, 7305, 7315, 7327, 
+	7333, 7338, 7348, 7351, 7358, 7362, 7370, 7380, 
+	7384, 7392, 7394, 7402, 7405, 7407, 7412, 7414, 
+	7421, 7423, 7431, 7432, 7453, 7457, 7463, 7468, 
+	7470, 7474, 7478, 7480, 7484, 7486, 7489, 7493, 
+	7495, 7502, 7504, 7508, 7512, 7516, 7518, 7520, 
+	7529, 7533, 7538, 7540, 7546, 7548, 7549, 7551, 
+	7552, 7554, 7556, 7558, 7560, 7575, 7579, 7581, 
+	7583, 7588, 7592, 7596, 7598, 7600, 7604, 7608, 
+	7610, 7614, 7621, 7626, 7630, 7633, 7634, 7638, 
+	7645, 7650, 7651, 7652, 7654, 7663, 7665, 7688, 
+	7692, 7694, 7698, 7702, 7703, 7707, 7711, 7714, 
+	7716, 7721, 7734, 7736, 7738, 7740, 7742, 7746, 
+	7750, 7752, 7754, 7756, 7760, 7764, 7768, 7770, 
+	7772, 7774, 7776, 7777, 7779, 7785, 7791, 7797, 
+	7799, 7803, 7807, 7812, 7815, 7825, 7827, 7829, 
+	7832, 7834, 7835, 7836, 7837, 7843, 7845, 7847, 
+	7847, 7853, 7865, 7872, 7886, 7892, 7910, 7921, 
+	7927, 7939, 7942, 7951, 7956, 7966, 7972, 7986, 
+	7992, 8004, 8016, 8020, 8022, 8028, 8030, 8037, 
+	8040, 8048, 8049, 8070, 8079, 8087, 8093, 8095, 
+	8099, 8103, 8108, 8114, 8116, 8119, 8132, 8137, 
+	8151, 8153, 8162, 8169, 8180, 8190, 8198, 8209, 
+	8213, 8218, 8220, 8222, 8224, 8225, 8227, 8229, 
+	8231, 8233, 8248, 8252, 8254, 8256, 8264, 8272, 
+	8274, 8278, 8289, 8292, 8302, 8306, 8313, 8321, 
+	8327, 8330, 8331, 8335, 8342, 8347, 8348, 8349, 
+	8351, 8360, 8362, 8385, 8390, 8392, 8401, 8406, 
+	8407, 8416, 8422, 8432, 8437, 8444, 8458, 8462, 
+	8467, 8478, 8481, 8491, 8495, 8504, 8506, 8514, 
+	8521, 8527, 8534, 8538, 8540, 8542, 8544, 8545, 
+	8547, 8553, 8561, 8567, 8569, 8573, 8577, 8582, 
+	8585, 8595, 8597, 8599, 8600, 8602, 8603, 8609, 
+	8611, 8613, 8613, 8616, 8622, 8624, 8644, 8650, 
+	8655, 8657, 8659, 8662, 8664, 8666, 8670, 8726, 
+	8782, 8817, 8822, 8830, 8832, 8832, 8834, 8838, 
+	8841, 8848, 8854, 8858, 8861, 8867, 8870, 8876, 
+	8879, 8885, 8898, 8902, 8904, 8906, 8908, 8911, 
+	8916, 8918, 8921, 8929, 8932, 8934, 8936, 8938, 
+	8968, 8976, 8978, 8982, 8985, 8990, 8995, 9005, 
+	9017, 9023, 9028, 9038, 9041, 9048, 9052, 9060, 
+	9070, 9074, 9082, 9084, 9092, 9095, 9097, 9102, 
+	9104, 9111, 9113, 9121, 9122, 9143, 9147, 9153, 
+	9158, 9160, 9164, 9168, 9170, 9174, 9176, 9179, 
+	9183, 9185, 9192, 9194, 9198, 9202, 9206, 9208, 
+	9210, 9219, 9223, 9228, 9230, 9236, 9238, 9239, 
+	9241, 9242, 9244, 9246, 9248, 9250, 9265, 9269, 
+	9271, 9273, 9278, 9282, 9286, 9288, 9290, 9294, 
+	9298, 9300, 9304, 9311, 9316, 9320, 9323, 9324, 
+	9328, 9335, 9340, 9341, 9342, 9344, 9353, 9355, 
+	9378, 9382, 9384, 9388, 9392, 9393, 9397, 9401, 
+	9404, 9406, 9411, 9424, 9426, 9428, 9430, 9432, 
+	9436, 9440, 9442, 9444, 9446, 9450, 9454, 9458, 
+	9460, 9462, 9464, 9466, 9467, 9469, 9475, 9481, 
+	9487, 9489, 9493, 9497, 9502, 9505, 9515, 9517, 
+	9519, 9522, 9524, 9526, 9528, 9530, 9533, 9538, 
+	9540, 9543, 9551, 9554, 9556, 9558, 9560, 9591, 
+	9599, 9601, 9605, 9612, 9624, 9631, 9645, 9651, 
+	9669, 9680, 9686, 9698, 9701, 9710, 9715, 9725, 
+	9731, 9745, 9751, 9763, 9775, 9779, 9781, 9787, 
+	9789, 9796, 9799, 9807, 9808, 9829, 9838, 9846, 
+	9852, 9854, 9858, 9862, 9867, 9873, 9875, 9878, 
+	9891, 9896, 9910, 9912, 9921, 9928, 9939, 9949, 
+	9957, 9968, 9972, 9977, 9979, 9981, 9983, 9984, 
+	9986, 9988, 9990, 9992, 10007, 10011, 10013, 10015, 
+	10023, 10031, 10033, 10037, 10048, 10051, 10061, 10065, 
+	10072, 10080, 10086, 10089, 10090, 10094, 10101, 10106, 
+	10107, 10108, 10110, 10119, 10121, 10144, 10149, 10151, 
+	10160, 10165, 10166, 10175, 10181, 10191, 10196, 10203, 
+	10217, 10221, 10226, 10237, 10240, 10250, 10254, 10263, 
+	10265, 10273, 10280, 10286, 10293, 10297, 10299, 10301, 
+	10303, 10304, 10306, 10312, 10320, 10326, 10328, 10332, 
+	10336, 10341, 10344, 10354, 10356, 10358, 10359, 10361, 
+	10362, 10368, 10370, 10372, 10372, 10373, 10374, 10375, 
+	10381, 10383, 10385, 10385, 10391, 10398, 10399, 10401, 
+	10404, 10414, 10434, 10441, 10445, 10452, 10462, 10469, 
+	10472, 10487, 10489, 10492, 10501, 10505, 10509, 10538, 
+	10558, 10578, 10598, 10620, 10640, 10660, 10680, 10703, 
+	10724, 10745, 10766, 10786, 10809, 10829, 10849, 10869, 
+	10890, 10911, 10932, 10952, 10972, 10992, 11012, 11032, 
+	11052, 11072, 11092, 11112, 
+}
+
+var _graphclust_trans_keys []byte = []byte{
+	10, 128, 255, 176, 255, 131, 137, 191, 
+	145, 189, 135, 129, 130, 132, 133, 144, 
+	154, 176, 139, 159, 150, 156, 159, 164, 
+	167, 168, 170, 173, 145, 176, 255, 139, 
+	255, 166, 176, 171, 179, 160, 161, 163, 
+	164, 165, 167, 169, 171, 173, 174, 175, 
+	176, 177, 179, 180, 181, 182, 183, 184, 
+	185, 186, 187, 188, 189, 190, 191, 166, 
+	170, 172, 178, 150, 153, 155, 163, 165, 
+	167, 169, 173, 153, 155, 148, 161, 163, 
+	255, 189, 132, 185, 144, 152, 161, 164, 
+	255, 188, 129, 131, 190, 255, 133, 134, 
+	137, 138, 142, 150, 152, 161, 164, 255, 
+	131, 134, 137, 138, 142, 144, 146, 175, 
+	178, 180, 182, 255, 134, 138, 142, 161, 
+	164, 255, 188, 129, 131, 190, 191, 128, 
+	132, 135, 136, 139, 141, 150, 151, 162, 
+	163, 130, 190, 191, 151, 128, 130, 134, 
+	136, 138, 141, 128, 131, 190, 255, 133, 
+	137, 142, 148, 151, 161, 164, 255, 128, 
+	132, 134, 136, 138, 141, 149, 150, 162, 
+	163, 129, 131, 190, 255, 133, 137, 142, 
+	150, 152, 161, 164, 255, 130, 131, 138, 
+	150, 143, 148, 152, 159, 178, 179, 177, 
+	179, 186, 135, 142, 177, 179, 185, 187, 
+	188, 136, 141, 181, 183, 185, 152, 153, 
+	190, 191, 177, 191, 128, 132, 134, 135, 
+	141, 151, 153, 188, 134, 128, 129, 130, 
+	141, 156, 157, 158, 159, 160, 162, 164, 
+	168, 169, 170, 172, 173, 174, 175, 176, 
+	179, 183, 173, 183, 185, 190, 150, 153, 
+	158, 160, 177, 180, 130, 141, 157, 132, 
+	134, 157, 159, 146, 148, 178, 180, 146, 
+	147, 178, 179, 180, 255, 148, 156, 158, 
+	255, 139, 141, 169, 133, 134, 160, 171, 
+	176, 187, 151, 155, 160, 162, 191, 149, 
+	158, 165, 188, 176, 190, 128, 132, 180, 
+	255, 133, 170, 180, 255, 128, 130, 161, 
+	173, 166, 179, 164, 183, 173, 144, 146, 
+	148, 168, 178, 180, 184, 185, 128, 181, 
+	187, 191, 128, 131, 179, 181, 183, 140, 
+	141, 128, 131, 157, 179, 181, 183, 144, 
+	176, 164, 175, 177, 191, 160, 191, 128, 
+	130, 170, 175, 153, 154, 153, 154, 155, 
+	160, 162, 163, 164, 165, 166, 167, 168, 
+	169, 170, 171, 175, 175, 178, 180, 189, 
+	158, 159, 176, 177, 130, 134, 139, 163, 
+	167, 128, 129, 180, 255, 134, 159, 178, 
+	255, 166, 173, 135, 147, 128, 131, 179, 
+	255, 129, 164, 166, 255, 169, 182, 131, 
+	188, 140, 141, 176, 178, 180, 183, 184, 
+	190, 191, 129, 171, 175, 181, 182, 163, 
+	170, 172, 173, 172, 184, 190, 158, 128, 
+	143, 160, 175, 144, 145, 150, 155, 157, 
+	158, 159, 135, 139, 141, 168, 171, 189, 
+	160, 182, 186, 191, 129, 131, 133, 134, 
+	140, 143, 184, 186, 165, 166, 128, 129, 
+	130, 132, 133, 134, 135, 136, 139, 140, 
+	141, 144, 145, 146, 147, 150, 151, 152, 
+	153, 154, 156, 176, 178, 128, 130, 184, 
+	255, 135, 190, 131, 175, 187, 255, 128, 
+	130, 167, 180, 179, 128, 130, 179, 255, 
+	129, 137, 141, 255, 190, 172, 183, 159, 
+	170, 188, 128, 131, 190, 191, 151, 128, 
+	132, 135, 136, 139, 141, 162, 163, 166, 
+	172, 176, 180, 181, 191, 128, 134, 176, 
+	255, 132, 255, 175, 181, 184, 255, 129, 
+	155, 158, 255, 129, 255, 171, 183, 157, 
+	171, 175, 182, 184, 191, 146, 167, 169, 
+	182, 171, 172, 189, 190, 176, 180, 176, 
+	182, 145, 190, 143, 146, 178, 157, 158, 
+	133, 134, 137, 168, 169, 170, 165, 169, 
+	173, 178, 187, 255, 131, 132, 140, 169, 
+	174, 255, 130, 132, 128, 182, 187, 255, 
+	173, 180, 182, 255, 132, 155, 159, 161, 
+	175, 128, 163, 165, 128, 134, 136, 152, 
+	155, 161, 163, 164, 166, 170, 144, 150, 
+	132, 138, 145, 146, 151, 166, 169, 0, 
+	127, 176, 255, 131, 137, 191, 145, 189, 
+	135, 129, 130, 132, 133, 144, 154, 176, 
+	139, 159, 150, 156, 159, 164, 167, 168, 
+	170, 173, 145, 176, 255, 139, 255, 166, 
+	176, 171, 179, 160, 161, 163, 164, 165, 
+	166, 167, 169, 171, 172, 173, 174, 175, 
+	176, 177, 178, 179, 180, 181, 182, 183, 
+	184, 185, 186, 187, 188, 189, 190, 191, 
+	168, 170, 150, 153, 155, 163, 165, 167, 
+	169, 173, 153, 155, 148, 161, 163, 255, 
+	131, 187, 189, 132, 185, 190, 255, 141, 
+	144, 129, 136, 145, 151, 152, 161, 162, 
+	163, 164, 255, 129, 188, 190, 130, 131, 
+	191, 255, 141, 151, 129, 132, 133, 134, 
+	137, 138, 142, 161, 162, 163, 164, 255, 
+	131, 188, 129, 130, 190, 255, 145, 181, 
+	129, 130, 131, 134, 135, 136, 137, 138, 
+	139, 141, 142, 175, 176, 177, 178, 255, 
+	134, 138, 141, 129, 136, 142, 161, 162, 
+	163, 164, 255, 129, 188, 130, 131, 190, 
+	191, 128, 141, 129, 132, 135, 136, 139, 
+	140, 150, 151, 162, 163, 130, 190, 191, 
+	128, 141, 151, 129, 130, 134, 136, 138, 
+	140, 128, 129, 131, 190, 255, 133, 137, 
+	129, 132, 142, 148, 151, 161, 164, 255, 
+	129, 188, 190, 191, 130, 131, 130, 134, 
+	128, 132, 135, 136, 138, 139, 140, 141, 
+	149, 150, 162, 163, 129, 190, 130, 131, 
+	191, 255, 133, 137, 141, 151, 129, 132, 
+	142, 161, 162, 163, 164, 255, 138, 143, 
+	150, 159, 144, 145, 146, 148, 152, 158, 
+	178, 179, 177, 179, 180, 186, 135, 142, 
+	177, 179, 180, 185, 187, 188, 136, 141, 
+	181, 183, 185, 152, 153, 190, 191, 191, 
+	177, 190, 128, 132, 134, 135, 141, 151, 
+	153, 188, 134, 128, 129, 130, 141, 156, 
+	157, 158, 159, 160, 162, 164, 168, 169, 
+	170, 172, 173, 174, 175, 176, 179, 183, 
+	177, 173, 183, 185, 186, 187, 188, 189, 
+	190, 150, 151, 152, 153, 158, 160, 177, 
+	180, 130, 132, 141, 157, 133, 134, 157, 
+	159, 146, 148, 178, 180, 146, 147, 178, 
+	179, 182, 180, 189, 190, 255, 134, 157, 
+	137, 147, 148, 255, 139, 141, 169, 133, 
+	134, 178, 160, 162, 163, 166, 167, 168, 
+	169, 171, 176, 184, 185, 187, 155, 151, 
+	152, 153, 154, 150, 160, 162, 191, 149, 
+	151, 152, 158, 165, 172, 173, 178, 179, 
+	188, 176, 190, 132, 181, 187, 128, 131, 
+	180, 188, 189, 255, 130, 133, 170, 171, 
+	179, 180, 255, 130, 161, 170, 128, 129, 
+	162, 165, 166, 167, 168, 173, 167, 173, 
+	166, 169, 170, 174, 175, 177, 178, 179, 
+	164, 171, 172, 179, 180, 181, 182, 183, 
+	161, 173, 180, 144, 146, 148, 168, 178, 
+	179, 184, 185, 128, 181, 187, 191, 128, 
+	131, 179, 181, 183, 140, 141, 144, 176, 
+	175, 177, 191, 160, 191, 128, 130, 170, 
+	175, 153, 154, 153, 154, 155, 160, 162, 
+	163, 164, 165, 166, 167, 168, 169, 170, 
+	171, 175, 175, 178, 180, 189, 158, 159, 
+	176, 177, 130, 134, 139, 167, 163, 164, 
+	165, 166, 132, 133, 134, 159, 160, 177, 
+	178, 255, 166, 173, 135, 145, 146, 147, 
+	131, 179, 188, 128, 130, 180, 181, 182, 
+	185, 186, 255, 165, 129, 255, 169, 174, 
+	175, 176, 177, 178, 179, 180, 181, 182, 
+	131, 140, 141, 188, 176, 178, 180, 183, 
+	184, 190, 191, 129, 171, 181, 182, 172, 
+	173, 174, 175, 165, 168, 172, 173, 163, 
+	170, 172, 184, 190, 158, 128, 143, 160, 
+	175, 144, 145, 150, 155, 157, 158, 159, 
+	135, 139, 141, 168, 171, 189, 160, 182, 
+	186, 191, 129, 131, 133, 134, 140, 143, 
+	184, 186, 165, 166, 128, 129, 130, 132, 
+	133, 134, 135, 136, 139, 140, 141, 144, 
+	145, 146, 147, 150, 151, 152, 153, 154, 
+	156, 176, 178, 129, 128, 130, 184, 255, 
+	135, 190, 130, 131, 175, 176, 178, 183, 
+	184, 187, 255, 172, 128, 130, 167, 180, 
+	179, 130, 128, 129, 179, 181, 182, 190, 
+	191, 255, 129, 137, 138, 140, 141, 255, 
+	180, 190, 172, 174, 175, 177, 178, 181, 
+	182, 183, 159, 160, 162, 163, 170, 188, 
+	190, 191, 128, 129, 130, 131, 128, 151, 
+	129, 132, 135, 136, 139, 141, 162, 163, 
+	166, 172, 176, 180, 181, 183, 184, 191, 
+	133, 128, 129, 130, 134, 176, 185, 189, 
+	177, 178, 179, 186, 187, 190, 191, 255, 
+	129, 132, 255, 175, 190, 176, 177, 178, 
+	181, 184, 187, 188, 255, 129, 155, 158, 
+	255, 189, 176, 178, 179, 186, 187, 190, 
+	191, 255, 129, 255, 172, 182, 171, 173, 
+	174, 175, 176, 183, 166, 157, 159, 160, 
+	161, 162, 171, 175, 190, 176, 182, 184, 
+	191, 169, 177, 180, 146, 167, 170, 182, 
+	171, 172, 189, 190, 176, 180, 176, 182, 
+	143, 146, 178, 157, 158, 133, 134, 137, 
+	168, 169, 170, 166, 173, 165, 169, 174, 
+	178, 187, 255, 131, 132, 140, 169, 174, 
+	255, 130, 132, 128, 182, 187, 255, 173, 
+	180, 182, 255, 132, 155, 159, 161, 175, 
+	128, 163, 165, 128, 134, 136, 152, 155, 
+	161, 163, 164, 166, 170, 144, 150, 132, 
+	138, 143, 187, 191, 160, 128, 129, 132, 
+	135, 133, 134, 160, 255, 192, 255, 139, 
+	168, 160, 128, 129, 132, 135, 133, 134, 
+	160, 255, 192, 255, 144, 145, 150, 155, 
+	157, 158, 128, 191, 173, 128, 159, 160, 
+	191, 156, 128, 133, 134, 191, 0, 127, 
+	176, 255, 131, 137, 191, 145, 189, 135, 
+	129, 130, 132, 133, 144, 154, 176, 139, 
+	159, 150, 156, 159, 164, 167, 168, 170, 
+	173, 145, 176, 255, 139, 255, 166, 176, 
+	171, 179, 160, 161, 163, 164, 165, 167, 
+	169, 171, 173, 174, 175, 176, 177, 179, 
+	180, 181, 182, 183, 184, 185, 186, 187, 
+	188, 189, 190, 191, 166, 170, 172, 178, 
+	150, 153, 155, 163, 165, 167, 169, 173, 
+	153, 155, 148, 161, 163, 255, 189, 132, 
+	185, 144, 152, 161, 164, 255, 188, 129, 
+	131, 190, 255, 133, 134, 137, 138, 142, 
+	150, 152, 161, 164, 255, 131, 134, 137, 
+	138, 142, 144, 146, 175, 178, 180, 182, 
+	255, 134, 138, 142, 161, 164, 255, 188, 
+	129, 131, 190, 191, 128, 132, 135, 136, 
+	139, 141, 150, 151, 162, 163, 130, 190, 
+	191, 151, 128, 130, 134, 136, 138, 141, 
+	128, 131, 190, 255, 133, 137, 142, 148, 
+	151, 161, 164, 255, 128, 132, 134, 136, 
+	138, 141, 149, 150, 162, 163, 129, 131, 
+	190, 255, 133, 137, 142, 150, 152, 161, 
+	164, 255, 130, 131, 138, 150, 143, 148, 
+	152, 159, 178, 179, 177, 179, 186, 135, 
+	142, 177, 179, 185, 187, 188, 136, 141, 
+	181, 183, 185, 152, 153, 190, 191, 177, 
+	191, 128, 132, 134, 135, 141, 151, 153, 
+	188, 134, 128, 129, 130, 141, 156, 157, 
+	158, 159, 160, 162, 164, 168, 169, 170, 
+	172, 173, 174, 175, 176, 179, 183, 173, 
+	183, 185, 190, 150, 153, 158, 160, 177, 
+	180, 130, 141, 157, 132, 134, 157, 159, 
+	146, 148, 178, 180, 146, 147, 178, 179, 
+	180, 255, 148, 156, 158, 255, 139, 141, 
+	169, 133, 134, 160, 171, 176, 187, 151, 
+	155, 160, 162, 191, 149, 158, 165, 188, 
+	176, 190, 128, 132, 180, 255, 133, 170, 
+	180, 255, 128, 130, 161, 173, 166, 179, 
+	164, 183, 173, 144, 146, 148, 168, 178, 
+	180, 184, 185, 128, 181, 187, 191, 128, 
+	131, 179, 181, 183, 140, 141, 128, 131, 
+	157, 179, 181, 183, 144, 176, 164, 175, 
+	177, 191, 160, 191, 128, 130, 170, 175, 
+	153, 154, 153, 154, 155, 160, 162, 163, 
+	164, 165, 166, 167, 168, 169, 170, 171, 
+	175, 175, 178, 180, 189, 158, 159, 176, 
+	177, 130, 134, 139, 163, 167, 128, 129, 
+	180, 255, 134, 159, 178, 255, 166, 173, 
+	135, 147, 128, 131, 179, 255, 129, 164, 
+	166, 255, 169, 182, 131, 188, 140, 141, 
+	176, 178, 180, 183, 184, 190, 191, 129, 
+	171, 175, 181, 182, 163, 170, 172, 173, 
+	172, 184, 190, 158, 128, 143, 160, 175, 
+	144, 145, 150, 155, 157, 158, 159, 135, 
+	139, 141, 168, 171, 189, 160, 182, 186, 
+	191, 129, 131, 133, 134, 140, 143, 184, 
+	186, 165, 166, 128, 129, 130, 132, 133, 
+	134, 135, 136, 139, 140, 141, 144, 145, 
+	146, 147, 150, 151, 152, 153, 154, 156, 
+	176, 178, 128, 130, 184, 255, 135, 190, 
+	131, 175, 187, 255, 128, 130, 167, 180, 
+	179, 128, 130, 179, 255, 129, 137, 141, 
+	255, 190, 172, 183, 159, 170, 188, 128, 
+	131, 190, 191, 151, 128, 132, 135, 136, 
+	139, 141, 162, 163, 166, 172, 176, 180, 
+	181, 191, 128, 134, 176, 255, 132, 255, 
+	175, 181, 184, 255, 129, 155, 158, 255, 
+	129, 255, 171, 183, 157, 171, 175, 182, 
+	184, 191, 146, 167, 169, 182, 171, 172, 
+	189, 190, 176, 180, 176, 182, 145, 190, 
+	143, 146, 178, 157, 158, 133, 134, 137, 
+	168, 169, 170, 165, 169, 173, 178, 187, 
+	255, 131, 132, 140, 169, 174, 255, 130, 
+	132, 128, 182, 187, 255, 173, 180, 182, 
+	255, 132, 155, 159, 161, 175, 128, 163, 
+	165, 128, 134, 136, 152, 155, 161, 163, 
+	164, 166, 170, 144, 150, 132, 138, 145, 
+	146, 151, 166, 169, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 166, 167, 169, 
+	171, 172, 173, 174, 175, 176, 177, 178, 
+	179, 180, 181, 182, 183, 184, 185, 186, 
+	187, 188, 189, 190, 191, 168, 170, 150, 
+	153, 155, 163, 165, 167, 169, 173, 153, 
+	155, 148, 161, 163, 255, 131, 187, 189, 
+	132, 185, 190, 255, 141, 144, 129, 136, 
+	145, 151, 152, 161, 162, 163, 164, 255, 
+	129, 188, 190, 130, 131, 191, 255, 141, 
+	151, 129, 132, 133, 134, 137, 138, 142, 
+	161, 162, 163, 164, 255, 131, 188, 129, 
+	130, 190, 255, 145, 181, 129, 130, 131, 
+	134, 135, 136, 137, 138, 139, 141, 142, 
+	175, 176, 177, 178, 255, 134, 138, 141, 
+	129, 136, 142, 161, 162, 163, 164, 255, 
+	129, 188, 130, 131, 190, 191, 128, 141, 
+	129, 132, 135, 136, 139, 140, 150, 151, 
+	162, 163, 130, 190, 191, 128, 141, 151, 
+	129, 130, 134, 136, 138, 140, 128, 129, 
+	131, 190, 255, 133, 137, 129, 132, 142, 
+	148, 151, 161, 164, 255, 129, 188, 190, 
+	191, 130, 131, 130, 134, 128, 132, 135, 
+	136, 138, 139, 140, 141, 149, 150, 162, 
+	163, 129, 190, 130, 131, 191, 255, 133, 
+	137, 141, 151, 129, 132, 142, 161, 162, 
+	163, 164, 255, 138, 143, 150, 159, 144, 
+	145, 146, 148, 152, 158, 178, 179, 177, 
+	179, 180, 186, 135, 142, 177, 179, 180, 
+	185, 187, 188, 136, 141, 181, 183, 185, 
+	152, 153, 190, 191, 191, 177, 190, 128, 
+	132, 134, 135, 141, 151, 153, 188, 134, 
+	128, 129, 130, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 177, 173, 183, 
+	185, 186, 187, 188, 189, 190, 150, 151, 
+	152, 153, 158, 160, 177, 180, 130, 132, 
+	141, 157, 133, 134, 157, 159, 146, 148, 
+	178, 180, 146, 147, 178, 179, 182, 180, 
+	189, 190, 255, 134, 157, 137, 147, 148, 
+	255, 139, 141, 169, 133, 134, 178, 160, 
+	162, 163, 166, 167, 168, 169, 171, 176, 
+	184, 185, 187, 155, 151, 152, 153, 154, 
+	150, 160, 162, 191, 149, 151, 152, 158, 
+	165, 172, 173, 178, 179, 188, 176, 190, 
+	132, 181, 187, 128, 131, 180, 188, 189, 
+	255, 130, 133, 170, 171, 179, 180, 255, 
+	130, 161, 170, 128, 129, 162, 165, 166, 
+	167, 168, 173, 167, 173, 166, 169, 170, 
+	174, 175, 177, 178, 179, 164, 171, 172, 
+	179, 180, 181, 182, 183, 161, 173, 180, 
+	144, 146, 148, 168, 178, 179, 184, 185, 
+	128, 181, 187, 191, 128, 131, 179, 181, 
+	183, 140, 141, 144, 176, 175, 177, 191, 
+	160, 191, 128, 130, 170, 175, 153, 154, 
+	153, 154, 155, 160, 162, 163, 164, 165, 
+	166, 167, 168, 169, 170, 171, 175, 175, 
+	178, 180, 189, 158, 159, 176, 177, 130, 
+	134, 139, 167, 163, 164, 165, 166, 132, 
+	133, 134, 159, 160, 177, 178, 255, 166, 
+	173, 135, 145, 146, 147, 131, 179, 188, 
+	128, 130, 180, 181, 182, 185, 186, 255, 
+	165, 129, 255, 169, 174, 175, 176, 177, 
+	178, 179, 180, 181, 182, 131, 140, 141, 
+	188, 176, 178, 180, 183, 184, 190, 191, 
+	129, 171, 181, 182, 172, 173, 174, 175, 
+	165, 168, 172, 173, 163, 170, 172, 184, 
+	190, 158, 128, 143, 160, 175, 144, 145, 
+	150, 155, 157, 158, 159, 135, 139, 141, 
+	168, 171, 189, 160, 182, 186, 191, 129, 
+	131, 133, 134, 140, 143, 184, 186, 165, 
+	166, 128, 129, 130, 132, 133, 134, 135, 
+	136, 139, 140, 141, 144, 145, 146, 147, 
+	150, 151, 152, 153, 154, 156, 176, 178, 
+	129, 128, 130, 184, 255, 135, 190, 130, 
+	131, 175, 176, 178, 183, 184, 187, 255, 
+	172, 128, 130, 167, 180, 179, 130, 128, 
+	129, 179, 181, 182, 190, 191, 255, 129, 
+	137, 138, 140, 141, 255, 180, 190, 172, 
+	174, 175, 177, 178, 181, 182, 183, 159, 
+	160, 162, 163, 170, 188, 190, 191, 128, 
+	129, 130, 131, 128, 151, 129, 132, 135, 
+	136, 139, 141, 162, 163, 166, 172, 176, 
+	180, 181, 183, 184, 191, 133, 128, 129, 
+	130, 134, 176, 185, 189, 177, 178, 179, 
+	186, 187, 190, 191, 255, 129, 132, 255, 
+	175, 190, 176, 177, 178, 181, 184, 187, 
+	188, 255, 129, 155, 158, 255, 189, 176, 
+	178, 179, 186, 187, 190, 191, 255, 129, 
+	255, 172, 182, 171, 173, 174, 175, 176, 
+	183, 166, 157, 159, 160, 161, 162, 171, 
+	175, 190, 176, 182, 184, 191, 169, 177, 
+	180, 146, 167, 170, 182, 171, 172, 189, 
+	190, 176, 180, 176, 182, 143, 146, 178, 
+	157, 158, 133, 134, 137, 168, 169, 170, 
+	166, 173, 165, 169, 174, 178, 187, 255, 
+	131, 132, 140, 169, 174, 255, 130, 132, 
+	128, 182, 187, 255, 173, 180, 182, 255, 
+	132, 155, 159, 161, 175, 128, 163, 165, 
+	128, 134, 136, 152, 155, 161, 163, 164, 
+	166, 170, 144, 150, 132, 138, 143, 187, 
+	191, 160, 128, 129, 132, 135, 133, 134, 
+	160, 255, 192, 255, 139, 168, 160, 128, 
+	129, 132, 135, 133, 134, 160, 255, 192, 
+	255, 144, 145, 150, 155, 157, 158, 128, 
+	191, 160, 172, 174, 191, 128, 133, 134, 
+	155, 157, 191, 157, 128, 191, 143, 128, 
+	191, 163, 181, 128, 191, 162, 128, 191, 
+	142, 128, 191, 132, 133, 134, 135, 160, 
+	128, 191, 128, 255, 128, 129, 130, 132, 
+	133, 134, 141, 156, 157, 158, 159, 160, 
+	162, 164, 168, 169, 170, 172, 173, 174, 
+	175, 176, 179, 183, 160, 255, 128, 129, 
+	130, 133, 134, 135, 141, 156, 157, 158, 
+	159, 160, 162, 164, 168, 169, 170, 172, 
+	173, 174, 175, 176, 179, 183, 160, 255, 
+	168, 255, 128, 129, 130, 134, 135, 141, 
+	156, 157, 158, 159, 160, 162, 164, 168, 
+	169, 170, 172, 173, 174, 175, 176, 179, 
+	183, 168, 255, 192, 255, 159, 139, 187, 
+	158, 159, 176, 255, 135, 138, 139, 187, 
+	188, 255, 168, 255, 153, 154, 155, 160, 
+	162, 163, 164, 165, 166, 167, 168, 169, 
+	170, 171, 175, 177, 178, 179, 180, 181, 
+	182, 184, 185, 186, 187, 188, 189, 191, 
+	176, 190, 192, 255, 135, 147, 160, 188, 
+	128, 156, 184, 129, 255, 128, 129, 130, 
+	133, 134, 141, 156, 157, 158, 159, 160, 
+	162, 164, 168, 169, 170, 172, 173, 174, 
+	175, 176, 179, 183, 158, 159, 135, 255, 
+	148, 176, 140, 168, 132, 160, 188, 152, 
+	180, 144, 172, 136, 164, 192, 255, 129, 
+	130, 131, 132, 133, 134, 136, 137, 138, 
+	139, 140, 141, 143, 144, 145, 146, 147, 
+	148, 150, 151, 152, 153, 154, 155, 157, 
+	158, 159, 160, 161, 162, 164, 165, 166, 
+	167, 168, 169, 171, 172, 173, 174, 175, 
+	176, 178, 179, 180, 181, 182, 183, 185, 
+	186, 187, 188, 189, 190, 128, 191, 129, 
+	130, 131, 132, 133, 134, 136, 137, 138, 
+	139, 140, 141, 143, 144, 145, 146, 147, 
+	148, 150, 151, 152, 153, 154, 155, 157, 
+	158, 159, 160, 161, 162, 164, 165, 166, 
+	167, 168, 169, 171, 172, 173, 174, 175, 
+	176, 178, 179, 180, 181, 182, 183, 185, 
+	186, 187, 188, 189, 190, 128, 191, 129, 
+	130, 131, 132, 133, 134, 136, 137, 138, 
+	139, 140, 141, 143, 144, 145, 146, 147, 
+	148, 150, 151, 152, 153, 154, 155, 157, 
+	158, 159, 128, 156, 160, 255, 136, 164, 
+	175, 176, 255, 128, 141, 143, 191, 128, 
+	129, 152, 155, 156, 130, 191, 140, 141, 
+	128, 138, 144, 167, 175, 191, 128, 159, 
+	176, 191, 157, 128, 191, 185, 128, 191, 
+	128, 137, 138, 141, 142, 191, 128, 191, 
+	165, 177, 178, 179, 180, 181, 182, 184, 
+	185, 186, 187, 188, 189, 191, 128, 175, 
+	176, 190, 192, 255, 128, 159, 160, 188, 
+	189, 191, 128, 156, 184, 129, 255, 148, 
+	176, 140, 168, 132, 160, 188, 152, 180, 
+	144, 172, 136, 164, 192, 255, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 161, 162, 164, 165, 166, 167, 
+	168, 169, 171, 172, 173, 174, 175, 176, 
+	178, 179, 180, 181, 182, 183, 185, 186, 
+	187, 188, 189, 190, 128, 191, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 161, 162, 164, 165, 166, 167, 
+	168, 169, 171, 172, 173, 174, 175, 176, 
+	178, 179, 180, 181, 182, 183, 185, 186, 
+	187, 188, 189, 190, 128, 191, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 128, 156, 160, 255, 136, 164, 175, 
+	176, 255, 135, 138, 139, 187, 188, 191, 
+	192, 255, 187, 191, 128, 190, 128, 190, 
+	188, 128, 175, 190, 191, 145, 155, 157, 
+	159, 128, 191, 130, 135, 128, 191, 189, 
+	128, 191, 128, 129, 130, 131, 132, 191, 
+	178, 128, 191, 128, 159, 164, 191, 133, 
+	128, 191, 128, 178, 187, 191, 135, 142, 
+	143, 145, 146, 149, 150, 153, 154, 155, 
+	164, 128, 191, 128, 165, 166, 191, 144, 
+	145, 150, 155, 157, 158, 159, 135, 166, 
+	191, 133, 128, 191, 128, 130, 131, 132, 
+	133, 137, 138, 139, 140, 191, 174, 188, 
+	128, 129, 130, 131, 132, 133, 134, 144, 
+	145, 165, 166, 169, 170, 175, 176, 184, 
+	185, 191, 128, 132, 170, 129, 135, 136, 
+	191, 181, 186, 128, 191, 144, 128, 148, 
+	149, 150, 151, 191, 128, 132, 133, 135, 
+	136, 138, 139, 143, 144, 191, 163, 128, 
+	179, 180, 182, 183, 191, 128, 129, 191, 
+	166, 176, 191, 128, 151, 152, 158, 159, 
+	178, 179, 185, 186, 187, 188, 190, 128, 
+	191, 160, 128, 191, 128, 129, 135, 132, 
+	134, 128, 175, 157, 128, 191, 143, 128, 
+	191, 163, 181, 128, 191, 162, 128, 191, 
+	142, 128, 191, 132, 133, 134, 135, 160, 
+	128, 191, 0, 127, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 167, 169, 171, 
+	173, 174, 175, 176, 177, 179, 180, 181, 
+	182, 183, 184, 185, 186, 187, 188, 189, 
+	190, 191, 166, 170, 172, 178, 150, 153, 
+	155, 163, 165, 167, 169, 173, 153, 155, 
+	148, 161, 163, 255, 189, 132, 185, 144, 
+	152, 161, 164, 255, 188, 129, 131, 190, 
+	255, 133, 134, 137, 138, 142, 150, 152, 
+	161, 164, 255, 131, 134, 137, 138, 142, 
+	144, 146, 175, 178, 180, 182, 255, 134, 
+	138, 142, 161, 164, 255, 188, 129, 131, 
+	190, 191, 128, 132, 135, 136, 139, 141, 
+	150, 151, 162, 163, 130, 190, 191, 151, 
+	128, 130, 134, 136, 138, 141, 128, 131, 
+	190, 255, 133, 137, 142, 148, 151, 161, 
+	164, 255, 128, 132, 134, 136, 138, 141, 
+	149, 150, 162, 163, 129, 131, 190, 255, 
+	133, 137, 142, 150, 152, 161, 164, 255, 
+	130, 131, 138, 150, 143, 148, 152, 159, 
+	178, 179, 177, 179, 186, 135, 142, 177, 
+	179, 185, 187, 188, 136, 141, 181, 183, 
+	185, 152, 153, 190, 191, 177, 191, 128, 
+	132, 134, 135, 141, 151, 153, 188, 134, 
+	128, 129, 130, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 173, 183, 185, 
+	190, 150, 153, 158, 160, 177, 180, 130, 
+	141, 157, 132, 134, 157, 159, 146, 148, 
+	178, 180, 146, 147, 178, 179, 180, 255, 
+	148, 156, 158, 255, 139, 141, 169, 133, 
+	134, 160, 171, 176, 187, 151, 155, 160, 
+	162, 191, 149, 158, 165, 188, 176, 190, 
+	128, 132, 180, 255, 133, 170, 180, 255, 
+	128, 130, 161, 173, 166, 179, 164, 183, 
+	173, 144, 146, 148, 168, 178, 180, 184, 
+	185, 128, 181, 187, 191, 128, 131, 179, 
+	181, 183, 140, 141, 128, 131, 157, 179, 
+	181, 183, 144, 176, 164, 175, 177, 191, 
+	160, 191, 128, 130, 170, 175, 153, 154, 
+	153, 154, 155, 160, 162, 163, 164, 165, 
+	166, 167, 168, 169, 170, 171, 175, 175, 
+	178, 180, 189, 158, 159, 176, 177, 130, 
+	134, 139, 163, 167, 128, 129, 180, 255, 
+	134, 159, 178, 255, 166, 173, 135, 147, 
+	128, 131, 179, 255, 129, 164, 166, 255, 
+	169, 182, 131, 188, 140, 141, 176, 178, 
+	180, 183, 184, 190, 191, 129, 171, 175, 
+	181, 182, 163, 170, 172, 173, 172, 184, 
+	190, 158, 128, 143, 160, 175, 144, 145, 
+	150, 155, 157, 158, 159, 135, 139, 141, 
+	168, 171, 189, 160, 182, 186, 191, 129, 
+	131, 133, 134, 140, 143, 184, 186, 165, 
+	166, 128, 129, 130, 132, 133, 134, 135, 
+	136, 139, 140, 141, 144, 145, 146, 147, 
+	150, 151, 152, 153, 154, 156, 176, 178, 
+	128, 130, 184, 255, 135, 190, 131, 175, 
+	187, 255, 128, 130, 167, 180, 179, 128, 
+	130, 179, 255, 129, 137, 141, 255, 190, 
+	172, 183, 159, 170, 188, 128, 131, 190, 
+	191, 151, 128, 132, 135, 136, 139, 141, 
+	162, 163, 166, 172, 176, 180, 181, 191, 
+	128, 134, 176, 255, 132, 255, 175, 181, 
+	184, 255, 129, 155, 158, 255, 129, 255, 
+	171, 183, 157, 171, 175, 182, 184, 191, 
+	146, 167, 169, 182, 171, 172, 189, 190, 
+	176, 180, 176, 182, 145, 190, 143, 146, 
+	178, 157, 158, 133, 134, 137, 168, 169, 
+	170, 165, 169, 173, 178, 187, 255, 131, 
+	132, 140, 169, 174, 255, 130, 132, 128, 
+	182, 187, 255, 173, 180, 182, 255, 132, 
+	155, 159, 161, 175, 128, 163, 165, 128, 
+	134, 136, 152, 155, 161, 163, 164, 166, 
+	170, 144, 150, 132, 138, 145, 146, 151, 
+	166, 169, 128, 255, 176, 255, 131, 137, 
+	191, 145, 189, 135, 129, 130, 132, 133, 
+	144, 154, 176, 139, 159, 150, 156, 159, 
+	164, 167, 168, 170, 173, 145, 176, 255, 
+	139, 255, 166, 176, 171, 179, 160, 161, 
+	163, 164, 165, 166, 167, 169, 171, 172, 
+	173, 174, 175, 176, 177, 178, 179, 180, 
+	181, 182, 183, 184, 185, 186, 187, 188, 
+	189, 190, 191, 168, 170, 150, 153, 155, 
+	163, 165, 167, 169, 173, 153, 155, 148, 
+	161, 163, 255, 131, 187, 189, 132, 185, 
+	190, 255, 141, 144, 129, 136, 145, 151, 
+	152, 161, 162, 163, 164, 255, 129, 188, 
+	190, 130, 131, 191, 255, 141, 151, 129, 
+	132, 133, 134, 137, 138, 142, 161, 162, 
+	163, 164, 255, 131, 188, 129, 130, 190, 
+	255, 145, 181, 129, 130, 131, 134, 135, 
+	136, 137, 138, 139, 141, 142, 175, 176, 
+	177, 178, 255, 134, 138, 141, 129, 136, 
+	142, 161, 162, 163, 164, 255, 129, 188, 
+	130, 131, 190, 191, 128, 141, 129, 132, 
+	135, 136, 139, 140, 150, 151, 162, 163, 
+	130, 190, 191, 128, 141, 151, 129, 130, 
+	134, 136, 138, 140, 128, 129, 131, 190, 
+	255, 133, 137, 129, 132, 142, 148, 151, 
+	161, 164, 255, 129, 188, 190, 191, 130, 
+	131, 130, 134, 128, 132, 135, 136, 138, 
+	139, 140, 141, 149, 150, 162, 163, 129, 
+	190, 130, 131, 191, 255, 133, 137, 141, 
+	151, 129, 132, 142, 161, 162, 163, 164, 
+	255, 138, 143, 150, 159, 144, 145, 146, 
+	148, 152, 158, 178, 179, 177, 179, 180, 
+	186, 135, 142, 177, 179, 180, 185, 187, 
+	188, 136, 141, 181, 183, 185, 152, 153, 
+	190, 191, 191, 177, 190, 128, 132, 134, 
+	135, 141, 151, 153, 188, 134, 128, 129, 
+	130, 141, 156, 157, 158, 159, 160, 162, 
+	164, 168, 169, 170, 172, 173, 174, 175, 
+	176, 179, 183, 177, 173, 183, 185, 186, 
+	187, 188, 189, 190, 150, 151, 152, 153, 
+	158, 160, 177, 180, 130, 132, 141, 157, 
+	133, 134, 157, 159, 146, 148, 178, 180, 
+	146, 147, 178, 179, 182, 180, 189, 190, 
+	255, 134, 157, 137, 147, 148, 255, 139, 
+	141, 169, 133, 134, 178, 160, 162, 163, 
+	166, 167, 168, 169, 171, 176, 184, 185, 
+	187, 155, 151, 152, 153, 154, 150, 160, 
+	162, 191, 149, 151, 152, 158, 165, 172, 
+	173, 178, 179, 188, 176, 190, 132, 181, 
+	187, 128, 131, 180, 188, 189, 255, 130, 
+	133, 170, 171, 179, 180, 255, 130, 161, 
+	170, 128, 129, 162, 165, 166, 167, 168, 
+	173, 167, 173, 166, 169, 170, 174, 175, 
+	177, 178, 179, 164, 171, 172, 179, 180, 
+	181, 182, 183, 161, 173, 180, 144, 146, 
+	148, 168, 178, 179, 184, 185, 128, 181, 
+	187, 191, 128, 131, 179, 181, 183, 140, 
+	141, 144, 176, 175, 177, 191, 160, 191, 
+	128, 130, 170, 175, 153, 154, 153, 154, 
+	155, 160, 162, 163, 164, 165, 166, 167, 
+	168, 169, 170, 171, 175, 175, 178, 180, 
+	189, 158, 159, 176, 177, 130, 134, 139, 
+	167, 163, 164, 165, 166, 132, 133, 134, 
+	159, 160, 177, 178, 255, 166, 173, 135, 
+	145, 146, 147, 131, 179, 188, 128, 130, 
+	180, 181, 182, 185, 186, 255, 165, 129, 
+	255, 169, 174, 175, 176, 177, 178, 179, 
+	180, 181, 182, 131, 140, 141, 188, 176, 
+	178, 180, 183, 184, 190, 191, 129, 171, 
+	181, 182, 172, 173, 174, 175, 165, 168, 
+	172, 173, 163, 170, 172, 184, 190, 158, 
+	128, 143, 160, 175, 144, 145, 150, 155, 
+	157, 158, 159, 135, 139, 141, 168, 171, 
+	189, 160, 182, 186, 191, 129, 131, 133, 
+	134, 140, 143, 184, 186, 165, 166, 128, 
+	129, 130, 132, 133, 134, 135, 136, 139, 
+	140, 141, 144, 145, 146, 147, 150, 151, 
+	152, 153, 154, 156, 176, 178, 129, 128, 
+	130, 184, 255, 135, 190, 130, 131, 175, 
+	176, 178, 183, 184, 187, 255, 172, 128, 
+	130, 167, 180, 179, 130, 128, 129, 179, 
+	181, 182, 190, 191, 255, 129, 137, 138, 
+	140, 141, 255, 180, 190, 172, 174, 175, 
+	177, 178, 181, 182, 183, 159, 160, 162, 
+	163, 170, 188, 190, 191, 128, 129, 130, 
+	131, 128, 151, 129, 132, 135, 136, 139, 
+	141, 162, 163, 166, 172, 176, 180, 181, 
+	183, 184, 191, 133, 128, 129, 130, 134, 
+	176, 185, 189, 177, 178, 179, 186, 187, 
+	190, 191, 255, 129, 132, 255, 175, 190, 
+	176, 177, 178, 181, 184, 187, 188, 255, 
+	129, 155, 158, 255, 189, 176, 178, 179, 
+	186, 187, 190, 191, 255, 129, 255, 172, 
+	182, 171, 173, 174, 175, 176, 183, 166, 
+	157, 159, 160, 161, 162, 171, 175, 190, 
+	176, 182, 184, 191, 169, 177, 180, 146, 
+	167, 170, 182, 171, 172, 189, 190, 176, 
+	180, 176, 182, 143, 146, 178, 157, 158, 
+	133, 134, 137, 168, 169, 170, 166, 173, 
+	165, 169, 174, 178, 187, 255, 131, 132, 
+	140, 169, 174, 255, 130, 132, 128, 182, 
+	187, 255, 173, 180, 182, 255, 132, 155, 
+	159, 161, 175, 128, 163, 165, 128, 134, 
+	136, 152, 155, 161, 163, 164, 166, 170, 
+	144, 150, 132, 138, 143, 187, 191, 160, 
+	128, 129, 132, 135, 133, 134, 160, 255, 
+	192, 255, 139, 168, 160, 128, 129, 132, 
+	135, 133, 134, 160, 255, 192, 255, 144, 
+	145, 150, 155, 157, 158, 128, 129, 130, 
+	132, 133, 134, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 160, 255, 128, 
+	129, 130, 133, 134, 135, 141, 156, 157, 
+	158, 159, 160, 162, 164, 168, 169, 170, 
+	172, 173, 174, 175, 176, 179, 183, 160, 
+	255, 168, 255, 128, 129, 130, 134, 135, 
+	141, 156, 157, 158, 159, 160, 162, 164, 
+	168, 169, 170, 172, 173, 174, 175, 176, 
+	179, 183, 168, 255, 192, 255, 159, 139, 
+	187, 158, 159, 176, 255, 135, 138, 139, 
+	187, 188, 255, 168, 255, 153, 154, 155, 
+	160, 162, 163, 164, 165, 166, 167, 168, 
+	169, 170, 171, 175, 177, 178, 179, 180, 
+	181, 182, 184, 185, 186, 187, 188, 189, 
+	191, 176, 190, 192, 255, 135, 147, 160, 
+	188, 128, 156, 184, 129, 255, 128, 129, 
+	130, 133, 134, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 158, 159, 135, 
+	255, 148, 176, 140, 168, 132, 160, 188, 
+	152, 180, 144, 172, 136, 164, 192, 255, 
+	129, 130, 131, 132, 133, 134, 136, 137, 
+	138, 139, 140, 141, 143, 144, 145, 146, 
+	147, 148, 150, 151, 152, 153, 154, 155, 
+	157, 158, 159, 160, 161, 162, 164, 165, 
+	166, 167, 168, 169, 171, 172, 173, 174, 
+	175, 176, 178, 179, 180, 181, 182, 183, 
+	185, 186, 187, 188, 189, 190, 128, 191, 
+	129, 130, 131, 132, 133, 134, 136, 137, 
+	138, 139, 140, 141, 143, 144, 145, 146, 
+	147, 148, 150, 151, 152, 153, 154, 155, 
+	157, 158, 159, 160, 161, 162, 164, 165, 
+	166, 167, 168, 169, 171, 172, 173, 174, 
+	175, 176, 178, 179, 180, 181, 182, 183, 
+	185, 186, 187, 188, 189, 190, 128, 191, 
+	129, 130, 131, 132, 133, 134, 136, 137, 
+	138, 139, 140, 141, 143, 144, 145, 146, 
+	147, 148, 150, 151, 152, 153, 154, 155, 
+	157, 158, 159, 128, 156, 160, 255, 136, 
+	164, 175, 176, 255, 142, 128, 191, 128, 
+	129, 152, 155, 156, 130, 191, 139, 141, 
+	128, 140, 142, 143, 144, 167, 168, 174, 
+	175, 191, 128, 255, 176, 255, 131, 137, 
+	191, 145, 189, 135, 129, 130, 132, 133, 
+	144, 154, 176, 139, 159, 150, 156, 159, 
+	164, 167, 168, 170, 173, 145, 176, 255, 
+	139, 255, 166, 176, 171, 179, 160, 161, 
+	163, 164, 165, 167, 169, 171, 173, 174, 
+	175, 176, 177, 179, 180, 181, 182, 183, 
+	184, 185, 186, 187, 188, 189, 190, 191, 
+	166, 170, 172, 178, 150, 153, 155, 163, 
+	165, 167, 169, 173, 153, 155, 148, 161, 
+	163, 255, 189, 132, 185, 144, 152, 161, 
+	164, 255, 188, 129, 131, 190, 255, 133, 
+	134, 137, 138, 142, 150, 152, 161, 164, 
+	255, 131, 134, 137, 138, 142, 144, 146, 
+	175, 178, 180, 182, 255, 134, 138, 142, 
+	161, 164, 255, 188, 129, 131, 190, 191, 
+	128, 132, 135, 136, 139, 141, 150, 151, 
+	162, 163, 130, 190, 191, 151, 128, 130, 
+	134, 136, 138, 141, 128, 131, 190, 255, 
+	133, 137, 142, 148, 151, 161, 164, 255, 
+	128, 132, 134, 136, 138, 141, 149, 150, 
+	162, 163, 129, 131, 190, 255, 133, 137, 
+	142, 150, 152, 161, 164, 255, 130, 131, 
+	138, 150, 143, 148, 152, 159, 178, 179, 
+	177, 179, 186, 135, 142, 177, 179, 185, 
+	187, 188, 136, 141, 181, 183, 185, 152, 
+	153, 190, 191, 177, 191, 128, 132, 134, 
+	135, 141, 151, 153, 188, 134, 128, 129, 
+	130, 141, 156, 157, 158, 159, 160, 162, 
+	164, 168, 169, 170, 172, 173, 174, 175, 
+	176, 179, 183, 173, 183, 185, 190, 150, 
+	153, 158, 160, 177, 180, 130, 141, 157, 
+	132, 134, 157, 159, 146, 148, 178, 180, 
+	146, 147, 178, 179, 180, 255, 148, 156, 
+	158, 255, 139, 141, 169, 133, 134, 160, 
+	171, 176, 187, 151, 155, 160, 162, 191, 
+	149, 158, 165, 188, 176, 190, 128, 132, 
+	180, 255, 133, 170, 180, 255, 128, 130, 
+	161, 173, 166, 179, 164, 183, 173, 144, 
+	146, 148, 168, 178, 180, 184, 185, 128, 
+	181, 187, 191, 128, 131, 179, 181, 183, 
+	140, 141, 144, 176, 175, 177, 191, 160, 
+	191, 128, 130, 170, 175, 153, 154, 153, 
+	154, 155, 160, 162, 163, 164, 165, 166, 
+	167, 168, 169, 170, 171, 175, 175, 178, 
+	180, 189, 158, 159, 176, 177, 130, 134, 
+	139, 163, 167, 128, 129, 180, 255, 134, 
+	159, 178, 255, 166, 173, 135, 147, 128, 
+	131, 179, 255, 129, 164, 166, 255, 169, 
+	182, 131, 188, 140, 141, 176, 178, 180, 
+	183, 184, 190, 191, 129, 171, 175, 181, 
+	182, 163, 170, 172, 173, 172, 184, 190, 
+	158, 128, 143, 160, 175, 144, 145, 150, 
+	155, 157, 158, 135, 139, 141, 168, 171, 
+	189, 160, 182, 186, 191, 129, 131, 133, 
+	134, 140, 143, 184, 186, 165, 166, 128, 
+	129, 130, 132, 133, 134, 135, 136, 139, 
+	140, 141, 144, 145, 146, 147, 150, 151, 
+	152, 153, 154, 156, 176, 178, 128, 130, 
+	184, 255, 135, 190, 131, 175, 187, 255, 
+	128, 130, 167, 180, 179, 128, 130, 179, 
+	255, 129, 137, 141, 255, 190, 172, 183, 
+	159, 170, 188, 128, 131, 190, 191, 151, 
+	128, 132, 135, 136, 139, 141, 162, 163, 
+	166, 172, 176, 180, 181, 191, 128, 134, 
+	176, 255, 132, 255, 175, 181, 184, 255, 
+	129, 155, 158, 255, 129, 255, 171, 183, 
+	157, 171, 175, 182, 184, 191, 146, 167, 
+	169, 182, 171, 172, 189, 190, 176, 180, 
+	176, 182, 145, 190, 143, 146, 178, 157, 
+	158, 133, 134, 137, 168, 169, 170, 165, 
+	169, 173, 178, 187, 255, 131, 132, 140, 
+	169, 174, 255, 130, 132, 128, 182, 187, 
+	255, 173, 180, 182, 255, 132, 155, 159, 
+	161, 175, 128, 163, 165, 128, 134, 136, 
+	152, 155, 161, 163, 164, 166, 170, 144, 
+	150, 132, 138, 160, 128, 129, 132, 135, 
+	133, 134, 160, 255, 192, 255, 128, 131, 
+	157, 179, 181, 183, 164, 144, 145, 150, 
+	155, 157, 158, 159, 145, 146, 151, 166, 
+	169, 128, 255, 176, 255, 131, 137, 191, 
+	145, 189, 135, 129, 130, 132, 133, 144, 
+	154, 176, 139, 159, 150, 156, 159, 164, 
+	167, 168, 170, 173, 145, 176, 255, 139, 
+	255, 166, 176, 171, 179, 160, 161, 163, 
+	164, 165, 166, 167, 169, 171, 172, 173, 
+	174, 175, 176, 177, 178, 179, 180, 181, 
+	182, 183, 184, 185, 186, 187, 188, 189, 
+	190, 191, 168, 170, 150, 153, 155, 163, 
+	165, 167, 169, 173, 153, 155, 148, 161, 
+	163, 255, 131, 187, 189, 132, 185, 190, 
+	255, 141, 144, 129, 136, 145, 151, 152, 
+	161, 162, 163, 164, 255, 129, 188, 190, 
+	130, 131, 191, 255, 141, 151, 129, 132, 
+	133, 134, 137, 138, 142, 161, 162, 163, 
+	164, 255, 131, 188, 129, 130, 190, 255, 
+	145, 181, 129, 130, 131, 134, 135, 136, 
+	137, 138, 139, 141, 142, 175, 176, 177, 
+	178, 255, 134, 138, 141, 129, 136, 142, 
+	161, 162, 163, 164, 255, 129, 188, 130, 
+	131, 190, 191, 128, 141, 129, 132, 135, 
+	136, 139, 140, 150, 151, 162, 163, 130, 
+	190, 191, 128, 141, 151, 129, 130, 134, 
+	136, 138, 140, 128, 129, 131, 190, 255, 
+	133, 137, 129, 132, 142, 148, 151, 161, 
+	164, 255, 129, 188, 190, 191, 130, 131, 
+	130, 134, 128, 132, 135, 136, 138, 139, 
+	140, 141, 149, 150, 162, 163, 129, 190, 
+	130, 131, 191, 255, 133, 137, 141, 151, 
+	129, 132, 142, 161, 162, 163, 164, 255, 
+	138, 143, 150, 159, 144, 145, 146, 148, 
+	152, 158, 178, 179, 177, 179, 180, 186, 
+	135, 142, 177, 179, 180, 185, 187, 188, 
+	136, 141, 181, 183, 185, 152, 153, 190, 
+	191, 191, 177, 190, 128, 132, 134, 135, 
+	141, 151, 153, 188, 134, 128, 129, 130, 
+	141, 156, 157, 158, 159, 160, 162, 164, 
+	168, 169, 170, 172, 173, 174, 175, 176, 
+	179, 183, 177, 173, 183, 185, 186, 187, 
+	188, 189, 190, 150, 151, 152, 153, 158, 
+	160, 177, 180, 130, 132, 141, 157, 133, 
+	134, 157, 159, 146, 148, 178, 180, 146, 
+	147, 178, 179, 182, 180, 189, 190, 255, 
+	134, 157, 137, 147, 148, 255, 139, 141, 
+	169, 133, 134, 178, 160, 162, 163, 166, 
+	167, 168, 169, 171, 176, 184, 185, 187, 
+	155, 151, 152, 153, 154, 150, 160, 162, 
+	191, 149, 151, 152, 158, 165, 172, 173, 
+	178, 179, 188, 176, 190, 132, 181, 187, 
+	128, 131, 180, 188, 189, 255, 130, 133, 
+	170, 171, 179, 180, 255, 130, 161, 170, 
+	128, 129, 162, 165, 166, 167, 168, 173, 
+	167, 173, 166, 169, 170, 174, 175, 177, 
+	178, 179, 164, 171, 172, 179, 180, 181, 
+	182, 183, 161, 173, 180, 144, 146, 148, 
+	168, 178, 179, 184, 185, 128, 181, 187, 
+	191, 128, 131, 179, 181, 183, 140, 141, 
+	144, 176, 175, 177, 191, 160, 191, 128, 
+	130, 170, 175, 153, 154, 153, 154, 155, 
+	160, 162, 163, 164, 165, 166, 167, 168, 
+	169, 170, 171, 175, 175, 178, 180, 189, 
+	158, 159, 176, 177, 130, 134, 139, 167, 
+	163, 164, 165, 166, 132, 133, 134, 159, 
+	160, 177, 178, 255, 166, 173, 135, 145, 
+	146, 147, 131, 179, 188, 128, 130, 180, 
+	181, 182, 185, 186, 255, 165, 129, 255, 
+	169, 174, 175, 176, 177, 178, 179, 180, 
+	181, 182, 131, 140, 141, 188, 176, 178, 
+	180, 183, 184, 190, 191, 129, 171, 181, 
+	182, 172, 173, 174, 175, 165, 168, 172, 
+	173, 163, 170, 172, 184, 190, 158, 128, 
+	143, 160, 175, 144, 145, 150, 155, 157, 
+	158, 159, 135, 139, 141, 168, 171, 189, 
+	160, 182, 186, 191, 129, 131, 133, 134, 
+	140, 143, 184, 186, 165, 166, 128, 129, 
+	130, 132, 133, 134, 135, 136, 139, 140, 
+	141, 144, 145, 146, 147, 150, 151, 152, 
+	153, 154, 156, 176, 178, 129, 128, 130, 
+	184, 255, 135, 190, 130, 131, 175, 176, 
+	178, 183, 184, 187, 255, 172, 128, 130, 
+	167, 180, 179, 130, 128, 129, 179, 181, 
+	182, 190, 191, 255, 129, 137, 138, 140, 
+	141, 255, 180, 190, 172, 174, 175, 177, 
+	178, 181, 182, 183, 159, 160, 162, 163, 
+	170, 188, 190, 191, 128, 129, 130, 131, 
+	128, 151, 129, 132, 135, 136, 139, 141, 
+	162, 163, 166, 172, 176, 180, 181, 183, 
+	184, 191, 133, 128, 129, 130, 134, 176, 
+	185, 189, 177, 178, 179, 186, 187, 190, 
+	191, 255, 129, 132, 255, 175, 190, 176, 
+	177, 178, 181, 184, 187, 188, 255, 129, 
+	155, 158, 255, 189, 176, 178, 179, 186, 
+	187, 190, 191, 255, 129, 255, 172, 182, 
+	171, 173, 174, 175, 176, 183, 166, 157, 
+	159, 160, 161, 162, 171, 175, 190, 176, 
+	182, 184, 191, 169, 177, 180, 146, 167, 
+	170, 182, 171, 172, 189, 190, 176, 180, 
+	176, 182, 143, 146, 178, 157, 158, 133, 
+	134, 137, 168, 169, 170, 166, 173, 165, 
+	169, 174, 178, 187, 255, 131, 132, 140, 
+	169, 174, 255, 130, 132, 128, 182, 187, 
+	255, 173, 180, 182, 255, 132, 155, 159, 
+	161, 175, 128, 163, 165, 128, 134, 136, 
+	152, 155, 161, 163, 164, 166, 170, 144, 
+	150, 132, 138, 143, 187, 191, 160, 128, 
+	129, 132, 135, 133, 134, 160, 255, 192, 
+	255, 139, 168, 128, 159, 160, 175, 176, 
+	191, 157, 128, 191, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 166, 167, 169, 
+	171, 172, 173, 174, 175, 176, 177, 178, 
+	179, 180, 181, 182, 183, 184, 185, 186, 
+	187, 188, 189, 190, 191, 168, 170, 150, 
+	153, 155, 163, 165, 167, 169, 173, 153, 
+	155, 148, 161, 163, 255, 131, 187, 189, 
+	132, 185, 190, 255, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 167, 169, 171, 
+	173, 174, 175, 176, 177, 179, 180, 181, 
+	182, 183, 184, 185, 186, 187, 188, 189, 
+	190, 191, 166, 170, 172, 178, 150, 153, 
+	155, 163, 165, 167, 169, 173, 153, 155, 
+	148, 161, 163, 255, 189, 132, 185, 144, 
+	152, 161, 164, 255, 188, 129, 131, 190, 
+	255, 133, 134, 137, 138, 142, 150, 152, 
+	161, 164, 255, 131, 134, 137, 138, 142, 
+	144, 146, 175, 178, 180, 182, 255, 134, 
+	138, 142, 161, 164, 255, 188, 129, 131, 
+	190, 191, 128, 132, 135, 136, 139, 141, 
+	150, 151, 162, 163, 130, 190, 191, 151, 
+	128, 130, 134, 136, 138, 141, 128, 131, 
+	190, 255, 133, 137, 142, 148, 151, 161, 
+	164, 255, 128, 132, 134, 136, 138, 141, 
+	149, 150, 162, 163, 129, 131, 190, 255, 
+	133, 137, 142, 150, 152, 161, 164, 255, 
+	130, 131, 138, 150, 143, 148, 152, 159, 
+	178, 179, 177, 179, 186, 135, 142, 177, 
+	179, 185, 187, 188, 136, 141, 181, 183, 
+	185, 152, 153, 190, 191, 177, 191, 128, 
+	132, 134, 135, 141, 151, 153, 188, 134, 
+	128, 129, 130, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 173, 183, 185, 
+	190, 150, 153, 158, 160, 177, 180, 130, 
+	141, 157, 132, 134, 157, 159, 146, 148, 
+	178, 180, 146, 147, 178, 179, 180, 255, 
+	148, 156, 158, 255, 139, 141, 169, 133, 
+	134, 160, 171, 176, 187, 151, 155, 160, 
+	162, 191, 149, 158, 165, 188, 176, 190, 
+	128, 132, 180, 255, 133, 170, 180, 255, 
+	128, 130, 161, 173, 166, 179, 164, 183, 
+	173, 144, 146, 148, 168, 178, 180, 184, 
+	185, 128, 181, 187, 191, 128, 131, 179, 
+	181, 183, 140, 141, 128, 131, 157, 179, 
+	181, 183, 144, 176, 164, 175, 177, 191, 
+	160, 191, 128, 130, 170, 175, 153, 154, 
+	153, 154, 155, 160, 162, 163, 164, 165, 
+	166, 167, 168, 169, 170, 171, 175, 175, 
+	178, 180, 189, 158, 159, 176, 177, 130, 
+	134, 139, 163, 167, 128, 129, 180, 255, 
+	134, 159, 178, 255, 166, 173, 135, 147, 
+	128, 131, 179, 255, 129, 164, 166, 255, 
+	169, 182, 131, 188, 140, 141, 176, 178, 
+	180, 183, 184, 190, 191, 129, 171, 175, 
+	181, 182, 163, 170, 172, 173, 172, 184, 
+	190, 158, 128, 143, 160, 175, 144, 145, 
+	150, 155, 157, 158, 159, 135, 139, 141, 
+	168, 171, 189, 160, 182, 186, 191, 129, 
+	131, 133, 134, 140, 143, 184, 186, 165, 
+	166, 128, 129, 130, 132, 133, 134, 135, 
+	136, 139, 140, 141, 144, 145, 146, 147, 
+	150, 151, 152, 153, 154, 156, 176, 178, 
+	128, 130, 184, 255, 135, 190, 131, 175, 
+	187, 255, 128, 130, 167, 180, 179, 128, 
+	130, 179, 255, 129, 137, 141, 255, 190, 
+	172, 183, 159, 170, 188, 128, 131, 190, 
+	191, 151, 128, 132, 135, 136, 139, 141, 
+	162, 163, 166, 172, 176, 180, 181, 191, 
+	128, 134, 176, 255, 132, 255, 175, 181, 
+	184, 255, 129, 155, 158, 255, 129, 255, 
+	171, 183, 157, 171, 175, 182, 184, 191, 
+	146, 167, 169, 182, 171, 172, 189, 190, 
+	176, 180, 176, 182, 145, 190, 143, 146, 
+	178, 157, 158, 133, 134, 137, 168, 169, 
+	170, 165, 169, 173, 178, 187, 255, 131, 
+	132, 140, 169, 174, 255, 130, 132, 128, 
+	182, 187, 255, 173, 180, 182, 255, 132, 
+	155, 159, 161, 175, 128, 163, 165, 128, 
+	134, 136, 152, 155, 161, 163, 164, 166, 
+	170, 144, 150, 132, 138, 145, 146, 151, 
+	166, 169, 139, 168, 160, 128, 129, 132, 
+	135, 133, 134, 160, 255, 192, 255, 144, 
+	145, 150, 155, 157, 158, 141, 144, 129, 
+	136, 145, 151, 152, 161, 162, 163, 164, 
+	255, 129, 188, 190, 130, 131, 191, 255, 
+	141, 151, 129, 132, 133, 134, 137, 138, 
+	142, 161, 162, 163, 164, 255, 131, 188, 
+	129, 130, 190, 255, 145, 181, 129, 130, 
+	131, 134, 135, 136, 137, 138, 139, 141, 
+	142, 175, 176, 177, 178, 255, 134, 138, 
+	141, 129, 136, 142, 161, 162, 163, 164, 
+	255, 129, 188, 130, 131, 190, 191, 128, 
+	141, 129, 132, 135, 136, 139, 140, 150, 
+	151, 162, 163, 130, 190, 191, 128, 141, 
+	151, 129, 130, 134, 136, 138, 140, 128, 
+	129, 131, 190, 255, 133, 137, 129, 132, 
+	142, 148, 151, 161, 164, 255, 129, 188, 
+	190, 191, 130, 131, 130, 134, 128, 132, 
+	135, 136, 138, 139, 140, 141, 149, 150, 
+	162, 163, 129, 190, 130, 131, 191, 255, 
+	133, 137, 141, 151, 129, 132, 142, 161, 
+	162, 163, 164, 255, 138, 143, 150, 159, 
+	144, 145, 146, 148, 152, 158, 178, 179, 
+	177, 179, 180, 186, 135, 142, 177, 179, 
+	180, 185, 187, 188, 136, 141, 181, 183, 
+	185, 152, 153, 190, 191, 191, 177, 190, 
+	128, 132, 134, 135, 141, 151, 153, 188, 
+	134, 128, 129, 130, 141, 156, 157, 158, 
+	159, 160, 162, 164, 168, 169, 170, 172, 
+	173, 174, 175, 176, 179, 183, 177, 173, 
+	183, 185, 186, 187, 188, 189, 190, 150, 
+	151, 152, 153, 158, 160, 177, 180, 130, 
+	132, 141, 157, 133, 134, 157, 159, 146, 
+	148, 178, 180, 146, 147, 178, 179, 182, 
+	180, 189, 190, 255, 134, 157, 137, 147, 
+	148, 255, 139, 141, 169, 133, 134, 178, 
+	160, 162, 163, 166, 167, 168, 169, 171, 
+	176, 184, 185, 187, 155, 151, 152, 153, 
+	154, 150, 160, 162, 191, 149, 151, 152, 
+	158, 165, 172, 173, 178, 179, 188, 176, 
+	190, 132, 181, 187, 128, 131, 180, 188, 
+	189, 255, 130, 133, 170, 171, 179, 180, 
+	255, 130, 161, 170, 128, 129, 162, 165, 
+	166, 167, 168, 173, 167, 173, 166, 169, 
+	170, 174, 175, 177, 178, 179, 164, 171, 
+	172, 179, 180, 181, 182, 183, 161, 173, 
+	180, 144, 146, 148, 168, 178, 179, 184, 
+	185, 128, 181, 187, 191, 128, 131, 179, 
+	181, 183, 140, 141, 144, 176, 175, 177, 
+	191, 160, 191, 128, 130, 170, 175, 153, 
+	154, 153, 154, 155, 160, 162, 163, 164, 
+	165, 166, 167, 168, 169, 170, 171, 175, 
+	175, 178, 180, 189, 158, 159, 176, 177, 
+	130, 134, 139, 167, 163, 164, 165, 166, 
+	132, 133, 134, 159, 160, 177, 178, 255, 
+	166, 173, 135, 145, 146, 147, 131, 179, 
+	188, 128, 130, 180, 181, 182, 185, 186, 
+	255, 165, 129, 255, 169, 174, 175, 176, 
+	177, 178, 179, 180, 181, 182, 131, 140, 
+	141, 188, 176, 178, 180, 183, 184, 190, 
+	191, 129, 171, 181, 182, 172, 173, 174, 
+	175, 165, 168, 172, 173, 163, 170, 172, 
+	184, 190, 158, 128, 143, 160, 175, 144, 
+	145, 150, 155, 157, 158, 159, 135, 139, 
+	141, 168, 171, 189, 160, 182, 186, 191, 
+	129, 131, 133, 134, 140, 143, 184, 186, 
+	165, 166, 128, 129, 130, 132, 133, 134, 
+	135, 136, 139, 140, 141, 144, 145, 146, 
+	147, 150, 151, 152, 153, 154, 156, 176, 
+	178, 129, 128, 130, 184, 255, 135, 190, 
+	130, 131, 175, 176, 178, 183, 184, 187, 
+	255, 172, 128, 130, 167, 180, 179, 130, 
+	128, 129, 179, 181, 182, 190, 191, 255, 
+	129, 137, 138, 140, 141, 255, 180, 190, 
+	172, 174, 175, 177, 178, 181, 182, 183, 
+	159, 160, 162, 163, 170, 188, 190, 191, 
+	128, 129, 130, 131, 128, 151, 129, 132, 
+	135, 136, 139, 141, 162, 163, 166, 172, 
+	176, 180, 181, 183, 184, 191, 133, 128, 
+	129, 130, 134, 176, 185, 189, 177, 178, 
+	179, 186, 187, 190, 191, 255, 129, 132, 
+	255, 175, 190, 176, 177, 178, 181, 184, 
+	187, 188, 255, 129, 155, 158, 255, 189, 
+	176, 178, 179, 186, 187, 190, 191, 255, 
+	129, 255, 172, 182, 171, 173, 174, 175, 
+	176, 183, 166, 157, 159, 160, 161, 162, 
+	171, 175, 190, 176, 182, 184, 191, 169, 
+	177, 180, 146, 167, 170, 182, 171, 172, 
+	189, 190, 176, 180, 176, 182, 143, 146, 
+	178, 157, 158, 133, 134, 137, 168, 169, 
+	170, 166, 173, 165, 169, 174, 178, 187, 
+	255, 131, 132, 140, 169, 174, 255, 130, 
+	132, 128, 182, 187, 255, 173, 180, 182, 
+	255, 132, 155, 159, 161, 175, 128, 163, 
+	165, 128, 134, 136, 152, 155, 161, 163, 
+	164, 166, 170, 144, 150, 132, 138, 143, 
+	187, 191, 160, 128, 129, 132, 135, 133, 
+	134, 160, 255, 192, 255, 185, 128, 191, 
+	128, 137, 138, 141, 142, 191, 128, 191, 
+	165, 177, 178, 179, 180, 181, 182, 184, 
+	185, 186, 187, 188, 189, 191, 128, 175, 
+	176, 190, 192, 255, 128, 159, 160, 188, 
+	189, 191, 128, 156, 184, 129, 255, 148, 
+	176, 140, 168, 132, 160, 188, 152, 180, 
+	144, 172, 136, 164, 192, 255, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 161, 162, 164, 165, 166, 167, 
+	168, 169, 171, 172, 173, 174, 175, 176, 
+	178, 179, 180, 181, 182, 183, 185, 186, 
+	187, 188, 189, 190, 128, 191, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 161, 162, 164, 165, 166, 167, 
+	168, 169, 171, 172, 173, 174, 175, 176, 
+	178, 179, 180, 181, 182, 183, 185, 186, 
+	187, 188, 189, 190, 128, 191, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 191, 128, 156, 161, 190, 192, 
+	255, 136, 164, 175, 176, 255, 135, 138, 
+	139, 187, 188, 191, 192, 255, 0, 127, 
+	192, 255, 187, 191, 128, 190, 191, 128, 
+	190, 188, 128, 175, 176, 189, 190, 191, 
+	145, 155, 157, 159, 128, 191, 130, 135, 
+	128, 191, 189, 128, 191, 128, 129, 130, 
+	131, 132, 191, 178, 128, 191, 128, 159, 
+	160, 163, 164, 191, 133, 128, 191, 128, 
+	178, 179, 186, 187, 191, 135, 142, 143, 
+	145, 146, 149, 150, 153, 154, 155, 164, 
+	128, 191, 128, 165, 166, 191, 128, 255, 
+	176, 255, 131, 137, 191, 145, 189, 135, 
+	129, 130, 132, 133, 144, 154, 176, 139, 
+	159, 150, 156, 159, 164, 167, 168, 170, 
+	173, 145, 176, 255, 139, 255, 166, 176, 
+	171, 179, 160, 161, 163, 164, 165, 167, 
+	169, 171, 173, 174, 175, 176, 177, 179, 
+	180, 181, 182, 183, 184, 185, 186, 187, 
+	188, 189, 190, 191, 166, 170, 172, 178, 
+	150, 153, 155, 163, 165, 167, 169, 173, 
+	153, 155, 148, 161, 163, 255, 189, 132, 
+	185, 144, 152, 161, 164, 255, 188, 129, 
+	131, 190, 255, 133, 134, 137, 138, 142, 
+	150, 152, 161, 164, 255, 131, 134, 137, 
+	138, 142, 144, 146, 175, 178, 180, 182, 
+	255, 134, 138, 142, 161, 164, 255, 188, 
+	129, 131, 190, 191, 128, 132, 135, 136, 
+	139, 141, 150, 151, 162, 163, 130, 190, 
+	191, 151, 128, 130, 134, 136, 138, 141, 
+	128, 131, 190, 255, 133, 137, 142, 148, 
+	151, 161, 164, 255, 128, 132, 134, 136, 
+	138, 141, 149, 150, 162, 163, 129, 131, 
+	190, 255, 133, 137, 142, 150, 152, 161, 
+	164, 255, 130, 131, 138, 150, 143, 148, 
+	152, 159, 178, 179, 177, 179, 186, 135, 
+	142, 177, 179, 185, 187, 188, 136, 141, 
+	181, 183, 185, 152, 153, 190, 191, 177, 
+	191, 128, 132, 134, 135, 141, 151, 153, 
+	188, 134, 128, 129, 130, 141, 156, 157, 
+	158, 159, 160, 162, 164, 168, 169, 170, 
+	172, 173, 174, 175, 176, 179, 183, 173, 
+	183, 185, 190, 150, 153, 158, 160, 177, 
+	180, 130, 141, 157, 132, 134, 157, 159, 
+	146, 148, 178, 180, 146, 147, 178, 179, 
+	180, 255, 148, 156, 158, 255, 139, 141, 
+	169, 133, 134, 160, 171, 176, 187, 151, 
+	155, 160, 162, 191, 149, 158, 165, 188, 
+	176, 190, 128, 132, 180, 255, 133, 170, 
+	180, 255, 128, 130, 161, 173, 166, 179, 
+	164, 183, 173, 144, 146, 148, 168, 178, 
+	180, 184, 185, 128, 181, 187, 191, 128, 
+	131, 179, 181, 183, 140, 141, 128, 131, 
+	157, 179, 181, 183, 144, 176, 164, 175, 
+	177, 191, 160, 191, 128, 130, 170, 175, 
+	153, 154, 153, 154, 155, 160, 162, 163, 
+	164, 165, 166, 167, 168, 169, 170, 171, 
+	175, 175, 178, 180, 189, 158, 159, 176, 
+	177, 130, 134, 139, 163, 167, 128, 129, 
+	180, 255, 134, 159, 178, 255, 166, 173, 
+	135, 147, 128, 131, 179, 255, 129, 164, 
+	166, 255, 169, 182, 131, 188, 140, 141, 
+	176, 178, 180, 183, 184, 190, 191, 129, 
+	171, 175, 181, 182, 163, 170, 172, 173, 
+	172, 184, 190, 158, 128, 143, 160, 175, 
+	144, 145, 150, 155, 157, 158, 159, 135, 
+	139, 141, 168, 171, 189, 160, 182, 186, 
+	191, 129, 131, 133, 134, 140, 143, 184, 
+	186, 165, 166, 128, 129, 130, 132, 133, 
+	134, 135, 136, 139, 140, 141, 144, 145, 
+	146, 147, 150, 151, 152, 153, 154, 156, 
+	176, 178, 128, 130, 184, 255, 135, 190, 
+	131, 175, 187, 255, 128, 130, 167, 180, 
+	179, 128, 130, 179, 255, 129, 137, 141, 
+	255, 190, 172, 183, 159, 170, 188, 128, 
+	131, 190, 191, 151, 128, 132, 135, 136, 
+	139, 141, 162, 163, 166, 172, 176, 180, 
+	181, 191, 128, 134, 176, 255, 132, 255, 
+	175, 181, 184, 255, 129, 155, 158, 255, 
+	129, 255, 171, 183, 157, 171, 175, 182, 
+	184, 191, 146, 167, 169, 182, 171, 172, 
+	189, 190, 176, 180, 176, 182, 145, 190, 
+	143, 146, 178, 157, 158, 133, 134, 137, 
+	168, 169, 170, 165, 169, 173, 178, 187, 
+	255, 131, 132, 140, 169, 174, 255, 130, 
+	132, 128, 182, 187, 255, 173, 180, 182, 
+	255, 132, 155, 159, 161, 175, 128, 163, 
+	165, 128, 134, 136, 152, 155, 161, 163, 
+	164, 166, 170, 144, 150, 132, 138, 145, 
+	146, 151, 166, 169, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 166, 167, 169, 
+	171, 172, 173, 174, 175, 176, 177, 178, 
+	179, 180, 181, 182, 183, 184, 185, 186, 
+	187, 188, 189, 190, 191, 168, 170, 150, 
+	153, 155, 163, 165, 167, 169, 173, 153, 
+	155, 148, 161, 163, 255, 131, 187, 189, 
+	132, 185, 190, 255, 141, 144, 129, 136, 
+	145, 151, 152, 161, 162, 163, 164, 255, 
+	129, 188, 190, 130, 131, 191, 255, 141, 
+	151, 129, 132, 133, 134, 137, 138, 142, 
+	161, 162, 163, 164, 255, 131, 188, 129, 
+	130, 190, 255, 145, 181, 129, 130, 131, 
+	134, 135, 136, 137, 138, 139, 141, 142, 
+	175, 176, 177, 178, 255, 134, 138, 141, 
+	129, 136, 142, 161, 162, 163, 164, 255, 
+	129, 188, 130, 131, 190, 191, 128, 141, 
+	129, 132, 135, 136, 139, 140, 150, 151, 
+	162, 163, 130, 190, 191, 128, 141, 151, 
+	129, 130, 134, 136, 138, 140, 128, 129, 
+	131, 190, 255, 133, 137, 129, 132, 142, 
+	148, 151, 161, 164, 255, 129, 188, 190, 
+	191, 130, 131, 130, 134, 128, 132, 135, 
+	136, 138, 139, 140, 141, 149, 150, 162, 
+	163, 129, 190, 130, 131, 191, 255, 133, 
+	137, 141, 151, 129, 132, 142, 161, 162, 
+	163, 164, 255, 138, 143, 150, 159, 144, 
+	145, 146, 148, 152, 158, 178, 179, 177, 
+	179, 180, 186, 135, 142, 177, 179, 180, 
+	185, 187, 188, 136, 141, 181, 183, 185, 
+	152, 153, 190, 191, 191, 177, 190, 128, 
+	132, 134, 135, 141, 151, 153, 188, 134, 
+	128, 129, 130, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 177, 173, 183, 
+	185, 186, 187, 188, 189, 190, 150, 151, 
+	152, 153, 158, 160, 177, 180, 130, 132, 
+	141, 157, 133, 134, 157, 159, 146, 148, 
+	178, 180, 146, 147, 178, 179, 182, 180, 
+	189, 190, 255, 134, 157, 137, 147, 148, 
+	255, 139, 141, 169, 133, 134, 178, 160, 
+	162, 163, 166, 167, 168, 169, 171, 176, 
+	184, 185, 187, 155, 151, 152, 153, 154, 
+	150, 160, 162, 191, 149, 151, 152, 158, 
+	165, 172, 173, 178, 179, 188, 176, 190, 
+	132, 181, 187, 128, 131, 180, 188, 189, 
+	255, 130, 133, 170, 171, 179, 180, 255, 
+	130, 161, 170, 128, 129, 162, 165, 166, 
+	167, 168, 173, 167, 173, 166, 169, 170, 
+	174, 175, 177, 178, 179, 164, 171, 172, 
+	179, 180, 181, 182, 183, 161, 173, 180, 
+	144, 146, 148, 168, 178, 179, 184, 185, 
+	128, 181, 187, 191, 128, 131, 179, 181, 
+	183, 140, 141, 144, 176, 175, 177, 191, 
+	160, 191, 128, 130, 170, 175, 153, 154, 
+	153, 154, 155, 160, 162, 163, 164, 165, 
+	166, 167, 168, 169, 170, 171, 175, 175, 
+	178, 180, 189, 158, 159, 176, 177, 130, 
+	134, 139, 167, 163, 164, 165, 166, 132, 
+	133, 134, 159, 160, 177, 178, 255, 166, 
+	173, 135, 145, 146, 147, 131, 179, 188, 
+	128, 130, 180, 181, 182, 185, 186, 255, 
+	165, 129, 255, 169, 174, 175, 176, 177, 
+	178, 179, 180, 181, 182, 131, 140, 141, 
+	188, 176, 178, 180, 183, 184, 190, 191, 
+	129, 171, 181, 182, 172, 173, 174, 175, 
+	165, 168, 172, 173, 163, 170, 172, 184, 
+	190, 158, 128, 143, 160, 175, 144, 145, 
+	150, 155, 157, 158, 159, 135, 139, 141, 
+	168, 171, 189, 160, 182, 186, 191, 129, 
+	131, 133, 134, 140, 143, 184, 186, 165, 
+	166, 128, 129, 130, 132, 133, 134, 135, 
+	136, 139, 140, 141, 144, 145, 146, 147, 
+	150, 151, 152, 153, 154, 156, 176, 178, 
+	129, 128, 130, 184, 255, 135, 190, 130, 
+	131, 175, 176, 178, 183, 184, 187, 255, 
+	172, 128, 130, 167, 180, 179, 130, 128, 
+	129, 179, 181, 182, 190, 191, 255, 129, 
+	137, 138, 140, 141, 255, 180, 190, 172, 
+	174, 175, 177, 178, 181, 182, 183, 159, 
+	160, 162, 163, 170, 188, 190, 191, 128, 
+	129, 130, 131, 128, 151, 129, 132, 135, 
+	136, 139, 141, 162, 163, 166, 172, 176, 
+	180, 181, 183, 184, 191, 133, 128, 129, 
+	130, 134, 176, 185, 189, 177, 178, 179, 
+	186, 187, 190, 191, 255, 129, 132, 255, 
+	175, 190, 176, 177, 178, 181, 184, 187, 
+	188, 255, 129, 155, 158, 255, 189, 176, 
+	178, 179, 186, 187, 190, 191, 255, 129, 
+	255, 172, 182, 171, 173, 174, 175, 176, 
+	183, 166, 157, 159, 160, 161, 162, 171, 
+	175, 190, 176, 182, 184, 191, 169, 177, 
+	180, 146, 167, 170, 182, 171, 172, 189, 
+	190, 176, 180, 176, 182, 143, 146, 178, 
+	157, 158, 133, 134, 137, 168, 169, 170, 
+	166, 173, 165, 169, 174, 178, 187, 255, 
+	131, 132, 140, 169, 174, 255, 130, 132, 
+	128, 182, 187, 255, 173, 180, 182, 255, 
+	132, 155, 159, 161, 175, 128, 163, 165, 
+	128, 134, 136, 152, 155, 161, 163, 164, 
+	166, 170, 144, 150, 132, 138, 143, 187, 
+	191, 160, 128, 129, 132, 135, 133, 134, 
+	160, 255, 192, 255, 139, 168, 160, 128, 
+	129, 132, 135, 133, 134, 160, 255, 192, 
+	255, 144, 145, 150, 155, 157, 158, 144, 
+	145, 150, 155, 157, 158, 159, 135, 166, 
+	191, 133, 128, 191, 128, 130, 131, 132, 
+	133, 137, 138, 139, 140, 191, 174, 188, 
+	128, 129, 130, 131, 132, 133, 134, 144, 
+	145, 165, 166, 169, 170, 175, 176, 184, 
+	185, 191, 128, 132, 170, 129, 135, 136, 
+	191, 181, 186, 128, 191, 144, 128, 148, 
+	149, 150, 151, 191, 128, 132, 133, 135, 
+	136, 138, 139, 143, 144, 191, 163, 128, 
+	179, 180, 182, 183, 191, 128, 129, 191, 
+	166, 176, 191, 128, 151, 152, 158, 159, 
+	178, 179, 185, 186, 187, 188, 190, 128, 
+	191, 160, 128, 191, 128, 130, 131, 135, 
+	191, 129, 134, 136, 190, 128, 159, 160, 
+	191, 128, 175, 176, 255, 10, 13, 127, 
+	194, 216, 219, 220, 224, 225, 226, 234, 
+	235, 236, 237, 239, 240, 243, 0, 31, 
+	128, 191, 192, 223, 227, 238, 241, 247, 
+	248, 255, 204, 205, 210, 214, 215, 216, 
+	217, 219, 220, 221, 222, 223, 224, 225, 
+	226, 227, 234, 239, 240, 243, 204, 205, 
+	210, 214, 215, 216, 217, 219, 220, 221, 
+	222, 223, 224, 225, 226, 227, 234, 239, 
+	240, 243, 204, 205, 210, 214, 215, 216, 
+	217, 219, 220, 221, 222, 223, 224, 225, 
+	226, 227, 234, 239, 240, 243, 194, 216, 
+	219, 220, 224, 225, 226, 234, 235, 236, 
+	237, 239, 240, 243, 32, 126, 192, 223, 
+	227, 238, 241, 247, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 235, 236, 237, 239, 240, 243, 204, 
+	205, 210, 214, 215, 216, 217, 219, 220, 
+	221, 222, 223, 224, 225, 226, 227, 234, 
+	237, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 237, 239, 240, 
+	243, 204, 205, 210, 214, 215, 216, 217, 
+	219, 220, 221, 222, 223, 224, 225, 226, 
+	227, 234, 237, 239, 240, 243, 204, 205, 
+	210, 214, 215, 216, 217, 219, 220, 221, 
+	222, 223, 224, 225, 226, 227, 234, 239, 
+	240, 243, 204, 205, 210, 214, 215, 216, 
+	217, 219, 220, 221, 222, 223, 224, 225, 
+	226, 227, 234, 235, 236, 237, 239, 240, 
+	243, 204, 205, 210, 214, 215, 216, 217, 
+	219, 220, 221, 222, 223, 224, 225, 226, 
+	227, 234, 239, 240, 243, 204, 205, 210, 
+	214, 215, 216, 217, 219, 220, 221, 222, 
+	223, 224, 225, 226, 227, 234, 239, 240, 
+	243, 204, 205, 210, 214, 215, 216, 217, 
+	219, 220, 221, 222, 223, 224, 225, 226, 
+	227, 234, 239, 240, 243, 204, 205, 210, 
+	214, 215, 216, 217, 219, 220, 221, 222, 
+	223, 224, 225, 226, 227, 234, 237, 239, 
+	240, 243, 204, 205, 210, 214, 215, 216, 
+	217, 219, 220, 221, 222, 223, 224, 225, 
+	226, 227, 234, 237, 239, 240, 243, 204, 
+	205, 210, 214, 215, 216, 217, 219, 220, 
+	221, 222, 223, 224, 225, 226, 227, 234, 
+	237, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 
+}
+
+var _graphclust_single_lengths []byte = []byte{
+	0, 1, 0, 0, 0, 1, 1, 0, 
+	1, 0, 1, 0, 0, 0, 26, 0, 
+	0, 0, 1, 1, 1, 0, 0, 2, 
+	1, 0, 1, 1, 0, 2, 0, 0, 
+	2, 0, 2, 1, 0, 1, 0, 3, 
+	0, 0, 1, 21, 0, 0, 3, 0, 
+	0, 0, 0, 0, 0, 1, 0, 0, 
+	3, 0, 0, 0, 0, 0, 0, 1, 
+	0, 5, 2, 6, 0, 1, 0, 1, 
+	0, 2, 0, 0, 15, 0, 0, 0, 
+	3, 0, 0, 0, 0, 0, 0, 0, 
+	2, 1, 1, 0, 3, 1, 0, 7, 
+	5, 1, 1, 0, 1, 0, 23, 0, 
+	0, 0, 0, 1, 0, 0, 1, 0, 
+	1, 1, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 4, 0, 0, 
+	0, 0, 1, 0, 6, 0, 0, 0, 
+	0, 0, 1, 3, 0, 0, 0, 3, 
+	0, 0, 0, 0, 1, 1, 0, 1, 
+	0, 1, 0, 0, 0, 29, 0, 0, 
+	0, 3, 2, 3, 2, 2, 2, 3, 
+	2, 2, 3, 3, 1, 2, 4, 2, 
+	2, 4, 4, 2, 0, 2, 0, 3, 
+	1, 0, 1, 21, 1, 0, 4, 0, 
+	0, 0, 1, 2, 0, 1, 1, 1, 
+	4, 0, 3, 1, 3, 2, 0, 3, 
+	0, 5, 2, 0, 0, 1, 0, 2, 
+	0, 0, 15, 0, 0, 0, 4, 0, 
+	0, 0, 3, 1, 0, 4, 1, 4, 
+	4, 3, 1, 0, 7, 5, 1, 1, 
+	0, 1, 0, 23, 1, 0, 1, 1, 
+	1, 1, 0, 2, 1, 3, 2, 0, 
+	1, 3, 1, 2, 0, 1, 0, 2, 
+	1, 2, 3, 4, 0, 0, 0, 1, 
+	0, 6, 2, 0, 0, 0, 0, 1, 
+	3, 0, 0, 0, 1, 0, 1, 4, 
+	0, 0, 0, 1, 1, 1, 4, 0, 
+	0, 0, 6, 0, 1, 1, 0, 0, 
+	0, 1, 1, 0, 1, 0, 1, 0, 
+	0, 0, 26, 0, 0, 0, 1, 1, 
+	1, 0, 0, 2, 1, 0, 1, 1, 
+	0, 2, 0, 0, 2, 0, 2, 1, 
+	0, 1, 0, 3, 0, 0, 1, 21, 
+	0, 0, 3, 0, 0, 0, 0, 0, 
+	0, 1, 0, 0, 3, 0, 0, 0, 
+	0, 0, 0, 1, 0, 5, 2, 6, 
+	0, 1, 0, 1, 0, 2, 0, 0, 
+	15, 0, 0, 0, 3, 0, 0, 0, 
+	0, 0, 0, 0, 2, 1, 1, 0, 
+	3, 1, 0, 7, 5, 1, 1, 0, 
+	1, 0, 23, 0, 0, 0, 0, 1, 
+	0, 0, 1, 0, 1, 1, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 4, 0, 0, 0, 0, 1, 0, 
+	6, 0, 0, 0, 0, 0, 1, 3, 
+	0, 0, 0, 3, 0, 0, 0, 0, 
+	1, 1, 0, 1, 0, 1, 0, 0, 
+	0, 29, 0, 0, 0, 3, 2, 3, 
+	2, 2, 2, 3, 2, 2, 3, 3, 
+	1, 2, 4, 2, 2, 4, 4, 2, 
+	0, 2, 0, 3, 1, 0, 1, 21, 
+	1, 0, 4, 0, 0, 0, 1, 2, 
+	0, 1, 1, 1, 4, 0, 3, 1, 
+	3, 2, 0, 3, 0, 5, 2, 0, 
+	0, 1, 0, 2, 0, 0, 15, 0, 
+	0, 0, 4, 0, 0, 0, 3, 1, 
+	0, 4, 1, 4, 4, 3, 1, 0, 
+	7, 5, 1, 1, 0, 1, 0, 23, 
+	1, 0, 1, 1, 1, 1, 0, 2, 
+	1, 3, 2, 0, 1, 3, 1, 2, 
+	0, 1, 0, 2, 1, 2, 3, 4, 
+	0, 0, 0, 1, 0, 6, 2, 0, 
+	0, 0, 0, 1, 3, 0, 0, 0, 
+	1, 0, 1, 4, 0, 0, 0, 1, 
+	1, 1, 4, 0, 0, 0, 6, 0, 
+	0, 0, 1, 1, 2, 1, 1, 5, 
+	0, 24, 0, 24, 0, 0, 23, 0, 
+	0, 1, 0, 2, 0, 0, 0, 28, 
+	0, 3, 23, 2, 0, 2, 2, 3, 
+	2, 2, 2, 0, 54, 54, 27, 1, 
+	0, 5, 2, 0, 1, 1, 0, 0, 
+	14, 0, 3, 2, 2, 3, 2, 2, 
+	2, 54, 54, 27, 1, 0, 2, 0, 
+	1, 4, 2, 1, 0, 1, 0, 1, 
+	0, 11, 0, 7, 1, 0, 1, 0, 
+	2, 3, 2, 1, 0, 1, 1, 3, 
+	0, 1, 3, 0, 1, 1, 2, 1, 
+	1, 5, 0, 0, 0, 0, 1, 1, 
+	0, 1, 0, 1, 0, 0, 0, 26, 
+	0, 0, 0, 1, 1, 1, 0, 0, 
+	2, 1, 0, 1, 1, 0, 2, 0, 
+	0, 2, 0, 2, 1, 0, 1, 0, 
+	3, 0, 0, 1, 21, 0, 0, 3, 
+	0, 0, 0, 0, 0, 0, 1, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	1, 0, 5, 2, 6, 0, 1, 0, 
+	1, 0, 2, 0, 0, 15, 0, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	0, 2, 1, 1, 0, 3, 1, 0, 
+	7, 5, 1, 1, 0, 1, 0, 23, 
+	0, 0, 0, 0, 1, 0, 0, 1, 
+	0, 1, 1, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 4, 0, 
+	0, 0, 0, 1, 0, 6, 0, 0, 
+	0, 0, 0, 1, 3, 0, 0, 0, 
+	3, 0, 0, 0, 0, 1, 1, 0, 
+	1, 0, 1, 0, 0, 0, 29, 0, 
+	0, 0, 3, 2, 3, 2, 2, 2, 
+	3, 2, 2, 3, 3, 1, 2, 4, 
+	2, 2, 4, 4, 2, 0, 2, 0, 
+	3, 1, 0, 1, 21, 1, 0, 4, 
+	0, 0, 0, 1, 2, 0, 1, 1, 
+	1, 4, 0, 3, 1, 3, 2, 0, 
+	3, 0, 5, 2, 0, 0, 1, 0, 
+	2, 0, 0, 15, 0, 0, 0, 4, 
+	0, 0, 0, 3, 1, 0, 4, 1, 
+	4, 4, 3, 1, 0, 7, 5, 1, 
+	1, 0, 1, 0, 23, 1, 0, 1, 
+	1, 1, 1, 0, 2, 1, 3, 2, 
+	0, 1, 3, 1, 2, 0, 1, 0, 
+	2, 1, 2, 3, 4, 0, 0, 0, 
+	1, 0, 6, 2, 0, 0, 0, 0, 
+	1, 3, 0, 0, 0, 1, 0, 1, 
+	4, 0, 0, 0, 1, 1, 1, 4, 
+	0, 0, 0, 6, 24, 0, 24, 0, 
+	0, 23, 0, 0, 1, 0, 2, 0, 
+	0, 0, 28, 0, 3, 23, 2, 0, 
+	2, 2, 3, 2, 2, 2, 0, 54, 
+	54, 27, 1, 1, 5, 2, 0, 0, 
+	0, 1, 1, 0, 1, 0, 1, 0, 
+	0, 0, 26, 0, 0, 0, 1, 1, 
+	1, 0, 0, 2, 1, 0, 1, 1, 
+	0, 2, 0, 0, 2, 0, 2, 1, 
+	0, 1, 0, 3, 0, 0, 1, 21, 
+	0, 0, 3, 0, 0, 0, 0, 0, 
+	0, 1, 0, 0, 3, 0, 0, 0, 
+	0, 0, 0, 1, 0, 5, 2, 0, 
+	0, 1, 0, 2, 0, 0, 15, 0, 
+	0, 0, 3, 0, 0, 0, 0, 0, 
+	0, 0, 2, 1, 1, 0, 3, 1, 
+	0, 6, 5, 1, 1, 0, 1, 0, 
+	23, 0, 0, 0, 0, 1, 0, 0, 
+	1, 0, 1, 1, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 4, 
+	0, 0, 0, 0, 1, 0, 6, 0, 
+	0, 0, 0, 0, 1, 3, 0, 0, 
+	0, 1, 4, 0, 0, 0, 6, 1, 
+	7, 3, 0, 0, 0, 0, 1, 1, 
+	0, 1, 0, 1, 0, 0, 0, 29, 
+	0, 0, 0, 3, 2, 3, 2, 2, 
+	2, 3, 2, 2, 3, 3, 1, 2, 
+	4, 2, 2, 4, 4, 2, 0, 2, 
+	0, 3, 1, 0, 1, 21, 1, 0, 
+	4, 0, 0, 0, 1, 2, 0, 1, 
+	1, 1, 4, 0, 3, 1, 3, 2, 
+	0, 3, 0, 5, 2, 0, 0, 1, 
+	0, 2, 0, 0, 15, 0, 0, 0, 
+	4, 0, 0, 0, 3, 1, 0, 4, 
+	1, 4, 4, 3, 1, 0, 7, 5, 
+	1, 1, 0, 1, 0, 23, 1, 0, 
+	1, 1, 1, 1, 0, 2, 1, 3, 
+	2, 0, 1, 3, 1, 2, 0, 1, 
+	0, 2, 1, 2, 3, 4, 0, 0, 
+	0, 1, 0, 6, 2, 0, 0, 0, 
+	0, 1, 3, 0, 0, 0, 1, 0, 
+	1, 4, 0, 0, 0, 1, 1, 0, 
+	1, 0, 0, 0, 1, 1, 0, 1, 
+	0, 1, 0, 0, 0, 29, 0, 0, 
+	0, 3, 0, 0, 0, 1, 1, 0, 
+	1, 0, 1, 0, 0, 0, 26, 0, 
+	0, 0, 1, 1, 1, 0, 0, 2, 
+	1, 0, 1, 1, 0, 2, 0, 0, 
+	2, 0, 2, 1, 0, 1, 0, 3, 
+	0, 0, 1, 21, 0, 0, 3, 0, 
+	0, 0, 0, 0, 0, 1, 0, 0, 
+	3, 0, 0, 0, 0, 0, 0, 1, 
+	0, 5, 2, 6, 0, 1, 0, 1, 
+	0, 2, 0, 0, 15, 0, 0, 0, 
+	3, 0, 0, 0, 0, 0, 0, 0, 
+	2, 1, 1, 0, 3, 1, 0, 7, 
+	5, 1, 1, 0, 1, 0, 23, 0, 
+	0, 0, 0, 1, 0, 0, 1, 0, 
+	1, 1, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 4, 0, 0, 
+	0, 0, 1, 0, 6, 0, 0, 0, 
+	0, 0, 1, 3, 0, 0, 0, 3, 
+	0, 1, 1, 1, 4, 0, 0, 0, 
+	6, 2, 3, 2, 2, 2, 3, 2, 
+	2, 3, 3, 1, 2, 4, 2, 2, 
+	4, 4, 2, 0, 2, 0, 3, 1, 
+	0, 1, 21, 1, 0, 4, 0, 0, 
+	0, 1, 2, 0, 1, 1, 1, 4, 
+	0, 3, 1, 3, 2, 0, 3, 0, 
+	5, 2, 0, 0, 1, 0, 2, 0, 
+	0, 15, 0, 0, 0, 4, 0, 0, 
+	0, 3, 1, 0, 4, 1, 4, 4, 
+	3, 1, 0, 7, 5, 1, 1, 0, 
+	1, 0, 23, 1, 0, 1, 1, 1, 
+	1, 0, 2, 1, 3, 2, 0, 1, 
+	3, 1, 2, 0, 1, 0, 2, 1, 
+	2, 3, 4, 0, 0, 0, 1, 0, 
+	6, 2, 0, 0, 0, 0, 1, 3, 
+	0, 0, 0, 1, 0, 1, 4, 0, 
+	0, 0, 1, 0, 0, 14, 0, 3, 
+	2, 2, 3, 2, 2, 2, 54, 54, 
+	29, 1, 0, 0, 0, 0, 2, 1, 
+	1, 4, 2, 1, 0, 1, 0, 1, 
+	0, 11, 0, 0, 0, 0, 1, 1, 
+	0, 1, 0, 1, 0, 0, 0, 26, 
+	0, 0, 0, 1, 1, 1, 0, 0, 
+	2, 1, 0, 1, 1, 0, 2, 0, 
+	0, 2, 0, 2, 1, 0, 1, 0, 
+	3, 0, 0, 1, 21, 0, 0, 3, 
+	0, 0, 0, 0, 0, 0, 1, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	1, 0, 5, 2, 6, 0, 1, 0, 
+	1, 0, 2, 0, 0, 15, 0, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	0, 2, 1, 1, 0, 3, 1, 0, 
+	7, 5, 1, 1, 0, 1, 0, 23, 
+	0, 0, 0, 0, 1, 0, 0, 1, 
+	0, 1, 1, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 4, 0, 
+	0, 0, 0, 1, 0, 6, 0, 0, 
+	0, 0, 0, 1, 3, 0, 0, 0, 
+	3, 0, 0, 0, 0, 1, 1, 0, 
+	1, 0, 1, 0, 0, 0, 29, 0, 
+	0, 0, 3, 2, 3, 2, 2, 2, 
+	3, 2, 2, 3, 3, 1, 2, 4, 
+	2, 2, 4, 4, 2, 0, 2, 0, 
+	3, 1, 0, 1, 21, 1, 0, 4, 
+	0, 0, 0, 1, 2, 0, 1, 1, 
+	1, 4, 0, 3, 1, 3, 2, 0, 
+	3, 0, 5, 2, 0, 0, 1, 0, 
+	2, 0, 0, 15, 0, 0, 0, 4, 
+	0, 0, 0, 3, 1, 0, 4, 1, 
+	4, 4, 3, 1, 0, 7, 5, 1, 
+	1, 0, 1, 0, 23, 1, 0, 1, 
+	1, 1, 1, 0, 2, 1, 3, 2, 
+	0, 1, 3, 1, 2, 0, 1, 0, 
+	2, 1, 2, 3, 4, 0, 0, 0, 
+	1, 0, 6, 2, 0, 0, 0, 0, 
+	1, 3, 0, 0, 0, 1, 0, 1, 
+	4, 0, 0, 0, 1, 1, 1, 4, 
+	0, 0, 0, 6, 7, 1, 0, 1, 
+	0, 2, 3, 2, 1, 0, 1, 1, 
+	3, 0, 1, 5, 0, 0, 17, 20, 
+	20, 20, 14, 20, 20, 20, 23, 21, 
+	21, 21, 20, 23, 20, 20, 20, 21, 
+	21, 21, 20, 20, 20, 20, 20, 20, 
+	20, 20, 20, 20, 
+}
+
+var _graphclust_range_lengths []byte = []byte{
+	0, 0, 1, 1, 1, 1, 2, 1, 
+	1, 4, 1, 1, 1, 1, 2, 4, 
+	1, 2, 1, 2, 2, 5, 6, 2, 
+	2, 5, 1, 3, 2, 3, 5, 2, 
+	3, 1, 3, 1, 1, 2, 1, 2, 
+	1, 4, 0, 0, 2, 3, 1, 1, 
+	2, 2, 1, 2, 1, 1, 2, 1, 
+	2, 1, 2, 2, 2, 1, 1, 4, 
+	2, 0, 0, 0, 1, 0, 1, 0, 
+	1, 0, 1, 1, 0, 2, 1, 1, 
+	1, 2, 2, 1, 1, 2, 2, 1, 
+	1, 3, 2, 2, 0, 0, 2, 0, 
+	0, 0, 0, 1, 4, 1, 0, 2, 
+	1, 2, 2, 0, 2, 2, 1, 1, 
+	2, 6, 1, 1, 1, 1, 2, 2, 
+	1, 1, 1, 2, 2, 0, 1, 1, 
+	1, 1, 0, 1, 0, 3, 3, 1, 
+	2, 2, 2, 0, 5, 1, 1, 0, 
+	1, 1, 1, 1, 1, 2, 1, 1, 
+	4, 1, 1, 1, 1, 1, 4, 1, 
+	2, 2, 5, 2, 6, 2, 8, 4, 
+	2, 5, 0, 3, 2, 4, 1, 6, 
+	2, 4, 4, 1, 1, 2, 1, 2, 
+	1, 4, 0, 0, 4, 4, 1, 1, 
+	2, 2, 2, 2, 1, 1, 6, 2, 
+	5, 1, 3, 3, 4, 4, 4, 4, 
+	2, 0, 0, 1, 1, 0, 1, 0, 
+	1, 1, 0, 2, 1, 1, 2, 4, 
+	1, 2, 4, 1, 5, 0, 3, 2, 
+	1, 0, 0, 2, 0, 0, 0, 0, 
+	1, 4, 1, 0, 2, 1, 4, 2, 
+	0, 4, 3, 4, 2, 2, 6, 2, 
+	2, 4, 1, 4, 2, 4, 1, 3, 
+	3, 2, 2, 0, 1, 1, 1, 0, 
+	1, 0, 3, 3, 1, 2, 2, 2, 
+	0, 5, 1, 1, 0, 1, 0, 1, 
+	1, 1, 0, 0, 0, 0, 1, 1, 
+	1, 0, 0, 1, 2, 2, 1, 1, 
+	1, 1, 2, 1, 1, 4, 1, 1, 
+	1, 1, 2, 4, 1, 2, 1, 2, 
+	2, 5, 6, 2, 2, 5, 1, 3, 
+	2, 3, 5, 2, 3, 1, 3, 1, 
+	1, 2, 1, 2, 1, 4, 0, 0, 
+	2, 3, 1, 1, 2, 2, 1, 2, 
+	1, 1, 2, 1, 2, 1, 2, 2, 
+	2, 1, 1, 4, 2, 0, 0, 0, 
+	1, 0, 1, 0, 1, 0, 1, 1, 
+	0, 2, 1, 1, 1, 2, 2, 1, 
+	1, 2, 2, 1, 1, 3, 2, 2, 
+	0, 0, 2, 0, 0, 0, 0, 1, 
+	4, 1, 0, 2, 1, 2, 2, 0, 
+	2, 2, 1, 1, 2, 6, 1, 1, 
+	1, 1, 2, 2, 1, 1, 1, 2, 
+	2, 0, 1, 1, 1, 1, 0, 1, 
+	0, 3, 3, 1, 2, 2, 2, 0, 
+	5, 1, 1, 0, 1, 1, 1, 1, 
+	1, 2, 1, 1, 4, 1, 1, 1, 
+	1, 1, 4, 1, 2, 2, 5, 2, 
+	6, 2, 8, 4, 2, 5, 0, 3, 
+	2, 4, 1, 6, 2, 4, 4, 1, 
+	1, 2, 1, 2, 1, 4, 0, 0, 
+	4, 4, 1, 1, 2, 2, 2, 2, 
+	1, 1, 6, 2, 5, 1, 3, 3, 
+	4, 4, 4, 4, 2, 0, 0, 1, 
+	1, 0, 1, 0, 1, 1, 0, 2, 
+	1, 1, 2, 4, 1, 2, 4, 1, 
+	5, 0, 3, 2, 1, 0, 0, 2, 
+	0, 0, 0, 0, 1, 4, 1, 0, 
+	2, 1, 4, 2, 0, 4, 3, 4, 
+	2, 2, 6, 2, 2, 4, 1, 4, 
+	2, 4, 1, 3, 3, 2, 2, 0, 
+	1, 1, 1, 0, 1, 0, 3, 3, 
+	1, 2, 2, 2, 0, 5, 1, 1, 
+	0, 1, 0, 1, 1, 1, 0, 0, 
+	0, 0, 1, 1, 1, 0, 0, 1, 
+	2, 3, 1, 1, 1, 1, 1, 1, 
+	1, 0, 1, 0, 1, 1, 0, 1, 
+	1, 0, 1, 0, 1, 3, 1, 2, 
+	2, 1, 0, 0, 1, 0, 0, 0, 
+	0, 0, 1, 0, 1, 1, 2, 2, 
+	2, 1, 3, 2, 1, 1, 3, 1, 
+	3, 3, 1, 0, 0, 0, 0, 0, 
+	1, 1, 1, 2, 2, 4, 1, 1, 
+	2, 1, 1, 1, 3, 1, 2, 1, 
+	2, 1, 2, 0, 0, 1, 1, 5, 
+	9, 2, 1, 3, 5, 3, 1, 6, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 2, 
+	1, 1, 4, 1, 1, 1, 1, 2, 
+	4, 1, 2, 1, 2, 2, 5, 6, 
+	2, 2, 5, 1, 3, 2, 3, 5, 
+	2, 3, 1, 3, 1, 1, 2, 1, 
+	2, 1, 4, 0, 0, 2, 3, 1, 
+	1, 2, 2, 1, 2, 1, 1, 2, 
+	1, 2, 1, 2, 2, 2, 1, 1, 
+	4, 2, 0, 0, 0, 1, 0, 1, 
+	0, 1, 0, 1, 1, 0, 2, 1, 
+	1, 1, 2, 2, 1, 1, 2, 2, 
+	1, 1, 3, 2, 2, 0, 0, 2, 
+	0, 0, 0, 0, 1, 4, 1, 0, 
+	2, 1, 2, 2, 0, 2, 2, 1, 
+	1, 2, 6, 1, 1, 1, 1, 2, 
+	2, 1, 1, 1, 2, 2, 0, 1, 
+	1, 1, 1, 0, 1, 0, 3, 3, 
+	1, 2, 2, 2, 0, 5, 1, 1, 
+	0, 1, 1, 1, 1, 1, 2, 1, 
+	1, 4, 1, 1, 1, 1, 1, 4, 
+	1, 2, 2, 5, 2, 6, 2, 8, 
+	4, 2, 5, 0, 3, 2, 4, 1, 
+	6, 2, 4, 4, 1, 1, 2, 1, 
+	2, 1, 4, 0, 0, 4, 4, 1, 
+	1, 2, 2, 2, 2, 1, 1, 6, 
+	2, 5, 1, 3, 3, 4, 4, 4, 
+	4, 2, 0, 0, 1, 1, 0, 1, 
+	0, 1, 1, 0, 2, 1, 1, 2, 
+	4, 1, 2, 4, 1, 5, 0, 3, 
+	2, 1, 0, 0, 2, 0, 0, 0, 
+	0, 1, 4, 1, 0, 2, 1, 4, 
+	2, 0, 4, 3, 4, 2, 2, 6, 
+	2, 2, 4, 1, 4, 2, 4, 1, 
+	3, 3, 2, 2, 0, 1, 1, 1, 
+	0, 1, 0, 3, 3, 1, 2, 2, 
+	2, 0, 5, 1, 1, 0, 1, 0, 
+	1, 1, 1, 0, 0, 0, 0, 1, 
+	1, 1, 0, 0, 0, 1, 0, 1, 
+	1, 0, 1, 1, 0, 1, 0, 1, 
+	3, 1, 2, 2, 1, 0, 0, 1, 
+	0, 0, 0, 0, 0, 1, 0, 1, 
+	1, 2, 2, 1, 1, 5, 1, 1, 
+	1, 1, 2, 1, 1, 4, 1, 1, 
+	1, 1, 2, 4, 1, 2, 1, 2, 
+	2, 5, 6, 2, 2, 5, 1, 3, 
+	2, 3, 5, 2, 3, 1, 3, 1, 
+	1, 2, 1, 2, 1, 4, 0, 0, 
+	2, 3, 1, 1, 2, 2, 1, 2, 
+	1, 1, 2, 1, 2, 1, 2, 2, 
+	2, 1, 1, 4, 2, 0, 0, 1, 
+	1, 0, 1, 0, 1, 1, 0, 2, 
+	1, 1, 1, 2, 2, 1, 1, 2, 
+	2, 1, 1, 3, 2, 2, 0, 0, 
+	2, 0, 0, 0, 0, 1, 4, 1, 
+	0, 2, 1, 2, 2, 0, 2, 2, 
+	1, 1, 2, 6, 1, 1, 1, 1, 
+	2, 2, 1, 1, 1, 2, 2, 0, 
+	1, 1, 1, 1, 0, 1, 0, 3, 
+	3, 1, 2, 2, 2, 0, 5, 1, 
+	1, 0, 1, 1, 1, 0, 0, 0, 
+	0, 0, 1, 1, 1, 1, 1, 2, 
+	1, 1, 4, 1, 1, 1, 1, 1, 
+	4, 1, 2, 2, 5, 2, 6, 2, 
+	8, 4, 2, 5, 0, 3, 2, 4, 
+	1, 6, 2, 4, 4, 1, 1, 2, 
+	1, 2, 1, 4, 0, 0, 4, 4, 
+	1, 1, 2, 2, 2, 2, 1, 1, 
+	6, 2, 5, 1, 3, 3, 4, 4, 
+	4, 4, 2, 0, 0, 1, 1, 0, 
+	1, 0, 1, 1, 0, 2, 1, 1, 
+	2, 4, 1, 2, 4, 1, 5, 0, 
+	3, 2, 1, 0, 0, 2, 0, 0, 
+	0, 0, 1, 4, 1, 0, 2, 1, 
+	4, 2, 0, 4, 3, 4, 2, 2, 
+	6, 2, 2, 4, 1, 4, 2, 4, 
+	1, 3, 3, 2, 2, 0, 1, 1, 
+	1, 0, 1, 0, 3, 3, 1, 2, 
+	2, 2, 0, 5, 1, 1, 0, 1, 
+	0, 1, 1, 1, 0, 0, 0, 3, 
+	1, 1, 1, 1, 1, 2, 1, 1, 
+	4, 1, 1, 1, 1, 1, 4, 1, 
+	2, 2, 1, 1, 1, 1, 2, 1, 
+	1, 4, 1, 1, 1, 1, 2, 4, 
+	1, 2, 1, 2, 2, 5, 6, 2, 
+	2, 5, 1, 3, 2, 3, 5, 2, 
+	3, 1, 3, 1, 1, 2, 1, 2, 
+	1, 4, 0, 0, 2, 3, 1, 1, 
+	2, 2, 1, 2, 1, 1, 2, 1, 
+	2, 1, 2, 2, 2, 1, 1, 4, 
+	2, 0, 0, 0, 1, 0, 1, 0, 
+	1, 0, 1, 1, 0, 2, 1, 1, 
+	1, 2, 2, 1, 1, 2, 2, 1, 
+	1, 3, 2, 2, 0, 0, 2, 0, 
+	0, 0, 0, 1, 4, 1, 0, 2, 
+	1, 2, 2, 0, 2, 2, 1, 1, 
+	2, 6, 1, 1, 1, 1, 2, 2, 
+	1, 1, 1, 2, 2, 0, 1, 1, 
+	1, 1, 0, 1, 0, 3, 3, 1, 
+	2, 2, 2, 0, 5, 1, 1, 0, 
+	1, 0, 0, 0, 1, 1, 1, 0, 
+	0, 5, 2, 6, 2, 8, 4, 2, 
+	5, 0, 3, 2, 4, 1, 6, 2, 
+	4, 4, 1, 1, 2, 1, 2, 1, 
+	4, 0, 0, 4, 4, 1, 1, 2, 
+	2, 2, 2, 1, 1, 6, 2, 5, 
+	1, 3, 3, 4, 4, 4, 4, 2, 
+	0, 0, 1, 1, 0, 1, 0, 1, 
+	1, 0, 2, 1, 1, 2, 4, 1, 
+	2, 4, 1, 5, 0, 3, 2, 1, 
+	0, 0, 2, 0, 0, 0, 0, 1, 
+	4, 1, 0, 2, 1, 4, 2, 0, 
+	4, 3, 4, 2, 2, 6, 2, 2, 
+	4, 1, 4, 2, 4, 1, 3, 3, 
+	2, 2, 0, 1, 1, 1, 0, 1, 
+	0, 3, 3, 1, 2, 2, 2, 0, 
+	5, 1, 1, 0, 1, 0, 1, 1, 
+	1, 0, 1, 3, 1, 3, 3, 1, 
+	0, 0, 0, 0, 0, 1, 1, 1, 
+	3, 2, 4, 1, 0, 1, 1, 1, 
+	3, 1, 1, 1, 3, 1, 3, 1, 
+	3, 1, 2, 1, 1, 1, 1, 2, 
+	1, 1, 4, 1, 1, 1, 1, 2, 
+	4, 1, 2, 1, 2, 2, 5, 6, 
+	2, 2, 5, 1, 3, 2, 3, 5, 
+	2, 3, 1, 3, 1, 1, 2, 1, 
+	2, 1, 4, 0, 0, 2, 3, 1, 
+	1, 2, 2, 1, 2, 1, 1, 2, 
+	1, 2, 1, 2, 2, 2, 1, 1, 
+	4, 2, 0, 0, 0, 1, 0, 1, 
+	0, 1, 0, 1, 1, 0, 2, 1, 
+	1, 1, 2, 2, 1, 1, 2, 2, 
+	1, 1, 3, 2, 2, 0, 0, 2, 
+	0, 0, 0, 0, 1, 4, 1, 0, 
+	2, 1, 2, 2, 0, 2, 2, 1, 
+	1, 2, 6, 1, 1, 1, 1, 2, 
+	2, 1, 1, 1, 2, 2, 0, 1, 
+	1, 1, 1, 0, 1, 0, 3, 3, 
+	1, 2, 2, 2, 0, 5, 1, 1, 
+	0, 1, 1, 1, 1, 1, 2, 1, 
+	1, 4, 1, 1, 1, 1, 1, 4, 
+	1, 2, 2, 5, 2, 6, 2, 8, 
+	4, 2, 5, 0, 3, 2, 4, 1, 
+	6, 2, 4, 4, 1, 1, 2, 1, 
+	2, 1, 4, 0, 0, 4, 4, 1, 
+	1, 2, 2, 2, 2, 1, 1, 6, 
+	2, 5, 1, 3, 3, 4, 4, 4, 
+	4, 2, 0, 0, 1, 1, 0, 1, 
+	0, 1, 1, 0, 2, 1, 1, 2, 
+	4, 1, 2, 4, 1, 5, 0, 3, 
+	2, 1, 0, 0, 2, 0, 0, 0, 
+	0, 1, 4, 1, 0, 2, 1, 4, 
+	2, 0, 4, 3, 4, 2, 2, 6, 
+	2, 2, 4, 1, 4, 2, 4, 1, 
+	3, 3, 2, 2, 0, 1, 1, 1, 
+	0, 1, 0, 3, 3, 1, 2, 2, 
+	2, 0, 5, 1, 1, 0, 1, 0, 
+	1, 1, 1, 0, 0, 0, 0, 1, 
+	1, 1, 0, 0, 0, 0, 1, 1, 
+	5, 9, 2, 1, 3, 5, 3, 1, 
+	6, 1, 1, 2, 2, 2, 6, 0, 
+	0, 0, 4, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 
+}
+
+var _graphclust_index_offsets []int16 = []int16{
+	0, 0, 2, 4, 6, 8, 11, 15, 
+	17, 20, 25, 28, 30, 32, 34, 63, 
+	68, 70, 73, 76, 80, 84, 90, 97, 
+	102, 106, 112, 115, 120, 123, 129, 135, 
+	138, 144, 146, 152, 155, 157, 161, 163, 
+	169, 171, 176, 178, 200, 203, 207, 212, 
+	214, 217, 220, 222, 225, 227, 230, 233, 
+	235, 241, 243, 246, 249, 252, 254, 256, 
+	262, 265, 271, 274, 281, 283, 285, 287, 
+	289, 291, 294, 296, 298, 314, 317, 319, 
+	321, 326, 329, 332, 334, 336, 339, 342, 
+	344, 348, 353, 357, 360, 364, 366, 369, 
+	377, 383, 385, 387, 389, 395, 397, 421, 
+	424, 426, 429, 432, 434, 437, 440, 443, 
+	445, 449, 457, 459, 461, 463, 465, 468, 
+	471, 473, 475, 477, 480, 483, 488, 490, 
+	492, 494, 496, 498, 500, 507, 511, 515, 
+	517, 520, 523, 527, 531, 537, 539, 541, 
+	545, 547, 549, 551, 553, 556, 560, 562, 
+	565, 570, 573, 575, 577, 579, 610, 615, 
+	617, 620, 626, 634, 640, 649, 654, 665, 
+	673, 678, 686, 690, 697, 701, 708, 714, 
+	723, 728, 737, 746, 750, 752, 757, 759, 
+	765, 768, 773, 775, 797, 803, 808, 814, 
+	816, 819, 822, 826, 831, 833, 836, 844, 
+	848, 858, 860, 867, 872, 880, 887, 892, 
+	900, 903, 909, 912, 914, 916, 918, 920, 
+	923, 925, 927, 943, 946, 948, 950, 957, 
+	962, 964, 967, 975, 978, 984, 989, 994, 
+	1001, 1007, 1011, 1013, 1016, 1024, 1030, 1032, 
+	1034, 1036, 1042, 1044, 1068, 1072, 1074, 1080, 
+	1084, 1086, 1092, 1096, 1103, 1107, 1113, 1122, 
+	1125, 1129, 1137, 1140, 1147, 1150, 1156, 1158, 
+	1164, 1169, 1174, 1180, 1185, 1187, 1189, 1191, 
+	1193, 1195, 1202, 1208, 1212, 1214, 1217, 1220, 
+	1224, 1228, 1234, 1236, 1238, 1240, 1242, 1244, 
+	1250, 1252, 1254, 1255, 1257, 1259, 1261, 1267, 
+	1269, 1271, 1272, 1279, 1281, 1285, 1289, 1291, 
+	1293, 1295, 1298, 1302, 1304, 1307, 1312, 1315, 
+	1317, 1319, 1321, 1350, 1355, 1357, 1360, 1363, 
+	1367, 1371, 1377, 1384, 1389, 1393, 1399, 1402, 
+	1407, 1410, 1416, 1422, 1425, 1431, 1433, 1439, 
+	1442, 1444, 1448, 1450, 1456, 1458, 1463, 1465, 
+	1487, 1490, 1494, 1499, 1501, 1504, 1507, 1509, 
+	1512, 1514, 1517, 1520, 1522, 1528, 1530, 1533, 
+	1536, 1539, 1541, 1543, 1549, 1552, 1558, 1561, 
+	1568, 1570, 1572, 1574, 1576, 1578, 1581, 1583, 
+	1585, 1601, 1604, 1606, 1608, 1613, 1616, 1619, 
+	1621, 1623, 1626, 1629, 1631, 1635, 1640, 1644, 
+	1647, 1651, 1653, 1656, 1664, 1670, 1672, 1674, 
+	1676, 1682, 1684, 1708, 1711, 1713, 1716, 1719, 
+	1721, 1724, 1727, 1730, 1732, 1736, 1744, 1746, 
+	1748, 1750, 1752, 1755, 1758, 1760, 1762, 1764, 
+	1767, 1770, 1775, 1777, 1779, 1781, 1783, 1785, 
+	1787, 1794, 1798, 1802, 1804, 1807, 1810, 1814, 
+	1818, 1824, 1826, 1828, 1832, 1834, 1836, 1838, 
+	1840, 1843, 1847, 1849, 1852, 1857, 1860, 1862, 
+	1864, 1866, 1897, 1902, 1904, 1907, 1913, 1921, 
+	1927, 1936, 1941, 1952, 1960, 1965, 1973, 1977, 
+	1984, 1988, 1995, 2001, 2010, 2015, 2024, 2033, 
+	2037, 2039, 2044, 2046, 2052, 2055, 2060, 2062, 
+	2084, 2090, 2095, 2101, 2103, 2106, 2109, 2113, 
+	2118, 2120, 2123, 2131, 2135, 2145, 2147, 2154, 
+	2159, 2167, 2174, 2179, 2187, 2190, 2196, 2199, 
+	2201, 2203, 2205, 2207, 2210, 2212, 2214, 2230, 
+	2233, 2235, 2237, 2244, 2249, 2251, 2254, 2262, 
+	2265, 2271, 2276, 2281, 2288, 2294, 2298, 2300, 
+	2303, 2311, 2317, 2319, 2321, 2323, 2329, 2331, 
+	2355, 2359, 2361, 2367, 2371, 2373, 2379, 2383, 
+	2390, 2394, 2400, 2409, 2412, 2416, 2424, 2427, 
+	2434, 2437, 2443, 2445, 2451, 2456, 2461, 2467, 
+	2472, 2474, 2476, 2478, 2480, 2482, 2489, 2495, 
+	2499, 2501, 2504, 2507, 2511, 2515, 2521, 2523, 
+	2525, 2527, 2529, 2531, 2537, 2539, 2541, 2542, 
+	2544, 2546, 2548, 2554, 2556, 2558, 2559, 2566, 
+	2568, 2571, 2575, 2578, 2581, 2585, 2588, 2591, 
+	2598, 2600, 2625, 2627, 2652, 2654, 2656, 2680, 
+	2682, 2684, 2686, 2688, 2691, 2693, 2697, 2699, 
+	2730, 2733, 2738, 2762, 2765, 2767, 2770, 2773, 
+	2777, 2780, 2783, 2787, 2788, 2844, 2900, 2930, 
+	2934, 2937, 2944, 2950, 2953, 2956, 2959, 2963, 
+	2965, 2983, 2987, 2992, 2995, 2998, 3002, 3005, 
+	3008, 3012, 3068, 3124, 3154, 3158, 3163, 3167, 
+	3169, 3173, 3179, 3183, 3186, 3190, 3193, 3196, 
+	3199, 3202, 3215, 3218, 3226, 3228, 3230, 3233, 
+	3239, 3251, 3257, 3261, 3266, 3272, 3277, 3280, 
+	3290, 3292, 3295, 3300, 3302, 3305, 3308, 3312, 
+	3315, 3318, 3325, 3327, 3329, 3331, 3333, 3336, 
+	3340, 3342, 3345, 3350, 3353, 3355, 3357, 3359, 
+	3388, 3393, 3395, 3398, 3401, 3405, 3409, 3415, 
+	3422, 3427, 3431, 3437, 3440, 3445, 3448, 3454, 
+	3460, 3463, 3469, 3471, 3477, 3480, 3482, 3486, 
+	3488, 3494, 3496, 3501, 3503, 3525, 3528, 3532, 
+	3537, 3539, 3542, 3545, 3547, 3550, 3552, 3555, 
+	3558, 3560, 3566, 3568, 3571, 3574, 3577, 3579, 
+	3581, 3587, 3590, 3596, 3599, 3606, 3608, 3610, 
+	3612, 3614, 3616, 3619, 3621, 3623, 3639, 3642, 
+	3644, 3646, 3651, 3654, 3657, 3659, 3661, 3664, 
+	3667, 3669, 3673, 3678, 3682, 3685, 3689, 3691, 
+	3694, 3702, 3708, 3710, 3712, 3714, 3720, 3722, 
+	3746, 3749, 3751, 3754, 3757, 3759, 3762, 3765, 
+	3768, 3770, 3774, 3782, 3784, 3786, 3788, 3790, 
+	3793, 3796, 3798, 3800, 3802, 3805, 3808, 3813, 
+	3815, 3817, 3819, 3821, 3823, 3825, 3832, 3836, 
+	3840, 3842, 3845, 3848, 3852, 3856, 3862, 3864, 
+	3866, 3870, 3872, 3874, 3876, 3878, 3881, 3885, 
+	3887, 3890, 3895, 3898, 3900, 3902, 3904, 3935, 
+	3940, 3942, 3945, 3951, 3959, 3965, 3974, 3979, 
+	3990, 3998, 4003, 4011, 4015, 4022, 4026, 4033, 
+	4039, 4048, 4053, 4062, 4071, 4075, 4077, 4082, 
+	4084, 4090, 4093, 4098, 4100, 4122, 4128, 4133, 
+	4139, 4141, 4144, 4147, 4151, 4156, 4158, 4161, 
+	4169, 4173, 4183, 4185, 4192, 4197, 4205, 4212, 
+	4217, 4225, 4228, 4234, 4237, 4239, 4241, 4243, 
+	4245, 4248, 4250, 4252, 4268, 4271, 4273, 4275, 
+	4282, 4287, 4289, 4292, 4300, 4303, 4309, 4314, 
+	4319, 4326, 4332, 4336, 4338, 4341, 4349, 4355, 
+	4357, 4359, 4361, 4367, 4369, 4393, 4397, 4399, 
+	4405, 4409, 4411, 4417, 4421, 4428, 4432, 4438, 
+	4447, 4450, 4454, 4462, 4465, 4472, 4475, 4481, 
+	4483, 4489, 4494, 4499, 4505, 4510, 4512, 4514, 
+	4516, 4518, 4520, 4527, 4533, 4537, 4539, 4542, 
+	4545, 4549, 4553, 4559, 4561, 4563, 4565, 4567, 
+	4569, 4575, 4577, 4579, 4580, 4582, 4584, 4586, 
+	4592, 4594, 4596, 4597, 4604, 4629, 4631, 4656, 
+	4658, 4660, 4684, 4686, 4688, 4690, 4692, 4695, 
+	4697, 4701, 4703, 4734, 4737, 4742, 4766, 4769, 
+	4771, 4774, 4777, 4781, 4784, 4787, 4791, 4792, 
+	4848, 4904, 4934, 4938, 4941, 4948, 4956, 4958, 
+	4960, 4962, 4965, 4969, 4971, 4974, 4979, 4982, 
+	4984, 4986, 4988, 5017, 5022, 5024, 5027, 5030, 
+	5034, 5038, 5044, 5051, 5056, 5060, 5066, 5069, 
+	5074, 5077, 5083, 5089, 5092, 5098, 5100, 5106, 
+	5109, 5111, 5115, 5117, 5123, 5125, 5130, 5132, 
+	5154, 5157, 5161, 5166, 5168, 5171, 5174, 5176, 
+	5179, 5181, 5184, 5187, 5189, 5195, 5197, 5200, 
+	5203, 5206, 5208, 5210, 5216, 5219, 5225, 5228, 
+	5230, 5232, 5234, 5236, 5239, 5241, 5243, 5259, 
+	5262, 5264, 5266, 5271, 5274, 5277, 5279, 5281, 
+	5284, 5287, 5289, 5293, 5298, 5302, 5305, 5309, 
+	5311, 5314, 5321, 5327, 5329, 5331, 5333, 5339, 
+	5341, 5365, 5368, 5370, 5373, 5376, 5378, 5381, 
+	5384, 5387, 5389, 5393, 5401, 5403, 5405, 5407, 
+	5409, 5412, 5415, 5417, 5419, 5421, 5424, 5427, 
+	5432, 5434, 5436, 5438, 5440, 5442, 5444, 5451, 
+	5455, 5459, 5461, 5464, 5467, 5471, 5475, 5481, 
+	5483, 5485, 5487, 5493, 5495, 5497, 5498, 5505, 
+	5507, 5515, 5519, 5521, 5523, 5525, 5527, 5530, 
+	5534, 5536, 5539, 5544, 5547, 5549, 5551, 5553, 
+	5584, 5589, 5591, 5594, 5600, 5608, 5614, 5623, 
+	5628, 5639, 5647, 5652, 5660, 5664, 5671, 5675, 
+	5682, 5688, 5697, 5702, 5711, 5720, 5724, 5726, 
+	5731, 5733, 5739, 5742, 5747, 5749, 5771, 5777, 
+	5782, 5788, 5790, 5793, 5796, 5800, 5805, 5807, 
+	5810, 5818, 5822, 5832, 5834, 5841, 5846, 5854, 
+	5861, 5866, 5874, 5877, 5883, 5886, 5888, 5890, 
+	5892, 5894, 5897, 5899, 5901, 5917, 5920, 5922, 
+	5924, 5931, 5936, 5938, 5941, 5949, 5952, 5958, 
+	5963, 5968, 5975, 5981, 5985, 5987, 5990, 5998, 
+	6004, 6006, 6008, 6010, 6016, 6018, 6042, 6046, 
+	6048, 6054, 6058, 6060, 6066, 6070, 6077, 6081, 
+	6087, 6096, 6099, 6103, 6111, 6114, 6121, 6124, 
+	6130, 6132, 6138, 6143, 6148, 6154, 6159, 6161, 
+	6163, 6165, 6167, 6169, 6176, 6182, 6186, 6188, 
+	6191, 6194, 6198, 6202, 6208, 6210, 6212, 6214, 
+	6216, 6218, 6224, 6226, 6228, 6229, 6231, 6233, 
+	6237, 6240, 6242, 6244, 6246, 6249, 6253, 6255, 
+	6258, 6263, 6266, 6268, 6270, 6272, 6303, 6308, 
+	6310, 6313, 6319, 6321, 6323, 6325, 6328, 6332, 
+	6334, 6337, 6342, 6345, 6347, 6349, 6351, 6380, 
+	6385, 6387, 6390, 6393, 6397, 6401, 6407, 6414, 
+	6419, 6423, 6429, 6432, 6437, 6440, 6446, 6452, 
+	6455, 6461, 6463, 6469, 6472, 6474, 6478, 6480, 
+	6486, 6488, 6493, 6495, 6517, 6520, 6524, 6529, 
+	6531, 6534, 6537, 6539, 6542, 6544, 6547, 6550, 
+	6552, 6558, 6560, 6563, 6566, 6569, 6571, 6573, 
+	6579, 6582, 6588, 6591, 6598, 6600, 6602, 6604, 
+	6606, 6608, 6611, 6613, 6615, 6631, 6634, 6636, 
+	6638, 6643, 6646, 6649, 6651, 6653, 6656, 6659, 
+	6661, 6665, 6670, 6674, 6677, 6681, 6683, 6686, 
+	6694, 6700, 6702, 6704, 6706, 6712, 6714, 6738, 
+	6741, 6743, 6746, 6749, 6751, 6754, 6757, 6760, 
+	6762, 6766, 6774, 6776, 6778, 6780, 6782, 6785, 
+	6788, 6790, 6792, 6794, 6797, 6800, 6805, 6807, 
+	6809, 6811, 6813, 6815, 6817, 6824, 6828, 6832, 
+	6834, 6837, 6840, 6844, 6848, 6854, 6856, 6858, 
+	6862, 6864, 6866, 6868, 6870, 6876, 6878, 6880, 
+	6881, 6888, 6896, 6902, 6911, 6916, 6927, 6935, 
+	6940, 6948, 6952, 6959, 6963, 6970, 6976, 6985, 
+	6990, 6999, 7008, 7012, 7014, 7019, 7021, 7027, 
+	7030, 7035, 7037, 7059, 7065, 7070, 7076, 7078, 
+	7081, 7084, 7088, 7093, 7095, 7098, 7106, 7110, 
+	7120, 7122, 7129, 7134, 7142, 7149, 7154, 7162, 
+	7165, 7171, 7174, 7176, 7178, 7180, 7182, 7185, 
+	7187, 7189, 7205, 7208, 7210, 7212, 7219, 7224, 
+	7226, 7229, 7237, 7240, 7246, 7251, 7256, 7263, 
+	7269, 7273, 7275, 7278, 7286, 7292, 7294, 7296, 
+	7298, 7304, 7306, 7330, 7334, 7336, 7342, 7346, 
+	7348, 7354, 7358, 7365, 7369, 7375, 7384, 7387, 
+	7391, 7399, 7402, 7409, 7412, 7418, 7420, 7426, 
+	7431, 7436, 7442, 7447, 7449, 7451, 7453, 7455, 
+	7457, 7464, 7470, 7474, 7476, 7479, 7482, 7486, 
+	7490, 7496, 7498, 7500, 7502, 7504, 7506, 7512, 
+	7514, 7516, 7517, 7520, 7524, 7526, 7544, 7548, 
+	7553, 7556, 7559, 7563, 7566, 7569, 7573, 7629, 
+	7685, 7718, 7722, 7727, 7729, 7730, 7732, 7736, 
+	7739, 7744, 7750, 7754, 7757, 7761, 7764, 7768, 
+	7771, 7775, 7788, 7791, 7793, 7795, 7797, 7800, 
+	7804, 7806, 7809, 7814, 7817, 7819, 7821, 7823, 
+	7852, 7857, 7859, 7862, 7865, 7869, 7873, 7879, 
+	7886, 7891, 7895, 7901, 7904, 7909, 7912, 7918, 
+	7924, 7927, 7933, 7935, 7941, 7944, 7946, 7950, 
+	7952, 7958, 7960, 7965, 7967, 7989, 7992, 7996, 
+	8001, 8003, 8006, 8009, 8011, 8014, 8016, 8019, 
+	8022, 8024, 8030, 8032, 8035, 8038, 8041, 8043, 
+	8045, 8051, 8054, 8060, 8063, 8070, 8072, 8074, 
+	8076, 8078, 8080, 8083, 8085, 8087, 8103, 8106, 
+	8108, 8110, 8115, 8118, 8121, 8123, 8125, 8128, 
+	8131, 8133, 8137, 8142, 8146, 8149, 8153, 8155, 
+	8158, 8166, 8172, 8174, 8176, 8178, 8184, 8186, 
+	8210, 8213, 8215, 8218, 8221, 8223, 8226, 8229, 
+	8232, 8234, 8238, 8246, 8248, 8250, 8252, 8254, 
+	8257, 8260, 8262, 8264, 8266, 8269, 8272, 8277, 
+	8279, 8281, 8283, 8285, 8287, 8289, 8296, 8300, 
+	8304, 8306, 8309, 8312, 8316, 8320, 8326, 8328, 
+	8330, 8334, 8336, 8338, 8340, 8342, 8345, 8349, 
+	8351, 8354, 8359, 8362, 8364, 8366, 8368, 8399, 
+	8404, 8406, 8409, 8415, 8423, 8429, 8438, 8443, 
+	8454, 8462, 8467, 8475, 8479, 8486, 8490, 8497, 
+	8503, 8512, 8517, 8526, 8535, 8539, 8541, 8546, 
+	8548, 8554, 8557, 8562, 8564, 8586, 8592, 8597, 
+	8603, 8605, 8608, 8611, 8615, 8620, 8622, 8625, 
+	8633, 8637, 8647, 8649, 8656, 8661, 8669, 8676, 
+	8681, 8689, 8692, 8698, 8701, 8703, 8705, 8707, 
+	8709, 8712, 8714, 8716, 8732, 8735, 8737, 8739, 
+	8746, 8751, 8753, 8756, 8764, 8767, 8773, 8778, 
+	8783, 8790, 8796, 8800, 8802, 8805, 8813, 8819, 
+	8821, 8823, 8825, 8831, 8833, 8857, 8861, 8863, 
+	8869, 8873, 8875, 8881, 8885, 8892, 8896, 8902, 
+	8911, 8914, 8918, 8926, 8929, 8936, 8939, 8945, 
+	8947, 8953, 8958, 8963, 8969, 8974, 8976, 8978, 
+	8980, 8982, 8984, 8991, 8997, 9001, 9003, 9006, 
+	9009, 9013, 9017, 9023, 9025, 9027, 9029, 9031, 
+	9033, 9039, 9041, 9043, 9044, 9046, 9048, 9050, 
+	9056, 9058, 9060, 9061, 9068, 9076, 9078, 9080, 
+	9083, 9089, 9101, 9107, 9111, 9116, 9122, 9127, 
+	9130, 9140, 9142, 9145, 9153, 9156, 9159, 9183, 
+	9204, 9225, 9246, 9265, 9286, 9307, 9328, 9352, 
+	9374, 9396, 9418, 9439, 9463, 9484, 9505, 9526, 
+	9548, 9570, 9592, 9613, 9634, 9655, 9676, 9697, 
+	9718, 9739, 9760, 9781, 
+}
+
+var _graphclust_indicies []int16 = []int16{
+	0, 1, 3, 2, 2, 3, 3, 2, 
+	3, 3, 2, 3, 3, 3, 2, 3, 
+	2, 3, 3, 2, 3, 3, 3, 3, 
+	2, 3, 3, 2, 2, 3, 3, 2, 
+	3, 2, 4, 5, 6, 7, 8, 10, 
+	11, 12, 14, 15, 16, 17, 18, 19, 
+	20, 21, 22, 23, 24, 25, 26, 27, 
+	28, 29, 30, 31, 9, 13, 2, 3, 
+	3, 3, 3, 2, 3, 2, 3, 3, 
+	2, 2, 2, 3, 2, 2, 2, 3, 
+	3, 3, 3, 2, 2, 2, 2, 2, 
+	2, 3, 2, 2, 2, 2, 2, 2, 
+	3, 2, 2, 2, 2, 3, 3, 3, 
+	3, 2, 3, 3, 3, 3, 3, 2, 
+	3, 3, 2, 3, 3, 3, 3, 2, 
+	3, 3, 2, 2, 2, 2, 2, 2, 
+	3, 3, 3, 3, 3, 3, 2, 3, 
+	3, 2, 2, 2, 2, 2, 2, 3, 
+	3, 2, 3, 3, 3, 3, 3, 2, 
+	3, 3, 2, 3, 2, 3, 3, 3, 
+	2, 3, 2, 3, 3, 3, 3, 3, 
+	2, 3, 2, 3, 3, 3, 3, 2, 
+	3, 2, 32, 33, 34, 35, 36, 37, 
+	38, 39, 40, 41, 42, 43, 44, 45, 
+	46, 47, 48, 49, 50, 51, 52, 2, 
+	3, 3, 2, 3, 3, 3, 2, 3, 
+	3, 3, 3, 2, 3, 2, 3, 3, 
+	2, 3, 3, 2, 3, 2, 2, 2, 
+	3, 3, 2, 3, 3, 2, 3, 3, 
+	2, 3, 2, 3, 3, 3, 3, 3, 
+	2, 3, 2, 3, 3, 2, 2, 2, 
+	3, 3, 3, 2, 3, 2, 3, 2, 
+	3, 3, 3, 3, 3, 2, 3, 3, 
+	2, 53, 54, 55, 56, 57, 2, 3, 
+	58, 2, 53, 54, 59, 55, 56, 57, 
+	2, 3, 2, 3, 2, 3, 2, 3, 
+	2, 3, 2, 60, 61, 2, 3, 2, 
+	3, 2, 62, 63, 64, 65, 66, 67, 
+	68, 69, 70, 71, 72, 73, 74, 75, 
+	76, 2, 3, 3, 2, 3, 2, 3, 
+	2, 3, 3, 3, 3, 2, 3, 3, 
+	2, 2, 2, 3, 3, 2, 3, 2, 
+	3, 3, 2, 2, 2, 3, 3, 2, 
+	3, 3, 3, 2, 3, 3, 3, 3, 
+	2, 3, 3, 3, 2, 3, 3, 2, 
+	77, 78, 63, 2, 3, 2, 3, 3, 
+	2, 79, 80, 81, 82, 83, 84, 85, 
+	2, 86, 87, 88, 89, 90, 2, 3, 
+	2, 3, 2, 3, 2, 3, 3, 3, 
+	3, 3, 2, 3, 2, 91, 92, 93, 
+	94, 95, 96, 97, 98, 99, 100, 101, 
+	102, 103, 104, 105, 106, 107, 104, 108, 
+	109, 110, 111, 112, 2, 3, 3, 2, 
+	2, 3, 2, 2, 3, 3, 3, 2, 
+	3, 2, 3, 3, 2, 2, 2, 3, 
+	3, 3, 2, 3, 2, 3, 3, 3, 
+	2, 3, 3, 3, 3, 3, 3, 3, 
+	2, 3, 2, 3, 2, 3, 2, 2, 
+	3, 3, 3, 2, 2, 2, 3, 2, 
+	3, 3, 2, 3, 2, 3, 3, 2, 
+	3, 3, 2, 113, 114, 115, 116, 2, 
+	3, 2, 3, 2, 3, 2, 3, 2, 
+	117, 2, 3, 2, 118, 119, 120, 121, 
+	122, 123, 2, 3, 3, 3, 2, 2, 
+	2, 2, 3, 3, 2, 3, 3, 2, 
+	2, 2, 3, 3, 3, 3, 2, 124, 
+	125, 126, 2, 3, 3, 3, 3, 3, 
+	2, 3, 2, 3, 2, 127, 128, 129, 
+	2, 130, 2, 2, 130, 2, 130, 130, 
+	2, 130, 130, 2, 130, 130, 130, 2, 
+	130, 2, 130, 130, 2, 130, 130, 130, 
+	130, 2, 130, 130, 2, 2, 130, 130, 
+	2, 130, 2, 131, 132, 133, 134, 135, 
+	136, 137, 139, 140, 141, 142, 143, 144, 
+	145, 146, 147, 148, 149, 150, 22, 151, 
+	152, 153, 154, 155, 156, 157, 158, 159, 
+	138, 2, 130, 130, 130, 130, 2, 130, 
+	2, 130, 130, 2, 3, 3, 2, 2, 
+	3, 130, 130, 2, 130, 130, 2, 130, 
+	2, 3, 130, 130, 130, 3, 3, 2, 
+	130, 130, 130, 2, 2, 2, 130, 2, 
+	3, 3, 130, 130, 3, 2, 130, 130, 
+	130, 2, 130, 2, 130, 2, 130, 2, 
+	3, 2, 2, 130, 130, 2, 130, 2, 
+	3, 130, 130, 3, 130, 2, 3, 130, 
+	130, 3, 3, 130, 130, 2, 130, 130, 
+	3, 2, 130, 130, 130, 3, 3, 3, 
+	2, 130, 3, 130, 2, 2, 2, 3, 
+	2, 2, 2, 130, 130, 130, 3, 130, 
+	3, 2, 130, 130, 3, 3, 3, 130, 
+	130, 130, 2, 130, 130, 3, 3, 2, 
+	2, 2, 130, 130, 130, 2, 130, 2, 
+	3, 130, 130, 130, 130, 3, 130, 3, 
+	3, 2, 130, 3, 130, 2, 130, 2, 
+	130, 3, 130, 130, 2, 130, 2, 130, 
+	130, 130, 130, 3, 2, 3, 130, 2, 
+	130, 130, 130, 130, 2, 130, 2, 160, 
+	161, 162, 163, 164, 165, 166, 167, 168, 
+	169, 170, 171, 172, 173, 174, 175, 176, 
+	177, 178, 179, 180, 2, 3, 130, 130, 
+	3, 130, 2, 3, 130, 130, 130, 2, 
+	130, 3, 130, 130, 130, 2, 130, 2, 
+	130, 130, 2, 130, 130, 2, 3, 130, 
+	3, 2, 130, 130, 130, 2, 3, 130, 
+	2, 130, 130, 2, 130, 130, 3, 130, 
+	3, 3, 130, 2, 130, 130, 3, 2, 
+	130, 130, 130, 130, 3, 130, 130, 3, 
+	130, 2, 130, 2, 3, 3, 3, 130, 
+	130, 3, 2, 130, 2, 130, 2, 3, 
+	3, 3, 3, 130, 130, 3, 130, 2, 
+	3, 130, 130, 3, 130, 3, 2, 3, 
+	130, 3, 130, 2, 3, 130, 130, 130, 
+	130, 3, 130, 2, 130, 130, 2, 181, 
+	182, 183, 184, 185, 2, 130, 58, 2, 
+	130, 2, 130, 2, 130, 2, 130, 2, 
+	186, 187, 2, 130, 2, 130, 2, 188, 
+	189, 190, 191, 66, 192, 193, 194, 195, 
+	196, 197, 198, 199, 200, 201, 2, 130, 
+	130, 2, 130, 2, 130, 2, 130, 130, 
+	130, 3, 3, 130, 2, 130, 2, 130, 
+	2, 3, 130, 2, 130, 3, 2, 3, 
+	130, 130, 130, 3, 130, 3, 2, 130, 
+	2, 3, 130, 3, 130, 3, 130, 2, 
+	130, 130, 3, 130, 2, 130, 130, 130, 
+	130, 2, 130, 3, 3, 130, 130, 3, 
+	2, 130, 130, 3, 130, 3, 2, 202, 
+	203, 189, 2, 130, 2, 130, 130, 2, 
+	204, 205, 206, 207, 208, 209, 210, 2, 
+	211, 212, 213, 214, 215, 2, 130, 2, 
+	130, 2, 130, 2, 130, 130, 130, 130, 
+	130, 2, 130, 2, 216, 217, 218, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	228, 229, 230, 231, 232, 233, 234, 235, 
+	236, 237, 238, 2, 130, 3, 130, 2, 
+	2, 130, 3, 2, 3, 3, 2, 130, 
+	3, 130, 130, 2, 130, 2, 3, 130, 
+	3, 130, 3, 2, 2, 130, 2, 3, 
+	130, 130, 3, 130, 3, 130, 2, 130, 
+	3, 130, 2, 130, 130, 3, 130, 3, 
+	2, 130, 130, 3, 3, 3, 3, 130, 
+	130, 2, 3, 130, 2, 3, 3, 130, 
+	2, 130, 3, 130, 3, 130, 3, 130, 
+	2, 3, 2, 130, 130, 3, 3, 130, 
+	3, 130, 2, 2, 2, 130, 130, 3, 
+	130, 3, 130, 2, 2, 130, 3, 3, 
+	130, 3, 130, 2, 3, 130, 3, 130, 
+	2, 3, 3, 130, 130, 2, 3, 3, 
+	3, 130, 130, 2, 239, 240, 115, 241, 
+	2, 130, 2, 130, 2, 130, 2, 242, 
+	2, 130, 2, 243, 244, 245, 246, 247, 
+	248, 2, 3, 3, 130, 130, 130, 2, 
+	2, 2, 2, 130, 130, 2, 130, 130, 
+	2, 2, 2, 130, 130, 130, 130, 2, 
+	249, 250, 251, 2, 130, 130, 130, 130, 
+	130, 2, 130, 2, 130, 2, 252, 2, 
+	3, 2, 253, 2, 254, 255, 256, 258, 
+	257, 2, 130, 2, 2, 130, 130, 3, 
+	2, 3, 2, 259, 2, 260, 261, 262, 
+	264, 263, 2, 3, 2, 2, 3, 3, 
+	79, 80, 81, 82, 83, 84, 2, 3, 
+	1, 265, 265, 3, 1, 265, 266, 3, 
+	1, 267, 268, 267, 268, 268, 267, 268, 
+	268, 267, 268, 268, 268, 267, 268, 267, 
+	268, 268, 267, 268, 268, 268, 268, 267, 
+	268, 268, 267, 267, 268, 268, 267, 268, 
+	267, 269, 270, 271, 272, 273, 275, 276, 
+	277, 279, 280, 281, 282, 283, 284, 285, 
+	286, 287, 288, 289, 290, 291, 292, 293, 
+	294, 295, 296, 274, 278, 267, 268, 268, 
+	268, 268, 267, 268, 267, 268, 268, 267, 
+	267, 267, 268, 267, 267, 267, 268, 268, 
+	268, 268, 267, 267, 267, 267, 267, 267, 
+	268, 267, 267, 267, 267, 267, 267, 268, 
+	267, 267, 267, 267, 268, 268, 268, 268, 
+	267, 268, 268, 268, 268, 268, 267, 268, 
+	268, 267, 268, 268, 268, 268, 267, 268, 
+	268, 267, 267, 267, 267, 267, 267, 268, 
+	268, 268, 268, 268, 268, 267, 268, 268, 
+	267, 267, 267, 267, 267, 267, 268, 268, 
+	267, 268, 268, 268, 268, 268, 267, 268, 
+	268, 267, 268, 267, 268, 268, 268, 267, 
+	268, 267, 268, 268, 268, 268, 268, 267, 
+	268, 267, 268, 268, 268, 268, 267, 268, 
+	267, 297, 298, 299, 300, 301, 302, 303, 
+	304, 305, 306, 307, 308, 309, 310, 311, 
+	312, 313, 314, 315, 316, 317, 267, 268, 
+	268, 267, 268, 268, 268, 267, 268, 268, 
+	268, 268, 267, 268, 267, 268, 268, 267, 
+	268, 268, 267, 268, 267, 267, 267, 268, 
+	268, 267, 268, 268, 267, 268, 268, 267, 
+	268, 267, 268, 268, 268, 268, 268, 267, 
+	268, 267, 268, 268, 267, 267, 267, 268, 
+	268, 268, 267, 268, 267, 268, 267, 268, 
+	268, 268, 268, 268, 267, 268, 268, 267, 
+	318, 319, 320, 321, 322, 267, 268, 323, 
+	267, 318, 319, 324, 320, 321, 322, 267, 
+	268, 267, 268, 267, 268, 267, 268, 267, 
+	268, 267, 325, 326, 267, 268, 267, 268, 
+	267, 327, 328, 329, 330, 331, 332, 333, 
+	334, 335, 336, 337, 338, 339, 340, 341, 
+	267, 268, 268, 267, 268, 267, 268, 267, 
+	268, 268, 268, 268, 267, 268, 268, 267, 
+	267, 267, 268, 268, 267, 268, 267, 268, 
+	268, 267, 267, 267, 268, 268, 267, 268, 
+	268, 268, 267, 268, 268, 268, 268, 267, 
+	268, 268, 268, 267, 268, 268, 267, 342, 
+	343, 328, 267, 268, 267, 268, 268, 267, 
+	344, 345, 346, 347, 348, 349, 350, 267, 
+	351, 352, 353, 354, 355, 267, 268, 267, 
+	268, 267, 268, 267, 268, 268, 268, 268, 
+	268, 267, 268, 267, 356, 357, 358, 359, 
+	360, 361, 362, 363, 364, 365, 366, 367, 
+	368, 369, 370, 371, 372, 369, 373, 374, 
+	375, 376, 377, 267, 268, 268, 267, 267, 
+	268, 267, 267, 268, 268, 268, 267, 268, 
+	267, 268, 268, 267, 267, 267, 268, 268, 
+	268, 267, 268, 267, 268, 268, 268, 267, 
+	268, 268, 268, 268, 268, 268, 268, 267, 
+	268, 267, 268, 267, 268, 267, 267, 268, 
+	268, 268, 267, 267, 267, 268, 267, 268, 
+	268, 267, 268, 267, 268, 268, 267, 268, 
+	268, 267, 378, 379, 380, 381, 267, 268, 
+	267, 268, 267, 268, 267, 268, 267, 382, 
+	267, 268, 267, 383, 384, 385, 386, 387, 
+	388, 267, 268, 268, 268, 267, 267, 267, 
+	267, 268, 268, 267, 268, 268, 267, 267, 
+	267, 268, 268, 268, 268, 267, 389, 390, 
+	391, 267, 268, 268, 268, 268, 268, 267, 
+	268, 267, 268, 267, 392, 393, 394, 267, 
+	395, 267, 395, 267, 267, 395, 395, 267, 
+	395, 395, 267, 395, 395, 395, 267, 395, 
+	267, 395, 395, 267, 395, 395, 395, 395, 
+	267, 395, 395, 267, 267, 395, 395, 267, 
+	395, 267, 396, 397, 398, 399, 400, 401, 
+	402, 404, 405, 406, 407, 408, 409, 410, 
+	411, 412, 413, 414, 415, 287, 416, 417, 
+	418, 419, 420, 421, 422, 423, 424, 403, 
+	267, 395, 395, 395, 395, 267, 395, 267, 
+	395, 395, 267, 268, 268, 267, 267, 268, 
+	395, 395, 267, 395, 395, 267, 395, 267, 
+	268, 395, 395, 395, 268, 268, 267, 395, 
+	395, 395, 267, 267, 267, 395, 267, 268, 
+	268, 395, 395, 268, 267, 395, 395, 395, 
+	267, 395, 267, 395, 267, 395, 267, 268, 
+	267, 267, 395, 395, 267, 395, 267, 268, 
+	395, 395, 268, 395, 267, 268, 395, 395, 
+	268, 268, 395, 395, 267, 395, 395, 268, 
+	267, 395, 395, 395, 268, 268, 268, 267, 
+	395, 268, 395, 267, 267, 267, 268, 267, 
+	267, 267, 395, 395, 395, 268, 395, 268, 
+	267, 395, 395, 268, 268, 268, 395, 395, 
+	395, 267, 395, 395, 268, 268, 267, 267, 
+	267, 395, 395, 395, 267, 395, 267, 268, 
+	395, 395, 395, 395, 268, 395, 268, 268, 
+	267, 395, 268, 395, 267, 395, 267, 395, 
+	268, 395, 395, 267, 395, 267, 395, 395, 
+	395, 395, 268, 267, 268, 395, 267, 395, 
+	395, 395, 395, 267, 395, 267, 425, 426, 
+	427, 428, 429, 430, 431, 432, 433, 434, 
+	435, 436, 437, 438, 439, 440, 441, 442, 
+	443, 444, 445, 267, 268, 395, 395, 268, 
+	395, 267, 268, 395, 395, 395, 267, 395, 
+	268, 395, 395, 395, 267, 395, 267, 395, 
+	395, 267, 395, 395, 267, 268, 395, 268, 
+	267, 395, 395, 395, 267, 268, 395, 267, 
+	395, 395, 267, 395, 395, 268, 395, 268, 
+	268, 395, 267, 395, 395, 268, 267, 395, 
+	395, 395, 395, 268, 395, 395, 268, 395, 
+	267, 395, 267, 268, 268, 268, 395, 395, 
+	268, 267, 395, 267, 395, 267, 268, 268, 
+	268, 268, 395, 395, 268, 395, 267, 268, 
+	395, 395, 268, 395, 268, 267, 268, 395, 
+	268, 395, 267, 268, 395, 395, 395, 395, 
+	268, 395, 267, 395, 395, 267, 446, 447, 
+	448, 449, 450, 267, 395, 323, 267, 395, 
+	267, 395, 267, 395, 267, 395, 267, 451, 
+	452, 267, 395, 267, 395, 267, 453, 454, 
+	455, 456, 331, 457, 458, 459, 460, 461, 
+	462, 463, 464, 465, 466, 267, 395, 395, 
+	267, 395, 267, 395, 267, 395, 395, 395, 
+	268, 268, 395, 267, 395, 267, 395, 267, 
+	268, 395, 267, 395, 268, 267, 268, 395, 
+	395, 395, 268, 395, 268, 267, 395, 267, 
+	268, 395, 268, 395, 268, 395, 267, 395, 
+	395, 268, 395, 267, 395, 395, 395, 395, 
+	267, 395, 268, 268, 395, 395, 268, 267, 
+	395, 395, 268, 395, 268, 267, 467, 468, 
+	454, 267, 395, 267, 395, 395, 267, 469, 
+	470, 471, 472, 473, 474, 475, 267, 476, 
+	477, 478, 479, 480, 267, 395, 267, 395, 
+	267, 395, 267, 395, 395, 395, 395, 395, 
+	267, 395, 267, 481, 482, 483, 484, 485, 
+	486, 487, 488, 489, 490, 491, 492, 493, 
+	494, 495, 496, 497, 498, 499, 500, 501, 
+	502, 503, 267, 395, 268, 395, 267, 267, 
+	395, 268, 267, 268, 268, 267, 395, 268, 
+	395, 395, 267, 395, 267, 268, 395, 268, 
+	395, 268, 267, 267, 395, 267, 268, 395, 
+	395, 268, 395, 268, 395, 267, 395, 268, 
+	395, 267, 395, 395, 268, 395, 268, 267, 
+	395, 395, 268, 268, 268, 268, 395, 395, 
+	267, 268, 395, 267, 268, 268, 395, 267, 
+	395, 268, 395, 268, 395, 268, 395, 267, 
+	268, 267, 395, 395, 268, 268, 395, 268, 
+	395, 267, 267, 267, 395, 395, 268, 395, 
+	268, 395, 267, 267, 395, 268, 268, 395, 
+	268, 395, 267, 268, 395, 268, 395, 267, 
+	268, 268, 395, 395, 267, 268, 268, 268, 
+	395, 395, 267, 504, 505, 380, 506, 267, 
+	395, 267, 395, 267, 395, 267, 507, 267, 
+	395, 267, 508, 509, 510, 511, 512, 513, 
+	267, 268, 268, 395, 395, 395, 267, 267, 
+	267, 267, 395, 395, 267, 395, 395, 267, 
+	267, 267, 395, 395, 395, 395, 267, 514, 
+	515, 516, 267, 395, 395, 395, 395, 395, 
+	267, 395, 267, 395, 267, 517, 267, 268, 
+	267, 518, 267, 519, 520, 521, 523, 522, 
+	267, 395, 267, 267, 395, 395, 268, 267, 
+	268, 267, 524, 267, 525, 526, 527, 529, 
+	528, 267, 268, 267, 267, 268, 268, 344, 
+	345, 346, 347, 348, 349, 267, 268, 267, 
+	268, 268, 267, 266, 268, 268, 267, 266, 
+	268, 267, 266, 268, 267, 531, 532, 530, 
+	267, 266, 268, 267, 266, 268, 267, 533, 
+	534, 535, 536, 537, 530, 267, 538, 267, 
+	297, 298, 299, 533, 534, 539, 300, 301, 
+	302, 303, 304, 305, 306, 307, 308, 309, 
+	310, 311, 312, 313, 314, 315, 316, 317, 
+	267, 540, 538, 297, 298, 299, 541, 535, 
+	536, 300, 301, 302, 303, 304, 305, 306, 
+	307, 308, 309, 310, 311, 312, 313, 314, 
+	315, 316, 317, 267, 540, 267, 542, 540, 
+	297, 298, 299, 543, 536, 300, 301, 302, 
+	303, 304, 305, 306, 307, 308, 309, 310, 
+	311, 312, 313, 314, 315, 316, 317, 267, 
+	542, 267, 267, 542, 544, 267, 542, 267, 
+	545, 546, 267, 540, 267, 267, 542, 267, 
+	540, 267, 540, 327, 328, 329, 330, 331, 
+	332, 333, 547, 335, 336, 337, 338, 339, 
+	340, 341, 549, 550, 551, 552, 553, 554, 
+	549, 550, 551, 552, 553, 554, 549, 548, 
+	555, 267, 268, 538, 267, 556, 556, 556, 
+	542, 267, 297, 298, 299, 541, 539, 300, 
+	301, 302, 303, 304, 305, 306, 307, 308, 
+	309, 310, 311, 312, 313, 314, 315, 316, 
+	317, 267, 545, 557, 267, 267, 540, 556, 
+	556, 542, 556, 556, 542, 556, 556, 556, 
+	542, 556, 556, 542, 556, 556, 542, 556, 
+	556, 267, 542, 542, 551, 552, 553, 554, 
+	548, 549, 551, 552, 553, 554, 548, 549, 
+	551, 552, 553, 554, 548, 549, 551, 552, 
+	553, 554, 548, 549, 551, 552, 553, 554, 
+	548, 549, 551, 552, 553, 554, 548, 549, 
+	551, 552, 553, 554, 548, 549, 551, 552, 
+	553, 554, 548, 549, 551, 552, 553, 554, 
+	548, 549, 550, 555, 552, 553, 554, 548, 
+	549, 550, 552, 553, 554, 548, 549, 550, 
+	552, 553, 554, 548, 549, 550, 552, 553, 
+	554, 548, 549, 550, 552, 553, 554, 548, 
+	549, 550, 552, 553, 554, 548, 549, 550, 
+	552, 553, 554, 548, 549, 550, 552, 553, 
+	554, 548, 549, 550, 552, 553, 554, 548, 
+	549, 550, 551, 555, 553, 554, 548, 549, 
+	550, 551, 553, 554, 548, 549, 550, 551, 
+	553, 554, 548, 549, 550, 551, 553, 554, 
+	548, 549, 550, 551, 553, 558, 557, 552, 
+	267, 555, 556, 267, 540, 542, 268, 268, 
+	267, 559, 560, 561, 562, 563, 530, 267, 
+	268, 323, 268, 268, 268, 267, 268, 268, 
+	267, 395, 268, 267, 395, 268, 267, 268, 
+	395, 268, 267, 530, 267, 564, 566, 567, 
+	568, 569, 570, 571, 566, 567, 568, 569, 
+	570, 571, 566, 530, 565, 555, 267, 268, 
+	538, 268, 267, 540, 540, 540, 542, 267, 
+	540, 540, 542, 540, 540, 542, 540, 540, 
+	540, 542, 540, 540, 542, 540, 540, 542, 
+	540, 540, 267, 542, 568, 569, 570, 571, 
+	565, 566, 568, 569, 570, 571, 565, 566, 
+	568, 569, 570, 571, 565, 566, 568, 569, 
+	570, 571, 565, 566, 568, 569, 570, 571, 
+	565, 566, 568, 569, 570, 571, 565, 566, 
+	568, 569, 570, 571, 565, 566, 568, 569, 
+	570, 571, 565, 566, 568, 569, 570, 571, 
+	565, 566, 567, 555, 569, 570, 571, 565, 
+	566, 567, 569, 570, 571, 565, 566, 567, 
+	569, 570, 571, 565, 566, 567, 569, 570, 
+	571, 565, 566, 567, 569, 570, 571, 565, 
+	566, 567, 569, 570, 571, 565, 566, 567, 
+	569, 570, 571, 565, 566, 567, 569, 570, 
+	571, 565, 566, 567, 569, 570, 571, 565, 
+	566, 567, 568, 555, 570, 571, 565, 566, 
+	567, 568, 570, 571, 565, 566, 567, 568, 
+	570, 571, 565, 566, 567, 568, 570, 571, 
+	565, 566, 567, 568, 570, 572, 573, 569, 
+	267, 555, 540, 268, 540, 542, 268, 542, 
+	268, 267, 540, 574, 575, 530, 267, 268, 
+	267, 268, 268, 268, 267, 577, 578, 579, 
+	580, 576, 267, 581, 582, 530, 267, 266, 
+	268, 267, 268, 266, 268, 267, 583, 530, 
+	267, 268, 268, 267, 584, 530, 267, 268, 
+	268, 267, 585, 586, 587, 588, 589, 590, 
+	591, 592, 593, 594, 595, 530, 267, 268, 
+	596, 267, 344, 345, 346, 347, 348, 349, 
+	597, 267, 598, 267, 268, 267, 395, 268, 
+	267, 268, 395, 268, 395, 268, 267, 395, 
+	395, 268, 395, 268, 395, 268, 395, 268, 
+	395, 268, 267, 268, 268, 395, 395, 268, 
+	267, 395, 395, 268, 267, 395, 268, 395, 
+	268, 267, 268, 395, 268, 395, 268, 267, 
+	395, 268, 395, 268, 267, 395, 268, 267, 
+	395, 395, 268, 268, 395, 268, 395, 268, 
+	395, 267, 576, 267, 599, 576, 267, 322, 
+	530, 600, 530, 267, 268, 267, 266, 3, 
+	1, 266, 3, 1, 602, 603, 601, 1, 
+	266, 3, 1, 266, 3, 1, 604, 605, 
+	606, 607, 608, 601, 1, 609, 610, 612, 
+	611, 611, 612, 612, 611, 612, 612, 611, 
+	612, 612, 612, 611, 612, 611, 612, 612, 
+	611, 612, 612, 612, 612, 611, 612, 612, 
+	611, 611, 612, 612, 611, 612, 611, 613, 
+	614, 615, 616, 617, 619, 620, 621, 623, 
+	624, 625, 626, 627, 628, 629, 630, 631, 
+	632, 633, 634, 635, 636, 637, 638, 639, 
+	640, 618, 622, 611, 612, 612, 612, 612, 
+	611, 612, 611, 612, 612, 611, 611, 611, 
+	612, 611, 611, 611, 612, 612, 612, 612, 
+	611, 611, 611, 611, 611, 611, 612, 611, 
+	611, 611, 611, 611, 611, 612, 611, 611, 
+	611, 611, 612, 612, 612, 612, 611, 612, 
+	612, 612, 612, 612, 611, 612, 612, 611, 
+	612, 612, 612, 612, 611, 612, 612, 611, 
+	611, 611, 611, 611, 611, 612, 612, 612, 
+	612, 612, 612, 611, 612, 612, 611, 611, 
+	611, 611, 611, 611, 612, 612, 611, 612, 
+	612, 612, 612, 612, 611, 612, 612, 611, 
+	612, 611, 612, 612, 612, 611, 612, 611, 
+	612, 612, 612, 612, 612, 611, 612, 611, 
+	612, 612, 612, 612, 611, 612, 611, 641, 
+	642, 643, 644, 645, 646, 647, 648, 649, 
+	650, 651, 652, 653, 654, 655, 656, 657, 
+	658, 659, 660, 661, 611, 612, 612, 611, 
+	612, 612, 612, 611, 612, 612, 612, 612, 
+	611, 612, 611, 612, 612, 611, 612, 612, 
+	611, 612, 611, 611, 611, 612, 612, 611, 
+	612, 612, 611, 612, 612, 611, 612, 611, 
+	612, 612, 612, 612, 612, 611, 612, 611, 
+	612, 612, 611, 611, 611, 612, 612, 612, 
+	611, 612, 611, 612, 611, 612, 612, 612, 
+	612, 612, 611, 612, 612, 611, 662, 663, 
+	664, 665, 666, 611, 612, 667, 611, 662, 
+	663, 668, 664, 665, 666, 611, 612, 611, 
+	612, 611, 612, 611, 612, 611, 612, 611, 
+	669, 670, 611, 612, 611, 612, 611, 671, 
+	672, 673, 674, 675, 676, 677, 678, 679, 
+	680, 681, 682, 683, 684, 685, 611, 612, 
+	612, 611, 612, 611, 612, 611, 612, 612, 
+	612, 612, 611, 612, 612, 611, 611, 611, 
+	612, 612, 611, 612, 611, 612, 612, 611, 
+	611, 611, 612, 612, 611, 612, 612, 612, 
+	611, 612, 612, 612, 612, 611, 612, 612, 
+	612, 611, 612, 612, 611, 686, 687, 672, 
+	611, 612, 611, 612, 612, 611, 688, 689, 
+	690, 691, 692, 693, 694, 611, 695, 696, 
+	697, 698, 699, 611, 612, 611, 612, 611, 
+	612, 611, 612, 612, 612, 612, 612, 611, 
+	612, 611, 700, 701, 702, 703, 704, 705, 
+	706, 707, 708, 709, 710, 711, 712, 713, 
+	714, 715, 716, 713, 717, 718, 719, 720, 
+	721, 611, 612, 612, 611, 611, 612, 611, 
+	611, 612, 612, 612, 611, 612, 611, 612, 
+	612, 611, 611, 611, 612, 612, 612, 611, 
+	612, 611, 612, 612, 612, 611, 612, 612, 
+	612, 612, 612, 612, 612, 611, 612, 611, 
+	612, 611, 612, 611, 611, 612, 612, 612, 
+	611, 611, 611, 612, 611, 612, 612, 611, 
+	612, 611, 612, 612, 611, 612, 612, 611, 
+	722, 723, 724, 725, 611, 612, 611, 612, 
+	611, 612, 611, 612, 611, 726, 611, 612, 
+	611, 727, 728, 729, 730, 731, 732, 611, 
+	612, 612, 612, 611, 611, 611, 611, 612, 
+	612, 611, 612, 612, 611, 611, 611, 612, 
+	612, 612, 612, 611, 733, 734, 735, 611, 
+	612, 612, 612, 612, 612, 611, 612, 611, 
+	612, 611, 736, 737, 738, 611, 739, 611, 
+	739, 611, 611, 739, 739, 611, 739, 739, 
+	611, 739, 739, 739, 611, 739, 611, 739, 
+	739, 611, 739, 739, 739, 739, 611, 739, 
+	739, 611, 611, 739, 739, 611, 739, 611, 
+	740, 741, 742, 743, 744, 745, 746, 748, 
+	749, 750, 751, 752, 753, 754, 755, 756, 
+	757, 758, 759, 631, 760, 761, 762, 763, 
+	764, 765, 766, 767, 768, 747, 611, 739, 
+	739, 739, 739, 611, 739, 611, 739, 739, 
+	611, 612, 612, 611, 611, 612, 739, 739, 
+	611, 739, 739, 611, 739, 611, 612, 739, 
+	739, 739, 612, 612, 611, 739, 739, 739, 
+	611, 611, 611, 739, 611, 612, 612, 739, 
+	739, 612, 611, 739, 739, 739, 611, 739, 
+	611, 739, 611, 739, 611, 612, 611, 611, 
+	739, 739, 611, 739, 611, 612, 739, 739, 
+	612, 739, 611, 612, 739, 739, 612, 612, 
+	739, 739, 611, 739, 739, 612, 611, 739, 
+	739, 739, 612, 612, 612, 611, 739, 612, 
+	739, 611, 611, 611, 612, 611, 611, 611, 
+	739, 739, 739, 612, 739, 612, 611, 739, 
+	739, 612, 612, 612, 739, 739, 739, 611, 
+	739, 739, 612, 612, 611, 611, 611, 739, 
+	739, 739, 611, 739, 611, 612, 739, 739, 
+	739, 739, 612, 739, 612, 612, 611, 739, 
+	612, 739, 611, 739, 611, 739, 612, 739, 
+	739, 611, 739, 611, 739, 739, 739, 739, 
+	612, 611, 612, 739, 611, 739, 739, 739, 
+	739, 611, 739, 611, 769, 770, 771, 772, 
+	773, 774, 775, 776, 777, 778, 779, 780, 
+	781, 782, 783, 784, 785, 786, 787, 788, 
+	789, 611, 612, 739, 739, 612, 739, 611, 
+	612, 739, 739, 739, 611, 739, 612, 739, 
+	739, 739, 611, 739, 611, 739, 739, 611, 
+	739, 739, 611, 612, 739, 612, 611, 739, 
+	739, 739, 611, 612, 739, 611, 739, 739, 
+	611, 739, 739, 612, 739, 612, 612, 739, 
+	611, 739, 739, 612, 611, 739, 739, 739, 
+	739, 612, 739, 739, 612, 739, 611, 739, 
+	611, 612, 612, 612, 739, 739, 612, 611, 
+	739, 611, 739, 611, 612, 612, 612, 612, 
+	739, 739, 612, 739, 611, 612, 739, 739, 
+	612, 739, 612, 611, 612, 739, 612, 739, 
+	611, 612, 739, 739, 739, 739, 612, 739, 
+	611, 739, 739, 611, 790, 791, 792, 793, 
+	794, 611, 739, 667, 611, 739, 611, 739, 
+	611, 739, 611, 739, 611, 795, 796, 611, 
+	739, 611, 739, 611, 797, 798, 799, 800, 
+	675, 801, 802, 803, 804, 805, 806, 807, 
+	808, 809, 810, 611, 739, 739, 611, 739, 
+	611, 739, 611, 739, 739, 739, 612, 612, 
+	739, 611, 739, 611, 739, 611, 612, 739, 
+	611, 739, 612, 611, 612, 739, 739, 739, 
+	612, 739, 612, 611, 739, 611, 612, 739, 
+	612, 739, 612, 739, 611, 739, 739, 612, 
+	739, 611, 739, 739, 739, 739, 611, 739, 
+	612, 612, 739, 739, 612, 611, 739, 739, 
+	612, 739, 612, 611, 811, 812, 798, 611, 
+	739, 611, 739, 739, 611, 813, 814, 815, 
+	816, 817, 818, 819, 611, 820, 821, 822, 
+	823, 824, 611, 739, 611, 739, 611, 739, 
+	611, 739, 739, 739, 739, 739, 611, 739, 
+	611, 825, 826, 827, 828, 829, 830, 831, 
+	832, 833, 834, 835, 836, 837, 838, 839, 
+	840, 841, 842, 843, 844, 845, 846, 847, 
+	611, 739, 612, 739, 611, 611, 739, 612, 
+	611, 612, 612, 611, 739, 612, 739, 739, 
+	611, 739, 611, 612, 739, 612, 739, 612, 
+	611, 611, 739, 611, 612, 739, 739, 612, 
+	739, 612, 739, 611, 739, 612, 739, 611, 
+	739, 739, 612, 739, 612, 611, 739, 739, 
+	612, 612, 612, 612, 739, 739, 611, 612, 
+	739, 611, 612, 612, 739, 611, 739, 612, 
+	739, 612, 739, 612, 739, 611, 612, 611, 
+	739, 739, 612, 612, 739, 612, 739, 611, 
+	611, 611, 739, 739, 612, 739, 612, 739, 
+	611, 611, 739, 612, 612, 739, 612, 739, 
+	611, 612, 739, 612, 739, 611, 612, 612, 
+	739, 739, 611, 612, 612, 612, 739, 739, 
+	611, 848, 849, 724, 850, 611, 739, 611, 
+	739, 611, 739, 611, 851, 611, 739, 611, 
+	852, 853, 854, 855, 856, 857, 611, 612, 
+	612, 739, 739, 739, 611, 611, 611, 611, 
+	739, 739, 611, 739, 739, 611, 611, 611, 
+	739, 739, 739, 739, 611, 858, 859, 860, 
+	611, 739, 739, 739, 739, 739, 611, 739, 
+	611, 739, 611, 861, 611, 612, 611, 862, 
+	611, 863, 864, 865, 867, 866, 611, 739, 
+	611, 611, 739, 739, 612, 611, 612, 611, 
+	868, 611, 869, 870, 871, 873, 872, 611, 
+	612, 611, 611, 612, 612, 688, 689, 690, 
+	691, 692, 693, 611, 641, 642, 643, 604, 
+	605, 874, 644, 645, 646, 647, 648, 649, 
+	650, 651, 652, 653, 654, 655, 656, 657, 
+	658, 659, 660, 661, 611, 875, 610, 641, 
+	642, 643, 876, 606, 607, 644, 645, 646, 
+	647, 648, 649, 650, 651, 652, 653, 654, 
+	655, 656, 657, 658, 659, 660, 661, 611, 
+	875, 611, 877, 875, 641, 642, 643, 878, 
+	607, 644, 645, 646, 647, 648, 649, 650, 
+	651, 652, 653, 654, 655, 656, 657, 658, 
+	659, 660, 661, 611, 877, 611, 609, 877, 
+	879, 611, 877, 611, 880, 881, 611, 875, 
+	611, 611, 877, 611, 875, 611, 875, 671, 
+	672, 673, 674, 675, 676, 677, 882, 679, 
+	680, 681, 682, 683, 684, 685, 884, 885, 
+	886, 887, 888, 889, 884, 885, 886, 887, 
+	888, 889, 884, 883, 890, 611, 612, 610, 
+	611, 891, 891, 891, 877, 611, 641, 642, 
+	643, 876, 874, 644, 645, 646, 647, 648, 
+	649, 650, 651, 652, 653, 654, 655, 656, 
+	657, 658, 659, 660, 661, 611, 880, 892, 
+	611, 611, 875, 891, 891, 877, 891, 891, 
+	877, 891, 891, 891, 877, 891, 891, 877, 
+	891, 891, 877, 891, 891, 611, 877, 877, 
+	886, 887, 888, 889, 883, 884, 886, 887, 
+	888, 889, 883, 884, 886, 887, 888, 889, 
+	883, 884, 886, 887, 888, 889, 883, 884, 
+	886, 887, 888, 889, 883, 884, 886, 887, 
+	888, 889, 883, 884, 886, 887, 888, 889, 
+	883, 884, 886, 887, 888, 889, 883, 884, 
+	886, 887, 888, 889, 883, 884, 885, 890, 
+	887, 888, 889, 883, 884, 885, 887, 888, 
+	889, 883, 884, 885, 887, 888, 889, 883, 
+	884, 885, 887, 888, 889, 883, 884, 885, 
+	887, 888, 889, 883, 884, 885, 887, 888, 
+	889, 883, 884, 885, 887, 888, 889, 883, 
+	884, 885, 887, 888, 889, 883, 884, 885, 
+	887, 888, 889, 883, 884, 885, 886, 890, 
+	888, 889, 883, 884, 885, 886, 888, 889, 
+	883, 884, 885, 886, 888, 889, 883, 884, 
+	885, 886, 888, 889, 883, 884, 885, 886, 
+	888, 893, 892, 887, 611, 890, 891, 611, 
+	875, 877, 265, 3, 1, 894, 895, 896, 
+	897, 898, 601, 1, 265, 899, 3, 265, 
+	3, 265, 3, 1, 901, 900, 900, 901, 
+	901, 900, 901, 901, 900, 901, 901, 901, 
+	900, 901, 900, 901, 901, 900, 901, 901, 
+	901, 901, 900, 901, 901, 900, 900, 901, 
+	901, 900, 901, 900, 902, 903, 904, 905, 
+	906, 908, 909, 910, 912, 913, 914, 915, 
+	916, 917, 918, 919, 920, 921, 922, 923, 
+	924, 925, 926, 927, 928, 929, 907, 911, 
+	900, 901, 901, 901, 901, 900, 901, 900, 
+	901, 901, 900, 900, 900, 901, 900, 900, 
+	900, 901, 901, 901, 901, 900, 900, 900, 
+	900, 900, 900, 901, 900, 900, 900, 900, 
+	900, 900, 901, 900, 900, 900, 900, 901, 
+	901, 901, 901, 900, 901, 901, 901, 901, 
+	901, 900, 901, 901, 900, 901, 901, 901, 
+	901, 900, 901, 901, 900, 900, 900, 900, 
+	900, 900, 901, 901, 901, 901, 901, 901, 
+	900, 901, 901, 900, 900, 900, 900, 900, 
+	900, 901, 901, 900, 901, 901, 901, 901, 
+	901, 900, 901, 901, 900, 901, 900, 901, 
+	901, 901, 900, 901, 900, 901, 901, 901, 
+	901, 901, 900, 901, 900, 901, 901, 901, 
+	901, 900, 901, 900, 930, 931, 932, 933, 
+	934, 935, 936, 937, 938, 939, 940, 941, 
+	942, 943, 944, 945, 946, 947, 948, 949, 
+	950, 900, 901, 901, 900, 901, 901, 901, 
+	900, 901, 901, 901, 901, 900, 901, 900, 
+	901, 901, 900, 901, 901, 900, 901, 900, 
+	900, 900, 901, 901, 900, 901, 901, 900, 
+	901, 901, 900, 901, 900, 901, 901, 901, 
+	901, 901, 900, 901, 900, 901, 901, 900, 
+	900, 900, 901, 901, 901, 900, 901, 900, 
+	901, 900, 901, 901, 901, 901, 901, 900, 
+	901, 901, 900, 951, 952, 953, 954, 955, 
+	900, 901, 899, 900, 901, 900, 901, 900, 
+	901, 900, 901, 900, 956, 957, 900, 901, 
+	900, 901, 900, 958, 959, 960, 961, 962, 
+	963, 964, 965, 966, 967, 968, 969, 970, 
+	971, 972, 900, 901, 901, 900, 901, 900, 
+	901, 900, 901, 901, 901, 901, 900, 901, 
+	901, 900, 900, 900, 901, 901, 900, 901, 
+	900, 901, 901, 900, 900, 900, 901, 901, 
+	900, 901, 901, 901, 900, 901, 901, 901, 
+	901, 900, 901, 901, 901, 900, 901, 901, 
+	900, 973, 974, 959, 900, 901, 900, 901, 
+	901, 900, 975, 976, 977, 978, 979, 980, 
+	900, 981, 982, 983, 984, 985, 900, 901, 
+	900, 901, 900, 901, 900, 901, 901, 901, 
+	901, 901, 900, 901, 900, 986, 987, 988, 
+	989, 990, 991, 992, 993, 994, 995, 996, 
+	997, 998, 999, 1000, 1001, 1002, 999, 1003, 
+	1004, 1005, 1006, 1007, 900, 901, 901, 900, 
+	900, 901, 900, 900, 901, 901, 901, 900, 
+	901, 900, 901, 901, 900, 900, 900, 901, 
+	901, 901, 900, 901, 900, 901, 901, 901, 
+	900, 901, 901, 901, 901, 901, 901, 901, 
+	900, 901, 900, 901, 900, 901, 900, 900, 
+	901, 901, 901, 900, 900, 900, 901, 900, 
+	901, 901, 900, 901, 900, 901, 901, 900, 
+	901, 901, 900, 1008, 1009, 1010, 1011, 900, 
+	901, 900, 901, 900, 901, 900, 901, 900, 
+	1012, 900, 901, 900, 1013, 1014, 1015, 1016, 
+	1017, 1018, 900, 901, 901, 901, 900, 900, 
+	900, 900, 901, 901, 900, 901, 901, 900, 
+	900, 900, 901, 901, 901, 901, 900, 1019, 
+	1020, 1021, 900, 901, 901, 901, 901, 901, 
+	900, 901, 900, 901, 900, 1022, 900, 1023, 
+	1024, 1025, 1027, 1026, 900, 901, 900, 900, 
+	901, 901, 951, 952, 1028, 953, 954, 955, 
+	900, 901, 900, 975, 976, 977, 978, 979, 
+	980, 1029, 900, 1030, 1031, 1032, 900, 1033, 
+	900, 1033, 900, 900, 1033, 1033, 900, 1033, 
+	1033, 900, 1033, 1033, 1033, 900, 1033, 900, 
+	1033, 1033, 900, 1033, 1033, 1033, 1033, 900, 
+	1033, 1033, 900, 900, 1033, 1033, 900, 1033, 
+	900, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 
+	1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 
+	1050, 1051, 1052, 1053, 920, 1054, 1055, 1056, 
+	1057, 1058, 1059, 1060, 1061, 1062, 1041, 900, 
+	1033, 1033, 1033, 1033, 900, 1033, 900, 1033, 
+	1033, 900, 901, 901, 900, 900, 901, 1033, 
+	1033, 900, 1033, 1033, 900, 1033, 900, 901, 
+	1033, 1033, 1033, 901, 901, 900, 1033, 1033, 
+	1033, 900, 900, 900, 1033, 900, 901, 901, 
+	1033, 1033, 901, 900, 1033, 1033, 1033, 900, 
+	1033, 900, 1033, 900, 1033, 900, 901, 900, 
+	900, 1033, 1033, 900, 1033, 900, 901, 1033, 
+	1033, 901, 1033, 900, 901, 1033, 1033, 901, 
+	901, 1033, 1033, 900, 1033, 1033, 901, 900, 
+	1033, 1033, 1033, 901, 901, 901, 900, 1033, 
+	901, 1033, 900, 900, 900, 901, 900, 900, 
+	900, 1033, 1033, 1033, 901, 1033, 901, 900, 
+	1033, 1033, 901, 901, 901, 1033, 1033, 1033, 
+	900, 1033, 1033, 901, 901, 900, 900, 900, 
+	1033, 1033, 1033, 900, 1033, 900, 901, 1033, 
+	1033, 1033, 1033, 901, 1033, 901, 901, 900, 
+	1033, 901, 1033, 900, 1033, 900, 1033, 901, 
+	1033, 1033, 900, 1033, 900, 1033, 1033, 1033, 
+	1033, 901, 900, 901, 1033, 900, 1033, 1033, 
+	1033, 1033, 900, 1033, 900, 1063, 1064, 1065, 
+	1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 
+	1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 
+	1082, 1083, 900, 901, 1033, 1033, 901, 1033, 
+	900, 901, 1033, 1033, 1033, 900, 1033, 901, 
+	1033, 1033, 1033, 900, 1033, 900, 1033, 1033, 
+	900, 1033, 1033, 900, 901, 1033, 901, 900, 
+	1033, 1033, 1033, 900, 901, 1033, 900, 1033, 
+	1033, 900, 1033, 1033, 901, 1033, 901, 901, 
+	1033, 900, 1033, 1033, 901, 900, 1033, 1033, 
+	1033, 1033, 901, 1033, 1033, 901, 1033, 900, 
+	1033, 900, 901, 901, 901, 1033, 1033, 901, 
+	900, 1033, 900, 1033, 900, 901, 901, 901, 
+	901, 1033, 1033, 901, 1033, 900, 901, 1033, 
+	1033, 901, 1033, 901, 900, 901, 1033, 901, 
+	1033, 900, 901, 1033, 1033, 1033, 1033, 901, 
+	1033, 900, 1033, 1033, 900, 1084, 1085, 1086, 
+	1087, 1088, 900, 1033, 899, 900, 1033, 900, 
+	1033, 900, 1033, 900, 1033, 900, 1089, 1090, 
+	900, 1033, 900, 1033, 900, 1091, 1092, 1093, 
+	1094, 962, 1095, 1096, 1097, 1098, 1099, 1100, 
+	1101, 1102, 1103, 1104, 900, 1033, 1033, 900, 
+	1033, 900, 1033, 900, 1033, 1033, 1033, 901, 
+	901, 1033, 900, 1033, 900, 1033, 900, 901, 
+	1033, 900, 1033, 901, 900, 901, 1033, 1033, 
+	1033, 901, 1033, 901, 900, 1033, 900, 901, 
+	1033, 901, 1033, 901, 1033, 900, 1033, 1033, 
+	901, 1033, 900, 1033, 1033, 1033, 1033, 900, 
+	1033, 901, 901, 1033, 1033, 901, 900, 1033, 
+	1033, 901, 1033, 901, 900, 1105, 1106, 1092, 
+	900, 1033, 900, 1033, 1033, 900, 1107, 1108, 
+	1109, 1110, 1111, 1112, 1113, 900, 1114, 1115, 
+	1116, 1117, 1118, 900, 1033, 900, 1033, 900, 
+	1033, 900, 1033, 1033, 1033, 1033, 1033, 900, 
+	1033, 900, 1119, 1120, 1121, 1122, 1123, 1124, 
+	1125, 1126, 1127, 1128, 1129, 1130, 1131, 1132, 
+	1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 
+	1141, 900, 1033, 901, 1033, 900, 900, 1033, 
+	901, 900, 901, 901, 900, 1033, 901, 1033, 
+	1033, 900, 1033, 900, 901, 1033, 901, 1033, 
+	901, 900, 900, 1033, 900, 901, 1033, 1033, 
+	901, 1033, 901, 1033, 900, 1033, 901, 1033, 
+	900, 1033, 1033, 901, 1033, 901, 900, 1033, 
+	1033, 901, 901, 901, 901, 1033, 1033, 900, 
+	901, 1033, 900, 901, 901, 1033, 900, 1033, 
+	901, 1033, 901, 1033, 901, 1033, 900, 901, 
+	900, 1033, 1033, 901, 901, 1033, 901, 1033, 
+	900, 900, 900, 1033, 1033, 901, 1033, 901, 
+	1033, 900, 900, 1033, 901, 901, 1033, 901, 
+	1033, 900, 901, 1033, 901, 1033, 900, 901, 
+	901, 1033, 1033, 900, 901, 901, 901, 1033, 
+	1033, 900, 1142, 1143, 1010, 1144, 900, 1033, 
+	900, 1033, 900, 1033, 900, 1145, 900, 1033, 
+	900, 1146, 1147, 1148, 1149, 1150, 1151, 900, 
+	901, 901, 1033, 1033, 1033, 900, 900, 900, 
+	900, 1033, 1033, 900, 1033, 1033, 900, 900, 
+	900, 1033, 1033, 1033, 1033, 900, 1152, 1153, 
+	1154, 900, 1033, 1033, 1033, 1033, 1033, 900, 
+	1033, 900, 1033, 900, 1155, 900, 901, 900, 
+	1156, 900, 1157, 1158, 1159, 1161, 1160, 900, 
+	1033, 900, 900, 1033, 1033, 901, 900, 901, 
+	900, 3, 265, 3, 1, 1162, 3, 1, 
+	1162, 1163, 1163, 1162, 1162, 1163, 1162, 1162, 
+	1163, 1162, 1162, 1162, 1163, 1162, 1163, 1162, 
+	1162, 1163, 1162, 1162, 1162, 1162, 1163, 1162, 
+	1162, 1163, 1163, 1162, 1162, 1163, 1162, 1163, 
+	1164, 1165, 1166, 1167, 1168, 1169, 1170, 1172, 
+	1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 
+	1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 
+	1189, 1190, 1191, 1192, 1193, 1171, 1163, 1162, 
+	1162, 1162, 1162, 1163, 1162, 1163, 1162, 1162, 
+	1163, 1194, 1194, 1163, 1163, 1194, 1162, 1194, 
+	1163, 1163, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1194, 1194, 1194, 1163, 1194, 1163, 1194, 1194, 
+	1163, 1194, 1194, 1194, 1194, 1163, 1194, 1194, 
+	1163, 1163, 1194, 1194, 1163, 1194, 1163, 1195, 
+	1196, 1197, 1198, 1199, 1201, 1202, 1203, 1205, 
+	1206, 1207, 1208, 1209, 1210, 1211, 1212, 1184, 
+	1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 
+	1221, 1200, 1204, 1163, 1194, 1194, 1194, 1194, 
+	1163, 1194, 1163, 1194, 1194, 1163, 1163, 1163, 
+	1194, 1163, 1163, 1163, 1194, 1194, 1194, 1194, 
+	1163, 1163, 1163, 1163, 1163, 1163, 1194, 1163, 
+	1163, 1163, 1163, 1163, 1163, 1194, 1163, 1163, 
+	1163, 1163, 1194, 1194, 1194, 1194, 1163, 1194, 
+	1194, 1194, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1194, 1194, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1163, 1163, 1163, 1163, 1163, 1194, 1194, 1194, 
+	1194, 1194, 1194, 1163, 1194, 1194, 1163, 1163, 
+	1163, 1163, 1163, 1163, 1194, 1194, 1163, 1194, 
+	1194, 1194, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1194, 1163, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1194, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1194, 1194, 1194, 1163, 1194, 1163, 1222, 
+	1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 
+	1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 
+	1239, 1240, 1241, 1242, 1163, 1194, 1194, 1163, 
+	1194, 1194, 1194, 1163, 1194, 1194, 1194, 1194, 
+	1163, 1194, 1163, 1194, 1194, 1163, 1194, 1194, 
+	1163, 1194, 1163, 1163, 1163, 1194, 1194, 1163, 
+	1194, 1194, 1163, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1194, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1194, 1163, 1163, 1163, 1194, 1194, 1194, 
+	1163, 1194, 1163, 1194, 1163, 1194, 1194, 1194, 
+	1194, 1194, 1163, 1194, 1194, 1163, 1243, 1244, 
+	1245, 1246, 1247, 1163, 1194, 1248, 1163, 1243, 
+	1244, 1249, 1245, 1246, 1247, 1163, 1194, 1163, 
+	1194, 1163, 1194, 1163, 1194, 1163, 1194, 1163, 
+	1250, 1251, 1163, 1194, 1163, 1194, 1163, 1252, 
+	1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260, 
+	1261, 1262, 1263, 1264, 1265, 1266, 1163, 1194, 
+	1194, 1163, 1194, 1163, 1194, 1163, 1194, 1194, 
+	1194, 1194, 1163, 1194, 1194, 1163, 1163, 1163, 
+	1194, 1194, 1163, 1194, 1163, 1194, 1194, 1163, 
+	1163, 1163, 1194, 1194, 1163, 1194, 1194, 1194, 
+	1163, 1194, 1194, 1194, 1194, 1163, 1194, 1194, 
+	1194, 1163, 1194, 1194, 1163, 1267, 1268, 1253, 
+	1163, 1194, 1163, 1194, 1194, 1163, 1269, 1270, 
+	1271, 1272, 1273, 1274, 1275, 1163, 1276, 1277, 
+	1278, 1279, 1280, 1163, 1194, 1163, 1194, 1163, 
+	1194, 1163, 1194, 1194, 1194, 1194, 1194, 1163, 
+	1194, 1163, 1281, 1282, 1283, 1284, 1285, 1286, 
+	1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 
+	1295, 1296, 1297, 1294, 1298, 1299, 1300, 1301, 
+	1302, 1163, 1194, 1194, 1163, 1163, 1194, 1163, 
+	1163, 1194, 1194, 1194, 1163, 1194, 1163, 1194, 
+	1194, 1163, 1163, 1163, 1194, 1194, 1194, 1163, 
+	1194, 1163, 1194, 1194, 1194, 1163, 1194, 1194, 
+	1194, 1194, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1163, 1194, 1163, 1163, 1194, 1194, 1194, 
+	1163, 1163, 1163, 1194, 1163, 1194, 1194, 1163, 
+	1194, 1163, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1303, 1304, 1305, 1306, 1163, 1194, 1163, 1194, 
+	1163, 1194, 1163, 1194, 1163, 1307, 1163, 1194, 
+	1163, 1308, 1309, 1310, 1311, 1312, 1313, 1163, 
+	1194, 1194, 1194, 1163, 1163, 1163, 1163, 1194, 
+	1194, 1163, 1194, 1194, 1163, 1163, 1163, 1194, 
+	1194, 1194, 1194, 1163, 1314, 1315, 1316, 1163, 
+	1194, 1194, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1163, 1317, 1318, 1319, 1163, 1162, 1163, 
+	1194, 1163, 1194, 1163, 1320, 1163, 1321, 1322, 
+	1323, 1325, 1324, 1163, 1194, 1163, 1163, 1194, 
+	1194, 1269, 1270, 1271, 1272, 1273, 1274, 1163, 
+	1162, 1163, 1162, 1162, 1163, 1162, 1163, 1194, 
+	1162, 1162, 1162, 1194, 1194, 1163, 1162, 1162, 
+	1162, 1163, 1163, 1163, 1162, 1163, 1194, 1194, 
+	1162, 1162, 1194, 1163, 1162, 1162, 1162, 1163, 
+	1162, 1163, 1162, 1163, 1162, 1163, 1194, 1163, 
+	1163, 1162, 1162, 1163, 1162, 1163, 1194, 1162, 
+	1162, 1194, 1162, 1163, 1194, 1162, 1162, 1194, 
+	1194, 1162, 1162, 1163, 1162, 1162, 1194, 1163, 
+	1162, 1162, 1162, 1194, 1194, 1194, 1163, 1162, 
+	1194, 1162, 1163, 1163, 1163, 1194, 1163, 1163, 
+	1163, 1162, 1162, 1162, 1194, 1162, 1194, 1163, 
+	1162, 1162, 1194, 1194, 1194, 1162, 1162, 1162, 
+	1163, 1162, 1162, 1194, 1194, 1163, 1163, 1163, 
+	1162, 1162, 1162, 1163, 1162, 1163, 1194, 1162, 
+	1162, 1162, 1162, 1194, 1162, 1194, 1194, 1163, 
+	1162, 1194, 1162, 1163, 1162, 1163, 1162, 1194, 
+	1162, 1162, 1163, 1162, 1163, 1162, 1162, 1162, 
+	1162, 1194, 1163, 1194, 1162, 1163, 1162, 1162, 
+	1162, 1162, 1163, 1162, 1163, 1326, 1327, 1328, 
+	1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 
+	1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 
+	1345, 1346, 1163, 1194, 1162, 1162, 1194, 1162, 
+	1163, 1194, 1162, 1162, 1162, 1163, 1162, 1194, 
+	1162, 1162, 1162, 1163, 1162, 1163, 1162, 1162, 
+	1163, 1162, 1162, 1163, 1194, 1162, 1194, 1163, 
+	1162, 1162, 1162, 1163, 1194, 1162, 1163, 1162, 
+	1162, 1163, 1162, 1162, 1194, 1162, 1194, 1194, 
+	1162, 1163, 1162, 1162, 1194, 1163, 1162, 1162, 
+	1162, 1162, 1194, 1162, 1162, 1194, 1162, 1163, 
+	1162, 1163, 1194, 1194, 1194, 1162, 1162, 1194, 
+	1163, 1162, 1163, 1162, 1163, 1194, 1194, 1194, 
+	1194, 1162, 1162, 1194, 1162, 1163, 1194, 1162, 
+	1162, 1194, 1162, 1194, 1163, 1194, 1162, 1194, 
+	1162, 1163, 1194, 1162, 1162, 1162, 1162, 1194, 
+	1162, 1163, 1162, 1162, 1163, 1347, 1348, 1349, 
+	1350, 1351, 1163, 1162, 1248, 1163, 1162, 1163, 
+	1162, 1163, 1162, 1163, 1162, 1163, 1352, 1353, 
+	1163, 1162, 1163, 1162, 1163, 1354, 1355, 1356, 
+	1357, 1256, 1358, 1359, 1360, 1361, 1362, 1363, 
+	1364, 1365, 1366, 1367, 1163, 1162, 1162, 1163, 
+	1162, 1163, 1162, 1163, 1162, 1162, 1162, 1194, 
+	1194, 1162, 1163, 1162, 1163, 1162, 1163, 1194, 
+	1162, 1163, 1162, 1194, 1163, 1194, 1162, 1162, 
+	1162, 1194, 1162, 1194, 1163, 1162, 1163, 1194, 
+	1162, 1194, 1162, 1194, 1162, 1163, 1162, 1162, 
+	1194, 1162, 1163, 1162, 1162, 1162, 1162, 1163, 
+	1162, 1194, 1194, 1162, 1162, 1194, 1163, 1162, 
+	1162, 1194, 1162, 1194, 1163, 1368, 1369, 1355, 
+	1163, 1162, 1163, 1162, 1162, 1163, 1370, 1371, 
+	1372, 1373, 1374, 1375, 1376, 1163, 1377, 1378, 
+	1379, 1380, 1381, 1163, 1162, 1163, 1162, 1163, 
+	1162, 1163, 1162, 1162, 1162, 1162, 1162, 1163, 
+	1162, 1163, 1382, 1383, 1384, 1385, 1386, 1387, 
+	1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 
+	1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 
+	1404, 1163, 1162, 1194, 1162, 1163, 1163, 1162, 
+	1194, 1163, 1194, 1194, 1163, 1162, 1194, 1162, 
+	1162, 1163, 1162, 1163, 1194, 1162, 1194, 1162, 
+	1194, 1163, 1163, 1162, 1163, 1194, 1162, 1162, 
+	1194, 1162, 1194, 1162, 1163, 1162, 1194, 1162, 
+	1163, 1162, 1162, 1194, 1162, 1194, 1163, 1162, 
+	1162, 1194, 1194, 1194, 1194, 1162, 1162, 1163, 
+	1194, 1162, 1163, 1194, 1194, 1162, 1163, 1162, 
+	1194, 1162, 1194, 1162, 1194, 1162, 1163, 1194, 
+	1163, 1162, 1162, 1194, 1194, 1162, 1194, 1162, 
+	1163, 1163, 1163, 1162, 1162, 1194, 1162, 1194, 
+	1162, 1163, 1163, 1162, 1194, 1194, 1162, 1194, 
+	1162, 1163, 1194, 1162, 1194, 1162, 1163, 1194, 
+	1194, 1162, 1162, 1163, 1194, 1194, 1194, 1162, 
+	1162, 1163, 1405, 1406, 1305, 1407, 1163, 1162, 
+	1163, 1162, 1163, 1162, 1163, 1408, 1163, 1162, 
+	1163, 1409, 1410, 1411, 1412, 1413, 1414, 1163, 
+	1194, 1194, 1162, 1162, 1162, 1163, 1163, 1163, 
+	1163, 1162, 1162, 1163, 1162, 1162, 1163, 1163, 
+	1163, 1162, 1162, 1162, 1162, 1163, 1415, 1416, 
+	1417, 1163, 1162, 1162, 1162, 1162, 1162, 1163, 
+	1162, 1163, 1162, 1163, 1418, 1163, 1194, 1163, 
+	1419, 1163, 1420, 1421, 1422, 1424, 1423, 1163, 
+	1162, 1163, 1163, 1162, 1162, 1162, 3, 1, 
+	3, 1162, 3, 1, 601, 1, 1425, 1427, 
+	1428, 1429, 1430, 1431, 1432, 1427, 1428, 1429, 
+	1430, 1431, 1432, 1427, 601, 1426, 890, 1, 
+	3, 610, 3, 1, 875, 875, 875, 877, 
+	1, 875, 875, 877, 875, 875, 877, 875, 
+	875, 875, 877, 875, 875, 877, 875, 875, 
+	877, 875, 875, 1, 877, 1429, 1430, 1431, 
+	1432, 1426, 1427, 1429, 1430, 1431, 1432, 1426, 
+	1427, 1429, 1430, 1431, 1432, 1426, 1427, 1429, 
+	1430, 1431, 1432, 1426, 1427, 1429, 1430, 1431, 
+	1432, 1426, 1427, 1429, 1430, 1431, 1432, 1426, 
+	1427, 1429, 1430, 1431, 1432, 1426, 1427, 1429, 
+	1430, 1431, 1432, 1426, 1427, 1429, 1430, 1431, 
+	1432, 1426, 1427, 1428, 890, 1430, 1431, 1432, 
+	1426, 1427, 1428, 1430, 1431, 1432, 1426, 1427, 
+	1428, 1430, 1431, 1432, 1426, 1427, 1428, 1430, 
+	1431, 1432, 1426, 1427, 1428, 1430, 1431, 1432, 
+	1426, 1427, 1428, 1430, 1431, 1432, 1426, 1427, 
+	1428, 1430, 1431, 1432, 1426, 1427, 1428, 1430, 
+	1431, 1432, 1426, 1427, 1428, 1430, 1431, 1432, 
+	1426, 1427, 1428, 1429, 890, 1431, 1432, 1426, 
+	1427, 1428, 1429, 1431, 1432, 1426, 1427, 1428, 
+	1429, 1431, 1432, 1426, 1427, 1428, 1429, 1431, 
+	1432, 1426, 1427, 1428, 1429, 1431, 1433, 1434, 
+	1435, 1437, 1430, 1436, 1, 890, 875, 3, 
+	875, 877, 3, 877, 3, 1, 875, 1, 
+	265, 265, 1, 265, 1438, 1439, 601, 1, 
+	265, 3, 1, 3, 3, 265, 3, 1, 
+	1441, 1442, 1443, 1444, 1440, 1, 1445, 1446, 
+	601, 1, 266, 3, 1, 3, 266, 3, 
+	1, 1447, 601, 1, 3, 265, 3, 1, 
+	1448, 601, 1, 3, 265, 3, 1, 1449, 
+	1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 
+	1458, 1459, 601, 1, 3, 1460, 1, 1462, 
+	1461, 1461, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1462, 1462, 1462, 1461, 1462, 1461, 1462, 1462, 
+	1461, 1462, 1462, 1462, 1462, 1461, 1462, 1462, 
+	1461, 1461, 1462, 1462, 1461, 1462, 1461, 1463, 
+	1464, 1465, 1466, 1467, 1469, 1470, 1471, 1473, 
+	1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481, 
+	1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 
+	1490, 1468, 1472, 1461, 1462, 1462, 1462, 1462, 
+	1461, 1462, 1461, 1462, 1462, 1461, 1461, 1461, 
+	1462, 1461, 1461, 1461, 1462, 1462, 1462, 1462, 
+	1461, 1461, 1461, 1461, 1461, 1461, 1462, 1461, 
+	1461, 1461, 1461, 1461, 1461, 1462, 1461, 1461, 
+	1461, 1461, 1462, 1462, 1462, 1462, 1461, 1462, 
+	1462, 1462, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1462, 1462, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1461, 1461, 1461, 1461, 1461, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1461, 1462, 1462, 1461, 1461, 
+	1461, 1461, 1461, 1461, 1462, 1462, 1461, 1462, 
+	1462, 1462, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1462, 1461, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1462, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1462, 1462, 1462, 1461, 1462, 1461, 1491, 
+	1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 
+	1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 
+	1508, 1509, 1510, 1511, 1461, 1462, 1462, 1461, 
+	1462, 1462, 1462, 1461, 1462, 1462, 1462, 1462, 
+	1461, 1462, 1461, 1462, 1462, 1461, 1462, 1462, 
+	1461, 1462, 1461, 1461, 1461, 1462, 1462, 1461, 
+	1462, 1462, 1461, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1462, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1462, 1461, 1461, 1461, 1462, 1462, 1462, 
+	1461, 1462, 1461, 1462, 1461, 1462, 1462, 1462, 
+	1462, 1462, 1461, 1462, 1462, 1461, 1512, 1513, 
+	1514, 1515, 1516, 1461, 1462, 1517, 1461, 1512, 
+	1513, 1518, 1514, 1515, 1516, 1461, 1462, 1461, 
+	1462, 1461, 1462, 1461, 1462, 1461, 1462, 1461, 
+	1519, 1520, 1461, 1462, 1461, 1462, 1461, 1521, 
+	1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 
+	1530, 1531, 1532, 1533, 1534, 1535, 1461, 1462, 
+	1462, 1461, 1462, 1461, 1462, 1461, 1462, 1462, 
+	1462, 1462, 1461, 1462, 1462, 1461, 1461, 1461, 
+	1462, 1462, 1461, 1462, 1461, 1462, 1462, 1461, 
+	1461, 1461, 1462, 1462, 1461, 1462, 1462, 1462, 
+	1461, 1462, 1462, 1462, 1462, 1461, 1462, 1462, 
+	1462, 1461, 1462, 1462, 1461, 1536, 1537, 1522, 
+	1461, 1462, 1461, 1462, 1462, 1461, 1538, 1539, 
+	1540, 1541, 1542, 1543, 1544, 1461, 1545, 1546, 
+	1547, 1548, 1549, 1461, 1462, 1461, 1462, 1461, 
+	1462, 1461, 1462, 1462, 1462, 1462, 1462, 1461, 
+	1462, 1461, 1550, 1551, 1552, 1553, 1554, 1555, 
+	1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 
+	1564, 1565, 1566, 1563, 1567, 1568, 1569, 1570, 
+	1571, 1461, 1462, 1462, 1461, 1461, 1462, 1461, 
+	1461, 1462, 1462, 1462, 1461, 1462, 1461, 1462, 
+	1462, 1461, 1461, 1461, 1462, 1462, 1462, 1461, 
+	1462, 1461, 1462, 1462, 1462, 1461, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1461, 1462, 1461, 1461, 1462, 1462, 1462, 
+	1461, 1461, 1461, 1462, 1461, 1462, 1462, 1461, 
+	1462, 1461, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1572, 1573, 1574, 1575, 1461, 1462, 1461, 1462, 
+	1461, 1462, 1461, 1462, 1461, 1576, 1461, 1462, 
+	1461, 1577, 1578, 1579, 1580, 1581, 1582, 1461, 
+	1462, 1462, 1462, 1461, 1461, 1461, 1461, 1462, 
+	1462, 1461, 1462, 1462, 1461, 1461, 1461, 1462, 
+	1462, 1462, 1462, 1461, 1583, 1584, 1585, 1461, 
+	1462, 1462, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1461, 1586, 1587, 1588, 1461, 1589, 1461, 
+	1589, 1461, 1461, 1589, 1589, 1461, 1589, 1589, 
+	1461, 1589, 1589, 1589, 1461, 1589, 1461, 1589, 
+	1589, 1461, 1589, 1589, 1589, 1589, 1461, 1589, 
+	1589, 1461, 1461, 1589, 1589, 1461, 1589, 1461, 
+	1590, 1591, 1592, 1593, 1594, 1595, 1596, 1598, 
+	1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 
+	1607, 1608, 1609, 1481, 1610, 1611, 1612, 1613, 
+	1614, 1615, 1616, 1617, 1618, 1597, 1461, 1589, 
+	1589, 1589, 1589, 1461, 1589, 1461, 1589, 1589, 
+	1461, 1462, 1462, 1461, 1461, 1462, 1589, 1589, 
+	1461, 1589, 1589, 1461, 1589, 1461, 1462, 1589, 
+	1589, 1589, 1462, 1462, 1461, 1589, 1589, 1589, 
+	1461, 1461, 1461, 1589, 1461, 1462, 1462, 1589, 
+	1589, 1462, 1461, 1589, 1589, 1589, 1461, 1589, 
+	1461, 1589, 1461, 1589, 1461, 1462, 1461, 1461, 
+	1589, 1589, 1461, 1589, 1461, 1462, 1589, 1589, 
+	1462, 1589, 1461, 1462, 1589, 1589, 1462, 1462, 
+	1589, 1589, 1461, 1589, 1589, 1462, 1461, 1589, 
+	1589, 1589, 1462, 1462, 1462, 1461, 1589, 1462, 
+	1589, 1461, 1461, 1461, 1462, 1461, 1461, 1461, 
+	1589, 1589, 1589, 1462, 1589, 1462, 1461, 1589, 
+	1589, 1462, 1462, 1462, 1589, 1589, 1589, 1461, 
+	1589, 1589, 1462, 1462, 1461, 1461, 1461, 1589, 
+	1589, 1589, 1461, 1589, 1461, 1462, 1589, 1589, 
+	1589, 1589, 1462, 1589, 1462, 1462, 1461, 1589, 
+	1462, 1589, 1461, 1589, 1461, 1589, 1462, 1589, 
+	1589, 1461, 1589, 1461, 1589, 1589, 1589, 1589, 
+	1462, 1461, 1462, 1589, 1461, 1589, 1589, 1589, 
+	1589, 1461, 1589, 1461, 1619, 1620, 1621, 1622, 
+	1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 
+	1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 
+	1639, 1461, 1462, 1589, 1589, 1462, 1589, 1461, 
+	1462, 1589, 1589, 1589, 1461, 1589, 1462, 1589, 
+	1589, 1589, 1461, 1589, 1461, 1589, 1589, 1461, 
+	1589, 1589, 1461, 1462, 1589, 1462, 1461, 1589, 
+	1589, 1589, 1461, 1462, 1589, 1461, 1589, 1589, 
+	1461, 1589, 1589, 1462, 1589, 1462, 1462, 1589, 
+	1461, 1589, 1589, 1462, 1461, 1589, 1589, 1589, 
+	1589, 1462, 1589, 1589, 1462, 1589, 1461, 1589, 
+	1461, 1462, 1462, 1462, 1589, 1589, 1462, 1461, 
+	1589, 1461, 1589, 1461, 1462, 1462, 1462, 1462, 
+	1589, 1589, 1462, 1589, 1461, 1462, 1589, 1589, 
+	1462, 1589, 1462, 1461, 1462, 1589, 1462, 1589, 
+	1461, 1462, 1589, 1589, 1589, 1589, 1462, 1589, 
+	1461, 1589, 1589, 1461, 1640, 1641, 1642, 1643, 
+	1644, 1461, 1589, 1517, 1461, 1589, 1461, 1589, 
+	1461, 1589, 1461, 1589, 1461, 1645, 1646, 1461, 
+	1589, 1461, 1589, 1461, 1647, 1648, 1649, 1650, 
+	1525, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 
+	1658, 1659, 1660, 1461, 1589, 1589, 1461, 1589, 
+	1461, 1589, 1461, 1589, 1589, 1589, 1462, 1462, 
+	1589, 1461, 1589, 1461, 1589, 1461, 1462, 1589, 
+	1461, 1589, 1462, 1461, 1462, 1589, 1589, 1589, 
+	1462, 1589, 1462, 1461, 1589, 1461, 1462, 1589, 
+	1462, 1589, 1462, 1589, 1461, 1589, 1589, 1462, 
+	1589, 1461, 1589, 1589, 1589, 1589, 1461, 1589, 
+	1462, 1462, 1589, 1589, 1462, 1461, 1589, 1589, 
+	1462, 1589, 1462, 1461, 1661, 1662, 1648, 1461, 
+	1589, 1461, 1589, 1589, 1461, 1663, 1664, 1665, 
+	1666, 1667, 1668, 1669, 1461, 1670, 1671, 1672, 
+	1673, 1674, 1461, 1589, 1461, 1589, 1461, 1589, 
+	1461, 1589, 1589, 1589, 1589, 1589, 1461, 1589, 
+	1461, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 
+	1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 
+	1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 
+	1461, 1589, 1462, 1589, 1461, 1461, 1589, 1462, 
+	1461, 1462, 1462, 1461, 1589, 1462, 1589, 1589, 
+	1461, 1589, 1461, 1462, 1589, 1462, 1589, 1462, 
+	1461, 1461, 1589, 1461, 1462, 1589, 1589, 1462, 
+	1589, 1462, 1589, 1461, 1589, 1462, 1589, 1461, 
+	1589, 1589, 1462, 1589, 1462, 1461, 1589, 1589, 
+	1462, 1462, 1462, 1462, 1589, 1589, 1461, 1462, 
+	1589, 1461, 1462, 1462, 1589, 1461, 1589, 1462, 
+	1589, 1462, 1589, 1462, 1589, 1461, 1462, 1461, 
+	1589, 1589, 1462, 1462, 1589, 1462, 1589, 1461, 
+	1461, 1461, 1589, 1589, 1462, 1589, 1462, 1589, 
+	1461, 1461, 1589, 1462, 1462, 1589, 1462, 1589, 
+	1461, 1462, 1589, 1462, 1589, 1461, 1462, 1462, 
+	1589, 1589, 1461, 1462, 1462, 1462, 1589, 1589, 
+	1461, 1698, 1699, 1574, 1700, 1461, 1589, 1461, 
+	1589, 1461, 1589, 1461, 1701, 1461, 1589, 1461, 
+	1702, 1703, 1704, 1705, 1706, 1707, 1461, 1462, 
+	1462, 1589, 1589, 1589, 1461, 1461, 1461, 1461, 
+	1589, 1589, 1461, 1589, 1589, 1461, 1461, 1461, 
+	1589, 1589, 1589, 1589, 1461, 1708, 1709, 1710, 
+	1461, 1589, 1589, 1589, 1589, 1589, 1461, 1589, 
+	1461, 1589, 1461, 1711, 1461, 1462, 1461, 1712, 
+	1461, 1713, 1714, 1715, 1717, 1716, 1461, 1589, 
+	1461, 1461, 1589, 1589, 1462, 1461, 1462, 1461, 
+	1718, 1461, 1719, 1720, 1721, 1723, 1722, 1461, 
+	1462, 1461, 1461, 1462, 1462, 1538, 1539, 1540, 
+	1541, 1542, 1543, 1461, 1538, 1539, 1540, 1541, 
+	1542, 1543, 1724, 1461, 1725, 1461, 1462, 1461, 
+	1162, 3, 1, 3, 1162, 3, 1162, 3, 
+	1, 1162, 1162, 3, 1162, 3, 1162, 3, 
+	1162, 3, 1162, 3, 1, 3, 3, 1162, 
+	1162, 3, 1, 1162, 1162, 3, 1, 1162, 
+	3, 1162, 3, 1, 3, 1162, 3, 1162, 
+	3, 1, 1162, 3, 1162, 3, 1, 1162, 
+	3, 1, 1162, 1162, 3, 3, 1162, 3, 
+	1162, 3, 1162, 1, 1440, 1, 1726, 1440, 
+	1, 1727, 1435, 1437, 1728, 1437, 601, 1436, 
+	1, 265, 3, 1, 3, 265, 1, 1, 
+	1730, 1729, 1733, 1734, 1735, 1736, 1737, 1738, 
+	1739, 1741, 1742, 1743, 1744, 1745, 1746, 1748, 
+	1729, 1, 1732, 1740, 1747, 1, 1731, 262, 
+	264, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 
+	1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 
+	1765, 1766, 1767, 1749, 262, 264, 1750, 1751, 
+	1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 
+	1760, 1761, 1768, 1763, 1764, 1765, 1769, 1767, 
+	1749, 256, 258, 1770, 1771, 1772, 1773, 1774, 
+	1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 
+	1783, 1784, 1785, 1786, 1787, 1749, 1789, 1790, 
+	1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 
+	1799, 1800, 1801, 1803, 268, 530, 576, 1802, 
+	1788, 527, 529, 1804, 1805, 1806, 1807, 1808, 
+	1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 
+	1817, 1818, 1819, 1820, 1821, 1788, 527, 529, 
+	1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 
+	1812, 1813, 1814, 1815, 1822, 1817, 1818, 1819, 
+	1823, 1821, 1788, 521, 523, 1824, 1825, 1826, 
+	1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, 
+	1835, 1836, 1837, 1838, 1839, 1840, 1841, 1788, 
+	527, 529, 1804, 1805, 1806, 1807, 1808, 1809, 
+	1810, 1811, 1812, 1813, 1814, 1842, 1816, 1817, 
+	1843, 1844, 1845, 1846, 1819, 1820, 1821, 1788, 
+	527, 529, 1804, 1805, 1806, 1807, 1808, 1809, 
+	1810, 1811, 1812, 1813, 1814, 1847, 1816, 1817, 
+	1818, 1848, 1819, 1820, 1821, 1788, 527, 529, 
+	1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 
+	1812, 1813, 1814, 1849, 1816, 1817, 1818, 1850, 
+	1819, 1820, 1821, 1788, 527, 529, 1804, 1805, 
+	1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 
+	1814, 1851, 1816, 1817, 1818, 1852, 1819, 1820, 
+	1821, 1788, 527, 529, 1804, 1805, 1806, 1807, 
+	1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 
+	1816, 1817, 1818, 1819, 1853, 1821, 1788, 871, 
+	873, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 
+	1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869, 
+	1870, 1871, 1872, 1873, 1874, 1875, 1854, 871, 
+	873, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 
+	1862, 1863, 1864, 1865, 1876, 1867, 1868, 1877, 
+	1873, 1874, 1875, 1854, 871, 873, 1855, 1856, 
+	1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 
+	1865, 1876, 1878, 1868, 1877, 1873, 1879, 1875, 
+	1854, 865, 867, 1880, 1881, 1882, 1883, 1884, 
+	1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 
+	1893, 1894, 1895, 1896, 1897, 1854, 871, 873, 
+	1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 
+	1863, 1864, 1865, 1898, 1867, 1868, 1877, 1899, 
+	1873, 1874, 1875, 1854, 871, 873, 1855, 1856, 
+	1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 
+	1865, 1900, 1867, 1868, 1877, 1901, 1873, 1874, 
+	1875, 1854, 871, 873, 1855, 1856, 1857, 1858, 
+	1859, 1860, 1861, 1862, 1863, 1864, 1865, 1902, 
+	1867, 1868, 1877, 1903, 1873, 1874, 1875, 1854, 
+	1025, 1027, 1905, 1906, 1907, 1908, 1909, 1910, 
+	1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 
+	1919, 1920, 1921, 1922, 1904, 1025, 1027, 1905, 
+	1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 
+	1914, 1915, 1916, 1923, 1918, 1919, 1920, 1924, 
+	1922, 1904, 1159, 1161, 1925, 1926, 1927, 1928, 
+	1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 
+	1937, 1938, 1939, 1940, 1941, 1942, 1904, 1422, 
+	1424, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 
+	1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 
+	1959, 1960, 1961, 1943, 1323, 1325, 1962, 1963, 
+	1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 
+	1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 
+	1943, 1323, 1325, 1962, 1963, 1964, 1965, 1966, 
+	1967, 1968, 1969, 1970, 1971, 1972, 1973, 1980, 
+	1975, 1976, 1977, 1981, 1979, 1943, 1721, 1723, 
+	1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 
+	1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 
+	1999, 2000, 1982, 1721, 1723, 1983, 1984, 1985, 
+	1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 
+	1994, 1995, 1996, 1997, 1998, 2001, 2000, 1982, 
+	1721, 1723, 1983, 1984, 1985, 1986, 1987, 1988, 
+	1989, 1990, 1991, 1992, 1993, 1994, 2002, 1996, 
+	1997, 1998, 2003, 2000, 1982, 1715, 1717, 2004, 
+	2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 
+	2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 
+	2021, 1982, 
+}
+
+var _graphclust_trans_targs []int16 = []int16{
+	1974, 0, 1974, 1975, 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, 
+	44, 45, 46, 47, 48, 49, 50, 51, 
+	52, 53, 54, 55, 56, 57, 58, 59, 
+	60, 61, 62, 63, 64, 66, 68, 70, 
+	71, 72, 1976, 69, 74, 75, 77, 78, 
+	79, 80, 81, 82, 83, 84, 85, 86, 
+	87, 88, 89, 90, 91, 93, 94, 96, 
+	102, 125, 130, 132, 139, 143, 97, 98, 
+	99, 100, 101, 103, 104, 105, 106, 107, 
+	108, 109, 110, 111, 112, 113, 114, 115, 
+	116, 117, 118, 119, 120, 121, 122, 123, 
+	124, 126, 127, 128, 129, 131, 133, 134, 
+	135, 136, 137, 138, 140, 141, 142, 144, 
+	291, 292, 1977, 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, 
+	188, 189, 190, 191, 192, 193, 194, 195, 
+	196, 197, 198, 199, 200, 201, 202, 203, 
+	204, 205, 206, 207, 208, 210, 211, 212, 
+	213, 214, 216, 217, 219, 220, 221, 222, 
+	223, 224, 225, 226, 227, 228, 229, 230, 
+	231, 232, 234, 235, 237, 243, 267, 271, 
+	273, 280, 284, 238, 239, 240, 241, 242, 
+	244, 245, 246, 247, 248, 249, 250, 251, 
+	252, 253, 254, 255, 256, 257, 258, 259, 
+	260, 261, 262, 263, 264, 265, 266, 268, 
+	269, 270, 272, 274, 275, 276, 277, 278, 
+	279, 281, 282, 283, 285, 287, 288, 289, 
+	145, 290, 146, 294, 295, 296, 2, 297, 
+	3, 1974, 1978, 1974, 1979, 315, 316, 317, 
+	318, 319, 320, 321, 322, 323, 324, 325, 
+	326, 327, 328, 329, 330, 331, 332, 333, 
+	334, 335, 336, 337, 338, 339, 340, 341, 
+	342, 344, 345, 346, 347, 348, 349, 350, 
+	351, 352, 353, 354, 355, 356, 357, 358, 
+	359, 360, 361, 362, 363, 364, 366, 368, 
+	370, 371, 372, 1980, 369, 374, 375, 377, 
+	378, 379, 380, 381, 382, 383, 384, 385, 
+	386, 387, 388, 389, 390, 391, 393, 394, 
+	396, 402, 425, 430, 432, 439, 443, 397, 
+	398, 399, 400, 401, 403, 404, 405, 406, 
+	407, 408, 409, 410, 411, 412, 413, 414, 
+	415, 416, 417, 418, 419, 420, 421, 422, 
+	423, 424, 426, 427, 428, 429, 431, 433, 
+	434, 435, 436, 437, 438, 440, 441, 442, 
+	444, 591, 592, 1981, 458, 459, 460, 461, 
+	462, 463, 464, 465, 466, 467, 468, 469, 
+	470, 471, 472, 473, 474, 475, 476, 477, 
+	478, 479, 480, 481, 482, 483, 484, 485, 
+	486, 488, 489, 490, 491, 492, 493, 494, 
+	495, 496, 497, 498, 499, 500, 501, 502, 
+	503, 504, 505, 506, 507, 508, 510, 511, 
+	512, 513, 514, 516, 517, 519, 520, 521, 
+	522, 523, 524, 525, 526, 527, 528, 529, 
+	530, 531, 532, 534, 535, 537, 543, 567, 
+	571, 573, 580, 584, 538, 539, 540, 541, 
+	542, 544, 545, 546, 547, 548, 549, 550, 
+	551, 552, 553, 554, 555, 556, 557, 558, 
+	559, 560, 561, 562, 563, 564, 565, 566, 
+	568, 569, 570, 572, 574, 575, 576, 577, 
+	578, 579, 581, 582, 583, 585, 587, 588, 
+	589, 445, 590, 446, 594, 595, 596, 302, 
+	597, 303, 599, 605, 606, 608, 610, 613, 
+	616, 640, 1982, 622, 1983, 612, 1984, 615, 
+	618, 620, 621, 624, 625, 629, 630, 631, 
+	632, 633, 634, 635, 1985, 628, 639, 642, 
+	643, 644, 645, 646, 649, 650, 651, 652, 
+	653, 654, 655, 656, 660, 661, 663, 664, 
+	647, 666, 669, 671, 673, 667, 668, 670, 
+	672, 674, 678, 679, 680, 681, 682, 683, 
+	684, 685, 686, 687, 1986, 676, 677, 690, 
+	691, 299, 695, 696, 698, 997, 1000, 1003, 
+	1027, 1974, 1987, 1974, 1988, 712, 713, 714, 
+	715, 716, 717, 718, 719, 720, 721, 722, 
+	723, 724, 725, 726, 727, 728, 729, 730, 
+	731, 732, 733, 734, 735, 736, 737, 738, 
+	739, 741, 742, 743, 744, 745, 746, 747, 
+	748, 749, 750, 751, 752, 753, 754, 755, 
+	756, 757, 758, 759, 760, 761, 763, 765, 
+	767, 768, 769, 1989, 766, 771, 772, 774, 
+	775, 776, 777, 778, 779, 780, 781, 782, 
+	783, 784, 785, 786, 787, 788, 790, 791, 
+	793, 799, 822, 827, 829, 836, 840, 794, 
+	795, 796, 797, 798, 800, 801, 802, 803, 
+	804, 805, 806, 807, 808, 809, 810, 811, 
+	812, 813, 814, 815, 816, 817, 818, 819, 
+	820, 821, 823, 824, 825, 826, 828, 830, 
+	831, 832, 833, 834, 835, 837, 838, 839, 
+	841, 988, 989, 1990, 855, 856, 857, 858, 
+	859, 860, 861, 862, 863, 864, 865, 866, 
+	867, 868, 869, 870, 871, 872, 873, 874, 
+	875, 876, 877, 878, 879, 880, 881, 882, 
+	883, 885, 886, 887, 888, 889, 890, 891, 
+	892, 893, 894, 895, 896, 897, 898, 899, 
+	900, 901, 902, 903, 904, 905, 907, 908, 
+	909, 910, 911, 913, 914, 916, 917, 918, 
+	919, 920, 921, 922, 923, 924, 925, 926, 
+	927, 928, 929, 931, 932, 934, 940, 964, 
+	968, 970, 977, 981, 935, 936, 937, 938, 
+	939, 941, 942, 943, 944, 945, 946, 947, 
+	948, 949, 950, 951, 952, 953, 954, 955, 
+	956, 957, 958, 959, 960, 961, 962, 963, 
+	965, 966, 967, 969, 971, 972, 973, 974, 
+	975, 976, 978, 979, 980, 982, 984, 985, 
+	986, 842, 987, 843, 991, 992, 993, 699, 
+	994, 700, 1009, 1991, 999, 1992, 1002, 1005, 
+	1007, 1008, 1011, 1012, 1016, 1017, 1018, 1019, 
+	1020, 1021, 1022, 1993, 1015, 1026, 1029, 1327, 
+	1328, 1626, 1627, 1994, 1974, 1995, 1043, 1044, 
+	1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 
+	1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 
+	1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 
+	1069, 1070, 1072, 1073, 1074, 1075, 1076, 1077, 
+	1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 
+	1086, 1087, 1088, 1089, 1090, 1091, 1092, 1094, 
+	1095, 1096, 1097, 1098, 1100, 1101, 1103, 1104, 
+	1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 
+	1113, 1114, 1115, 1116, 1117, 1119, 1120, 1122, 
+	1128, 1151, 1156, 1158, 1165, 1123, 1124, 1125, 
+	1126, 1127, 1129, 1130, 1131, 1132, 1133, 1134, 
+	1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 
+	1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 
+	1152, 1153, 1154, 1155, 1157, 1159, 1160, 1161, 
+	1162, 1163, 1164, 1166, 1167, 1168, 1170, 1171, 
+	1172, 1030, 1173, 1031, 1175, 1177, 1178, 1325, 
+	1326, 1996, 1192, 1193, 1194, 1195, 1196, 1197, 
+	1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 
+	1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 
+	1214, 1215, 1216, 1217, 1218, 1219, 1220, 1222, 
+	1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 
+	1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 
+	1239, 1240, 1241, 1242, 1244, 1245, 1246, 1247, 
+	1248, 1250, 1251, 1253, 1254, 1255, 1256, 1257, 
+	1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 
+	1266, 1268, 1269, 1271, 1277, 1301, 1305, 1307, 
+	1314, 1318, 1272, 1273, 1274, 1275, 1276, 1278, 
+	1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 
+	1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 
+	1295, 1296, 1297, 1298, 1299, 1300, 1302, 1303, 
+	1304, 1306, 1308, 1309, 1310, 1311, 1312, 1313, 
+	1315, 1316, 1317, 1319, 1321, 1322, 1323, 1179, 
+	1324, 1180, 1997, 1974, 1342, 1343, 1344, 1345, 
+	1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 
+	1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 
+	1377, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 
+	1520, 1521, 1998, 1359, 1360, 1361, 1362, 1363, 
+	1364, 1365, 1366, 1367, 1368, 1369, 1370, 1371, 
+	1372, 1373, 1374, 1375, 1376, 1378, 1379, 1380, 
+	1381, 1382, 1383, 1384, 1385, 1386, 1388, 1389, 
+	1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 
+	1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 
+	1406, 1407, 1408, 1410, 1412, 1414, 1415, 1416, 
+	1999, 1413, 1418, 1419, 1421, 1422, 1423, 1424, 
+	1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 
+	1433, 1434, 1435, 1437, 1438, 1440, 1446, 1469, 
+	1474, 1476, 1483, 1487, 1441, 1442, 1443, 1444, 
+	1445, 1447, 1448, 1449, 1450, 1451, 1452, 1453, 
+	1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 
+	1462, 1463, 1464, 1465, 1466, 1467, 1468, 1470, 
+	1471, 1472, 1473, 1475, 1477, 1478, 1479, 1480, 
+	1481, 1482, 1484, 1485, 1486, 1488, 1489, 1490, 
+	1492, 1493, 1494, 1346, 1495, 1347, 1523, 1524, 
+	1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 
+	1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 
+	1541, 1542, 1543, 1545, 1546, 1547, 1548, 1549, 
+	1551, 1552, 1554, 1555, 1556, 1557, 1558, 1559, 
+	1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 
+	1569, 1570, 1572, 1578, 1602, 1606, 1608, 1615, 
+	1619, 1573, 1574, 1575, 1576, 1577, 1579, 1580, 
+	1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 
+	1589, 1590, 1591, 1592, 1593, 1594, 1595, 1596, 
+	1597, 1598, 1599, 1600, 1601, 1603, 1604, 1605, 
+	1607, 1609, 1610, 1611, 1612, 1613, 1614, 1616, 
+	1617, 1618, 1620, 1622, 1623, 1624, 1329, 1625, 
+	1330, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 
+	1637, 1641, 1642, 1643, 1644, 1645, 1647, 1648, 
+	1628, 1650, 1653, 1655, 1657, 1651, 1652, 1654, 
+	1656, 1658, 1959, 1960, 1961, 1962, 1963, 1964, 
+	1965, 1966, 1967, 1968, 2000, 1974, 2001, 1672, 
+	1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 
+	1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 
+	1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 
+	1697, 1698, 1699, 1701, 1702, 1703, 1704, 1705, 
+	1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 
+	1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 
+	1723, 1725, 1727, 1728, 1729, 2002, 1726, 1731, 
+	1732, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 
+	1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 
+	1750, 1751, 1753, 1759, 1782, 1787, 1789, 1796, 
+	1800, 1754, 1755, 1756, 1757, 1758, 1760, 1761, 
+	1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, 
+	1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 
+	1778, 1779, 1780, 1781, 1783, 1784, 1785, 1786, 
+	1788, 1790, 1791, 1792, 1793, 1794, 1795, 1797, 
+	1798, 1799, 1801, 1948, 1949, 2003, 1815, 1816, 
+	1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, 
+	1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 
+	1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 
+	1841, 1842, 1843, 1845, 1846, 1847, 1848, 1849, 
+	1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 
+	1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865, 
+	1867, 1868, 1869, 1870, 1871, 1873, 1874, 1876, 
+	1877, 1878, 1879, 1880, 1881, 1882, 1883, 1884, 
+	1885, 1886, 1887, 1888, 1889, 1891, 1892, 1894, 
+	1900, 1924, 1928, 1930, 1937, 1941, 1895, 1896, 
+	1897, 1898, 1899, 1901, 1902, 1903, 1904, 1905, 
+	1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 
+	1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 
+	1922, 1923, 1925, 1926, 1927, 1929, 1931, 1932, 
+	1933, 1934, 1935, 1936, 1938, 1939, 1940, 1942, 
+	1944, 1945, 1946, 1802, 1947, 1803, 1951, 1952, 
+	1953, 1659, 1954, 1660, 1957, 1958, 1971, 1972, 
+	1973, 1974, 1, 1975, 299, 300, 301, 692, 
+	693, 694, 697, 1028, 1628, 1629, 1638, 1639, 
+	1640, 1646, 1649, 1969, 1970, 1974, 4, 5, 
+	6, 7, 8, 9, 10, 11, 12, 13, 
+	14, 43, 65, 73, 76, 92, 298, 293, 
+	67, 95, 147, 148, 149, 150, 151, 152, 
+	153, 154, 155, 156, 157, 187, 209, 215, 
+	218, 233, 236, 286, 1974, 600, 601, 602, 
+	603, 604, 607, 641, 648, 657, 658, 659, 
+	662, 665, 688, 689, 304, 305, 306, 307, 
+	308, 309, 310, 311, 312, 313, 314, 343, 
+	365, 373, 376, 392, 598, 593, 367, 395, 
+	447, 448, 449, 450, 451, 452, 453, 454, 
+	455, 456, 457, 487, 509, 515, 518, 533, 
+	536, 586, 609, 623, 636, 637, 638, 611, 
+	619, 614, 617, 626, 627, 675, 1974, 701, 
+	702, 703, 704, 705, 706, 707, 708, 709, 
+	710, 711, 996, 762, 770, 1010, 1023, 1024, 
+	1025, 789, 995, 990, 740, 773, 764, 792, 
+	844, 845, 846, 847, 848, 849, 850, 851, 
+	852, 853, 854, 884, 906, 912, 915, 930, 
+	933, 983, 998, 1006, 1001, 1004, 1013, 1014, 
+	1974, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 
+	1039, 1040, 1041, 1042, 1071, 1174, 1099, 1102, 
+	1118, 1176, 1169, 1093, 1121, 1181, 1182, 1183, 
+	1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 
+	1221, 1243, 1249, 1252, 1267, 1270, 1320, 1974, 
+	1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 
+	1339, 1340, 1341, 1522, 1544, 1550, 1553, 1568, 
+	1571, 1621, 1348, 1349, 1350, 1351, 1352, 1353, 
+	1354, 1355, 1356, 1357, 1358, 1387, 1409, 1417, 
+	1420, 1436, 1496, 1491, 1411, 1439, 1974, 1661, 
+	1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 
+	1670, 1671, 1700, 1722, 1730, 1733, 1749, 1956, 
+	1950, 1955, 1724, 1752, 1804, 1805, 1806, 1807, 
+	1808, 1809, 1810, 1811, 1812, 1813, 1814, 1844, 
+	1866, 1872, 1875, 1890, 1893, 1943, 
+}
+
+var _graphclust_trans_actions []byte = []byte{
+	31, 0, 27, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 34, 40, 25, 40, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 0, 40, 0, 40, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 40, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 40, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 29, 51, 17, 40, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 51, 0, 51, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 40, 21, 40, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 40, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 19, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	40, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 40, 23, 40, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 40, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 40, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 43, 1, 47, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 15, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 13, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 5, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	9, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 7, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 11, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 
+}
+
+var _graphclust_to_state_actions []byte = []byte{
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 37, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 
+}
+
+var _graphclust_from_state_actions []byte = []byte{
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 3, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 
+}
+
+var _graphclust_eof_trans []int16 = []int16{
+	0, 0, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 0, 0, 0, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 0, 0, 0, 0, 
+	0, 0, 610, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 610, 612, 612, 
+	610, 612, 612, 610, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 610, 612, 
+	612, 612, 612, 0, 0, 0, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 0, 
+	0, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 1750, 
+	1750, 1750, 1789, 1789, 1789, 1789, 1789, 1789, 
+	1789, 1789, 1789, 1855, 1855, 1855, 1855, 1855, 
+	1855, 1855, 1905, 1905, 1905, 1944, 1944, 1944, 
+	1983, 1983, 1983, 1983, 
+}
+
+const graphclust_start int = 1974
+const graphclust_first_final int = 1974
+const graphclust_error int = 0
+
+const graphclust_en_main int = 1974
+
+
+// line 14 "grapheme_clusters.rl"
+
+
+var Error = errors.New("invalid UTF8 text")
+
+// ScanGraphemeClusters is a split function for bufio.Scanner that splits
+// on grapheme cluster boundaries.
+func ScanGraphemeClusters(data []byte, atEOF bool) (int, []byte, error) {
+    if len(data) == 0 {
+        return 0, nil, nil
+    }
+
+    // Ragel state
+	cs := 0 // Current State
+	p := 0  // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+    ts := 0
+    te := 0
+    act := 0
+    eof := pe
+
+    // Make Go compiler happy
+    _ = ts
+    _ = te
+    _ = act
+    _ = eof
+
+    startPos := 0
+    endPos := 0
+
+    
+// line 4976 "grapheme_clusters.go"
+	{
+	cs = graphclust_start
+	ts = 0
+	te = 0
+	act = 0
+	}
+
+// line 4984 "grapheme_clusters.go"
+	{
+	var _klen int
+	var _trans int
+	var _acts int
+	var _nacts uint
+	var _keys int
+	if p == pe {
+		goto _test_eof
+	}
+	if cs == 0 {
+		goto _out
+	}
+_resume:
+	_acts = int(_graphclust_from_state_actions[cs])
+	_nacts = uint(_graphclust_actions[_acts]); _acts++
+	for ; _nacts > 0; _nacts-- {
+		 _acts++
+		switch _graphclust_actions[_acts - 1] {
+		case 4:
+// line 1 "NONE"
+
+ts = p
+
+// line 5008 "grapheme_clusters.go"
+		}
+	}
+
+	_keys = int(_graphclust_key_offsets[cs])
+	_trans = int(_graphclust_index_offsets[cs])
+
+	_klen = int(_graphclust_single_lengths[cs])
+	if _klen > 0 {
+		_lower := int(_keys)
+		var _mid int
+		_upper := int(_keys + _klen - 1)
+		for {
+			if _upper < _lower {
+				break
+			}
+
+			_mid = _lower + ((_upper - _lower) >> 1)
+			switch {
+			case data[p] < _graphclust_trans_keys[_mid]:
+				_upper = _mid - 1
+			case data[p] > _graphclust_trans_keys[_mid]:
+				_lower = _mid + 1
+			default:
+				_trans += int(_mid - int(_keys))
+				goto _match
+			}
+		}
+		_keys += _klen
+		_trans += _klen
+	}
+
+	_klen = int(_graphclust_range_lengths[cs])
+	if _klen > 0 {
+		_lower := int(_keys)
+		var _mid int
+		_upper := int(_keys + (_klen << 1) - 2)
+		for {
+			if _upper < _lower {
+				break
+			}
+
+			_mid = _lower + (((_upper - _lower) >> 1) & ^1)
+			switch {
+			case data[p] < _graphclust_trans_keys[_mid]:
+				_upper = _mid - 2
+			case data[p] > _graphclust_trans_keys[_mid + 1]:
+				_lower = _mid + 2
+			default:
+				_trans += int((_mid - int(_keys)) >> 1)
+				goto _match
+			}
+		}
+		_trans += _klen
+	}
+
+_match:
+	_trans = int(_graphclust_indicies[_trans])
+_eof_trans:
+	cs = int(_graphclust_trans_targs[_trans])
+
+	if _graphclust_trans_actions[_trans] == 0 {
+		goto _again
+	}
+
+	_acts = int(_graphclust_trans_actions[_trans])
+	_nacts = uint(_graphclust_actions[_acts]); _acts++
+	for ; _nacts > 0; _nacts-- {
+		_acts++
+		switch _graphclust_actions[_acts-1] {
+		case 0:
+// line 46 "grapheme_clusters.rl"
+
+
+            startPos = p
+        
+		case 1:
+// line 50 "grapheme_clusters.rl"
+
+
+            endPos = p
+        
+		case 5:
+// line 1 "NONE"
+
+te = p+1
+
+		case 6:
+// line 54 "grapheme_clusters.rl"
+
+act = 3;
+		case 7:
+// line 54 "grapheme_clusters.rl"
+
+te = p+1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 8:
+// line 54 "grapheme_clusters.rl"
+
+te = p+1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 9:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 10:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 11:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 12:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 13:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 14:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 15:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 16:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 17:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 18:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 19:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 20:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 21:
+// line 1 "NONE"
+
+	switch act {
+	case 0:
+	{cs = 0
+goto _again
+}
+	case 3:
+	{p = (te) - 1
+
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+	}
+	
+// line 5218 "grapheme_clusters.go"
+		}
+	}
+
+_again:
+	_acts = int(_graphclust_to_state_actions[cs])
+	_nacts = uint(_graphclust_actions[_acts]); _acts++
+	for ; _nacts > 0; _nacts-- {
+		_acts++
+		switch _graphclust_actions[_acts-1] {
+		case 2:
+// line 1 "NONE"
+
+ts = 0
+
+		case 3:
+// line 1 "NONE"
+
+act = 0
+
+// line 5238 "grapheme_clusters.go"
+		}
+	}
+
+	if cs == 0 {
+		goto _out
+	}
+	p++
+	if p != pe {
+		goto _resume
+	}
+	_test_eof: {}
+	if p == eof {
+		if _graphclust_eof_trans[cs] > 0 {
+			_trans = int(_graphclust_eof_trans[cs] - 1)
+			goto _eof_trans
+		}
+	}
+
+	_out: {}
+	}
+
+// line 116 "grapheme_clusters.rl"
+
+
+    // If we fall out here then we were unable to complete a sequence.
+    // If we weren't able to complete a sequence then either we've
+    // reached the end of a partial buffer (so there's more data to come)
+    // or we have an isolated symbol that would normally be part of a
+    // grapheme cluster but has appeared in isolation here.
+
+    if !atEOF {
+        // Request more
+        return 0, nil, nil
+    }
+
+    // Just take the first UTF-8 sequence and return that.
+    _, seqLen := utf8.DecodeRune(data)
+    return seqLen, data[:seqLen], nil
+}
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.rl b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.rl
new file mode 100644
index 00000000..003ffbf5
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.rl
@@ -0,0 +1,132 @@
+package textseg
+
+import (
+    "errors"
+    "unicode/utf8"
+)
+
+// Generated from grapheme_clusters.rl. DO NOT EDIT
+%%{
+  # (except you are actually in grapheme_clusters.rl here, so edit away!)
+
+  machine graphclust;
+  write data;
+}%%
+
+var Error = errors.New("invalid UTF8 text")
+
+// ScanGraphemeClusters is a split function for bufio.Scanner that splits
+// on grapheme cluster boundaries.
+func ScanGraphemeClusters(data []byte, atEOF bool) (int, []byte, error) {
+    if len(data) == 0 {
+        return 0, nil, nil
+    }
+
+    // Ragel state
+	cs := 0 // Current State
+	p := 0  // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+    ts := 0
+    te := 0
+    act := 0
+    eof := pe
+
+    // Make Go compiler happy
+    _ = ts
+    _ = te
+    _ = act
+    _ = eof
+
+    startPos := 0
+    endPos := 0
+
+    %%{
+        include GraphemeCluster "grapheme_clusters_table.rl";
+
+        action start {
+            startPos = p
+        }
+
+        action end {
+            endPos = p
+        }
+
+        action emit {
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+
+        ZWJGlue = ZWJ (Glue_After_Zwj | E_Base_GAZ Extend* E_Modifier?)?;
+        AnyExtender = Extend | ZWJGlue | SpacingMark;
+        Extension = AnyExtender*;
+        ReplacementChar = (0xEF 0xBF 0xBD);
+
+        CRLFSeq = CR LF;
+        ControlSeq = Control | ReplacementChar;
+        HangulSeq = (
+            L+ (((LV? V+ | LVT) T*)?|LV?) |
+            LV V* T* |
+            V+ T* |
+            LVT T* |
+            T+
+        ) Extension;
+        EmojiSeq = (E_Base | E_Base_GAZ) Extend* E_Modifier? Extension;
+        ZWJSeq = ZWJGlue Extension;
+        EmojiFlagSeq = Regional_Indicator Regional_Indicator? Extension;
+
+        UTF8Cont = 0x80 .. 0xBF;
+        AnyUTF8 = (
+            0x00..0x7F |
+            0xC0..0xDF . UTF8Cont |
+            0xE0..0xEF . UTF8Cont . UTF8Cont |
+            0xF0..0xF7 . UTF8Cont . UTF8Cont . UTF8Cont
+        );
+
+        # OtherSeq is any character that isn't at the start of one of the extended sequences above, followed by extension
+        OtherSeq = (AnyUTF8 - (CR|LF|Control|ReplacementChar|L|LV|V|LVT|T|E_Base|E_Base_GAZ|ZWJ|Regional_Indicator|Prepend)) Extension;
+
+        # PrependSeq is prepend followed by any of the other patterns above, except control characters which explicitly break
+        PrependSeq = Prepend+ (HangulSeq|EmojiSeq|ZWJSeq|EmojiFlagSeq|OtherSeq)?;
+
+        CRLFTok = CRLFSeq >start @end;
+        ControlTok = ControlSeq >start @end;
+        HangulTok = HangulSeq >start @end;
+        EmojiTok = EmojiSeq >start @end;
+        ZWJTok = ZWJSeq >start @end;
+        EmojiFlagTok = EmojiFlagSeq >start @end;
+        OtherTok = OtherSeq >start @end;
+        PrependTok = PrependSeq >start @end;
+
+        main := |*
+            CRLFTok => emit;
+            ControlTok => emit;
+            HangulTok => emit;
+            EmojiTok => emit;
+            ZWJTok => emit;
+            EmojiFlagTok => emit;
+            PrependTok => emit;
+            OtherTok => emit;
+
+            # any single valid UTF-8 character would also be valid per spec,
+            # but we'll handle that separately after the loop so we can deal
+            # with requesting more bytes if we're not at EOF.
+        *|;
+
+        write init;
+        write exec;
+    }%%
+
+    // If we fall out here then we were unable to complete a sequence.
+    // If we weren't able to complete a sequence then either we've
+    // reached the end of a partial buffer (so there's more data to come)
+    // or we have an isolated symbol that would normally be part of a
+    // grapheme cluster but has appeared in isolation here.
+
+    if !atEOF {
+        // Request more
+        return 0, nil, nil
+    }
+
+    // Just take the first UTF-8 sequence and return that.
+    _, seqLen := utf8.DecodeRune(data)
+    return seqLen, data[:seqLen], nil
+}
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters_table.rl b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters_table.rl
new file mode 100644
index 00000000..fb451182
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters_table.rl
@@ -0,0 +1,1583 @@
+# The following Ragel file was autogenerated with unicode2ragel.rb 
+# from: http://www.unicode.org/Public/9.0.0/ucd/auxiliary/GraphemeBreakProperty.txt
+#
+# It defines ["Prepend", "CR", "LF", "Control", "Extend", "Regional_Indicator", "SpacingMark", "L", "V", "T", "LV", "LVT", "E_Base", "E_Modifier", "ZWJ", "Glue_After_Zwj", "E_Base_GAZ"].
+#
+# To use this, make sure that your alphtype is set to byte,
+# and that your input is in utf8.
+
+%%{
+    machine GraphemeCluster;
+    
+    Prepend = 
+        0xD8 0x80..0x85         #Cf   [6] ARABIC NUMBER SIGN..ARABIC NUMBER ...
+      | 0xDB 0x9D               #Cf       ARABIC END OF AYAH
+      | 0xDC 0x8F               #Cf       SYRIAC ABBREVIATION MARK
+      | 0xE0 0xA3 0xA2          #Cf       ARABIC DISPUTED END OF AYAH
+      | 0xE0 0xB5 0x8E          #Lo       MALAYALAM LETTER DOT REPH
+      | 0xF0 0x91 0x82 0xBD     #Cf       KAITHI NUMBER SIGN
+      | 0xF0 0x91 0x87 0x82..0x83  #Lo   [2] SHARADA SIGN JIHVAMULIYA..SHARA...
+      ;
+
+    CR = 
+        0x0D                    #Cc       <control-000D>
+      ;
+
+    LF = 
+        0x0A                    #Cc       <control-000A>
+      ;
+
+    Control = 
+        0x00..0x09              #Cc  [10] <control-0000>..<control-0009>
+      | 0x0B..0x0C              #Cc   [2] <control-000B>..<control-000C>
+      | 0x0E..0x1F              #Cc  [18] <control-000E>..<control-001F>
+      | 0x7F                    #Cc  [33] <control-007F>..<control-009F>
+      | 0xC2 0x80..0x9F         #
+      | 0xC2 0xAD               #Cf       SOFT HYPHEN
+      | 0xD8 0x9C               #Cf       ARABIC LETTER MARK
+      | 0xE1 0xA0 0x8E          #Cf       MONGOLIAN VOWEL SEPARATOR
+      | 0xE2 0x80 0x8B          #Cf       ZERO WIDTH SPACE
+      | 0xE2 0x80 0x8E..0x8F    #Cf   [2] LEFT-TO-RIGHT MARK..RIGHT-TO-LEFT ...
+      | 0xE2 0x80 0xA8          #Zl       LINE SEPARATOR
+      | 0xE2 0x80 0xA9          #Zp       PARAGRAPH SEPARATOR
+      | 0xE2 0x80 0xAA..0xAE    #Cf   [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-...
+      | 0xE2 0x81 0xA0..0xA4    #Cf   [5] WORD JOINER..INVISIBLE PLUS
+      | 0xE2 0x81 0xA5          #Cn       <reserved-2065>
+      | 0xE2 0x81 0xA6..0xAF    #Cf  [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIG...
+      | 0xED 0xA0 0x80..0xFF        #Cs [2048] <surrogate-D800>..<surrogate-...
+      | 0xED 0xA1..0xBE 0x00..0xFF  #
+      | 0xED 0xBF 0x00..0xBF        #
+      | 0xEF 0xBB 0xBF          #Cf       ZERO WIDTH NO-BREAK SPACE
+      | 0xEF 0xBF 0xB0..0xB8    #Cn   [9] <reserved-FFF0>..<reserved-FFF8>
+      | 0xEF 0xBF 0xB9..0xBB    #Cf   [3] INTERLINEAR ANNOTATION ANCHOR..INT...
+      | 0xF0 0x9B 0xB2 0xA0..0xA3  #Cf   [4] SHORTHAND FORMAT LETTER OVERLAP...
+      | 0xF0 0x9D 0x85 0xB3..0xBA  #Cf   [8] MUSICAL SYMBOL BEGIN BEAM..MUSI...
+      | 0xF3 0xA0 0x80 0x80     #Cn       <reserved-E0000>
+      | 0xF3 0xA0 0x80 0x81     #Cf       LANGUAGE TAG
+      | 0xF3 0xA0 0x80 0x82..0x9F  #Cn  [30] <reserved-E0002>..<reserved-E001F>
+      | 0xF3 0xA0 0x82 0x80..0xFF  #Cn [128] <reserved-E0080>..<reserved-E00FF>
+      | 0xF3 0xA0 0x83 0x00..0xBF  #
+      | 0xF3 0xA0 0x87 0xB0..0xFF        #Cn [3600] <reserved-E01F0>..<reser...
+      | 0xF3 0xA0 0x88..0xBE 0x00..0xFF  #
+      | 0xF3 0xA0 0xBF 0x00..0xBF        #
+      ;
+
+    Extend = 
+        0xCC 0x80..0xFF         #Mn [112] COMBINING GRAVE ACCENT..COMBINING ...
+      | 0xCD 0x00..0xAF         #
+      | 0xD2 0x83..0x87         #Mn   [5] COMBINING CYRILLIC TITLO..COMBININ...
+      | 0xD2 0x88..0x89         #Me   [2] COMBINING CYRILLIC HUNDRED THOUSAN...
+      | 0xD6 0x91..0xBD         #Mn  [45] HEBREW ACCENT ETNAHTA..HEBREW POIN...
+      | 0xD6 0xBF               #Mn       HEBREW POINT RAFE
+      | 0xD7 0x81..0x82         #Mn   [2] HEBREW POINT SHIN DOT..HEBREW POIN...
+      | 0xD7 0x84..0x85         #Mn   [2] HEBREW MARK UPPER DOT..HEBREW MARK...
+      | 0xD7 0x87               #Mn       HEBREW POINT QAMATS QATAN
+      | 0xD8 0x90..0x9A         #Mn  [11] ARABIC SIGN SALLALLAHOU ALAYHE WAS...
+      | 0xD9 0x8B..0x9F         #Mn  [21] ARABIC FATHATAN..ARABIC WAVY HAMZA...
+      | 0xD9 0xB0               #Mn       ARABIC LETTER SUPERSCRIPT ALEF
+      | 0xDB 0x96..0x9C         #Mn   [7] ARABIC SMALL HIGH LIGATURE SAD WIT...
+      | 0xDB 0x9F..0xA4         #Mn   [6] ARABIC SMALL HIGH ROUNDED ZERO..AR...
+      | 0xDB 0xA7..0xA8         #Mn   [2] ARABIC SMALL HIGH YEH..ARABIC SMAL...
+      | 0xDB 0xAA..0xAD         #Mn   [4] ARABIC EMPTY CENTRE LOW STOP..ARAB...
+      | 0xDC 0x91               #Mn       SYRIAC LETTER SUPERSCRIPT ALAPH
+      | 0xDC 0xB0..0xFF         #Mn  [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH
+      | 0xDD 0x00..0x8A         #
+      | 0xDE 0xA6..0xB0         #Mn  [11] THAANA ABAFILI..THAANA SUKUN
+      | 0xDF 0xAB..0xB3         #Mn   [9] NKO COMBINING SHORT HIGH TONE..NKO...
+      | 0xE0 0xA0 0x96..0x99    #Mn   [4] SAMARITAN MARK IN..SAMARITAN MARK ...
+      | 0xE0 0xA0 0x9B..0xA3    #Mn   [9] SAMARITAN MARK EPENTHETIC YUT..SAM...
+      | 0xE0 0xA0 0xA5..0xA7    #Mn   [3] SAMARITAN VOWEL SIGN SHORT A..SAMA...
+      | 0xE0 0xA0 0xA9..0xAD    #Mn   [5] SAMARITAN VOWEL SIGN LONG I..SAMAR...
+      | 0xE0 0xA1 0x99..0x9B    #Mn   [3] MANDAIC AFFRICATION MARK..MANDAIC ...
+      | 0xE0 0xA3 0x94..0xA1    #Mn  [14] ARABIC SMALL HIGH WORD AR-RUB..ARA...
+      | 0xE0 0xA3 0xA3..0xFF    #Mn  [32] ARABIC TURNED DAMMA BELOW..DEVANAG...
+      | 0xE0 0xA4 0x00..0x82    #
+      | 0xE0 0xA4 0xBA          #Mn       DEVANAGARI VOWEL SIGN OE
+      | 0xE0 0xA4 0xBC          #Mn       DEVANAGARI SIGN NUKTA
+      | 0xE0 0xA5 0x81..0x88    #Mn   [8] DEVANAGARI VOWEL SIGN U..DEVANAGAR...
+      | 0xE0 0xA5 0x8D          #Mn       DEVANAGARI SIGN VIRAMA
+      | 0xE0 0xA5 0x91..0x97    #Mn   [7] DEVANAGARI STRESS SIGN UDATTA..DEV...
+      | 0xE0 0xA5 0xA2..0xA3    #Mn   [2] DEVANAGARI VOWEL SIGN VOCALIC L..D...
+      | 0xE0 0xA6 0x81          #Mn       BENGALI SIGN CANDRABINDU
+      | 0xE0 0xA6 0xBC          #Mn       BENGALI SIGN NUKTA
+      | 0xE0 0xA6 0xBE          #Mc       BENGALI VOWEL SIGN AA
+      | 0xE0 0xA7 0x81..0x84    #Mn   [4] BENGALI VOWEL SIGN U..BENGALI VOWE...
+      | 0xE0 0xA7 0x8D          #Mn       BENGALI SIGN VIRAMA
+      | 0xE0 0xA7 0x97          #Mc       BENGALI AU LENGTH MARK
+      | 0xE0 0xA7 0xA2..0xA3    #Mn   [2] BENGALI VOWEL SIGN VOCALIC L..BENG...
+      | 0xE0 0xA8 0x81..0x82    #Mn   [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI...
+      | 0xE0 0xA8 0xBC          #Mn       GURMUKHI SIGN NUKTA
+      | 0xE0 0xA9 0x81..0x82    #Mn   [2] GURMUKHI VOWEL SIGN U..GURMUKHI VO...
+      | 0xE0 0xA9 0x87..0x88    #Mn   [2] GURMUKHI VOWEL SIGN EE..GURMUKHI V...
+      | 0xE0 0xA9 0x8B..0x8D    #Mn   [3] GURMUKHI VOWEL SIGN OO..GURMUKHI S...
+      | 0xE0 0xA9 0x91          #Mn       GURMUKHI SIGN UDAAT
+      | 0xE0 0xA9 0xB0..0xB1    #Mn   [2] GURMUKHI TIPPI..GURMUKHI ADDAK
+      | 0xE0 0xA9 0xB5          #Mn       GURMUKHI SIGN YAKASH
+      | 0xE0 0xAA 0x81..0x82    #Mn   [2] GUJARATI SIGN CANDRABINDU..GUJARAT...
+      | 0xE0 0xAA 0xBC          #Mn       GUJARATI SIGN NUKTA
+      | 0xE0 0xAB 0x81..0x85    #Mn   [5] GUJARATI VOWEL SIGN U..GUJARATI VO...
+      | 0xE0 0xAB 0x87..0x88    #Mn   [2] GUJARATI VOWEL SIGN E..GUJARATI VO...
+      | 0xE0 0xAB 0x8D          #Mn       GUJARATI SIGN VIRAMA
+      | 0xE0 0xAB 0xA2..0xA3    #Mn   [2] GUJARATI VOWEL SIGN VOCALIC L..GUJ...
+      | 0xE0 0xAC 0x81          #Mn       ORIYA SIGN CANDRABINDU
+      | 0xE0 0xAC 0xBC          #Mn       ORIYA SIGN NUKTA
+      | 0xE0 0xAC 0xBE          #Mc       ORIYA VOWEL SIGN AA
+      | 0xE0 0xAC 0xBF          #Mn       ORIYA VOWEL SIGN I
+      | 0xE0 0xAD 0x81..0x84    #Mn   [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SI...
+      | 0xE0 0xAD 0x8D          #Mn       ORIYA SIGN VIRAMA
+      | 0xE0 0xAD 0x96          #Mn       ORIYA AI LENGTH MARK
+      | 0xE0 0xAD 0x97          #Mc       ORIYA AU LENGTH MARK
+      | 0xE0 0xAD 0xA2..0xA3    #Mn   [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA ...
+      | 0xE0 0xAE 0x82          #Mn       TAMIL SIGN ANUSVARA
+      | 0xE0 0xAE 0xBE          #Mc       TAMIL VOWEL SIGN AA
+      | 0xE0 0xAF 0x80          #Mn       TAMIL VOWEL SIGN II
+      | 0xE0 0xAF 0x8D          #Mn       TAMIL SIGN VIRAMA
+      | 0xE0 0xAF 0x97          #Mc       TAMIL AU LENGTH MARK
+      | 0xE0 0xB0 0x80          #Mn       TELUGU SIGN COMBINING CANDRABINDU ...
+      | 0xE0 0xB0 0xBE..0xFF    #Mn   [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL...
+      | 0xE0 0xB1 0x00..0x80    #
+      | 0xE0 0xB1 0x86..0x88    #Mn   [3] TELUGU VOWEL SIGN E..TELUGU VOWEL ...
+      | 0xE0 0xB1 0x8A..0x8D    #Mn   [4] TELUGU VOWEL SIGN O..TELUGU SIGN V...
+      | 0xE0 0xB1 0x95..0x96    #Mn   [2] TELUGU LENGTH MARK..TELUGU AI LENG...
+      | 0xE0 0xB1 0xA2..0xA3    #Mn   [2] TELUGU VOWEL SIGN VOCALIC L..TELUG...
+      | 0xE0 0xB2 0x81          #Mn       KANNADA SIGN CANDRABINDU
+      | 0xE0 0xB2 0xBC          #Mn       KANNADA SIGN NUKTA
+      | 0xE0 0xB2 0xBF          #Mn       KANNADA VOWEL SIGN I
+      | 0xE0 0xB3 0x82          #Mc       KANNADA VOWEL SIGN UU
+      | 0xE0 0xB3 0x86          #Mn       KANNADA VOWEL SIGN E
+      | 0xE0 0xB3 0x8C..0x8D    #Mn   [2] KANNADA VOWEL SIGN AU..KANNADA SIG...
+      | 0xE0 0xB3 0x95..0x96    #Mc   [2] KANNADA LENGTH MARK..KANNADA AI LE...
+      | 0xE0 0xB3 0xA2..0xA3    #Mn   [2] KANNADA VOWEL SIGN VOCALIC L..KANN...
+      | 0xE0 0xB4 0x81          #Mn       MALAYALAM SIGN CANDRABINDU
+      | 0xE0 0xB4 0xBE          #Mc       MALAYALAM VOWEL SIGN AA
+      | 0xE0 0xB5 0x81..0x84    #Mn   [4] MALAYALAM VOWEL SIGN U..MALAYALAM ...
+      | 0xE0 0xB5 0x8D          #Mn       MALAYALAM SIGN VIRAMA
+      | 0xE0 0xB5 0x97          #Mc       MALAYALAM AU LENGTH MARK
+      | 0xE0 0xB5 0xA2..0xA3    #Mn   [2] MALAYALAM VOWEL SIGN VOCALIC L..MA...
+      | 0xE0 0xB7 0x8A          #Mn       SINHALA SIGN AL-LAKUNA
+      | 0xE0 0xB7 0x8F          #Mc       SINHALA VOWEL SIGN AELA-PILLA
+      | 0xE0 0xB7 0x92..0x94    #Mn   [3] SINHALA VOWEL SIGN KETTI IS-PILLA....
+      | 0xE0 0xB7 0x96          #Mn       SINHALA VOWEL SIGN DIGA PAA-PILLA
+      | 0xE0 0xB7 0x9F          #Mc       SINHALA VOWEL SIGN GAYANUKITTA
+      | 0xE0 0xB8 0xB1          #Mn       THAI CHARACTER MAI HAN-AKAT
+      | 0xE0 0xB8 0xB4..0xBA    #Mn   [7] THAI CHARACTER SARA I..THAI CHARAC...
+      | 0xE0 0xB9 0x87..0x8E    #Mn   [8] THAI CHARACTER MAITAIKHU..THAI CHA...
+      | 0xE0 0xBA 0xB1          #Mn       LAO VOWEL SIGN MAI KAN
+      | 0xE0 0xBA 0xB4..0xB9    #Mn   [6] LAO VOWEL SIGN I..LAO VOWEL SIGN UU
+      | 0xE0 0xBA 0xBB..0xBC    #Mn   [2] LAO VOWEL SIGN MAI KON..LAO SEMIVO...
+      | 0xE0 0xBB 0x88..0x8D    #Mn   [6] LAO TONE MAI EK..LAO NIGGAHITA
+      | 0xE0 0xBC 0x98..0x99    #Mn   [2] TIBETAN ASTROLOGICAL SIGN -KHYUD P...
+      | 0xE0 0xBC 0xB5          #Mn       TIBETAN MARK NGAS BZUNG NYI ZLA
+      | 0xE0 0xBC 0xB7          #Mn       TIBETAN MARK NGAS BZUNG SGOR RTAGS
+      | 0xE0 0xBC 0xB9          #Mn       TIBETAN MARK TSA -PHRU
+      | 0xE0 0xBD 0xB1..0xBE    #Mn  [14] TIBETAN VOWEL SIGN AA..TIBETAN SIG...
+      | 0xE0 0xBE 0x80..0x84    #Mn   [5] TIBETAN VOWEL SIGN REVERSED I..TIB...
+      | 0xE0 0xBE 0x86..0x87    #Mn   [2] TIBETAN SIGN LCI RTAGS..TIBETAN SI...
+      | 0xE0 0xBE 0x8D..0x97    #Mn  [11] TIBETAN SUBJOINED SIGN LCE TSA CAN...
+      | 0xE0 0xBE 0x99..0xBC    #Mn  [36] TIBETAN SUBJOINED LETTER NYA..TIBE...
+      | 0xE0 0xBF 0x86          #Mn       TIBETAN SYMBOL PADMA GDAN
+      | 0xE1 0x80 0xAD..0xB0    #Mn   [4] MYANMAR VOWEL SIGN I..MYANMAR VOWE...
+      | 0xE1 0x80 0xB2..0xB7    #Mn   [6] MYANMAR VOWEL SIGN AI..MYANMAR SIG...
+      | 0xE1 0x80 0xB9..0xBA    #Mn   [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ...
+      | 0xE1 0x80 0xBD..0xBE    #Mn   [2] MYANMAR CONSONANT SIGN MEDIAL WA.....
+      | 0xE1 0x81 0x98..0x99    #Mn   [2] MYANMAR VOWEL SIGN VOCALIC L..MYAN...
+      | 0xE1 0x81 0x9E..0xA0    #Mn   [3] MYANMAR CONSONANT SIGN MON MEDIAL ...
+      | 0xE1 0x81 0xB1..0xB4    #Mn   [4] MYANMAR VOWEL SIGN GEBA KAREN I..M...
+      | 0xE1 0x82 0x82          #Mn       MYANMAR CONSONANT SIGN SHAN MEDIAL WA
+      | 0xE1 0x82 0x85..0x86    #Mn   [2] MYANMAR VOWEL SIGN SHAN E ABOVE..M...
+      | 0xE1 0x82 0x8D          #Mn       MYANMAR SIGN SHAN COUNCIL EMPHATIC...
+      | 0xE1 0x82 0x9D          #Mn       MYANMAR VOWEL SIGN AITON AI
+      | 0xE1 0x8D 0x9D..0x9F    #Mn   [3] ETHIOPIC COMBINING GEMINATION AND ...
+      | 0xE1 0x9C 0x92..0x94    #Mn   [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN...
+      | 0xE1 0x9C 0xB2..0xB4    #Mn   [3] HANUNOO VOWEL SIGN I..HANUNOO SIGN...
+      | 0xE1 0x9D 0x92..0x93    #Mn   [2] BUHID VOWEL SIGN I..BUHID VOWEL SI...
+      | 0xE1 0x9D 0xB2..0xB3    #Mn   [2] TAGBANWA VOWEL SIGN I..TAGBANWA VO...
+      | 0xE1 0x9E 0xB4..0xB5    #Mn   [2] KHMER VOWEL INHERENT AQ..KHMER VOW...
+      | 0xE1 0x9E 0xB7..0xBD    #Mn   [7] KHMER VOWEL SIGN I..KHMER VOWEL SI...
+      | 0xE1 0x9F 0x86          #Mn       KHMER SIGN NIKAHIT
+      | 0xE1 0x9F 0x89..0x93    #Mn  [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN...
+      | 0xE1 0x9F 0x9D          #Mn       KHMER SIGN ATTHACAN
+      | 0xE1 0xA0 0x8B..0x8D    #Mn   [3] MONGOLIAN FREE VARIATION SELECTOR ...
+      | 0xE1 0xA2 0x85..0x86    #Mn   [2] MONGOLIAN LETTER ALI GALI BALUDA.....
+      | 0xE1 0xA2 0xA9          #Mn       MONGOLIAN LETTER ALI GALI DAGALGA
+      | 0xE1 0xA4 0xA0..0xA2    #Mn   [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SI...
+      | 0xE1 0xA4 0xA7..0xA8    #Mn   [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SI...
+      | 0xE1 0xA4 0xB2          #Mn       LIMBU SMALL LETTER ANUSVARA
+      | 0xE1 0xA4 0xB9..0xBB    #Mn   [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I
+      | 0xE1 0xA8 0x97..0x98    #Mn   [2] BUGINESE VOWEL SIGN I..BUGINESE VO...
+      | 0xE1 0xA8 0x9B          #Mn       BUGINESE VOWEL SIGN AE
+      | 0xE1 0xA9 0x96          #Mn       TAI THAM CONSONANT SIGN MEDIAL LA
+      | 0xE1 0xA9 0x98..0x9E    #Mn   [7] TAI THAM SIGN MAI KANG LAI..TAI TH...
+      | 0xE1 0xA9 0xA0          #Mn       TAI THAM SIGN SAKOT
+      | 0xE1 0xA9 0xA2          #Mn       TAI THAM VOWEL SIGN MAI SAT
+      | 0xE1 0xA9 0xA5..0xAC    #Mn   [8] TAI THAM VOWEL SIGN I..TAI THAM VO...
+      | 0xE1 0xA9 0xB3..0xBC    #Mn  [10] TAI THAM VOWEL SIGN OA ABOVE..TAI ...
+      | 0xE1 0xA9 0xBF          #Mn       TAI THAM COMBINING CRYPTOGRAMMIC DOT
+      | 0xE1 0xAA 0xB0..0xBD    #Mn  [14] COMBINING DOUBLED CIRCUMFLEX ACCEN...
+      | 0xE1 0xAA 0xBE          #Me       COMBINING PARENTHESES OVERLAY
+      | 0xE1 0xAC 0x80..0x83    #Mn   [4] BALINESE SIGN ULU RICEM..BALINESE ...
+      | 0xE1 0xAC 0xB4          #Mn       BALINESE SIGN REREKAN
+      | 0xE1 0xAC 0xB6..0xBA    #Mn   [5] BALINESE VOWEL SIGN ULU..BALINESE ...
+      | 0xE1 0xAC 0xBC          #Mn       BALINESE VOWEL SIGN LA LENGA
+      | 0xE1 0xAD 0x82          #Mn       BALINESE VOWEL SIGN PEPET
+      | 0xE1 0xAD 0xAB..0xB3    #Mn   [9] BALINESE MUSICAL SYMBOL COMBINING ...
+      | 0xE1 0xAE 0x80..0x81    #Mn   [2] SUNDANESE SIGN PANYECEK..SUNDANESE...
+      | 0xE1 0xAE 0xA2..0xA5    #Mn   [4] SUNDANESE CONSONANT SIGN PANYAKRA....
+      | 0xE1 0xAE 0xA8..0xA9    #Mn   [2] SUNDANESE VOWEL SIGN PAMEPET..SUND...
+      | 0xE1 0xAE 0xAB..0xAD    #Mn   [3] SUNDANESE SIGN VIRAMA..SUNDANESE C...
+      | 0xE1 0xAF 0xA6          #Mn       BATAK SIGN TOMPI
+      | 0xE1 0xAF 0xA8..0xA9    #Mn   [2] BATAK VOWEL SIGN PAKPAK E..BATAK V...
+      | 0xE1 0xAF 0xAD          #Mn       BATAK VOWEL SIGN KARO O
+      | 0xE1 0xAF 0xAF..0xB1    #Mn   [3] BATAK VOWEL SIGN U FOR SIMALUNGUN ...
+      | 0xE1 0xB0 0xAC..0xB3    #Mn   [8] LEPCHA VOWEL SIGN E..LEPCHA CONSON...
+      | 0xE1 0xB0 0xB6..0xB7    #Mn   [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA
+      | 0xE1 0xB3 0x90..0x92    #Mn   [3] VEDIC TONE KARSHANA..VEDIC TONE PR...
+      | 0xE1 0xB3 0x94..0xA0    #Mn  [13] VEDIC SIGN YAJURVEDIC MIDLINE SVAR...
+      | 0xE1 0xB3 0xA2..0xA8    #Mn   [7] VEDIC SIGN VISARGA SVARITA..VEDIC ...
+      | 0xE1 0xB3 0xAD          #Mn       VEDIC SIGN TIRYAK
+      | 0xE1 0xB3 0xB4          #Mn       VEDIC TONE CANDRA ABOVE
+      | 0xE1 0xB3 0xB8..0xB9    #Mn   [2] VEDIC TONE RING ABOVE..VEDIC TONE ...
+      | 0xE1 0xB7 0x80..0xB5    #Mn  [54] COMBINING DOTTED GRAVE ACCENT..COM...
+      | 0xE1 0xB7 0xBB..0xBF    #Mn   [5] COMBINING DELETION MARK..COMBINING...
+      | 0xE2 0x80 0x8C          #Cf       ZERO WIDTH NON-JOINER
+      | 0xE2 0x83 0x90..0x9C    #Mn  [13] COMBINING LEFT HARPOON ABOVE..COMB...
+      | 0xE2 0x83 0x9D..0xA0    #Me   [4] COMBINING ENCLOSING CIRCLE..COMBIN...
+      | 0xE2 0x83 0xA1          #Mn       COMBINING LEFT RIGHT ARROW ABOVE
+      | 0xE2 0x83 0xA2..0xA4    #Me   [3] COMBINING ENCLOSING SCREEN..COMBIN...
+      | 0xE2 0x83 0xA5..0xB0    #Mn  [12] COMBINING REVERSE SOLIDUS OVERLAY....
+      | 0xE2 0xB3 0xAF..0xB1    #Mn   [3] COPTIC COMBINING NI ABOVE..COPTIC ...
+      | 0xE2 0xB5 0xBF          #Mn       TIFINAGH CONSONANT JOINER
+      | 0xE2 0xB7 0xA0..0xBF    #Mn  [32] COMBINING CYRILLIC LETTER BE..COMB...
+      | 0xE3 0x80 0xAA..0xAD    #Mn   [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOG...
+      | 0xE3 0x80 0xAE..0xAF    #Mc   [2] HANGUL SINGLE DOT TONE MARK..HANGU...
+      | 0xE3 0x82 0x99..0x9A    #Mn   [2] COMBINING KATAKANA-HIRAGANA VOICED...
+      | 0xEA 0x99 0xAF          #Mn       COMBINING CYRILLIC VZMET
+      | 0xEA 0x99 0xB0..0xB2    #Me   [3] COMBINING CYRILLIC TEN MILLIONS SI...
+      | 0xEA 0x99 0xB4..0xBD    #Mn  [10] COMBINING CYRILLIC LETTER UKRAINIA...
+      | 0xEA 0x9A 0x9E..0x9F    #Mn   [2] COMBINING CYRILLIC LETTER EF..COMB...
+      | 0xEA 0x9B 0xB0..0xB1    #Mn   [2] BAMUM COMBINING MARK KOQNDON..BAMU...
+      | 0xEA 0xA0 0x82          #Mn       SYLOTI NAGRI SIGN DVISVARA
+      | 0xEA 0xA0 0x86          #Mn       SYLOTI NAGRI SIGN HASANTA
+      | 0xEA 0xA0 0x8B          #Mn       SYLOTI NAGRI SIGN ANUSVARA
+      | 0xEA 0xA0 0xA5..0xA6    #Mn   [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI ...
+      | 0xEA 0xA3 0x84..0x85    #Mn   [2] SAURASHTRA SIGN VIRAMA..SAURASHTRA...
+      | 0xEA 0xA3 0xA0..0xB1    #Mn  [18] COMBINING DEVANAGARI DIGIT ZERO..C...
+      | 0xEA 0xA4 0xA6..0xAD    #Mn   [8] KAYAH LI VOWEL UE..KAYAH LI TONE C...
+      | 0xEA 0xA5 0x87..0x91    #Mn  [11] REJANG VOWEL SIGN I..REJANG CONSON...
+      | 0xEA 0xA6 0x80..0x82    #Mn   [3] JAVANESE SIGN PANYANGGA..JAVANESE ...
+      | 0xEA 0xA6 0xB3          #Mn       JAVANESE SIGN CECAK TELU
+      | 0xEA 0xA6 0xB6..0xB9    #Mn   [4] JAVANESE VOWEL SIGN WULU..JAVANESE...
+      | 0xEA 0xA6 0xBC          #Mn       JAVANESE VOWEL SIGN PEPET
+      | 0xEA 0xA7 0xA5          #Mn       MYANMAR SIGN SHAN SAW
+      | 0xEA 0xA8 0xA9..0xAE    #Mn   [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIG...
+      | 0xEA 0xA8 0xB1..0xB2    #Mn   [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIG...
+      | 0xEA 0xA8 0xB5..0xB6    #Mn   [2] CHAM CONSONANT SIGN LA..CHAM CONSO...
+      | 0xEA 0xA9 0x83          #Mn       CHAM CONSONANT SIGN FINAL NG
+      | 0xEA 0xA9 0x8C          #Mn       CHAM CONSONANT SIGN FINAL M
+      | 0xEA 0xA9 0xBC          #Mn       MYANMAR SIGN TAI LAING TONE-2
+      | 0xEA 0xAA 0xB0          #Mn       TAI VIET MAI KANG
+      | 0xEA 0xAA 0xB2..0xB4    #Mn   [3] TAI VIET VOWEL I..TAI VIET VOWEL U
+      | 0xEA 0xAA 0xB7..0xB8    #Mn   [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA
+      | 0xEA 0xAA 0xBE..0xBF    #Mn   [2] TAI VIET VOWEL AM..TAI VIET TONE M...
+      | 0xEA 0xAB 0x81          #Mn       TAI VIET TONE MAI THO
+      | 0xEA 0xAB 0xAC..0xAD    #Mn   [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI...
+      | 0xEA 0xAB 0xB6          #Mn       MEETEI MAYEK VIRAMA
+      | 0xEA 0xAF 0xA5          #Mn       MEETEI MAYEK VOWEL SIGN ANAP
+      | 0xEA 0xAF 0xA8          #Mn       MEETEI MAYEK VOWEL SIGN UNAP
+      | 0xEA 0xAF 0xAD          #Mn       MEETEI MAYEK APUN IYEK
+      | 0xEF 0xAC 0x9E          #Mn       HEBREW POINT JUDEO-SPANISH VARIKA
+      | 0xEF 0xB8 0x80..0x8F    #Mn  [16] VARIATION SELECTOR-1..VARIATION SE...
+      | 0xEF 0xB8 0xA0..0xAF    #Mn  [16] COMBINING LIGATURE LEFT HALF..COMB...
+      | 0xEF 0xBE 0x9E..0x9F    #Lm   [2] HALFWIDTH KATAKANA VOICED SOUND MA...
+      | 0xF0 0x90 0x87 0xBD     #Mn       PHAISTOS DISC SIGN COMBINING OBLIQ...
+      | 0xF0 0x90 0x8B 0xA0     #Mn       COPTIC EPACT THOUSANDS MARK
+      | 0xF0 0x90 0x8D 0xB6..0xBA  #Mn   [5] COMBINING OLD PERMIC LETTER AN....
+      | 0xF0 0x90 0xA8 0x81..0x83  #Mn   [3] KHAROSHTHI VOWEL SIGN I..KHAROS...
+      | 0xF0 0x90 0xA8 0x85..0x86  #Mn   [2] KHAROSHTHI VOWEL SIGN E..KHAROS...
+      | 0xF0 0x90 0xA8 0x8C..0x8F  #Mn   [4] KHAROSHTHI VOWEL LENGTH MARK..K...
+      | 0xF0 0x90 0xA8 0xB8..0xBA  #Mn   [3] KHAROSHTHI SIGN BAR ABOVE..KHAR...
+      | 0xF0 0x90 0xA8 0xBF     #Mn       KHAROSHTHI VIRAMA
+      | 0xF0 0x90 0xAB 0xA5..0xA6  #Mn   [2] MANICHAEAN ABBREVIATION MARK AB...
+      | 0xF0 0x91 0x80 0x81     #Mn       BRAHMI SIGN ANUSVARA
+      | 0xF0 0x91 0x80 0xB8..0xFF  #Mn  [15] BRAHMI VOWEL SIGN AA..BRAHMI VI...
+      | 0xF0 0x91 0x81 0x00..0x86  #
+      | 0xF0 0x91 0x81 0xBF..0xFF  #Mn   [3] BRAHMI NUMBER JOINER..KAITHI SI...
+      | 0xF0 0x91 0x82 0x00..0x81  #
+      | 0xF0 0x91 0x82 0xB3..0xB6  #Mn   [4] KAITHI VOWEL SIGN U..KAITHI VOW...
+      | 0xF0 0x91 0x82 0xB9..0xBA  #Mn   [2] KAITHI SIGN VIRAMA..KAITHI SIGN...
+      | 0xF0 0x91 0x84 0x80..0x82  #Mn   [3] CHAKMA SIGN CANDRABINDU..CHAKMA...
+      | 0xF0 0x91 0x84 0xA7..0xAB  #Mn   [5] CHAKMA VOWEL SIGN A..CHAKMA VOW...
+      | 0xF0 0x91 0x84 0xAD..0xB4  #Mn   [8] CHAKMA VOWEL SIGN AI..CHAKMA MA...
+      | 0xF0 0x91 0x85 0xB3     #Mn       MAHAJANI SIGN NUKTA
+      | 0xF0 0x91 0x86 0x80..0x81  #Mn   [2] SHARADA SIGN CANDRABINDU..SHARA...
+      | 0xF0 0x91 0x86 0xB6..0xBE  #Mn   [9] SHARADA VOWEL SIGN U..SHARADA V...
+      | 0xF0 0x91 0x87 0x8A..0x8C  #Mn   [3] SHARADA SIGN NUKTA..SHARADA EXT...
+      | 0xF0 0x91 0x88 0xAF..0xB1  #Mn   [3] KHOJKI VOWEL SIGN U..KHOJKI VOW...
+      | 0xF0 0x91 0x88 0xB4     #Mn       KHOJKI SIGN ANUSVARA
+      | 0xF0 0x91 0x88 0xB6..0xB7  #Mn   [2] KHOJKI SIGN NUKTA..KHOJKI SIGN ...
+      | 0xF0 0x91 0x88 0xBE     #Mn       KHOJKI SIGN SUKUN
+      | 0xF0 0x91 0x8B 0x9F     #Mn       KHUDAWADI SIGN ANUSVARA
+      | 0xF0 0x91 0x8B 0xA3..0xAA  #Mn   [8] KHUDAWADI VOWEL SIGN U..KHUDAWA...
+      | 0xF0 0x91 0x8C 0x80..0x81  #Mn   [2] GRANTHA SIGN COMBINING ANUSVARA...
+      | 0xF0 0x91 0x8C 0xBC     #Mn       GRANTHA SIGN NUKTA
+      | 0xF0 0x91 0x8C 0xBE     #Mc       GRANTHA VOWEL SIGN AA
+      | 0xF0 0x91 0x8D 0x80     #Mn       GRANTHA VOWEL SIGN II
+      | 0xF0 0x91 0x8D 0x97     #Mc       GRANTHA AU LENGTH MARK
+      | 0xF0 0x91 0x8D 0xA6..0xAC  #Mn   [7] COMBINING GRANTHA DIGIT ZERO..C...
+      | 0xF0 0x91 0x8D 0xB0..0xB4  #Mn   [5] COMBINING GRANTHA LETTER A..COM...
+      | 0xF0 0x91 0x90 0xB8..0xBF  #Mn   [8] NEWA VOWEL SIGN U..NEWA VOWEL S...
+      | 0xF0 0x91 0x91 0x82..0x84  #Mn   [3] NEWA SIGN VIRAMA..NEWA SIGN ANU...
+      | 0xF0 0x91 0x91 0x86     #Mn       NEWA SIGN NUKTA
+      | 0xF0 0x91 0x92 0xB0     #Mc       TIRHUTA VOWEL SIGN AA
+      | 0xF0 0x91 0x92 0xB3..0xB8  #Mn   [6] TIRHUTA VOWEL SIGN U..TIRHUTA V...
+      | 0xF0 0x91 0x92 0xBA     #Mn       TIRHUTA VOWEL SIGN SHORT E
+      | 0xF0 0x91 0x92 0xBD     #Mc       TIRHUTA VOWEL SIGN SHORT O
+      | 0xF0 0x91 0x92 0xBF..0xFF  #Mn   [2] TIRHUTA SIGN CANDRABINDU..TIRHU...
+      | 0xF0 0x91 0x93 0x00..0x80  #
+      | 0xF0 0x91 0x93 0x82..0x83  #Mn   [2] TIRHUTA SIGN VIRAMA..TIRHUTA SI...
+      | 0xF0 0x91 0x96 0xAF     #Mc       SIDDHAM VOWEL SIGN AA
+      | 0xF0 0x91 0x96 0xB2..0xB5  #Mn   [4] SIDDHAM VOWEL SIGN U..SIDDHAM V...
+      | 0xF0 0x91 0x96 0xBC..0xBD  #Mn   [2] SIDDHAM SIGN CANDRABINDU..SIDDH...
+      | 0xF0 0x91 0x96 0xBF..0xFF  #Mn   [2] SIDDHAM SIGN VIRAMA..SIDDHAM SI...
+      | 0xF0 0x91 0x97 0x00..0x80  #
+      | 0xF0 0x91 0x97 0x9C..0x9D  #Mn   [2] SIDDHAM VOWEL SIGN ALTERNATE U....
+      | 0xF0 0x91 0x98 0xB3..0xBA  #Mn   [8] MODI VOWEL SIGN U..MODI VOWEL S...
+      | 0xF0 0x91 0x98 0xBD     #Mn       MODI SIGN ANUSVARA
+      | 0xF0 0x91 0x98 0xBF..0xFF  #Mn   [2] MODI SIGN VIRAMA..MODI SIGN ARD...
+      | 0xF0 0x91 0x99 0x00..0x80  #
+      | 0xF0 0x91 0x9A 0xAB     #Mn       TAKRI SIGN ANUSVARA
+      | 0xF0 0x91 0x9A 0xAD     #Mn       TAKRI VOWEL SIGN AA
+      | 0xF0 0x91 0x9A 0xB0..0xB5  #Mn   [6] TAKRI VOWEL SIGN U..TAKRI VOWEL...
+      | 0xF0 0x91 0x9A 0xB7     #Mn       TAKRI SIGN NUKTA
+      | 0xF0 0x91 0x9C 0x9D..0x9F  #Mn   [3] AHOM CONSONANT SIGN MEDIAL LA.....
+      | 0xF0 0x91 0x9C 0xA2..0xA5  #Mn   [4] AHOM VOWEL SIGN I..AHOM VOWEL S...
+      | 0xF0 0x91 0x9C 0xA7..0xAB  #Mn   [5] AHOM VOWEL SIGN AW..AHOM SIGN K...
+      | 0xF0 0x91 0xB0 0xB0..0xB6  #Mn   [7] BHAIKSUKI VOWEL SIGN I..BHAIKSU...
+      | 0xF0 0x91 0xB0 0xB8..0xBD  #Mn   [6] BHAIKSUKI VOWEL SIGN E..BHAIKSU...
+      | 0xF0 0x91 0xB0 0xBF     #Mn       BHAIKSUKI SIGN VIRAMA
+      | 0xF0 0x91 0xB2 0x92..0xA7  #Mn  [22] MARCHEN SUBJOINED LETTER KA..MA...
+      | 0xF0 0x91 0xB2 0xAA..0xB0  #Mn   [7] MARCHEN SUBJOINED LETTER RA..MA...
+      | 0xF0 0x91 0xB2 0xB2..0xB3  #Mn   [2] MARCHEN VOWEL SIGN U..MARCHEN V...
+      | 0xF0 0x91 0xB2 0xB5..0xB6  #Mn   [2] MARCHEN SIGN ANUSVARA..MARCHEN ...
+      | 0xF0 0x96 0xAB 0xB0..0xB4  #Mn   [5] BASSA VAH COMBINING HIGH TONE.....
+      | 0xF0 0x96 0xAC 0xB0..0xB6  #Mn   [7] PAHAWH HMONG MARK CIM TUB..PAHA...
+      | 0xF0 0x96 0xBE 0x8F..0x92  #Mn   [4] MIAO TONE RIGHT..MIAO TONE BELOW
+      | 0xF0 0x9B 0xB2 0x9D..0x9E  #Mn   [2] DUPLOYAN THICK LETTER SELECTOR....
+      | 0xF0 0x9D 0x85 0xA5     #Mc       MUSICAL SYMBOL COMBINING STEM
+      | 0xF0 0x9D 0x85 0xA7..0xA9  #Mn   [3] MUSICAL SYMBOL COMBINING TREMOL...
+      | 0xF0 0x9D 0x85 0xAE..0xB2  #Mc   [5] MUSICAL SYMBOL COMBINING FLAG-1...
+      | 0xF0 0x9D 0x85 0xBB..0xFF  #Mn   [8] MUSICAL SYMBOL COMBINING ACCENT...
+      | 0xF0 0x9D 0x86 0x00..0x82  #
+      | 0xF0 0x9D 0x86 0x85..0x8B  #Mn   [7] MUSICAL SYMBOL COMBINING DOIT.....
+      | 0xF0 0x9D 0x86 0xAA..0xAD  #Mn   [4] MUSICAL SYMBOL COMBINING DOWN B...
+      | 0xF0 0x9D 0x89 0x82..0x84  #Mn   [3] COMBINING GREEK MUSICAL TRISEME...
+      | 0xF0 0x9D 0xA8 0x80..0xB6  #Mn  [55] SIGNWRITING HEAD RIM..SIGNWRITI...
+      | 0xF0 0x9D 0xA8 0xBB..0xFF  #Mn  [50] SIGNWRITING MOUTH CLOSED NEUTRA...
+      | 0xF0 0x9D 0xA9 0x00..0xAC  #
+      | 0xF0 0x9D 0xA9 0xB5     #Mn       SIGNWRITING UPPER BODY TILTING FRO...
+      | 0xF0 0x9D 0xAA 0x84     #Mn       SIGNWRITING LOCATION HEAD NECK
+      | 0xF0 0x9D 0xAA 0x9B..0x9F  #Mn   [5] SIGNWRITING FILL MODIFIER-2..SI...
+      | 0xF0 0x9D 0xAA 0xA1..0xAF  #Mn  [15] SIGNWRITING ROTATION MODIFIER-2...
+      | 0xF0 0x9E 0x80 0x80..0x86  #Mn   [7] COMBINING GLAGOLITIC LETTER AZU...
+      | 0xF0 0x9E 0x80 0x88..0x98  #Mn  [17] COMBINING GLAGOLITIC LETTER ZEM...
+      | 0xF0 0x9E 0x80 0x9B..0xA1  #Mn   [7] COMBINING GLAGOLITIC LETTER SHT...
+      | 0xF0 0x9E 0x80 0xA3..0xA4  #Mn   [2] COMBINING GLAGOLITIC LETTER YU....
+      | 0xF0 0x9E 0x80 0xA6..0xAA  #Mn   [5] COMBINING GLAGOLITIC LETTER YO....
+      | 0xF0 0x9E 0xA3 0x90..0x96  #Mn   [7] MENDE KIKAKUI COMBINING NUMBER ...
+      | 0xF0 0x9E 0xA5 0x84..0x8A  #Mn   [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA
+      | 0xF3 0xA0 0x80 0xA0..0xFF  #Cf  [96] TAG SPACE..CANCEL TAG
+      | 0xF3 0xA0 0x81 0x00..0xBF  #
+      | 0xF3 0xA0 0x84 0x80..0xFF        #Mn [240] VARIATION SELECTOR-17..VA...
+      | 0xF3 0xA0 0x85..0x86 0x00..0xFF  #
+      | 0xF3 0xA0 0x87 0x00..0xAF        #
+      ;
+
+    Regional_Indicator = 
+        0xF0 0x9F 0x87 0xA6..0xBF  #So  [26] REGIONAL INDICATOR SYMBOL LETTE...
+      ;
+
+    SpacingMark = 
+        0xE0 0xA4 0x83          #Mc       DEVANAGARI SIGN VISARGA
+      | 0xE0 0xA4 0xBB          #Mc       DEVANAGARI VOWEL SIGN OOE
+      | 0xE0 0xA4 0xBE..0xFF    #Mc   [3] DEVANAGARI VOWEL SIGN AA..DEVANAGA...
+      | 0xE0 0xA5 0x00..0x80    #
+      | 0xE0 0xA5 0x89..0x8C    #Mc   [4] DEVANAGARI VOWEL SIGN CANDRA O..DE...
+      | 0xE0 0xA5 0x8E..0x8F    #Mc   [2] DEVANAGARI VOWEL SIGN PRISHTHAMATR...
+      | 0xE0 0xA6 0x82..0x83    #Mc   [2] BENGALI SIGN ANUSVARA..BENGALI SIG...
+      | 0xE0 0xA6 0xBF..0xFF    #Mc   [2] BENGALI VOWEL SIGN I..BENGALI VOWE...
+      | 0xE0 0xA7 0x00..0x80    #
+      | 0xE0 0xA7 0x87..0x88    #Mc   [2] BENGALI VOWEL SIGN E..BENGALI VOWE...
+      | 0xE0 0xA7 0x8B..0x8C    #Mc   [2] BENGALI VOWEL SIGN O..BENGALI VOWE...
+      | 0xE0 0xA8 0x83          #Mc       GURMUKHI SIGN VISARGA
+      | 0xE0 0xA8 0xBE..0xFF    #Mc   [3] GURMUKHI VOWEL SIGN AA..GURMUKHI V...
+      | 0xE0 0xA9 0x00..0x80    #
+      | 0xE0 0xAA 0x83          #Mc       GUJARATI SIGN VISARGA
+      | 0xE0 0xAA 0xBE..0xFF    #Mc   [3] GUJARATI VOWEL SIGN AA..GUJARATI V...
+      | 0xE0 0xAB 0x00..0x80    #
+      | 0xE0 0xAB 0x89          #Mc       GUJARATI VOWEL SIGN CANDRA O
+      | 0xE0 0xAB 0x8B..0x8C    #Mc   [2] GUJARATI VOWEL SIGN O..GUJARATI VO...
+      | 0xE0 0xAC 0x82..0x83    #Mc   [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VI...
+      | 0xE0 0xAD 0x80          #Mc       ORIYA VOWEL SIGN II
+      | 0xE0 0xAD 0x87..0x88    #Mc   [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SI...
+      | 0xE0 0xAD 0x8B..0x8C    #Mc   [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SI...
+      | 0xE0 0xAE 0xBF          #Mc       TAMIL VOWEL SIGN I
+      | 0xE0 0xAF 0x81..0x82    #Mc   [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SI...
+      | 0xE0 0xAF 0x86..0x88    #Mc   [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SI...
+      | 0xE0 0xAF 0x8A..0x8C    #Mc   [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SI...
+      | 0xE0 0xB0 0x81..0x83    #Mc   [3] TELUGU SIGN CANDRABINDU..TELUGU SI...
+      | 0xE0 0xB1 0x81..0x84    #Mc   [4] TELUGU VOWEL SIGN U..TELUGU VOWEL ...
+      | 0xE0 0xB2 0x82..0x83    #Mc   [2] KANNADA SIGN ANUSVARA..KANNADA SIG...
+      | 0xE0 0xB2 0xBE          #Mc       KANNADA VOWEL SIGN AA
+      | 0xE0 0xB3 0x80..0x81    #Mc   [2] KANNADA VOWEL SIGN II..KANNADA VOW...
+      | 0xE0 0xB3 0x83..0x84    #Mc   [2] KANNADA VOWEL SIGN VOCALIC R..KANN...
+      | 0xE0 0xB3 0x87..0x88    #Mc   [2] KANNADA VOWEL SIGN EE..KANNADA VOW...
+      | 0xE0 0xB3 0x8A..0x8B    #Mc   [2] KANNADA VOWEL SIGN O..KANNADA VOWE...
+      | 0xE0 0xB4 0x82..0x83    #Mc   [2] MALAYALAM SIGN ANUSVARA..MALAYALAM...
+      | 0xE0 0xB4 0xBF..0xFF    #Mc   [2] MALAYALAM VOWEL SIGN I..MALAYALAM ...
+      | 0xE0 0xB5 0x00..0x80    #
+      | 0xE0 0xB5 0x86..0x88    #Mc   [3] MALAYALAM VOWEL SIGN E..MALAYALAM ...
+      | 0xE0 0xB5 0x8A..0x8C    #Mc   [3] MALAYALAM VOWEL SIGN O..MALAYALAM ...
+      | 0xE0 0xB6 0x82..0x83    #Mc   [2] SINHALA SIGN ANUSVARAYA..SINHALA S...
+      | 0xE0 0xB7 0x90..0x91    #Mc   [2] SINHALA VOWEL SIGN KETTI AEDA-PILL...
+      | 0xE0 0xB7 0x98..0x9E    #Mc   [7] SINHALA VOWEL SIGN GAETTA-PILLA..S...
+      | 0xE0 0xB7 0xB2..0xB3    #Mc   [2] SINHALA VOWEL SIGN DIGA GAETTA-PIL...
+      | 0xE0 0xB8 0xB3          #Lo       THAI CHARACTER SARA AM
+      | 0xE0 0xBA 0xB3          #Lo       LAO VOWEL SIGN AM
+      | 0xE0 0xBC 0xBE..0xBF    #Mc   [2] TIBETAN SIGN YAR TSHES..TIBETAN SI...
+      | 0xE0 0xBD 0xBF          #Mc       TIBETAN SIGN RNAM BCAD
+      | 0xE1 0x80 0xB1          #Mc       MYANMAR VOWEL SIGN E
+      | 0xE1 0x80 0xBB..0xBC    #Mc   [2] MYANMAR CONSONANT SIGN MEDIAL YA.....
+      | 0xE1 0x81 0x96..0x97    #Mc   [2] MYANMAR VOWEL SIGN VOCALIC R..MYAN...
+      | 0xE1 0x82 0x84          #Mc       MYANMAR VOWEL SIGN SHAN E
+      | 0xE1 0x9E 0xB6          #Mc       KHMER VOWEL SIGN AA
+      | 0xE1 0x9E 0xBE..0xFF    #Mc   [8] KHMER VOWEL SIGN OE..KHMER VOWEL S...
+      | 0xE1 0x9F 0x00..0x85    #
+      | 0xE1 0x9F 0x87..0x88    #Mc   [2] KHMER SIGN REAHMUK..KHMER SIGN YUU...
+      | 0xE1 0xA4 0xA3..0xA6    #Mc   [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL S...
+      | 0xE1 0xA4 0xA9..0xAB    #Mc   [3] LIMBU SUBJOINED LETTER YA..LIMBU S...
+      | 0xE1 0xA4 0xB0..0xB1    #Mc   [2] LIMBU SMALL LETTER KA..LIMBU SMALL...
+      | 0xE1 0xA4 0xB3..0xB8    #Mc   [6] LIMBU SMALL LETTER TA..LIMBU SMALL...
+      | 0xE1 0xA8 0x99..0x9A    #Mc   [2] BUGINESE VOWEL SIGN E..BUGINESE VO...
+      | 0xE1 0xA9 0x95          #Mc       TAI THAM CONSONANT SIGN MEDIAL RA
+      | 0xE1 0xA9 0x97          #Mc       TAI THAM CONSONANT SIGN LA TANG LAI
+      | 0xE1 0xA9 0xAD..0xB2    #Mc   [6] TAI THAM VOWEL SIGN OY..TAI THAM V...
+      | 0xE1 0xAC 0x84          #Mc       BALINESE SIGN BISAH
+      | 0xE1 0xAC 0xB5          #Mc       BALINESE VOWEL SIGN TEDUNG
+      | 0xE1 0xAC 0xBB          #Mc       BALINESE VOWEL SIGN RA REPA TEDUNG
+      | 0xE1 0xAC 0xBD..0xFF    #Mc   [5] BALINESE VOWEL SIGN LA LENGA TEDUN...
+      | 0xE1 0xAD 0x00..0x81    #
+      | 0xE1 0xAD 0x83..0x84    #Mc   [2] BALINESE VOWEL SIGN PEPET TEDUNG.....
+      | 0xE1 0xAE 0x82          #Mc       SUNDANESE SIGN PANGWISAD
+      | 0xE1 0xAE 0xA1          #Mc       SUNDANESE CONSONANT SIGN PAMINGKAL
+      | 0xE1 0xAE 0xA6..0xA7    #Mc   [2] SUNDANESE VOWEL SIGN PANAELAENG..S...
+      | 0xE1 0xAE 0xAA          #Mc       SUNDANESE SIGN PAMAAEH
+      | 0xE1 0xAF 0xA7          #Mc       BATAK VOWEL SIGN E
+      | 0xE1 0xAF 0xAA..0xAC    #Mc   [3] BATAK VOWEL SIGN I..BATAK VOWEL SI...
+      | 0xE1 0xAF 0xAE          #Mc       BATAK VOWEL SIGN U
+      | 0xE1 0xAF 0xB2..0xB3    #Mc   [2] BATAK PANGOLAT..BATAK PANONGONAN
+      | 0xE1 0xB0 0xA4..0xAB    #Mc   [8] LEPCHA SUBJOINED LETTER YA..LEPCHA...
+      | 0xE1 0xB0 0xB4..0xB5    #Mc   [2] LEPCHA CONSONANT SIGN NYIN-DO..LEP...
+      | 0xE1 0xB3 0xA1          #Mc       VEDIC TONE ATHARVAVEDIC INDEPENDEN...
+      | 0xE1 0xB3 0xB2..0xB3    #Mc   [2] VEDIC SIGN ARDHAVISARGA..VEDIC SIG...
+      | 0xEA 0xA0 0xA3..0xA4    #Mc   [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI ...
+      | 0xEA 0xA0 0xA7          #Mc       SYLOTI NAGRI VOWEL SIGN OO
+      | 0xEA 0xA2 0x80..0x81    #Mc   [2] SAURASHTRA SIGN ANUSVARA..SAURASHT...
+      | 0xEA 0xA2 0xB4..0xFF    #Mc  [16] SAURASHTRA CONSONANT SIGN HAARU..S...
+      | 0xEA 0xA3 0x00..0x83    #
+      | 0xEA 0xA5 0x92..0x93    #Mc   [2] REJANG CONSONANT SIGN H..REJANG VI...
+      | 0xEA 0xA6 0x83          #Mc       JAVANESE SIGN WIGNYAN
+      | 0xEA 0xA6 0xB4..0xB5    #Mc   [2] JAVANESE VOWEL SIGN TARUNG..JAVANE...
+      | 0xEA 0xA6 0xBA..0xBB    #Mc   [2] JAVANESE VOWEL SIGN TALING..JAVANE...
+      | 0xEA 0xA6 0xBD..0xFF    #Mc   [4] JAVANESE CONSONANT SIGN KERET..JAV...
+      | 0xEA 0xA7 0x00..0x80    #
+      | 0xEA 0xA8 0xAF..0xB0    #Mc   [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI
+      | 0xEA 0xA8 0xB3..0xB4    #Mc   [2] CHAM CONSONANT SIGN YA..CHAM CONSO...
+      | 0xEA 0xA9 0x8D          #Mc       CHAM CONSONANT SIGN FINAL H
+      | 0xEA 0xAB 0xAB          #Mc       MEETEI MAYEK VOWEL SIGN II
+      | 0xEA 0xAB 0xAE..0xAF    #Mc   [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI...
+      | 0xEA 0xAB 0xB5          #Mc       MEETEI MAYEK VOWEL SIGN VISARGA
+      | 0xEA 0xAF 0xA3..0xA4    #Mc   [2] MEETEI MAYEK VOWEL SIGN ONAP..MEET...
+      | 0xEA 0xAF 0xA6..0xA7    #Mc   [2] MEETEI MAYEK VOWEL SIGN YENAP..MEE...
+      | 0xEA 0xAF 0xA9..0xAA    #Mc   [2] MEETEI MAYEK VOWEL SIGN CHEINAP..M...
+      | 0xEA 0xAF 0xAC          #Mc       MEETEI MAYEK LUM IYEK
+      | 0xF0 0x91 0x80 0x80     #Mc       BRAHMI SIGN CANDRABINDU
+      | 0xF0 0x91 0x80 0x82     #Mc       BRAHMI SIGN VISARGA
+      | 0xF0 0x91 0x82 0x82     #Mc       KAITHI SIGN VISARGA
+      | 0xF0 0x91 0x82 0xB0..0xB2  #Mc   [3] KAITHI VOWEL SIGN AA..KAITHI VO...
+      | 0xF0 0x91 0x82 0xB7..0xB8  #Mc   [2] KAITHI VOWEL SIGN O..KAITHI VOW...
+      | 0xF0 0x91 0x84 0xAC     #Mc       CHAKMA VOWEL SIGN E
+      | 0xF0 0x91 0x86 0x82     #Mc       SHARADA SIGN VISARGA
+      | 0xF0 0x91 0x86 0xB3..0xB5  #Mc   [3] SHARADA VOWEL SIGN AA..SHARADA ...
+      | 0xF0 0x91 0x86 0xBF..0xFF  #Mc   [2] SHARADA VOWEL SIGN AU..SHARADA ...
+      | 0xF0 0x91 0x87 0x00..0x80  #
+      | 0xF0 0x91 0x88 0xAC..0xAE  #Mc   [3] KHOJKI VOWEL SIGN AA..KHOJKI VO...
+      | 0xF0 0x91 0x88 0xB2..0xB3  #Mc   [2] KHOJKI VOWEL SIGN O..KHOJKI VOW...
+      | 0xF0 0x91 0x88 0xB5     #Mc       KHOJKI SIGN VIRAMA
+      | 0xF0 0x91 0x8B 0xA0..0xA2  #Mc   [3] KHUDAWADI VOWEL SIGN AA..KHUDAW...
+      | 0xF0 0x91 0x8C 0x82..0x83  #Mc   [2] GRANTHA SIGN ANUSVARA..GRANTHA ...
+      | 0xF0 0x91 0x8C 0xBF     #Mc       GRANTHA VOWEL SIGN I
+      | 0xF0 0x91 0x8D 0x81..0x84  #Mc   [4] GRANTHA VOWEL SIGN U..GRANTHA V...
+      | 0xF0 0x91 0x8D 0x87..0x88  #Mc   [2] GRANTHA VOWEL SIGN EE..GRANTHA ...
+      | 0xF0 0x91 0x8D 0x8B..0x8D  #Mc   [3] GRANTHA VOWEL SIGN OO..GRANTHA ...
+      | 0xF0 0x91 0x8D 0xA2..0xA3  #Mc   [2] GRANTHA VOWEL SIGN VOCALIC L..G...
+      | 0xF0 0x91 0x90 0xB5..0xB7  #Mc   [3] NEWA VOWEL SIGN AA..NEWA VOWEL ...
+      | 0xF0 0x91 0x91 0x80..0x81  #Mc   [2] NEWA VOWEL SIGN O..NEWA VOWEL S...
+      | 0xF0 0x91 0x91 0x85     #Mc       NEWA SIGN VISARGA
+      | 0xF0 0x91 0x92 0xB1..0xB2  #Mc   [2] TIRHUTA VOWEL SIGN I..TIRHUTA V...
+      | 0xF0 0x91 0x92 0xB9     #Mc       TIRHUTA VOWEL SIGN E
+      | 0xF0 0x91 0x92 0xBB..0xBC  #Mc   [2] TIRHUTA VOWEL SIGN AI..TIRHUTA ...
+      | 0xF0 0x91 0x92 0xBE     #Mc       TIRHUTA VOWEL SIGN AU
+      | 0xF0 0x91 0x93 0x81     #Mc       TIRHUTA SIGN VISARGA
+      | 0xF0 0x91 0x96 0xB0..0xB1  #Mc   [2] SIDDHAM VOWEL SIGN I..SIDDHAM V...
+      | 0xF0 0x91 0x96 0xB8..0xBB  #Mc   [4] SIDDHAM VOWEL SIGN E..SIDDHAM V...
+      | 0xF0 0x91 0x96 0xBE     #Mc       SIDDHAM SIGN VISARGA
+      | 0xF0 0x91 0x98 0xB0..0xB2  #Mc   [3] MODI VOWEL SIGN AA..MODI VOWEL ...
+      | 0xF0 0x91 0x98 0xBB..0xBC  #Mc   [2] MODI VOWEL SIGN O..MODI VOWEL S...
+      | 0xF0 0x91 0x98 0xBE     #Mc       MODI SIGN VISARGA
+      | 0xF0 0x91 0x9A 0xAC     #Mc       TAKRI SIGN VISARGA
+      | 0xF0 0x91 0x9A 0xAE..0xAF  #Mc   [2] TAKRI VOWEL SIGN I..TAKRI VOWEL...
+      | 0xF0 0x91 0x9A 0xB6     #Mc       TAKRI SIGN VIRAMA
+      | 0xF0 0x91 0x9C 0xA0..0xA1  #Mc   [2] AHOM VOWEL SIGN A..AHOM VOWEL S...
+      | 0xF0 0x91 0x9C 0xA6     #Mc       AHOM VOWEL SIGN E
+      | 0xF0 0x91 0xB0 0xAF     #Mc       BHAIKSUKI VOWEL SIGN AA
+      | 0xF0 0x91 0xB0 0xBE     #Mc       BHAIKSUKI SIGN VISARGA
+      | 0xF0 0x91 0xB2 0xA9     #Mc       MARCHEN SUBJOINED LETTER YA
+      | 0xF0 0x91 0xB2 0xB1     #Mc       MARCHEN VOWEL SIGN I
+      | 0xF0 0x91 0xB2 0xB4     #Mc       MARCHEN VOWEL SIGN O
+      | 0xF0 0x96 0xBD 0x91..0xBE  #Mc  [46] MIAO SIGN ASPIRATION..MIAO VOWE...
+      | 0xF0 0x9D 0x85 0xA6     #Mc       MUSICAL SYMBOL COMBINING SPRECHGES...
+      | 0xF0 0x9D 0x85 0xAD     #Mc       MUSICAL SYMBOL COMBINING AUGMENTAT...
+      ;
+
+    L = 
+        0xE1 0x84 0x80..0xFF    #Lo  [96] HANGUL CHOSEONG KIYEOK..HANGUL CHO...
+      | 0xE1 0x85 0x00..0x9F    #
+      | 0xEA 0xA5 0xA0..0xBC    #Lo  [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANG...
+      ;
+
+    V = 
+        0xE1 0x85 0xA0..0xFF    #Lo  [72] HANGUL JUNGSEONG FILLER..HANGUL JU...
+      | 0xE1 0x86 0x00..0xA7    #
+      | 0xED 0x9E 0xB0..0xFF    #Lo  [23] HANGUL JUNGSEONG O-YEO..HANGUL JUN...
+      | 0xED 0x9F 0x00..0x86    #
+      ;
+
+    T = 
+        0xE1 0x86 0xA8..0xFF    #Lo  [88] HANGUL JONGSEONG KIYEOK..HANGUL JO...
+      | 0xE1 0x87 0x00..0xBF    #
+      | 0xED 0x9F 0x8B..0xBB    #Lo  [49] HANGUL JONGSEONG NIEUN-RIEUL..HANG...
+      ;
+
+    LV = 
+        0xEA 0xB0 0x80          #Lo       HANGUL SYLLABLE GA
+      | 0xEA 0xB0 0x9C          #Lo       HANGUL SYLLABLE GAE
+      | 0xEA 0xB0 0xB8          #Lo       HANGUL SYLLABLE GYA
+      | 0xEA 0xB1 0x94          #Lo       HANGUL SYLLABLE GYAE
+      | 0xEA 0xB1 0xB0          #Lo       HANGUL SYLLABLE GEO
+      | 0xEA 0xB2 0x8C          #Lo       HANGUL SYLLABLE GE
+      | 0xEA 0xB2 0xA8          #Lo       HANGUL SYLLABLE GYEO
+      | 0xEA 0xB3 0x84          #Lo       HANGUL SYLLABLE GYE
+      | 0xEA 0xB3 0xA0          #Lo       HANGUL SYLLABLE GO
+      | 0xEA 0xB3 0xBC          #Lo       HANGUL SYLLABLE GWA
+      | 0xEA 0xB4 0x98          #Lo       HANGUL SYLLABLE GWAE
+      | 0xEA 0xB4 0xB4          #Lo       HANGUL SYLLABLE GOE
+      | 0xEA 0xB5 0x90          #Lo       HANGUL SYLLABLE GYO
+      | 0xEA 0xB5 0xAC          #Lo       HANGUL SYLLABLE GU
+      | 0xEA 0xB6 0x88          #Lo       HANGUL SYLLABLE GWEO
+      | 0xEA 0xB6 0xA4          #Lo       HANGUL SYLLABLE GWE
+      | 0xEA 0xB7 0x80          #Lo       HANGUL SYLLABLE GWI
+      | 0xEA 0xB7 0x9C          #Lo       HANGUL SYLLABLE GYU
+      | 0xEA 0xB7 0xB8          #Lo       HANGUL SYLLABLE GEU
+      | 0xEA 0xB8 0x94          #Lo       HANGUL SYLLABLE GYI
+      | 0xEA 0xB8 0xB0          #Lo       HANGUL SYLLABLE GI
+      | 0xEA 0xB9 0x8C          #Lo       HANGUL SYLLABLE GGA
+      | 0xEA 0xB9 0xA8          #Lo       HANGUL SYLLABLE GGAE
+      | 0xEA 0xBA 0x84          #Lo       HANGUL SYLLABLE GGYA
+      | 0xEA 0xBA 0xA0          #Lo       HANGUL SYLLABLE GGYAE
+      | 0xEA 0xBA 0xBC          #Lo       HANGUL SYLLABLE GGEO
+      | 0xEA 0xBB 0x98          #Lo       HANGUL SYLLABLE GGE
+      | 0xEA 0xBB 0xB4          #Lo       HANGUL SYLLABLE GGYEO
+      | 0xEA 0xBC 0x90          #Lo       HANGUL SYLLABLE GGYE
+      | 0xEA 0xBC 0xAC          #Lo       HANGUL SYLLABLE GGO
+      | 0xEA 0xBD 0x88          #Lo       HANGUL SYLLABLE GGWA
+      | 0xEA 0xBD 0xA4          #Lo       HANGUL SYLLABLE GGWAE
+      | 0xEA 0xBE 0x80          #Lo       HANGUL SYLLABLE GGOE
+      | 0xEA 0xBE 0x9C          #Lo       HANGUL SYLLABLE GGYO
+      | 0xEA 0xBE 0xB8          #Lo       HANGUL SYLLABLE GGU
+      | 0xEA 0xBF 0x94          #Lo       HANGUL SYLLABLE GGWEO
+      | 0xEA 0xBF 0xB0          #Lo       HANGUL SYLLABLE GGWE
+      | 0xEB 0x80 0x8C          #Lo       HANGUL SYLLABLE GGWI
+      | 0xEB 0x80 0xA8          #Lo       HANGUL SYLLABLE GGYU
+      | 0xEB 0x81 0x84          #Lo       HANGUL SYLLABLE GGEU
+      | 0xEB 0x81 0xA0          #Lo       HANGUL SYLLABLE GGYI
+      | 0xEB 0x81 0xBC          #Lo       HANGUL SYLLABLE GGI
+      | 0xEB 0x82 0x98          #Lo       HANGUL SYLLABLE NA
+      | 0xEB 0x82 0xB4          #Lo       HANGUL SYLLABLE NAE
+      | 0xEB 0x83 0x90          #Lo       HANGUL SYLLABLE NYA
+      | 0xEB 0x83 0xAC          #Lo       HANGUL SYLLABLE NYAE
+      | 0xEB 0x84 0x88          #Lo       HANGUL SYLLABLE NEO
+      | 0xEB 0x84 0xA4          #Lo       HANGUL SYLLABLE NE
+      | 0xEB 0x85 0x80          #Lo       HANGUL SYLLABLE NYEO
+      | 0xEB 0x85 0x9C          #Lo       HANGUL SYLLABLE NYE
+      | 0xEB 0x85 0xB8          #Lo       HANGUL SYLLABLE NO
+      | 0xEB 0x86 0x94          #Lo       HANGUL SYLLABLE NWA
+      | 0xEB 0x86 0xB0          #Lo       HANGUL SYLLABLE NWAE
+      | 0xEB 0x87 0x8C          #Lo       HANGUL SYLLABLE NOE
+      | 0xEB 0x87 0xA8          #Lo       HANGUL SYLLABLE NYO
+      | 0xEB 0x88 0x84          #Lo       HANGUL SYLLABLE NU
+      | 0xEB 0x88 0xA0          #Lo       HANGUL SYLLABLE NWEO
+      | 0xEB 0x88 0xBC          #Lo       HANGUL SYLLABLE NWE
+      | 0xEB 0x89 0x98          #Lo       HANGUL SYLLABLE NWI
+      | 0xEB 0x89 0xB4          #Lo       HANGUL SYLLABLE NYU
+      | 0xEB 0x8A 0x90          #Lo       HANGUL SYLLABLE NEU
+      | 0xEB 0x8A 0xAC          #Lo       HANGUL SYLLABLE NYI
+      | 0xEB 0x8B 0x88          #Lo       HANGUL SYLLABLE NI
+      | 0xEB 0x8B 0xA4          #Lo       HANGUL SYLLABLE DA
+      | 0xEB 0x8C 0x80          #Lo       HANGUL SYLLABLE DAE
+      | 0xEB 0x8C 0x9C          #Lo       HANGUL SYLLABLE DYA
+      | 0xEB 0x8C 0xB8          #Lo       HANGUL SYLLABLE DYAE
+      | 0xEB 0x8D 0x94          #Lo       HANGUL SYLLABLE DEO
+      | 0xEB 0x8D 0xB0          #Lo       HANGUL SYLLABLE DE
+      | 0xEB 0x8E 0x8C          #Lo       HANGUL SYLLABLE DYEO
+      | 0xEB 0x8E 0xA8          #Lo       HANGUL SYLLABLE DYE
+      | 0xEB 0x8F 0x84          #Lo       HANGUL SYLLABLE DO
+      | 0xEB 0x8F 0xA0          #Lo       HANGUL SYLLABLE DWA
+      | 0xEB 0x8F 0xBC          #Lo       HANGUL SYLLABLE DWAE
+      | 0xEB 0x90 0x98          #Lo       HANGUL SYLLABLE DOE
+      | 0xEB 0x90 0xB4          #Lo       HANGUL SYLLABLE DYO
+      | 0xEB 0x91 0x90          #Lo       HANGUL SYLLABLE DU
+      | 0xEB 0x91 0xAC          #Lo       HANGUL SYLLABLE DWEO
+      | 0xEB 0x92 0x88          #Lo       HANGUL SYLLABLE DWE
+      | 0xEB 0x92 0xA4          #Lo       HANGUL SYLLABLE DWI
+      | 0xEB 0x93 0x80          #Lo       HANGUL SYLLABLE DYU
+      | 0xEB 0x93 0x9C          #Lo       HANGUL SYLLABLE DEU
+      | 0xEB 0x93 0xB8          #Lo       HANGUL SYLLABLE DYI
+      | 0xEB 0x94 0x94          #Lo       HANGUL SYLLABLE DI
+      | 0xEB 0x94 0xB0          #Lo       HANGUL SYLLABLE DDA
+      | 0xEB 0x95 0x8C          #Lo       HANGUL SYLLABLE DDAE
+      | 0xEB 0x95 0xA8          #Lo       HANGUL SYLLABLE DDYA
+      | 0xEB 0x96 0x84          #Lo       HANGUL SYLLABLE DDYAE
+      | 0xEB 0x96 0xA0          #Lo       HANGUL SYLLABLE DDEO
+      | 0xEB 0x96 0xBC          #Lo       HANGUL SYLLABLE DDE
+      | 0xEB 0x97 0x98          #Lo       HANGUL SYLLABLE DDYEO
+      | 0xEB 0x97 0xB4          #Lo       HANGUL SYLLABLE DDYE
+      | 0xEB 0x98 0x90          #Lo       HANGUL SYLLABLE DDO
+      | 0xEB 0x98 0xAC          #Lo       HANGUL SYLLABLE DDWA
+      | 0xEB 0x99 0x88          #Lo       HANGUL SYLLABLE DDWAE
+      | 0xEB 0x99 0xA4          #Lo       HANGUL SYLLABLE DDOE
+      | 0xEB 0x9A 0x80          #Lo       HANGUL SYLLABLE DDYO
+      | 0xEB 0x9A 0x9C          #Lo       HANGUL SYLLABLE DDU
+      | 0xEB 0x9A 0xB8          #Lo       HANGUL SYLLABLE DDWEO
+      | 0xEB 0x9B 0x94          #Lo       HANGUL SYLLABLE DDWE
+      | 0xEB 0x9B 0xB0          #Lo       HANGUL SYLLABLE DDWI
+      | 0xEB 0x9C 0x8C          #Lo       HANGUL SYLLABLE DDYU
+      | 0xEB 0x9C 0xA8          #Lo       HANGUL SYLLABLE DDEU
+      | 0xEB 0x9D 0x84          #Lo       HANGUL SYLLABLE DDYI
+      | 0xEB 0x9D 0xA0          #Lo       HANGUL SYLLABLE DDI
+      | 0xEB 0x9D 0xBC          #Lo       HANGUL SYLLABLE RA
+      | 0xEB 0x9E 0x98          #Lo       HANGUL SYLLABLE RAE
+      | 0xEB 0x9E 0xB4          #Lo       HANGUL SYLLABLE RYA
+      | 0xEB 0x9F 0x90          #Lo       HANGUL SYLLABLE RYAE
+      | 0xEB 0x9F 0xAC          #Lo       HANGUL SYLLABLE REO
+      | 0xEB 0xA0 0x88          #Lo       HANGUL SYLLABLE RE
+      | 0xEB 0xA0 0xA4          #Lo       HANGUL SYLLABLE RYEO
+      | 0xEB 0xA1 0x80          #Lo       HANGUL SYLLABLE RYE
+      | 0xEB 0xA1 0x9C          #Lo       HANGUL SYLLABLE RO
+      | 0xEB 0xA1 0xB8          #Lo       HANGUL SYLLABLE RWA
+      | 0xEB 0xA2 0x94          #Lo       HANGUL SYLLABLE RWAE
+      | 0xEB 0xA2 0xB0          #Lo       HANGUL SYLLABLE ROE
+      | 0xEB 0xA3 0x8C          #Lo       HANGUL SYLLABLE RYO
+      | 0xEB 0xA3 0xA8          #Lo       HANGUL SYLLABLE RU
+      | 0xEB 0xA4 0x84          #Lo       HANGUL SYLLABLE RWEO
+      | 0xEB 0xA4 0xA0          #Lo       HANGUL SYLLABLE RWE
+      | 0xEB 0xA4 0xBC          #Lo       HANGUL SYLLABLE RWI
+      | 0xEB 0xA5 0x98          #Lo       HANGUL SYLLABLE RYU
+      | 0xEB 0xA5 0xB4          #Lo       HANGUL SYLLABLE REU
+      | 0xEB 0xA6 0x90          #Lo       HANGUL SYLLABLE RYI
+      | 0xEB 0xA6 0xAC          #Lo       HANGUL SYLLABLE RI
+      | 0xEB 0xA7 0x88          #Lo       HANGUL SYLLABLE MA
+      | 0xEB 0xA7 0xA4          #Lo       HANGUL SYLLABLE MAE
+      | 0xEB 0xA8 0x80          #Lo       HANGUL SYLLABLE MYA
+      | 0xEB 0xA8 0x9C          #Lo       HANGUL SYLLABLE MYAE
+      | 0xEB 0xA8 0xB8          #Lo       HANGUL SYLLABLE MEO
+      | 0xEB 0xA9 0x94          #Lo       HANGUL SYLLABLE ME
+      | 0xEB 0xA9 0xB0          #Lo       HANGUL SYLLABLE MYEO
+      | 0xEB 0xAA 0x8C          #Lo       HANGUL SYLLABLE MYE
+      | 0xEB 0xAA 0xA8          #Lo       HANGUL SYLLABLE MO
+      | 0xEB 0xAB 0x84          #Lo       HANGUL SYLLABLE MWA
+      | 0xEB 0xAB 0xA0          #Lo       HANGUL SYLLABLE MWAE
+      | 0xEB 0xAB 0xBC          #Lo       HANGUL SYLLABLE MOE
+      | 0xEB 0xAC 0x98          #Lo       HANGUL SYLLABLE MYO
+      | 0xEB 0xAC 0xB4          #Lo       HANGUL SYLLABLE MU
+      | 0xEB 0xAD 0x90          #Lo       HANGUL SYLLABLE MWEO
+      | 0xEB 0xAD 0xAC          #Lo       HANGUL SYLLABLE MWE
+      | 0xEB 0xAE 0x88          #Lo       HANGUL SYLLABLE MWI
+      | 0xEB 0xAE 0xA4          #Lo       HANGUL SYLLABLE MYU
+      | 0xEB 0xAF 0x80          #Lo       HANGUL SYLLABLE MEU
+      | 0xEB 0xAF 0x9C          #Lo       HANGUL SYLLABLE MYI
+      | 0xEB 0xAF 0xB8          #Lo       HANGUL SYLLABLE MI
+      | 0xEB 0xB0 0x94          #Lo       HANGUL SYLLABLE BA
+      | 0xEB 0xB0 0xB0          #Lo       HANGUL SYLLABLE BAE
+      | 0xEB 0xB1 0x8C          #Lo       HANGUL SYLLABLE BYA
+      | 0xEB 0xB1 0xA8          #Lo       HANGUL SYLLABLE BYAE
+      | 0xEB 0xB2 0x84          #Lo       HANGUL SYLLABLE BEO
+      | 0xEB 0xB2 0xA0          #Lo       HANGUL SYLLABLE BE
+      | 0xEB 0xB2 0xBC          #Lo       HANGUL SYLLABLE BYEO
+      | 0xEB 0xB3 0x98          #Lo       HANGUL SYLLABLE BYE
+      | 0xEB 0xB3 0xB4          #Lo       HANGUL SYLLABLE BO
+      | 0xEB 0xB4 0x90          #Lo       HANGUL SYLLABLE BWA
+      | 0xEB 0xB4 0xAC          #Lo       HANGUL SYLLABLE BWAE
+      | 0xEB 0xB5 0x88          #Lo       HANGUL SYLLABLE BOE
+      | 0xEB 0xB5 0xA4          #Lo       HANGUL SYLLABLE BYO
+      | 0xEB 0xB6 0x80          #Lo       HANGUL SYLLABLE BU
+      | 0xEB 0xB6 0x9C          #Lo       HANGUL SYLLABLE BWEO
+      | 0xEB 0xB6 0xB8          #Lo       HANGUL SYLLABLE BWE
+      | 0xEB 0xB7 0x94          #Lo       HANGUL SYLLABLE BWI
+      | 0xEB 0xB7 0xB0          #Lo       HANGUL SYLLABLE BYU
+      | 0xEB 0xB8 0x8C          #Lo       HANGUL SYLLABLE BEU
+      | 0xEB 0xB8 0xA8          #Lo       HANGUL SYLLABLE BYI
+      | 0xEB 0xB9 0x84          #Lo       HANGUL SYLLABLE BI
+      | 0xEB 0xB9 0xA0          #Lo       HANGUL SYLLABLE BBA
+      | 0xEB 0xB9 0xBC          #Lo       HANGUL SYLLABLE BBAE
+      | 0xEB 0xBA 0x98          #Lo       HANGUL SYLLABLE BBYA
+      | 0xEB 0xBA 0xB4          #Lo       HANGUL SYLLABLE BBYAE
+      | 0xEB 0xBB 0x90          #Lo       HANGUL SYLLABLE BBEO
+      | 0xEB 0xBB 0xAC          #Lo       HANGUL SYLLABLE BBE
+      | 0xEB 0xBC 0x88          #Lo       HANGUL SYLLABLE BBYEO
+      | 0xEB 0xBC 0xA4          #Lo       HANGUL SYLLABLE BBYE
+      | 0xEB 0xBD 0x80          #Lo       HANGUL SYLLABLE BBO
+      | 0xEB 0xBD 0x9C          #Lo       HANGUL SYLLABLE BBWA
+      | 0xEB 0xBD 0xB8          #Lo       HANGUL SYLLABLE BBWAE
+      | 0xEB 0xBE 0x94          #Lo       HANGUL SYLLABLE BBOE
+      | 0xEB 0xBE 0xB0          #Lo       HANGUL SYLLABLE BBYO
+      | 0xEB 0xBF 0x8C          #Lo       HANGUL SYLLABLE BBU
+      | 0xEB 0xBF 0xA8          #Lo       HANGUL SYLLABLE BBWEO
+      | 0xEC 0x80 0x84          #Lo       HANGUL SYLLABLE BBWE
+      | 0xEC 0x80 0xA0          #Lo       HANGUL SYLLABLE BBWI
+      | 0xEC 0x80 0xBC          #Lo       HANGUL SYLLABLE BBYU
+      | 0xEC 0x81 0x98          #Lo       HANGUL SYLLABLE BBEU
+      | 0xEC 0x81 0xB4          #Lo       HANGUL SYLLABLE BBYI
+      | 0xEC 0x82 0x90          #Lo       HANGUL SYLLABLE BBI
+      | 0xEC 0x82 0xAC          #Lo       HANGUL SYLLABLE SA
+      | 0xEC 0x83 0x88          #Lo       HANGUL SYLLABLE SAE
+      | 0xEC 0x83 0xA4          #Lo       HANGUL SYLLABLE SYA
+      | 0xEC 0x84 0x80          #Lo       HANGUL SYLLABLE SYAE
+      | 0xEC 0x84 0x9C          #Lo       HANGUL SYLLABLE SEO
+      | 0xEC 0x84 0xB8          #Lo       HANGUL SYLLABLE SE
+      | 0xEC 0x85 0x94          #Lo       HANGUL SYLLABLE SYEO
+      | 0xEC 0x85 0xB0          #Lo       HANGUL SYLLABLE SYE
+      | 0xEC 0x86 0x8C          #Lo       HANGUL SYLLABLE SO
+      | 0xEC 0x86 0xA8          #Lo       HANGUL SYLLABLE SWA
+      | 0xEC 0x87 0x84          #Lo       HANGUL SYLLABLE SWAE
+      | 0xEC 0x87 0xA0          #Lo       HANGUL SYLLABLE SOE
+      | 0xEC 0x87 0xBC          #Lo       HANGUL SYLLABLE SYO
+      | 0xEC 0x88 0x98          #Lo       HANGUL SYLLABLE SU
+      | 0xEC 0x88 0xB4          #Lo       HANGUL SYLLABLE SWEO
+      | 0xEC 0x89 0x90          #Lo       HANGUL SYLLABLE SWE
+      | 0xEC 0x89 0xAC          #Lo       HANGUL SYLLABLE SWI
+      | 0xEC 0x8A 0x88          #Lo       HANGUL SYLLABLE SYU
+      | 0xEC 0x8A 0xA4          #Lo       HANGUL SYLLABLE SEU
+      | 0xEC 0x8B 0x80          #Lo       HANGUL SYLLABLE SYI
+      | 0xEC 0x8B 0x9C          #Lo       HANGUL SYLLABLE SI
+      | 0xEC 0x8B 0xB8          #Lo       HANGUL SYLLABLE SSA
+      | 0xEC 0x8C 0x94          #Lo       HANGUL SYLLABLE SSAE
+      | 0xEC 0x8C 0xB0          #Lo       HANGUL SYLLABLE SSYA
+      | 0xEC 0x8D 0x8C          #Lo       HANGUL SYLLABLE SSYAE
+      | 0xEC 0x8D 0xA8          #Lo       HANGUL SYLLABLE SSEO
+      | 0xEC 0x8E 0x84          #Lo       HANGUL SYLLABLE SSE
+      | 0xEC 0x8E 0xA0          #Lo       HANGUL SYLLABLE SSYEO
+      | 0xEC 0x8E 0xBC          #Lo       HANGUL SYLLABLE SSYE
+      | 0xEC 0x8F 0x98          #Lo       HANGUL SYLLABLE SSO
+      | 0xEC 0x8F 0xB4          #Lo       HANGUL SYLLABLE SSWA
+      | 0xEC 0x90 0x90          #Lo       HANGUL SYLLABLE SSWAE
+      | 0xEC 0x90 0xAC          #Lo       HANGUL SYLLABLE SSOE
+      | 0xEC 0x91 0x88          #Lo       HANGUL SYLLABLE SSYO
+      | 0xEC 0x91 0xA4          #Lo       HANGUL SYLLABLE SSU
+      | 0xEC 0x92 0x80          #Lo       HANGUL SYLLABLE SSWEO
+      | 0xEC 0x92 0x9C          #Lo       HANGUL SYLLABLE SSWE
+      | 0xEC 0x92 0xB8          #Lo       HANGUL SYLLABLE SSWI
+      | 0xEC 0x93 0x94          #Lo       HANGUL SYLLABLE SSYU
+      | 0xEC 0x93 0xB0          #Lo       HANGUL SYLLABLE SSEU
+      | 0xEC 0x94 0x8C          #Lo       HANGUL SYLLABLE SSYI
+      | 0xEC 0x94 0xA8          #Lo       HANGUL SYLLABLE SSI
+      | 0xEC 0x95 0x84          #Lo       HANGUL SYLLABLE A
+      | 0xEC 0x95 0xA0          #Lo       HANGUL SYLLABLE AE
+      | 0xEC 0x95 0xBC          #Lo       HANGUL SYLLABLE YA
+      | 0xEC 0x96 0x98          #Lo       HANGUL SYLLABLE YAE
+      | 0xEC 0x96 0xB4          #Lo       HANGUL SYLLABLE EO
+      | 0xEC 0x97 0x90          #Lo       HANGUL SYLLABLE E
+      | 0xEC 0x97 0xAC          #Lo       HANGUL SYLLABLE YEO
+      | 0xEC 0x98 0x88          #Lo       HANGUL SYLLABLE YE
+      | 0xEC 0x98 0xA4          #Lo       HANGUL SYLLABLE O
+      | 0xEC 0x99 0x80          #Lo       HANGUL SYLLABLE WA
+      | 0xEC 0x99 0x9C          #Lo       HANGUL SYLLABLE WAE
+      | 0xEC 0x99 0xB8          #Lo       HANGUL SYLLABLE OE
+      | 0xEC 0x9A 0x94          #Lo       HANGUL SYLLABLE YO
+      | 0xEC 0x9A 0xB0          #Lo       HANGUL SYLLABLE U
+      | 0xEC 0x9B 0x8C          #Lo       HANGUL SYLLABLE WEO
+      | 0xEC 0x9B 0xA8          #Lo       HANGUL SYLLABLE WE
+      | 0xEC 0x9C 0x84          #Lo       HANGUL SYLLABLE WI
+      | 0xEC 0x9C 0xA0          #Lo       HANGUL SYLLABLE YU
+      | 0xEC 0x9C 0xBC          #Lo       HANGUL SYLLABLE EU
+      | 0xEC 0x9D 0x98          #Lo       HANGUL SYLLABLE YI
+      | 0xEC 0x9D 0xB4          #Lo       HANGUL SYLLABLE I
+      | 0xEC 0x9E 0x90          #Lo       HANGUL SYLLABLE JA
+      | 0xEC 0x9E 0xAC          #Lo       HANGUL SYLLABLE JAE
+      | 0xEC 0x9F 0x88          #Lo       HANGUL SYLLABLE JYA
+      | 0xEC 0x9F 0xA4          #Lo       HANGUL SYLLABLE JYAE
+      | 0xEC 0xA0 0x80          #Lo       HANGUL SYLLABLE JEO
+      | 0xEC 0xA0 0x9C          #Lo       HANGUL SYLLABLE JE
+      | 0xEC 0xA0 0xB8          #Lo       HANGUL SYLLABLE JYEO
+      | 0xEC 0xA1 0x94          #Lo       HANGUL SYLLABLE JYE
+      | 0xEC 0xA1 0xB0          #Lo       HANGUL SYLLABLE JO
+      | 0xEC 0xA2 0x8C          #Lo       HANGUL SYLLABLE JWA
+      | 0xEC 0xA2 0xA8          #Lo       HANGUL SYLLABLE JWAE
+      | 0xEC 0xA3 0x84          #Lo       HANGUL SYLLABLE JOE
+      | 0xEC 0xA3 0xA0          #Lo       HANGUL SYLLABLE JYO
+      | 0xEC 0xA3 0xBC          #Lo       HANGUL SYLLABLE JU
+      | 0xEC 0xA4 0x98          #Lo       HANGUL SYLLABLE JWEO
+      | 0xEC 0xA4 0xB4          #Lo       HANGUL SYLLABLE JWE
+      | 0xEC 0xA5 0x90          #Lo       HANGUL SYLLABLE JWI
+      | 0xEC 0xA5 0xAC          #Lo       HANGUL SYLLABLE JYU
+      | 0xEC 0xA6 0x88          #Lo       HANGUL SYLLABLE JEU
+      | 0xEC 0xA6 0xA4          #Lo       HANGUL SYLLABLE JYI
+      | 0xEC 0xA7 0x80          #Lo       HANGUL SYLLABLE JI
+      | 0xEC 0xA7 0x9C          #Lo       HANGUL SYLLABLE JJA
+      | 0xEC 0xA7 0xB8          #Lo       HANGUL SYLLABLE JJAE
+      | 0xEC 0xA8 0x94          #Lo       HANGUL SYLLABLE JJYA
+      | 0xEC 0xA8 0xB0          #Lo       HANGUL SYLLABLE JJYAE
+      | 0xEC 0xA9 0x8C          #Lo       HANGUL SYLLABLE JJEO
+      | 0xEC 0xA9 0xA8          #Lo       HANGUL SYLLABLE JJE
+      | 0xEC 0xAA 0x84          #Lo       HANGUL SYLLABLE JJYEO
+      | 0xEC 0xAA 0xA0          #Lo       HANGUL SYLLABLE JJYE
+      | 0xEC 0xAA 0xBC          #Lo       HANGUL SYLLABLE JJO
+      | 0xEC 0xAB 0x98          #Lo       HANGUL SYLLABLE JJWA
+      | 0xEC 0xAB 0xB4          #Lo       HANGUL SYLLABLE JJWAE
+      | 0xEC 0xAC 0x90          #Lo       HANGUL SYLLABLE JJOE
+      | 0xEC 0xAC 0xAC          #Lo       HANGUL SYLLABLE JJYO
+      | 0xEC 0xAD 0x88          #Lo       HANGUL SYLLABLE JJU
+      | 0xEC 0xAD 0xA4          #Lo       HANGUL SYLLABLE JJWEO
+      | 0xEC 0xAE 0x80          #Lo       HANGUL SYLLABLE JJWE
+      | 0xEC 0xAE 0x9C          #Lo       HANGUL SYLLABLE JJWI
+      | 0xEC 0xAE 0xB8          #Lo       HANGUL SYLLABLE JJYU
+      | 0xEC 0xAF 0x94          #Lo       HANGUL SYLLABLE JJEU
+      | 0xEC 0xAF 0xB0          #Lo       HANGUL SYLLABLE JJYI
+      | 0xEC 0xB0 0x8C          #Lo       HANGUL SYLLABLE JJI
+      | 0xEC 0xB0 0xA8          #Lo       HANGUL SYLLABLE CA
+      | 0xEC 0xB1 0x84          #Lo       HANGUL SYLLABLE CAE
+      | 0xEC 0xB1 0xA0          #Lo       HANGUL SYLLABLE CYA
+      | 0xEC 0xB1 0xBC          #Lo       HANGUL SYLLABLE CYAE
+      | 0xEC 0xB2 0x98          #Lo       HANGUL SYLLABLE CEO
+      | 0xEC 0xB2 0xB4          #Lo       HANGUL SYLLABLE CE
+      | 0xEC 0xB3 0x90          #Lo       HANGUL SYLLABLE CYEO
+      | 0xEC 0xB3 0xAC          #Lo       HANGUL SYLLABLE CYE
+      | 0xEC 0xB4 0x88          #Lo       HANGUL SYLLABLE CO
+      | 0xEC 0xB4 0xA4          #Lo       HANGUL SYLLABLE CWA
+      | 0xEC 0xB5 0x80          #Lo       HANGUL SYLLABLE CWAE
+      | 0xEC 0xB5 0x9C          #Lo       HANGUL SYLLABLE COE
+      | 0xEC 0xB5 0xB8          #Lo       HANGUL SYLLABLE CYO
+      | 0xEC 0xB6 0x94          #Lo       HANGUL SYLLABLE CU
+      | 0xEC 0xB6 0xB0          #Lo       HANGUL SYLLABLE CWEO
+      | 0xEC 0xB7 0x8C          #Lo       HANGUL SYLLABLE CWE
+      | 0xEC 0xB7 0xA8          #Lo       HANGUL SYLLABLE CWI
+      | 0xEC 0xB8 0x84          #Lo       HANGUL SYLLABLE CYU
+      | 0xEC 0xB8 0xA0          #Lo       HANGUL SYLLABLE CEU
+      | 0xEC 0xB8 0xBC          #Lo       HANGUL SYLLABLE CYI
+      | 0xEC 0xB9 0x98          #Lo       HANGUL SYLLABLE CI
+      | 0xEC 0xB9 0xB4          #Lo       HANGUL SYLLABLE KA
+      | 0xEC 0xBA 0x90          #Lo       HANGUL SYLLABLE KAE
+      | 0xEC 0xBA 0xAC          #Lo       HANGUL SYLLABLE KYA
+      | 0xEC 0xBB 0x88          #Lo       HANGUL SYLLABLE KYAE
+      | 0xEC 0xBB 0xA4          #Lo       HANGUL SYLLABLE KEO
+      | 0xEC 0xBC 0x80          #Lo       HANGUL SYLLABLE KE
+      | 0xEC 0xBC 0x9C          #Lo       HANGUL SYLLABLE KYEO
+      | 0xEC 0xBC 0xB8          #Lo       HANGUL SYLLABLE KYE
+      | 0xEC 0xBD 0x94          #Lo       HANGUL SYLLABLE KO
+      | 0xEC 0xBD 0xB0          #Lo       HANGUL SYLLABLE KWA
+      | 0xEC 0xBE 0x8C          #Lo       HANGUL SYLLABLE KWAE
+      | 0xEC 0xBE 0xA8          #Lo       HANGUL SYLLABLE KOE
+      | 0xEC 0xBF 0x84          #Lo       HANGUL SYLLABLE KYO
+      | 0xEC 0xBF 0xA0          #Lo       HANGUL SYLLABLE KU
+      | 0xEC 0xBF 0xBC          #Lo       HANGUL SYLLABLE KWEO
+      | 0xED 0x80 0x98          #Lo       HANGUL SYLLABLE KWE
+      | 0xED 0x80 0xB4          #Lo       HANGUL SYLLABLE KWI
+      | 0xED 0x81 0x90          #Lo       HANGUL SYLLABLE KYU
+      | 0xED 0x81 0xAC          #Lo       HANGUL SYLLABLE KEU
+      | 0xED 0x82 0x88          #Lo       HANGUL SYLLABLE KYI
+      | 0xED 0x82 0xA4          #Lo       HANGUL SYLLABLE KI
+      | 0xED 0x83 0x80          #Lo       HANGUL SYLLABLE TA
+      | 0xED 0x83 0x9C          #Lo       HANGUL SYLLABLE TAE
+      | 0xED 0x83 0xB8          #Lo       HANGUL SYLLABLE TYA
+      | 0xED 0x84 0x94          #Lo       HANGUL SYLLABLE TYAE
+      | 0xED 0x84 0xB0          #Lo       HANGUL SYLLABLE TEO
+      | 0xED 0x85 0x8C          #Lo       HANGUL SYLLABLE TE
+      | 0xED 0x85 0xA8          #Lo       HANGUL SYLLABLE TYEO
+      | 0xED 0x86 0x84          #Lo       HANGUL SYLLABLE TYE
+      | 0xED 0x86 0xA0          #Lo       HANGUL SYLLABLE TO
+      | 0xED 0x86 0xBC          #Lo       HANGUL SYLLABLE TWA
+      | 0xED 0x87 0x98          #Lo       HANGUL SYLLABLE TWAE
+      | 0xED 0x87 0xB4          #Lo       HANGUL SYLLABLE TOE
+      | 0xED 0x88 0x90          #Lo       HANGUL SYLLABLE TYO
+      | 0xED 0x88 0xAC          #Lo       HANGUL SYLLABLE TU
+      | 0xED 0x89 0x88          #Lo       HANGUL SYLLABLE TWEO
+      | 0xED 0x89 0xA4          #Lo       HANGUL SYLLABLE TWE
+      | 0xED 0x8A 0x80          #Lo       HANGUL SYLLABLE TWI
+      | 0xED 0x8A 0x9C          #Lo       HANGUL SYLLABLE TYU
+      | 0xED 0x8A 0xB8          #Lo       HANGUL SYLLABLE TEU
+      | 0xED 0x8B 0x94          #Lo       HANGUL SYLLABLE TYI
+      | 0xED 0x8B 0xB0          #Lo       HANGUL SYLLABLE TI
+      | 0xED 0x8C 0x8C          #Lo       HANGUL SYLLABLE PA
+      | 0xED 0x8C 0xA8          #Lo       HANGUL SYLLABLE PAE
+      | 0xED 0x8D 0x84          #Lo       HANGUL SYLLABLE PYA
+      | 0xED 0x8D 0xA0          #Lo       HANGUL SYLLABLE PYAE
+      | 0xED 0x8D 0xBC          #Lo       HANGUL SYLLABLE PEO
+      | 0xED 0x8E 0x98          #Lo       HANGUL SYLLABLE PE
+      | 0xED 0x8E 0xB4          #Lo       HANGUL SYLLABLE PYEO
+      | 0xED 0x8F 0x90          #Lo       HANGUL SYLLABLE PYE
+      | 0xED 0x8F 0xAC          #Lo       HANGUL SYLLABLE PO
+      | 0xED 0x90 0x88          #Lo       HANGUL SYLLABLE PWA
+      | 0xED 0x90 0xA4          #Lo       HANGUL SYLLABLE PWAE
+      | 0xED 0x91 0x80          #Lo       HANGUL SYLLABLE POE
+      | 0xED 0x91 0x9C          #Lo       HANGUL SYLLABLE PYO
+      | 0xED 0x91 0xB8          #Lo       HANGUL SYLLABLE PU
+      | 0xED 0x92 0x94          #Lo       HANGUL SYLLABLE PWEO
+      | 0xED 0x92 0xB0          #Lo       HANGUL SYLLABLE PWE
+      | 0xED 0x93 0x8C          #Lo       HANGUL SYLLABLE PWI
+      | 0xED 0x93 0xA8          #Lo       HANGUL SYLLABLE PYU
+      | 0xED 0x94 0x84          #Lo       HANGUL SYLLABLE PEU
+      | 0xED 0x94 0xA0          #Lo       HANGUL SYLLABLE PYI
+      | 0xED 0x94 0xBC          #Lo       HANGUL SYLLABLE PI
+      | 0xED 0x95 0x98          #Lo       HANGUL SYLLABLE HA
+      | 0xED 0x95 0xB4          #Lo       HANGUL SYLLABLE HAE
+      | 0xED 0x96 0x90          #Lo       HANGUL SYLLABLE HYA
+      | 0xED 0x96 0xAC          #Lo       HANGUL SYLLABLE HYAE
+      | 0xED 0x97 0x88          #Lo       HANGUL SYLLABLE HEO
+      | 0xED 0x97 0xA4          #Lo       HANGUL SYLLABLE HE
+      | 0xED 0x98 0x80          #Lo       HANGUL SYLLABLE HYEO
+      | 0xED 0x98 0x9C          #Lo       HANGUL SYLLABLE HYE
+      | 0xED 0x98 0xB8          #Lo       HANGUL SYLLABLE HO
+      | 0xED 0x99 0x94          #Lo       HANGUL SYLLABLE HWA
+      | 0xED 0x99 0xB0          #Lo       HANGUL SYLLABLE HWAE
+      | 0xED 0x9A 0x8C          #Lo       HANGUL SYLLABLE HOE
+      | 0xED 0x9A 0xA8          #Lo       HANGUL SYLLABLE HYO
+      | 0xED 0x9B 0x84          #Lo       HANGUL SYLLABLE HU
+      | 0xED 0x9B 0xA0          #Lo       HANGUL SYLLABLE HWEO
+      | 0xED 0x9B 0xBC          #Lo       HANGUL SYLLABLE HWE
+      | 0xED 0x9C 0x98          #Lo       HANGUL SYLLABLE HWI
+      | 0xED 0x9C 0xB4          #Lo       HANGUL SYLLABLE HYU
+      | 0xED 0x9D 0x90          #Lo       HANGUL SYLLABLE HEU
+      | 0xED 0x9D 0xAC          #Lo       HANGUL SYLLABLE HYI
+      | 0xED 0x9E 0x88          #Lo       HANGUL SYLLABLE HI
+      ;
+
+    LVT = 
+        0xEA 0xB0 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE GAG..HANGUL SYLLAB...
+      | 0xEA 0xB0 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE GAEG..HANGUL SYLLA...
+      | 0xEA 0xB0 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE GYAG..HANGUL SYLLA...
+      | 0xEA 0xB1 0x00..0x93    #
+      | 0xEA 0xB1 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE GYAEG..HANGUL SYLL...
+      | 0xEA 0xB1 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE GEOG..HANGUL SYLLA...
+      | 0xEA 0xB2 0x00..0x8B    #
+      | 0xEA 0xB2 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE GEG..HANGUL SYLLAB...
+      | 0xEA 0xB2 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE GYEOG..HANGUL SYLL...
+      | 0xEA 0xB3 0x00..0x83    #
+      | 0xEA 0xB3 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE GYEG..HANGUL SYLLA...
+      | 0xEA 0xB3 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE GOG..HANGUL SYLLAB...
+      | 0xEA 0xB3 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE GWAG..HANGUL SYLLA...
+      | 0xEA 0xB4 0x00..0x97    #
+      | 0xEA 0xB4 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE GWAEG..HANGUL SYLL...
+      | 0xEA 0xB4 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE GOEG..HANGUL SYLLA...
+      | 0xEA 0xB5 0x00..0x8F    #
+      | 0xEA 0xB5 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE GYOG..HANGUL SYLLA...
+      | 0xEA 0xB5 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE GUG..HANGUL SYLLAB...
+      | 0xEA 0xB6 0x00..0x87    #
+      | 0xEA 0xB6 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE GWEOG..HANGUL SYLL...
+      | 0xEA 0xB6 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE GWEG..HANGUL SYLLA...
+      | 0xEA 0xB7 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE GWIG..HANGUL SYLLA...
+      | 0xEA 0xB7 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE GYUG..HANGUL SYLLA...
+      | 0xEA 0xB7 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE GEUG..HANGUL SYLLA...
+      | 0xEA 0xB8 0x00..0x93    #
+      | 0xEA 0xB8 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE GYIG..HANGUL SYLLA...
+      | 0xEA 0xB8 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE GIG..HANGUL SYLLAB...
+      | 0xEA 0xB9 0x00..0x8B    #
+      | 0xEA 0xB9 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE GGAG..HANGUL SYLLA...
+      | 0xEA 0xB9 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE GGAEG..HANGUL SYLL...
+      | 0xEA 0xBA 0x00..0x83    #
+      | 0xEA 0xBA 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE GGYAG..HANGUL SYLL...
+      | 0xEA 0xBA 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE GGYAEG..HANGUL SYL...
+      | 0xEA 0xBA 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE GGEOG..HANGUL SYLL...
+      | 0xEA 0xBB 0x00..0x97    #
+      | 0xEA 0xBB 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE GGEG..HANGUL SYLLA...
+      | 0xEA 0xBB 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE GGYEOG..HANGUL SYL...
+      | 0xEA 0xBC 0x00..0x8F    #
+      | 0xEA 0xBC 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE GGYEG..HANGUL SYLL...
+      | 0xEA 0xBC 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE GGOG..HANGUL SYLLA...
+      | 0xEA 0xBD 0x00..0x87    #
+      | 0xEA 0xBD 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE GGWAG..HANGUL SYLL...
+      | 0xEA 0xBD 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE GGWAEG..HANGUL SYL...
+      | 0xEA 0xBE 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE GGOEG..HANGUL SYLL...
+      | 0xEA 0xBE 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE GGYOG..HANGUL SYLL...
+      | 0xEA 0xBE 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE GGUG..HANGUL SYLLA...
+      | 0xEA 0xBF 0x00..0x93    #
+      | 0xEA 0xBF 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE GGWEOG..HANGUL SYL...
+      | 0xEA 0xBF 0xB1..0xFF        #Lo  [27] HANGUL SYLLABLE GGWEG..HANGUL ...
+      | 0xEA 0xC0..0xFF 0x00..0xFF  #
+      | 0xEB 0x00 0x00..0xFF        #
+      | 0xEB 0x01..0x7F 0x00..0xFF  #
+      | 0xEB 0x80 0x00..0x8B        #
+      | 0xEB 0x80 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE GGWIG..HANGUL SYLL...
+      | 0xEB 0x80 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE GGYUG..HANGUL SYLL...
+      | 0xEB 0x81 0x00..0x83    #
+      | 0xEB 0x81 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE GGEUG..HANGUL SYLL...
+      | 0xEB 0x81 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE GGYIG..HANGUL SYLL...
+      | 0xEB 0x81 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE GGIG..HANGUL SYLLA...
+      | 0xEB 0x82 0x00..0x97    #
+      | 0xEB 0x82 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE NAG..HANGUL SYLLAB...
+      | 0xEB 0x82 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE NAEG..HANGUL SYLLA...
+      | 0xEB 0x83 0x00..0x8F    #
+      | 0xEB 0x83 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE NYAG..HANGUL SYLLA...
+      | 0xEB 0x83 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE NYAEG..HANGUL SYLL...
+      | 0xEB 0x84 0x00..0x87    #
+      | 0xEB 0x84 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE NEOG..HANGUL SYLLA...
+      | 0xEB 0x84 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE NEG..HANGUL SYLLAB...
+      | 0xEB 0x85 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE NYEOG..HANGUL SYLL...
+      | 0xEB 0x85 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE NYEG..HANGUL SYLLA...
+      | 0xEB 0x85 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE NOG..HANGUL SYLLAB...
+      | 0xEB 0x86 0x00..0x93    #
+      | 0xEB 0x86 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE NWAG..HANGUL SYLLA...
+      | 0xEB 0x86 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE NWAEG..HANGUL SYLL...
+      | 0xEB 0x87 0x00..0x8B    #
+      | 0xEB 0x87 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE NOEG..HANGUL SYLLA...
+      | 0xEB 0x87 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE NYOG..HANGUL SYLLA...
+      | 0xEB 0x88 0x00..0x83    #
+      | 0xEB 0x88 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE NUG..HANGUL SYLLAB...
+      | 0xEB 0x88 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE NWEOG..HANGUL SYLL...
+      | 0xEB 0x88 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE NWEG..HANGUL SYLLA...
+      | 0xEB 0x89 0x00..0x97    #
+      | 0xEB 0x89 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE NWIG..HANGUL SYLLA...
+      | 0xEB 0x89 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE NYUG..HANGUL SYLLA...
+      | 0xEB 0x8A 0x00..0x8F    #
+      | 0xEB 0x8A 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE NEUG..HANGUL SYLLA...
+      | 0xEB 0x8A 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE NYIG..HANGUL SYLLA...
+      | 0xEB 0x8B 0x00..0x87    #
+      | 0xEB 0x8B 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE NIG..HANGUL SYLLAB...
+      | 0xEB 0x8B 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE DAG..HANGUL SYLLAB...
+      | 0xEB 0x8C 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE DAEG..HANGUL SYLLA...
+      | 0xEB 0x8C 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE DYAG..HANGUL SYLLA...
+      | 0xEB 0x8C 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE DYAEG..HANGUL SYLL...
+      | 0xEB 0x8D 0x00..0x93    #
+      | 0xEB 0x8D 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE DEOG..HANGUL SYLLA...
+      | 0xEB 0x8D 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE DEG..HANGUL SYLLAB...
+      | 0xEB 0x8E 0x00..0x8B    #
+      | 0xEB 0x8E 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE DYEOG..HANGUL SYLL...
+      | 0xEB 0x8E 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE DYEG..HANGUL SYLLA...
+      | 0xEB 0x8F 0x00..0x83    #
+      | 0xEB 0x8F 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE DOG..HANGUL SYLLAB...
+      | 0xEB 0x8F 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE DWAG..HANGUL SYLLA...
+      | 0xEB 0x8F 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE DWAEG..HANGUL SYLL...
+      | 0xEB 0x90 0x00..0x97    #
+      | 0xEB 0x90 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE DOEG..HANGUL SYLLA...
+      | 0xEB 0x90 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE DYOG..HANGUL SYLLA...
+      | 0xEB 0x91 0x00..0x8F    #
+      | 0xEB 0x91 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE DUG..HANGUL SYLLAB...
+      | 0xEB 0x91 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE DWEOG..HANGUL SYLL...
+      | 0xEB 0x92 0x00..0x87    #
+      | 0xEB 0x92 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE DWEG..HANGUL SYLLA...
+      | 0xEB 0x92 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE DWIG..HANGUL SYLLA...
+      | 0xEB 0x93 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE DYUG..HANGUL SYLLA...
+      | 0xEB 0x93 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE DEUG..HANGUL SYLLA...
+      | 0xEB 0x93 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE DYIG..HANGUL SYLLA...
+      | 0xEB 0x94 0x00..0x93    #
+      | 0xEB 0x94 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE DIG..HANGUL SYLLAB...
+      | 0xEB 0x94 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE DDAG..HANGUL SYLLA...
+      | 0xEB 0x95 0x00..0x8B    #
+      | 0xEB 0x95 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE DDAEG..HANGUL SYLL...
+      | 0xEB 0x95 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE DDYAG..HANGUL SYLL...
+      | 0xEB 0x96 0x00..0x83    #
+      | 0xEB 0x96 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE DDYAEG..HANGUL SYL...
+      | 0xEB 0x96 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE DDEOG..HANGUL SYLL...
+      | 0xEB 0x96 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE DDEG..HANGUL SYLLA...
+      | 0xEB 0x97 0x00..0x97    #
+      | 0xEB 0x97 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE DDYEOG..HANGUL SYL...
+      | 0xEB 0x97 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE DDYEG..HANGUL SYLL...
+      | 0xEB 0x98 0x00..0x8F    #
+      | 0xEB 0x98 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE DDOG..HANGUL SYLLA...
+      | 0xEB 0x98 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE DDWAG..HANGUL SYLL...
+      | 0xEB 0x99 0x00..0x87    #
+      | 0xEB 0x99 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE DDWAEG..HANGUL SYL...
+      | 0xEB 0x99 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE DDOEG..HANGUL SYLL...
+      | 0xEB 0x9A 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE DDYOG..HANGUL SYLL...
+      | 0xEB 0x9A 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE DDUG..HANGUL SYLLA...
+      | 0xEB 0x9A 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE DDWEOG..HANGUL SYL...
+      | 0xEB 0x9B 0x00..0x93    #
+      | 0xEB 0x9B 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE DDWEG..HANGUL SYLL...
+      | 0xEB 0x9B 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE DDWIG..HANGUL SYLL...
+      | 0xEB 0x9C 0x00..0x8B    #
+      | 0xEB 0x9C 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE DDYUG..HANGUL SYLL...
+      | 0xEB 0x9C 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE DDEUG..HANGUL SYLL...
+      | 0xEB 0x9D 0x00..0x83    #
+      | 0xEB 0x9D 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE DDYIG..HANGUL SYLL...
+      | 0xEB 0x9D 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE DDIG..HANGUL SYLLA...
+      | 0xEB 0x9D 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE RAG..HANGUL SYLLAB...
+      | 0xEB 0x9E 0x00..0x97    #
+      | 0xEB 0x9E 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE RAEG..HANGUL SYLLA...
+      | 0xEB 0x9E 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE RYAG..HANGUL SYLLA...
+      | 0xEB 0x9F 0x00..0x8F    #
+      | 0xEB 0x9F 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE RYAEG..HANGUL SYLL...
+      | 0xEB 0x9F 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE REOG..HANGUL SYLLA...
+      | 0xEB 0xA0 0x00..0x87    #
+      | 0xEB 0xA0 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE REG..HANGUL SYLLAB...
+      | 0xEB 0xA0 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE RYEOG..HANGUL SYLL...
+      | 0xEB 0xA1 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE RYEG..HANGUL SYLLA...
+      | 0xEB 0xA1 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE ROG..HANGUL SYLLAB...
+      | 0xEB 0xA1 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE RWAG..HANGUL SYLLA...
+      | 0xEB 0xA2 0x00..0x93    #
+      | 0xEB 0xA2 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE RWAEG..HANGUL SYLL...
+      | 0xEB 0xA2 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE ROEG..HANGUL SYLLA...
+      | 0xEB 0xA3 0x00..0x8B    #
+      | 0xEB 0xA3 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE RYOG..HANGUL SYLLA...
+      | 0xEB 0xA3 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE RUG..HANGUL SYLLAB...
+      | 0xEB 0xA4 0x00..0x83    #
+      | 0xEB 0xA4 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE RWEOG..HANGUL SYLL...
+      | 0xEB 0xA4 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE RWEG..HANGUL SYLLA...
+      | 0xEB 0xA4 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE RWIG..HANGUL SYLLA...
+      | 0xEB 0xA5 0x00..0x97    #
+      | 0xEB 0xA5 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE RYUG..HANGUL SYLLA...
+      | 0xEB 0xA5 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE REUG..HANGUL SYLLA...
+      | 0xEB 0xA6 0x00..0x8F    #
+      | 0xEB 0xA6 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE RYIG..HANGUL SYLLA...
+      | 0xEB 0xA6 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE RIG..HANGUL SYLLAB...
+      | 0xEB 0xA7 0x00..0x87    #
+      | 0xEB 0xA7 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE MAG..HANGUL SYLLAB...
+      | 0xEB 0xA7 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE MAEG..HANGUL SYLLA...
+      | 0xEB 0xA8 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE MYAG..HANGUL SYLLA...
+      | 0xEB 0xA8 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE MYAEG..HANGUL SYLL...
+      | 0xEB 0xA8 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE MEOG..HANGUL SYLLA...
+      | 0xEB 0xA9 0x00..0x93    #
+      | 0xEB 0xA9 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE MEG..HANGUL SYLLAB...
+      | 0xEB 0xA9 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE MYEOG..HANGUL SYLL...
+      | 0xEB 0xAA 0x00..0x8B    #
+      | 0xEB 0xAA 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE MYEG..HANGUL SYLLA...
+      | 0xEB 0xAA 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE MOG..HANGUL SYLLAB...
+      | 0xEB 0xAB 0x00..0x83    #
+      | 0xEB 0xAB 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE MWAG..HANGUL SYLLA...
+      | 0xEB 0xAB 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE MWAEG..HANGUL SYLL...
+      | 0xEB 0xAB 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE MOEG..HANGUL SYLLA...
+      | 0xEB 0xAC 0x00..0x97    #
+      | 0xEB 0xAC 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE MYOG..HANGUL SYLLA...
+      | 0xEB 0xAC 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE MUG..HANGUL SYLLAB...
+      | 0xEB 0xAD 0x00..0x8F    #
+      | 0xEB 0xAD 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE MWEOG..HANGUL SYLL...
+      | 0xEB 0xAD 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE MWEG..HANGUL SYLLA...
+      | 0xEB 0xAE 0x00..0x87    #
+      | 0xEB 0xAE 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE MWIG..HANGUL SYLLA...
+      | 0xEB 0xAE 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE MYUG..HANGUL SYLLA...
+      | 0xEB 0xAF 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE MEUG..HANGUL SYLLA...
+      | 0xEB 0xAF 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE MYIG..HANGUL SYLLA...
+      | 0xEB 0xAF 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE MIG..HANGUL SYLLAB...
+      | 0xEB 0xB0 0x00..0x93    #
+      | 0xEB 0xB0 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE BAG..HANGUL SYLLAB...
+      | 0xEB 0xB0 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE BAEG..HANGUL SYLLA...
+      | 0xEB 0xB1 0x00..0x8B    #
+      | 0xEB 0xB1 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE BYAG..HANGUL SYLLA...
+      | 0xEB 0xB1 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE BYAEG..HANGUL SYLL...
+      | 0xEB 0xB2 0x00..0x83    #
+      | 0xEB 0xB2 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE BEOG..HANGUL SYLLA...
+      | 0xEB 0xB2 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE BEG..HANGUL SYLLAB...
+      | 0xEB 0xB2 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE BYEOG..HANGUL SYLL...
+      | 0xEB 0xB3 0x00..0x97    #
+      | 0xEB 0xB3 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE BYEG..HANGUL SYLLA...
+      | 0xEB 0xB3 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE BOG..HANGUL SYLLAB...
+      | 0xEB 0xB4 0x00..0x8F    #
+      | 0xEB 0xB4 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE BWAG..HANGUL SYLLA...
+      | 0xEB 0xB4 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE BWAEG..HANGUL SYLL...
+      | 0xEB 0xB5 0x00..0x87    #
+      | 0xEB 0xB5 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE BOEG..HANGUL SYLLA...
+      | 0xEB 0xB5 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE BYOG..HANGUL SYLLA...
+      | 0xEB 0xB6 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE BUG..HANGUL SYLLAB...
+      | 0xEB 0xB6 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE BWEOG..HANGUL SYLL...
+      | 0xEB 0xB6 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE BWEG..HANGUL SYLLA...
+      | 0xEB 0xB7 0x00..0x93    #
+      | 0xEB 0xB7 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE BWIG..HANGUL SYLLA...
+      | 0xEB 0xB7 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE BYUG..HANGUL SYLLA...
+      | 0xEB 0xB8 0x00..0x8B    #
+      | 0xEB 0xB8 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE BEUG..HANGUL SYLLA...
+      | 0xEB 0xB8 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE BYIG..HANGUL SYLLA...
+      | 0xEB 0xB9 0x00..0x83    #
+      | 0xEB 0xB9 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE BIG..HANGUL SYLLAB...
+      | 0xEB 0xB9 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE BBAG..HANGUL SYLLA...
+      | 0xEB 0xB9 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE BBAEG..HANGUL SYLL...
+      | 0xEB 0xBA 0x00..0x97    #
+      | 0xEB 0xBA 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE BBYAG..HANGUL SYLL...
+      | 0xEB 0xBA 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE BBYAEG..HANGUL SYL...
+      | 0xEB 0xBB 0x00..0x8F    #
+      | 0xEB 0xBB 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE BBEOG..HANGUL SYLL...
+      | 0xEB 0xBB 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE BBEG..HANGUL SYLLA...
+      | 0xEB 0xBC 0x00..0x87    #
+      | 0xEB 0xBC 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE BBYEOG..HANGUL SYL...
+      | 0xEB 0xBC 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE BBYEG..HANGUL SYLL...
+      | 0xEB 0xBD 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE BBOG..HANGUL SYLLA...
+      | 0xEB 0xBD 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE BBWAG..HANGUL SYLL...
+      | 0xEB 0xBD 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE BBWAEG..HANGUL SYL...
+      | 0xEB 0xBE 0x00..0x93    #
+      | 0xEB 0xBE 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE BBOEG..HANGUL SYLL...
+      | 0xEB 0xBE 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE BBYOG..HANGUL SYLL...
+      | 0xEB 0xBF 0x00..0x8B    #
+      | 0xEB 0xBF 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE BBUG..HANGUL SYLLA...
+      | 0xEB 0xBF 0xA9..0xFF        #Lo  [27] HANGUL SYLLABLE BBWEOG..HANGUL...
+      | 0xEB 0xC0..0xFF 0x00..0xFF  #
+      | 0xEC 0x00 0x00..0xFF        #
+      | 0xEC 0x01..0x7F 0x00..0xFF  #
+      | 0xEC 0x80 0x00..0x83        #
+      | 0xEC 0x80 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE BBWEG..HANGUL SYLL...
+      | 0xEC 0x80 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE BBWIG..HANGUL SYLL...
+      | 0xEC 0x80 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE BBYUG..HANGUL SYLL...
+      | 0xEC 0x81 0x00..0x97    #
+      | 0xEC 0x81 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE BBEUG..HANGUL SYLL...
+      | 0xEC 0x81 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE BBYIG..HANGUL SYLL...
+      | 0xEC 0x82 0x00..0x8F    #
+      | 0xEC 0x82 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE BBIG..HANGUL SYLLA...
+      | 0xEC 0x82 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE SAG..HANGUL SYLLAB...
+      | 0xEC 0x83 0x00..0x87    #
+      | 0xEC 0x83 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE SAEG..HANGUL SYLLA...
+      | 0xEC 0x83 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE SYAG..HANGUL SYLLA...
+      | 0xEC 0x84 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE SYAEG..HANGUL SYLL...
+      | 0xEC 0x84 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE SEOG..HANGUL SYLLA...
+      | 0xEC 0x84 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE SEG..HANGUL SYLLAB...
+      | 0xEC 0x85 0x00..0x93    #
+      | 0xEC 0x85 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE SYEOG..HANGUL SYLL...
+      | 0xEC 0x85 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE SYEG..HANGUL SYLLA...
+      | 0xEC 0x86 0x00..0x8B    #
+      | 0xEC 0x86 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE SOG..HANGUL SYLLAB...
+      | 0xEC 0x86 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE SWAG..HANGUL SYLLA...
+      | 0xEC 0x87 0x00..0x83    #
+      | 0xEC 0x87 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE SWAEG..HANGUL SYLL...
+      | 0xEC 0x87 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE SOEG..HANGUL SYLLA...
+      | 0xEC 0x87 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE SYOG..HANGUL SYLLA...
+      | 0xEC 0x88 0x00..0x97    #
+      | 0xEC 0x88 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE SUG..HANGUL SYLLAB...
+      | 0xEC 0x88 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE SWEOG..HANGUL SYLL...
+      | 0xEC 0x89 0x00..0x8F    #
+      | 0xEC 0x89 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE SWEG..HANGUL SYLLA...
+      | 0xEC 0x89 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE SWIG..HANGUL SYLLA...
+      | 0xEC 0x8A 0x00..0x87    #
+      | 0xEC 0x8A 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE SYUG..HANGUL SYLLA...
+      | 0xEC 0x8A 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE SEUG..HANGUL SYLLA...
+      | 0xEC 0x8B 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE SYIG..HANGUL SYLLA...
+      | 0xEC 0x8B 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE SIG..HANGUL SYLLAB...
+      | 0xEC 0x8B 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE SSAG..HANGUL SYLLA...
+      | 0xEC 0x8C 0x00..0x93    #
+      | 0xEC 0x8C 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE SSAEG..HANGUL SYLL...
+      | 0xEC 0x8C 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE SSYAG..HANGUL SYLL...
+      | 0xEC 0x8D 0x00..0x8B    #
+      | 0xEC 0x8D 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE SSYAEG..HANGUL SYL...
+      | 0xEC 0x8D 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE SSEOG..HANGUL SYLL...
+      | 0xEC 0x8E 0x00..0x83    #
+      | 0xEC 0x8E 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE SSEG..HANGUL SYLLA...
+      | 0xEC 0x8E 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE SSYEOG..HANGUL SYL...
+      | 0xEC 0x8E 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE SSYEG..HANGUL SYLL...
+      | 0xEC 0x8F 0x00..0x97    #
+      | 0xEC 0x8F 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE SSOG..HANGUL SYLLA...
+      | 0xEC 0x8F 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE SSWAG..HANGUL SYLL...
+      | 0xEC 0x90 0x00..0x8F    #
+      | 0xEC 0x90 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE SSWAEG..HANGUL SYL...
+      | 0xEC 0x90 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE SSOEG..HANGUL SYLL...
+      | 0xEC 0x91 0x00..0x87    #
+      | 0xEC 0x91 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE SSYOG..HANGUL SYLL...
+      | 0xEC 0x91 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE SSUG..HANGUL SYLLA...
+      | 0xEC 0x92 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE SSWEOG..HANGUL SYL...
+      | 0xEC 0x92 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE SSWEG..HANGUL SYLL...
+      | 0xEC 0x92 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE SSWIG..HANGUL SYLL...
+      | 0xEC 0x93 0x00..0x93    #
+      | 0xEC 0x93 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE SSYUG..HANGUL SYLL...
+      | 0xEC 0x93 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE SSEUG..HANGUL SYLL...
+      | 0xEC 0x94 0x00..0x8B    #
+      | 0xEC 0x94 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE SSYIG..HANGUL SYLL...
+      | 0xEC 0x94 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE SSIG..HANGUL SYLLA...
+      | 0xEC 0x95 0x00..0x83    #
+      | 0xEC 0x95 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE AG..HANGUL SYLLABL...
+      | 0xEC 0x95 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE AEG..HANGUL SYLLAB...
+      | 0xEC 0x95 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE YAG..HANGUL SYLLAB...
+      | 0xEC 0x96 0x00..0x97    #
+      | 0xEC 0x96 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE YAEG..HANGUL SYLLA...
+      | 0xEC 0x96 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE EOG..HANGUL SYLLAB...
+      | 0xEC 0x97 0x00..0x8F    #
+      | 0xEC 0x97 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE EG..HANGUL SYLLABL...
+      | 0xEC 0x97 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE YEOG..HANGUL SYLLA...
+      | 0xEC 0x98 0x00..0x87    #
+      | 0xEC 0x98 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE YEG..HANGUL SYLLAB...
+      | 0xEC 0x98 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE OG..HANGUL SYLLABL...
+      | 0xEC 0x99 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE WAG..HANGUL SYLLAB...
+      | 0xEC 0x99 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE WAEG..HANGUL SYLLA...
+      | 0xEC 0x99 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE OEG..HANGUL SYLLAB...
+      | 0xEC 0x9A 0x00..0x93    #
+      | 0xEC 0x9A 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE YOG..HANGUL SYLLAB...
+      | 0xEC 0x9A 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE UG..HANGUL SYLLABL...
+      | 0xEC 0x9B 0x00..0x8B    #
+      | 0xEC 0x9B 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE WEOG..HANGUL SYLLA...
+      | 0xEC 0x9B 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE WEG..HANGUL SYLLAB...
+      | 0xEC 0x9C 0x00..0x83    #
+      | 0xEC 0x9C 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE WIG..HANGUL SYLLAB...
+      | 0xEC 0x9C 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE YUG..HANGUL SYLLAB...
+      | 0xEC 0x9C 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE EUG..HANGUL SYLLAB...
+      | 0xEC 0x9D 0x00..0x97    #
+      | 0xEC 0x9D 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE YIG..HANGUL SYLLAB...
+      | 0xEC 0x9D 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE IG..HANGUL SYLLABL...
+      | 0xEC 0x9E 0x00..0x8F    #
+      | 0xEC 0x9E 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE JAG..HANGUL SYLLAB...
+      | 0xEC 0x9E 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE JAEG..HANGUL SYLLA...
+      | 0xEC 0x9F 0x00..0x87    #
+      | 0xEC 0x9F 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE JYAG..HANGUL SYLLA...
+      | 0xEC 0x9F 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE JYAEG..HANGUL SYLL...
+      | 0xEC 0xA0 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE JEOG..HANGUL SYLLA...
+      | 0xEC 0xA0 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE JEG..HANGUL SYLLAB...
+      | 0xEC 0xA0 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE JYEOG..HANGUL SYLL...
+      | 0xEC 0xA1 0x00..0x93    #
+      | 0xEC 0xA1 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE JYEG..HANGUL SYLLA...
+      | 0xEC 0xA1 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE JOG..HANGUL SYLLAB...
+      | 0xEC 0xA2 0x00..0x8B    #
+      | 0xEC 0xA2 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE JWAG..HANGUL SYLLA...
+      | 0xEC 0xA2 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE JWAEG..HANGUL SYLL...
+      | 0xEC 0xA3 0x00..0x83    #
+      | 0xEC 0xA3 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE JOEG..HANGUL SYLLA...
+      | 0xEC 0xA3 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE JYOG..HANGUL SYLLA...
+      | 0xEC 0xA3 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE JUG..HANGUL SYLLAB...
+      | 0xEC 0xA4 0x00..0x97    #
+      | 0xEC 0xA4 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE JWEOG..HANGUL SYLL...
+      | 0xEC 0xA4 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE JWEG..HANGUL SYLLA...
+      | 0xEC 0xA5 0x00..0x8F    #
+      | 0xEC 0xA5 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE JWIG..HANGUL SYLLA...
+      | 0xEC 0xA5 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE JYUG..HANGUL SYLLA...
+      | 0xEC 0xA6 0x00..0x87    #
+      | 0xEC 0xA6 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE JEUG..HANGUL SYLLA...
+      | 0xEC 0xA6 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE JYIG..HANGUL SYLLA...
+      | 0xEC 0xA7 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE JIG..HANGUL SYLLAB...
+      | 0xEC 0xA7 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE JJAG..HANGUL SYLLA...
+      | 0xEC 0xA7 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE JJAEG..HANGUL SYLL...
+      | 0xEC 0xA8 0x00..0x93    #
+      | 0xEC 0xA8 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE JJYAG..HANGUL SYLL...
+      | 0xEC 0xA8 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE JJYAEG..HANGUL SYL...
+      | 0xEC 0xA9 0x00..0x8B    #
+      | 0xEC 0xA9 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE JJEOG..HANGUL SYLL...
+      | 0xEC 0xA9 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE JJEG..HANGUL SYLLA...
+      | 0xEC 0xAA 0x00..0x83    #
+      | 0xEC 0xAA 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE JJYEOG..HANGUL SYL...
+      | 0xEC 0xAA 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE JJYEG..HANGUL SYLL...
+      | 0xEC 0xAA 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE JJOG..HANGUL SYLLA...
+      | 0xEC 0xAB 0x00..0x97    #
+      | 0xEC 0xAB 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE JJWAG..HANGUL SYLL...
+      | 0xEC 0xAB 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE JJWAEG..HANGUL SYL...
+      | 0xEC 0xAC 0x00..0x8F    #
+      | 0xEC 0xAC 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE JJOEG..HANGUL SYLL...
+      | 0xEC 0xAC 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE JJYOG..HANGUL SYLL...
+      | 0xEC 0xAD 0x00..0x87    #
+      | 0xEC 0xAD 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE JJUG..HANGUL SYLLA...
+      | 0xEC 0xAD 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE JJWEOG..HANGUL SYL...
+      | 0xEC 0xAE 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE JJWEG..HANGUL SYLL...
+      | 0xEC 0xAE 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE JJWIG..HANGUL SYLL...
+      | 0xEC 0xAE 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE JJYUG..HANGUL SYLL...
+      | 0xEC 0xAF 0x00..0x93    #
+      | 0xEC 0xAF 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE JJEUG..HANGUL SYLL...
+      | 0xEC 0xAF 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE JJYIG..HANGUL SYLL...
+      | 0xEC 0xB0 0x00..0x8B    #
+      | 0xEC 0xB0 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE JJIG..HANGUL SYLLA...
+      | 0xEC 0xB0 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE CAG..HANGUL SYLLAB...
+      | 0xEC 0xB1 0x00..0x83    #
+      | 0xEC 0xB1 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE CAEG..HANGUL SYLLA...
+      | 0xEC 0xB1 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE CYAG..HANGUL SYLLA...
+      | 0xEC 0xB1 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE CYAEG..HANGUL SYLL...
+      | 0xEC 0xB2 0x00..0x97    #
+      | 0xEC 0xB2 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE CEOG..HANGUL SYLLA...
+      | 0xEC 0xB2 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE CEG..HANGUL SYLLAB...
+      | 0xEC 0xB3 0x00..0x8F    #
+      | 0xEC 0xB3 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE CYEOG..HANGUL SYLL...
+      | 0xEC 0xB3 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE CYEG..HANGUL SYLLA...
+      | 0xEC 0xB4 0x00..0x87    #
+      | 0xEC 0xB4 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE COG..HANGUL SYLLAB...
+      | 0xEC 0xB4 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE CWAG..HANGUL SYLLA...
+      | 0xEC 0xB5 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE CWAEG..HANGUL SYLL...
+      | 0xEC 0xB5 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE COEG..HANGUL SYLLA...
+      | 0xEC 0xB5 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE CYOG..HANGUL SYLLA...
+      | 0xEC 0xB6 0x00..0x93    #
+      | 0xEC 0xB6 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE CUG..HANGUL SYLLAB...
+      | 0xEC 0xB6 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE CWEOG..HANGUL SYLL...
+      | 0xEC 0xB7 0x00..0x8B    #
+      | 0xEC 0xB7 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE CWEG..HANGUL SYLLA...
+      | 0xEC 0xB7 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE CWIG..HANGUL SYLLA...
+      | 0xEC 0xB8 0x00..0x83    #
+      | 0xEC 0xB8 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE CYUG..HANGUL SYLLA...
+      | 0xEC 0xB8 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE CEUG..HANGUL SYLLA...
+      | 0xEC 0xB8 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE CYIG..HANGUL SYLLA...
+      | 0xEC 0xB9 0x00..0x97    #
+      | 0xEC 0xB9 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE CIG..HANGUL SYLLAB...
+      | 0xEC 0xB9 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE KAG..HANGUL SYLLAB...
+      | 0xEC 0xBA 0x00..0x8F    #
+      | 0xEC 0xBA 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE KAEG..HANGUL SYLLA...
+      | 0xEC 0xBA 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE KYAG..HANGUL SYLLA...
+      | 0xEC 0xBB 0x00..0x87    #
+      | 0xEC 0xBB 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE KYAEG..HANGUL SYLL...
+      | 0xEC 0xBB 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE KEOG..HANGUL SYLLA...
+      | 0xEC 0xBC 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE KEG..HANGUL SYLLAB...
+      | 0xEC 0xBC 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE KYEOG..HANGUL SYLL...
+      | 0xEC 0xBC 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE KYEG..HANGUL SYLLA...
+      | 0xEC 0xBD 0x00..0x93    #
+      | 0xEC 0xBD 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE KOG..HANGUL SYLLAB...
+      | 0xEC 0xBD 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE KWAG..HANGUL SYLLA...
+      | 0xEC 0xBE 0x00..0x8B    #
+      | 0xEC 0xBE 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE KWAEG..HANGUL SYLL...
+      | 0xEC 0xBE 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE KOEG..HANGUL SYLLA...
+      | 0xEC 0xBF 0x00..0x83    #
+      | 0xEC 0xBF 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE KYOG..HANGUL SYLLA...
+      | 0xEC 0xBF 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE KUG..HANGUL SYLLAB...
+      | 0xEC 0xBF 0xBD..0xFF        #Lo  [27] HANGUL SYLLABLE KWEOG..HANGUL ...
+      | 0xEC 0xC0..0xFF 0x00..0xFF  #
+      | 0xED 0x00 0x00..0xFF        #
+      | 0xED 0x01..0x7F 0x00..0xFF  #
+      | 0xED 0x80 0x00..0x97        #
+      | 0xED 0x80 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE KWEG..HANGUL SYLLA...
+      | 0xED 0x80 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE KWIG..HANGUL SYLLA...
+      | 0xED 0x81 0x00..0x8F    #
+      | 0xED 0x81 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE KYUG..HANGUL SYLLA...
+      | 0xED 0x81 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE KEUG..HANGUL SYLLA...
+      | 0xED 0x82 0x00..0x87    #
+      | 0xED 0x82 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE KYIG..HANGUL SYLLA...
+      | 0xED 0x82 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE KIG..HANGUL SYLLAB...
+      | 0xED 0x83 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE TAG..HANGUL SYLLAB...
+      | 0xED 0x83 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE TAEG..HANGUL SYLLA...
+      | 0xED 0x83 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE TYAG..HANGUL SYLLA...
+      | 0xED 0x84 0x00..0x93    #
+      | 0xED 0x84 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE TYAEG..HANGUL SYLL...
+      | 0xED 0x84 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE TEOG..HANGUL SYLLA...
+      | 0xED 0x85 0x00..0x8B    #
+      | 0xED 0x85 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE TEG..HANGUL SYLLAB...
+      | 0xED 0x85 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE TYEOG..HANGUL SYLL...
+      | 0xED 0x86 0x00..0x83    #
+      | 0xED 0x86 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE TYEG..HANGUL SYLLA...
+      | 0xED 0x86 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE TOG..HANGUL SYLLAB...
+      | 0xED 0x86 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE TWAG..HANGUL SYLLA...
+      | 0xED 0x87 0x00..0x97    #
+      | 0xED 0x87 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE TWAEG..HANGUL SYLL...
+      | 0xED 0x87 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE TOEG..HANGUL SYLLA...
+      | 0xED 0x88 0x00..0x8F    #
+      | 0xED 0x88 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE TYOG..HANGUL SYLLA...
+      | 0xED 0x88 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE TUG..HANGUL SYLLAB...
+      | 0xED 0x89 0x00..0x87    #
+      | 0xED 0x89 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE TWEOG..HANGUL SYLL...
+      | 0xED 0x89 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE TWEG..HANGUL SYLLA...
+      | 0xED 0x8A 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE TWIG..HANGUL SYLLA...
+      | 0xED 0x8A 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE TYUG..HANGUL SYLLA...
+      | 0xED 0x8A 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE TEUG..HANGUL SYLLA...
+      | 0xED 0x8B 0x00..0x93    #
+      | 0xED 0x8B 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE TYIG..HANGUL SYLLA...
+      | 0xED 0x8B 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE TIG..HANGUL SYLLAB...
+      | 0xED 0x8C 0x00..0x8B    #
+      | 0xED 0x8C 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE PAG..HANGUL SYLLAB...
+      | 0xED 0x8C 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE PAEG..HANGUL SYLLA...
+      | 0xED 0x8D 0x00..0x83    #
+      | 0xED 0x8D 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE PYAG..HANGUL SYLLA...
+      | 0xED 0x8D 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE PYAEG..HANGUL SYLL...
+      | 0xED 0x8D 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE PEOG..HANGUL SYLLA...
+      | 0xED 0x8E 0x00..0x97    #
+      | 0xED 0x8E 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE PEG..HANGUL SYLLAB...
+      | 0xED 0x8E 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE PYEOG..HANGUL SYLL...
+      | 0xED 0x8F 0x00..0x8F    #
+      | 0xED 0x8F 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE PYEG..HANGUL SYLLA...
+      | 0xED 0x8F 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE POG..HANGUL SYLLAB...
+      | 0xED 0x90 0x00..0x87    #
+      | 0xED 0x90 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE PWAG..HANGUL SYLLA...
+      | 0xED 0x90 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE PWAEG..HANGUL SYLL...
+      | 0xED 0x91 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE POEG..HANGUL SYLLA...
+      | 0xED 0x91 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE PYOG..HANGUL SYLLA...
+      | 0xED 0x91 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE PUG..HANGUL SYLLAB...
+      | 0xED 0x92 0x00..0x93    #
+      | 0xED 0x92 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE PWEOG..HANGUL SYLL...
+      | 0xED 0x92 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE PWEG..HANGUL SYLLA...
+      | 0xED 0x93 0x00..0x8B    #
+      | 0xED 0x93 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE PWIG..HANGUL SYLLA...
+      | 0xED 0x93 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE PYUG..HANGUL SYLLA...
+      | 0xED 0x94 0x00..0x83    #
+      | 0xED 0x94 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE PEUG..HANGUL SYLLA...
+      | 0xED 0x94 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE PYIG..HANGUL SYLLA...
+      | 0xED 0x94 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE PIG..HANGUL SYLLAB...
+      | 0xED 0x95 0x00..0x97    #
+      | 0xED 0x95 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE HAG..HANGUL SYLLAB...
+      | 0xED 0x95 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE HAEG..HANGUL SYLLA...
+      | 0xED 0x96 0x00..0x8F    #
+      | 0xED 0x96 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE HYAG..HANGUL SYLLA...
+      | 0xED 0x96 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE HYAEG..HANGUL SYLL...
+      | 0xED 0x97 0x00..0x87    #
+      | 0xED 0x97 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE HEOG..HANGUL SYLLA...
+      | 0xED 0x97 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE HEG..HANGUL SYLLAB...
+      | 0xED 0x98 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE HYEOG..HANGUL SYLL...
+      | 0xED 0x98 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE HYEG..HANGUL SYLLA...
+      | 0xED 0x98 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE HOG..HANGUL SYLLAB...
+      | 0xED 0x99 0x00..0x93    #
+      | 0xED 0x99 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE HWAG..HANGUL SYLLA...
+      | 0xED 0x99 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE HWAEG..HANGUL SYLL...
+      | 0xED 0x9A 0x00..0x8B    #
+      | 0xED 0x9A 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE HOEG..HANGUL SYLLA...
+      | 0xED 0x9A 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE HYOG..HANGUL SYLLA...
+      | 0xED 0x9B 0x00..0x83    #
+      | 0xED 0x9B 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE HUG..HANGUL SYLLAB...
+      | 0xED 0x9B 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE HWEOG..HANGUL SYLL...
+      | 0xED 0x9B 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE HWEG..HANGUL SYLLA...
+      | 0xED 0x9C 0x00..0x97    #
+      | 0xED 0x9C 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE HWIG..HANGUL SYLLA...
+      | 0xED 0x9C 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE HYUG..HANGUL SYLLA...
+      | 0xED 0x9D 0x00..0x8F    #
+      | 0xED 0x9D 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE HEUG..HANGUL SYLLA...
+      | 0xED 0x9D 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE HYIG..HANGUL SYLLA...
+      | 0xED 0x9E 0x00..0x87    #
+      | 0xED 0x9E 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE HIG..HANGUL SYLLAB...
+      ;
+
+    E_Base = 
+        0xE2 0x98 0x9D          #So       WHITE UP POINTING INDEX
+      | 0xE2 0x9B 0xB9          #So       PERSON WITH BALL
+      | 0xE2 0x9C 0x8A..0x8D    #So   [4] RAISED FIST..WRITING HAND
+      | 0xF0 0x9F 0x8E 0x85     #So       FATHER CHRISTMAS
+      | 0xF0 0x9F 0x8F 0x83..0x84  #So   [2] RUNNER..SURFER
+      | 0xF0 0x9F 0x8F 0x8A..0x8B  #So   [2] SWIMMER..WEIGHT LIFTER
+      | 0xF0 0x9F 0x91 0x82..0x83  #So   [2] EAR..NOSE
+      | 0xF0 0x9F 0x91 0x86..0x90  #So  [11] WHITE UP POINTING BACKHAND INDE...
+      | 0xF0 0x9F 0x91 0xAE     #So       POLICE OFFICER
+      | 0xF0 0x9F 0x91 0xB0..0xB8  #So   [9] BRIDE WITH VEIL..PRINCESS
+      | 0xF0 0x9F 0x91 0xBC     #So       BABY ANGEL
+      | 0xF0 0x9F 0x92 0x81..0x83  #So   [3] INFORMATION DESK PERSON..DANCER
+      | 0xF0 0x9F 0x92 0x85..0x87  #So   [3] NAIL POLISH..HAIRCUT
+      | 0xF0 0x9F 0x92 0xAA     #So       FLEXED BICEPS
+      | 0xF0 0x9F 0x95 0xB5     #So       SLEUTH OR SPY
+      | 0xF0 0x9F 0x95 0xBA     #So       MAN DANCING
+      | 0xF0 0x9F 0x96 0x90     #So       RAISED HAND WITH FINGERS SPLAYED
+      | 0xF0 0x9F 0x96 0x95..0x96  #So   [2] REVERSED HAND WITH MIDDLE FINGE...
+      | 0xF0 0x9F 0x99 0x85..0x87  #So   [3] FACE WITH NO GOOD GESTURE..PERS...
+      | 0xF0 0x9F 0x99 0x8B..0x8F  #So   [5] HAPPY PERSON RAISING ONE HAND.....
+      | 0xF0 0x9F 0x9A 0xA3     #So       ROWBOAT
+      | 0xF0 0x9F 0x9A 0xB4..0xB6  #So   [3] BICYCLIST..PEDESTRIAN
+      | 0xF0 0x9F 0x9B 0x80     #So       BATH
+      | 0xF0 0x9F 0xA4 0x98..0x9E  #So   [7] SIGN OF THE HORNS..HAND WITH IN...
+      | 0xF0 0x9F 0xA4 0xA6     #So       FACE PALM
+      | 0xF0 0x9F 0xA4 0xB0     #So       PREGNANT WOMAN
+      | 0xF0 0x9F 0xA4 0xB3..0xB9  #So   [7] SELFIE..JUGGLING
+      | 0xF0 0x9F 0xA4 0xBC..0xBE  #So   [3] WRESTLERS..HANDBALL
+      ;
+
+    E_Modifier = 
+        0xF0 0x9F 0x8F 0xBB..0xBF  #Sk   [5] EMOJI MODIFIER FITZPATRICK TYPE...
+      ;
+
+    ZWJ = 
+        0xE2 0x80 0x8D          #Cf       ZERO WIDTH JOINER
+      ;
+
+    Glue_After_Zwj = 
+        0xE2 0x9D 0xA4          #So       HEAVY BLACK HEART
+      | 0xF0 0x9F 0x92 0x8B     #So       KISS MARK
+      | 0xF0 0x9F 0x97 0xA8     #So       LEFT SPEECH BUBBLE
+      ;
+
+    E_Base_GAZ = 
+        0xF0 0x9F 0x91 0xA6..0xA9  #So   [4] BOY..WOMAN
+      ;
+
+}%%
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/tables.go b/vendor/github.com/apparentlymart/go-textseg/textseg/tables.go
new file mode 100644
index 00000000..fab7e842
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/tables.go
@@ -0,0 +1,5700 @@
+// Generated by running
+//      maketables --url=http://www.unicode.org/Public/9.0.0/ucd/auxiliary/
+// DO NOT EDIT
+
+package textseg
+
+import (
+	"unicode"
+)
+
+var _GraphemeCR = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xd, Hi: 0xd, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _GraphemeControl = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x0, Hi: 0x9, Stride: 0x1},
+		unicode.Range16{Lo: 0xb, Hi: 0xc, Stride: 0x1},
+		unicode.Range16{Lo: 0xe, Hi: 0x1f, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f, Hi: 0x9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xad, Hi: 0xad, Stride: 0x1},
+		unicode.Range16{Lo: 0x61c, Hi: 0x61c, Stride: 0x1},
+		unicode.Range16{Lo: 0x180e, Hi: 0x180e, Stride: 0x1},
+		unicode.Range16{Lo: 0x200b, Hi: 0x200b, Stride: 0x1},
+		unicode.Range16{Lo: 0x200e, Hi: 0x200f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2028, Hi: 0x2028, Stride: 0x1},
+		unicode.Range16{Lo: 0x2029, Hi: 0x2029, Stride: 0x1},
+		unicode.Range16{Lo: 0x202a, Hi: 0x202e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2060, Hi: 0x2064, Stride: 0x1},
+		unicode.Range16{Lo: 0x2065, Hi: 0x2065, Stride: 0x1},
+		unicode.Range16{Lo: 0x2066, Hi: 0x206f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd800, Hi: 0xdfff, Stride: 0x1},
+		unicode.Range16{Lo: 0xfeff, Hi: 0xfeff, Stride: 0x1},
+		unicode.Range16{Lo: 0xfff0, Hi: 0xfff8, Stride: 0x1},
+		unicode.Range16{Lo: 0xfff9, Hi: 0xfffb, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1bca0, Hi: 0x1bca3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d173, Hi: 0x1d17a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0000, Hi: 0xe0000, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0001, Hi: 0xe0001, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0002, Hi: 0xe001f, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0080, Hi: 0xe00ff, Stride: 0x1},
+		unicode.Range32{Lo: 0xe01f0, Hi: 0xe0fff, Stride: 0x1},
+	},
+	LatinOffset: 5,
+}
+
+var _GraphemeE_Base = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x261d, Hi: 0x261d, Stride: 0x1},
+		unicode.Range16{Lo: 0x26f9, Hi: 0x26f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x270a, Hi: 0x270d, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f385, Hi: 0x1f385, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f3c3, Hi: 0x1f3c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f3ca, Hi: 0x1f3cb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f442, Hi: 0x1f443, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f446, Hi: 0x1f450, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f46e, Hi: 0x1f46e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f470, Hi: 0x1f478, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f47c, Hi: 0x1f47c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f481, Hi: 0x1f483, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f485, Hi: 0x1f487, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f4aa, Hi: 0x1f4aa, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f575, Hi: 0x1f575, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f57a, Hi: 0x1f57a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f590, Hi: 0x1f590, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f595, Hi: 0x1f596, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f645, Hi: 0x1f647, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f64b, Hi: 0x1f64f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6a3, Hi: 0x1f6a3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6b4, Hi: 0x1f6b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6c0, Hi: 0x1f6c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f918, Hi: 0x1f91e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f926, Hi: 0x1f926, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f930, Hi: 0x1f930, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f933, Hi: 0x1f939, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f93c, Hi: 0x1f93e, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeE_Base_GAZ = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f466, Hi: 0x1f469, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeE_Modifier = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f3fb, Hi: 0x1f3ff, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeExtend = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x300, Hi: 0x36f, Stride: 0x1},
+		unicode.Range16{Lo: 0x483, Hi: 0x487, Stride: 0x1},
+		unicode.Range16{Lo: 0x488, Hi: 0x489, Stride: 0x1},
+		unicode.Range16{Lo: 0x591, Hi: 0x5bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x5bf, Hi: 0x5bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c1, Hi: 0x5c2, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c4, Hi: 0x5c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c7, Hi: 0x5c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x610, Hi: 0x61a, Stride: 0x1},
+		unicode.Range16{Lo: 0x64b, Hi: 0x65f, Stride: 0x1},
+		unicode.Range16{Lo: 0x670, Hi: 0x670, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d6, Hi: 0x6dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6df, Hi: 0x6e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e7, Hi: 0x6e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ea, Hi: 0x6ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x711, Hi: 0x711, Stride: 0x1},
+		unicode.Range16{Lo: 0x730, Hi: 0x74a, Stride: 0x1},
+		unicode.Range16{Lo: 0x7a6, Hi: 0x7b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x7eb, Hi: 0x7f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x816, Hi: 0x819, Stride: 0x1},
+		unicode.Range16{Lo: 0x81b, Hi: 0x823, Stride: 0x1},
+		unicode.Range16{Lo: 0x825, Hi: 0x827, Stride: 0x1},
+		unicode.Range16{Lo: 0x829, Hi: 0x82d, Stride: 0x1},
+		unicode.Range16{Lo: 0x859, Hi: 0x85b, Stride: 0x1},
+		unicode.Range16{Lo: 0x8d4, Hi: 0x8e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e3, Hi: 0x902, Stride: 0x1},
+		unicode.Range16{Lo: 0x93a, Hi: 0x93a, Stride: 0x1},
+		unicode.Range16{Lo: 0x93c, Hi: 0x93c, Stride: 0x1},
+		unicode.Range16{Lo: 0x941, Hi: 0x948, Stride: 0x1},
+		unicode.Range16{Lo: 0x94d, Hi: 0x94d, Stride: 0x1},
+		unicode.Range16{Lo: 0x951, Hi: 0x957, Stride: 0x1},
+		unicode.Range16{Lo: 0x962, Hi: 0x963, Stride: 0x1},
+		unicode.Range16{Lo: 0x981, Hi: 0x981, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bc, Hi: 0x9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9be, Hi: 0x9be, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c1, Hi: 0x9c4, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cd, Hi: 0x9cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9d7, Hi: 0x9d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e2, Hi: 0x9e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa01, Hi: 0xa02, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3c, Hi: 0xa3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa41, Hi: 0xa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xa47, Hi: 0xa48, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4b, Hi: 0xa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa51, Hi: 0xa51, Stride: 0x1},
+		unicode.Range16{Lo: 0xa70, Hi: 0xa71, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75, Hi: 0xa75, Stride: 0x1},
+		unicode.Range16{Lo: 0xa81, Hi: 0xa82, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc, Hi: 0xabc, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1, Hi: 0xac5, Stride: 0x1},
+		unicode.Range16{Lo: 0xac7, Hi: 0xac8, Stride: 0x1},
+		unicode.Range16{Lo: 0xacd, Hi: 0xacd, Stride: 0x1},
+		unicode.Range16{Lo: 0xae2, Hi: 0xae3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb01, Hi: 0xb01, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c, Hi: 0xb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e, Hi: 0xb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3f, Hi: 0xb3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb41, Hi: 0xb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4d, Hi: 0xb4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb56, Hi: 0xb56, Stride: 0x1},
+		unicode.Range16{Lo: 0xb57, Hi: 0xb57, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62, Hi: 0xb63, Stride: 0x1},
+		unicode.Range16{Lo: 0xb82, Hi: 0xb82, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbe, Hi: 0xbbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc0, Hi: 0xbc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd, Hi: 0xbcd, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd7, Hi: 0xbd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc00, Hi: 0xc00, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3e, Hi: 0xc40, Stride: 0x1},
+		unicode.Range16{Lo: 0xc46, Hi: 0xc48, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4a, Hi: 0xc4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc55, Hi: 0xc56, Stride: 0x1},
+		unicode.Range16{Lo: 0xc62, Hi: 0xc63, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81, Hi: 0xc81, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbc, Hi: 0xcbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf, Hi: 0xcbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc2, Hi: 0xcc2, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc6, Hi: 0xcc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xccc, Hi: 0xccd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5, Hi: 0xcd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xce2, Hi: 0xce3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd01, Hi: 0xd01, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3e, Hi: 0xd3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xd41, Hi: 0xd44, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4d, Hi: 0xd4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd57, Hi: 0xd57, Stride: 0x1},
+		unicode.Range16{Lo: 0xd62, Hi: 0xd63, Stride: 0x1},
+		unicode.Range16{Lo: 0xdca, Hi: 0xdca, Stride: 0x1},
+		unicode.Range16{Lo: 0xdcf, Hi: 0xdcf, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd2, Hi: 0xdd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd6, Hi: 0xdd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xddf, Hi: 0xddf, Stride: 0x1},
+		unicode.Range16{Lo: 0xe31, Hi: 0xe31, Stride: 0x1},
+		unicode.Range16{Lo: 0xe34, Hi: 0xe3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xe47, Hi: 0xe4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb1, Hi: 0xeb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb4, Hi: 0xeb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xebb, Hi: 0xebc, Stride: 0x1},
+		unicode.Range16{Lo: 0xec8, Hi: 0xecd, Stride: 0x1},
+		unicode.Range16{Lo: 0xf18, Hi: 0xf19, Stride: 0x1},
+		unicode.Range16{Lo: 0xf35, Hi: 0xf35, Stride: 0x1},
+		unicode.Range16{Lo: 0xf37, Hi: 0xf37, Stride: 0x1},
+		unicode.Range16{Lo: 0xf39, Hi: 0xf39, Stride: 0x1},
+		unicode.Range16{Lo: 0xf71, Hi: 0xf7e, Stride: 0x1},
+		unicode.Range16{Lo: 0xf80, Hi: 0xf84, Stride: 0x1},
+		unicode.Range16{Lo: 0xf86, Hi: 0xf87, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8d, Hi: 0xf97, Stride: 0x1},
+		unicode.Range16{Lo: 0xf99, Hi: 0xfbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xfc6, Hi: 0xfc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x102d, Hi: 0x1030, Stride: 0x1},
+		unicode.Range16{Lo: 0x1032, Hi: 0x1037, Stride: 0x1},
+		unicode.Range16{Lo: 0x1039, Hi: 0x103a, Stride: 0x1},
+		unicode.Range16{Lo: 0x103d, Hi: 0x103e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1058, Hi: 0x1059, Stride: 0x1},
+		unicode.Range16{Lo: 0x105e, Hi: 0x1060, Stride: 0x1},
+		unicode.Range16{Lo: 0x1071, Hi: 0x1074, Stride: 0x1},
+		unicode.Range16{Lo: 0x1082, Hi: 0x1082, Stride: 0x1},
+		unicode.Range16{Lo: 0x1085, Hi: 0x1086, Stride: 0x1},
+		unicode.Range16{Lo: 0x108d, Hi: 0x108d, Stride: 0x1},
+		unicode.Range16{Lo: 0x109d, Hi: 0x109d, Stride: 0x1},
+		unicode.Range16{Lo: 0x135d, Hi: 0x135f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1712, Hi: 0x1714, Stride: 0x1},
+		unicode.Range16{Lo: 0x1732, Hi: 0x1734, Stride: 0x1},
+		unicode.Range16{Lo: 0x1752, Hi: 0x1753, Stride: 0x1},
+		unicode.Range16{Lo: 0x1772, Hi: 0x1773, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b4, Hi: 0x17b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b7, Hi: 0x17bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c6, Hi: 0x17c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c9, Hi: 0x17d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x17dd, Hi: 0x17dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x180b, Hi: 0x180d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1885, Hi: 0x1886, Stride: 0x1},
+		unicode.Range16{Lo: 0x18a9, Hi: 0x18a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1920, Hi: 0x1922, Stride: 0x1},
+		unicode.Range16{Lo: 0x1927, Hi: 0x1928, Stride: 0x1},
+		unicode.Range16{Lo: 0x1932, Hi: 0x1932, Stride: 0x1},
+		unicode.Range16{Lo: 0x1939, Hi: 0x193b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a17, Hi: 0x1a18, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a1b, Hi: 0x1a1b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a56, Hi: 0x1a56, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a58, Hi: 0x1a5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a60, Hi: 0x1a60, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a62, Hi: 0x1a62, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a65, Hi: 0x1a6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a73, Hi: 0x1a7c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a7f, Hi: 0x1a7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ab0, Hi: 0x1abd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1abe, Hi: 0x1abe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b00, Hi: 0x1b03, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b34, Hi: 0x1b34, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b36, Hi: 0x1b3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3c, Hi: 0x1b3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b42, Hi: 0x1b42, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b6b, Hi: 0x1b73, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b80, Hi: 0x1b81, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba2, Hi: 0x1ba5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba8, Hi: 0x1ba9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bab, Hi: 0x1bad, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be6, Hi: 0x1be6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be8, Hi: 0x1be9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bed, Hi: 0x1bed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bef, Hi: 0x1bf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c2c, Hi: 0x1c33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c36, Hi: 0x1c37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd0, Hi: 0x1cd2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd4, Hi: 0x1ce0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce2, Hi: 0x1ce8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ced, Hi: 0x1ced, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf4, Hi: 0x1cf4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf8, Hi: 0x1cf9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dc0, Hi: 0x1df5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dfb, Hi: 0x1dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x200c, Hi: 0x200c, Stride: 0x1},
+		unicode.Range16{Lo: 0x20d0, Hi: 0x20dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x20dd, Hi: 0x20e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e1, Hi: 0x20e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e2, Hi: 0x20e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e5, Hi: 0x20f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cef, Hi: 0x2cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d7f, Hi: 0x2d7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2de0, Hi: 0x2dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x302a, Hi: 0x302d, Stride: 0x1},
+		unicode.Range16{Lo: 0x302e, Hi: 0x302f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3099, Hi: 0x309a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66f, Hi: 0xa66f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa670, Hi: 0xa672, Stride: 0x1},
+		unicode.Range16{Lo: 0xa674, Hi: 0xa67d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69e, Hi: 0xa69f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f0, Hi: 0xa6f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa802, Hi: 0xa802, Stride: 0x1},
+		unicode.Range16{Lo: 0xa806, Hi: 0xa806, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80b, Hi: 0xa80b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa825, Hi: 0xa826, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8c4, Hi: 0xa8c5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8e0, Hi: 0xa8f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa926, Hi: 0xa92d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa947, Hi: 0xa951, Stride: 0x1},
+		unicode.Range16{Lo: 0xa980, Hi: 0xa982, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b3, Hi: 0xa9b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b6, Hi: 0xa9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bc, Hi: 0xa9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e5, Hi: 0xa9e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa29, Hi: 0xaa2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa31, Hi: 0xaa32, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa35, Hi: 0xaa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa43, Hi: 0xaa43, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4c, Hi: 0xaa4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7c, Hi: 0xaa7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab0, Hi: 0xaab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab2, Hi: 0xaab4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab7, Hi: 0xaab8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaabe, Hi: 0xaabf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac1, Hi: 0xaac1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaec, Hi: 0xaaed, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf6, Hi: 0xaaf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe5, Hi: 0xabe5, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe8, Hi: 0xabe8, Stride: 0x1},
+		unicode.Range16{Lo: 0xabed, Hi: 0xabed, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1e, Hi: 0xfb1e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe00, Hi: 0xfe0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe20, Hi: 0xfe2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff9e, Hi: 0xff9f, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x101fd, Hi: 0x101fd, Stride: 0x1},
+		unicode.Range32{Lo: 0x102e0, Hi: 0x102e0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10376, Hi: 0x1037a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a01, Hi: 0x10a03, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a05, Hi: 0x10a06, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a0c, Hi: 0x10a0f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a38, Hi: 0x10a3a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a3f, Hi: 0x10a3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ae5, Hi: 0x10ae6, Stride: 0x1},
+		unicode.Range32{Lo: 0x11001, Hi: 0x11001, Stride: 0x1},
+		unicode.Range32{Lo: 0x11038, Hi: 0x11046, Stride: 0x1},
+		unicode.Range32{Lo: 0x1107f, Hi: 0x11081, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b3, Hi: 0x110b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b9, Hi: 0x110ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x11100, Hi: 0x11102, Stride: 0x1},
+		unicode.Range32{Lo: 0x11127, Hi: 0x1112b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112d, Hi: 0x11134, Stride: 0x1},
+		unicode.Range32{Lo: 0x11173, Hi: 0x11173, Stride: 0x1},
+		unicode.Range32{Lo: 0x11180, Hi: 0x11181, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b6, Hi: 0x111be, Stride: 0x1},
+		unicode.Range32{Lo: 0x111ca, Hi: 0x111cc, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122f, Hi: 0x11231, Stride: 0x1},
+		unicode.Range32{Lo: 0x11234, Hi: 0x11234, Stride: 0x1},
+		unicode.Range32{Lo: 0x11236, Hi: 0x11237, Stride: 0x1},
+		unicode.Range32{Lo: 0x1123e, Hi: 0x1123e, Stride: 0x1},
+		unicode.Range32{Lo: 0x112df, Hi: 0x112df, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e3, Hi: 0x112ea, Stride: 0x1},
+		unicode.Range32{Lo: 0x11300, Hi: 0x11301, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133c, Hi: 0x1133c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133e, Hi: 0x1133e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11340, Hi: 0x11340, Stride: 0x1},
+		unicode.Range32{Lo: 0x11357, Hi: 0x11357, Stride: 0x1},
+		unicode.Range32{Lo: 0x11366, Hi: 0x1136c, Stride: 0x1},
+		unicode.Range32{Lo: 0x11370, Hi: 0x11374, Stride: 0x1},
+		unicode.Range32{Lo: 0x11438, Hi: 0x1143f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11442, Hi: 0x11444, Stride: 0x1},
+		unicode.Range32{Lo: 0x11446, Hi: 0x11446, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b0, Hi: 0x114b0, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b3, Hi: 0x114b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x114ba, Hi: 0x114ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bd, Hi: 0x114bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bf, Hi: 0x114c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c2, Hi: 0x114c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x115af, Hi: 0x115af, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b2, Hi: 0x115b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bc, Hi: 0x115bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bf, Hi: 0x115c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x115dc, Hi: 0x115dd, Stride: 0x1},
+		unicode.Range32{Lo: 0x11633, Hi: 0x1163a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163d, Hi: 0x1163d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163f, Hi: 0x11640, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ab, Hi: 0x116ab, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ad, Hi: 0x116ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b0, Hi: 0x116b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b7, Hi: 0x116b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x1171d, Hi: 0x1171f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11722, Hi: 0x11725, Stride: 0x1},
+		unicode.Range32{Lo: 0x11727, Hi: 0x1172b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c30, Hi: 0x11c36, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c38, Hi: 0x11c3d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3f, Hi: 0x11c3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c92, Hi: 0x11ca7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11caa, Hi: 0x11cb0, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb2, Hi: 0x11cb3, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb5, Hi: 0x11cb6, Stride: 0x1},
+		unicode.Range32{Lo: 0x16af0, Hi: 0x16af4, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b30, Hi: 0x16b36, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f8f, Hi: 0x16f92, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc9d, Hi: 0x1bc9e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d165, Hi: 0x1d165, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d167, Hi: 0x1d169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d16e, Hi: 0x1d172, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d17b, Hi: 0x1d182, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d185, Hi: 0x1d18b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d1aa, Hi: 0x1d1ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d242, Hi: 0x1d244, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da00, Hi: 0x1da36, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da3b, Hi: 0x1da6c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da75, Hi: 0x1da75, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da84, Hi: 0x1da84, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da9b, Hi: 0x1da9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1daa1, Hi: 0x1daaf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e000, Hi: 0x1e006, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e008, Hi: 0x1e018, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e01b, Hi: 0x1e021, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e023, Hi: 0x1e024, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e026, Hi: 0x1e02a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e8d0, Hi: 0x1e8d6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e944, Hi: 0x1e94a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0020, Hi: 0xe007f, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0100, Hi: 0xe01ef, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeGlue_After_Zwj = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2764, Hi: 0x2764, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f48b, Hi: 0x1f48b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f5e8, Hi: 0x1f5e8, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeL = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x1100, Hi: 0x115f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa960, Hi: 0xa97c, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeLF = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xa, Hi: 0xa, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _GraphemeLV = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xac00, Hi: 0xac00, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1c, Hi: 0xac1c, Stride: 0x1},
+		unicode.Range16{Lo: 0xac38, Hi: 0xac38, Stride: 0x1},
+		unicode.Range16{Lo: 0xac54, Hi: 0xac54, Stride: 0x1},
+		unicode.Range16{Lo: 0xac70, Hi: 0xac70, Stride: 0x1},
+		unicode.Range16{Lo: 0xac8c, Hi: 0xac8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaca8, Hi: 0xaca8, Stride: 0x1},
+		unicode.Range16{Lo: 0xacc4, Hi: 0xacc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xace0, Hi: 0xace0, Stride: 0x1},
+		unicode.Range16{Lo: 0xacfc, Hi: 0xacfc, Stride: 0x1},
+		unicode.Range16{Lo: 0xad18, Hi: 0xad18, Stride: 0x1},
+		unicode.Range16{Lo: 0xad34, Hi: 0xad34, Stride: 0x1},
+		unicode.Range16{Lo: 0xad50, Hi: 0xad50, Stride: 0x1},
+		unicode.Range16{Lo: 0xad6c, Hi: 0xad6c, Stride: 0x1},
+		unicode.Range16{Lo: 0xad88, Hi: 0xad88, Stride: 0x1},
+		unicode.Range16{Lo: 0xada4, Hi: 0xada4, Stride: 0x1},
+		unicode.Range16{Lo: 0xadc0, Hi: 0xadc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaddc, Hi: 0xaddc, Stride: 0x1},
+		unicode.Range16{Lo: 0xadf8, Hi: 0xadf8, Stride: 0x1},
+		unicode.Range16{Lo: 0xae14, Hi: 0xae14, Stride: 0x1},
+		unicode.Range16{Lo: 0xae30, Hi: 0xae30, Stride: 0x1},
+		unicode.Range16{Lo: 0xae4c, Hi: 0xae4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xae68, Hi: 0xae68, Stride: 0x1},
+		unicode.Range16{Lo: 0xae84, Hi: 0xae84, Stride: 0x1},
+		unicode.Range16{Lo: 0xaea0, Hi: 0xaea0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaebc, Hi: 0xaebc, Stride: 0x1},
+		unicode.Range16{Lo: 0xaed8, Hi: 0xaed8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaef4, Hi: 0xaef4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf10, Hi: 0xaf10, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf2c, Hi: 0xaf2c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf48, Hi: 0xaf48, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf64, Hi: 0xaf64, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf80, Hi: 0xaf80, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf9c, Hi: 0xaf9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xafb8, Hi: 0xafb8, Stride: 0x1},
+		unicode.Range16{Lo: 0xafd4, Hi: 0xafd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaff0, Hi: 0xaff0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb00c, Hi: 0xb00c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb028, Hi: 0xb028, Stride: 0x1},
+		unicode.Range16{Lo: 0xb044, Hi: 0xb044, Stride: 0x1},
+		unicode.Range16{Lo: 0xb060, Hi: 0xb060, Stride: 0x1},
+		unicode.Range16{Lo: 0xb07c, Hi: 0xb07c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb098, Hi: 0xb098, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0b4, Hi: 0xb0b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0d0, Hi: 0xb0d0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0ec, Hi: 0xb0ec, Stride: 0x1},
+		unicode.Range16{Lo: 0xb108, Hi: 0xb108, Stride: 0x1},
+		unicode.Range16{Lo: 0xb124, Hi: 0xb124, Stride: 0x1},
+		unicode.Range16{Lo: 0xb140, Hi: 0xb140, Stride: 0x1},
+		unicode.Range16{Lo: 0xb15c, Hi: 0xb15c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb178, Hi: 0xb178, Stride: 0x1},
+		unicode.Range16{Lo: 0xb194, Hi: 0xb194, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1b0, Hi: 0xb1b0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1cc, Hi: 0xb1cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1e8, Hi: 0xb1e8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb204, Hi: 0xb204, Stride: 0x1},
+		unicode.Range16{Lo: 0xb220, Hi: 0xb220, Stride: 0x1},
+		unicode.Range16{Lo: 0xb23c, Hi: 0xb23c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb258, Hi: 0xb258, Stride: 0x1},
+		unicode.Range16{Lo: 0xb274, Hi: 0xb274, Stride: 0x1},
+		unicode.Range16{Lo: 0xb290, Hi: 0xb290, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2ac, Hi: 0xb2ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2c8, Hi: 0xb2c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2e4, Hi: 0xb2e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb300, Hi: 0xb300, Stride: 0x1},
+		unicode.Range16{Lo: 0xb31c, Hi: 0xb31c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb338, Hi: 0xb338, Stride: 0x1},
+		unicode.Range16{Lo: 0xb354, Hi: 0xb354, Stride: 0x1},
+		unicode.Range16{Lo: 0xb370, Hi: 0xb370, Stride: 0x1},
+		unicode.Range16{Lo: 0xb38c, Hi: 0xb38c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3a8, Hi: 0xb3a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c4, Hi: 0xb3c4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e0, Hi: 0xb3e0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3fc, Hi: 0xb3fc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb418, Hi: 0xb418, Stride: 0x1},
+		unicode.Range16{Lo: 0xb434, Hi: 0xb434, Stride: 0x1},
+		unicode.Range16{Lo: 0xb450, Hi: 0xb450, Stride: 0x1},
+		unicode.Range16{Lo: 0xb46c, Hi: 0xb46c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb488, Hi: 0xb488, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4a4, Hi: 0xb4a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4c0, Hi: 0xb4c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4dc, Hi: 0xb4dc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4f8, Hi: 0xb4f8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb514, Hi: 0xb514, Stride: 0x1},
+		unicode.Range16{Lo: 0xb530, Hi: 0xb530, Stride: 0x1},
+		unicode.Range16{Lo: 0xb54c, Hi: 0xb54c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb568, Hi: 0xb568, Stride: 0x1},
+		unicode.Range16{Lo: 0xb584, Hi: 0xb584, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5a0, Hi: 0xb5a0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5bc, Hi: 0xb5bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5d8, Hi: 0xb5d8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5f4, Hi: 0xb5f4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb610, Hi: 0xb610, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62c, Hi: 0xb62c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb648, Hi: 0xb648, Stride: 0x1},
+		unicode.Range16{Lo: 0xb664, Hi: 0xb664, Stride: 0x1},
+		unicode.Range16{Lo: 0xb680, Hi: 0xb680, Stride: 0x1},
+		unicode.Range16{Lo: 0xb69c, Hi: 0xb69c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6b8, Hi: 0xb6b8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6d4, Hi: 0xb6d4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6f0, Hi: 0xb6f0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb70c, Hi: 0xb70c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb728, Hi: 0xb728, Stride: 0x1},
+		unicode.Range16{Lo: 0xb744, Hi: 0xb744, Stride: 0x1},
+		unicode.Range16{Lo: 0xb760, Hi: 0xb760, Stride: 0x1},
+		unicode.Range16{Lo: 0xb77c, Hi: 0xb77c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb798, Hi: 0xb798, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7b4, Hi: 0xb7b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7d0, Hi: 0xb7d0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7ec, Hi: 0xb7ec, Stride: 0x1},
+		unicode.Range16{Lo: 0xb808, Hi: 0xb808, Stride: 0x1},
+		unicode.Range16{Lo: 0xb824, Hi: 0xb824, Stride: 0x1},
+		unicode.Range16{Lo: 0xb840, Hi: 0xb840, Stride: 0x1},
+		unicode.Range16{Lo: 0xb85c, Hi: 0xb85c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb878, Hi: 0xb878, Stride: 0x1},
+		unicode.Range16{Lo: 0xb894, Hi: 0xb894, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8b0, Hi: 0xb8b0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8cc, Hi: 0xb8cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8e8, Hi: 0xb8e8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb904, Hi: 0xb904, Stride: 0x1},
+		unicode.Range16{Lo: 0xb920, Hi: 0xb920, Stride: 0x1},
+		unicode.Range16{Lo: 0xb93c, Hi: 0xb93c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb958, Hi: 0xb958, Stride: 0x1},
+		unicode.Range16{Lo: 0xb974, Hi: 0xb974, Stride: 0x1},
+		unicode.Range16{Lo: 0xb990, Hi: 0xb990, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9ac, Hi: 0xb9ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9c8, Hi: 0xb9c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9e4, Hi: 0xb9e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xba00, Hi: 0xba00, Stride: 0x1},
+		unicode.Range16{Lo: 0xba1c, Hi: 0xba1c, Stride: 0x1},
+		unicode.Range16{Lo: 0xba38, Hi: 0xba38, Stride: 0x1},
+		unicode.Range16{Lo: 0xba54, Hi: 0xba54, Stride: 0x1},
+		unicode.Range16{Lo: 0xba70, Hi: 0xba70, Stride: 0x1},
+		unicode.Range16{Lo: 0xba8c, Hi: 0xba8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbaa8, Hi: 0xbaa8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbac4, Hi: 0xbac4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbae0, Hi: 0xbae0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbafc, Hi: 0xbafc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb18, Hi: 0xbb18, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb34, Hi: 0xbb34, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb50, Hi: 0xbb50, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb6c, Hi: 0xbb6c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb88, Hi: 0xbb88, Stride: 0x1},
+		unicode.Range16{Lo: 0xbba4, Hi: 0xbba4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbc0, Hi: 0xbbc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbdc, Hi: 0xbbdc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbf8, Hi: 0xbbf8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc14, Hi: 0xbc14, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc30, Hi: 0xbc30, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc4c, Hi: 0xbc4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc68, Hi: 0xbc68, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc84, Hi: 0xbc84, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca0, Hi: 0xbca0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcbc, Hi: 0xbcbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd8, Hi: 0xbcd8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcf4, Hi: 0xbcf4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd10, Hi: 0xbd10, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd2c, Hi: 0xbd2c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd48, Hi: 0xbd48, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd64, Hi: 0xbd64, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd80, Hi: 0xbd80, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd9c, Hi: 0xbd9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdb8, Hi: 0xbdb8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdd4, Hi: 0xbdd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdf0, Hi: 0xbdf0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe0c, Hi: 0xbe0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe28, Hi: 0xbe28, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe44, Hi: 0xbe44, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe60, Hi: 0xbe60, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe7c, Hi: 0xbe7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe98, Hi: 0xbe98, Stride: 0x1},
+		unicode.Range16{Lo: 0xbeb4, Hi: 0xbeb4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbed0, Hi: 0xbed0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbeec, Hi: 0xbeec, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf08, Hi: 0xbf08, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf24, Hi: 0xbf24, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf40, Hi: 0xbf40, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf5c, Hi: 0xbf5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf78, Hi: 0xbf78, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf94, Hi: 0xbf94, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfb0, Hi: 0xbfb0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfcc, Hi: 0xbfcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfe8, Hi: 0xbfe8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc004, Hi: 0xc004, Stride: 0x1},
+		unicode.Range16{Lo: 0xc020, Hi: 0xc020, Stride: 0x1},
+		unicode.Range16{Lo: 0xc03c, Hi: 0xc03c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc058, Hi: 0xc058, Stride: 0x1},
+		unicode.Range16{Lo: 0xc074, Hi: 0xc074, Stride: 0x1},
+		unicode.Range16{Lo: 0xc090, Hi: 0xc090, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0ac, Hi: 0xc0ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0c8, Hi: 0xc0c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0e4, Hi: 0xc0e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc100, Hi: 0xc100, Stride: 0x1},
+		unicode.Range16{Lo: 0xc11c, Hi: 0xc11c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc138, Hi: 0xc138, Stride: 0x1},
+		unicode.Range16{Lo: 0xc154, Hi: 0xc154, Stride: 0x1},
+		unicode.Range16{Lo: 0xc170, Hi: 0xc170, Stride: 0x1},
+		unicode.Range16{Lo: 0xc18c, Hi: 0xc18c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1a8, Hi: 0xc1a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1c4, Hi: 0xc1c4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1e0, Hi: 0xc1e0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1fc, Hi: 0xc1fc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc218, Hi: 0xc218, Stride: 0x1},
+		unicode.Range16{Lo: 0xc234, Hi: 0xc234, Stride: 0x1},
+		unicode.Range16{Lo: 0xc250, Hi: 0xc250, Stride: 0x1},
+		unicode.Range16{Lo: 0xc26c, Hi: 0xc26c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc288, Hi: 0xc288, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2a4, Hi: 0xc2a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2c0, Hi: 0xc2c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2dc, Hi: 0xc2dc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2f8, Hi: 0xc2f8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc314, Hi: 0xc314, Stride: 0x1},
+		unicode.Range16{Lo: 0xc330, Hi: 0xc330, Stride: 0x1},
+		unicode.Range16{Lo: 0xc34c, Hi: 0xc34c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc368, Hi: 0xc368, Stride: 0x1},
+		unicode.Range16{Lo: 0xc384, Hi: 0xc384, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3a0, Hi: 0xc3a0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3bc, Hi: 0xc3bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3d8, Hi: 0xc3d8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3f4, Hi: 0xc3f4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc410, Hi: 0xc410, Stride: 0x1},
+		unicode.Range16{Lo: 0xc42c, Hi: 0xc42c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc448, Hi: 0xc448, Stride: 0x1},
+		unicode.Range16{Lo: 0xc464, Hi: 0xc464, Stride: 0x1},
+		unicode.Range16{Lo: 0xc480, Hi: 0xc480, Stride: 0x1},
+		unicode.Range16{Lo: 0xc49c, Hi: 0xc49c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4b8, Hi: 0xc4b8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4d4, Hi: 0xc4d4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4f0, Hi: 0xc4f0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc50c, Hi: 0xc50c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc528, Hi: 0xc528, Stride: 0x1},
+		unicode.Range16{Lo: 0xc544, Hi: 0xc544, Stride: 0x1},
+		unicode.Range16{Lo: 0xc560, Hi: 0xc560, Stride: 0x1},
+		unicode.Range16{Lo: 0xc57c, Hi: 0xc57c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc598, Hi: 0xc598, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5b4, Hi: 0xc5b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5d0, Hi: 0xc5d0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5ec, Hi: 0xc5ec, Stride: 0x1},
+		unicode.Range16{Lo: 0xc608, Hi: 0xc608, Stride: 0x1},
+		unicode.Range16{Lo: 0xc624, Hi: 0xc624, Stride: 0x1},
+		unicode.Range16{Lo: 0xc640, Hi: 0xc640, Stride: 0x1},
+		unicode.Range16{Lo: 0xc65c, Hi: 0xc65c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc678, Hi: 0xc678, Stride: 0x1},
+		unicode.Range16{Lo: 0xc694, Hi: 0xc694, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6b0, Hi: 0xc6b0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6cc, Hi: 0xc6cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6e8, Hi: 0xc6e8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc704, Hi: 0xc704, Stride: 0x1},
+		unicode.Range16{Lo: 0xc720, Hi: 0xc720, Stride: 0x1},
+		unicode.Range16{Lo: 0xc73c, Hi: 0xc73c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc758, Hi: 0xc758, Stride: 0x1},
+		unicode.Range16{Lo: 0xc774, Hi: 0xc774, Stride: 0x1},
+		unicode.Range16{Lo: 0xc790, Hi: 0xc790, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7ac, Hi: 0xc7ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7c8, Hi: 0xc7c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7e4, Hi: 0xc7e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc800, Hi: 0xc800, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81c, Hi: 0xc81c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc838, Hi: 0xc838, Stride: 0x1},
+		unicode.Range16{Lo: 0xc854, Hi: 0xc854, Stride: 0x1},
+		unicode.Range16{Lo: 0xc870, Hi: 0xc870, Stride: 0x1},
+		unicode.Range16{Lo: 0xc88c, Hi: 0xc88c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8a8, Hi: 0xc8a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8c4, Hi: 0xc8c4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8e0, Hi: 0xc8e0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8fc, Hi: 0xc8fc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc918, Hi: 0xc918, Stride: 0x1},
+		unicode.Range16{Lo: 0xc934, Hi: 0xc934, Stride: 0x1},
+		unicode.Range16{Lo: 0xc950, Hi: 0xc950, Stride: 0x1},
+		unicode.Range16{Lo: 0xc96c, Hi: 0xc96c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc988, Hi: 0xc988, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9a4, Hi: 0xc9a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9c0, Hi: 0xc9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9dc, Hi: 0xc9dc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9f8, Hi: 0xc9f8, Stride: 0x1},
+		unicode.Range16{Lo: 0xca14, Hi: 0xca14, Stride: 0x1},
+		unicode.Range16{Lo: 0xca30, Hi: 0xca30, Stride: 0x1},
+		unicode.Range16{Lo: 0xca4c, Hi: 0xca4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xca68, Hi: 0xca68, Stride: 0x1},
+		unicode.Range16{Lo: 0xca84, Hi: 0xca84, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaa0, Hi: 0xcaa0, Stride: 0x1},
+		unicode.Range16{Lo: 0xcabc, Hi: 0xcabc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcad8, Hi: 0xcad8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaf4, Hi: 0xcaf4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb10, Hi: 0xcb10, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb2c, Hi: 0xcb2c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb48, Hi: 0xcb48, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb64, Hi: 0xcb64, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb80, Hi: 0xcb80, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb9c, Hi: 0xcb9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbb8, Hi: 0xcbb8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbd4, Hi: 0xcbd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf0, Hi: 0xcbf0, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0c, Hi: 0xcc0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc28, Hi: 0xcc28, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc44, Hi: 0xcc44, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc60, Hi: 0xcc60, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7c, Hi: 0xcc7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc98, Hi: 0xcc98, Stride: 0x1},
+		unicode.Range16{Lo: 0xccb4, Hi: 0xccb4, Stride: 0x1},
+		unicode.Range16{Lo: 0xccd0, Hi: 0xccd0, Stride: 0x1},
+		unicode.Range16{Lo: 0xccec, Hi: 0xccec, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd08, Hi: 0xcd08, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd24, Hi: 0xcd24, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd40, Hi: 0xcd40, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5c, Hi: 0xcd5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd78, Hi: 0xcd78, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd94, Hi: 0xcd94, Stride: 0x1},
+		unicode.Range16{Lo: 0xcdb0, Hi: 0xcdb0, Stride: 0x1},
+		unicode.Range16{Lo: 0xcdcc, Hi: 0xcdcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcde8, Hi: 0xcde8, Stride: 0x1},
+		unicode.Range16{Lo: 0xce04, Hi: 0xce04, Stride: 0x1},
+		unicode.Range16{Lo: 0xce20, Hi: 0xce20, Stride: 0x1},
+		unicode.Range16{Lo: 0xce3c, Hi: 0xce3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xce58, Hi: 0xce58, Stride: 0x1},
+		unicode.Range16{Lo: 0xce74, Hi: 0xce74, Stride: 0x1},
+		unicode.Range16{Lo: 0xce90, Hi: 0xce90, Stride: 0x1},
+		unicode.Range16{Lo: 0xceac, Hi: 0xceac, Stride: 0x1},
+		unicode.Range16{Lo: 0xcec8, Hi: 0xcec8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcee4, Hi: 0xcee4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf00, Hi: 0xcf00, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf1c, Hi: 0xcf1c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf38, Hi: 0xcf38, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf54, Hi: 0xcf54, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf70, Hi: 0xcf70, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf8c, Hi: 0xcf8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfa8, Hi: 0xcfa8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfc4, Hi: 0xcfc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfe0, Hi: 0xcfe0, Stride: 0x1},
+		unicode.Range16{Lo: 0xcffc, Hi: 0xcffc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd018, Hi: 0xd018, Stride: 0x1},
+		unicode.Range16{Lo: 0xd034, Hi: 0xd034, Stride: 0x1},
+		unicode.Range16{Lo: 0xd050, Hi: 0xd050, Stride: 0x1},
+		unicode.Range16{Lo: 0xd06c, Hi: 0xd06c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd088, Hi: 0xd088, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0a4, Hi: 0xd0a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0c0, Hi: 0xd0c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0dc, Hi: 0xd0dc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0f8, Hi: 0xd0f8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd114, Hi: 0xd114, Stride: 0x1},
+		unicode.Range16{Lo: 0xd130, Hi: 0xd130, Stride: 0x1},
+		unicode.Range16{Lo: 0xd14c, Hi: 0xd14c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd168, Hi: 0xd168, Stride: 0x1},
+		unicode.Range16{Lo: 0xd184, Hi: 0xd184, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1a0, Hi: 0xd1a0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1bc, Hi: 0xd1bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1d8, Hi: 0xd1d8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1f4, Hi: 0xd1f4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd210, Hi: 0xd210, Stride: 0x1},
+		unicode.Range16{Lo: 0xd22c, Hi: 0xd22c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd248, Hi: 0xd248, Stride: 0x1},
+		unicode.Range16{Lo: 0xd264, Hi: 0xd264, Stride: 0x1},
+		unicode.Range16{Lo: 0xd280, Hi: 0xd280, Stride: 0x1},
+		unicode.Range16{Lo: 0xd29c, Hi: 0xd29c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2b8, Hi: 0xd2b8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2d4, Hi: 0xd2d4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2f0, Hi: 0xd2f0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd30c, Hi: 0xd30c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd328, Hi: 0xd328, Stride: 0x1},
+		unicode.Range16{Lo: 0xd344, Hi: 0xd344, Stride: 0x1},
+		unicode.Range16{Lo: 0xd360, Hi: 0xd360, Stride: 0x1},
+		unicode.Range16{Lo: 0xd37c, Hi: 0xd37c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd398, Hi: 0xd398, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3b4, Hi: 0xd3b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3d0, Hi: 0xd3d0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3ec, Hi: 0xd3ec, Stride: 0x1},
+		unicode.Range16{Lo: 0xd408, Hi: 0xd408, Stride: 0x1},
+		unicode.Range16{Lo: 0xd424, Hi: 0xd424, Stride: 0x1},
+		unicode.Range16{Lo: 0xd440, Hi: 0xd440, Stride: 0x1},
+		unicode.Range16{Lo: 0xd45c, Hi: 0xd45c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd478, Hi: 0xd478, Stride: 0x1},
+		unicode.Range16{Lo: 0xd494, Hi: 0xd494, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4b0, Hi: 0xd4b0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4cc, Hi: 0xd4cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e8, Hi: 0xd4e8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd504, Hi: 0xd504, Stride: 0x1},
+		unicode.Range16{Lo: 0xd520, Hi: 0xd520, Stride: 0x1},
+		unicode.Range16{Lo: 0xd53c, Hi: 0xd53c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd558, Hi: 0xd558, Stride: 0x1},
+		unicode.Range16{Lo: 0xd574, Hi: 0xd574, Stride: 0x1},
+		unicode.Range16{Lo: 0xd590, Hi: 0xd590, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5ac, Hi: 0xd5ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5c8, Hi: 0xd5c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5e4, Hi: 0xd5e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd600, Hi: 0xd600, Stride: 0x1},
+		unicode.Range16{Lo: 0xd61c, Hi: 0xd61c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd638, Hi: 0xd638, Stride: 0x1},
+		unicode.Range16{Lo: 0xd654, Hi: 0xd654, Stride: 0x1},
+		unicode.Range16{Lo: 0xd670, Hi: 0xd670, Stride: 0x1},
+		unicode.Range16{Lo: 0xd68c, Hi: 0xd68c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6a8, Hi: 0xd6a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6c4, Hi: 0xd6c4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6e0, Hi: 0xd6e0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6fc, Hi: 0xd6fc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd718, Hi: 0xd718, Stride: 0x1},
+		unicode.Range16{Lo: 0xd734, Hi: 0xd734, Stride: 0x1},
+		unicode.Range16{Lo: 0xd750, Hi: 0xd750, Stride: 0x1},
+		unicode.Range16{Lo: 0xd76c, Hi: 0xd76c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd788, Hi: 0xd788, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeLVT = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xac01, Hi: 0xac1b, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1d, Hi: 0xac37, Stride: 0x1},
+		unicode.Range16{Lo: 0xac39, Hi: 0xac53, Stride: 0x1},
+		unicode.Range16{Lo: 0xac55, Hi: 0xac6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xac71, Hi: 0xac8b, Stride: 0x1},
+		unicode.Range16{Lo: 0xac8d, Hi: 0xaca7, Stride: 0x1},
+		unicode.Range16{Lo: 0xaca9, Hi: 0xacc3, Stride: 0x1},
+		unicode.Range16{Lo: 0xacc5, Hi: 0xacdf, Stride: 0x1},
+		unicode.Range16{Lo: 0xace1, Hi: 0xacfb, Stride: 0x1},
+		unicode.Range16{Lo: 0xacfd, Hi: 0xad17, Stride: 0x1},
+		unicode.Range16{Lo: 0xad19, Hi: 0xad33, Stride: 0x1},
+		unicode.Range16{Lo: 0xad35, Hi: 0xad4f, Stride: 0x1},
+		unicode.Range16{Lo: 0xad51, Hi: 0xad6b, Stride: 0x1},
+		unicode.Range16{Lo: 0xad6d, Hi: 0xad87, Stride: 0x1},
+		unicode.Range16{Lo: 0xad89, Hi: 0xada3, Stride: 0x1},
+		unicode.Range16{Lo: 0xada5, Hi: 0xadbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xadc1, Hi: 0xaddb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaddd, Hi: 0xadf7, Stride: 0x1},
+		unicode.Range16{Lo: 0xadf9, Hi: 0xae13, Stride: 0x1},
+		unicode.Range16{Lo: 0xae15, Hi: 0xae2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xae31, Hi: 0xae4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xae4d, Hi: 0xae67, Stride: 0x1},
+		unicode.Range16{Lo: 0xae69, Hi: 0xae83, Stride: 0x1},
+		unicode.Range16{Lo: 0xae85, Hi: 0xae9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaea1, Hi: 0xaebb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaebd, Hi: 0xaed7, Stride: 0x1},
+		unicode.Range16{Lo: 0xaed9, Hi: 0xaef3, Stride: 0x1},
+		unicode.Range16{Lo: 0xaef5, Hi: 0xaf0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf11, Hi: 0xaf2b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf2d, Hi: 0xaf47, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf49, Hi: 0xaf63, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf65, Hi: 0xaf7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf81, Hi: 0xaf9b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf9d, Hi: 0xafb7, Stride: 0x1},
+		unicode.Range16{Lo: 0xafb9, Hi: 0xafd3, Stride: 0x1},
+		unicode.Range16{Lo: 0xafd5, Hi: 0xafef, Stride: 0x1},
+		unicode.Range16{Lo: 0xaff1, Hi: 0xb00b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb00d, Hi: 0xb027, Stride: 0x1},
+		unicode.Range16{Lo: 0xb029, Hi: 0xb043, Stride: 0x1},
+		unicode.Range16{Lo: 0xb045, Hi: 0xb05f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb061, Hi: 0xb07b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb07d, Hi: 0xb097, Stride: 0x1},
+		unicode.Range16{Lo: 0xb099, Hi: 0xb0b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0b5, Hi: 0xb0cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0d1, Hi: 0xb0eb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0ed, Hi: 0xb107, Stride: 0x1},
+		unicode.Range16{Lo: 0xb109, Hi: 0xb123, Stride: 0x1},
+		unicode.Range16{Lo: 0xb125, Hi: 0xb13f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb141, Hi: 0xb15b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb15d, Hi: 0xb177, Stride: 0x1},
+		unicode.Range16{Lo: 0xb179, Hi: 0xb193, Stride: 0x1},
+		unicode.Range16{Lo: 0xb195, Hi: 0xb1af, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1b1, Hi: 0xb1cb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1cd, Hi: 0xb1e7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1e9, Hi: 0xb203, Stride: 0x1},
+		unicode.Range16{Lo: 0xb205, Hi: 0xb21f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb221, Hi: 0xb23b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb23d, Hi: 0xb257, Stride: 0x1},
+		unicode.Range16{Lo: 0xb259, Hi: 0xb273, Stride: 0x1},
+		unicode.Range16{Lo: 0xb275, Hi: 0xb28f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb291, Hi: 0xb2ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2ad, Hi: 0xb2c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2c9, Hi: 0xb2e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2e5, Hi: 0xb2ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xb301, Hi: 0xb31b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb31d, Hi: 0xb337, Stride: 0x1},
+		unicode.Range16{Lo: 0xb339, Hi: 0xb353, Stride: 0x1},
+		unicode.Range16{Lo: 0xb355, Hi: 0xb36f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb371, Hi: 0xb38b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb38d, Hi: 0xb3a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3a9, Hi: 0xb3c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c5, Hi: 0xb3df, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e1, Hi: 0xb3fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3fd, Hi: 0xb417, Stride: 0x1},
+		unicode.Range16{Lo: 0xb419, Hi: 0xb433, Stride: 0x1},
+		unicode.Range16{Lo: 0xb435, Hi: 0xb44f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb451, Hi: 0xb46b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb46d, Hi: 0xb487, Stride: 0x1},
+		unicode.Range16{Lo: 0xb489, Hi: 0xb4a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4a5, Hi: 0xb4bf, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4c1, Hi: 0xb4db, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4dd, Hi: 0xb4f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4f9, Hi: 0xb513, Stride: 0x1},
+		unicode.Range16{Lo: 0xb515, Hi: 0xb52f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb531, Hi: 0xb54b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb54d, Hi: 0xb567, Stride: 0x1},
+		unicode.Range16{Lo: 0xb569, Hi: 0xb583, Stride: 0x1},
+		unicode.Range16{Lo: 0xb585, Hi: 0xb59f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5a1, Hi: 0xb5bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5bd, Hi: 0xb5d7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5d9, Hi: 0xb5f3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5f5, Hi: 0xb60f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb611, Hi: 0xb62b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62d, Hi: 0xb647, Stride: 0x1},
+		unicode.Range16{Lo: 0xb649, Hi: 0xb663, Stride: 0x1},
+		unicode.Range16{Lo: 0xb665, Hi: 0xb67f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb681, Hi: 0xb69b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb69d, Hi: 0xb6b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6b9, Hi: 0xb6d3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6d5, Hi: 0xb6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6f1, Hi: 0xb70b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb70d, Hi: 0xb727, Stride: 0x1},
+		unicode.Range16{Lo: 0xb729, Hi: 0xb743, Stride: 0x1},
+		unicode.Range16{Lo: 0xb745, Hi: 0xb75f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb761, Hi: 0xb77b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb77d, Hi: 0xb797, Stride: 0x1},
+		unicode.Range16{Lo: 0xb799, Hi: 0xb7b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7b5, Hi: 0xb7cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7d1, Hi: 0xb7eb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7ed, Hi: 0xb807, Stride: 0x1},
+		unicode.Range16{Lo: 0xb809, Hi: 0xb823, Stride: 0x1},
+		unicode.Range16{Lo: 0xb825, Hi: 0xb83f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb841, Hi: 0xb85b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb85d, Hi: 0xb877, Stride: 0x1},
+		unicode.Range16{Lo: 0xb879, Hi: 0xb893, Stride: 0x1},
+		unicode.Range16{Lo: 0xb895, Hi: 0xb8af, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8b1, Hi: 0xb8cb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8cd, Hi: 0xb8e7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8e9, Hi: 0xb903, Stride: 0x1},
+		unicode.Range16{Lo: 0xb905, Hi: 0xb91f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb921, Hi: 0xb93b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb93d, Hi: 0xb957, Stride: 0x1},
+		unicode.Range16{Lo: 0xb959, Hi: 0xb973, Stride: 0x1},
+		unicode.Range16{Lo: 0xb975, Hi: 0xb98f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb991, Hi: 0xb9ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9ad, Hi: 0xb9c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9c9, Hi: 0xb9e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9e5, Hi: 0xb9ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xba01, Hi: 0xba1b, Stride: 0x1},
+		unicode.Range16{Lo: 0xba1d, Hi: 0xba37, Stride: 0x1},
+		unicode.Range16{Lo: 0xba39, Hi: 0xba53, Stride: 0x1},
+		unicode.Range16{Lo: 0xba55, Hi: 0xba6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xba71, Hi: 0xba8b, Stride: 0x1},
+		unicode.Range16{Lo: 0xba8d, Hi: 0xbaa7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbaa9, Hi: 0xbac3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbac5, Hi: 0xbadf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbae1, Hi: 0xbafb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbafd, Hi: 0xbb17, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb19, Hi: 0xbb33, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb35, Hi: 0xbb4f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb51, Hi: 0xbb6b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb6d, Hi: 0xbb87, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb89, Hi: 0xbba3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbba5, Hi: 0xbbbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbc1, Hi: 0xbbdb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbdd, Hi: 0xbbf7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbf9, Hi: 0xbc13, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc15, Hi: 0xbc2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc31, Hi: 0xbc4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc4d, Hi: 0xbc67, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc69, Hi: 0xbc83, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc85, Hi: 0xbc9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca1, Hi: 0xbcbb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcbd, Hi: 0xbcd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd9, Hi: 0xbcf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcf5, Hi: 0xbd0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd11, Hi: 0xbd2b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd2d, Hi: 0xbd47, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd49, Hi: 0xbd63, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd65, Hi: 0xbd7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd81, Hi: 0xbd9b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd9d, Hi: 0xbdb7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdb9, Hi: 0xbdd3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdd5, Hi: 0xbdef, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdf1, Hi: 0xbe0b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe0d, Hi: 0xbe27, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe29, Hi: 0xbe43, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe45, Hi: 0xbe5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe61, Hi: 0xbe7b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe7d, Hi: 0xbe97, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe99, Hi: 0xbeb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbeb5, Hi: 0xbecf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbed1, Hi: 0xbeeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbeed, Hi: 0xbf07, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf09, Hi: 0xbf23, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf25, Hi: 0xbf3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf41, Hi: 0xbf5b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf5d, Hi: 0xbf77, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf79, Hi: 0xbf93, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf95, Hi: 0xbfaf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfb1, Hi: 0xbfcb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfcd, Hi: 0xbfe7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfe9, Hi: 0xc003, Stride: 0x1},
+		unicode.Range16{Lo: 0xc005, Hi: 0xc01f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc021, Hi: 0xc03b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc03d, Hi: 0xc057, Stride: 0x1},
+		unicode.Range16{Lo: 0xc059, Hi: 0xc073, Stride: 0x1},
+		unicode.Range16{Lo: 0xc075, Hi: 0xc08f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc091, Hi: 0xc0ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0ad, Hi: 0xc0c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0c9, Hi: 0xc0e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0e5, Hi: 0xc0ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xc101, Hi: 0xc11b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc11d, Hi: 0xc137, Stride: 0x1},
+		unicode.Range16{Lo: 0xc139, Hi: 0xc153, Stride: 0x1},
+		unicode.Range16{Lo: 0xc155, Hi: 0xc16f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc171, Hi: 0xc18b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc18d, Hi: 0xc1a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1a9, Hi: 0xc1c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1c5, Hi: 0xc1df, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1e1, Hi: 0xc1fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1fd, Hi: 0xc217, Stride: 0x1},
+		unicode.Range16{Lo: 0xc219, Hi: 0xc233, Stride: 0x1},
+		unicode.Range16{Lo: 0xc235, Hi: 0xc24f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc251, Hi: 0xc26b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc26d, Hi: 0xc287, Stride: 0x1},
+		unicode.Range16{Lo: 0xc289, Hi: 0xc2a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2a5, Hi: 0xc2bf, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2c1, Hi: 0xc2db, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2dd, Hi: 0xc2f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2f9, Hi: 0xc313, Stride: 0x1},
+		unicode.Range16{Lo: 0xc315, Hi: 0xc32f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc331, Hi: 0xc34b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc34d, Hi: 0xc367, Stride: 0x1},
+		unicode.Range16{Lo: 0xc369, Hi: 0xc383, Stride: 0x1},
+		unicode.Range16{Lo: 0xc385, Hi: 0xc39f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3a1, Hi: 0xc3bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3bd, Hi: 0xc3d7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3d9, Hi: 0xc3f3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3f5, Hi: 0xc40f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc411, Hi: 0xc42b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc42d, Hi: 0xc447, Stride: 0x1},
+		unicode.Range16{Lo: 0xc449, Hi: 0xc463, Stride: 0x1},
+		unicode.Range16{Lo: 0xc465, Hi: 0xc47f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc481, Hi: 0xc49b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc49d, Hi: 0xc4b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4b9, Hi: 0xc4d3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4d5, Hi: 0xc4ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4f1, Hi: 0xc50b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc50d, Hi: 0xc527, Stride: 0x1},
+		unicode.Range16{Lo: 0xc529, Hi: 0xc543, Stride: 0x1},
+		unicode.Range16{Lo: 0xc545, Hi: 0xc55f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc561, Hi: 0xc57b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc57d, Hi: 0xc597, Stride: 0x1},
+		unicode.Range16{Lo: 0xc599, Hi: 0xc5b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5b5, Hi: 0xc5cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5d1, Hi: 0xc5eb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5ed, Hi: 0xc607, Stride: 0x1},
+		unicode.Range16{Lo: 0xc609, Hi: 0xc623, Stride: 0x1},
+		unicode.Range16{Lo: 0xc625, Hi: 0xc63f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc641, Hi: 0xc65b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc65d, Hi: 0xc677, Stride: 0x1},
+		unicode.Range16{Lo: 0xc679, Hi: 0xc693, Stride: 0x1},
+		unicode.Range16{Lo: 0xc695, Hi: 0xc6af, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6b1, Hi: 0xc6cb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6cd, Hi: 0xc6e7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6e9, Hi: 0xc703, Stride: 0x1},
+		unicode.Range16{Lo: 0xc705, Hi: 0xc71f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc721, Hi: 0xc73b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc73d, Hi: 0xc757, Stride: 0x1},
+		unicode.Range16{Lo: 0xc759, Hi: 0xc773, Stride: 0x1},
+		unicode.Range16{Lo: 0xc775, Hi: 0xc78f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc791, Hi: 0xc7ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7ad, Hi: 0xc7c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7c9, Hi: 0xc7e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7e5, Hi: 0xc7ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xc801, Hi: 0xc81b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81d, Hi: 0xc837, Stride: 0x1},
+		unicode.Range16{Lo: 0xc839, Hi: 0xc853, Stride: 0x1},
+		unicode.Range16{Lo: 0xc855, Hi: 0xc86f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc871, Hi: 0xc88b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc88d, Hi: 0xc8a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8a9, Hi: 0xc8c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8c5, Hi: 0xc8df, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8e1, Hi: 0xc8fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8fd, Hi: 0xc917, Stride: 0x1},
+		unicode.Range16{Lo: 0xc919, Hi: 0xc933, Stride: 0x1},
+		unicode.Range16{Lo: 0xc935, Hi: 0xc94f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc951, Hi: 0xc96b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc96d, Hi: 0xc987, Stride: 0x1},
+		unicode.Range16{Lo: 0xc989, Hi: 0xc9a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9a5, Hi: 0xc9bf, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9c1, Hi: 0xc9db, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9dd, Hi: 0xc9f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9f9, Hi: 0xca13, Stride: 0x1},
+		unicode.Range16{Lo: 0xca15, Hi: 0xca2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xca31, Hi: 0xca4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xca4d, Hi: 0xca67, Stride: 0x1},
+		unicode.Range16{Lo: 0xca69, Hi: 0xca83, Stride: 0x1},
+		unicode.Range16{Lo: 0xca85, Hi: 0xca9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaa1, Hi: 0xcabb, Stride: 0x1},
+		unicode.Range16{Lo: 0xcabd, Hi: 0xcad7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcad9, Hi: 0xcaf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaf5, Hi: 0xcb0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb11, Hi: 0xcb2b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb2d, Hi: 0xcb47, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb49, Hi: 0xcb63, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb65, Hi: 0xcb7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb81, Hi: 0xcb9b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb9d, Hi: 0xcbb7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbb9, Hi: 0xcbd3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbd5, Hi: 0xcbef, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf1, Hi: 0xcc0b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0d, Hi: 0xcc27, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc29, Hi: 0xcc43, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc45, Hi: 0xcc5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc61, Hi: 0xcc7b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7d, Hi: 0xcc97, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc99, Hi: 0xccb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xccb5, Hi: 0xcccf, Stride: 0x1},
+		unicode.Range16{Lo: 0xccd1, Hi: 0xcceb, Stride: 0x1},
+		unicode.Range16{Lo: 0xcced, Hi: 0xcd07, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd09, Hi: 0xcd23, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd25, Hi: 0xcd3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd41, Hi: 0xcd5b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5d, Hi: 0xcd77, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd79, Hi: 0xcd93, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd95, Hi: 0xcdaf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcdb1, Hi: 0xcdcb, Stride: 0x1},
+		unicode.Range16{Lo: 0xcdcd, Hi: 0xcde7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcde9, Hi: 0xce03, Stride: 0x1},
+		unicode.Range16{Lo: 0xce05, Hi: 0xce1f, Stride: 0x1},
+		unicode.Range16{Lo: 0xce21, Hi: 0xce3b, Stride: 0x1},
+		unicode.Range16{Lo: 0xce3d, Hi: 0xce57, Stride: 0x1},
+		unicode.Range16{Lo: 0xce59, Hi: 0xce73, Stride: 0x1},
+		unicode.Range16{Lo: 0xce75, Hi: 0xce8f, Stride: 0x1},
+		unicode.Range16{Lo: 0xce91, Hi: 0xceab, Stride: 0x1},
+		unicode.Range16{Lo: 0xcead, Hi: 0xcec7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcec9, Hi: 0xcee3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcee5, Hi: 0xceff, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf01, Hi: 0xcf1b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf1d, Hi: 0xcf37, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf39, Hi: 0xcf53, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf55, Hi: 0xcf6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf71, Hi: 0xcf8b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf8d, Hi: 0xcfa7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfa9, Hi: 0xcfc3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfc5, Hi: 0xcfdf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfe1, Hi: 0xcffb, Stride: 0x1},
+		unicode.Range16{Lo: 0xcffd, Hi: 0xd017, Stride: 0x1},
+		unicode.Range16{Lo: 0xd019, Hi: 0xd033, Stride: 0x1},
+		unicode.Range16{Lo: 0xd035, Hi: 0xd04f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd051, Hi: 0xd06b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd06d, Hi: 0xd087, Stride: 0x1},
+		unicode.Range16{Lo: 0xd089, Hi: 0xd0a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0a5, Hi: 0xd0bf, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0c1, Hi: 0xd0db, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0dd, Hi: 0xd0f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0f9, Hi: 0xd113, Stride: 0x1},
+		unicode.Range16{Lo: 0xd115, Hi: 0xd12f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd131, Hi: 0xd14b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd14d, Hi: 0xd167, Stride: 0x1},
+		unicode.Range16{Lo: 0xd169, Hi: 0xd183, Stride: 0x1},
+		unicode.Range16{Lo: 0xd185, Hi: 0xd19f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1a1, Hi: 0xd1bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1bd, Hi: 0xd1d7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1d9, Hi: 0xd1f3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1f5, Hi: 0xd20f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd211, Hi: 0xd22b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd22d, Hi: 0xd247, Stride: 0x1},
+		unicode.Range16{Lo: 0xd249, Hi: 0xd263, Stride: 0x1},
+		unicode.Range16{Lo: 0xd265, Hi: 0xd27f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd281, Hi: 0xd29b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd29d, Hi: 0xd2b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2b9, Hi: 0xd2d3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2d5, Hi: 0xd2ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2f1, Hi: 0xd30b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd30d, Hi: 0xd327, Stride: 0x1},
+		unicode.Range16{Lo: 0xd329, Hi: 0xd343, Stride: 0x1},
+		unicode.Range16{Lo: 0xd345, Hi: 0xd35f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd361, Hi: 0xd37b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd37d, Hi: 0xd397, Stride: 0x1},
+		unicode.Range16{Lo: 0xd399, Hi: 0xd3b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3b5, Hi: 0xd3cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3d1, Hi: 0xd3eb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3ed, Hi: 0xd407, Stride: 0x1},
+		unicode.Range16{Lo: 0xd409, Hi: 0xd423, Stride: 0x1},
+		unicode.Range16{Lo: 0xd425, Hi: 0xd43f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd441, Hi: 0xd45b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd45d, Hi: 0xd477, Stride: 0x1},
+		unicode.Range16{Lo: 0xd479, Hi: 0xd493, Stride: 0x1},
+		unicode.Range16{Lo: 0xd495, Hi: 0xd4af, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4b1, Hi: 0xd4cb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4cd, Hi: 0xd4e7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e9, Hi: 0xd503, Stride: 0x1},
+		unicode.Range16{Lo: 0xd505, Hi: 0xd51f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd521, Hi: 0xd53b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd53d, Hi: 0xd557, Stride: 0x1},
+		unicode.Range16{Lo: 0xd559, Hi: 0xd573, Stride: 0x1},
+		unicode.Range16{Lo: 0xd575, Hi: 0xd58f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd591, Hi: 0xd5ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5ad, Hi: 0xd5c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5c9, Hi: 0xd5e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5e5, Hi: 0xd5ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xd601, Hi: 0xd61b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd61d, Hi: 0xd637, Stride: 0x1},
+		unicode.Range16{Lo: 0xd639, Hi: 0xd653, Stride: 0x1},
+		unicode.Range16{Lo: 0xd655, Hi: 0xd66f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd671, Hi: 0xd68b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd68d, Hi: 0xd6a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6a9, Hi: 0xd6c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6c5, Hi: 0xd6df, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6e1, Hi: 0xd6fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6fd, Hi: 0xd717, Stride: 0x1},
+		unicode.Range16{Lo: 0xd719, Hi: 0xd733, Stride: 0x1},
+		unicode.Range16{Lo: 0xd735, Hi: 0xd74f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd751, Hi: 0xd76b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd76d, Hi: 0xd787, Stride: 0x1},
+		unicode.Range16{Lo: 0xd789, Hi: 0xd7a3, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemePrepend = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x600, Hi: 0x605, Stride: 0x1},
+		unicode.Range16{Lo: 0x6dd, Hi: 0x6dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x70f, Hi: 0x70f, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e2, Hi: 0x8e2, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e, Hi: 0xd4e, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x110bd, Hi: 0x110bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x111c2, Hi: 0x111c3, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeRegional_Indicator = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f1e6, Hi: 0x1f1ff, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeSpacingMark = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x903, Hi: 0x903, Stride: 0x1},
+		unicode.Range16{Lo: 0x93b, Hi: 0x93b, Stride: 0x1},
+		unicode.Range16{Lo: 0x93e, Hi: 0x940, Stride: 0x1},
+		unicode.Range16{Lo: 0x949, Hi: 0x94c, Stride: 0x1},
+		unicode.Range16{Lo: 0x94e, Hi: 0x94f, Stride: 0x1},
+		unicode.Range16{Lo: 0x982, Hi: 0x983, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bf, Hi: 0x9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c7, Hi: 0x9c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cb, Hi: 0x9cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xa03, Hi: 0xa03, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3e, Hi: 0xa40, Stride: 0x1},
+		unicode.Range16{Lo: 0xa83, Hi: 0xa83, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe, Hi: 0xac0, Stride: 0x1},
+		unicode.Range16{Lo: 0xac9, Hi: 0xac9, Stride: 0x1},
+		unicode.Range16{Lo: 0xacb, Hi: 0xacc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb02, Hi: 0xb03, Stride: 0x1},
+		unicode.Range16{Lo: 0xb40, Hi: 0xb40, Stride: 0x1},
+		unicode.Range16{Lo: 0xb47, Hi: 0xb48, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4b, Hi: 0xb4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbf, Hi: 0xbbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc1, Hi: 0xbc2, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc6, Hi: 0xbc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca, Hi: 0xbcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc01, Hi: 0xc03, Stride: 0x1},
+		unicode.Range16{Lo: 0xc41, Hi: 0xc44, Stride: 0x1},
+		unicode.Range16{Lo: 0xc82, Hi: 0xc83, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbe, Hi: 0xcbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0, Hi: 0xcc1, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc3, Hi: 0xcc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7, Hi: 0xcc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcca, Hi: 0xccb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd02, Hi: 0xd03, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3f, Hi: 0xd40, Stride: 0x1},
+		unicode.Range16{Lo: 0xd46, Hi: 0xd48, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4a, Hi: 0xd4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd82, Hi: 0xd83, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd0, Hi: 0xdd1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd8, Hi: 0xdde, Stride: 0x1},
+		unicode.Range16{Lo: 0xdf2, Hi: 0xdf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xe33, Hi: 0xe33, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb3, Hi: 0xeb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3e, Hi: 0xf3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf7f, Hi: 0xf7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1031, Hi: 0x1031, Stride: 0x1},
+		unicode.Range16{Lo: 0x103b, Hi: 0x103c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1056, Hi: 0x1057, Stride: 0x1},
+		unicode.Range16{Lo: 0x1084, Hi: 0x1084, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b6, Hi: 0x17b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17be, Hi: 0x17c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c7, Hi: 0x17c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1923, Hi: 0x1926, Stride: 0x1},
+		unicode.Range16{Lo: 0x1929, Hi: 0x192b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1930, Hi: 0x1931, Stride: 0x1},
+		unicode.Range16{Lo: 0x1933, Hi: 0x1938, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a19, Hi: 0x1a1a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a55, Hi: 0x1a55, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a57, Hi: 0x1a57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a6d, Hi: 0x1a72, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b04, Hi: 0x1b04, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b35, Hi: 0x1b35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3b, Hi: 0x1b3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3d, Hi: 0x1b41, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b43, Hi: 0x1b44, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b82, Hi: 0x1b82, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba1, Hi: 0x1ba1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba6, Hi: 0x1ba7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1baa, Hi: 0x1baa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be7, Hi: 0x1be7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bea, Hi: 0x1bec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bee, Hi: 0x1bee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bf2, Hi: 0x1bf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c24, Hi: 0x1c2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c34, Hi: 0x1c35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce1, Hi: 0x1ce1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf2, Hi: 0x1cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa823, Hi: 0xa824, Stride: 0x1},
+		unicode.Range16{Lo: 0xa827, Hi: 0xa827, Stride: 0x1},
+		unicode.Range16{Lo: 0xa880, Hi: 0xa881, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8b4, Hi: 0xa8c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa952, Hi: 0xa953, Stride: 0x1},
+		unicode.Range16{Lo: 0xa983, Hi: 0xa983, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b4, Hi: 0xa9b5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9ba, Hi: 0xa9bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bd, Hi: 0xa9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa2f, Hi: 0xaa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa33, Hi: 0xaa34, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4d, Hi: 0xaa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaeb, Hi: 0xaaeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaee, Hi: 0xaaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf5, Hi: 0xaaf5, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe3, Hi: 0xabe4, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe6, Hi: 0xabe7, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe9, Hi: 0xabea, Stride: 0x1},
+		unicode.Range16{Lo: 0xabec, Hi: 0xabec, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x11000, Hi: 0x11000, Stride: 0x1},
+		unicode.Range32{Lo: 0x11002, Hi: 0x11002, Stride: 0x1},
+		unicode.Range32{Lo: 0x11082, Hi: 0x11082, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b0, Hi: 0x110b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b7, Hi: 0x110b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112c, Hi: 0x1112c, Stride: 0x1},
+		unicode.Range32{Lo: 0x11182, Hi: 0x11182, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b3, Hi: 0x111b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x111bf, Hi: 0x111c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122c, Hi: 0x1122e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11232, Hi: 0x11233, Stride: 0x1},
+		unicode.Range32{Lo: 0x11235, Hi: 0x11235, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e0, Hi: 0x112e2, Stride: 0x1},
+		unicode.Range32{Lo: 0x11302, Hi: 0x11303, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133f, Hi: 0x1133f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11341, Hi: 0x11344, Stride: 0x1},
+		unicode.Range32{Lo: 0x11347, Hi: 0x11348, Stride: 0x1},
+		unicode.Range32{Lo: 0x1134b, Hi: 0x1134d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11362, Hi: 0x11363, Stride: 0x1},
+		unicode.Range32{Lo: 0x11435, Hi: 0x11437, Stride: 0x1},
+		unicode.Range32{Lo: 0x11440, Hi: 0x11441, Stride: 0x1},
+		unicode.Range32{Lo: 0x11445, Hi: 0x11445, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b1, Hi: 0x114b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b9, Hi: 0x114b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bb, Hi: 0x114bc, Stride: 0x1},
+		unicode.Range32{Lo: 0x114be, Hi: 0x114be, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c1, Hi: 0x114c1, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b0, Hi: 0x115b1, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b8, Hi: 0x115bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x115be, Hi: 0x115be, Stride: 0x1},
+		unicode.Range32{Lo: 0x11630, Hi: 0x11632, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163b, Hi: 0x1163c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163e, Hi: 0x1163e, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ac, Hi: 0x116ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ae, Hi: 0x116af, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b6, Hi: 0x116b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x11720, Hi: 0x11721, Stride: 0x1},
+		unicode.Range32{Lo: 0x11726, Hi: 0x11726, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c2f, Hi: 0x11c2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3e, Hi: 0x11c3e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ca9, Hi: 0x11ca9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb1, Hi: 0x11cb1, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb4, Hi: 0x11cb4, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f51, Hi: 0x16f7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d166, Hi: 0x1d166, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d16d, Hi: 0x1d16d, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeT = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x11a8, Hi: 0x11ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7cb, Hi: 0xd7fb, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeV = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x1160, Hi: 0x11a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7b0, Hi: 0xd7c6, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeZWJ = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x200d, Hi: 0x200d, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+type _GraphemeRuneRange unicode.RangeTable
+
+func _GraphemeRuneType(r rune) *_GraphemeRuneRange {
+	switch {
+	case unicode.Is(_GraphemeCR, r):
+		return (*_GraphemeRuneRange)(_GraphemeCR)
+	case unicode.Is(_GraphemeControl, r):
+		return (*_GraphemeRuneRange)(_GraphemeControl)
+	case unicode.Is(_GraphemeE_Base, r):
+		return (*_GraphemeRuneRange)(_GraphemeE_Base)
+	case unicode.Is(_GraphemeE_Base_GAZ, r):
+		return (*_GraphemeRuneRange)(_GraphemeE_Base_GAZ)
+	case unicode.Is(_GraphemeE_Modifier, r):
+		return (*_GraphemeRuneRange)(_GraphemeE_Modifier)
+	case unicode.Is(_GraphemeExtend, r):
+		return (*_GraphemeRuneRange)(_GraphemeExtend)
+	case unicode.Is(_GraphemeGlue_After_Zwj, r):
+		return (*_GraphemeRuneRange)(_GraphemeGlue_After_Zwj)
+	case unicode.Is(_GraphemeL, r):
+		return (*_GraphemeRuneRange)(_GraphemeL)
+	case unicode.Is(_GraphemeLF, r):
+		return (*_GraphemeRuneRange)(_GraphemeLF)
+	case unicode.Is(_GraphemeLV, r):
+		return (*_GraphemeRuneRange)(_GraphemeLV)
+	case unicode.Is(_GraphemeLVT, r):
+		return (*_GraphemeRuneRange)(_GraphemeLVT)
+	case unicode.Is(_GraphemePrepend, r):
+		return (*_GraphemeRuneRange)(_GraphemePrepend)
+	case unicode.Is(_GraphemeRegional_Indicator, r):
+		return (*_GraphemeRuneRange)(_GraphemeRegional_Indicator)
+	case unicode.Is(_GraphemeSpacingMark, r):
+		return (*_GraphemeRuneRange)(_GraphemeSpacingMark)
+	case unicode.Is(_GraphemeT, r):
+		return (*_GraphemeRuneRange)(_GraphemeT)
+	case unicode.Is(_GraphemeV, r):
+		return (*_GraphemeRuneRange)(_GraphemeV)
+	case unicode.Is(_GraphemeZWJ, r):
+		return (*_GraphemeRuneRange)(_GraphemeZWJ)
+	default:
+		return nil
+	}
+}
+func (rng *_GraphemeRuneRange) String() string {
+	switch (*unicode.RangeTable)(rng) {
+	case _GraphemeCR:
+		return "CR"
+	case _GraphemeControl:
+		return "Control"
+	case _GraphemeE_Base:
+		return "E_Base"
+	case _GraphemeE_Base_GAZ:
+		return "E_Base_GAZ"
+	case _GraphemeE_Modifier:
+		return "E_Modifier"
+	case _GraphemeExtend:
+		return "Extend"
+	case _GraphemeGlue_After_Zwj:
+		return "Glue_After_Zwj"
+	case _GraphemeL:
+		return "L"
+	case _GraphemeLF:
+		return "LF"
+	case _GraphemeLV:
+		return "LV"
+	case _GraphemeLVT:
+		return "LVT"
+	case _GraphemePrepend:
+		return "Prepend"
+	case _GraphemeRegional_Indicator:
+		return "Regional_Indicator"
+	case _GraphemeSpacingMark:
+		return "SpacingMark"
+	case _GraphemeT:
+		return "T"
+	case _GraphemeV:
+		return "V"
+	case _GraphemeZWJ:
+		return "ZWJ"
+	default:
+		return "Other"
+	}
+}
+
+var _WordALetter = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x41, Hi: 0x5a, Stride: 0x1},
+		unicode.Range16{Lo: 0x61, Hi: 0x7a, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa, Hi: 0xaa, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5, Hi: 0xb5, Stride: 0x1},
+		unicode.Range16{Lo: 0xba, Hi: 0xba, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0, Hi: 0xd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xd8, Hi: 0xf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8, Hi: 0x1ba, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bb, Hi: 0x1bb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bc, Hi: 0x1bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c0, Hi: 0x1c3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c4, Hi: 0x293, Stride: 0x1},
+		unicode.Range16{Lo: 0x294, Hi: 0x294, Stride: 0x1},
+		unicode.Range16{Lo: 0x295, Hi: 0x2af, Stride: 0x1},
+		unicode.Range16{Lo: 0x2b0, Hi: 0x2c1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6, Hi: 0x2d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0, Hi: 0x2e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ec, Hi: 0x2ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ee, Hi: 0x2ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x370, Hi: 0x373, Stride: 0x1},
+		unicode.Range16{Lo: 0x374, Hi: 0x374, Stride: 0x1},
+		unicode.Range16{Lo: 0x376, Hi: 0x377, Stride: 0x1},
+		unicode.Range16{Lo: 0x37a, Hi: 0x37a, Stride: 0x1},
+		unicode.Range16{Lo: 0x37b, Hi: 0x37d, Stride: 0x1},
+		unicode.Range16{Lo: 0x37f, Hi: 0x37f, Stride: 0x1},
+		unicode.Range16{Lo: 0x386, Hi: 0x386, Stride: 0x1},
+		unicode.Range16{Lo: 0x388, Hi: 0x38a, Stride: 0x1},
+		unicode.Range16{Lo: 0x38c, Hi: 0x38c, Stride: 0x1},
+		unicode.Range16{Lo: 0x38e, Hi: 0x3a1, Stride: 0x1},
+		unicode.Range16{Lo: 0x3a3, Hi: 0x3f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f7, Hi: 0x481, Stride: 0x1},
+		unicode.Range16{Lo: 0x48a, Hi: 0x52f, Stride: 0x1},
+		unicode.Range16{Lo: 0x531, Hi: 0x556, Stride: 0x1},
+		unicode.Range16{Lo: 0x559, Hi: 0x559, Stride: 0x1},
+		unicode.Range16{Lo: 0x561, Hi: 0x587, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f3, Hi: 0x5f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x620, Hi: 0x63f, Stride: 0x1},
+		unicode.Range16{Lo: 0x640, Hi: 0x640, Stride: 0x1},
+		unicode.Range16{Lo: 0x641, Hi: 0x64a, Stride: 0x1},
+		unicode.Range16{Lo: 0x66e, Hi: 0x66f, Stride: 0x1},
+		unicode.Range16{Lo: 0x671, Hi: 0x6d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d5, Hi: 0x6d5, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e5, Hi: 0x6e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ee, Hi: 0x6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0x6fa, Hi: 0x6fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ff, Hi: 0x6ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x710, Hi: 0x710, Stride: 0x1},
+		unicode.Range16{Lo: 0x712, Hi: 0x72f, Stride: 0x1},
+		unicode.Range16{Lo: 0x74d, Hi: 0x7a5, Stride: 0x1},
+		unicode.Range16{Lo: 0x7b1, Hi: 0x7b1, Stride: 0x1},
+		unicode.Range16{Lo: 0x7ca, Hi: 0x7ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f4, Hi: 0x7f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x7fa, Hi: 0x7fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x800, Hi: 0x815, Stride: 0x1},
+		unicode.Range16{Lo: 0x81a, Hi: 0x81a, Stride: 0x1},
+		unicode.Range16{Lo: 0x824, Hi: 0x824, Stride: 0x1},
+		unicode.Range16{Lo: 0x828, Hi: 0x828, Stride: 0x1},
+		unicode.Range16{Lo: 0x840, Hi: 0x858, Stride: 0x1},
+		unicode.Range16{Lo: 0x8a0, Hi: 0x8b4, Stride: 0x1},
+		unicode.Range16{Lo: 0x8b6, Hi: 0x8bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x904, Hi: 0x939, Stride: 0x1},
+		unicode.Range16{Lo: 0x93d, Hi: 0x93d, Stride: 0x1},
+		unicode.Range16{Lo: 0x950, Hi: 0x950, Stride: 0x1},
+		unicode.Range16{Lo: 0x958, Hi: 0x961, Stride: 0x1},
+		unicode.Range16{Lo: 0x971, Hi: 0x971, Stride: 0x1},
+		unicode.Range16{Lo: 0x972, Hi: 0x980, Stride: 0x1},
+		unicode.Range16{Lo: 0x985, Hi: 0x98c, Stride: 0x1},
+		unicode.Range16{Lo: 0x98f, Hi: 0x990, Stride: 0x1},
+		unicode.Range16{Lo: 0x993, Hi: 0x9a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9aa, Hi: 0x9b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9b2, Hi: 0x9b2, Stride: 0x1},
+		unicode.Range16{Lo: 0x9b6, Hi: 0x9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bd, Hi: 0x9bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9ce, Hi: 0x9ce, Stride: 0x1},
+		unicode.Range16{Lo: 0x9dc, Hi: 0x9dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9df, Hi: 0x9e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x9f0, Hi: 0x9f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa05, Hi: 0xa0a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa0f, Hi: 0xa10, Stride: 0x1},
+		unicode.Range16{Lo: 0xa13, Hi: 0xa28, Stride: 0x1},
+		unicode.Range16{Lo: 0xa2a, Hi: 0xa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xa32, Hi: 0xa33, Stride: 0x1},
+		unicode.Range16{Lo: 0xa35, Hi: 0xa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xa38, Hi: 0xa39, Stride: 0x1},
+		unicode.Range16{Lo: 0xa59, Hi: 0xa5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa5e, Hi: 0xa5e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72, Hi: 0xa74, Stride: 0x1},
+		unicode.Range16{Lo: 0xa85, Hi: 0xa8d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8f, Hi: 0xa91, Stride: 0x1},
+		unicode.Range16{Lo: 0xa93, Hi: 0xaa8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaa, Hi: 0xab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xab2, Hi: 0xab3, Stride: 0x1},
+		unicode.Range16{Lo: 0xab5, Hi: 0xab9, Stride: 0x1},
+		unicode.Range16{Lo: 0xabd, Hi: 0xabd, Stride: 0x1},
+		unicode.Range16{Lo: 0xad0, Hi: 0xad0, Stride: 0x1},
+		unicode.Range16{Lo: 0xae0, Hi: 0xae1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf9, Hi: 0xaf9, Stride: 0x1},
+		unicode.Range16{Lo: 0xb05, Hi: 0xb0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0f, Hi: 0xb10, Stride: 0x1},
+		unicode.Range16{Lo: 0xb13, Hi: 0xb28, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2a, Hi: 0xb30, Stride: 0x1},
+		unicode.Range16{Lo: 0xb32, Hi: 0xb33, Stride: 0x1},
+		unicode.Range16{Lo: 0xb35, Hi: 0xb39, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3d, Hi: 0xb3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5c, Hi: 0xb5d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5f, Hi: 0xb61, Stride: 0x1},
+		unicode.Range16{Lo: 0xb71, Hi: 0xb71, Stride: 0x1},
+		unicode.Range16{Lo: 0xb83, Hi: 0xb83, Stride: 0x1},
+		unicode.Range16{Lo: 0xb85, Hi: 0xb8a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8e, Hi: 0xb90, Stride: 0x1},
+		unicode.Range16{Lo: 0xb92, Hi: 0xb95, Stride: 0x1},
+		unicode.Range16{Lo: 0xb99, Hi: 0xb9a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9c, Hi: 0xb9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9e, Hi: 0xb9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xba3, Hi: 0xba4, Stride: 0x1},
+		unicode.Range16{Lo: 0xba8, Hi: 0xbaa, Stride: 0x1},
+		unicode.Range16{Lo: 0xbae, Hi: 0xbb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd0, Hi: 0xbd0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc05, Hi: 0xc0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0e, Hi: 0xc10, Stride: 0x1},
+		unicode.Range16{Lo: 0xc12, Hi: 0xc28, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2a, Hi: 0xc39, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3d, Hi: 0xc3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc58, Hi: 0xc5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xc60, Hi: 0xc61, Stride: 0x1},
+		unicode.Range16{Lo: 0xc80, Hi: 0xc80, Stride: 0x1},
+		unicode.Range16{Lo: 0xc85, Hi: 0xc8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8e, Hi: 0xc90, Stride: 0x1},
+		unicode.Range16{Lo: 0xc92, Hi: 0xca8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaa, Hi: 0xcb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb5, Hi: 0xcb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbd, Hi: 0xcbd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcde, Hi: 0xcde, Stride: 0x1},
+		unicode.Range16{Lo: 0xce0, Hi: 0xce1, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf1, Hi: 0xcf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xd05, Hi: 0xd0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0e, Hi: 0xd10, Stride: 0x1},
+		unicode.Range16{Lo: 0xd12, Hi: 0xd3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3d, Hi: 0xd3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e, Hi: 0xd4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xd54, Hi: 0xd56, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5f, Hi: 0xd61, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7a, Hi: 0xd7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd85, Hi: 0xd96, Stride: 0x1},
+		unicode.Range16{Lo: 0xd9a, Hi: 0xdb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdb3, Hi: 0xdbb, Stride: 0x1},
+		unicode.Range16{Lo: 0xdbd, Hi: 0xdbd, Stride: 0x1},
+		unicode.Range16{Lo: 0xdc0, Hi: 0xdc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xf00, Hi: 0xf00, Stride: 0x1},
+		unicode.Range16{Lo: 0xf40, Hi: 0xf47, Stride: 0x1},
+		unicode.Range16{Lo: 0xf49, Hi: 0xf6c, Stride: 0x1},
+		unicode.Range16{Lo: 0xf88, Hi: 0xf8c, Stride: 0x1},
+		unicode.Range16{Lo: 0x10a0, Hi: 0x10c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x10c7, Hi: 0x10c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x10cd, Hi: 0x10cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x10d0, Hi: 0x10fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x10fc, Hi: 0x10fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x10fd, Hi: 0x1248, Stride: 0x1},
+		unicode.Range16{Lo: 0x124a, Hi: 0x124d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1250, Hi: 0x1256, Stride: 0x1},
+		unicode.Range16{Lo: 0x1258, Hi: 0x1258, Stride: 0x1},
+		unicode.Range16{Lo: 0x125a, Hi: 0x125d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1260, Hi: 0x1288, Stride: 0x1},
+		unicode.Range16{Lo: 0x128a, Hi: 0x128d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1290, Hi: 0x12b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b2, Hi: 0x12b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b8, Hi: 0x12be, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c0, Hi: 0x12c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c2, Hi: 0x12c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c8, Hi: 0x12d6, Stride: 0x1},
+		unicode.Range16{Lo: 0x12d8, Hi: 0x1310, Stride: 0x1},
+		unicode.Range16{Lo: 0x1312, Hi: 0x1315, Stride: 0x1},
+		unicode.Range16{Lo: 0x1318, Hi: 0x135a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1380, Hi: 0x138f, Stride: 0x1},
+		unicode.Range16{Lo: 0x13a0, Hi: 0x13f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x13f8, Hi: 0x13fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1401, Hi: 0x166c, Stride: 0x1},
+		unicode.Range16{Lo: 0x166f, Hi: 0x167f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1681, Hi: 0x169a, Stride: 0x1},
+		unicode.Range16{Lo: 0x16a0, Hi: 0x16ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x16ee, Hi: 0x16f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x16f1, Hi: 0x16f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1700, Hi: 0x170c, Stride: 0x1},
+		unicode.Range16{Lo: 0x170e, Hi: 0x1711, Stride: 0x1},
+		unicode.Range16{Lo: 0x1720, Hi: 0x1731, Stride: 0x1},
+		unicode.Range16{Lo: 0x1740, Hi: 0x1751, Stride: 0x1},
+		unicode.Range16{Lo: 0x1760, Hi: 0x176c, Stride: 0x1},
+		unicode.Range16{Lo: 0x176e, Hi: 0x1770, Stride: 0x1},
+		unicode.Range16{Lo: 0x1820, Hi: 0x1842, Stride: 0x1},
+		unicode.Range16{Lo: 0x1843, Hi: 0x1843, Stride: 0x1},
+		unicode.Range16{Lo: 0x1844, Hi: 0x1877, Stride: 0x1},
+		unicode.Range16{Lo: 0x1880, Hi: 0x1884, Stride: 0x1},
+		unicode.Range16{Lo: 0x1887, Hi: 0x18a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x18aa, Hi: 0x18aa, Stride: 0x1},
+		unicode.Range16{Lo: 0x18b0, Hi: 0x18f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1900, Hi: 0x191e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a00, Hi: 0x1a16, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b05, Hi: 0x1b33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b45, Hi: 0x1b4b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b83, Hi: 0x1ba0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bae, Hi: 0x1baf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bba, Hi: 0x1be5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c00, Hi: 0x1c23, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c4d, Hi: 0x1c4f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c5a, Hi: 0x1c77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c78, Hi: 0x1c7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c80, Hi: 0x1c88, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce9, Hi: 0x1cec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cee, Hi: 0x1cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf5, Hi: 0x1cf6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d00, Hi: 0x1d2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d2c, Hi: 0x1d6a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d6b, Hi: 0x1d77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d78, Hi: 0x1d78, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d79, Hi: 0x1d9a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d9b, Hi: 0x1dbf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e00, Hi: 0x1f15, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f18, Hi: 0x1f1d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f20, Hi: 0x1f45, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f48, Hi: 0x1f4d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f50, Hi: 0x1f57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f59, Hi: 0x1f59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5b, Hi: 0x1f5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5d, Hi: 0x1f5d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5f, Hi: 0x1f7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f80, Hi: 0x1fb4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb6, Hi: 0x1fbc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fbe, Hi: 0x1fbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc2, Hi: 0x1fc4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc6, Hi: 0x1fcc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd0, Hi: 0x1fd3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd6, Hi: 0x1fdb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fe0, Hi: 0x1fec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff2, Hi: 0x1ff4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff6, Hi: 0x1ffc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2071, Hi: 0x2071, Stride: 0x1},
+		unicode.Range16{Lo: 0x207f, Hi: 0x207f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2090, Hi: 0x209c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2102, Hi: 0x2102, Stride: 0x1},
+		unicode.Range16{Lo: 0x2107, Hi: 0x2107, Stride: 0x1},
+		unicode.Range16{Lo: 0x210a, Hi: 0x2113, Stride: 0x1},
+		unicode.Range16{Lo: 0x2115, Hi: 0x2115, Stride: 0x1},
+		unicode.Range16{Lo: 0x2119, Hi: 0x211d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2124, Hi: 0x2124, Stride: 0x1},
+		unicode.Range16{Lo: 0x2126, Hi: 0x2126, Stride: 0x1},
+		unicode.Range16{Lo: 0x2128, Hi: 0x2128, Stride: 0x1},
+		unicode.Range16{Lo: 0x212a, Hi: 0x212d, Stride: 0x1},
+		unicode.Range16{Lo: 0x212f, Hi: 0x2134, Stride: 0x1},
+		unicode.Range16{Lo: 0x2135, Hi: 0x2138, Stride: 0x1},
+		unicode.Range16{Lo: 0x2139, Hi: 0x2139, Stride: 0x1},
+		unicode.Range16{Lo: 0x213c, Hi: 0x213f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2145, Hi: 0x2149, Stride: 0x1},
+		unicode.Range16{Lo: 0x214e, Hi: 0x214e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2160, Hi: 0x2182, Stride: 0x1},
+		unicode.Range16{Lo: 0x2183, Hi: 0x2184, Stride: 0x1},
+		unicode.Range16{Lo: 0x2185, Hi: 0x2188, Stride: 0x1},
+		unicode.Range16{Lo: 0x24b6, Hi: 0x24e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c00, Hi: 0x2c2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c30, Hi: 0x2c5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c60, Hi: 0x2c7b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c7c, Hi: 0x2c7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c7e, Hi: 0x2ce4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ceb, Hi: 0x2cee, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cf2, Hi: 0x2cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d00, Hi: 0x2d25, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d27, Hi: 0x2d27, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d2d, Hi: 0x2d2d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d30, Hi: 0x2d67, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d6f, Hi: 0x2d6f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d80, Hi: 0x2d96, Stride: 0x1},
+		unicode.Range16{Lo: 0x2da0, Hi: 0x2da6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2da8, Hi: 0x2dae, Stride: 0x1},
+		unicode.Range16{Lo: 0x2db0, Hi: 0x2db6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2db8, Hi: 0x2dbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dc0, Hi: 0x2dc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dc8, Hi: 0x2dce, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dd0, Hi: 0x2dd6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dd8, Hi: 0x2dde, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e2f, Hi: 0x2e2f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3005, Hi: 0x3005, Stride: 0x1},
+		unicode.Range16{Lo: 0x303b, Hi: 0x303b, Stride: 0x1},
+		unicode.Range16{Lo: 0x303c, Hi: 0x303c, Stride: 0x1},
+		unicode.Range16{Lo: 0x3105, Hi: 0x312d, Stride: 0x1},
+		unicode.Range16{Lo: 0x3131, Hi: 0x318e, Stride: 0x1},
+		unicode.Range16{Lo: 0x31a0, Hi: 0x31ba, Stride: 0x1},
+		unicode.Range16{Lo: 0xa000, Hi: 0xa014, Stride: 0x1},
+		unicode.Range16{Lo: 0xa015, Hi: 0xa015, Stride: 0x1},
+		unicode.Range16{Lo: 0xa016, Hi: 0xa48c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4d0, Hi: 0xa4f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4f8, Hi: 0xa4fd, Stride: 0x1},
+		unicode.Range16{Lo: 0xa500, Hi: 0xa60b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa60c, Hi: 0xa60c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa610, Hi: 0xa61f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa62a, Hi: 0xa62b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa640, Hi: 0xa66d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66e, Hi: 0xa66e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa67f, Hi: 0xa67f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa680, Hi: 0xa69b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69c, Hi: 0xa69d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6a0, Hi: 0xa6e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6e6, Hi: 0xa6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa717, Hi: 0xa71f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa722, Hi: 0xa76f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa770, Hi: 0xa770, Stride: 0x1},
+		unicode.Range16{Lo: 0xa771, Hi: 0xa787, Stride: 0x1},
+		unicode.Range16{Lo: 0xa788, Hi: 0xa788, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78b, Hi: 0xa78e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78f, Hi: 0xa78f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa790, Hi: 0xa7ae, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b0, Hi: 0xa7b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7f7, Hi: 0xa7f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7f8, Hi: 0xa7f9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7fa, Hi: 0xa7fa, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7fb, Hi: 0xa801, Stride: 0x1},
+		unicode.Range16{Lo: 0xa803, Hi: 0xa805, Stride: 0x1},
+		unicode.Range16{Lo: 0xa807, Hi: 0xa80a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80c, Hi: 0xa822, Stride: 0x1},
+		unicode.Range16{Lo: 0xa840, Hi: 0xa873, Stride: 0x1},
+		unicode.Range16{Lo: 0xa882, Hi: 0xa8b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8f2, Hi: 0xa8f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8fb, Hi: 0xa8fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8fd, Hi: 0xa8fd, Stride: 0x1},
+		unicode.Range16{Lo: 0xa90a, Hi: 0xa925, Stride: 0x1},
+		unicode.Range16{Lo: 0xa930, Hi: 0xa946, Stride: 0x1},
+		unicode.Range16{Lo: 0xa960, Hi: 0xa97c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa984, Hi: 0xa9b2, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9cf, Hi: 0xa9cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa00, Hi: 0xaa28, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa40, Hi: 0xaa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa44, Hi: 0xaa4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaae0, Hi: 0xaaea, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf2, Hi: 0xaaf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf3, Hi: 0xaaf4, Stride: 0x1},
+		unicode.Range16{Lo: 0xab01, Hi: 0xab06, Stride: 0x1},
+		unicode.Range16{Lo: 0xab09, Hi: 0xab0e, Stride: 0x1},
+		unicode.Range16{Lo: 0xab11, Hi: 0xab16, Stride: 0x1},
+		unicode.Range16{Lo: 0xab20, Hi: 0xab26, Stride: 0x1},
+		unicode.Range16{Lo: 0xab28, Hi: 0xab2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xab30, Hi: 0xab5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xab5c, Hi: 0xab5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xab60, Hi: 0xab65, Stride: 0x1},
+		unicode.Range16{Lo: 0xab70, Hi: 0xabbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc0, Hi: 0xabe2, Stride: 0x1},
+		unicode.Range16{Lo: 0xac00, Hi: 0xd7a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7b0, Hi: 0xd7c6, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7cb, Hi: 0xd7fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb00, Hi: 0xfb06, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb13, Hi: 0xfb17, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb50, Hi: 0xfbb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xfbd3, Hi: 0xfd3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd50, Hi: 0xfd8f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd92, Hi: 0xfdc7, Stride: 0x1},
+		unicode.Range16{Lo: 0xfdf0, Hi: 0xfdfb, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe70, Hi: 0xfe74, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe76, Hi: 0xfefc, Stride: 0x1},
+		unicode.Range16{Lo: 0xff21, Hi: 0xff3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xff41, Hi: 0xff5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xffa0, Hi: 0xffbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xffc2, Hi: 0xffc7, Stride: 0x1},
+		unicode.Range16{Lo: 0xffca, Hi: 0xffcf, Stride: 0x1},
+		unicode.Range16{Lo: 0xffd2, Hi: 0xffd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xffda, Hi: 0xffdc, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10000, Hi: 0x1000b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1000d, Hi: 0x10026, Stride: 0x1},
+		unicode.Range32{Lo: 0x10028, Hi: 0x1003a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1003c, Hi: 0x1003d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1003f, Hi: 0x1004d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10050, Hi: 0x1005d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10080, Hi: 0x100fa, Stride: 0x1},
+		unicode.Range32{Lo: 0x10140, Hi: 0x10174, Stride: 0x1},
+		unicode.Range32{Lo: 0x10280, Hi: 0x1029c, Stride: 0x1},
+		unicode.Range32{Lo: 0x102a0, Hi: 0x102d0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10300, Hi: 0x1031f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10330, Hi: 0x10340, Stride: 0x1},
+		unicode.Range32{Lo: 0x10341, Hi: 0x10341, Stride: 0x1},
+		unicode.Range32{Lo: 0x10342, Hi: 0x10349, Stride: 0x1},
+		unicode.Range32{Lo: 0x1034a, Hi: 0x1034a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10350, Hi: 0x10375, Stride: 0x1},
+		unicode.Range32{Lo: 0x10380, Hi: 0x1039d, Stride: 0x1},
+		unicode.Range32{Lo: 0x103a0, Hi: 0x103c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x103c8, Hi: 0x103cf, Stride: 0x1},
+		unicode.Range32{Lo: 0x103d1, Hi: 0x103d5, Stride: 0x1},
+		unicode.Range32{Lo: 0x10400, Hi: 0x1044f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10450, Hi: 0x1049d, Stride: 0x1},
+		unicode.Range32{Lo: 0x104b0, Hi: 0x104d3, Stride: 0x1},
+		unicode.Range32{Lo: 0x104d8, Hi: 0x104fb, Stride: 0x1},
+		unicode.Range32{Lo: 0x10500, Hi: 0x10527, Stride: 0x1},
+		unicode.Range32{Lo: 0x10530, Hi: 0x10563, Stride: 0x1},
+		unicode.Range32{Lo: 0x10600, Hi: 0x10736, Stride: 0x1},
+		unicode.Range32{Lo: 0x10740, Hi: 0x10755, Stride: 0x1},
+		unicode.Range32{Lo: 0x10760, Hi: 0x10767, Stride: 0x1},
+		unicode.Range32{Lo: 0x10800, Hi: 0x10805, Stride: 0x1},
+		unicode.Range32{Lo: 0x10808, Hi: 0x10808, Stride: 0x1},
+		unicode.Range32{Lo: 0x1080a, Hi: 0x10835, Stride: 0x1},
+		unicode.Range32{Lo: 0x10837, Hi: 0x10838, Stride: 0x1},
+		unicode.Range32{Lo: 0x1083c, Hi: 0x1083c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1083f, Hi: 0x10855, Stride: 0x1},
+		unicode.Range32{Lo: 0x10860, Hi: 0x10876, Stride: 0x1},
+		unicode.Range32{Lo: 0x10880, Hi: 0x1089e, Stride: 0x1},
+		unicode.Range32{Lo: 0x108e0, Hi: 0x108f2, Stride: 0x1},
+		unicode.Range32{Lo: 0x108f4, Hi: 0x108f5, Stride: 0x1},
+		unicode.Range32{Lo: 0x10900, Hi: 0x10915, Stride: 0x1},
+		unicode.Range32{Lo: 0x10920, Hi: 0x10939, Stride: 0x1},
+		unicode.Range32{Lo: 0x10980, Hi: 0x109b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x109be, Hi: 0x109bf, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a00, Hi: 0x10a00, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a10, Hi: 0x10a13, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a15, Hi: 0x10a17, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a19, Hi: 0x10a33, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a60, Hi: 0x10a7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a80, Hi: 0x10a9c, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ac0, Hi: 0x10ac7, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ac9, Hi: 0x10ae4, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b00, Hi: 0x10b35, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b40, Hi: 0x10b55, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b60, Hi: 0x10b72, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b80, Hi: 0x10b91, Stride: 0x1},
+		unicode.Range32{Lo: 0x10c00, Hi: 0x10c48, Stride: 0x1},
+		unicode.Range32{Lo: 0x10c80, Hi: 0x10cb2, Stride: 0x1},
+		unicode.Range32{Lo: 0x10cc0, Hi: 0x10cf2, Stride: 0x1},
+		unicode.Range32{Lo: 0x11003, Hi: 0x11037, Stride: 0x1},
+		unicode.Range32{Lo: 0x11083, Hi: 0x110af, Stride: 0x1},
+		unicode.Range32{Lo: 0x110d0, Hi: 0x110e8, Stride: 0x1},
+		unicode.Range32{Lo: 0x11103, Hi: 0x11126, Stride: 0x1},
+		unicode.Range32{Lo: 0x11150, Hi: 0x11172, Stride: 0x1},
+		unicode.Range32{Lo: 0x11176, Hi: 0x11176, Stride: 0x1},
+		unicode.Range32{Lo: 0x11183, Hi: 0x111b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x111c1, Hi: 0x111c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x111da, Hi: 0x111da, Stride: 0x1},
+		unicode.Range32{Lo: 0x111dc, Hi: 0x111dc, Stride: 0x1},
+		unicode.Range32{Lo: 0x11200, Hi: 0x11211, Stride: 0x1},
+		unicode.Range32{Lo: 0x11213, Hi: 0x1122b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11280, Hi: 0x11286, Stride: 0x1},
+		unicode.Range32{Lo: 0x11288, Hi: 0x11288, Stride: 0x1},
+		unicode.Range32{Lo: 0x1128a, Hi: 0x1128d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1128f, Hi: 0x1129d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1129f, Hi: 0x112a8, Stride: 0x1},
+		unicode.Range32{Lo: 0x112b0, Hi: 0x112de, Stride: 0x1},
+		unicode.Range32{Lo: 0x11305, Hi: 0x1130c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1130f, Hi: 0x11310, Stride: 0x1},
+		unicode.Range32{Lo: 0x11313, Hi: 0x11328, Stride: 0x1},
+		unicode.Range32{Lo: 0x1132a, Hi: 0x11330, Stride: 0x1},
+		unicode.Range32{Lo: 0x11332, Hi: 0x11333, Stride: 0x1},
+		unicode.Range32{Lo: 0x11335, Hi: 0x11339, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133d, Hi: 0x1133d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11350, Hi: 0x11350, Stride: 0x1},
+		unicode.Range32{Lo: 0x1135d, Hi: 0x11361, Stride: 0x1},
+		unicode.Range32{Lo: 0x11400, Hi: 0x11434, Stride: 0x1},
+		unicode.Range32{Lo: 0x11447, Hi: 0x1144a, Stride: 0x1},
+		unicode.Range32{Lo: 0x11480, Hi: 0x114af, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c4, Hi: 0x114c5, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c7, Hi: 0x114c7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11580, Hi: 0x115ae, Stride: 0x1},
+		unicode.Range32{Lo: 0x115d8, Hi: 0x115db, Stride: 0x1},
+		unicode.Range32{Lo: 0x11600, Hi: 0x1162f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11644, Hi: 0x11644, Stride: 0x1},
+		unicode.Range32{Lo: 0x11680, Hi: 0x116aa, Stride: 0x1},
+		unicode.Range32{Lo: 0x118a0, Hi: 0x118df, Stride: 0x1},
+		unicode.Range32{Lo: 0x118ff, Hi: 0x118ff, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ac0, Hi: 0x11af8, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c00, Hi: 0x11c08, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c0a, Hi: 0x11c2e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c40, Hi: 0x11c40, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c72, Hi: 0x11c8f, Stride: 0x1},
+		unicode.Range32{Lo: 0x12000, Hi: 0x12399, Stride: 0x1},
+		unicode.Range32{Lo: 0x12400, Hi: 0x1246e, Stride: 0x1},
+		unicode.Range32{Lo: 0x12480, Hi: 0x12543, Stride: 0x1},
+		unicode.Range32{Lo: 0x13000, Hi: 0x1342e, Stride: 0x1},
+		unicode.Range32{Lo: 0x14400, Hi: 0x14646, Stride: 0x1},
+		unicode.Range32{Lo: 0x16800, Hi: 0x16a38, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a40, Hi: 0x16a5e, Stride: 0x1},
+		unicode.Range32{Lo: 0x16ad0, Hi: 0x16aed, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b00, Hi: 0x16b2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b40, Hi: 0x16b43, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b63, Hi: 0x16b77, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b7d, Hi: 0x16b8f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f00, Hi: 0x16f44, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f50, Hi: 0x16f50, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f93, Hi: 0x16f9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16fe0, Hi: 0x16fe0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc00, Hi: 0x1bc6a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc70, Hi: 0x1bc7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc80, Hi: 0x1bc88, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc90, Hi: 0x1bc99, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d400, Hi: 0x1d454, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d456, Hi: 0x1d49c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d49e, Hi: 0x1d49f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a2, Hi: 0x1d4a2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a5, Hi: 0x1d4a6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a9, Hi: 0x1d4ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4ae, Hi: 0x1d4b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4bb, Hi: 0x1d4bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4bd, Hi: 0x1d4c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4c5, Hi: 0x1d505, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d507, Hi: 0x1d50a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d50d, Hi: 0x1d514, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d516, Hi: 0x1d51c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d51e, Hi: 0x1d539, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d53b, Hi: 0x1d53e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d540, Hi: 0x1d544, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d546, Hi: 0x1d546, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d54a, Hi: 0x1d550, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d552, Hi: 0x1d6a5, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6a8, Hi: 0x1d6c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6c2, Hi: 0x1d6da, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6dc, Hi: 0x1d6fa, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6fc, Hi: 0x1d714, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d716, Hi: 0x1d734, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d736, Hi: 0x1d74e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d750, Hi: 0x1d76e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d770, Hi: 0x1d788, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d78a, Hi: 0x1d7a8, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7aa, Hi: 0x1d7c2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7c4, Hi: 0x1d7cb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e800, Hi: 0x1e8c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e900, Hi: 0x1e943, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee00, Hi: 0x1ee03, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee05, Hi: 0x1ee1f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee21, Hi: 0x1ee22, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee24, Hi: 0x1ee24, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee27, Hi: 0x1ee27, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee29, Hi: 0x1ee32, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee34, Hi: 0x1ee37, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee39, Hi: 0x1ee39, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee3b, Hi: 0x1ee3b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee42, Hi: 0x1ee42, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee47, Hi: 0x1ee47, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee49, Hi: 0x1ee49, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee4b, Hi: 0x1ee4b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee4d, Hi: 0x1ee4f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee51, Hi: 0x1ee52, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee54, Hi: 0x1ee54, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee57, Hi: 0x1ee57, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee59, Hi: 0x1ee59, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5b, Hi: 0x1ee5b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5d, Hi: 0x1ee5d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5f, Hi: 0x1ee5f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee61, Hi: 0x1ee62, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee64, Hi: 0x1ee64, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee67, Hi: 0x1ee6a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee6c, Hi: 0x1ee72, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee74, Hi: 0x1ee77, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee79, Hi: 0x1ee7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee7e, Hi: 0x1ee7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee80, Hi: 0x1ee89, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee8b, Hi: 0x1ee9b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eea1, Hi: 0x1eea3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eea5, Hi: 0x1eea9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eeab, Hi: 0x1eebb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f130, Hi: 0x1f149, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f150, Hi: 0x1f169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f170, Hi: 0x1f189, Stride: 0x1},
+	},
+	LatinOffset: 7,
+}
+
+var _WordCR = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xd, Hi: 0xd, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordDouble_Quote = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x22, Hi: 0x22, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordE_Base = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x261d, Hi: 0x261d, Stride: 0x1},
+		unicode.Range16{Lo: 0x26f9, Hi: 0x26f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x270a, Hi: 0x270d, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f385, Hi: 0x1f385, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f3c3, Hi: 0x1f3c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f3ca, Hi: 0x1f3cb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f442, Hi: 0x1f443, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f446, Hi: 0x1f450, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f46e, Hi: 0x1f46e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f470, Hi: 0x1f478, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f47c, Hi: 0x1f47c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f481, Hi: 0x1f483, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f485, Hi: 0x1f487, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f4aa, Hi: 0x1f4aa, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f575, Hi: 0x1f575, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f57a, Hi: 0x1f57a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f590, Hi: 0x1f590, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f595, Hi: 0x1f596, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f645, Hi: 0x1f647, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f64b, Hi: 0x1f64f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6a3, Hi: 0x1f6a3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6b4, Hi: 0x1f6b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6c0, Hi: 0x1f6c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f918, Hi: 0x1f91e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f926, Hi: 0x1f926, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f930, Hi: 0x1f930, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f933, Hi: 0x1f939, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f93c, Hi: 0x1f93e, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordE_Base_GAZ = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f466, Hi: 0x1f469, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordE_Modifier = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f3fb, Hi: 0x1f3ff, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordExtend = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x300, Hi: 0x36f, Stride: 0x1},
+		unicode.Range16{Lo: 0x483, Hi: 0x487, Stride: 0x1},
+		unicode.Range16{Lo: 0x488, Hi: 0x489, Stride: 0x1},
+		unicode.Range16{Lo: 0x591, Hi: 0x5bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x5bf, Hi: 0x5bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c1, Hi: 0x5c2, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c4, Hi: 0x5c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c7, Hi: 0x5c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x610, Hi: 0x61a, Stride: 0x1},
+		unicode.Range16{Lo: 0x64b, Hi: 0x65f, Stride: 0x1},
+		unicode.Range16{Lo: 0x670, Hi: 0x670, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d6, Hi: 0x6dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6df, Hi: 0x6e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e7, Hi: 0x6e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ea, Hi: 0x6ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x711, Hi: 0x711, Stride: 0x1},
+		unicode.Range16{Lo: 0x730, Hi: 0x74a, Stride: 0x1},
+		unicode.Range16{Lo: 0x7a6, Hi: 0x7b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x7eb, Hi: 0x7f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x816, Hi: 0x819, Stride: 0x1},
+		unicode.Range16{Lo: 0x81b, Hi: 0x823, Stride: 0x1},
+		unicode.Range16{Lo: 0x825, Hi: 0x827, Stride: 0x1},
+		unicode.Range16{Lo: 0x829, Hi: 0x82d, Stride: 0x1},
+		unicode.Range16{Lo: 0x859, Hi: 0x85b, Stride: 0x1},
+		unicode.Range16{Lo: 0x8d4, Hi: 0x8e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e3, Hi: 0x902, Stride: 0x1},
+		unicode.Range16{Lo: 0x903, Hi: 0x903, Stride: 0x1},
+		unicode.Range16{Lo: 0x93a, Hi: 0x93a, Stride: 0x1},
+		unicode.Range16{Lo: 0x93b, Hi: 0x93b, Stride: 0x1},
+		unicode.Range16{Lo: 0x93c, Hi: 0x93c, Stride: 0x1},
+		unicode.Range16{Lo: 0x93e, Hi: 0x940, Stride: 0x1},
+		unicode.Range16{Lo: 0x941, Hi: 0x948, Stride: 0x1},
+		unicode.Range16{Lo: 0x949, Hi: 0x94c, Stride: 0x1},
+		unicode.Range16{Lo: 0x94d, Hi: 0x94d, Stride: 0x1},
+		unicode.Range16{Lo: 0x94e, Hi: 0x94f, Stride: 0x1},
+		unicode.Range16{Lo: 0x951, Hi: 0x957, Stride: 0x1},
+		unicode.Range16{Lo: 0x962, Hi: 0x963, Stride: 0x1},
+		unicode.Range16{Lo: 0x981, Hi: 0x981, Stride: 0x1},
+		unicode.Range16{Lo: 0x982, Hi: 0x983, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bc, Hi: 0x9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9be, Hi: 0x9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c1, Hi: 0x9c4, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c7, Hi: 0x9c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cb, Hi: 0x9cc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cd, Hi: 0x9cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9d7, Hi: 0x9d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e2, Hi: 0x9e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa01, Hi: 0xa02, Stride: 0x1},
+		unicode.Range16{Lo: 0xa03, Hi: 0xa03, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3c, Hi: 0xa3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3e, Hi: 0xa40, Stride: 0x1},
+		unicode.Range16{Lo: 0xa41, Hi: 0xa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xa47, Hi: 0xa48, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4b, Hi: 0xa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa51, Hi: 0xa51, Stride: 0x1},
+		unicode.Range16{Lo: 0xa70, Hi: 0xa71, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75, Hi: 0xa75, Stride: 0x1},
+		unicode.Range16{Lo: 0xa81, Hi: 0xa82, Stride: 0x1},
+		unicode.Range16{Lo: 0xa83, Hi: 0xa83, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc, Hi: 0xabc, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe, Hi: 0xac0, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1, Hi: 0xac5, Stride: 0x1},
+		unicode.Range16{Lo: 0xac7, Hi: 0xac8, Stride: 0x1},
+		unicode.Range16{Lo: 0xac9, Hi: 0xac9, Stride: 0x1},
+		unicode.Range16{Lo: 0xacb, Hi: 0xacc, Stride: 0x1},
+		unicode.Range16{Lo: 0xacd, Hi: 0xacd, Stride: 0x1},
+		unicode.Range16{Lo: 0xae2, Hi: 0xae3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb01, Hi: 0xb01, Stride: 0x1},
+		unicode.Range16{Lo: 0xb02, Hi: 0xb03, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c, Hi: 0xb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e, Hi: 0xb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3f, Hi: 0xb3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb40, Hi: 0xb40, Stride: 0x1},
+		unicode.Range16{Lo: 0xb41, Hi: 0xb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xb47, Hi: 0xb48, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4b, Hi: 0xb4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4d, Hi: 0xb4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb56, Hi: 0xb56, Stride: 0x1},
+		unicode.Range16{Lo: 0xb57, Hi: 0xb57, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62, Hi: 0xb63, Stride: 0x1},
+		unicode.Range16{Lo: 0xb82, Hi: 0xb82, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbe, Hi: 0xbbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc0, Hi: 0xbc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc1, Hi: 0xbc2, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc6, Hi: 0xbc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca, Hi: 0xbcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd, Hi: 0xbcd, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd7, Hi: 0xbd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc00, Hi: 0xc00, Stride: 0x1},
+		unicode.Range16{Lo: 0xc01, Hi: 0xc03, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3e, Hi: 0xc40, Stride: 0x1},
+		unicode.Range16{Lo: 0xc41, Hi: 0xc44, Stride: 0x1},
+		unicode.Range16{Lo: 0xc46, Hi: 0xc48, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4a, Hi: 0xc4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc55, Hi: 0xc56, Stride: 0x1},
+		unicode.Range16{Lo: 0xc62, Hi: 0xc63, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81, Hi: 0xc81, Stride: 0x1},
+		unicode.Range16{Lo: 0xc82, Hi: 0xc83, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbc, Hi: 0xcbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbe, Hi: 0xcbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf, Hi: 0xcbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0, Hi: 0xcc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc6, Hi: 0xcc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7, Hi: 0xcc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcca, Hi: 0xccb, Stride: 0x1},
+		unicode.Range16{Lo: 0xccc, Hi: 0xccd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5, Hi: 0xcd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xce2, Hi: 0xce3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd01, Hi: 0xd01, Stride: 0x1},
+		unicode.Range16{Lo: 0xd02, Hi: 0xd03, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3e, Hi: 0xd40, Stride: 0x1},
+		unicode.Range16{Lo: 0xd41, Hi: 0xd44, Stride: 0x1},
+		unicode.Range16{Lo: 0xd46, Hi: 0xd48, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4a, Hi: 0xd4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4d, Hi: 0xd4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd57, Hi: 0xd57, Stride: 0x1},
+		unicode.Range16{Lo: 0xd62, Hi: 0xd63, Stride: 0x1},
+		unicode.Range16{Lo: 0xd82, Hi: 0xd83, Stride: 0x1},
+		unicode.Range16{Lo: 0xdca, Hi: 0xdca, Stride: 0x1},
+		unicode.Range16{Lo: 0xdcf, Hi: 0xdd1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd2, Hi: 0xdd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd6, Hi: 0xdd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd8, Hi: 0xddf, Stride: 0x1},
+		unicode.Range16{Lo: 0xdf2, Hi: 0xdf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xe31, Hi: 0xe31, Stride: 0x1},
+		unicode.Range16{Lo: 0xe34, Hi: 0xe3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xe47, Hi: 0xe4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb1, Hi: 0xeb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb4, Hi: 0xeb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xebb, Hi: 0xebc, Stride: 0x1},
+		unicode.Range16{Lo: 0xec8, Hi: 0xecd, Stride: 0x1},
+		unicode.Range16{Lo: 0xf18, Hi: 0xf19, Stride: 0x1},
+		unicode.Range16{Lo: 0xf35, Hi: 0xf35, Stride: 0x1},
+		unicode.Range16{Lo: 0xf37, Hi: 0xf37, Stride: 0x1},
+		unicode.Range16{Lo: 0xf39, Hi: 0xf39, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3e, Hi: 0xf3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf71, Hi: 0xf7e, Stride: 0x1},
+		unicode.Range16{Lo: 0xf7f, Hi: 0xf7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf80, Hi: 0xf84, Stride: 0x1},
+		unicode.Range16{Lo: 0xf86, Hi: 0xf87, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8d, Hi: 0xf97, Stride: 0x1},
+		unicode.Range16{Lo: 0xf99, Hi: 0xfbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xfc6, Hi: 0xfc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x102b, Hi: 0x102c, Stride: 0x1},
+		unicode.Range16{Lo: 0x102d, Hi: 0x1030, Stride: 0x1},
+		unicode.Range16{Lo: 0x1031, Hi: 0x1031, Stride: 0x1},
+		unicode.Range16{Lo: 0x1032, Hi: 0x1037, Stride: 0x1},
+		unicode.Range16{Lo: 0x1038, Hi: 0x1038, Stride: 0x1},
+		unicode.Range16{Lo: 0x1039, Hi: 0x103a, Stride: 0x1},
+		unicode.Range16{Lo: 0x103b, Hi: 0x103c, Stride: 0x1},
+		unicode.Range16{Lo: 0x103d, Hi: 0x103e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1056, Hi: 0x1057, Stride: 0x1},
+		unicode.Range16{Lo: 0x1058, Hi: 0x1059, Stride: 0x1},
+		unicode.Range16{Lo: 0x105e, Hi: 0x1060, Stride: 0x1},
+		unicode.Range16{Lo: 0x1062, Hi: 0x1064, Stride: 0x1},
+		unicode.Range16{Lo: 0x1067, Hi: 0x106d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1071, Hi: 0x1074, Stride: 0x1},
+		unicode.Range16{Lo: 0x1082, Hi: 0x1082, Stride: 0x1},
+		unicode.Range16{Lo: 0x1083, Hi: 0x1084, Stride: 0x1},
+		unicode.Range16{Lo: 0x1085, Hi: 0x1086, Stride: 0x1},
+		unicode.Range16{Lo: 0x1087, Hi: 0x108c, Stride: 0x1},
+		unicode.Range16{Lo: 0x108d, Hi: 0x108d, Stride: 0x1},
+		unicode.Range16{Lo: 0x108f, Hi: 0x108f, Stride: 0x1},
+		unicode.Range16{Lo: 0x109a, Hi: 0x109c, Stride: 0x1},
+		unicode.Range16{Lo: 0x109d, Hi: 0x109d, Stride: 0x1},
+		unicode.Range16{Lo: 0x135d, Hi: 0x135f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1712, Hi: 0x1714, Stride: 0x1},
+		unicode.Range16{Lo: 0x1732, Hi: 0x1734, Stride: 0x1},
+		unicode.Range16{Lo: 0x1752, Hi: 0x1753, Stride: 0x1},
+		unicode.Range16{Lo: 0x1772, Hi: 0x1773, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b4, Hi: 0x17b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b6, Hi: 0x17b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b7, Hi: 0x17bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x17be, Hi: 0x17c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c6, Hi: 0x17c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c7, Hi: 0x17c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c9, Hi: 0x17d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x17dd, Hi: 0x17dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x180b, Hi: 0x180d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1885, Hi: 0x1886, Stride: 0x1},
+		unicode.Range16{Lo: 0x18a9, Hi: 0x18a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1920, Hi: 0x1922, Stride: 0x1},
+		unicode.Range16{Lo: 0x1923, Hi: 0x1926, Stride: 0x1},
+		unicode.Range16{Lo: 0x1927, Hi: 0x1928, Stride: 0x1},
+		unicode.Range16{Lo: 0x1929, Hi: 0x192b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1930, Hi: 0x1931, Stride: 0x1},
+		unicode.Range16{Lo: 0x1932, Hi: 0x1932, Stride: 0x1},
+		unicode.Range16{Lo: 0x1933, Hi: 0x1938, Stride: 0x1},
+		unicode.Range16{Lo: 0x1939, Hi: 0x193b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a17, Hi: 0x1a18, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a19, Hi: 0x1a1a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a1b, Hi: 0x1a1b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a55, Hi: 0x1a55, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a56, Hi: 0x1a56, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a57, Hi: 0x1a57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a58, Hi: 0x1a5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a60, Hi: 0x1a60, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a61, Hi: 0x1a61, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a62, Hi: 0x1a62, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a63, Hi: 0x1a64, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a65, Hi: 0x1a6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a6d, Hi: 0x1a72, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a73, Hi: 0x1a7c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a7f, Hi: 0x1a7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ab0, Hi: 0x1abd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1abe, Hi: 0x1abe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b00, Hi: 0x1b03, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b04, Hi: 0x1b04, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b34, Hi: 0x1b34, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b35, Hi: 0x1b35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b36, Hi: 0x1b3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3b, Hi: 0x1b3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3c, Hi: 0x1b3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3d, Hi: 0x1b41, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b42, Hi: 0x1b42, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b43, Hi: 0x1b44, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b6b, Hi: 0x1b73, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b80, Hi: 0x1b81, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b82, Hi: 0x1b82, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba1, Hi: 0x1ba1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba2, Hi: 0x1ba5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba6, Hi: 0x1ba7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba8, Hi: 0x1ba9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1baa, Hi: 0x1baa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bab, Hi: 0x1bad, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be6, Hi: 0x1be6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be7, Hi: 0x1be7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be8, Hi: 0x1be9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bea, Hi: 0x1bec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bed, Hi: 0x1bed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bee, Hi: 0x1bee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bef, Hi: 0x1bf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bf2, Hi: 0x1bf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c24, Hi: 0x1c2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c2c, Hi: 0x1c33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c34, Hi: 0x1c35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c36, Hi: 0x1c37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd0, Hi: 0x1cd2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd4, Hi: 0x1ce0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce1, Hi: 0x1ce1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce2, Hi: 0x1ce8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ced, Hi: 0x1ced, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf2, Hi: 0x1cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf4, Hi: 0x1cf4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf8, Hi: 0x1cf9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dc0, Hi: 0x1df5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dfb, Hi: 0x1dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x200c, Hi: 0x200c, Stride: 0x1},
+		unicode.Range16{Lo: 0x20d0, Hi: 0x20dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x20dd, Hi: 0x20e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e1, Hi: 0x20e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e2, Hi: 0x20e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e5, Hi: 0x20f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cef, Hi: 0x2cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d7f, Hi: 0x2d7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2de0, Hi: 0x2dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x302a, Hi: 0x302d, Stride: 0x1},
+		unicode.Range16{Lo: 0x302e, Hi: 0x302f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3099, Hi: 0x309a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66f, Hi: 0xa66f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa670, Hi: 0xa672, Stride: 0x1},
+		unicode.Range16{Lo: 0xa674, Hi: 0xa67d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69e, Hi: 0xa69f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f0, Hi: 0xa6f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa802, Hi: 0xa802, Stride: 0x1},
+		unicode.Range16{Lo: 0xa806, Hi: 0xa806, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80b, Hi: 0xa80b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa823, Hi: 0xa824, Stride: 0x1},
+		unicode.Range16{Lo: 0xa825, Hi: 0xa826, Stride: 0x1},
+		unicode.Range16{Lo: 0xa827, Hi: 0xa827, Stride: 0x1},
+		unicode.Range16{Lo: 0xa880, Hi: 0xa881, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8b4, Hi: 0xa8c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8c4, Hi: 0xa8c5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8e0, Hi: 0xa8f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa926, Hi: 0xa92d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa947, Hi: 0xa951, Stride: 0x1},
+		unicode.Range16{Lo: 0xa952, Hi: 0xa953, Stride: 0x1},
+		unicode.Range16{Lo: 0xa980, Hi: 0xa982, Stride: 0x1},
+		unicode.Range16{Lo: 0xa983, Hi: 0xa983, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b3, Hi: 0xa9b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b4, Hi: 0xa9b5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b6, Hi: 0xa9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9ba, Hi: 0xa9bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bc, Hi: 0xa9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bd, Hi: 0xa9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e5, Hi: 0xa9e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa29, Hi: 0xaa2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa2f, Hi: 0xaa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa31, Hi: 0xaa32, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa33, Hi: 0xaa34, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa35, Hi: 0xaa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa43, Hi: 0xaa43, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4c, Hi: 0xaa4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4d, Hi: 0xaa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7b, Hi: 0xaa7b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7c, Hi: 0xaa7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7d, Hi: 0xaa7d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab0, Hi: 0xaab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab2, Hi: 0xaab4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab7, Hi: 0xaab8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaabe, Hi: 0xaabf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac1, Hi: 0xaac1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaeb, Hi: 0xaaeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaec, Hi: 0xaaed, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaee, Hi: 0xaaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf5, Hi: 0xaaf5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf6, Hi: 0xaaf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe3, Hi: 0xabe4, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe5, Hi: 0xabe5, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe6, Hi: 0xabe7, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe8, Hi: 0xabe8, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe9, Hi: 0xabea, Stride: 0x1},
+		unicode.Range16{Lo: 0xabec, Hi: 0xabec, Stride: 0x1},
+		unicode.Range16{Lo: 0xabed, Hi: 0xabed, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1e, Hi: 0xfb1e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe00, Hi: 0xfe0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe20, Hi: 0xfe2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff9e, Hi: 0xff9f, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x101fd, Hi: 0x101fd, Stride: 0x1},
+		unicode.Range32{Lo: 0x102e0, Hi: 0x102e0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10376, Hi: 0x1037a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a01, Hi: 0x10a03, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a05, Hi: 0x10a06, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a0c, Hi: 0x10a0f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a38, Hi: 0x10a3a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a3f, Hi: 0x10a3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ae5, Hi: 0x10ae6, Stride: 0x1},
+		unicode.Range32{Lo: 0x11000, Hi: 0x11000, Stride: 0x1},
+		unicode.Range32{Lo: 0x11001, Hi: 0x11001, Stride: 0x1},
+		unicode.Range32{Lo: 0x11002, Hi: 0x11002, Stride: 0x1},
+		unicode.Range32{Lo: 0x11038, Hi: 0x11046, Stride: 0x1},
+		unicode.Range32{Lo: 0x1107f, Hi: 0x11081, Stride: 0x1},
+		unicode.Range32{Lo: 0x11082, Hi: 0x11082, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b0, Hi: 0x110b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b3, Hi: 0x110b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b7, Hi: 0x110b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b9, Hi: 0x110ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x11100, Hi: 0x11102, Stride: 0x1},
+		unicode.Range32{Lo: 0x11127, Hi: 0x1112b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112c, Hi: 0x1112c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112d, Hi: 0x11134, Stride: 0x1},
+		unicode.Range32{Lo: 0x11173, Hi: 0x11173, Stride: 0x1},
+		unicode.Range32{Lo: 0x11180, Hi: 0x11181, Stride: 0x1},
+		unicode.Range32{Lo: 0x11182, Hi: 0x11182, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b3, Hi: 0x111b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b6, Hi: 0x111be, Stride: 0x1},
+		unicode.Range32{Lo: 0x111bf, Hi: 0x111c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x111ca, Hi: 0x111cc, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122c, Hi: 0x1122e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122f, Hi: 0x11231, Stride: 0x1},
+		unicode.Range32{Lo: 0x11232, Hi: 0x11233, Stride: 0x1},
+		unicode.Range32{Lo: 0x11234, Hi: 0x11234, Stride: 0x1},
+		unicode.Range32{Lo: 0x11235, Hi: 0x11235, Stride: 0x1},
+		unicode.Range32{Lo: 0x11236, Hi: 0x11237, Stride: 0x1},
+		unicode.Range32{Lo: 0x1123e, Hi: 0x1123e, Stride: 0x1},
+		unicode.Range32{Lo: 0x112df, Hi: 0x112df, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e0, Hi: 0x112e2, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e3, Hi: 0x112ea, Stride: 0x1},
+		unicode.Range32{Lo: 0x11300, Hi: 0x11301, Stride: 0x1},
+		unicode.Range32{Lo: 0x11302, Hi: 0x11303, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133c, Hi: 0x1133c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133e, Hi: 0x1133f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11340, Hi: 0x11340, Stride: 0x1},
+		unicode.Range32{Lo: 0x11341, Hi: 0x11344, Stride: 0x1},
+		unicode.Range32{Lo: 0x11347, Hi: 0x11348, Stride: 0x1},
+		unicode.Range32{Lo: 0x1134b, Hi: 0x1134d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11357, Hi: 0x11357, Stride: 0x1},
+		unicode.Range32{Lo: 0x11362, Hi: 0x11363, Stride: 0x1},
+		unicode.Range32{Lo: 0x11366, Hi: 0x1136c, Stride: 0x1},
+		unicode.Range32{Lo: 0x11370, Hi: 0x11374, Stride: 0x1},
+		unicode.Range32{Lo: 0x11435, Hi: 0x11437, Stride: 0x1},
+		unicode.Range32{Lo: 0x11438, Hi: 0x1143f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11440, Hi: 0x11441, Stride: 0x1},
+		unicode.Range32{Lo: 0x11442, Hi: 0x11444, Stride: 0x1},
+		unicode.Range32{Lo: 0x11445, Hi: 0x11445, Stride: 0x1},
+		unicode.Range32{Lo: 0x11446, Hi: 0x11446, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b0, Hi: 0x114b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b3, Hi: 0x114b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b9, Hi: 0x114b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x114ba, Hi: 0x114ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bb, Hi: 0x114be, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bf, Hi: 0x114c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c1, Hi: 0x114c1, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c2, Hi: 0x114c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x115af, Hi: 0x115b1, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b2, Hi: 0x115b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b8, Hi: 0x115bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bc, Hi: 0x115bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x115be, Hi: 0x115be, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bf, Hi: 0x115c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x115dc, Hi: 0x115dd, Stride: 0x1},
+		unicode.Range32{Lo: 0x11630, Hi: 0x11632, Stride: 0x1},
+		unicode.Range32{Lo: 0x11633, Hi: 0x1163a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163b, Hi: 0x1163c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163d, Hi: 0x1163d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163e, Hi: 0x1163e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163f, Hi: 0x11640, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ab, Hi: 0x116ab, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ac, Hi: 0x116ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ad, Hi: 0x116ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ae, Hi: 0x116af, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b0, Hi: 0x116b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b6, Hi: 0x116b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b7, Hi: 0x116b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x1171d, Hi: 0x1171f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11720, Hi: 0x11721, Stride: 0x1},
+		unicode.Range32{Lo: 0x11722, Hi: 0x11725, Stride: 0x1},
+		unicode.Range32{Lo: 0x11726, Hi: 0x11726, Stride: 0x1},
+		unicode.Range32{Lo: 0x11727, Hi: 0x1172b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c2f, Hi: 0x11c2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c30, Hi: 0x11c36, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c38, Hi: 0x11c3d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3e, Hi: 0x11c3e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3f, Hi: 0x11c3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c92, Hi: 0x11ca7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ca9, Hi: 0x11ca9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11caa, Hi: 0x11cb0, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb1, Hi: 0x11cb1, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb2, Hi: 0x11cb3, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb4, Hi: 0x11cb4, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb5, Hi: 0x11cb6, Stride: 0x1},
+		unicode.Range32{Lo: 0x16af0, Hi: 0x16af4, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b30, Hi: 0x16b36, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f51, Hi: 0x16f7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f8f, Hi: 0x16f92, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc9d, Hi: 0x1bc9e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d165, Hi: 0x1d166, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d167, Hi: 0x1d169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d16d, Hi: 0x1d172, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d17b, Hi: 0x1d182, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d185, Hi: 0x1d18b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d1aa, Hi: 0x1d1ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d242, Hi: 0x1d244, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da00, Hi: 0x1da36, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da3b, Hi: 0x1da6c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da75, Hi: 0x1da75, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da84, Hi: 0x1da84, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da9b, Hi: 0x1da9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1daa1, Hi: 0x1daaf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e000, Hi: 0x1e006, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e008, Hi: 0x1e018, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e01b, Hi: 0x1e021, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e023, Hi: 0x1e024, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e026, Hi: 0x1e02a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e8d0, Hi: 0x1e8d6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e944, Hi: 0x1e94a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0020, Hi: 0xe007f, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0100, Hi: 0xe01ef, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordExtendNumLet = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x5f, Hi: 0x5f, Stride: 0x1},
+		unicode.Range16{Lo: 0x202f, Hi: 0x202f, Stride: 0x1},
+		unicode.Range16{Lo: 0x203f, Hi: 0x2040, Stride: 0x1},
+		unicode.Range16{Lo: 0x2054, Hi: 0x2054, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe33, Hi: 0xfe34, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe4d, Hi: 0xfe4f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff3f, Hi: 0xff3f, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordFormat = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xad, Hi: 0xad, Stride: 0x1},
+		unicode.Range16{Lo: 0x600, Hi: 0x605, Stride: 0x1},
+		unicode.Range16{Lo: 0x61c, Hi: 0x61c, Stride: 0x1},
+		unicode.Range16{Lo: 0x6dd, Hi: 0x6dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x70f, Hi: 0x70f, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e2, Hi: 0x8e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x180e, Hi: 0x180e, Stride: 0x1},
+		unicode.Range16{Lo: 0x200e, Hi: 0x200f, Stride: 0x1},
+		unicode.Range16{Lo: 0x202a, Hi: 0x202e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2060, Hi: 0x2064, Stride: 0x1},
+		unicode.Range16{Lo: 0x2066, Hi: 0x206f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfeff, Hi: 0xfeff, Stride: 0x1},
+		unicode.Range16{Lo: 0xfff9, Hi: 0xfffb, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x110bd, Hi: 0x110bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bca0, Hi: 0x1bca3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d173, Hi: 0x1d17a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0001, Hi: 0xe0001, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordGlue_After_Zwj = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2764, Hi: 0x2764, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f48b, Hi: 0x1f48b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f5e8, Hi: 0x1f5e8, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordHebrew_Letter = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x5d0, Hi: 0x5ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f0, Hi: 0x5f2, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1d, Hi: 0xfb1d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1f, Hi: 0xfb28, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb2a, Hi: 0xfb36, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb38, Hi: 0xfb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb3e, Hi: 0xfb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb40, Hi: 0xfb41, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb43, Hi: 0xfb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb46, Hi: 0xfb4f, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordKatakana = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x3031, Hi: 0x3035, Stride: 0x1},
+		unicode.Range16{Lo: 0x309b, Hi: 0x309c, Stride: 0x1},
+		unicode.Range16{Lo: 0x30a0, Hi: 0x30a0, Stride: 0x1},
+		unicode.Range16{Lo: 0x30a1, Hi: 0x30fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x30fc, Hi: 0x30fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x30ff, Hi: 0x30ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x31f0, Hi: 0x31ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x32d0, Hi: 0x32fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x3300, Hi: 0x3357, Stride: 0x1},
+		unicode.Range16{Lo: 0xff66, Hi: 0xff6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff70, Hi: 0xff70, Stride: 0x1},
+		unicode.Range16{Lo: 0xff71, Hi: 0xff9d, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1b000, Hi: 0x1b000, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordLF = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xa, Hi: 0xa, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordMidLetter = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x3a, Hi: 0x3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7, Hi: 0xb7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d7, Hi: 0x2d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x387, Hi: 0x387, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f4, Hi: 0x5f4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2027, Hi: 0x2027, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe13, Hi: 0xfe13, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe55, Hi: 0xfe55, Stride: 0x1},
+		unicode.Range16{Lo: 0xff1a, Hi: 0xff1a, Stride: 0x1},
+	},
+	LatinOffset: 2,
+}
+
+var _WordMidNum = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2c, Hi: 0x2c, Stride: 0x1},
+		unicode.Range16{Lo: 0x3b, Hi: 0x3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x37e, Hi: 0x37e, Stride: 0x1},
+		unicode.Range16{Lo: 0x589, Hi: 0x589, Stride: 0x1},
+		unicode.Range16{Lo: 0x60c, Hi: 0x60d, Stride: 0x1},
+		unicode.Range16{Lo: 0x66c, Hi: 0x66c, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f8, Hi: 0x7f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2044, Hi: 0x2044, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe10, Hi: 0xfe10, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe14, Hi: 0xfe14, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe50, Hi: 0xfe50, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe54, Hi: 0xfe54, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0c, Hi: 0xff0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xff1b, Hi: 0xff1b, Stride: 0x1},
+	},
+	LatinOffset: 2,
+}
+
+var _WordMidNumLet = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2e, Hi: 0x2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2018, Hi: 0x2018, Stride: 0x1},
+		unicode.Range16{Lo: 0x2019, Hi: 0x2019, Stride: 0x1},
+		unicode.Range16{Lo: 0x2024, Hi: 0x2024, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe52, Hi: 0xfe52, Stride: 0x1},
+		unicode.Range16{Lo: 0xff07, Hi: 0xff07, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0e, Hi: 0xff0e, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordNewline = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xb, Hi: 0xc, Stride: 0x1},
+		unicode.Range16{Lo: 0x85, Hi: 0x85, Stride: 0x1},
+		unicode.Range16{Lo: 0x2028, Hi: 0x2028, Stride: 0x1},
+		unicode.Range16{Lo: 0x2029, Hi: 0x2029, Stride: 0x1},
+	},
+	LatinOffset: 2,
+}
+
+var _WordNumeric = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x30, Hi: 0x39, Stride: 0x1},
+		unicode.Range16{Lo: 0x660, Hi: 0x669, Stride: 0x1},
+		unicode.Range16{Lo: 0x66b, Hi: 0x66b, Stride: 0x1},
+		unicode.Range16{Lo: 0x6f0, Hi: 0x6f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x7c0, Hi: 0x7c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x966, Hi: 0x96f, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e6, Hi: 0x9ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66, Hi: 0xa6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xae6, Hi: 0xaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xb66, Hi: 0xb6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe6, Hi: 0xbef, Stride: 0x1},
+		unicode.Range16{Lo: 0xc66, Hi: 0xc6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xce6, Hi: 0xcef, Stride: 0x1},
+		unicode.Range16{Lo: 0xd66, Hi: 0xd6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xde6, Hi: 0xdef, Stride: 0x1},
+		unicode.Range16{Lo: 0xe50, Hi: 0xe59, Stride: 0x1},
+		unicode.Range16{Lo: 0xed0, Hi: 0xed9, Stride: 0x1},
+		unicode.Range16{Lo: 0xf20, Hi: 0xf29, Stride: 0x1},
+		unicode.Range16{Lo: 0x1040, Hi: 0x1049, Stride: 0x1},
+		unicode.Range16{Lo: 0x1090, Hi: 0x1099, Stride: 0x1},
+		unicode.Range16{Lo: 0x17e0, Hi: 0x17e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1810, Hi: 0x1819, Stride: 0x1},
+		unicode.Range16{Lo: 0x1946, Hi: 0x194f, Stride: 0x1},
+		unicode.Range16{Lo: 0x19d0, Hi: 0x19d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a80, Hi: 0x1a89, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a90, Hi: 0x1a99, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b50, Hi: 0x1b59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bb0, Hi: 0x1bb9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c40, Hi: 0x1c49, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c50, Hi: 0x1c59, Stride: 0x1},
+		unicode.Range16{Lo: 0xa620, Hi: 0xa629, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8d0, Hi: 0xa8d9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa900, Hi: 0xa909, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9d0, Hi: 0xa9d9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9f0, Hi: 0xa9f9, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa50, Hi: 0xaa59, Stride: 0x1},
+		unicode.Range16{Lo: 0xabf0, Hi: 0xabf9, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x104a0, Hi: 0x104a9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11066, Hi: 0x1106f, Stride: 0x1},
+		unicode.Range32{Lo: 0x110f0, Hi: 0x110f9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11136, Hi: 0x1113f, Stride: 0x1},
+		unicode.Range32{Lo: 0x111d0, Hi: 0x111d9, Stride: 0x1},
+		unicode.Range32{Lo: 0x112f0, Hi: 0x112f9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11450, Hi: 0x11459, Stride: 0x1},
+		unicode.Range32{Lo: 0x114d0, Hi: 0x114d9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11650, Hi: 0x11659, Stride: 0x1},
+		unicode.Range32{Lo: 0x116c0, Hi: 0x116c9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11730, Hi: 0x11739, Stride: 0x1},
+		unicode.Range32{Lo: 0x118e0, Hi: 0x118e9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c50, Hi: 0x11c59, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a60, Hi: 0x16a69, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b50, Hi: 0x16b59, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7ce, Hi: 0x1d7ff, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e950, Hi: 0x1e959, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordRegional_Indicator = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f1e6, Hi: 0x1f1ff, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordSingle_Quote = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x27, Hi: 0x27, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordZWJ = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x200d, Hi: 0x200d, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+type _WordRuneRange unicode.RangeTable
+
+func _WordRuneType(r rune) *_WordRuneRange {
+	switch {
+	case unicode.Is(_WordALetter, r):
+		return (*_WordRuneRange)(_WordALetter)
+	case unicode.Is(_WordCR, r):
+		return (*_WordRuneRange)(_WordCR)
+	case unicode.Is(_WordDouble_Quote, r):
+		return (*_WordRuneRange)(_WordDouble_Quote)
+	case unicode.Is(_WordE_Base, r):
+		return (*_WordRuneRange)(_WordE_Base)
+	case unicode.Is(_WordE_Base_GAZ, r):
+		return (*_WordRuneRange)(_WordE_Base_GAZ)
+	case unicode.Is(_WordE_Modifier, r):
+		return (*_WordRuneRange)(_WordE_Modifier)
+	case unicode.Is(_WordExtend, r):
+		return (*_WordRuneRange)(_WordExtend)
+	case unicode.Is(_WordExtendNumLet, r):
+		return (*_WordRuneRange)(_WordExtendNumLet)
+	case unicode.Is(_WordFormat, r):
+		return (*_WordRuneRange)(_WordFormat)
+	case unicode.Is(_WordGlue_After_Zwj, r):
+		return (*_WordRuneRange)(_WordGlue_After_Zwj)
+	case unicode.Is(_WordHebrew_Letter, r):
+		return (*_WordRuneRange)(_WordHebrew_Letter)
+	case unicode.Is(_WordKatakana, r):
+		return (*_WordRuneRange)(_WordKatakana)
+	case unicode.Is(_WordLF, r):
+		return (*_WordRuneRange)(_WordLF)
+	case unicode.Is(_WordMidLetter, r):
+		return (*_WordRuneRange)(_WordMidLetter)
+	case unicode.Is(_WordMidNum, r):
+		return (*_WordRuneRange)(_WordMidNum)
+	case unicode.Is(_WordMidNumLet, r):
+		return (*_WordRuneRange)(_WordMidNumLet)
+	case unicode.Is(_WordNewline, r):
+		return (*_WordRuneRange)(_WordNewline)
+	case unicode.Is(_WordNumeric, r):
+		return (*_WordRuneRange)(_WordNumeric)
+	case unicode.Is(_WordRegional_Indicator, r):
+		return (*_WordRuneRange)(_WordRegional_Indicator)
+	case unicode.Is(_WordSingle_Quote, r):
+		return (*_WordRuneRange)(_WordSingle_Quote)
+	case unicode.Is(_WordZWJ, r):
+		return (*_WordRuneRange)(_WordZWJ)
+	default:
+		return nil
+	}
+}
+func (rng *_WordRuneRange) String() string {
+	switch (*unicode.RangeTable)(rng) {
+	case _WordALetter:
+		return "ALetter"
+	case _WordCR:
+		return "CR"
+	case _WordDouble_Quote:
+		return "Double_Quote"
+	case _WordE_Base:
+		return "E_Base"
+	case _WordE_Base_GAZ:
+		return "E_Base_GAZ"
+	case _WordE_Modifier:
+		return "E_Modifier"
+	case _WordExtend:
+		return "Extend"
+	case _WordExtendNumLet:
+		return "ExtendNumLet"
+	case _WordFormat:
+		return "Format"
+	case _WordGlue_After_Zwj:
+		return "Glue_After_Zwj"
+	case _WordHebrew_Letter:
+		return "Hebrew_Letter"
+	case _WordKatakana:
+		return "Katakana"
+	case _WordLF:
+		return "LF"
+	case _WordMidLetter:
+		return "MidLetter"
+	case _WordMidNum:
+		return "MidNum"
+	case _WordMidNumLet:
+		return "MidNumLet"
+	case _WordNewline:
+		return "Newline"
+	case _WordNumeric:
+		return "Numeric"
+	case _WordRegional_Indicator:
+		return "Regional_Indicator"
+	case _WordSingle_Quote:
+		return "Single_Quote"
+	case _WordZWJ:
+		return "ZWJ"
+	default:
+		return "Other"
+	}
+}
+
+var _SentenceATerm = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2e, Hi: 0x2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2024, Hi: 0x2024, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe52, Hi: 0xfe52, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0e, Hi: 0xff0e, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceCR = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xd, Hi: 0xd, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceClose = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x22, Hi: 0x22, Stride: 0x1},
+		unicode.Range16{Lo: 0x27, Hi: 0x27, Stride: 0x1},
+		unicode.Range16{Lo: 0x28, Hi: 0x28, Stride: 0x1},
+		unicode.Range16{Lo: 0x29, Hi: 0x29, Stride: 0x1},
+		unicode.Range16{Lo: 0x5b, Hi: 0x5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x5d, Hi: 0x5d, Stride: 0x1},
+		unicode.Range16{Lo: 0x7b, Hi: 0x7b, Stride: 0x1},
+		unicode.Range16{Lo: 0x7d, Hi: 0x7d, Stride: 0x1},
+		unicode.Range16{Lo: 0xab, Hi: 0xab, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb, Hi: 0xbb, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3a, Hi: 0xf3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3b, Hi: 0xf3b, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3c, Hi: 0xf3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3d, Hi: 0xf3d, Stride: 0x1},
+		unicode.Range16{Lo: 0x169b, Hi: 0x169b, Stride: 0x1},
+		unicode.Range16{Lo: 0x169c, Hi: 0x169c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2018, Hi: 0x2018, Stride: 0x1},
+		unicode.Range16{Lo: 0x2019, Hi: 0x2019, Stride: 0x1},
+		unicode.Range16{Lo: 0x201a, Hi: 0x201a, Stride: 0x1},
+		unicode.Range16{Lo: 0x201b, Hi: 0x201c, Stride: 0x1},
+		unicode.Range16{Lo: 0x201d, Hi: 0x201d, Stride: 0x1},
+		unicode.Range16{Lo: 0x201e, Hi: 0x201e, Stride: 0x1},
+		unicode.Range16{Lo: 0x201f, Hi: 0x201f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2039, Hi: 0x2039, Stride: 0x1},
+		unicode.Range16{Lo: 0x203a, Hi: 0x203a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2045, Hi: 0x2045, Stride: 0x1},
+		unicode.Range16{Lo: 0x2046, Hi: 0x2046, Stride: 0x1},
+		unicode.Range16{Lo: 0x207d, Hi: 0x207d, Stride: 0x1},
+		unicode.Range16{Lo: 0x207e, Hi: 0x207e, Stride: 0x1},
+		unicode.Range16{Lo: 0x208d, Hi: 0x208d, Stride: 0x1},
+		unicode.Range16{Lo: 0x208e, Hi: 0x208e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2308, Hi: 0x2308, Stride: 0x1},
+		unicode.Range16{Lo: 0x2309, Hi: 0x2309, Stride: 0x1},
+		unicode.Range16{Lo: 0x230a, Hi: 0x230a, Stride: 0x1},
+		unicode.Range16{Lo: 0x230b, Hi: 0x230b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2329, Hi: 0x2329, Stride: 0x1},
+		unicode.Range16{Lo: 0x232a, Hi: 0x232a, Stride: 0x1},
+		unicode.Range16{Lo: 0x275b, Hi: 0x2760, Stride: 0x1},
+		unicode.Range16{Lo: 0x2768, Hi: 0x2768, Stride: 0x1},
+		unicode.Range16{Lo: 0x2769, Hi: 0x2769, Stride: 0x1},
+		unicode.Range16{Lo: 0x276a, Hi: 0x276a, Stride: 0x1},
+		unicode.Range16{Lo: 0x276b, Hi: 0x276b, Stride: 0x1},
+		unicode.Range16{Lo: 0x276c, Hi: 0x276c, Stride: 0x1},
+		unicode.Range16{Lo: 0x276d, Hi: 0x276d, Stride: 0x1},
+		unicode.Range16{Lo: 0x276e, Hi: 0x276e, Stride: 0x1},
+		unicode.Range16{Lo: 0x276f, Hi: 0x276f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2770, Hi: 0x2770, Stride: 0x1},
+		unicode.Range16{Lo: 0x2771, Hi: 0x2771, Stride: 0x1},
+		unicode.Range16{Lo: 0x2772, Hi: 0x2772, Stride: 0x1},
+		unicode.Range16{Lo: 0x2773, Hi: 0x2773, Stride: 0x1},
+		unicode.Range16{Lo: 0x2774, Hi: 0x2774, Stride: 0x1},
+		unicode.Range16{Lo: 0x2775, Hi: 0x2775, Stride: 0x1},
+		unicode.Range16{Lo: 0x27c5, Hi: 0x27c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x27c6, Hi: 0x27c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x27e6, Hi: 0x27e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x27e7, Hi: 0x27e7, Stride: 0x1},
+		unicode.Range16{Lo: 0x27e8, Hi: 0x27e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x27e9, Hi: 0x27e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ea, Hi: 0x27ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x27eb, Hi: 0x27eb, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ec, Hi: 0x27ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ed, Hi: 0x27ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ee, Hi: 0x27ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ef, Hi: 0x27ef, Stride: 0x1},
+		unicode.Range16{Lo: 0x2983, Hi: 0x2983, Stride: 0x1},
+		unicode.Range16{Lo: 0x2984, Hi: 0x2984, Stride: 0x1},
+		unicode.Range16{Lo: 0x2985, Hi: 0x2985, Stride: 0x1},
+		unicode.Range16{Lo: 0x2986, Hi: 0x2986, Stride: 0x1},
+		unicode.Range16{Lo: 0x2987, Hi: 0x2987, Stride: 0x1},
+		unicode.Range16{Lo: 0x2988, Hi: 0x2988, Stride: 0x1},
+		unicode.Range16{Lo: 0x2989, Hi: 0x2989, Stride: 0x1},
+		unicode.Range16{Lo: 0x298a, Hi: 0x298a, Stride: 0x1},
+		unicode.Range16{Lo: 0x298b, Hi: 0x298b, Stride: 0x1},
+		unicode.Range16{Lo: 0x298c, Hi: 0x298c, Stride: 0x1},
+		unicode.Range16{Lo: 0x298d, Hi: 0x298d, Stride: 0x1},
+		unicode.Range16{Lo: 0x298e, Hi: 0x298e, Stride: 0x1},
+		unicode.Range16{Lo: 0x298f, Hi: 0x298f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2990, Hi: 0x2990, Stride: 0x1},
+		unicode.Range16{Lo: 0x2991, Hi: 0x2991, Stride: 0x1},
+		unicode.Range16{Lo: 0x2992, Hi: 0x2992, Stride: 0x1},
+		unicode.Range16{Lo: 0x2993, Hi: 0x2993, Stride: 0x1},
+		unicode.Range16{Lo: 0x2994, Hi: 0x2994, Stride: 0x1},
+		unicode.Range16{Lo: 0x2995, Hi: 0x2995, Stride: 0x1},
+		unicode.Range16{Lo: 0x2996, Hi: 0x2996, Stride: 0x1},
+		unicode.Range16{Lo: 0x2997, Hi: 0x2997, Stride: 0x1},
+		unicode.Range16{Lo: 0x2998, Hi: 0x2998, Stride: 0x1},
+		unicode.Range16{Lo: 0x29d8, Hi: 0x29d8, Stride: 0x1},
+		unicode.Range16{Lo: 0x29d9, Hi: 0x29d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x29da, Hi: 0x29da, Stride: 0x1},
+		unicode.Range16{Lo: 0x29db, Hi: 0x29db, Stride: 0x1},
+		unicode.Range16{Lo: 0x29fc, Hi: 0x29fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x29fd, Hi: 0x29fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e00, Hi: 0x2e01, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e02, Hi: 0x2e02, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e03, Hi: 0x2e03, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e04, Hi: 0x2e04, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e05, Hi: 0x2e05, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e06, Hi: 0x2e08, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e09, Hi: 0x2e09, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0a, Hi: 0x2e0a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0b, Hi: 0x2e0b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0c, Hi: 0x2e0c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0d, Hi: 0x2e0d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e1c, Hi: 0x2e1c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e1d, Hi: 0x2e1d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e20, Hi: 0x2e20, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e21, Hi: 0x2e21, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e22, Hi: 0x2e22, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e23, Hi: 0x2e23, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e24, Hi: 0x2e24, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e25, Hi: 0x2e25, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e26, Hi: 0x2e26, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e27, Hi: 0x2e27, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e28, Hi: 0x2e28, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e29, Hi: 0x2e29, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e42, Hi: 0x2e42, Stride: 0x1},
+		unicode.Range16{Lo: 0x3008, Hi: 0x3008, Stride: 0x1},
+		unicode.Range16{Lo: 0x3009, Hi: 0x3009, Stride: 0x1},
+		unicode.Range16{Lo: 0x300a, Hi: 0x300a, Stride: 0x1},
+		unicode.Range16{Lo: 0x300b, Hi: 0x300b, Stride: 0x1},
+		unicode.Range16{Lo: 0x300c, Hi: 0x300c, Stride: 0x1},
+		unicode.Range16{Lo: 0x300d, Hi: 0x300d, Stride: 0x1},
+		unicode.Range16{Lo: 0x300e, Hi: 0x300e, Stride: 0x1},
+		unicode.Range16{Lo: 0x300f, Hi: 0x300f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3010, Hi: 0x3010, Stride: 0x1},
+		unicode.Range16{Lo: 0x3011, Hi: 0x3011, Stride: 0x1},
+		unicode.Range16{Lo: 0x3014, Hi: 0x3014, Stride: 0x1},
+		unicode.Range16{Lo: 0x3015, Hi: 0x3015, Stride: 0x1},
+		unicode.Range16{Lo: 0x3016, Hi: 0x3016, Stride: 0x1},
+		unicode.Range16{Lo: 0x3017, Hi: 0x3017, Stride: 0x1},
+		unicode.Range16{Lo: 0x3018, Hi: 0x3018, Stride: 0x1},
+		unicode.Range16{Lo: 0x3019, Hi: 0x3019, Stride: 0x1},
+		unicode.Range16{Lo: 0x301a, Hi: 0x301a, Stride: 0x1},
+		unicode.Range16{Lo: 0x301b, Hi: 0x301b, Stride: 0x1},
+		unicode.Range16{Lo: 0x301d, Hi: 0x301d, Stride: 0x1},
+		unicode.Range16{Lo: 0x301e, Hi: 0x301f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd3e, Hi: 0xfd3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd3f, Hi: 0xfd3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe17, Hi: 0xfe17, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe18, Hi: 0xfe18, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe35, Hi: 0xfe35, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe36, Hi: 0xfe36, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe37, Hi: 0xfe37, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe38, Hi: 0xfe38, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe39, Hi: 0xfe39, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3a, Hi: 0xfe3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3b, Hi: 0xfe3b, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3c, Hi: 0xfe3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3d, Hi: 0xfe3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3e, Hi: 0xfe3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3f, Hi: 0xfe3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe40, Hi: 0xfe40, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe41, Hi: 0xfe41, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe42, Hi: 0xfe42, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe43, Hi: 0xfe43, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe44, Hi: 0xfe44, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe47, Hi: 0xfe47, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe48, Hi: 0xfe48, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe59, Hi: 0xfe59, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5a, Hi: 0xfe5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5b, Hi: 0xfe5b, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5c, Hi: 0xfe5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5d, Hi: 0xfe5d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5e, Hi: 0xfe5e, Stride: 0x1},
+		unicode.Range16{Lo: 0xff08, Hi: 0xff08, Stride: 0x1},
+		unicode.Range16{Lo: 0xff09, Hi: 0xff09, Stride: 0x1},
+		unicode.Range16{Lo: 0xff3b, Hi: 0xff3b, Stride: 0x1},
+		unicode.Range16{Lo: 0xff3d, Hi: 0xff3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xff5b, Hi: 0xff5b, Stride: 0x1},
+		unicode.Range16{Lo: 0xff5d, Hi: 0xff5d, Stride: 0x1},
+		unicode.Range16{Lo: 0xff5f, Hi: 0xff5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff60, Hi: 0xff60, Stride: 0x1},
+		unicode.Range16{Lo: 0xff62, Hi: 0xff62, Stride: 0x1},
+		unicode.Range16{Lo: 0xff63, Hi: 0xff63, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f676, Hi: 0x1f678, Stride: 0x1},
+	},
+	LatinOffset: 10,
+}
+
+var _SentenceExtend = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x300, Hi: 0x36f, Stride: 0x1},
+		unicode.Range16{Lo: 0x483, Hi: 0x487, Stride: 0x1},
+		unicode.Range16{Lo: 0x488, Hi: 0x489, Stride: 0x1},
+		unicode.Range16{Lo: 0x591, Hi: 0x5bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x5bf, Hi: 0x5bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c1, Hi: 0x5c2, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c4, Hi: 0x5c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c7, Hi: 0x5c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x610, Hi: 0x61a, Stride: 0x1},
+		unicode.Range16{Lo: 0x64b, Hi: 0x65f, Stride: 0x1},
+		unicode.Range16{Lo: 0x670, Hi: 0x670, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d6, Hi: 0x6dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6df, Hi: 0x6e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e7, Hi: 0x6e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ea, Hi: 0x6ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x711, Hi: 0x711, Stride: 0x1},
+		unicode.Range16{Lo: 0x730, Hi: 0x74a, Stride: 0x1},
+		unicode.Range16{Lo: 0x7a6, Hi: 0x7b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x7eb, Hi: 0x7f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x816, Hi: 0x819, Stride: 0x1},
+		unicode.Range16{Lo: 0x81b, Hi: 0x823, Stride: 0x1},
+		unicode.Range16{Lo: 0x825, Hi: 0x827, Stride: 0x1},
+		unicode.Range16{Lo: 0x829, Hi: 0x82d, Stride: 0x1},
+		unicode.Range16{Lo: 0x859, Hi: 0x85b, Stride: 0x1},
+		unicode.Range16{Lo: 0x8d4, Hi: 0x8e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e3, Hi: 0x902, Stride: 0x1},
+		unicode.Range16{Lo: 0x903, Hi: 0x903, Stride: 0x1},
+		unicode.Range16{Lo: 0x93a, Hi: 0x93a, Stride: 0x1},
+		unicode.Range16{Lo: 0x93b, Hi: 0x93b, Stride: 0x1},
+		unicode.Range16{Lo: 0x93c, Hi: 0x93c, Stride: 0x1},
+		unicode.Range16{Lo: 0x93e, Hi: 0x940, Stride: 0x1},
+		unicode.Range16{Lo: 0x941, Hi: 0x948, Stride: 0x1},
+		unicode.Range16{Lo: 0x949, Hi: 0x94c, Stride: 0x1},
+		unicode.Range16{Lo: 0x94d, Hi: 0x94d, Stride: 0x1},
+		unicode.Range16{Lo: 0x94e, Hi: 0x94f, Stride: 0x1},
+		unicode.Range16{Lo: 0x951, Hi: 0x957, Stride: 0x1},
+		unicode.Range16{Lo: 0x962, Hi: 0x963, Stride: 0x1},
+		unicode.Range16{Lo: 0x981, Hi: 0x981, Stride: 0x1},
+		unicode.Range16{Lo: 0x982, Hi: 0x983, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bc, Hi: 0x9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9be, Hi: 0x9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c1, Hi: 0x9c4, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c7, Hi: 0x9c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cb, Hi: 0x9cc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cd, Hi: 0x9cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9d7, Hi: 0x9d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e2, Hi: 0x9e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa01, Hi: 0xa02, Stride: 0x1},
+		unicode.Range16{Lo: 0xa03, Hi: 0xa03, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3c, Hi: 0xa3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3e, Hi: 0xa40, Stride: 0x1},
+		unicode.Range16{Lo: 0xa41, Hi: 0xa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xa47, Hi: 0xa48, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4b, Hi: 0xa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa51, Hi: 0xa51, Stride: 0x1},
+		unicode.Range16{Lo: 0xa70, Hi: 0xa71, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75, Hi: 0xa75, Stride: 0x1},
+		unicode.Range16{Lo: 0xa81, Hi: 0xa82, Stride: 0x1},
+		unicode.Range16{Lo: 0xa83, Hi: 0xa83, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc, Hi: 0xabc, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe, Hi: 0xac0, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1, Hi: 0xac5, Stride: 0x1},
+		unicode.Range16{Lo: 0xac7, Hi: 0xac8, Stride: 0x1},
+		unicode.Range16{Lo: 0xac9, Hi: 0xac9, Stride: 0x1},
+		unicode.Range16{Lo: 0xacb, Hi: 0xacc, Stride: 0x1},
+		unicode.Range16{Lo: 0xacd, Hi: 0xacd, Stride: 0x1},
+		unicode.Range16{Lo: 0xae2, Hi: 0xae3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb01, Hi: 0xb01, Stride: 0x1},
+		unicode.Range16{Lo: 0xb02, Hi: 0xb03, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c, Hi: 0xb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e, Hi: 0xb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3f, Hi: 0xb3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb40, Hi: 0xb40, Stride: 0x1},
+		unicode.Range16{Lo: 0xb41, Hi: 0xb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xb47, Hi: 0xb48, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4b, Hi: 0xb4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4d, Hi: 0xb4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb56, Hi: 0xb56, Stride: 0x1},
+		unicode.Range16{Lo: 0xb57, Hi: 0xb57, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62, Hi: 0xb63, Stride: 0x1},
+		unicode.Range16{Lo: 0xb82, Hi: 0xb82, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbe, Hi: 0xbbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc0, Hi: 0xbc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc1, Hi: 0xbc2, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc6, Hi: 0xbc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca, Hi: 0xbcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd, Hi: 0xbcd, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd7, Hi: 0xbd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc00, Hi: 0xc00, Stride: 0x1},
+		unicode.Range16{Lo: 0xc01, Hi: 0xc03, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3e, Hi: 0xc40, Stride: 0x1},
+		unicode.Range16{Lo: 0xc41, Hi: 0xc44, Stride: 0x1},
+		unicode.Range16{Lo: 0xc46, Hi: 0xc48, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4a, Hi: 0xc4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc55, Hi: 0xc56, Stride: 0x1},
+		unicode.Range16{Lo: 0xc62, Hi: 0xc63, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81, Hi: 0xc81, Stride: 0x1},
+		unicode.Range16{Lo: 0xc82, Hi: 0xc83, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbc, Hi: 0xcbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbe, Hi: 0xcbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf, Hi: 0xcbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0, Hi: 0xcc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc6, Hi: 0xcc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7, Hi: 0xcc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcca, Hi: 0xccb, Stride: 0x1},
+		unicode.Range16{Lo: 0xccc, Hi: 0xccd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5, Hi: 0xcd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xce2, Hi: 0xce3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd01, Hi: 0xd01, Stride: 0x1},
+		unicode.Range16{Lo: 0xd02, Hi: 0xd03, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3e, Hi: 0xd40, Stride: 0x1},
+		unicode.Range16{Lo: 0xd41, Hi: 0xd44, Stride: 0x1},
+		unicode.Range16{Lo: 0xd46, Hi: 0xd48, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4a, Hi: 0xd4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4d, Hi: 0xd4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd57, Hi: 0xd57, Stride: 0x1},
+		unicode.Range16{Lo: 0xd62, Hi: 0xd63, Stride: 0x1},
+		unicode.Range16{Lo: 0xd82, Hi: 0xd83, Stride: 0x1},
+		unicode.Range16{Lo: 0xdca, Hi: 0xdca, Stride: 0x1},
+		unicode.Range16{Lo: 0xdcf, Hi: 0xdd1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd2, Hi: 0xdd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd6, Hi: 0xdd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd8, Hi: 0xddf, Stride: 0x1},
+		unicode.Range16{Lo: 0xdf2, Hi: 0xdf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xe31, Hi: 0xe31, Stride: 0x1},
+		unicode.Range16{Lo: 0xe34, Hi: 0xe3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xe47, Hi: 0xe4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb1, Hi: 0xeb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb4, Hi: 0xeb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xebb, Hi: 0xebc, Stride: 0x1},
+		unicode.Range16{Lo: 0xec8, Hi: 0xecd, Stride: 0x1},
+		unicode.Range16{Lo: 0xf18, Hi: 0xf19, Stride: 0x1},
+		unicode.Range16{Lo: 0xf35, Hi: 0xf35, Stride: 0x1},
+		unicode.Range16{Lo: 0xf37, Hi: 0xf37, Stride: 0x1},
+		unicode.Range16{Lo: 0xf39, Hi: 0xf39, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3e, Hi: 0xf3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf71, Hi: 0xf7e, Stride: 0x1},
+		unicode.Range16{Lo: 0xf7f, Hi: 0xf7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf80, Hi: 0xf84, Stride: 0x1},
+		unicode.Range16{Lo: 0xf86, Hi: 0xf87, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8d, Hi: 0xf97, Stride: 0x1},
+		unicode.Range16{Lo: 0xf99, Hi: 0xfbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xfc6, Hi: 0xfc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x102b, Hi: 0x102c, Stride: 0x1},
+		unicode.Range16{Lo: 0x102d, Hi: 0x1030, Stride: 0x1},
+		unicode.Range16{Lo: 0x1031, Hi: 0x1031, Stride: 0x1},
+		unicode.Range16{Lo: 0x1032, Hi: 0x1037, Stride: 0x1},
+		unicode.Range16{Lo: 0x1038, Hi: 0x1038, Stride: 0x1},
+		unicode.Range16{Lo: 0x1039, Hi: 0x103a, Stride: 0x1},
+		unicode.Range16{Lo: 0x103b, Hi: 0x103c, Stride: 0x1},
+		unicode.Range16{Lo: 0x103d, Hi: 0x103e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1056, Hi: 0x1057, Stride: 0x1},
+		unicode.Range16{Lo: 0x1058, Hi: 0x1059, Stride: 0x1},
+		unicode.Range16{Lo: 0x105e, Hi: 0x1060, Stride: 0x1},
+		unicode.Range16{Lo: 0x1062, Hi: 0x1064, Stride: 0x1},
+		unicode.Range16{Lo: 0x1067, Hi: 0x106d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1071, Hi: 0x1074, Stride: 0x1},
+		unicode.Range16{Lo: 0x1082, Hi: 0x1082, Stride: 0x1},
+		unicode.Range16{Lo: 0x1083, Hi: 0x1084, Stride: 0x1},
+		unicode.Range16{Lo: 0x1085, Hi: 0x1086, Stride: 0x1},
+		unicode.Range16{Lo: 0x1087, Hi: 0x108c, Stride: 0x1},
+		unicode.Range16{Lo: 0x108d, Hi: 0x108d, Stride: 0x1},
+		unicode.Range16{Lo: 0x108f, Hi: 0x108f, Stride: 0x1},
+		unicode.Range16{Lo: 0x109a, Hi: 0x109c, Stride: 0x1},
+		unicode.Range16{Lo: 0x109d, Hi: 0x109d, Stride: 0x1},
+		unicode.Range16{Lo: 0x135d, Hi: 0x135f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1712, Hi: 0x1714, Stride: 0x1},
+		unicode.Range16{Lo: 0x1732, Hi: 0x1734, Stride: 0x1},
+		unicode.Range16{Lo: 0x1752, Hi: 0x1753, Stride: 0x1},
+		unicode.Range16{Lo: 0x1772, Hi: 0x1773, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b4, Hi: 0x17b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b6, Hi: 0x17b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b7, Hi: 0x17bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x17be, Hi: 0x17c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c6, Hi: 0x17c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c7, Hi: 0x17c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c9, Hi: 0x17d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x17dd, Hi: 0x17dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x180b, Hi: 0x180d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1885, Hi: 0x1886, Stride: 0x1},
+		unicode.Range16{Lo: 0x18a9, Hi: 0x18a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1920, Hi: 0x1922, Stride: 0x1},
+		unicode.Range16{Lo: 0x1923, Hi: 0x1926, Stride: 0x1},
+		unicode.Range16{Lo: 0x1927, Hi: 0x1928, Stride: 0x1},
+		unicode.Range16{Lo: 0x1929, Hi: 0x192b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1930, Hi: 0x1931, Stride: 0x1},
+		unicode.Range16{Lo: 0x1932, Hi: 0x1932, Stride: 0x1},
+		unicode.Range16{Lo: 0x1933, Hi: 0x1938, Stride: 0x1},
+		unicode.Range16{Lo: 0x1939, Hi: 0x193b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a17, Hi: 0x1a18, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a19, Hi: 0x1a1a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a1b, Hi: 0x1a1b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a55, Hi: 0x1a55, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a56, Hi: 0x1a56, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a57, Hi: 0x1a57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a58, Hi: 0x1a5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a60, Hi: 0x1a60, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a61, Hi: 0x1a61, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a62, Hi: 0x1a62, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a63, Hi: 0x1a64, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a65, Hi: 0x1a6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a6d, Hi: 0x1a72, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a73, Hi: 0x1a7c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a7f, Hi: 0x1a7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ab0, Hi: 0x1abd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1abe, Hi: 0x1abe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b00, Hi: 0x1b03, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b04, Hi: 0x1b04, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b34, Hi: 0x1b34, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b35, Hi: 0x1b35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b36, Hi: 0x1b3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3b, Hi: 0x1b3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3c, Hi: 0x1b3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3d, Hi: 0x1b41, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b42, Hi: 0x1b42, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b43, Hi: 0x1b44, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b6b, Hi: 0x1b73, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b80, Hi: 0x1b81, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b82, Hi: 0x1b82, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba1, Hi: 0x1ba1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba2, Hi: 0x1ba5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba6, Hi: 0x1ba7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba8, Hi: 0x1ba9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1baa, Hi: 0x1baa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bab, Hi: 0x1bad, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be6, Hi: 0x1be6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be7, Hi: 0x1be7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be8, Hi: 0x1be9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bea, Hi: 0x1bec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bed, Hi: 0x1bed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bee, Hi: 0x1bee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bef, Hi: 0x1bf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bf2, Hi: 0x1bf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c24, Hi: 0x1c2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c2c, Hi: 0x1c33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c34, Hi: 0x1c35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c36, Hi: 0x1c37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd0, Hi: 0x1cd2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd4, Hi: 0x1ce0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce1, Hi: 0x1ce1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce2, Hi: 0x1ce8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ced, Hi: 0x1ced, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf2, Hi: 0x1cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf4, Hi: 0x1cf4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf8, Hi: 0x1cf9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dc0, Hi: 0x1df5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dfb, Hi: 0x1dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x200c, Hi: 0x200d, Stride: 0x1},
+		unicode.Range16{Lo: 0x20d0, Hi: 0x20dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x20dd, Hi: 0x20e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e1, Hi: 0x20e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e2, Hi: 0x20e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e5, Hi: 0x20f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cef, Hi: 0x2cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d7f, Hi: 0x2d7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2de0, Hi: 0x2dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x302a, Hi: 0x302d, Stride: 0x1},
+		unicode.Range16{Lo: 0x302e, Hi: 0x302f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3099, Hi: 0x309a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66f, Hi: 0xa66f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa670, Hi: 0xa672, Stride: 0x1},
+		unicode.Range16{Lo: 0xa674, Hi: 0xa67d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69e, Hi: 0xa69f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f0, Hi: 0xa6f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa802, Hi: 0xa802, Stride: 0x1},
+		unicode.Range16{Lo: 0xa806, Hi: 0xa806, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80b, Hi: 0xa80b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa823, Hi: 0xa824, Stride: 0x1},
+		unicode.Range16{Lo: 0xa825, Hi: 0xa826, Stride: 0x1},
+		unicode.Range16{Lo: 0xa827, Hi: 0xa827, Stride: 0x1},
+		unicode.Range16{Lo: 0xa880, Hi: 0xa881, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8b4, Hi: 0xa8c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8c4, Hi: 0xa8c5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8e0, Hi: 0xa8f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa926, Hi: 0xa92d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa947, Hi: 0xa951, Stride: 0x1},
+		unicode.Range16{Lo: 0xa952, Hi: 0xa953, Stride: 0x1},
+		unicode.Range16{Lo: 0xa980, Hi: 0xa982, Stride: 0x1},
+		unicode.Range16{Lo: 0xa983, Hi: 0xa983, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b3, Hi: 0xa9b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b4, Hi: 0xa9b5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b6, Hi: 0xa9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9ba, Hi: 0xa9bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bc, Hi: 0xa9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bd, Hi: 0xa9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e5, Hi: 0xa9e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa29, Hi: 0xaa2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa2f, Hi: 0xaa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa31, Hi: 0xaa32, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa33, Hi: 0xaa34, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa35, Hi: 0xaa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa43, Hi: 0xaa43, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4c, Hi: 0xaa4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4d, Hi: 0xaa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7b, Hi: 0xaa7b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7c, Hi: 0xaa7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7d, Hi: 0xaa7d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab0, Hi: 0xaab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab2, Hi: 0xaab4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab7, Hi: 0xaab8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaabe, Hi: 0xaabf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac1, Hi: 0xaac1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaeb, Hi: 0xaaeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaec, Hi: 0xaaed, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaee, Hi: 0xaaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf5, Hi: 0xaaf5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf6, Hi: 0xaaf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe3, Hi: 0xabe4, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe5, Hi: 0xabe5, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe6, Hi: 0xabe7, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe8, Hi: 0xabe8, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe9, Hi: 0xabea, Stride: 0x1},
+		unicode.Range16{Lo: 0xabec, Hi: 0xabec, Stride: 0x1},
+		unicode.Range16{Lo: 0xabed, Hi: 0xabed, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1e, Hi: 0xfb1e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe00, Hi: 0xfe0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe20, Hi: 0xfe2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff9e, Hi: 0xff9f, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x101fd, Hi: 0x101fd, Stride: 0x1},
+		unicode.Range32{Lo: 0x102e0, Hi: 0x102e0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10376, Hi: 0x1037a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a01, Hi: 0x10a03, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a05, Hi: 0x10a06, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a0c, Hi: 0x10a0f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a38, Hi: 0x10a3a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a3f, Hi: 0x10a3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ae5, Hi: 0x10ae6, Stride: 0x1},
+		unicode.Range32{Lo: 0x11000, Hi: 0x11000, Stride: 0x1},
+		unicode.Range32{Lo: 0x11001, Hi: 0x11001, Stride: 0x1},
+		unicode.Range32{Lo: 0x11002, Hi: 0x11002, Stride: 0x1},
+		unicode.Range32{Lo: 0x11038, Hi: 0x11046, Stride: 0x1},
+		unicode.Range32{Lo: 0x1107f, Hi: 0x11081, Stride: 0x1},
+		unicode.Range32{Lo: 0x11082, Hi: 0x11082, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b0, Hi: 0x110b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b3, Hi: 0x110b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b7, Hi: 0x110b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b9, Hi: 0x110ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x11100, Hi: 0x11102, Stride: 0x1},
+		unicode.Range32{Lo: 0x11127, Hi: 0x1112b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112c, Hi: 0x1112c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112d, Hi: 0x11134, Stride: 0x1},
+		unicode.Range32{Lo: 0x11173, Hi: 0x11173, Stride: 0x1},
+		unicode.Range32{Lo: 0x11180, Hi: 0x11181, Stride: 0x1},
+		unicode.Range32{Lo: 0x11182, Hi: 0x11182, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b3, Hi: 0x111b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b6, Hi: 0x111be, Stride: 0x1},
+		unicode.Range32{Lo: 0x111bf, Hi: 0x111c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x111ca, Hi: 0x111cc, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122c, Hi: 0x1122e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122f, Hi: 0x11231, Stride: 0x1},
+		unicode.Range32{Lo: 0x11232, Hi: 0x11233, Stride: 0x1},
+		unicode.Range32{Lo: 0x11234, Hi: 0x11234, Stride: 0x1},
+		unicode.Range32{Lo: 0x11235, Hi: 0x11235, Stride: 0x1},
+		unicode.Range32{Lo: 0x11236, Hi: 0x11237, Stride: 0x1},
+		unicode.Range32{Lo: 0x1123e, Hi: 0x1123e, Stride: 0x1},
+		unicode.Range32{Lo: 0x112df, Hi: 0x112df, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e0, Hi: 0x112e2, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e3, Hi: 0x112ea, Stride: 0x1},
+		unicode.Range32{Lo: 0x11300, Hi: 0x11301, Stride: 0x1},
+		unicode.Range32{Lo: 0x11302, Hi: 0x11303, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133c, Hi: 0x1133c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133e, Hi: 0x1133f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11340, Hi: 0x11340, Stride: 0x1},
+		unicode.Range32{Lo: 0x11341, Hi: 0x11344, Stride: 0x1},
+		unicode.Range32{Lo: 0x11347, Hi: 0x11348, Stride: 0x1},
+		unicode.Range32{Lo: 0x1134b, Hi: 0x1134d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11357, Hi: 0x11357, Stride: 0x1},
+		unicode.Range32{Lo: 0x11362, Hi: 0x11363, Stride: 0x1},
+		unicode.Range32{Lo: 0x11366, Hi: 0x1136c, Stride: 0x1},
+		unicode.Range32{Lo: 0x11370, Hi: 0x11374, Stride: 0x1},
+		unicode.Range32{Lo: 0x11435, Hi: 0x11437, Stride: 0x1},
+		unicode.Range32{Lo: 0x11438, Hi: 0x1143f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11440, Hi: 0x11441, Stride: 0x1},
+		unicode.Range32{Lo: 0x11442, Hi: 0x11444, Stride: 0x1},
+		unicode.Range32{Lo: 0x11445, Hi: 0x11445, Stride: 0x1},
+		unicode.Range32{Lo: 0x11446, Hi: 0x11446, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b0, Hi: 0x114b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b3, Hi: 0x114b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b9, Hi: 0x114b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x114ba, Hi: 0x114ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bb, Hi: 0x114be, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bf, Hi: 0x114c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c1, Hi: 0x114c1, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c2, Hi: 0x114c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x115af, Hi: 0x115b1, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b2, Hi: 0x115b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b8, Hi: 0x115bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bc, Hi: 0x115bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x115be, Hi: 0x115be, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bf, Hi: 0x115c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x115dc, Hi: 0x115dd, Stride: 0x1},
+		unicode.Range32{Lo: 0x11630, Hi: 0x11632, Stride: 0x1},
+		unicode.Range32{Lo: 0x11633, Hi: 0x1163a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163b, Hi: 0x1163c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163d, Hi: 0x1163d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163e, Hi: 0x1163e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163f, Hi: 0x11640, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ab, Hi: 0x116ab, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ac, Hi: 0x116ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ad, Hi: 0x116ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ae, Hi: 0x116af, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b0, Hi: 0x116b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b6, Hi: 0x116b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b7, Hi: 0x116b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x1171d, Hi: 0x1171f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11720, Hi: 0x11721, Stride: 0x1},
+		unicode.Range32{Lo: 0x11722, Hi: 0x11725, Stride: 0x1},
+		unicode.Range32{Lo: 0x11726, Hi: 0x11726, Stride: 0x1},
+		unicode.Range32{Lo: 0x11727, Hi: 0x1172b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c2f, Hi: 0x11c2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c30, Hi: 0x11c36, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c38, Hi: 0x11c3d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3e, Hi: 0x11c3e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3f, Hi: 0x11c3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c92, Hi: 0x11ca7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ca9, Hi: 0x11ca9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11caa, Hi: 0x11cb0, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb1, Hi: 0x11cb1, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb2, Hi: 0x11cb3, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb4, Hi: 0x11cb4, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb5, Hi: 0x11cb6, Stride: 0x1},
+		unicode.Range32{Lo: 0x16af0, Hi: 0x16af4, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b30, Hi: 0x16b36, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f51, Hi: 0x16f7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f8f, Hi: 0x16f92, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc9d, Hi: 0x1bc9e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d165, Hi: 0x1d166, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d167, Hi: 0x1d169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d16d, Hi: 0x1d172, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d17b, Hi: 0x1d182, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d185, Hi: 0x1d18b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d1aa, Hi: 0x1d1ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d242, Hi: 0x1d244, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da00, Hi: 0x1da36, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da3b, Hi: 0x1da6c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da75, Hi: 0x1da75, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da84, Hi: 0x1da84, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da9b, Hi: 0x1da9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1daa1, Hi: 0x1daaf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e000, Hi: 0x1e006, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e008, Hi: 0x1e018, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e01b, Hi: 0x1e021, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e023, Hi: 0x1e024, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e026, Hi: 0x1e02a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e8d0, Hi: 0x1e8d6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e944, Hi: 0x1e94a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0020, Hi: 0xe007f, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0100, Hi: 0xe01ef, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _SentenceFormat = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xad, Hi: 0xad, Stride: 0x1},
+		unicode.Range16{Lo: 0x600, Hi: 0x605, Stride: 0x1},
+		unicode.Range16{Lo: 0x61c, Hi: 0x61c, Stride: 0x1},
+		unicode.Range16{Lo: 0x6dd, Hi: 0x6dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x70f, Hi: 0x70f, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e2, Hi: 0x8e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x180e, Hi: 0x180e, Stride: 0x1},
+		unicode.Range16{Lo: 0x200b, Hi: 0x200b, Stride: 0x1},
+		unicode.Range16{Lo: 0x200e, Hi: 0x200f, Stride: 0x1},
+		unicode.Range16{Lo: 0x202a, Hi: 0x202e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2060, Hi: 0x2064, Stride: 0x1},
+		unicode.Range16{Lo: 0x2066, Hi: 0x206f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfeff, Hi: 0xfeff, Stride: 0x1},
+		unicode.Range16{Lo: 0xfff9, Hi: 0xfffb, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x110bd, Hi: 0x110bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bca0, Hi: 0x1bca3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d173, Hi: 0x1d17a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0001, Hi: 0xe0001, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceLF = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xa, Hi: 0xa, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceLower = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x61, Hi: 0x7a, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa, Hi: 0xaa, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5, Hi: 0xb5, Stride: 0x1},
+		unicode.Range16{Lo: 0xba, Hi: 0xba, Stride: 0x1},
+		unicode.Range16{Lo: 0xdf, Hi: 0xf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8, Hi: 0xff, Stride: 0x1},
+		unicode.Range16{Lo: 0x101, Hi: 0x101, Stride: 0x1},
+		unicode.Range16{Lo: 0x103, Hi: 0x103, Stride: 0x1},
+		unicode.Range16{Lo: 0x105, Hi: 0x105, Stride: 0x1},
+		unicode.Range16{Lo: 0x107, Hi: 0x107, Stride: 0x1},
+		unicode.Range16{Lo: 0x109, Hi: 0x109, Stride: 0x1},
+		unicode.Range16{Lo: 0x10b, Hi: 0x10b, Stride: 0x1},
+		unicode.Range16{Lo: 0x10d, Hi: 0x10d, Stride: 0x1},
+		unicode.Range16{Lo: 0x10f, Hi: 0x10f, Stride: 0x1},
+		unicode.Range16{Lo: 0x111, Hi: 0x111, Stride: 0x1},
+		unicode.Range16{Lo: 0x113, Hi: 0x113, Stride: 0x1},
+		unicode.Range16{Lo: 0x115, Hi: 0x115, Stride: 0x1},
+		unicode.Range16{Lo: 0x117, Hi: 0x117, Stride: 0x1},
+		unicode.Range16{Lo: 0x119, Hi: 0x119, Stride: 0x1},
+		unicode.Range16{Lo: 0x11b, Hi: 0x11b, Stride: 0x1},
+		unicode.Range16{Lo: 0x11d, Hi: 0x11d, Stride: 0x1},
+		unicode.Range16{Lo: 0x11f, Hi: 0x11f, Stride: 0x1},
+		unicode.Range16{Lo: 0x121, Hi: 0x121, Stride: 0x1},
+		unicode.Range16{Lo: 0x123, Hi: 0x123, Stride: 0x1},
+		unicode.Range16{Lo: 0x125, Hi: 0x125, Stride: 0x1},
+		unicode.Range16{Lo: 0x127, Hi: 0x127, Stride: 0x1},
+		unicode.Range16{Lo: 0x129, Hi: 0x129, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b, Hi: 0x12b, Stride: 0x1},
+		unicode.Range16{Lo: 0x12d, Hi: 0x12d, Stride: 0x1},
+		unicode.Range16{Lo: 0x12f, Hi: 0x12f, Stride: 0x1},
+		unicode.Range16{Lo: 0x131, Hi: 0x131, Stride: 0x1},
+		unicode.Range16{Lo: 0x133, Hi: 0x133, Stride: 0x1},
+		unicode.Range16{Lo: 0x135, Hi: 0x135, Stride: 0x1},
+		unicode.Range16{Lo: 0x137, Hi: 0x138, Stride: 0x1},
+		unicode.Range16{Lo: 0x13a, Hi: 0x13a, Stride: 0x1},
+		unicode.Range16{Lo: 0x13c, Hi: 0x13c, Stride: 0x1},
+		unicode.Range16{Lo: 0x13e, Hi: 0x13e, Stride: 0x1},
+		unicode.Range16{Lo: 0x140, Hi: 0x140, Stride: 0x1},
+		unicode.Range16{Lo: 0x142, Hi: 0x142, Stride: 0x1},
+		unicode.Range16{Lo: 0x144, Hi: 0x144, Stride: 0x1},
+		unicode.Range16{Lo: 0x146, Hi: 0x146, Stride: 0x1},
+		unicode.Range16{Lo: 0x148, Hi: 0x149, Stride: 0x1},
+		unicode.Range16{Lo: 0x14b, Hi: 0x14b, Stride: 0x1},
+		unicode.Range16{Lo: 0x14d, Hi: 0x14d, Stride: 0x1},
+		unicode.Range16{Lo: 0x14f, Hi: 0x14f, Stride: 0x1},
+		unicode.Range16{Lo: 0x151, Hi: 0x151, Stride: 0x1},
+		unicode.Range16{Lo: 0x153, Hi: 0x153, Stride: 0x1},
+		unicode.Range16{Lo: 0x155, Hi: 0x155, Stride: 0x1},
+		unicode.Range16{Lo: 0x157, Hi: 0x157, Stride: 0x1},
+		unicode.Range16{Lo: 0x159, Hi: 0x159, Stride: 0x1},
+		unicode.Range16{Lo: 0x15b, Hi: 0x15b, Stride: 0x1},
+		unicode.Range16{Lo: 0x15d, Hi: 0x15d, Stride: 0x1},
+		unicode.Range16{Lo: 0x15f, Hi: 0x15f, Stride: 0x1},
+		unicode.Range16{Lo: 0x161, Hi: 0x161, Stride: 0x1},
+		unicode.Range16{Lo: 0x163, Hi: 0x163, Stride: 0x1},
+		unicode.Range16{Lo: 0x165, Hi: 0x165, Stride: 0x1},
+		unicode.Range16{Lo: 0x167, Hi: 0x167, Stride: 0x1},
+		unicode.Range16{Lo: 0x169, Hi: 0x169, Stride: 0x1},
+		unicode.Range16{Lo: 0x16b, Hi: 0x16b, Stride: 0x1},
+		unicode.Range16{Lo: 0x16d, Hi: 0x16d, Stride: 0x1},
+		unicode.Range16{Lo: 0x16f, Hi: 0x16f, Stride: 0x1},
+		unicode.Range16{Lo: 0x171, Hi: 0x171, Stride: 0x1},
+		unicode.Range16{Lo: 0x173, Hi: 0x173, Stride: 0x1},
+		unicode.Range16{Lo: 0x175, Hi: 0x175, Stride: 0x1},
+		unicode.Range16{Lo: 0x177, Hi: 0x177, Stride: 0x1},
+		unicode.Range16{Lo: 0x17a, Hi: 0x17a, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c, Hi: 0x17c, Stride: 0x1},
+		unicode.Range16{Lo: 0x17e, Hi: 0x180, Stride: 0x1},
+		unicode.Range16{Lo: 0x183, Hi: 0x183, Stride: 0x1},
+		unicode.Range16{Lo: 0x185, Hi: 0x185, Stride: 0x1},
+		unicode.Range16{Lo: 0x188, Hi: 0x188, Stride: 0x1},
+		unicode.Range16{Lo: 0x18c, Hi: 0x18d, Stride: 0x1},
+		unicode.Range16{Lo: 0x192, Hi: 0x192, Stride: 0x1},
+		unicode.Range16{Lo: 0x195, Hi: 0x195, Stride: 0x1},
+		unicode.Range16{Lo: 0x199, Hi: 0x19b, Stride: 0x1},
+		unicode.Range16{Lo: 0x19e, Hi: 0x19e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a1, Hi: 0x1a1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a3, Hi: 0x1a3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a5, Hi: 0x1a5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a8, Hi: 0x1a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1aa, Hi: 0x1ab, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ad, Hi: 0x1ad, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b0, Hi: 0x1b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b4, Hi: 0x1b4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b6, Hi: 0x1b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b9, Hi: 0x1ba, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bd, Hi: 0x1bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c6, Hi: 0x1c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c9, Hi: 0x1c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cc, Hi: 0x1cc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce, Hi: 0x1ce, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d0, Hi: 0x1d0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d2, Hi: 0x1d2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d4, Hi: 0x1d4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d6, Hi: 0x1d6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d8, Hi: 0x1d8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1da, Hi: 0x1da, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dc, Hi: 0x1dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1df, Hi: 0x1df, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1, Hi: 0x1e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3, Hi: 0x1e3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5, Hi: 0x1e5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7, Hi: 0x1e7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e9, Hi: 0x1e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb, Hi: 0x1eb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed, Hi: 0x1ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef, Hi: 0x1f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f3, Hi: 0x1f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5, Hi: 0x1f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f9, Hi: 0x1f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb, Hi: 0x1fb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd, Hi: 0x1fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff, Hi: 0x1ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x201, Hi: 0x201, Stride: 0x1},
+		unicode.Range16{Lo: 0x203, Hi: 0x203, Stride: 0x1},
+		unicode.Range16{Lo: 0x205, Hi: 0x205, Stride: 0x1},
+		unicode.Range16{Lo: 0x207, Hi: 0x207, Stride: 0x1},
+		unicode.Range16{Lo: 0x209, Hi: 0x209, Stride: 0x1},
+		unicode.Range16{Lo: 0x20b, Hi: 0x20b, Stride: 0x1},
+		unicode.Range16{Lo: 0x20d, Hi: 0x20d, Stride: 0x1},
+		unicode.Range16{Lo: 0x20f, Hi: 0x20f, Stride: 0x1},
+		unicode.Range16{Lo: 0x211, Hi: 0x211, Stride: 0x1},
+		unicode.Range16{Lo: 0x213, Hi: 0x213, Stride: 0x1},
+		unicode.Range16{Lo: 0x215, Hi: 0x215, Stride: 0x1},
+		unicode.Range16{Lo: 0x217, Hi: 0x217, Stride: 0x1},
+		unicode.Range16{Lo: 0x219, Hi: 0x219, Stride: 0x1},
+		unicode.Range16{Lo: 0x21b, Hi: 0x21b, Stride: 0x1},
+		unicode.Range16{Lo: 0x21d, Hi: 0x21d, Stride: 0x1},
+		unicode.Range16{Lo: 0x21f, Hi: 0x21f, Stride: 0x1},
+		unicode.Range16{Lo: 0x221, Hi: 0x221, Stride: 0x1},
+		unicode.Range16{Lo: 0x223, Hi: 0x223, Stride: 0x1},
+		unicode.Range16{Lo: 0x225, Hi: 0x225, Stride: 0x1},
+		unicode.Range16{Lo: 0x227, Hi: 0x227, Stride: 0x1},
+		unicode.Range16{Lo: 0x229, Hi: 0x229, Stride: 0x1},
+		unicode.Range16{Lo: 0x22b, Hi: 0x22b, Stride: 0x1},
+		unicode.Range16{Lo: 0x22d, Hi: 0x22d, Stride: 0x1},
+		unicode.Range16{Lo: 0x22f, Hi: 0x22f, Stride: 0x1},
+		unicode.Range16{Lo: 0x231, Hi: 0x231, Stride: 0x1},
+		unicode.Range16{Lo: 0x233, Hi: 0x239, Stride: 0x1},
+		unicode.Range16{Lo: 0x23c, Hi: 0x23c, Stride: 0x1},
+		unicode.Range16{Lo: 0x23f, Hi: 0x240, Stride: 0x1},
+		unicode.Range16{Lo: 0x242, Hi: 0x242, Stride: 0x1},
+		unicode.Range16{Lo: 0x247, Hi: 0x247, Stride: 0x1},
+		unicode.Range16{Lo: 0x249, Hi: 0x249, Stride: 0x1},
+		unicode.Range16{Lo: 0x24b, Hi: 0x24b, Stride: 0x1},
+		unicode.Range16{Lo: 0x24d, Hi: 0x24d, Stride: 0x1},
+		unicode.Range16{Lo: 0x24f, Hi: 0x293, Stride: 0x1},
+		unicode.Range16{Lo: 0x295, Hi: 0x2af, Stride: 0x1},
+		unicode.Range16{Lo: 0x2b0, Hi: 0x2b8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c0, Hi: 0x2c1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0, Hi: 0x2e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x371, Hi: 0x371, Stride: 0x1},
+		unicode.Range16{Lo: 0x373, Hi: 0x373, Stride: 0x1},
+		unicode.Range16{Lo: 0x377, Hi: 0x377, Stride: 0x1},
+		unicode.Range16{Lo: 0x37a, Hi: 0x37a, Stride: 0x1},
+		unicode.Range16{Lo: 0x37b, Hi: 0x37d, Stride: 0x1},
+		unicode.Range16{Lo: 0x390, Hi: 0x390, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ac, Hi: 0x3ce, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d0, Hi: 0x3d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d5, Hi: 0x3d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d9, Hi: 0x3d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x3db, Hi: 0x3db, Stride: 0x1},
+		unicode.Range16{Lo: 0x3dd, Hi: 0x3dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x3df, Hi: 0x3df, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e1, Hi: 0x3e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e3, Hi: 0x3e3, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e5, Hi: 0x3e5, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e7, Hi: 0x3e7, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e9, Hi: 0x3e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x3eb, Hi: 0x3eb, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ed, Hi: 0x3ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ef, Hi: 0x3f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f5, Hi: 0x3f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f8, Hi: 0x3f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x3fb, Hi: 0x3fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x430, Hi: 0x45f, Stride: 0x1},
+		unicode.Range16{Lo: 0x461, Hi: 0x461, Stride: 0x1},
+		unicode.Range16{Lo: 0x463, Hi: 0x463, Stride: 0x1},
+		unicode.Range16{Lo: 0x465, Hi: 0x465, Stride: 0x1},
+		unicode.Range16{Lo: 0x467, Hi: 0x467, Stride: 0x1},
+		unicode.Range16{Lo: 0x469, Hi: 0x469, Stride: 0x1},
+		unicode.Range16{Lo: 0x46b, Hi: 0x46b, Stride: 0x1},
+		unicode.Range16{Lo: 0x46d, Hi: 0x46d, Stride: 0x1},
+		unicode.Range16{Lo: 0x46f, Hi: 0x46f, Stride: 0x1},
+		unicode.Range16{Lo: 0x471, Hi: 0x471, Stride: 0x1},
+		unicode.Range16{Lo: 0x473, Hi: 0x473, Stride: 0x1},
+		unicode.Range16{Lo: 0x475, Hi: 0x475, Stride: 0x1},
+		unicode.Range16{Lo: 0x477, Hi: 0x477, Stride: 0x1},
+		unicode.Range16{Lo: 0x479, Hi: 0x479, Stride: 0x1},
+		unicode.Range16{Lo: 0x47b, Hi: 0x47b, Stride: 0x1},
+		unicode.Range16{Lo: 0x47d, Hi: 0x47d, Stride: 0x1},
+		unicode.Range16{Lo: 0x47f, Hi: 0x47f, Stride: 0x1},
+		unicode.Range16{Lo: 0x481, Hi: 0x481, Stride: 0x1},
+		unicode.Range16{Lo: 0x48b, Hi: 0x48b, Stride: 0x1},
+		unicode.Range16{Lo: 0x48d, Hi: 0x48d, Stride: 0x1},
+		unicode.Range16{Lo: 0x48f, Hi: 0x48f, Stride: 0x1},
+		unicode.Range16{Lo: 0x491, Hi: 0x491, Stride: 0x1},
+		unicode.Range16{Lo: 0x493, Hi: 0x493, Stride: 0x1},
+		unicode.Range16{Lo: 0x495, Hi: 0x495, Stride: 0x1},
+		unicode.Range16{Lo: 0x497, Hi: 0x497, Stride: 0x1},
+		unicode.Range16{Lo: 0x499, Hi: 0x499, Stride: 0x1},
+		unicode.Range16{Lo: 0x49b, Hi: 0x49b, Stride: 0x1},
+		unicode.Range16{Lo: 0x49d, Hi: 0x49d, Stride: 0x1},
+		unicode.Range16{Lo: 0x49f, Hi: 0x49f, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a1, Hi: 0x4a1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a3, Hi: 0x4a3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a5, Hi: 0x4a5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a7, Hi: 0x4a7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a9, Hi: 0x4a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ab, Hi: 0x4ab, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ad, Hi: 0x4ad, Stride: 0x1},
+		unicode.Range16{Lo: 0x4af, Hi: 0x4af, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b1, Hi: 0x4b1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b3, Hi: 0x4b3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b5, Hi: 0x4b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b7, Hi: 0x4b7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b9, Hi: 0x4b9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4bb, Hi: 0x4bb, Stride: 0x1},
+		unicode.Range16{Lo: 0x4bd, Hi: 0x4bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x4bf, Hi: 0x4bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c2, Hi: 0x4c2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c4, Hi: 0x4c4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c6, Hi: 0x4c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c8, Hi: 0x4c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ca, Hi: 0x4ca, Stride: 0x1},
+		unicode.Range16{Lo: 0x4cc, Hi: 0x4cc, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ce, Hi: 0x4cf, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d1, Hi: 0x4d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d3, Hi: 0x4d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d5, Hi: 0x4d5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d7, Hi: 0x4d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d9, Hi: 0x4d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4db, Hi: 0x4db, Stride: 0x1},
+		unicode.Range16{Lo: 0x4dd, Hi: 0x4dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x4df, Hi: 0x4df, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e1, Hi: 0x4e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e3, Hi: 0x4e3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e5, Hi: 0x4e5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e7, Hi: 0x4e7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e9, Hi: 0x4e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4eb, Hi: 0x4eb, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ed, Hi: 0x4ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ef, Hi: 0x4ef, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f1, Hi: 0x4f1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f3, Hi: 0x4f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f5, Hi: 0x4f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f7, Hi: 0x4f7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f9, Hi: 0x4f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fb, Hi: 0x4fb, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fd, Hi: 0x4fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ff, Hi: 0x4ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x501, Hi: 0x501, Stride: 0x1},
+		unicode.Range16{Lo: 0x503, Hi: 0x503, Stride: 0x1},
+		unicode.Range16{Lo: 0x505, Hi: 0x505, Stride: 0x1},
+		unicode.Range16{Lo: 0x507, Hi: 0x507, Stride: 0x1},
+		unicode.Range16{Lo: 0x509, Hi: 0x509, Stride: 0x1},
+		unicode.Range16{Lo: 0x50b, Hi: 0x50b, Stride: 0x1},
+		unicode.Range16{Lo: 0x50d, Hi: 0x50d, Stride: 0x1},
+		unicode.Range16{Lo: 0x50f, Hi: 0x50f, Stride: 0x1},
+		unicode.Range16{Lo: 0x511, Hi: 0x511, Stride: 0x1},
+		unicode.Range16{Lo: 0x513, Hi: 0x513, Stride: 0x1},
+		unicode.Range16{Lo: 0x515, Hi: 0x515, Stride: 0x1},
+		unicode.Range16{Lo: 0x517, Hi: 0x517, Stride: 0x1},
+		unicode.Range16{Lo: 0x519, Hi: 0x519, Stride: 0x1},
+		unicode.Range16{Lo: 0x51b, Hi: 0x51b, Stride: 0x1},
+		unicode.Range16{Lo: 0x51d, Hi: 0x51d, Stride: 0x1},
+		unicode.Range16{Lo: 0x51f, Hi: 0x51f, Stride: 0x1},
+		unicode.Range16{Lo: 0x521, Hi: 0x521, Stride: 0x1},
+		unicode.Range16{Lo: 0x523, Hi: 0x523, Stride: 0x1},
+		unicode.Range16{Lo: 0x525, Hi: 0x525, Stride: 0x1},
+		unicode.Range16{Lo: 0x527, Hi: 0x527, Stride: 0x1},
+		unicode.Range16{Lo: 0x529, Hi: 0x529, Stride: 0x1},
+		unicode.Range16{Lo: 0x52b, Hi: 0x52b, Stride: 0x1},
+		unicode.Range16{Lo: 0x52d, Hi: 0x52d, Stride: 0x1},
+		unicode.Range16{Lo: 0x52f, Hi: 0x52f, Stride: 0x1},
+		unicode.Range16{Lo: 0x561, Hi: 0x587, Stride: 0x1},
+		unicode.Range16{Lo: 0x13f8, Hi: 0x13fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c80, Hi: 0x1c88, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d00, Hi: 0x1d2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d2c, Hi: 0x1d6a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d6b, Hi: 0x1d77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d78, Hi: 0x1d78, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d79, Hi: 0x1d9a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d9b, Hi: 0x1dbf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e01, Hi: 0x1e01, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e03, Hi: 0x1e03, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e05, Hi: 0x1e05, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e07, Hi: 0x1e07, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e09, Hi: 0x1e09, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0b, Hi: 0x1e0b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0d, Hi: 0x1e0d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0f, Hi: 0x1e0f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e11, Hi: 0x1e11, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e13, Hi: 0x1e13, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e15, Hi: 0x1e15, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e17, Hi: 0x1e17, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e19, Hi: 0x1e19, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1b, Hi: 0x1e1b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1d, Hi: 0x1e1d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1f, Hi: 0x1e1f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e21, Hi: 0x1e21, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e23, Hi: 0x1e23, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e25, Hi: 0x1e25, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e27, Hi: 0x1e27, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e29, Hi: 0x1e29, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2b, Hi: 0x1e2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2d, Hi: 0x1e2d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2f, Hi: 0x1e2f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e31, Hi: 0x1e31, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e33, Hi: 0x1e33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e35, Hi: 0x1e35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e37, Hi: 0x1e37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e39, Hi: 0x1e39, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3b, Hi: 0x1e3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3d, Hi: 0x1e3d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3f, Hi: 0x1e3f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e41, Hi: 0x1e41, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e43, Hi: 0x1e43, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e45, Hi: 0x1e45, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e47, Hi: 0x1e47, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e49, Hi: 0x1e49, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4b, Hi: 0x1e4b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4d, Hi: 0x1e4d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4f, Hi: 0x1e4f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e51, Hi: 0x1e51, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e53, Hi: 0x1e53, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e55, Hi: 0x1e55, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e57, Hi: 0x1e57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e59, Hi: 0x1e59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5b, Hi: 0x1e5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5d, Hi: 0x1e5d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5f, Hi: 0x1e5f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e61, Hi: 0x1e61, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e63, Hi: 0x1e63, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e65, Hi: 0x1e65, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e67, Hi: 0x1e67, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e69, Hi: 0x1e69, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6b, Hi: 0x1e6b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6d, Hi: 0x1e6d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6f, Hi: 0x1e6f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e71, Hi: 0x1e71, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e73, Hi: 0x1e73, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e75, Hi: 0x1e75, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e77, Hi: 0x1e77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e79, Hi: 0x1e79, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7b, Hi: 0x1e7b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7d, Hi: 0x1e7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7f, Hi: 0x1e7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e81, Hi: 0x1e81, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e83, Hi: 0x1e83, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e85, Hi: 0x1e85, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e87, Hi: 0x1e87, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e89, Hi: 0x1e89, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8b, Hi: 0x1e8b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8d, Hi: 0x1e8d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8f, Hi: 0x1e8f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e91, Hi: 0x1e91, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e93, Hi: 0x1e93, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e95, Hi: 0x1e9d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e9f, Hi: 0x1e9f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea1, Hi: 0x1ea1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea3, Hi: 0x1ea3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea5, Hi: 0x1ea5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea7, Hi: 0x1ea7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea9, Hi: 0x1ea9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eab, Hi: 0x1eab, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ead, Hi: 0x1ead, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eaf, Hi: 0x1eaf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb1, Hi: 0x1eb1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb3, Hi: 0x1eb3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb5, Hi: 0x1eb5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb7, Hi: 0x1eb7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb9, Hi: 0x1eb9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebb, Hi: 0x1ebb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebd, Hi: 0x1ebd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebf, Hi: 0x1ebf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec1, Hi: 0x1ec1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec3, Hi: 0x1ec3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec5, Hi: 0x1ec5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec7, Hi: 0x1ec7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec9, Hi: 0x1ec9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ecb, Hi: 0x1ecb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ecd, Hi: 0x1ecd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ecf, Hi: 0x1ecf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed1, Hi: 0x1ed1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed3, Hi: 0x1ed3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed5, Hi: 0x1ed5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed7, Hi: 0x1ed7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed9, Hi: 0x1ed9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1edb, Hi: 0x1edb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1edd, Hi: 0x1edd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1edf, Hi: 0x1edf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee1, Hi: 0x1ee1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee3, Hi: 0x1ee3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee5, Hi: 0x1ee5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee7, Hi: 0x1ee7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee9, Hi: 0x1ee9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eeb, Hi: 0x1eeb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eed, Hi: 0x1eed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eef, Hi: 0x1eef, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef1, Hi: 0x1ef1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef3, Hi: 0x1ef3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef5, Hi: 0x1ef5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef7, Hi: 0x1ef7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef9, Hi: 0x1ef9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efb, Hi: 0x1efb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efd, Hi: 0x1efd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eff, Hi: 0x1f07, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f10, Hi: 0x1f15, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f20, Hi: 0x1f27, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f30, Hi: 0x1f37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f40, Hi: 0x1f45, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f50, Hi: 0x1f57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f60, Hi: 0x1f67, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f70, Hi: 0x1f7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f80, Hi: 0x1f87, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f90, Hi: 0x1f97, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fa0, Hi: 0x1fa7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb0, Hi: 0x1fb4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb6, Hi: 0x1fb7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fbe, Hi: 0x1fbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc2, Hi: 0x1fc4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc6, Hi: 0x1fc7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd0, Hi: 0x1fd3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd6, Hi: 0x1fd7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fe0, Hi: 0x1fe7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff2, Hi: 0x1ff4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff6, Hi: 0x1ff7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2071, Hi: 0x2071, Stride: 0x1},
+		unicode.Range16{Lo: 0x207f, Hi: 0x207f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2090, Hi: 0x209c, Stride: 0x1},
+		unicode.Range16{Lo: 0x210a, Hi: 0x210a, Stride: 0x1},
+		unicode.Range16{Lo: 0x210e, Hi: 0x210f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2113, Hi: 0x2113, Stride: 0x1},
+		unicode.Range16{Lo: 0x212f, Hi: 0x212f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2134, Hi: 0x2134, Stride: 0x1},
+		unicode.Range16{Lo: 0x2139, Hi: 0x2139, Stride: 0x1},
+		unicode.Range16{Lo: 0x213c, Hi: 0x213d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2146, Hi: 0x2149, Stride: 0x1},
+		unicode.Range16{Lo: 0x214e, Hi: 0x214e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2170, Hi: 0x217f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2184, Hi: 0x2184, Stride: 0x1},
+		unicode.Range16{Lo: 0x24d0, Hi: 0x24e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c30, Hi: 0x2c5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c61, Hi: 0x2c61, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c65, Hi: 0x2c66, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c68, Hi: 0x2c68, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6a, Hi: 0x2c6a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6c, Hi: 0x2c6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c71, Hi: 0x2c71, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c73, Hi: 0x2c74, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c76, Hi: 0x2c7b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c7c, Hi: 0x2c7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c81, Hi: 0x2c81, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c83, Hi: 0x2c83, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c85, Hi: 0x2c85, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c87, Hi: 0x2c87, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c89, Hi: 0x2c89, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8b, Hi: 0x2c8b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8d, Hi: 0x2c8d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8f, Hi: 0x2c8f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c91, Hi: 0x2c91, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c93, Hi: 0x2c93, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c95, Hi: 0x2c95, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c97, Hi: 0x2c97, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c99, Hi: 0x2c99, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9b, Hi: 0x2c9b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9d, Hi: 0x2c9d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9f, Hi: 0x2c9f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca1, Hi: 0x2ca1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca3, Hi: 0x2ca3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca5, Hi: 0x2ca5, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca7, Hi: 0x2ca7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca9, Hi: 0x2ca9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cab, Hi: 0x2cab, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cad, Hi: 0x2cad, Stride: 0x1},
+		unicode.Range16{Lo: 0x2caf, Hi: 0x2caf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb1, Hi: 0x2cb1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb3, Hi: 0x2cb3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb5, Hi: 0x2cb5, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb7, Hi: 0x2cb7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb9, Hi: 0x2cb9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbb, Hi: 0x2cbb, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbd, Hi: 0x2cbd, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbf, Hi: 0x2cbf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc1, Hi: 0x2cc1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc3, Hi: 0x2cc3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc5, Hi: 0x2cc5, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc7, Hi: 0x2cc7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc9, Hi: 0x2cc9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ccb, Hi: 0x2ccb, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ccd, Hi: 0x2ccd, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ccf, Hi: 0x2ccf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd1, Hi: 0x2cd1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd3, Hi: 0x2cd3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd5, Hi: 0x2cd5, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd7, Hi: 0x2cd7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd9, Hi: 0x2cd9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cdb, Hi: 0x2cdb, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cdd, Hi: 0x2cdd, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cdf, Hi: 0x2cdf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ce1, Hi: 0x2ce1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ce3, Hi: 0x2ce4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cec, Hi: 0x2cec, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cee, Hi: 0x2cee, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cf3, Hi: 0x2cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d00, Hi: 0x2d25, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d27, Hi: 0x2d27, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d2d, Hi: 0x2d2d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa641, Hi: 0xa641, Stride: 0x1},
+		unicode.Range16{Lo: 0xa643, Hi: 0xa643, Stride: 0x1},
+		unicode.Range16{Lo: 0xa645, Hi: 0xa645, Stride: 0x1},
+		unicode.Range16{Lo: 0xa647, Hi: 0xa647, Stride: 0x1},
+		unicode.Range16{Lo: 0xa649, Hi: 0xa649, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64b, Hi: 0xa64b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64d, Hi: 0xa64d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64f, Hi: 0xa64f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa651, Hi: 0xa651, Stride: 0x1},
+		unicode.Range16{Lo: 0xa653, Hi: 0xa653, Stride: 0x1},
+		unicode.Range16{Lo: 0xa655, Hi: 0xa655, Stride: 0x1},
+		unicode.Range16{Lo: 0xa657, Hi: 0xa657, Stride: 0x1},
+		unicode.Range16{Lo: 0xa659, Hi: 0xa659, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65b, Hi: 0xa65b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65d, Hi: 0xa65d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65f, Hi: 0xa65f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa661, Hi: 0xa661, Stride: 0x1},
+		unicode.Range16{Lo: 0xa663, Hi: 0xa663, Stride: 0x1},
+		unicode.Range16{Lo: 0xa665, Hi: 0xa665, Stride: 0x1},
+		unicode.Range16{Lo: 0xa667, Hi: 0xa667, Stride: 0x1},
+		unicode.Range16{Lo: 0xa669, Hi: 0xa669, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66b, Hi: 0xa66b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66d, Hi: 0xa66d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa681, Hi: 0xa681, Stride: 0x1},
+		unicode.Range16{Lo: 0xa683, Hi: 0xa683, Stride: 0x1},
+		unicode.Range16{Lo: 0xa685, Hi: 0xa685, Stride: 0x1},
+		unicode.Range16{Lo: 0xa687, Hi: 0xa687, Stride: 0x1},
+		unicode.Range16{Lo: 0xa689, Hi: 0xa689, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68b, Hi: 0xa68b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68d, Hi: 0xa68d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68f, Hi: 0xa68f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa691, Hi: 0xa691, Stride: 0x1},
+		unicode.Range16{Lo: 0xa693, Hi: 0xa693, Stride: 0x1},
+		unicode.Range16{Lo: 0xa695, Hi: 0xa695, Stride: 0x1},
+		unicode.Range16{Lo: 0xa697, Hi: 0xa697, Stride: 0x1},
+		unicode.Range16{Lo: 0xa699, Hi: 0xa699, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69b, Hi: 0xa69b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69c, Hi: 0xa69d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa723, Hi: 0xa723, Stride: 0x1},
+		unicode.Range16{Lo: 0xa725, Hi: 0xa725, Stride: 0x1},
+		unicode.Range16{Lo: 0xa727, Hi: 0xa727, Stride: 0x1},
+		unicode.Range16{Lo: 0xa729, Hi: 0xa729, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72b, Hi: 0xa72b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72d, Hi: 0xa72d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72f, Hi: 0xa731, Stride: 0x1},
+		unicode.Range16{Lo: 0xa733, Hi: 0xa733, Stride: 0x1},
+		unicode.Range16{Lo: 0xa735, Hi: 0xa735, Stride: 0x1},
+		unicode.Range16{Lo: 0xa737, Hi: 0xa737, Stride: 0x1},
+		unicode.Range16{Lo: 0xa739, Hi: 0xa739, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73b, Hi: 0xa73b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73d, Hi: 0xa73d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73f, Hi: 0xa73f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa741, Hi: 0xa741, Stride: 0x1},
+		unicode.Range16{Lo: 0xa743, Hi: 0xa743, Stride: 0x1},
+		unicode.Range16{Lo: 0xa745, Hi: 0xa745, Stride: 0x1},
+		unicode.Range16{Lo: 0xa747, Hi: 0xa747, Stride: 0x1},
+		unicode.Range16{Lo: 0xa749, Hi: 0xa749, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74b, Hi: 0xa74b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74d, Hi: 0xa74d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74f, Hi: 0xa74f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa751, Hi: 0xa751, Stride: 0x1},
+		unicode.Range16{Lo: 0xa753, Hi: 0xa753, Stride: 0x1},
+		unicode.Range16{Lo: 0xa755, Hi: 0xa755, Stride: 0x1},
+		unicode.Range16{Lo: 0xa757, Hi: 0xa757, Stride: 0x1},
+		unicode.Range16{Lo: 0xa759, Hi: 0xa759, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75b, Hi: 0xa75b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75d, Hi: 0xa75d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75f, Hi: 0xa75f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa761, Hi: 0xa761, Stride: 0x1},
+		unicode.Range16{Lo: 0xa763, Hi: 0xa763, Stride: 0x1},
+		unicode.Range16{Lo: 0xa765, Hi: 0xa765, Stride: 0x1},
+		unicode.Range16{Lo: 0xa767, Hi: 0xa767, Stride: 0x1},
+		unicode.Range16{Lo: 0xa769, Hi: 0xa769, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76b, Hi: 0xa76b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76d, Hi: 0xa76d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76f, Hi: 0xa76f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa770, Hi: 0xa770, Stride: 0x1},
+		unicode.Range16{Lo: 0xa771, Hi: 0xa778, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77a, Hi: 0xa77a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77c, Hi: 0xa77c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77f, Hi: 0xa77f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa781, Hi: 0xa781, Stride: 0x1},
+		unicode.Range16{Lo: 0xa783, Hi: 0xa783, Stride: 0x1},
+		unicode.Range16{Lo: 0xa785, Hi: 0xa785, Stride: 0x1},
+		unicode.Range16{Lo: 0xa787, Hi: 0xa787, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78c, Hi: 0xa78c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78e, Hi: 0xa78e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa791, Hi: 0xa791, Stride: 0x1},
+		unicode.Range16{Lo: 0xa793, Hi: 0xa795, Stride: 0x1},
+		unicode.Range16{Lo: 0xa797, Hi: 0xa797, Stride: 0x1},
+		unicode.Range16{Lo: 0xa799, Hi: 0xa799, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79b, Hi: 0xa79b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79d, Hi: 0xa79d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79f, Hi: 0xa79f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a1, Hi: 0xa7a1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a3, Hi: 0xa7a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a5, Hi: 0xa7a5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a7, Hi: 0xa7a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a9, Hi: 0xa7a9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b5, Hi: 0xa7b5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b7, Hi: 0xa7b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7f8, Hi: 0xa7f9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7fa, Hi: 0xa7fa, Stride: 0x1},
+		unicode.Range16{Lo: 0xab30, Hi: 0xab5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xab5c, Hi: 0xab5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xab60, Hi: 0xab65, Stride: 0x1},
+		unicode.Range16{Lo: 0xab70, Hi: 0xabbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb00, Hi: 0xfb06, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb13, Hi: 0xfb17, Stride: 0x1},
+		unicode.Range16{Lo: 0xff41, Hi: 0xff5a, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10428, Hi: 0x1044f, Stride: 0x1},
+		unicode.Range32{Lo: 0x104d8, Hi: 0x104fb, Stride: 0x1},
+		unicode.Range32{Lo: 0x10cc0, Hi: 0x10cf2, Stride: 0x1},
+		unicode.Range32{Lo: 0x118c0, Hi: 0x118df, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d41a, Hi: 0x1d433, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d44e, Hi: 0x1d454, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d456, Hi: 0x1d467, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d482, Hi: 0x1d49b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4b6, Hi: 0x1d4b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4bb, Hi: 0x1d4bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4bd, Hi: 0x1d4c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4c5, Hi: 0x1d4cf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4ea, Hi: 0x1d503, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d51e, Hi: 0x1d537, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d552, Hi: 0x1d56b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d586, Hi: 0x1d59f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d5ba, Hi: 0x1d5d3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d5ee, Hi: 0x1d607, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d622, Hi: 0x1d63b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d656, Hi: 0x1d66f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d68a, Hi: 0x1d6a5, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6c2, Hi: 0x1d6da, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6dc, Hi: 0x1d6e1, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6fc, Hi: 0x1d714, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d716, Hi: 0x1d71b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d736, Hi: 0x1d74e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d750, Hi: 0x1d755, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d770, Hi: 0x1d788, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d78a, Hi: 0x1d78f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7aa, Hi: 0x1d7c2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7c4, Hi: 0x1d7c9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7cb, Hi: 0x1d7cb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e922, Hi: 0x1e943, Stride: 0x1},
+	},
+	LatinOffset: 6,
+}
+
+var _SentenceNumeric = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x30, Hi: 0x39, Stride: 0x1},
+		unicode.Range16{Lo: 0x660, Hi: 0x669, Stride: 0x1},
+		unicode.Range16{Lo: 0x66b, Hi: 0x66c, Stride: 0x1},
+		unicode.Range16{Lo: 0x6f0, Hi: 0x6f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x7c0, Hi: 0x7c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x966, Hi: 0x96f, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e6, Hi: 0x9ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66, Hi: 0xa6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xae6, Hi: 0xaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xb66, Hi: 0xb6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe6, Hi: 0xbef, Stride: 0x1},
+		unicode.Range16{Lo: 0xc66, Hi: 0xc6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xce6, Hi: 0xcef, Stride: 0x1},
+		unicode.Range16{Lo: 0xd66, Hi: 0xd6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xde6, Hi: 0xdef, Stride: 0x1},
+		unicode.Range16{Lo: 0xe50, Hi: 0xe59, Stride: 0x1},
+		unicode.Range16{Lo: 0xed0, Hi: 0xed9, Stride: 0x1},
+		unicode.Range16{Lo: 0xf20, Hi: 0xf29, Stride: 0x1},
+		unicode.Range16{Lo: 0x1040, Hi: 0x1049, Stride: 0x1},
+		unicode.Range16{Lo: 0x1090, Hi: 0x1099, Stride: 0x1},
+		unicode.Range16{Lo: 0x17e0, Hi: 0x17e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1810, Hi: 0x1819, Stride: 0x1},
+		unicode.Range16{Lo: 0x1946, Hi: 0x194f, Stride: 0x1},
+		unicode.Range16{Lo: 0x19d0, Hi: 0x19d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a80, Hi: 0x1a89, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a90, Hi: 0x1a99, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b50, Hi: 0x1b59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bb0, Hi: 0x1bb9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c40, Hi: 0x1c49, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c50, Hi: 0x1c59, Stride: 0x1},
+		unicode.Range16{Lo: 0xa620, Hi: 0xa629, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8d0, Hi: 0xa8d9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa900, Hi: 0xa909, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9d0, Hi: 0xa9d9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9f0, Hi: 0xa9f9, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa50, Hi: 0xaa59, Stride: 0x1},
+		unicode.Range16{Lo: 0xabf0, Hi: 0xabf9, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x104a0, Hi: 0x104a9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11066, Hi: 0x1106f, Stride: 0x1},
+		unicode.Range32{Lo: 0x110f0, Hi: 0x110f9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11136, Hi: 0x1113f, Stride: 0x1},
+		unicode.Range32{Lo: 0x111d0, Hi: 0x111d9, Stride: 0x1},
+		unicode.Range32{Lo: 0x112f0, Hi: 0x112f9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11450, Hi: 0x11459, Stride: 0x1},
+		unicode.Range32{Lo: 0x114d0, Hi: 0x114d9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11650, Hi: 0x11659, Stride: 0x1},
+		unicode.Range32{Lo: 0x116c0, Hi: 0x116c9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11730, Hi: 0x11739, Stride: 0x1},
+		unicode.Range32{Lo: 0x118e0, Hi: 0x118e9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c50, Hi: 0x11c59, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a60, Hi: 0x16a69, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b50, Hi: 0x16b59, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7ce, Hi: 0x1d7ff, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e950, Hi: 0x1e959, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceOLetter = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x1bb, Hi: 0x1bb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c0, Hi: 0x1c3, Stride: 0x1},
+		unicode.Range16{Lo: 0x294, Hi: 0x294, Stride: 0x1},
+		unicode.Range16{Lo: 0x2b9, Hi: 0x2bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6, Hi: 0x2d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ec, Hi: 0x2ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ee, Hi: 0x2ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x374, Hi: 0x374, Stride: 0x1},
+		unicode.Range16{Lo: 0x559, Hi: 0x559, Stride: 0x1},
+		unicode.Range16{Lo: 0x5d0, Hi: 0x5ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f0, Hi: 0x5f2, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f3, Hi: 0x5f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x620, Hi: 0x63f, Stride: 0x1},
+		unicode.Range16{Lo: 0x640, Hi: 0x640, Stride: 0x1},
+		unicode.Range16{Lo: 0x641, Hi: 0x64a, Stride: 0x1},
+		unicode.Range16{Lo: 0x66e, Hi: 0x66f, Stride: 0x1},
+		unicode.Range16{Lo: 0x671, Hi: 0x6d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d5, Hi: 0x6d5, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e5, Hi: 0x6e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ee, Hi: 0x6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0x6fa, Hi: 0x6fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ff, Hi: 0x6ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x710, Hi: 0x710, Stride: 0x1},
+		unicode.Range16{Lo: 0x712, Hi: 0x72f, Stride: 0x1},
+		unicode.Range16{Lo: 0x74d, Hi: 0x7a5, Stride: 0x1},
+		unicode.Range16{Lo: 0x7b1, Hi: 0x7b1, Stride: 0x1},
+		unicode.Range16{Lo: 0x7ca, Hi: 0x7ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f4, Hi: 0x7f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x7fa, Hi: 0x7fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x800, Hi: 0x815, Stride: 0x1},
+		unicode.Range16{Lo: 0x81a, Hi: 0x81a, Stride: 0x1},
+		unicode.Range16{Lo: 0x824, Hi: 0x824, Stride: 0x1},
+		unicode.Range16{Lo: 0x828, Hi: 0x828, Stride: 0x1},
+		unicode.Range16{Lo: 0x840, Hi: 0x858, Stride: 0x1},
+		unicode.Range16{Lo: 0x8a0, Hi: 0x8b4, Stride: 0x1},
+		unicode.Range16{Lo: 0x8b6, Hi: 0x8bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x904, Hi: 0x939, Stride: 0x1},
+		unicode.Range16{Lo: 0x93d, Hi: 0x93d, Stride: 0x1},
+		unicode.Range16{Lo: 0x950, Hi: 0x950, Stride: 0x1},
+		unicode.Range16{Lo: 0x958, Hi: 0x961, Stride: 0x1},
+		unicode.Range16{Lo: 0x971, Hi: 0x971, Stride: 0x1},
+		unicode.Range16{Lo: 0x972, Hi: 0x980, Stride: 0x1},
+		unicode.Range16{Lo: 0x985, Hi: 0x98c, Stride: 0x1},
+		unicode.Range16{Lo: 0x98f, Hi: 0x990, Stride: 0x1},
+		unicode.Range16{Lo: 0x993, Hi: 0x9a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9aa, Hi: 0x9b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9b2, Hi: 0x9b2, Stride: 0x1},
+		unicode.Range16{Lo: 0x9b6, Hi: 0x9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bd, Hi: 0x9bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9ce, Hi: 0x9ce, Stride: 0x1},
+		unicode.Range16{Lo: 0x9dc, Hi: 0x9dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9df, Hi: 0x9e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x9f0, Hi: 0x9f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa05, Hi: 0xa0a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa0f, Hi: 0xa10, Stride: 0x1},
+		unicode.Range16{Lo: 0xa13, Hi: 0xa28, Stride: 0x1},
+		unicode.Range16{Lo: 0xa2a, Hi: 0xa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xa32, Hi: 0xa33, Stride: 0x1},
+		unicode.Range16{Lo: 0xa35, Hi: 0xa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xa38, Hi: 0xa39, Stride: 0x1},
+		unicode.Range16{Lo: 0xa59, Hi: 0xa5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa5e, Hi: 0xa5e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72, Hi: 0xa74, Stride: 0x1},
+		unicode.Range16{Lo: 0xa85, Hi: 0xa8d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8f, Hi: 0xa91, Stride: 0x1},
+		unicode.Range16{Lo: 0xa93, Hi: 0xaa8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaa, Hi: 0xab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xab2, Hi: 0xab3, Stride: 0x1},
+		unicode.Range16{Lo: 0xab5, Hi: 0xab9, Stride: 0x1},
+		unicode.Range16{Lo: 0xabd, Hi: 0xabd, Stride: 0x1},
+		unicode.Range16{Lo: 0xad0, Hi: 0xad0, Stride: 0x1},
+		unicode.Range16{Lo: 0xae0, Hi: 0xae1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf9, Hi: 0xaf9, Stride: 0x1},
+		unicode.Range16{Lo: 0xb05, Hi: 0xb0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0f, Hi: 0xb10, Stride: 0x1},
+		unicode.Range16{Lo: 0xb13, Hi: 0xb28, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2a, Hi: 0xb30, Stride: 0x1},
+		unicode.Range16{Lo: 0xb32, Hi: 0xb33, Stride: 0x1},
+		unicode.Range16{Lo: 0xb35, Hi: 0xb39, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3d, Hi: 0xb3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5c, Hi: 0xb5d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5f, Hi: 0xb61, Stride: 0x1},
+		unicode.Range16{Lo: 0xb71, Hi: 0xb71, Stride: 0x1},
+		unicode.Range16{Lo: 0xb83, Hi: 0xb83, Stride: 0x1},
+		unicode.Range16{Lo: 0xb85, Hi: 0xb8a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8e, Hi: 0xb90, Stride: 0x1},
+		unicode.Range16{Lo: 0xb92, Hi: 0xb95, Stride: 0x1},
+		unicode.Range16{Lo: 0xb99, Hi: 0xb9a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9c, Hi: 0xb9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9e, Hi: 0xb9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xba3, Hi: 0xba4, Stride: 0x1},
+		unicode.Range16{Lo: 0xba8, Hi: 0xbaa, Stride: 0x1},
+		unicode.Range16{Lo: 0xbae, Hi: 0xbb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd0, Hi: 0xbd0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc05, Hi: 0xc0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0e, Hi: 0xc10, Stride: 0x1},
+		unicode.Range16{Lo: 0xc12, Hi: 0xc28, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2a, Hi: 0xc39, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3d, Hi: 0xc3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc58, Hi: 0xc5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xc60, Hi: 0xc61, Stride: 0x1},
+		unicode.Range16{Lo: 0xc80, Hi: 0xc80, Stride: 0x1},
+		unicode.Range16{Lo: 0xc85, Hi: 0xc8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8e, Hi: 0xc90, Stride: 0x1},
+		unicode.Range16{Lo: 0xc92, Hi: 0xca8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaa, Hi: 0xcb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb5, Hi: 0xcb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbd, Hi: 0xcbd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcde, Hi: 0xcde, Stride: 0x1},
+		unicode.Range16{Lo: 0xce0, Hi: 0xce1, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf1, Hi: 0xcf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xd05, Hi: 0xd0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0e, Hi: 0xd10, Stride: 0x1},
+		unicode.Range16{Lo: 0xd12, Hi: 0xd3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3d, Hi: 0xd3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e, Hi: 0xd4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xd54, Hi: 0xd56, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5f, Hi: 0xd61, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7a, Hi: 0xd7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd85, Hi: 0xd96, Stride: 0x1},
+		unicode.Range16{Lo: 0xd9a, Hi: 0xdb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdb3, Hi: 0xdbb, Stride: 0x1},
+		unicode.Range16{Lo: 0xdbd, Hi: 0xdbd, Stride: 0x1},
+		unicode.Range16{Lo: 0xdc0, Hi: 0xdc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xe01, Hi: 0xe30, Stride: 0x1},
+		unicode.Range16{Lo: 0xe32, Hi: 0xe33, Stride: 0x1},
+		unicode.Range16{Lo: 0xe40, Hi: 0xe45, Stride: 0x1},
+		unicode.Range16{Lo: 0xe46, Hi: 0xe46, Stride: 0x1},
+		unicode.Range16{Lo: 0xe81, Hi: 0xe82, Stride: 0x1},
+		unicode.Range16{Lo: 0xe84, Hi: 0xe84, Stride: 0x1},
+		unicode.Range16{Lo: 0xe87, Hi: 0xe88, Stride: 0x1},
+		unicode.Range16{Lo: 0xe8a, Hi: 0xe8a, Stride: 0x1},
+		unicode.Range16{Lo: 0xe8d, Hi: 0xe8d, Stride: 0x1},
+		unicode.Range16{Lo: 0xe94, Hi: 0xe97, Stride: 0x1},
+		unicode.Range16{Lo: 0xe99, Hi: 0xe9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xea1, Hi: 0xea3, Stride: 0x1},
+		unicode.Range16{Lo: 0xea5, Hi: 0xea5, Stride: 0x1},
+		unicode.Range16{Lo: 0xea7, Hi: 0xea7, Stride: 0x1},
+		unicode.Range16{Lo: 0xeaa, Hi: 0xeab, Stride: 0x1},
+		unicode.Range16{Lo: 0xead, Hi: 0xeb0, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb2, Hi: 0xeb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xebd, Hi: 0xebd, Stride: 0x1},
+		unicode.Range16{Lo: 0xec0, Hi: 0xec4, Stride: 0x1},
+		unicode.Range16{Lo: 0xec6, Hi: 0xec6, Stride: 0x1},
+		unicode.Range16{Lo: 0xedc, Hi: 0xedf, Stride: 0x1},
+		unicode.Range16{Lo: 0xf00, Hi: 0xf00, Stride: 0x1},
+		unicode.Range16{Lo: 0xf40, Hi: 0xf47, Stride: 0x1},
+		unicode.Range16{Lo: 0xf49, Hi: 0xf6c, Stride: 0x1},
+		unicode.Range16{Lo: 0xf88, Hi: 0xf8c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1000, Hi: 0x102a, Stride: 0x1},
+		unicode.Range16{Lo: 0x103f, Hi: 0x103f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1050, Hi: 0x1055, Stride: 0x1},
+		unicode.Range16{Lo: 0x105a, Hi: 0x105d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1061, Hi: 0x1061, Stride: 0x1},
+		unicode.Range16{Lo: 0x1065, Hi: 0x1066, Stride: 0x1},
+		unicode.Range16{Lo: 0x106e, Hi: 0x1070, Stride: 0x1},
+		unicode.Range16{Lo: 0x1075, Hi: 0x1081, Stride: 0x1},
+		unicode.Range16{Lo: 0x108e, Hi: 0x108e, Stride: 0x1},
+		unicode.Range16{Lo: 0x10d0, Hi: 0x10fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x10fc, Hi: 0x10fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x10fd, Hi: 0x1248, Stride: 0x1},
+		unicode.Range16{Lo: 0x124a, Hi: 0x124d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1250, Hi: 0x1256, Stride: 0x1},
+		unicode.Range16{Lo: 0x1258, Hi: 0x1258, Stride: 0x1},
+		unicode.Range16{Lo: 0x125a, Hi: 0x125d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1260, Hi: 0x1288, Stride: 0x1},
+		unicode.Range16{Lo: 0x128a, Hi: 0x128d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1290, Hi: 0x12b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b2, Hi: 0x12b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b8, Hi: 0x12be, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c0, Hi: 0x12c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c2, Hi: 0x12c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c8, Hi: 0x12d6, Stride: 0x1},
+		unicode.Range16{Lo: 0x12d8, Hi: 0x1310, Stride: 0x1},
+		unicode.Range16{Lo: 0x1312, Hi: 0x1315, Stride: 0x1},
+		unicode.Range16{Lo: 0x1318, Hi: 0x135a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1380, Hi: 0x138f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1401, Hi: 0x166c, Stride: 0x1},
+		unicode.Range16{Lo: 0x166f, Hi: 0x167f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1681, Hi: 0x169a, Stride: 0x1},
+		unicode.Range16{Lo: 0x16a0, Hi: 0x16ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x16ee, Hi: 0x16f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x16f1, Hi: 0x16f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1700, Hi: 0x170c, Stride: 0x1},
+		unicode.Range16{Lo: 0x170e, Hi: 0x1711, Stride: 0x1},
+		unicode.Range16{Lo: 0x1720, Hi: 0x1731, Stride: 0x1},
+		unicode.Range16{Lo: 0x1740, Hi: 0x1751, Stride: 0x1},
+		unicode.Range16{Lo: 0x1760, Hi: 0x176c, Stride: 0x1},
+		unicode.Range16{Lo: 0x176e, Hi: 0x1770, Stride: 0x1},
+		unicode.Range16{Lo: 0x1780, Hi: 0x17b3, Stride: 0x1},
+		unicode.Range16{Lo: 0x17d7, Hi: 0x17d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x17dc, Hi: 0x17dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1820, Hi: 0x1842, Stride: 0x1},
+		unicode.Range16{Lo: 0x1843, Hi: 0x1843, Stride: 0x1},
+		unicode.Range16{Lo: 0x1844, Hi: 0x1877, Stride: 0x1},
+		unicode.Range16{Lo: 0x1880, Hi: 0x1884, Stride: 0x1},
+		unicode.Range16{Lo: 0x1887, Hi: 0x18a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x18aa, Hi: 0x18aa, Stride: 0x1},
+		unicode.Range16{Lo: 0x18b0, Hi: 0x18f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1900, Hi: 0x191e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1950, Hi: 0x196d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1970, Hi: 0x1974, Stride: 0x1},
+		unicode.Range16{Lo: 0x1980, Hi: 0x19ab, Stride: 0x1},
+		unicode.Range16{Lo: 0x19b0, Hi: 0x19c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a00, Hi: 0x1a16, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a20, Hi: 0x1a54, Stride: 0x1},
+		unicode.Range16{Lo: 0x1aa7, Hi: 0x1aa7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b05, Hi: 0x1b33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b45, Hi: 0x1b4b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b83, Hi: 0x1ba0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bae, Hi: 0x1baf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bba, Hi: 0x1be5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c00, Hi: 0x1c23, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c4d, Hi: 0x1c4f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c5a, Hi: 0x1c77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c78, Hi: 0x1c7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce9, Hi: 0x1cec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cee, Hi: 0x1cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf5, Hi: 0x1cf6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2135, Hi: 0x2138, Stride: 0x1},
+		unicode.Range16{Lo: 0x2180, Hi: 0x2182, Stride: 0x1},
+		unicode.Range16{Lo: 0x2185, Hi: 0x2188, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d30, Hi: 0x2d67, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d6f, Hi: 0x2d6f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d80, Hi: 0x2d96, Stride: 0x1},
+		unicode.Range16{Lo: 0x2da0, Hi: 0x2da6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2da8, Hi: 0x2dae, Stride: 0x1},
+		unicode.Range16{Lo: 0x2db0, Hi: 0x2db6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2db8, Hi: 0x2dbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dc0, Hi: 0x2dc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dc8, Hi: 0x2dce, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dd0, Hi: 0x2dd6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dd8, Hi: 0x2dde, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e2f, Hi: 0x2e2f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3005, Hi: 0x3005, Stride: 0x1},
+		unicode.Range16{Lo: 0x3006, Hi: 0x3006, Stride: 0x1},
+		unicode.Range16{Lo: 0x3007, Hi: 0x3007, Stride: 0x1},
+		unicode.Range16{Lo: 0x3021, Hi: 0x3029, Stride: 0x1},
+		unicode.Range16{Lo: 0x3031, Hi: 0x3035, Stride: 0x1},
+		unicode.Range16{Lo: 0x3038, Hi: 0x303a, Stride: 0x1},
+		unicode.Range16{Lo: 0x303b, Hi: 0x303b, Stride: 0x1},
+		unicode.Range16{Lo: 0x303c, Hi: 0x303c, Stride: 0x1},
+		unicode.Range16{Lo: 0x3041, Hi: 0x3096, Stride: 0x1},
+		unicode.Range16{Lo: 0x309d, Hi: 0x309e, Stride: 0x1},
+		unicode.Range16{Lo: 0x309f, Hi: 0x309f, Stride: 0x1},
+		unicode.Range16{Lo: 0x30a1, Hi: 0x30fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x30fc, Hi: 0x30fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x30ff, Hi: 0x30ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x3105, Hi: 0x312d, Stride: 0x1},
+		unicode.Range16{Lo: 0x3131, Hi: 0x318e, Stride: 0x1},
+		unicode.Range16{Lo: 0x31a0, Hi: 0x31ba, Stride: 0x1},
+		unicode.Range16{Lo: 0x31f0, Hi: 0x31ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x3400, Hi: 0x4db5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e00, Hi: 0x9fd5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa000, Hi: 0xa014, Stride: 0x1},
+		unicode.Range16{Lo: 0xa015, Hi: 0xa015, Stride: 0x1},
+		unicode.Range16{Lo: 0xa016, Hi: 0xa48c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4d0, Hi: 0xa4f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4f8, Hi: 0xa4fd, Stride: 0x1},
+		unicode.Range16{Lo: 0xa500, Hi: 0xa60b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa60c, Hi: 0xa60c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa610, Hi: 0xa61f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa62a, Hi: 0xa62b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66e, Hi: 0xa66e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa67f, Hi: 0xa67f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6a0, Hi: 0xa6e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6e6, Hi: 0xa6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa717, Hi: 0xa71f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa788, Hi: 0xa788, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78f, Hi: 0xa78f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7f7, Hi: 0xa7f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7fb, Hi: 0xa801, Stride: 0x1},
+		unicode.Range16{Lo: 0xa803, Hi: 0xa805, Stride: 0x1},
+		unicode.Range16{Lo: 0xa807, Hi: 0xa80a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80c, Hi: 0xa822, Stride: 0x1},
+		unicode.Range16{Lo: 0xa840, Hi: 0xa873, Stride: 0x1},
+		unicode.Range16{Lo: 0xa882, Hi: 0xa8b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8f2, Hi: 0xa8f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8fb, Hi: 0xa8fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8fd, Hi: 0xa8fd, Stride: 0x1},
+		unicode.Range16{Lo: 0xa90a, Hi: 0xa925, Stride: 0x1},
+		unicode.Range16{Lo: 0xa930, Hi: 0xa946, Stride: 0x1},
+		unicode.Range16{Lo: 0xa960, Hi: 0xa97c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa984, Hi: 0xa9b2, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9cf, Hi: 0xa9cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e0, Hi: 0xa9e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e6, Hi: 0xa9e6, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e7, Hi: 0xa9ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9fa, Hi: 0xa9fe, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa00, Hi: 0xaa28, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa40, Hi: 0xaa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa44, Hi: 0xaa4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa60, Hi: 0xaa6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa70, Hi: 0xaa70, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa71, Hi: 0xaa76, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7a, Hi: 0xaa7a, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7e, Hi: 0xaaaf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab1, Hi: 0xaab1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab5, Hi: 0xaab6, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab9, Hi: 0xaabd, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac0, Hi: 0xaac0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac2, Hi: 0xaac2, Stride: 0x1},
+		unicode.Range16{Lo: 0xaadb, Hi: 0xaadc, Stride: 0x1},
+		unicode.Range16{Lo: 0xaadd, Hi: 0xaadd, Stride: 0x1},
+		unicode.Range16{Lo: 0xaae0, Hi: 0xaaea, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf2, Hi: 0xaaf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf3, Hi: 0xaaf4, Stride: 0x1},
+		unicode.Range16{Lo: 0xab01, Hi: 0xab06, Stride: 0x1},
+		unicode.Range16{Lo: 0xab09, Hi: 0xab0e, Stride: 0x1},
+		unicode.Range16{Lo: 0xab11, Hi: 0xab16, Stride: 0x1},
+		unicode.Range16{Lo: 0xab20, Hi: 0xab26, Stride: 0x1},
+		unicode.Range16{Lo: 0xab28, Hi: 0xab2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc0, Hi: 0xabe2, Stride: 0x1},
+		unicode.Range16{Lo: 0xac00, Hi: 0xd7a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7b0, Hi: 0xd7c6, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7cb, Hi: 0xd7fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xf900, Hi: 0xfa6d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfa70, Hi: 0xfad9, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1d, Hi: 0xfb1d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1f, Hi: 0xfb28, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb2a, Hi: 0xfb36, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb38, Hi: 0xfb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb3e, Hi: 0xfb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb40, Hi: 0xfb41, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb43, Hi: 0xfb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb46, Hi: 0xfbb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xfbd3, Hi: 0xfd3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd50, Hi: 0xfd8f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd92, Hi: 0xfdc7, Stride: 0x1},
+		unicode.Range16{Lo: 0xfdf0, Hi: 0xfdfb, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe70, Hi: 0xfe74, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe76, Hi: 0xfefc, Stride: 0x1},
+		unicode.Range16{Lo: 0xff66, Hi: 0xff6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff70, Hi: 0xff70, Stride: 0x1},
+		unicode.Range16{Lo: 0xff71, Hi: 0xff9d, Stride: 0x1},
+		unicode.Range16{Lo: 0xffa0, Hi: 0xffbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xffc2, Hi: 0xffc7, Stride: 0x1},
+		unicode.Range16{Lo: 0xffca, Hi: 0xffcf, Stride: 0x1},
+		unicode.Range16{Lo: 0xffd2, Hi: 0xffd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xffda, Hi: 0xffdc, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10000, Hi: 0x1000b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1000d, Hi: 0x10026, Stride: 0x1},
+		unicode.Range32{Lo: 0x10028, Hi: 0x1003a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1003c, Hi: 0x1003d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1003f, Hi: 0x1004d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10050, Hi: 0x1005d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10080, Hi: 0x100fa, Stride: 0x1},
+		unicode.Range32{Lo: 0x10140, Hi: 0x10174, Stride: 0x1},
+		unicode.Range32{Lo: 0x10280, Hi: 0x1029c, Stride: 0x1},
+		unicode.Range32{Lo: 0x102a0, Hi: 0x102d0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10300, Hi: 0x1031f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10330, Hi: 0x10340, Stride: 0x1},
+		unicode.Range32{Lo: 0x10341, Hi: 0x10341, Stride: 0x1},
+		unicode.Range32{Lo: 0x10342, Hi: 0x10349, Stride: 0x1},
+		unicode.Range32{Lo: 0x1034a, Hi: 0x1034a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10350, Hi: 0x10375, Stride: 0x1},
+		unicode.Range32{Lo: 0x10380, Hi: 0x1039d, Stride: 0x1},
+		unicode.Range32{Lo: 0x103a0, Hi: 0x103c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x103c8, Hi: 0x103cf, Stride: 0x1},
+		unicode.Range32{Lo: 0x103d1, Hi: 0x103d5, Stride: 0x1},
+		unicode.Range32{Lo: 0x10450, Hi: 0x1049d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10500, Hi: 0x10527, Stride: 0x1},
+		unicode.Range32{Lo: 0x10530, Hi: 0x10563, Stride: 0x1},
+		unicode.Range32{Lo: 0x10600, Hi: 0x10736, Stride: 0x1},
+		unicode.Range32{Lo: 0x10740, Hi: 0x10755, Stride: 0x1},
+		unicode.Range32{Lo: 0x10760, Hi: 0x10767, Stride: 0x1},
+		unicode.Range32{Lo: 0x10800, Hi: 0x10805, Stride: 0x1},
+		unicode.Range32{Lo: 0x10808, Hi: 0x10808, Stride: 0x1},
+		unicode.Range32{Lo: 0x1080a, Hi: 0x10835, Stride: 0x1},
+		unicode.Range32{Lo: 0x10837, Hi: 0x10838, Stride: 0x1},
+		unicode.Range32{Lo: 0x1083c, Hi: 0x1083c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1083f, Hi: 0x10855, Stride: 0x1},
+		unicode.Range32{Lo: 0x10860, Hi: 0x10876, Stride: 0x1},
+		unicode.Range32{Lo: 0x10880, Hi: 0x1089e, Stride: 0x1},
+		unicode.Range32{Lo: 0x108e0, Hi: 0x108f2, Stride: 0x1},
+		unicode.Range32{Lo: 0x108f4, Hi: 0x108f5, Stride: 0x1},
+		unicode.Range32{Lo: 0x10900, Hi: 0x10915, Stride: 0x1},
+		unicode.Range32{Lo: 0x10920, Hi: 0x10939, Stride: 0x1},
+		unicode.Range32{Lo: 0x10980, Hi: 0x109b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x109be, Hi: 0x109bf, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a00, Hi: 0x10a00, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a10, Hi: 0x10a13, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a15, Hi: 0x10a17, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a19, Hi: 0x10a33, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a60, Hi: 0x10a7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a80, Hi: 0x10a9c, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ac0, Hi: 0x10ac7, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ac9, Hi: 0x10ae4, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b00, Hi: 0x10b35, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b40, Hi: 0x10b55, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b60, Hi: 0x10b72, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b80, Hi: 0x10b91, Stride: 0x1},
+		unicode.Range32{Lo: 0x10c00, Hi: 0x10c48, Stride: 0x1},
+		unicode.Range32{Lo: 0x11003, Hi: 0x11037, Stride: 0x1},
+		unicode.Range32{Lo: 0x11083, Hi: 0x110af, Stride: 0x1},
+		unicode.Range32{Lo: 0x110d0, Hi: 0x110e8, Stride: 0x1},
+		unicode.Range32{Lo: 0x11103, Hi: 0x11126, Stride: 0x1},
+		unicode.Range32{Lo: 0x11150, Hi: 0x11172, Stride: 0x1},
+		unicode.Range32{Lo: 0x11176, Hi: 0x11176, Stride: 0x1},
+		unicode.Range32{Lo: 0x11183, Hi: 0x111b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x111c1, Hi: 0x111c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x111da, Hi: 0x111da, Stride: 0x1},
+		unicode.Range32{Lo: 0x111dc, Hi: 0x111dc, Stride: 0x1},
+		unicode.Range32{Lo: 0x11200, Hi: 0x11211, Stride: 0x1},
+		unicode.Range32{Lo: 0x11213, Hi: 0x1122b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11280, Hi: 0x11286, Stride: 0x1},
+		unicode.Range32{Lo: 0x11288, Hi: 0x11288, Stride: 0x1},
+		unicode.Range32{Lo: 0x1128a, Hi: 0x1128d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1128f, Hi: 0x1129d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1129f, Hi: 0x112a8, Stride: 0x1},
+		unicode.Range32{Lo: 0x112b0, Hi: 0x112de, Stride: 0x1},
+		unicode.Range32{Lo: 0x11305, Hi: 0x1130c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1130f, Hi: 0x11310, Stride: 0x1},
+		unicode.Range32{Lo: 0x11313, Hi: 0x11328, Stride: 0x1},
+		unicode.Range32{Lo: 0x1132a, Hi: 0x11330, Stride: 0x1},
+		unicode.Range32{Lo: 0x11332, Hi: 0x11333, Stride: 0x1},
+		unicode.Range32{Lo: 0x11335, Hi: 0x11339, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133d, Hi: 0x1133d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11350, Hi: 0x11350, Stride: 0x1},
+		unicode.Range32{Lo: 0x1135d, Hi: 0x11361, Stride: 0x1},
+		unicode.Range32{Lo: 0x11400, Hi: 0x11434, Stride: 0x1},
+		unicode.Range32{Lo: 0x11447, Hi: 0x1144a, Stride: 0x1},
+		unicode.Range32{Lo: 0x11480, Hi: 0x114af, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c4, Hi: 0x114c5, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c7, Hi: 0x114c7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11580, Hi: 0x115ae, Stride: 0x1},
+		unicode.Range32{Lo: 0x115d8, Hi: 0x115db, Stride: 0x1},
+		unicode.Range32{Lo: 0x11600, Hi: 0x1162f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11644, Hi: 0x11644, Stride: 0x1},
+		unicode.Range32{Lo: 0x11680, Hi: 0x116aa, Stride: 0x1},
+		unicode.Range32{Lo: 0x11700, Hi: 0x11719, Stride: 0x1},
+		unicode.Range32{Lo: 0x118ff, Hi: 0x118ff, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ac0, Hi: 0x11af8, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c00, Hi: 0x11c08, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c0a, Hi: 0x11c2e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c40, Hi: 0x11c40, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c72, Hi: 0x11c8f, Stride: 0x1},
+		unicode.Range32{Lo: 0x12000, Hi: 0x12399, Stride: 0x1},
+		unicode.Range32{Lo: 0x12400, Hi: 0x1246e, Stride: 0x1},
+		unicode.Range32{Lo: 0x12480, Hi: 0x12543, Stride: 0x1},
+		unicode.Range32{Lo: 0x13000, Hi: 0x1342e, Stride: 0x1},
+		unicode.Range32{Lo: 0x14400, Hi: 0x14646, Stride: 0x1},
+		unicode.Range32{Lo: 0x16800, Hi: 0x16a38, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a40, Hi: 0x16a5e, Stride: 0x1},
+		unicode.Range32{Lo: 0x16ad0, Hi: 0x16aed, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b00, Hi: 0x16b2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b40, Hi: 0x16b43, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b63, Hi: 0x16b77, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b7d, Hi: 0x16b8f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f00, Hi: 0x16f44, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f50, Hi: 0x16f50, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f93, Hi: 0x16f9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16fe0, Hi: 0x16fe0, Stride: 0x1},
+		unicode.Range32{Lo: 0x17000, Hi: 0x187ec, Stride: 0x1},
+		unicode.Range32{Lo: 0x18800, Hi: 0x18af2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1b000, Hi: 0x1b001, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc00, Hi: 0x1bc6a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc70, Hi: 0x1bc7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc80, Hi: 0x1bc88, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc90, Hi: 0x1bc99, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e800, Hi: 0x1e8c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee00, Hi: 0x1ee03, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee05, Hi: 0x1ee1f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee21, Hi: 0x1ee22, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee24, Hi: 0x1ee24, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee27, Hi: 0x1ee27, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee29, Hi: 0x1ee32, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee34, Hi: 0x1ee37, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee39, Hi: 0x1ee39, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee3b, Hi: 0x1ee3b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee42, Hi: 0x1ee42, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee47, Hi: 0x1ee47, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee49, Hi: 0x1ee49, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee4b, Hi: 0x1ee4b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee4d, Hi: 0x1ee4f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee51, Hi: 0x1ee52, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee54, Hi: 0x1ee54, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee57, Hi: 0x1ee57, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee59, Hi: 0x1ee59, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5b, Hi: 0x1ee5b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5d, Hi: 0x1ee5d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5f, Hi: 0x1ee5f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee61, Hi: 0x1ee62, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee64, Hi: 0x1ee64, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee67, Hi: 0x1ee6a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee6c, Hi: 0x1ee72, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee74, Hi: 0x1ee77, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee79, Hi: 0x1ee7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee7e, Hi: 0x1ee7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee80, Hi: 0x1ee89, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee8b, Hi: 0x1ee9b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eea1, Hi: 0x1eea3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eea5, Hi: 0x1eea9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eeab, Hi: 0x1eebb, Stride: 0x1},
+		unicode.Range32{Lo: 0x20000, Hi: 0x2a6d6, Stride: 0x1},
+		unicode.Range32{Lo: 0x2a700, Hi: 0x2b734, Stride: 0x1},
+		unicode.Range32{Lo: 0x2b740, Hi: 0x2b81d, Stride: 0x1},
+		unicode.Range32{Lo: 0x2b820, Hi: 0x2cea1, Stride: 0x1},
+		unicode.Range32{Lo: 0x2f800, Hi: 0x2fa1d, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _SentenceSContinue = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2c, Hi: 0x2c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d, Hi: 0x2d, Stride: 0x1},
+		unicode.Range16{Lo: 0x3a, Hi: 0x3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x55d, Hi: 0x55d, Stride: 0x1},
+		unicode.Range16{Lo: 0x60c, Hi: 0x60d, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f8, Hi: 0x7f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1802, Hi: 0x1802, Stride: 0x1},
+		unicode.Range16{Lo: 0x1808, Hi: 0x1808, Stride: 0x1},
+		unicode.Range16{Lo: 0x2013, Hi: 0x2014, Stride: 0x1},
+		unicode.Range16{Lo: 0x3001, Hi: 0x3001, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe10, Hi: 0xfe11, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe13, Hi: 0xfe13, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe31, Hi: 0xfe32, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe50, Hi: 0xfe51, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe55, Hi: 0xfe55, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe58, Hi: 0xfe58, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe63, Hi: 0xfe63, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0c, Hi: 0xff0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0d, Hi: 0xff0d, Stride: 0x1},
+		unicode.Range16{Lo: 0xff1a, Hi: 0xff1a, Stride: 0x1},
+		unicode.Range16{Lo: 0xff64, Hi: 0xff64, Stride: 0x1},
+	},
+	LatinOffset: 3,
+}
+
+var _SentenceSTerm = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x21, Hi: 0x21, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f, Hi: 0x3f, Stride: 0x1},
+		unicode.Range16{Lo: 0x589, Hi: 0x589, Stride: 0x1},
+		unicode.Range16{Lo: 0x61f, Hi: 0x61f, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d4, Hi: 0x6d4, Stride: 0x1},
+		unicode.Range16{Lo: 0x700, Hi: 0x702, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f9, Hi: 0x7f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x964, Hi: 0x965, Stride: 0x1},
+		unicode.Range16{Lo: 0x104a, Hi: 0x104b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1362, Hi: 0x1362, Stride: 0x1},
+		unicode.Range16{Lo: 0x1367, Hi: 0x1368, Stride: 0x1},
+		unicode.Range16{Lo: 0x166e, Hi: 0x166e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1735, Hi: 0x1736, Stride: 0x1},
+		unicode.Range16{Lo: 0x1803, Hi: 0x1803, Stride: 0x1},
+		unicode.Range16{Lo: 0x1809, Hi: 0x1809, Stride: 0x1},
+		unicode.Range16{Lo: 0x1944, Hi: 0x1945, Stride: 0x1},
+		unicode.Range16{Lo: 0x1aa8, Hi: 0x1aab, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b5a, Hi: 0x1b5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b5e, Hi: 0x1b5f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c3b, Hi: 0x1c3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c7e, Hi: 0x1c7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x203c, Hi: 0x203d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2047, Hi: 0x2049, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e2e, Hi: 0x2e2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e3c, Hi: 0x2e3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x3002, Hi: 0x3002, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4ff, Hi: 0xa4ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xa60e, Hi: 0xa60f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f3, Hi: 0xa6f3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f7, Hi: 0xa6f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa876, Hi: 0xa877, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8ce, Hi: 0xa8cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xa92f, Hi: 0xa92f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9c8, Hi: 0xa9c9, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa5d, Hi: 0xaa5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf0, Hi: 0xaaf1, Stride: 0x1},
+		unicode.Range16{Lo: 0xabeb, Hi: 0xabeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe56, Hi: 0xfe57, Stride: 0x1},
+		unicode.Range16{Lo: 0xff01, Hi: 0xff01, Stride: 0x1},
+		unicode.Range16{Lo: 0xff1f, Hi: 0xff1f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff61, Hi: 0xff61, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10a56, Hi: 0x10a57, Stride: 0x1},
+		unicode.Range32{Lo: 0x11047, Hi: 0x11048, Stride: 0x1},
+		unicode.Range32{Lo: 0x110be, Hi: 0x110c1, Stride: 0x1},
+		unicode.Range32{Lo: 0x11141, Hi: 0x11143, Stride: 0x1},
+		unicode.Range32{Lo: 0x111c5, Hi: 0x111c6, Stride: 0x1},
+		unicode.Range32{Lo: 0x111cd, Hi: 0x111cd, Stride: 0x1},
+		unicode.Range32{Lo: 0x111de, Hi: 0x111df, Stride: 0x1},
+		unicode.Range32{Lo: 0x11238, Hi: 0x11239, Stride: 0x1},
+		unicode.Range32{Lo: 0x1123b, Hi: 0x1123c, Stride: 0x1},
+		unicode.Range32{Lo: 0x112a9, Hi: 0x112a9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1144b, Hi: 0x1144c, Stride: 0x1},
+		unicode.Range32{Lo: 0x115c2, Hi: 0x115c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x115c9, Hi: 0x115d7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11641, Hi: 0x11642, Stride: 0x1},
+		unicode.Range32{Lo: 0x1173c, Hi: 0x1173e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c41, Hi: 0x11c42, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a6e, Hi: 0x16a6f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16af5, Hi: 0x16af5, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b37, Hi: 0x16b38, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b44, Hi: 0x16b44, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc9f, Hi: 0x1bc9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da88, Hi: 0x1da88, Stride: 0x1},
+	},
+	LatinOffset: 2,
+}
+
+var _SentenceSep = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x85, Hi: 0x85, Stride: 0x1},
+		unicode.Range16{Lo: 0x2028, Hi: 0x2028, Stride: 0x1},
+		unicode.Range16{Lo: 0x2029, Hi: 0x2029, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceSp = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x9, Hi: 0x9, Stride: 0x1},
+		unicode.Range16{Lo: 0xb, Hi: 0xc, Stride: 0x1},
+		unicode.Range16{Lo: 0x20, Hi: 0x20, Stride: 0x1},
+		unicode.Range16{Lo: 0xa0, Hi: 0xa0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1680, Hi: 0x1680, Stride: 0x1},
+		unicode.Range16{Lo: 0x2000, Hi: 0x200a, Stride: 0x1},
+		unicode.Range16{Lo: 0x202f, Hi: 0x202f, Stride: 0x1},
+		unicode.Range16{Lo: 0x205f, Hi: 0x205f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3000, Hi: 0x3000, Stride: 0x1},
+	},
+	LatinOffset: 4,
+}
+
+var _SentenceUpper = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x41, Hi: 0x5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0, Hi: 0xd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xd8, Hi: 0xde, Stride: 0x1},
+		unicode.Range16{Lo: 0x100, Hi: 0x100, Stride: 0x1},
+		unicode.Range16{Lo: 0x102, Hi: 0x102, Stride: 0x1},
+		unicode.Range16{Lo: 0x104, Hi: 0x104, Stride: 0x1},
+		unicode.Range16{Lo: 0x106, Hi: 0x106, Stride: 0x1},
+		unicode.Range16{Lo: 0x108, Hi: 0x108, Stride: 0x1},
+		unicode.Range16{Lo: 0x10a, Hi: 0x10a, Stride: 0x1},
+		unicode.Range16{Lo: 0x10c, Hi: 0x10c, Stride: 0x1},
+		unicode.Range16{Lo: 0x10e, Hi: 0x10e, Stride: 0x1},
+		unicode.Range16{Lo: 0x110, Hi: 0x110, Stride: 0x1},
+		unicode.Range16{Lo: 0x112, Hi: 0x112, Stride: 0x1},
+		unicode.Range16{Lo: 0x114, Hi: 0x114, Stride: 0x1},
+		unicode.Range16{Lo: 0x116, Hi: 0x116, Stride: 0x1},
+		unicode.Range16{Lo: 0x118, Hi: 0x118, Stride: 0x1},
+		unicode.Range16{Lo: 0x11a, Hi: 0x11a, Stride: 0x1},
+		unicode.Range16{Lo: 0x11c, Hi: 0x11c, Stride: 0x1},
+		unicode.Range16{Lo: 0x11e, Hi: 0x11e, Stride: 0x1},
+		unicode.Range16{Lo: 0x120, Hi: 0x120, Stride: 0x1},
+		unicode.Range16{Lo: 0x122, Hi: 0x122, Stride: 0x1},
+		unicode.Range16{Lo: 0x124, Hi: 0x124, Stride: 0x1},
+		unicode.Range16{Lo: 0x126, Hi: 0x126, Stride: 0x1},
+		unicode.Range16{Lo: 0x128, Hi: 0x128, Stride: 0x1},
+		unicode.Range16{Lo: 0x12a, Hi: 0x12a, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c, Hi: 0x12c, Stride: 0x1},
+		unicode.Range16{Lo: 0x12e, Hi: 0x12e, Stride: 0x1},
+		unicode.Range16{Lo: 0x130, Hi: 0x130, Stride: 0x1},
+		unicode.Range16{Lo: 0x132, Hi: 0x132, Stride: 0x1},
+		unicode.Range16{Lo: 0x134, Hi: 0x134, Stride: 0x1},
+		unicode.Range16{Lo: 0x136, Hi: 0x136, Stride: 0x1},
+		unicode.Range16{Lo: 0x139, Hi: 0x139, Stride: 0x1},
+		unicode.Range16{Lo: 0x13b, Hi: 0x13b, Stride: 0x1},
+		unicode.Range16{Lo: 0x13d, Hi: 0x13d, Stride: 0x1},
+		unicode.Range16{Lo: 0x13f, Hi: 0x13f, Stride: 0x1},
+		unicode.Range16{Lo: 0x141, Hi: 0x141, Stride: 0x1},
+		unicode.Range16{Lo: 0x143, Hi: 0x143, Stride: 0x1},
+		unicode.Range16{Lo: 0x145, Hi: 0x145, Stride: 0x1},
+		unicode.Range16{Lo: 0x147, Hi: 0x147, Stride: 0x1},
+		unicode.Range16{Lo: 0x14a, Hi: 0x14a, Stride: 0x1},
+		unicode.Range16{Lo: 0x14c, Hi: 0x14c, Stride: 0x1},
+		unicode.Range16{Lo: 0x14e, Hi: 0x14e, Stride: 0x1},
+		unicode.Range16{Lo: 0x150, Hi: 0x150, Stride: 0x1},
+		unicode.Range16{Lo: 0x152, Hi: 0x152, Stride: 0x1},
+		unicode.Range16{Lo: 0x154, Hi: 0x154, Stride: 0x1},
+		unicode.Range16{Lo: 0x156, Hi: 0x156, Stride: 0x1},
+		unicode.Range16{Lo: 0x158, Hi: 0x158, Stride: 0x1},
+		unicode.Range16{Lo: 0x15a, Hi: 0x15a, Stride: 0x1},
+		unicode.Range16{Lo: 0x15c, Hi: 0x15c, Stride: 0x1},
+		unicode.Range16{Lo: 0x15e, Hi: 0x15e, Stride: 0x1},
+		unicode.Range16{Lo: 0x160, Hi: 0x160, Stride: 0x1},
+		unicode.Range16{Lo: 0x162, Hi: 0x162, Stride: 0x1},
+		unicode.Range16{Lo: 0x164, Hi: 0x164, Stride: 0x1},
+		unicode.Range16{Lo: 0x166, Hi: 0x166, Stride: 0x1},
+		unicode.Range16{Lo: 0x168, Hi: 0x168, Stride: 0x1},
+		unicode.Range16{Lo: 0x16a, Hi: 0x16a, Stride: 0x1},
+		unicode.Range16{Lo: 0x16c, Hi: 0x16c, Stride: 0x1},
+		unicode.Range16{Lo: 0x16e, Hi: 0x16e, Stride: 0x1},
+		unicode.Range16{Lo: 0x170, Hi: 0x170, Stride: 0x1},
+		unicode.Range16{Lo: 0x172, Hi: 0x172, Stride: 0x1},
+		unicode.Range16{Lo: 0x174, Hi: 0x174, Stride: 0x1},
+		unicode.Range16{Lo: 0x176, Hi: 0x176, Stride: 0x1},
+		unicode.Range16{Lo: 0x178, Hi: 0x179, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b, Hi: 0x17b, Stride: 0x1},
+		unicode.Range16{Lo: 0x17d, Hi: 0x17d, Stride: 0x1},
+		unicode.Range16{Lo: 0x181, Hi: 0x182, Stride: 0x1},
+		unicode.Range16{Lo: 0x184, Hi: 0x184, Stride: 0x1},
+		unicode.Range16{Lo: 0x186, Hi: 0x187, Stride: 0x1},
+		unicode.Range16{Lo: 0x189, Hi: 0x18b, Stride: 0x1},
+		unicode.Range16{Lo: 0x18e, Hi: 0x191, Stride: 0x1},
+		unicode.Range16{Lo: 0x193, Hi: 0x194, Stride: 0x1},
+		unicode.Range16{Lo: 0x196, Hi: 0x198, Stride: 0x1},
+		unicode.Range16{Lo: 0x19c, Hi: 0x19d, Stride: 0x1},
+		unicode.Range16{Lo: 0x19f, Hi: 0x1a0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a2, Hi: 0x1a2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a4, Hi: 0x1a4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a6, Hi: 0x1a7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a9, Hi: 0x1a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ac, Hi: 0x1ac, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ae, Hi: 0x1af, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b1, Hi: 0x1b3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b5, Hi: 0x1b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b7, Hi: 0x1b8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bc, Hi: 0x1bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c4, Hi: 0x1c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c7, Hi: 0x1c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ca, Hi: 0x1cb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd, Hi: 0x1cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf, Hi: 0x1cf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d1, Hi: 0x1d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d3, Hi: 0x1d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d5, Hi: 0x1d5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d7, Hi: 0x1d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d9, Hi: 0x1d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1db, Hi: 0x1db, Stride: 0x1},
+		unicode.Range16{Lo: 0x1de, Hi: 0x1de, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0, Hi: 0x1e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2, Hi: 0x1e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4, Hi: 0x1e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6, Hi: 0x1e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8, Hi: 0x1e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea, Hi: 0x1ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec, Hi: 0x1ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee, Hi: 0x1ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f1, Hi: 0x1f2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f4, Hi: 0x1f4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f6, Hi: 0x1f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fa, Hi: 0x1fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc, Hi: 0x1fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fe, Hi: 0x1fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x200, Hi: 0x200, Stride: 0x1},
+		unicode.Range16{Lo: 0x202, Hi: 0x202, Stride: 0x1},
+		unicode.Range16{Lo: 0x204, Hi: 0x204, Stride: 0x1},
+		unicode.Range16{Lo: 0x206, Hi: 0x206, Stride: 0x1},
+		unicode.Range16{Lo: 0x208, Hi: 0x208, Stride: 0x1},
+		unicode.Range16{Lo: 0x20a, Hi: 0x20a, Stride: 0x1},
+		unicode.Range16{Lo: 0x20c, Hi: 0x20c, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e, Hi: 0x20e, Stride: 0x1},
+		unicode.Range16{Lo: 0x210, Hi: 0x210, Stride: 0x1},
+		unicode.Range16{Lo: 0x212, Hi: 0x212, Stride: 0x1},
+		unicode.Range16{Lo: 0x214, Hi: 0x214, Stride: 0x1},
+		unicode.Range16{Lo: 0x216, Hi: 0x216, Stride: 0x1},
+		unicode.Range16{Lo: 0x218, Hi: 0x218, Stride: 0x1},
+		unicode.Range16{Lo: 0x21a, Hi: 0x21a, Stride: 0x1},
+		unicode.Range16{Lo: 0x21c, Hi: 0x21c, Stride: 0x1},
+		unicode.Range16{Lo: 0x21e, Hi: 0x21e, Stride: 0x1},
+		unicode.Range16{Lo: 0x220, Hi: 0x220, Stride: 0x1},
+		unicode.Range16{Lo: 0x222, Hi: 0x222, Stride: 0x1},
+		unicode.Range16{Lo: 0x224, Hi: 0x224, Stride: 0x1},
+		unicode.Range16{Lo: 0x226, Hi: 0x226, Stride: 0x1},
+		unicode.Range16{Lo: 0x228, Hi: 0x228, Stride: 0x1},
+		unicode.Range16{Lo: 0x22a, Hi: 0x22a, Stride: 0x1},
+		unicode.Range16{Lo: 0x22c, Hi: 0x22c, Stride: 0x1},
+		unicode.Range16{Lo: 0x22e, Hi: 0x22e, Stride: 0x1},
+		unicode.Range16{Lo: 0x230, Hi: 0x230, Stride: 0x1},
+		unicode.Range16{Lo: 0x232, Hi: 0x232, Stride: 0x1},
+		unicode.Range16{Lo: 0x23a, Hi: 0x23b, Stride: 0x1},
+		unicode.Range16{Lo: 0x23d, Hi: 0x23e, Stride: 0x1},
+		unicode.Range16{Lo: 0x241, Hi: 0x241, Stride: 0x1},
+		unicode.Range16{Lo: 0x243, Hi: 0x246, Stride: 0x1},
+		unicode.Range16{Lo: 0x248, Hi: 0x248, Stride: 0x1},
+		unicode.Range16{Lo: 0x24a, Hi: 0x24a, Stride: 0x1},
+		unicode.Range16{Lo: 0x24c, Hi: 0x24c, Stride: 0x1},
+		unicode.Range16{Lo: 0x24e, Hi: 0x24e, Stride: 0x1},
+		unicode.Range16{Lo: 0x370, Hi: 0x370, Stride: 0x1},
+		unicode.Range16{Lo: 0x372, Hi: 0x372, Stride: 0x1},
+		unicode.Range16{Lo: 0x376, Hi: 0x376, Stride: 0x1},
+		unicode.Range16{Lo: 0x37f, Hi: 0x37f, Stride: 0x1},
+		unicode.Range16{Lo: 0x386, Hi: 0x386, Stride: 0x1},
+		unicode.Range16{Lo: 0x388, Hi: 0x38a, Stride: 0x1},
+		unicode.Range16{Lo: 0x38c, Hi: 0x38c, Stride: 0x1},
+		unicode.Range16{Lo: 0x38e, Hi: 0x38f, Stride: 0x1},
+		unicode.Range16{Lo: 0x391, Hi: 0x3a1, Stride: 0x1},
+		unicode.Range16{Lo: 0x3a3, Hi: 0x3ab, Stride: 0x1},
+		unicode.Range16{Lo: 0x3cf, Hi: 0x3cf, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d2, Hi: 0x3d4, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d8, Hi: 0x3d8, Stride: 0x1},
+		unicode.Range16{Lo: 0x3da, Hi: 0x3da, Stride: 0x1},
+		unicode.Range16{Lo: 0x3dc, Hi: 0x3dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x3de, Hi: 0x3de, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e0, Hi: 0x3e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e2, Hi: 0x3e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e4, Hi: 0x3e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e6, Hi: 0x3e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e8, Hi: 0x3e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ea, Hi: 0x3ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ec, Hi: 0x3ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ee, Hi: 0x3ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f4, Hi: 0x3f4, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f7, Hi: 0x3f7, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f9, Hi: 0x3fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x3fd, Hi: 0x42f, Stride: 0x1},
+		unicode.Range16{Lo: 0x460, Hi: 0x460, Stride: 0x1},
+		unicode.Range16{Lo: 0x462, Hi: 0x462, Stride: 0x1},
+		unicode.Range16{Lo: 0x464, Hi: 0x464, Stride: 0x1},
+		unicode.Range16{Lo: 0x466, Hi: 0x466, Stride: 0x1},
+		unicode.Range16{Lo: 0x468, Hi: 0x468, Stride: 0x1},
+		unicode.Range16{Lo: 0x46a, Hi: 0x46a, Stride: 0x1},
+		unicode.Range16{Lo: 0x46c, Hi: 0x46c, Stride: 0x1},
+		unicode.Range16{Lo: 0x46e, Hi: 0x46e, Stride: 0x1},
+		unicode.Range16{Lo: 0x470, Hi: 0x470, Stride: 0x1},
+		unicode.Range16{Lo: 0x472, Hi: 0x472, Stride: 0x1},
+		unicode.Range16{Lo: 0x474, Hi: 0x474, Stride: 0x1},
+		unicode.Range16{Lo: 0x476, Hi: 0x476, Stride: 0x1},
+		unicode.Range16{Lo: 0x478, Hi: 0x478, Stride: 0x1},
+		unicode.Range16{Lo: 0x47a, Hi: 0x47a, Stride: 0x1},
+		unicode.Range16{Lo: 0x47c, Hi: 0x47c, Stride: 0x1},
+		unicode.Range16{Lo: 0x47e, Hi: 0x47e, Stride: 0x1},
+		unicode.Range16{Lo: 0x480, Hi: 0x480, Stride: 0x1},
+		unicode.Range16{Lo: 0x48a, Hi: 0x48a, Stride: 0x1},
+		unicode.Range16{Lo: 0x48c, Hi: 0x48c, Stride: 0x1},
+		unicode.Range16{Lo: 0x48e, Hi: 0x48e, Stride: 0x1},
+		unicode.Range16{Lo: 0x490, Hi: 0x490, Stride: 0x1},
+		unicode.Range16{Lo: 0x492, Hi: 0x492, Stride: 0x1},
+		unicode.Range16{Lo: 0x494, Hi: 0x494, Stride: 0x1},
+		unicode.Range16{Lo: 0x496, Hi: 0x496, Stride: 0x1},
+		unicode.Range16{Lo: 0x498, Hi: 0x498, Stride: 0x1},
+		unicode.Range16{Lo: 0x49a, Hi: 0x49a, Stride: 0x1},
+		unicode.Range16{Lo: 0x49c, Hi: 0x49c, Stride: 0x1},
+		unicode.Range16{Lo: 0x49e, Hi: 0x49e, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a0, Hi: 0x4a0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a2, Hi: 0x4a2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a4, Hi: 0x4a4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a6, Hi: 0x4a6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a8, Hi: 0x4a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4aa, Hi: 0x4aa, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ac, Hi: 0x4ac, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ae, Hi: 0x4ae, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b0, Hi: 0x4b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b2, Hi: 0x4b2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b4, Hi: 0x4b4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b6, Hi: 0x4b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b8, Hi: 0x4b8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ba, Hi: 0x4ba, Stride: 0x1},
+		unicode.Range16{Lo: 0x4bc, Hi: 0x4bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x4be, Hi: 0x4be, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c0, Hi: 0x4c1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c3, Hi: 0x4c3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c5, Hi: 0x4c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c7, Hi: 0x4c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c9, Hi: 0x4c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4cb, Hi: 0x4cb, Stride: 0x1},
+		unicode.Range16{Lo: 0x4cd, Hi: 0x4cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d0, Hi: 0x4d0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d2, Hi: 0x4d2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d4, Hi: 0x4d4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d6, Hi: 0x4d6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d8, Hi: 0x4d8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4da, Hi: 0x4da, Stride: 0x1},
+		unicode.Range16{Lo: 0x4dc, Hi: 0x4dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x4de, Hi: 0x4de, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e0, Hi: 0x4e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e2, Hi: 0x4e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e4, Hi: 0x4e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e6, Hi: 0x4e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e8, Hi: 0x4e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ea, Hi: 0x4ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ec, Hi: 0x4ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ee, Hi: 0x4ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f0, Hi: 0x4f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f2, Hi: 0x4f2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f4, Hi: 0x4f4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f6, Hi: 0x4f6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f8, Hi: 0x4f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fa, Hi: 0x4fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fc, Hi: 0x4fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fe, Hi: 0x4fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x500, Hi: 0x500, Stride: 0x1},
+		unicode.Range16{Lo: 0x502, Hi: 0x502, Stride: 0x1},
+		unicode.Range16{Lo: 0x504, Hi: 0x504, Stride: 0x1},
+		unicode.Range16{Lo: 0x506, Hi: 0x506, Stride: 0x1},
+		unicode.Range16{Lo: 0x508, Hi: 0x508, Stride: 0x1},
+		unicode.Range16{Lo: 0x50a, Hi: 0x50a, Stride: 0x1},
+		unicode.Range16{Lo: 0x50c, Hi: 0x50c, Stride: 0x1},
+		unicode.Range16{Lo: 0x50e, Hi: 0x50e, Stride: 0x1},
+		unicode.Range16{Lo: 0x510, Hi: 0x510, Stride: 0x1},
+		unicode.Range16{Lo: 0x512, Hi: 0x512, Stride: 0x1},
+		unicode.Range16{Lo: 0x514, Hi: 0x514, Stride: 0x1},
+		unicode.Range16{Lo: 0x516, Hi: 0x516, Stride: 0x1},
+		unicode.Range16{Lo: 0x518, Hi: 0x518, Stride: 0x1},
+		unicode.Range16{Lo: 0x51a, Hi: 0x51a, Stride: 0x1},
+		unicode.Range16{Lo: 0x51c, Hi: 0x51c, Stride: 0x1},
+		unicode.Range16{Lo: 0x51e, Hi: 0x51e, Stride: 0x1},
+		unicode.Range16{Lo: 0x520, Hi: 0x520, Stride: 0x1},
+		unicode.Range16{Lo: 0x522, Hi: 0x522, Stride: 0x1},
+		unicode.Range16{Lo: 0x524, Hi: 0x524, Stride: 0x1},
+		unicode.Range16{Lo: 0x526, Hi: 0x526, Stride: 0x1},
+		unicode.Range16{Lo: 0x528, Hi: 0x528, Stride: 0x1},
+		unicode.Range16{Lo: 0x52a, Hi: 0x52a, Stride: 0x1},
+		unicode.Range16{Lo: 0x52c, Hi: 0x52c, Stride: 0x1},
+		unicode.Range16{Lo: 0x52e, Hi: 0x52e, Stride: 0x1},
+		unicode.Range16{Lo: 0x531, Hi: 0x556, Stride: 0x1},
+		unicode.Range16{Lo: 0x10a0, Hi: 0x10c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x10c7, Hi: 0x10c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x10cd, Hi: 0x10cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x13a0, Hi: 0x13f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e00, Hi: 0x1e00, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e02, Hi: 0x1e02, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e04, Hi: 0x1e04, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e06, Hi: 0x1e06, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e08, Hi: 0x1e08, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0a, Hi: 0x1e0a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0c, Hi: 0x1e0c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0e, Hi: 0x1e0e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e10, Hi: 0x1e10, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e12, Hi: 0x1e12, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e14, Hi: 0x1e14, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e16, Hi: 0x1e16, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e18, Hi: 0x1e18, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1a, Hi: 0x1e1a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1c, Hi: 0x1e1c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1e, Hi: 0x1e1e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e20, Hi: 0x1e20, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e22, Hi: 0x1e22, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e24, Hi: 0x1e24, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e26, Hi: 0x1e26, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e28, Hi: 0x1e28, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2a, Hi: 0x1e2a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2c, Hi: 0x1e2c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2e, Hi: 0x1e2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e30, Hi: 0x1e30, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e32, Hi: 0x1e32, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e34, Hi: 0x1e34, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e36, Hi: 0x1e36, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e38, Hi: 0x1e38, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3a, Hi: 0x1e3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3c, Hi: 0x1e3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3e, Hi: 0x1e3e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e40, Hi: 0x1e40, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e42, Hi: 0x1e42, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e44, Hi: 0x1e44, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e46, Hi: 0x1e46, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e48, Hi: 0x1e48, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4a, Hi: 0x1e4a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4c, Hi: 0x1e4c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4e, Hi: 0x1e4e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e50, Hi: 0x1e50, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e52, Hi: 0x1e52, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e54, Hi: 0x1e54, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e56, Hi: 0x1e56, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e58, Hi: 0x1e58, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5a, Hi: 0x1e5a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5c, Hi: 0x1e5c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5e, Hi: 0x1e5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e60, Hi: 0x1e60, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e62, Hi: 0x1e62, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e64, Hi: 0x1e64, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e66, Hi: 0x1e66, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e68, Hi: 0x1e68, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6a, Hi: 0x1e6a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6c, Hi: 0x1e6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6e, Hi: 0x1e6e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e70, Hi: 0x1e70, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e72, Hi: 0x1e72, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e74, Hi: 0x1e74, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e76, Hi: 0x1e76, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e78, Hi: 0x1e78, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7a, Hi: 0x1e7a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7c, Hi: 0x1e7c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7e, Hi: 0x1e7e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e80, Hi: 0x1e80, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e82, Hi: 0x1e82, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e84, Hi: 0x1e84, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e86, Hi: 0x1e86, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e88, Hi: 0x1e88, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8a, Hi: 0x1e8a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8c, Hi: 0x1e8c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8e, Hi: 0x1e8e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e90, Hi: 0x1e90, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e92, Hi: 0x1e92, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e94, Hi: 0x1e94, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e9e, Hi: 0x1e9e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea0, Hi: 0x1ea0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea2, Hi: 0x1ea2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea4, Hi: 0x1ea4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea6, Hi: 0x1ea6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea8, Hi: 0x1ea8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eaa, Hi: 0x1eaa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eac, Hi: 0x1eac, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eae, Hi: 0x1eae, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb0, Hi: 0x1eb0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb2, Hi: 0x1eb2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb4, Hi: 0x1eb4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb6, Hi: 0x1eb6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb8, Hi: 0x1eb8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eba, Hi: 0x1eba, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebc, Hi: 0x1ebc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebe, Hi: 0x1ebe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec0, Hi: 0x1ec0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec2, Hi: 0x1ec2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec4, Hi: 0x1ec4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec6, Hi: 0x1ec6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec8, Hi: 0x1ec8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eca, Hi: 0x1eca, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ecc, Hi: 0x1ecc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ece, Hi: 0x1ece, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed0, Hi: 0x1ed0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed2, Hi: 0x1ed2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed4, Hi: 0x1ed4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed6, Hi: 0x1ed6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed8, Hi: 0x1ed8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eda, Hi: 0x1eda, Stride: 0x1},
+		unicode.Range16{Lo: 0x1edc, Hi: 0x1edc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ede, Hi: 0x1ede, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee0, Hi: 0x1ee0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee2, Hi: 0x1ee2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee4, Hi: 0x1ee4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee6, Hi: 0x1ee6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee8, Hi: 0x1ee8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eea, Hi: 0x1eea, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eec, Hi: 0x1eec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eee, Hi: 0x1eee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef0, Hi: 0x1ef0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef2, Hi: 0x1ef2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef4, Hi: 0x1ef4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef6, Hi: 0x1ef6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef8, Hi: 0x1ef8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efa, Hi: 0x1efa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efc, Hi: 0x1efc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efe, Hi: 0x1efe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f08, Hi: 0x1f0f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f18, Hi: 0x1f1d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f28, Hi: 0x1f2f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f38, Hi: 0x1f3f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f48, Hi: 0x1f4d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f59, Hi: 0x1f59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5b, Hi: 0x1f5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5d, Hi: 0x1f5d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5f, Hi: 0x1f5f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f68, Hi: 0x1f6f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f88, Hi: 0x1f8f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f98, Hi: 0x1f9f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fa8, Hi: 0x1faf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb8, Hi: 0x1fbc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc8, Hi: 0x1fcc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd8, Hi: 0x1fdb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fe8, Hi: 0x1fec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff8, Hi: 0x1ffc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2102, Hi: 0x2102, Stride: 0x1},
+		unicode.Range16{Lo: 0x2107, Hi: 0x2107, Stride: 0x1},
+		unicode.Range16{Lo: 0x210b, Hi: 0x210d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2110, Hi: 0x2112, Stride: 0x1},
+		unicode.Range16{Lo: 0x2115, Hi: 0x2115, Stride: 0x1},
+		unicode.Range16{Lo: 0x2119, Hi: 0x211d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2124, Hi: 0x2124, Stride: 0x1},
+		unicode.Range16{Lo: 0x2126, Hi: 0x2126, Stride: 0x1},
+		unicode.Range16{Lo: 0x2128, Hi: 0x2128, Stride: 0x1},
+		unicode.Range16{Lo: 0x212a, Hi: 0x212d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2130, Hi: 0x2133, Stride: 0x1},
+		unicode.Range16{Lo: 0x213e, Hi: 0x213f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2145, Hi: 0x2145, Stride: 0x1},
+		unicode.Range16{Lo: 0x2160, Hi: 0x216f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2183, Hi: 0x2183, Stride: 0x1},
+		unicode.Range16{Lo: 0x24b6, Hi: 0x24cf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c00, Hi: 0x2c2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c60, Hi: 0x2c60, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c62, Hi: 0x2c64, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c67, Hi: 0x2c67, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c69, Hi: 0x2c69, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6b, Hi: 0x2c6b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6d, Hi: 0x2c70, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c72, Hi: 0x2c72, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c75, Hi: 0x2c75, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c7e, Hi: 0x2c80, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c82, Hi: 0x2c82, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c84, Hi: 0x2c84, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c86, Hi: 0x2c86, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c88, Hi: 0x2c88, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8a, Hi: 0x2c8a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8c, Hi: 0x2c8c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8e, Hi: 0x2c8e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c90, Hi: 0x2c90, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c92, Hi: 0x2c92, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c94, Hi: 0x2c94, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c96, Hi: 0x2c96, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c98, Hi: 0x2c98, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9a, Hi: 0x2c9a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9c, Hi: 0x2c9c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9e, Hi: 0x2c9e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca0, Hi: 0x2ca0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca2, Hi: 0x2ca2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca4, Hi: 0x2ca4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca6, Hi: 0x2ca6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca8, Hi: 0x2ca8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2caa, Hi: 0x2caa, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cac, Hi: 0x2cac, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cae, Hi: 0x2cae, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb0, Hi: 0x2cb0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb2, Hi: 0x2cb2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb4, Hi: 0x2cb4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb6, Hi: 0x2cb6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb8, Hi: 0x2cb8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cba, Hi: 0x2cba, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbc, Hi: 0x2cbc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbe, Hi: 0x2cbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc0, Hi: 0x2cc0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc2, Hi: 0x2cc2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc4, Hi: 0x2cc4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc6, Hi: 0x2cc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc8, Hi: 0x2cc8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cca, Hi: 0x2cca, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ccc, Hi: 0x2ccc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cce, Hi: 0x2cce, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd0, Hi: 0x2cd0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd2, Hi: 0x2cd2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd4, Hi: 0x2cd4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd6, Hi: 0x2cd6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd8, Hi: 0x2cd8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cda, Hi: 0x2cda, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cdc, Hi: 0x2cdc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cde, Hi: 0x2cde, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ce0, Hi: 0x2ce0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ce2, Hi: 0x2ce2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ceb, Hi: 0x2ceb, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ced, Hi: 0x2ced, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cf2, Hi: 0x2cf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xa640, Hi: 0xa640, Stride: 0x1},
+		unicode.Range16{Lo: 0xa642, Hi: 0xa642, Stride: 0x1},
+		unicode.Range16{Lo: 0xa644, Hi: 0xa644, Stride: 0x1},
+		unicode.Range16{Lo: 0xa646, Hi: 0xa646, Stride: 0x1},
+		unicode.Range16{Lo: 0xa648, Hi: 0xa648, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64a, Hi: 0xa64a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64c, Hi: 0xa64c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64e, Hi: 0xa64e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa650, Hi: 0xa650, Stride: 0x1},
+		unicode.Range16{Lo: 0xa652, Hi: 0xa652, Stride: 0x1},
+		unicode.Range16{Lo: 0xa654, Hi: 0xa654, Stride: 0x1},
+		unicode.Range16{Lo: 0xa656, Hi: 0xa656, Stride: 0x1},
+		unicode.Range16{Lo: 0xa658, Hi: 0xa658, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65a, Hi: 0xa65a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65c, Hi: 0xa65c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65e, Hi: 0xa65e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa660, Hi: 0xa660, Stride: 0x1},
+		unicode.Range16{Lo: 0xa662, Hi: 0xa662, Stride: 0x1},
+		unicode.Range16{Lo: 0xa664, Hi: 0xa664, Stride: 0x1},
+		unicode.Range16{Lo: 0xa666, Hi: 0xa666, Stride: 0x1},
+		unicode.Range16{Lo: 0xa668, Hi: 0xa668, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66a, Hi: 0xa66a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66c, Hi: 0xa66c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa680, Hi: 0xa680, Stride: 0x1},
+		unicode.Range16{Lo: 0xa682, Hi: 0xa682, Stride: 0x1},
+		unicode.Range16{Lo: 0xa684, Hi: 0xa684, Stride: 0x1},
+		unicode.Range16{Lo: 0xa686, Hi: 0xa686, Stride: 0x1},
+		unicode.Range16{Lo: 0xa688, Hi: 0xa688, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68a, Hi: 0xa68a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68c, Hi: 0xa68c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68e, Hi: 0xa68e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa690, Hi: 0xa690, Stride: 0x1},
+		unicode.Range16{Lo: 0xa692, Hi: 0xa692, Stride: 0x1},
+		unicode.Range16{Lo: 0xa694, Hi: 0xa694, Stride: 0x1},
+		unicode.Range16{Lo: 0xa696, Hi: 0xa696, Stride: 0x1},
+		unicode.Range16{Lo: 0xa698, Hi: 0xa698, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69a, Hi: 0xa69a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa722, Hi: 0xa722, Stride: 0x1},
+		unicode.Range16{Lo: 0xa724, Hi: 0xa724, Stride: 0x1},
+		unicode.Range16{Lo: 0xa726, Hi: 0xa726, Stride: 0x1},
+		unicode.Range16{Lo: 0xa728, Hi: 0xa728, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72a, Hi: 0xa72a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72c, Hi: 0xa72c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72e, Hi: 0xa72e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa732, Hi: 0xa732, Stride: 0x1},
+		unicode.Range16{Lo: 0xa734, Hi: 0xa734, Stride: 0x1},
+		unicode.Range16{Lo: 0xa736, Hi: 0xa736, Stride: 0x1},
+		unicode.Range16{Lo: 0xa738, Hi: 0xa738, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73a, Hi: 0xa73a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73c, Hi: 0xa73c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73e, Hi: 0xa73e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa740, Hi: 0xa740, Stride: 0x1},
+		unicode.Range16{Lo: 0xa742, Hi: 0xa742, Stride: 0x1},
+		unicode.Range16{Lo: 0xa744, Hi: 0xa744, Stride: 0x1},
+		unicode.Range16{Lo: 0xa746, Hi: 0xa746, Stride: 0x1},
+		unicode.Range16{Lo: 0xa748, Hi: 0xa748, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74a, Hi: 0xa74a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74c, Hi: 0xa74c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74e, Hi: 0xa74e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa750, Hi: 0xa750, Stride: 0x1},
+		unicode.Range16{Lo: 0xa752, Hi: 0xa752, Stride: 0x1},
+		unicode.Range16{Lo: 0xa754, Hi: 0xa754, Stride: 0x1},
+		unicode.Range16{Lo: 0xa756, Hi: 0xa756, Stride: 0x1},
+		unicode.Range16{Lo: 0xa758, Hi: 0xa758, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75a, Hi: 0xa75a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75c, Hi: 0xa75c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75e, Hi: 0xa75e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa760, Hi: 0xa760, Stride: 0x1},
+		unicode.Range16{Lo: 0xa762, Hi: 0xa762, Stride: 0x1},
+		unicode.Range16{Lo: 0xa764, Hi: 0xa764, Stride: 0x1},
+		unicode.Range16{Lo: 0xa766, Hi: 0xa766, Stride: 0x1},
+		unicode.Range16{Lo: 0xa768, Hi: 0xa768, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76a, Hi: 0xa76a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76c, Hi: 0xa76c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76e, Hi: 0xa76e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa779, Hi: 0xa779, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77b, Hi: 0xa77b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77d, Hi: 0xa77e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa780, Hi: 0xa780, Stride: 0x1},
+		unicode.Range16{Lo: 0xa782, Hi: 0xa782, Stride: 0x1},
+		unicode.Range16{Lo: 0xa784, Hi: 0xa784, Stride: 0x1},
+		unicode.Range16{Lo: 0xa786, Hi: 0xa786, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78b, Hi: 0xa78b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78d, Hi: 0xa78d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa790, Hi: 0xa790, Stride: 0x1},
+		unicode.Range16{Lo: 0xa792, Hi: 0xa792, Stride: 0x1},
+		unicode.Range16{Lo: 0xa796, Hi: 0xa796, Stride: 0x1},
+		unicode.Range16{Lo: 0xa798, Hi: 0xa798, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79a, Hi: 0xa79a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79c, Hi: 0xa79c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79e, Hi: 0xa79e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a0, Hi: 0xa7a0, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a2, Hi: 0xa7a2, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a4, Hi: 0xa7a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a6, Hi: 0xa7a6, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a8, Hi: 0xa7a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7aa, Hi: 0xa7ae, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b0, Hi: 0xa7b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b6, Hi: 0xa7b6, Stride: 0x1},
+		unicode.Range16{Lo: 0xff21, Hi: 0xff3a, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10400, Hi: 0x10427, Stride: 0x1},
+		unicode.Range32{Lo: 0x104b0, Hi: 0x104d3, Stride: 0x1},
+		unicode.Range32{Lo: 0x10c80, Hi: 0x10cb2, Stride: 0x1},
+		unicode.Range32{Lo: 0x118a0, Hi: 0x118bf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d400, Hi: 0x1d419, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d434, Hi: 0x1d44d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d468, Hi: 0x1d481, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d49c, Hi: 0x1d49c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d49e, Hi: 0x1d49f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a2, Hi: 0x1d4a2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a5, Hi: 0x1d4a6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a9, Hi: 0x1d4ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4ae, Hi: 0x1d4b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4d0, Hi: 0x1d4e9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d504, Hi: 0x1d505, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d507, Hi: 0x1d50a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d50d, Hi: 0x1d514, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d516, Hi: 0x1d51c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d538, Hi: 0x1d539, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d53b, Hi: 0x1d53e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d540, Hi: 0x1d544, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d546, Hi: 0x1d546, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d54a, Hi: 0x1d550, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d56c, Hi: 0x1d585, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d5a0, Hi: 0x1d5b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d5d4, Hi: 0x1d5ed, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d608, Hi: 0x1d621, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d63c, Hi: 0x1d655, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d670, Hi: 0x1d689, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6a8, Hi: 0x1d6c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6e2, Hi: 0x1d6fa, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d71c, Hi: 0x1d734, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d756, Hi: 0x1d76e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d790, Hi: 0x1d7a8, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7ca, Hi: 0x1d7ca, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e900, Hi: 0x1e921, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f130, Hi: 0x1f149, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f150, Hi: 0x1f169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f170, Hi: 0x1f189, Stride: 0x1},
+	},
+	LatinOffset: 3,
+}
+
+type _SentenceRuneRange unicode.RangeTable
+
+func _SentenceRuneType(r rune) *_SentenceRuneRange {
+	switch {
+	case unicode.Is(_SentenceATerm, r):
+		return (*_SentenceRuneRange)(_SentenceATerm)
+	case unicode.Is(_SentenceCR, r):
+		return (*_SentenceRuneRange)(_SentenceCR)
+	case unicode.Is(_SentenceClose, r):
+		return (*_SentenceRuneRange)(_SentenceClose)
+	case unicode.Is(_SentenceExtend, r):
+		return (*_SentenceRuneRange)(_SentenceExtend)
+	case unicode.Is(_SentenceFormat, r):
+		return (*_SentenceRuneRange)(_SentenceFormat)
+	case unicode.Is(_SentenceLF, r):
+		return (*_SentenceRuneRange)(_SentenceLF)
+	case unicode.Is(_SentenceLower, r):
+		return (*_SentenceRuneRange)(_SentenceLower)
+	case unicode.Is(_SentenceNumeric, r):
+		return (*_SentenceRuneRange)(_SentenceNumeric)
+	case unicode.Is(_SentenceOLetter, r):
+		return (*_SentenceRuneRange)(_SentenceOLetter)
+	case unicode.Is(_SentenceSContinue, r):
+		return (*_SentenceRuneRange)(_SentenceSContinue)
+	case unicode.Is(_SentenceSTerm, r):
+		return (*_SentenceRuneRange)(_SentenceSTerm)
+	case unicode.Is(_SentenceSep, r):
+		return (*_SentenceRuneRange)(_SentenceSep)
+	case unicode.Is(_SentenceSp, r):
+		return (*_SentenceRuneRange)(_SentenceSp)
+	case unicode.Is(_SentenceUpper, r):
+		return (*_SentenceRuneRange)(_SentenceUpper)
+	default:
+		return nil
+	}
+}
+func (rng *_SentenceRuneRange) String() string {
+	switch (*unicode.RangeTable)(rng) {
+	case _SentenceATerm:
+		return "ATerm"
+	case _SentenceCR:
+		return "CR"
+	case _SentenceClose:
+		return "Close"
+	case _SentenceExtend:
+		return "Extend"
+	case _SentenceFormat:
+		return "Format"
+	case _SentenceLF:
+		return "LF"
+	case _SentenceLower:
+		return "Lower"
+	case _SentenceNumeric:
+		return "Numeric"
+	case _SentenceOLetter:
+		return "OLetter"
+	case _SentenceSContinue:
+		return "SContinue"
+	case _SentenceSTerm:
+		return "STerm"
+	case _SentenceSep:
+		return "Sep"
+	case _SentenceSp:
+		return "Sp"
+	case _SentenceUpper:
+		return "Upper"
+	default:
+		return "Other"
+	}
+}
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/unicode2ragel.rb b/vendor/github.com/apparentlymart/go-textseg/textseg/unicode2ragel.rb
new file mode 100644
index 00000000..422e4e5c
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/unicode2ragel.rb
@@ -0,0 +1,335 @@
+#!/usr/bin/env ruby
+#
+# This scripted has been updated to accept more command-line arguments:
+#
+#    -u, --url                        URL to process
+#    -m, --machine                    Machine name
+#    -p, --properties                 Properties to add to the machine
+#    -o, --output                     Write output to file
+#
+# Updated by: Marty Schoch <marty.schoch@gmail.com>
+# 
+# This script uses the unicode spec to generate a Ragel state machine
+# that recognizes unicode alphanumeric characters.  It generates 5
+# character classes: uupper, ulower, ualpha, udigit, and ualnum.
+# Currently supported encodings are UTF-8 [default] and UCS-4.
+#
+# Usage: unicode2ragel.rb [options]
+#    -e, --encoding [ucs4 | utf8]     Data encoding
+#    -h, --help                       Show this message
+#
+# This script was originally written as part of the Ferret search
+# engine library.
+#
+# Author: Rakan El-Khalil <rakan@well.com>
+
+require 'optparse'
+require 'open-uri'
+
+ENCODINGS = [ :utf8, :ucs4 ]
+ALPHTYPES = { :utf8 => "byte", :ucs4 => "rune" }
+DEFAULT_CHART_URL = "http://www.unicode.org/Public/5.1.0/ucd/DerivedCoreProperties.txt"
+DEFAULT_MACHINE_NAME= "WChar"
+
+###
+# Display vars & default option
+
+TOTAL_WIDTH = 80
+RANGE_WIDTH = 23
+@encoding = :utf8
+@chart_url = DEFAULT_CHART_URL
+machine_name = DEFAULT_MACHINE_NAME
+properties = []
+@output = $stdout
+
+###
+# Option parsing
+
+cli_opts = OptionParser.new do |opts|
+  opts.on("-e", "--encoding [ucs4 | utf8]", "Data encoding") do |o|
+    @encoding = o.downcase.to_sym
+  end
+  opts.on("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+  opts.on("-u", "--url URL", "URL to process") do |o|
+    @chart_url = o 
+  end
+  opts.on("-m", "--machine MACHINE_NAME", "Machine name") do |o|
+    machine_name = o
+  end
+  opts.on("-p", "--properties x,y,z", Array, "Properties to add to machine") do |o|
+    properties = o
+  end
+  opts.on("-o", "--output FILE", "output file") do |o|
+    @output = File.new(o, "w+")
+  end
+end
+
+cli_opts.parse(ARGV)
+unless ENCODINGS.member? @encoding
+  puts "Invalid encoding: #{@encoding}"
+  puts cli_opts
+  exit
+end
+
+##
+# Downloads the document at url and yields every alpha line's hex
+# range and description.
+
+def each_alpha( url, property ) 
+  open( url ) do |file|
+    file.each_line do |line|
+      next if line =~ /^#/;
+      next if line !~ /; #{property} #/;
+
+      range, description = line.split(/;/)
+      range.strip!
+      description.gsub!(/.*#/, '').strip!
+
+      if range =~ /\.\./
+           start, stop = range.split '..'
+      else start = stop = range
+      end
+
+      yield start.hex .. stop.hex, description
+    end
+  end
+end
+
+###
+# Formats to hex at minimum width
+
+def to_hex( n )
+  r = "%0X" % n
+  r = "0#{r}" unless (r.length % 2).zero?
+  r
+end
+
+###
+# UCS4 is just a straight hex conversion of the unicode codepoint.
+
+def to_ucs4( range )
+  rangestr  =   "0x" + to_hex(range.begin)
+  rangestr << "..0x" + to_hex(range.end) if range.begin != range.end
+  [ rangestr ]
+end
+
+##
+# 0x00     - 0x7f     -> 0zzzzzzz[7]
+# 0x80     - 0x7ff    -> 110yyyyy[5] 10zzzzzz[6]
+# 0x800    - 0xffff   -> 1110xxxx[4] 10yyyyyy[6] 10zzzzzz[6]
+# 0x010000 - 0x10ffff -> 11110www[3] 10xxxxxx[6] 10yyyyyy[6] 10zzzzzz[6] 
+
+UTF8_BOUNDARIES = [0x7f, 0x7ff, 0xffff, 0x10ffff]
+
+def to_utf8_enc( n )
+  r = 0
+  if n <= 0x7f
+    r = n
+  elsif n <= 0x7ff
+    y = 0xc0 | (n >> 6)
+    z = 0x80 | (n & 0x3f)
+    r = y << 8 | z
+  elsif n <= 0xffff
+    x = 0xe0 | (n >> 12)
+    y = 0x80 | (n >>  6) & 0x3f
+    z = 0x80 |  n        & 0x3f
+    r = x << 16 | y << 8 | z
+  elsif n <= 0x10ffff
+    w = 0xf0 | (n >> 18)
+    x = 0x80 | (n >> 12) & 0x3f
+    y = 0x80 | (n >>  6) & 0x3f
+    z = 0x80 |  n        & 0x3f
+    r = w << 24 | x << 16 | y << 8 | z
+  end
+
+  to_hex(r)
+end
+
+def from_utf8_enc( n )
+  n = n.hex
+  r = 0
+  if n <= 0x7f
+    r = n
+  elsif n <= 0xdfff
+    y = (n >> 8) & 0x1f
+    z =  n       & 0x3f
+    r = y << 6 | z
+  elsif n <= 0xefffff
+    x = (n >> 16) & 0x0f
+    y = (n >>  8) & 0x3f
+    z =  n        & 0x3f
+    r = x << 10 | y << 6 | z
+  elsif n <= 0xf7ffffff
+    w = (n >> 24) & 0x07
+    x = (n >> 16) & 0x3f
+    y = (n >>  8) & 0x3f
+    z =  n        & 0x3f
+    r = w << 18 | x << 12 | y << 6 | z
+  end
+  r
+end
+
+###
+# Given a range, splits it up into ranges that can be continuously
+# encoded into utf8.  Eg: 0x00 .. 0xff => [0x00..0x7f, 0x80..0xff]
+# This is not strictly needed since the current [5.1] unicode standard
+# doesn't have ranges that straddle utf8 boundaries.  This is included
+# for completeness as there is no telling if that will ever change.
+
+def utf8_ranges( range )
+  ranges = []
+  UTF8_BOUNDARIES.each do |max|
+    if range.begin <= max
+      if range.end <= max
+        ranges << range
+        return ranges
+      end
+
+      ranges << (range.begin .. max)
+      range = (max + 1) .. range.end
+    end
+  end
+  ranges
+end
+
+def build_range( start, stop )
+  size = start.size/2
+  left = size - 1
+  return [""] if size < 1
+
+  a = start[0..1]
+  b = stop[0..1]
+
+  ###
+  # Shared prefix
+
+  if a == b
+    return build_range(start[2..-1], stop[2..-1]).map do |elt|
+      "0x#{a} " + elt
+    end
+  end
+
+  ###
+  # Unshared prefix, end of run
+
+  return ["0x#{a}..0x#{b} "] if left.zero?
+  
+  ###
+  # Unshared prefix, not end of run
+  # Range can be 0x123456..0x56789A
+  # Which is equivalent to:
+  #     0x123456 .. 0x12FFFF
+  #     0x130000 .. 0x55FFFF
+  #     0x560000 .. 0x56789A
+
+  ret = []
+  ret << build_range(start, a + "FF" * left)
+
+  ###
+  # Only generate middle range if need be.
+
+  if a.hex+1 != b.hex
+    max = to_hex(b.hex - 1)
+    max = "FF" if b == "FF"
+    ret << "0x#{to_hex(a.hex+1)}..0x#{max} " + "0x00..0xFF " * left
+  end
+
+  ###
+  # Don't generate last range if it is covered by first range
+  
+  ret << build_range(b + "00" * left, stop) unless b == "FF"
+  ret.flatten!
+end
+
+def to_utf8( range )
+  utf8_ranges( range ).map do |r|   
+    begin_enc = to_utf8_enc(r.begin)
+    end_enc = to_utf8_enc(r.end)
+    build_range begin_enc, end_enc
+  end.flatten!
+end
+
+##
+# Perform a 3-way comparison of the number of codepoints advertised by
+# the unicode spec for the given range, the originally parsed range,
+# and the resulting utf8 encoded range.
+
+def count_codepoints( code )
+  code.split(' ').inject(1) do |acc, elt|
+    if elt =~ /0x(.+)\.\.0x(.+)/
+      if @encoding == :utf8
+        acc * (from_utf8_enc($2) - from_utf8_enc($1) + 1)
+      else
+        acc * ($2.hex - $1.hex + 1)
+      end
+    else
+      acc
+    end
+  end
+end
+
+def is_valid?( range, desc, codes )
+  spec_count  = 1
+  spec_count  = $1.to_i if desc =~ /\[(\d+)\]/
+  range_count = range.end - range.begin + 1
+
+  sum = codes.inject(0) { |acc, elt| acc + count_codepoints(elt) }
+  sum == spec_count and sum == range_count
+end
+
+##
+# Generate the state maching to stdout
+
+def generate_machine( name, property )
+  pipe = " "
+  @output.puts "    #{name} = "
+  each_alpha( @chart_url, property ) do |range, desc|
+
+    codes = (@encoding == :ucs4) ? to_ucs4(range) : to_utf8(range)
+
+    #raise "Invalid encoding of range #{range}: #{codes.inspect}" unless 
+    #  is_valid? range, desc, codes
+
+    range_width = codes.map { |a| a.size }.max
+    range_width = RANGE_WIDTH if range_width < RANGE_WIDTH
+
+    desc_width  = TOTAL_WIDTH - RANGE_WIDTH - 11
+    desc_width -= (range_width - RANGE_WIDTH) if range_width > RANGE_WIDTH
+
+    if desc.size > desc_width
+      desc = desc[0..desc_width - 4] + "..."
+    end
+
+    codes.each_with_index do |r, idx|
+      desc = "" unless idx.zero?
+      code = "%-#{range_width}s" % r
+      @output.puts "      #{pipe} #{code} ##{desc}"
+      pipe = "|"
+    end
+  end
+  @output.puts "      ;"
+  @output.puts ""
+end
+
+@output.puts <<EOF
+# The following Ragel file was autogenerated with #{$0} 
+# from: #{@chart_url}
+#
+# It defines #{properties}.
+#
+# To use this, make sure that your alphtype is set to #{ALPHTYPES[@encoding]},
+# and that your input is in #{@encoding}.
+
+%%{
+    machine #{machine_name};
+    
+EOF
+
+properties.each { |x| generate_machine( x, x ) }
+
+@output.puts <<EOF
+}%%
+EOF
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/utf8_seqs.go b/vendor/github.com/apparentlymart/go-textseg/textseg/utf8_seqs.go
new file mode 100644
index 00000000..6b14bef0
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/utf8_seqs.go
@@ -0,0 +1,19 @@
+package textseg
+
+import "unicode/utf8"
+
+// ScanGraphemeClusters is a split function for bufio.Scanner that splits
+// on UTF8 sequence boundaries.
+//
+// This is included largely for completeness, since this behavior is already
+// built in to Go when ranging over a string.
+func ScanUTF8Sequences(data []byte, atEOF bool) (int, []byte, error) {
+	if len(data) == 0 {
+		return 0, nil, nil
+	}
+	r, seqLen := utf8.DecodeRune(data)
+	if r == utf8.RuneError && !atEOF {
+		return 0, nil, nil
+	}
+	return seqLen, data[:seqLen], nil
+}
diff --git a/vendor/github.com/google/go-cmp/LICENSE b/vendor/github.com/google/go-cmp/LICENSE
new file mode 100644
index 00000000..32017f8f
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2017 The Go 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/google/go-cmp/cmp/compare.go b/vendor/github.com/google/go-cmp/cmp/compare.go
new file mode 100644
index 00000000..2133562b
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/compare.go
@@ -0,0 +1,616 @@
+// Copyright 2017, 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.md file.
+
+// Package cmp determines equality of values.
+//
+// This package is intended to be a more powerful and safer alternative to
+// reflect.DeepEqual for comparing whether two values are semantically equal.
+//
+// The primary features of cmp are:
+//
+// • When the default behavior of equality does not suit the needs of the test,
+// custom equality functions can override the equality operation.
+// For example, an equality function may report floats as equal so long as they
+// are within some tolerance of each other.
+//
+// • Types that have an Equal method may use that method to determine equality.
+// This allows package authors to determine the equality operation for the types
+// that they define.
+//
+// • If no custom equality functions are used and no Equal method is defined,
+// equality is determined by recursively comparing the primitive kinds on both
+// values, much like reflect.DeepEqual. Unlike reflect.DeepEqual, unexported
+// fields are not compared by default; they result in panics unless suppressed
+// by using an Ignore option (see cmpopts.IgnoreUnexported) or explicitly compared
+// using the AllowUnexported option.
+package cmp
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/google/go-cmp/cmp/internal/diff"
+	"github.com/google/go-cmp/cmp/internal/flags"
+	"github.com/google/go-cmp/cmp/internal/function"
+	"github.com/google/go-cmp/cmp/internal/value"
+)
+
+// Equal reports whether x and y are equal by recursively applying the
+// following rules in the given order to x and y and all of their sub-values:
+//
+// • Let S be the set of all Ignore, Transformer, and Comparer options that
+// remain after applying all path filters, value filters, and type filters.
+// If at least one Ignore exists in S, then the comparison is ignored.
+// If the number of Transformer and Comparer options in S is greater than one,
+// then Equal panics because it is ambiguous which option to use.
+// If S contains a single Transformer, then use that to transform the current
+// values and recursively call Equal on the output values.
+// If S contains a single Comparer, then use that to compare the current values.
+// Otherwise, evaluation proceeds to the next rule.
+//
+// • If the values have an Equal method of the form "(T) Equal(T) bool" or
+// "(T) Equal(I) bool" where T is assignable to I, then use the result of
+// x.Equal(y) even if x or y is nil. Otherwise, no such method exists and
+// evaluation proceeds to the next rule.
+//
+// • Lastly, try to compare x and y based on their basic kinds.
+// Simple kinds like booleans, integers, floats, complex numbers, strings, and
+// channels are compared using the equivalent of the == operator in Go.
+// Functions are only equal if they are both nil, otherwise they are unequal.
+//
+// Structs are equal if recursively calling Equal on all fields report equal.
+// If a struct contains unexported fields, Equal panics unless an Ignore option
+// (e.g., cmpopts.IgnoreUnexported) ignores that field or the AllowUnexported
+// option explicitly permits comparing the unexported field.
+//
+// Slices are equal if they are both nil or both non-nil, where recursively
+// calling Equal on all non-ignored slice or array elements report equal.
+// Empty non-nil slices and nil slices are not equal; to equate empty slices,
+// consider using cmpopts.EquateEmpty.
+//
+// Maps are equal if they are both nil or both non-nil, where recursively
+// calling Equal on all non-ignored map entries report equal.
+// Map keys are equal according to the == operator.
+// To use custom comparisons for map keys, consider using cmpopts.SortMaps.
+// Empty non-nil maps and nil maps are not equal; to equate empty maps,
+// consider using cmpopts.EquateEmpty.
+//
+// Pointers and interfaces are equal if they are both nil or both non-nil,
+// where they have the same underlying concrete type and recursively
+// calling Equal on the underlying values reports equal.
+func Equal(x, y interface{}, opts ...Option) bool {
+	vx := reflect.ValueOf(x)
+	vy := reflect.ValueOf(y)
+
+	// If the inputs are different types, auto-wrap them in an empty interface
+	// so that they have the same parent type.
+	var t reflect.Type
+	if !vx.IsValid() || !vy.IsValid() || vx.Type() != vy.Type() {
+		t = reflect.TypeOf((*interface{})(nil)).Elem()
+		if vx.IsValid() {
+			vvx := reflect.New(t).Elem()
+			vvx.Set(vx)
+			vx = vvx
+		}
+		if vy.IsValid() {
+			vvy := reflect.New(t).Elem()
+			vvy.Set(vy)
+			vy = vvy
+		}
+	} else {
+		t = vx.Type()
+	}
+
+	s := newState(opts)
+	s.compareAny(&pathStep{t, vx, vy})
+	return s.result.Equal()
+}
+
+// Diff returns a human-readable report of the differences between two values.
+// It returns an empty string if and only if Equal returns true for the same
+// input values and options.
+//
+// The output is displayed as a literal in pseudo-Go syntax.
+// At the start of each line, a "-" prefix indicates an element removed from x,
+// a "+" prefix to indicates an element added to y, and the lack of a prefix
+// indicates an element common to both x and y. If possible, the output
+// uses fmt.Stringer.String or error.Error methods to produce more humanly
+// readable outputs. In such cases, the string is prefixed with either an
+// 's' or 'e' character, respectively, to indicate that the method was called.
+//
+// Do not depend on this output being stable. If you need the ability to
+// programmatically interpret the difference, consider using a custom Reporter.
+func Diff(x, y interface{}, opts ...Option) string {
+	r := new(defaultReporter)
+	eq := Equal(x, y, Options(opts), Reporter(r))
+	d := r.String()
+	if (d == "") != eq {
+		panic("inconsistent difference and equality results")
+	}
+	return d
+}
+
+type state struct {
+	// These fields represent the "comparison state".
+	// Calling statelessCompare must not result in observable changes to these.
+	result    diff.Result // The current result of comparison
+	curPath   Path        // The current path in the value tree
+	reporters []reporter  // Optional reporters
+
+	// recChecker checks for infinite cycles applying the same set of
+	// transformers upon the output of itself.
+	recChecker recChecker
+
+	// dynChecker triggers pseudo-random checks for option correctness.
+	// It is safe for statelessCompare to mutate this value.
+	dynChecker dynChecker
+
+	// These fields, once set by processOption, will not change.
+	exporters map[reflect.Type]bool // Set of structs with unexported field visibility
+	opts      Options               // List of all fundamental and filter options
+}
+
+func newState(opts []Option) *state {
+	// Always ensure a validator option exists to validate the inputs.
+	s := &state{opts: Options{validator{}}}
+	s.processOption(Options(opts))
+	return s
+}
+
+func (s *state) processOption(opt Option) {
+	switch opt := opt.(type) {
+	case nil:
+	case Options:
+		for _, o := range opt {
+			s.processOption(o)
+		}
+	case coreOption:
+		type filtered interface {
+			isFiltered() bool
+		}
+		if fopt, ok := opt.(filtered); ok && !fopt.isFiltered() {
+			panic(fmt.Sprintf("cannot use an unfiltered option: %v", opt))
+		}
+		s.opts = append(s.opts, opt)
+	case visibleStructs:
+		if s.exporters == nil {
+			s.exporters = make(map[reflect.Type]bool)
+		}
+		for t := range opt {
+			s.exporters[t] = true
+		}
+	case reporter:
+		s.reporters = append(s.reporters, opt)
+	default:
+		panic(fmt.Sprintf("unknown option %T", opt))
+	}
+}
+
+// statelessCompare compares two values and returns the result.
+// This function is stateless in that it does not alter the current result,
+// or output to any registered reporters.
+func (s *state) statelessCompare(step PathStep) diff.Result {
+	// We do not save and restore the curPath because all of the compareX
+	// methods should properly push and pop from the path.
+	// It is an implementation bug if the contents of curPath differs from
+	// when calling this function to when returning from it.
+
+	oldResult, oldReporters := s.result, s.reporters
+	s.result = diff.Result{} // Reset result
+	s.reporters = nil        // Remove reporters to avoid spurious printouts
+	s.compareAny(step)
+	res := s.result
+	s.result, s.reporters = oldResult, oldReporters
+	return res
+}
+
+func (s *state) compareAny(step PathStep) {
+	// Update the path stack.
+	s.curPath.push(step)
+	defer s.curPath.pop()
+	for _, r := range s.reporters {
+		r.PushStep(step)
+		defer r.PopStep()
+	}
+	s.recChecker.Check(s.curPath)
+
+	// Obtain the current type and values.
+	t := step.Type()
+	vx, vy := step.Values()
+
+	// Rule 1: Check whether an option applies on this node in the value tree.
+	if s.tryOptions(t, vx, vy) {
+		return
+	}
+
+	// Rule 2: Check whether the type has a valid Equal method.
+	if s.tryMethod(t, vx, vy) {
+		return
+	}
+
+	// Rule 3: Compare based on the underlying kind.
+	switch t.Kind() {
+	case reflect.Bool:
+		s.report(vx.Bool() == vy.Bool(), 0)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		s.report(vx.Int() == vy.Int(), 0)
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		s.report(vx.Uint() == vy.Uint(), 0)
+	case reflect.Float32, reflect.Float64:
+		s.report(vx.Float() == vy.Float(), 0)
+	case reflect.Complex64, reflect.Complex128:
+		s.report(vx.Complex() == vy.Complex(), 0)
+	case reflect.String:
+		s.report(vx.String() == vy.String(), 0)
+	case reflect.Chan, reflect.UnsafePointer:
+		s.report(vx.Pointer() == vy.Pointer(), 0)
+	case reflect.Func:
+		s.report(vx.IsNil() && vy.IsNil(), 0)
+	case reflect.Struct:
+		s.compareStruct(t, vx, vy)
+	case reflect.Slice, reflect.Array:
+		s.compareSlice(t, vx, vy)
+	case reflect.Map:
+		s.compareMap(t, vx, vy)
+	case reflect.Ptr:
+		s.comparePtr(t, vx, vy)
+	case reflect.Interface:
+		s.compareInterface(t, vx, vy)
+	default:
+		panic(fmt.Sprintf("%v kind not handled", t.Kind()))
+	}
+}
+
+func (s *state) tryOptions(t reflect.Type, vx, vy reflect.Value) bool {
+	// Evaluate all filters and apply the remaining options.
+	if opt := s.opts.filter(s, t, vx, vy); opt != nil {
+		opt.apply(s, vx, vy)
+		return true
+	}
+	return false
+}
+
+func (s *state) tryMethod(t reflect.Type, vx, vy reflect.Value) bool {
+	// Check if this type even has an Equal method.
+	m, ok := t.MethodByName("Equal")
+	if !ok || !function.IsType(m.Type, function.EqualAssignable) {
+		return false
+	}
+
+	eq := s.callTTBFunc(m.Func, vx, vy)
+	s.report(eq, reportByMethod)
+	return true
+}
+
+func (s *state) callTRFunc(f, v reflect.Value, step Transform) reflect.Value {
+	v = sanitizeValue(v, f.Type().In(0))
+	if !s.dynChecker.Next() {
+		return f.Call([]reflect.Value{v})[0]
+	}
+
+	// Run the function twice and ensure that we get the same results back.
+	// We run in goroutines so that the race detector (if enabled) can detect
+	// unsafe mutations to the input.
+	c := make(chan reflect.Value)
+	go detectRaces(c, f, v)
+	got := <-c
+	want := f.Call([]reflect.Value{v})[0]
+	if step.vx, step.vy = got, want; !s.statelessCompare(step).Equal() {
+		// To avoid false-positives with non-reflexive equality operations,
+		// we sanity check whether a value is equal to itself.
+		if step.vx, step.vy = want, want; !s.statelessCompare(step).Equal() {
+			return want
+		}
+		panic(fmt.Sprintf("non-deterministic function detected: %s", function.NameOf(f)))
+	}
+	return want
+}
+
+func (s *state) callTTBFunc(f, x, y reflect.Value) bool {
+	x = sanitizeValue(x, f.Type().In(0))
+	y = sanitizeValue(y, f.Type().In(1))
+	if !s.dynChecker.Next() {
+		return f.Call([]reflect.Value{x, y})[0].Bool()
+	}
+
+	// Swapping the input arguments is sufficient to check that
+	// f is symmetric and deterministic.
+	// We run in goroutines so that the race detector (if enabled) can detect
+	// unsafe mutations to the input.
+	c := make(chan reflect.Value)
+	go detectRaces(c, f, y, x)
+	got := <-c
+	want := f.Call([]reflect.Value{x, y})[0].Bool()
+	if !got.IsValid() || got.Bool() != want {
+		panic(fmt.Sprintf("non-deterministic or non-symmetric function detected: %s", function.NameOf(f)))
+	}
+	return want
+}
+
+func detectRaces(c chan<- reflect.Value, f reflect.Value, vs ...reflect.Value) {
+	var ret reflect.Value
+	defer func() {
+		recover() // Ignore panics, let the other call to f panic instead
+		c <- ret
+	}()
+	ret = f.Call(vs)[0]
+}
+
+// sanitizeValue converts nil interfaces of type T to those of type R,
+// assuming that T is assignable to R.
+// Otherwise, it returns the input value as is.
+func sanitizeValue(v reflect.Value, t reflect.Type) reflect.Value {
+	// TODO(dsnet): Workaround for reflect bug (https://golang.org/issue/22143).
+	if !flags.AtLeastGo110 {
+		if v.Kind() == reflect.Interface && v.IsNil() && v.Type() != t {
+			return reflect.New(t).Elem()
+		}
+	}
+	return v
+}
+
+func (s *state) compareStruct(t reflect.Type, vx, vy reflect.Value) {
+	var vax, vay reflect.Value // Addressable versions of vx and vy
+
+	step := StructField{&structField{}}
+	for i := 0; i < t.NumField(); i++ {
+		step.typ = t.Field(i).Type
+		step.vx = vx.Field(i)
+		step.vy = vy.Field(i)
+		step.name = t.Field(i).Name
+		step.idx = i
+		step.unexported = !isExported(step.name)
+		if step.unexported {
+			if step.name == "_" {
+				continue
+			}
+			// Defer checking of unexported fields until later to give an
+			// Ignore a chance to ignore the field.
+			if !vax.IsValid() || !vay.IsValid() {
+				// For retrieveUnexportedField to work, the parent struct must
+				// be addressable. Create a new copy of the values if
+				// necessary to make them addressable.
+				vax = makeAddressable(vx)
+				vay = makeAddressable(vy)
+			}
+			step.mayForce = s.exporters[t]
+			step.pvx = vax
+			step.pvy = vay
+			step.field = t.Field(i)
+		}
+		s.compareAny(step)
+	}
+}
+
+func (s *state) compareSlice(t reflect.Type, vx, vy reflect.Value) {
+	isSlice := t.Kind() == reflect.Slice
+	if isSlice && (vx.IsNil() || vy.IsNil()) {
+		s.report(vx.IsNil() && vy.IsNil(), 0)
+		return
+	}
+
+	// TODO: Support cyclic data structures.
+
+	step := SliceIndex{&sliceIndex{pathStep: pathStep{typ: t.Elem()}}}
+	withIndexes := func(ix, iy int) SliceIndex {
+		if ix >= 0 {
+			step.vx, step.xkey = vx.Index(ix), ix
+		} else {
+			step.vx, step.xkey = reflect.Value{}, -1
+		}
+		if iy >= 0 {
+			step.vy, step.ykey = vy.Index(iy), iy
+		} else {
+			step.vy, step.ykey = reflect.Value{}, -1
+		}
+		return step
+	}
+
+	// Ignore options are able to ignore missing elements in a slice.
+	// However, detecting these reliably requires an optimal differencing
+	// algorithm, for which diff.Difference is not.
+	//
+	// Instead, we first iterate through both slices to detect which elements
+	// would be ignored if standing alone. The index of non-discarded elements
+	// are stored in a separate slice, which diffing is then performed on.
+	var indexesX, indexesY []int
+	var ignoredX, ignoredY []bool
+	for ix := 0; ix < vx.Len(); ix++ {
+		ignored := s.statelessCompare(withIndexes(ix, -1)).NumDiff == 0
+		if !ignored {
+			indexesX = append(indexesX, ix)
+		}
+		ignoredX = append(ignoredX, ignored)
+	}
+	for iy := 0; iy < vy.Len(); iy++ {
+		ignored := s.statelessCompare(withIndexes(-1, iy)).NumDiff == 0
+		if !ignored {
+			indexesY = append(indexesY, iy)
+		}
+		ignoredY = append(ignoredY, ignored)
+	}
+
+	// Compute an edit-script for slices vx and vy (excluding ignored elements).
+	edits := diff.Difference(len(indexesX), len(indexesY), func(ix, iy int) diff.Result {
+		return s.statelessCompare(withIndexes(indexesX[ix], indexesY[iy]))
+	})
+
+	// Replay the ignore-scripts and the edit-script.
+	var ix, iy int
+	for ix < vx.Len() || iy < vy.Len() {
+		var e diff.EditType
+		switch {
+		case ix < len(ignoredX) && ignoredX[ix]:
+			e = diff.UniqueX
+		case iy < len(ignoredY) && ignoredY[iy]:
+			e = diff.UniqueY
+		default:
+			e, edits = edits[0], edits[1:]
+		}
+		switch e {
+		case diff.UniqueX:
+			s.compareAny(withIndexes(ix, -1))
+			ix++
+		case diff.UniqueY:
+			s.compareAny(withIndexes(-1, iy))
+			iy++
+		default:
+			s.compareAny(withIndexes(ix, iy))
+			ix++
+			iy++
+		}
+	}
+}
+
+func (s *state) compareMap(t reflect.Type, vx, vy reflect.Value) {
+	if vx.IsNil() || vy.IsNil() {
+		s.report(vx.IsNil() && vy.IsNil(), 0)
+		return
+	}
+
+	// TODO: Support cyclic data structures.
+
+	// We combine and sort the two map keys so that we can perform the
+	// comparisons in a deterministic order.
+	step := MapIndex{&mapIndex{pathStep: pathStep{typ: t.Elem()}}}
+	for _, k := range value.SortKeys(append(vx.MapKeys(), vy.MapKeys()...)) {
+		step.vx = vx.MapIndex(k)
+		step.vy = vy.MapIndex(k)
+		step.key = k
+		if !step.vx.IsValid() && !step.vy.IsValid() {
+			// It is possible for both vx and vy to be invalid if the
+			// key contained a NaN value in it.
+			//
+			// Even with the ability to retrieve NaN keys in Go 1.12,
+			// there still isn't a sensible way to compare the values since
+			// a NaN key may map to multiple unordered values.
+			// The most reasonable way to compare NaNs would be to compare the
+			// set of values. However, this is impossible to do efficiently
+			// since set equality is provably an O(n^2) operation given only
+			// an Equal function. If we had a Less function or Hash function,
+			// this could be done in O(n*log(n)) or O(n), respectively.
+			//
+			// Rather than adding complex logic to deal with NaNs, make it
+			// the user's responsibility to compare such obscure maps.
+			const help = "consider providing a Comparer to compare the map"
+			panic(fmt.Sprintf("%#v has map key with NaNs\n%s", s.curPath, help))
+		}
+		s.compareAny(step)
+	}
+}
+
+func (s *state) comparePtr(t reflect.Type, vx, vy reflect.Value) {
+	if vx.IsNil() || vy.IsNil() {
+		s.report(vx.IsNil() && vy.IsNil(), 0)
+		return
+	}
+
+	// TODO: Support cyclic data structures.
+
+	vx, vy = vx.Elem(), vy.Elem()
+	s.compareAny(Indirect{&indirect{pathStep{t.Elem(), vx, vy}}})
+}
+
+func (s *state) compareInterface(t reflect.Type, vx, vy reflect.Value) {
+	if vx.IsNil() || vy.IsNil() {
+		s.report(vx.IsNil() && vy.IsNil(), 0)
+		return
+	}
+	vx, vy = vx.Elem(), vy.Elem()
+	if vx.Type() != vy.Type() {
+		s.report(false, 0)
+		return
+	}
+	s.compareAny(TypeAssertion{&typeAssertion{pathStep{vx.Type(), vx, vy}}})
+}
+
+func (s *state) report(eq bool, rf resultFlags) {
+	if rf&reportByIgnore == 0 {
+		if eq {
+			s.result.NumSame++
+			rf |= reportEqual
+		} else {
+			s.result.NumDiff++
+			rf |= reportUnequal
+		}
+	}
+	for _, r := range s.reporters {
+		r.Report(Result{flags: rf})
+	}
+}
+
+// recChecker tracks the state needed to periodically perform checks that
+// user provided transformers are not stuck in an infinitely recursive cycle.
+type recChecker struct{ next int }
+
+// Check scans the Path for any recursive transformers and panics when any
+// recursive transformers are detected. Note that the presence of a
+// recursive Transformer does not necessarily imply an infinite cycle.
+// As such, this check only activates after some minimal number of path steps.
+func (rc *recChecker) Check(p Path) {
+	const minLen = 1 << 16
+	if rc.next == 0 {
+		rc.next = minLen
+	}
+	if len(p) < rc.next {
+		return
+	}
+	rc.next <<= 1
+
+	// Check whether the same transformer has appeared at least twice.
+	var ss []string
+	m := map[Option]int{}
+	for _, ps := range p {
+		if t, ok := ps.(Transform); ok {
+			t := t.Option()
+			if m[t] == 1 { // Transformer was used exactly once before
+				tf := t.(*transformer).fnc.Type()
+				ss = append(ss, fmt.Sprintf("%v: %v => %v", t, tf.In(0), tf.Out(0)))
+			}
+			m[t]++
+		}
+	}
+	if len(ss) > 0 {
+		const warning = "recursive set of Transformers detected"
+		const help = "consider using cmpopts.AcyclicTransformer"
+		set := strings.Join(ss, "\n\t")
+		panic(fmt.Sprintf("%s:\n\t%s\n%s", warning, set, help))
+	}
+}
+
+// dynChecker tracks the state needed to periodically perform checks that
+// user provided functions are symmetric and deterministic.
+// The zero value is safe for immediate use.
+type dynChecker struct{ curr, next int }
+
+// Next increments the state and reports whether a check should be performed.
+//
+// Checks occur every Nth function call, where N is a triangular number:
+//	0 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 ...
+// See https://en.wikipedia.org/wiki/Triangular_number
+//
+// This sequence ensures that the cost of checks drops significantly as
+// the number of functions calls grows larger.
+func (dc *dynChecker) Next() bool {
+	ok := dc.curr == dc.next
+	if ok {
+		dc.curr = 0
+		dc.next++
+	}
+	dc.curr++
+	return ok
+}
+
+// makeAddressable returns a value that is always addressable.
+// It returns the input verbatim if it is already addressable,
+// otherwise it creates a new value and returns an addressable copy.
+func makeAddressable(v reflect.Value) reflect.Value {
+	if v.CanAddr() {
+		return v
+	}
+	vc := reflect.New(v.Type()).Elem()
+	vc.Set(v)
+	return vc
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/export_panic.go b/vendor/github.com/google/go-cmp/cmp/export_panic.go
new file mode 100644
index 00000000..abc3a1c3
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/export_panic.go
@@ -0,0 +1,15 @@
+// Copyright 2017, 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.md file.
+
+// +build purego
+
+package cmp
+
+import "reflect"
+
+const supportAllowUnexported = false
+
+func retrieveUnexportedField(reflect.Value, reflect.StructField) reflect.Value {
+	panic("retrieveUnexportedField is not implemented")
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/export_unsafe.go b/vendor/github.com/google/go-cmp/cmp/export_unsafe.go
new file mode 100644
index 00000000..59d4ee91
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/export_unsafe.go
@@ -0,0 +1,23 @@
+// Copyright 2017, 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.md file.
+
+// +build !purego
+
+package cmp
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+const supportAllowUnexported = true
+
+// retrieveUnexportedField uses unsafe to forcibly retrieve any field from
+// a struct such that the value has read-write permissions.
+//
+// The parent struct, v, must be addressable, while f must be a StructField
+// describing the field to retrieve.
+func retrieveUnexportedField(v reflect.Value, f reflect.StructField) reflect.Value {
+	return reflect.NewAt(f.Type, unsafe.Pointer(v.UnsafeAddr()+f.Offset)).Elem()
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_disable.go b/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_disable.go
new file mode 100644
index 00000000..fe98dcc6
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_disable.go
@@ -0,0 +1,17 @@
+// Copyright 2017, 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.md file.
+
+// +build !cmp_debug
+
+package diff
+
+var debug debugger
+
+type debugger struct{}
+
+func (debugger) Begin(_, _ int, f EqualFunc, _, _ *EditScript) EqualFunc {
+	return f
+}
+func (debugger) Update() {}
+func (debugger) Finish() {}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_enable.go b/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_enable.go
new file mode 100644
index 00000000..597b6ae5
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_enable.go
@@ -0,0 +1,122 @@
+// Copyright 2017, 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.md file.
+
+// +build cmp_debug
+
+package diff
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+)
+
+// The algorithm can be seen running in real-time by enabling debugging:
+//	go test -tags=cmp_debug -v
+//
+// Example output:
+//	=== RUN   TestDifference/#34
+//	┌───────────────────────────────┐
+//	│ \ · · · · · · · · · · · · · · │
+//	│ · # · · · · · · · · · · · · · │
+//	│ · \ · · · · · · · · · · · · · │
+//	│ · · \ · · · · · · · · · · · · │
+//	│ · · · X # · · · · · · · · · · │
+//	│ · · · # \ · · · · · · · · · · │
+//	│ · · · · · # # · · · · · · · · │
+//	│ · · · · · # \ · · · · · · · · │
+//	│ · · · · · · · \ · · · · · · · │
+//	│ · · · · · · · · \ · · · · · · │
+//	│ · · · · · · · · · \ · · · · · │
+//	│ · · · · · · · · · · \ · · # · │
+//	│ · · · · · · · · · · · \ # # · │
+//	│ · · · · · · · · · · · # # # · │
+//	│ · · · · · · · · · · # # # # · │
+//	│ · · · · · · · · · # # # # # · │
+//	│ · · · · · · · · · · · · · · \ │
+//	└───────────────────────────────┘
+//	[.Y..M.XY......YXYXY.|]
+//
+// The grid represents the edit-graph where the horizontal axis represents
+// list X and the vertical axis represents list Y. The start of the two lists
+// is the top-left, while the ends are the bottom-right. The '·' represents
+// an unexplored node in the graph. The '\' indicates that the two symbols
+// from list X and Y are equal. The 'X' indicates that two symbols are similar
+// (but not exactly equal) to each other. The '#' indicates that the two symbols
+// are different (and not similar). The algorithm traverses this graph trying to
+// make the paths starting in the top-left and the bottom-right connect.
+//
+// The series of '.', 'X', 'Y', and 'M' characters at the bottom represents
+// the currently established path from the forward and reverse searches,
+// separated by a '|' character.
+
+const (
+	updateDelay  = 100 * time.Millisecond
+	finishDelay  = 500 * time.Millisecond
+	ansiTerminal = true // ANSI escape codes used to move terminal cursor
+)
+
+var debug debugger
+
+type debugger struct {
+	sync.Mutex
+	p1, p2           EditScript
+	fwdPath, revPath *EditScript
+	grid             []byte
+	lines            int
+}
+
+func (dbg *debugger) Begin(nx, ny int, f EqualFunc, p1, p2 *EditScript) EqualFunc {
+	dbg.Lock()
+	dbg.fwdPath, dbg.revPath = p1, p2
+	top := "┌─" + strings.Repeat("──", nx) + "┐\n"
+	row := "│ " + strings.Repeat("· ", nx) + "│\n"
+	btm := "└─" + strings.Repeat("──", nx) + "┘\n"
+	dbg.grid = []byte(top + strings.Repeat(row, ny) + btm)
+	dbg.lines = strings.Count(dbg.String(), "\n")
+	fmt.Print(dbg)
+
+	// Wrap the EqualFunc so that we can intercept each result.
+	return func(ix, iy int) (r Result) {
+		cell := dbg.grid[len(top)+iy*len(row):][len("│ ")+len("· ")*ix:][:len("·")]
+		for i := range cell {
+			cell[i] = 0 // Zero out the multiple bytes of UTF-8 middle-dot
+		}
+		switch r = f(ix, iy); {
+		case r.Equal():
+			cell[0] = '\\'
+		case r.Similar():
+			cell[0] = 'X'
+		default:
+			cell[0] = '#'
+		}
+		return
+	}
+}
+
+func (dbg *debugger) Update() {
+	dbg.print(updateDelay)
+}
+
+func (dbg *debugger) Finish() {
+	dbg.print(finishDelay)
+	dbg.Unlock()
+}
+
+func (dbg *debugger) String() string {
+	dbg.p1, dbg.p2 = *dbg.fwdPath, dbg.p2[:0]
+	for i := len(*dbg.revPath) - 1; i >= 0; i-- {
+		dbg.p2 = append(dbg.p2, (*dbg.revPath)[i])
+	}
+	return fmt.Sprintf("%s[%v|%v]\n\n", dbg.grid, dbg.p1, dbg.p2)
+}
+
+func (dbg *debugger) print(d time.Duration) {
+	if ansiTerminal {
+		fmt.Printf("\x1b[%dA", dbg.lines) // Reset terminal cursor
+	}
+	fmt.Print(dbg)
+	time.Sleep(d)
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/diff/diff.go b/vendor/github.com/google/go-cmp/cmp/internal/diff/diff.go
new file mode 100644
index 00000000..3d2e4266
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/diff/diff.go
@@ -0,0 +1,372 @@
+// Copyright 2017, 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.md file.
+
+// Package diff implements an algorithm for producing edit-scripts.
+// The edit-script is a sequence of operations needed to transform one list
+// of symbols into another (or vice-versa). The edits allowed are insertions,
+// deletions, and modifications. The summation of all edits is called the
+// Levenshtein distance as this problem is well-known in computer science.
+//
+// This package prioritizes performance over accuracy. That is, the run time
+// is more important than obtaining a minimal Levenshtein distance.
+package diff
+
+// EditType represents a single operation within an edit-script.
+type EditType uint8
+
+const (
+	// Identity indicates that a symbol pair is identical in both list X and Y.
+	Identity EditType = iota
+	// UniqueX indicates that a symbol only exists in X and not Y.
+	UniqueX
+	// UniqueY indicates that a symbol only exists in Y and not X.
+	UniqueY
+	// Modified indicates that a symbol pair is a modification of each other.
+	Modified
+)
+
+// EditScript represents the series of differences between two lists.
+type EditScript []EditType
+
+// String returns a human-readable string representing the edit-script where
+// Identity, UniqueX, UniqueY, and Modified are represented by the
+// '.', 'X', 'Y', and 'M' characters, respectively.
+func (es EditScript) String() string {
+	b := make([]byte, len(es))
+	for i, e := range es {
+		switch e {
+		case Identity:
+			b[i] = '.'
+		case UniqueX:
+			b[i] = 'X'
+		case UniqueY:
+			b[i] = 'Y'
+		case Modified:
+			b[i] = 'M'
+		default:
+			panic("invalid edit-type")
+		}
+	}
+	return string(b)
+}
+
+// stats returns a histogram of the number of each type of edit operation.
+func (es EditScript) stats() (s struct{ NI, NX, NY, NM int }) {
+	for _, e := range es {
+		switch e {
+		case Identity:
+			s.NI++
+		case UniqueX:
+			s.NX++
+		case UniqueY:
+			s.NY++
+		case Modified:
+			s.NM++
+		default:
+			panic("invalid edit-type")
+		}
+	}
+	return
+}
+
+// Dist is the Levenshtein distance and is guaranteed to be 0 if and only if
+// lists X and Y are equal.
+func (es EditScript) Dist() int { return len(es) - es.stats().NI }
+
+// LenX is the length of the X list.
+func (es EditScript) LenX() int { return len(es) - es.stats().NY }
+
+// LenY is the length of the Y list.
+func (es EditScript) LenY() int { return len(es) - es.stats().NX }
+
+// EqualFunc reports whether the symbols at indexes ix and iy are equal.
+// When called by Difference, the index is guaranteed to be within nx and ny.
+type EqualFunc func(ix int, iy int) Result
+
+// Result is the result of comparison.
+// NumSame is the number of sub-elements that are equal.
+// NumDiff is the number of sub-elements that are not equal.
+type Result struct{ NumSame, NumDiff int }
+
+// BoolResult returns a Result that is either Equal or not Equal.
+func BoolResult(b bool) Result {
+	if b {
+		return Result{NumSame: 1} // Equal, Similar
+	} else {
+		return Result{NumDiff: 2} // Not Equal, not Similar
+	}
+}
+
+// Equal indicates whether the symbols are equal. Two symbols are equal
+// if and only if NumDiff == 0. If Equal, then they are also Similar.
+func (r Result) Equal() bool { return r.NumDiff == 0 }
+
+// Similar indicates whether two symbols are similar and may be represented
+// by using the Modified type. As a special case, we consider binary comparisons
+// (i.e., those that return Result{1, 0} or Result{0, 1}) to be similar.
+//
+// The exact ratio of NumSame to NumDiff to determine similarity may change.
+func (r Result) Similar() bool {
+	// Use NumSame+1 to offset NumSame so that binary comparisons are similar.
+	return r.NumSame+1 >= r.NumDiff
+}
+
+// Difference reports whether two lists of lengths nx and ny are equal
+// given the definition of equality provided as f.
+//
+// This function returns an edit-script, which is a sequence of operations
+// needed to convert one list into the other. The following invariants for
+// the edit-script are maintained:
+//	• eq == (es.Dist()==0)
+//	• nx == es.LenX()
+//	• ny == es.LenY()
+//
+// This algorithm is not guaranteed to be an optimal solution (i.e., one that
+// produces an edit-script with a minimal Levenshtein distance). This algorithm
+// favors performance over optimality. The exact output is not guaranteed to
+// be stable and may change over time.
+func Difference(nx, ny int, f EqualFunc) (es EditScript) {
+	// This algorithm is based on traversing what is known as an "edit-graph".
+	// See Figure 1 from "An O(ND) Difference Algorithm and Its Variations"
+	// by Eugene W. Myers. Since D can be as large as N itself, this is
+	// effectively O(N^2). Unlike the algorithm from that paper, we are not
+	// interested in the optimal path, but at least some "decent" path.
+	//
+	// For example, let X and Y be lists of symbols:
+	//	X = [A B C A B B A]
+	//	Y = [C B A B A C]
+	//
+	// The edit-graph can be drawn as the following:
+	//	   A B C A B B A
+	//	  ┌─────────────┐
+	//	C │_|_|\|_|_|_|_│ 0
+	//	B │_|\|_|_|\|\|_│ 1
+	//	A │\|_|_|\|_|_|\│ 2
+	//	B │_|\|_|_|\|\|_│ 3
+	//	A │\|_|_|\|_|_|\│ 4
+	//	C │ | |\| | | | │ 5
+	//	  └─────────────┘ 6
+	//	   0 1 2 3 4 5 6 7
+	//
+	// List X is written along the horizontal axis, while list Y is written
+	// along the vertical axis. At any point on this grid, if the symbol in
+	// list X matches the corresponding symbol in list Y, then a '\' is drawn.
+	// The goal of any minimal edit-script algorithm is to find a path from the
+	// top-left corner to the bottom-right corner, while traveling through the
+	// fewest horizontal or vertical edges.
+	// A horizontal edge is equivalent to inserting a symbol from list X.
+	// A vertical edge is equivalent to inserting a symbol from list Y.
+	// A diagonal edge is equivalent to a matching symbol between both X and Y.
+
+	// Invariants:
+	//	• 0 ≤ fwdPath.X ≤ (fwdFrontier.X, revFrontier.X) ≤ revPath.X ≤ nx
+	//	• 0 ≤ fwdPath.Y ≤ (fwdFrontier.Y, revFrontier.Y) ≤ revPath.Y ≤ ny
+	//
+	// In general:
+	//	• fwdFrontier.X < revFrontier.X
+	//	• fwdFrontier.Y < revFrontier.Y
+	// Unless, it is time for the algorithm to terminate.
+	fwdPath := path{+1, point{0, 0}, make(EditScript, 0, (nx+ny)/2)}
+	revPath := path{-1, point{nx, ny}, make(EditScript, 0)}
+	fwdFrontier := fwdPath.point // Forward search frontier
+	revFrontier := revPath.point // Reverse search frontier
+
+	// Search budget bounds the cost of searching for better paths.
+	// The longest sequence of non-matching symbols that can be tolerated is
+	// approximately the square-root of the search budget.
+	searchBudget := 4 * (nx + ny) // O(n)
+
+	// The algorithm below is a greedy, meet-in-the-middle algorithm for
+	// computing sub-optimal edit-scripts between two lists.
+	//
+	// The algorithm is approximately as follows:
+	//	• Searching for differences switches back-and-forth between
+	//	a search that starts at the beginning (the top-left corner), and
+	//	a search that starts at the end (the bottom-right corner). The goal of
+	//	the search is connect with the search from the opposite corner.
+	//	• As we search, we build a path in a greedy manner, where the first
+	//	match seen is added to the path (this is sub-optimal, but provides a
+	//	decent result in practice). When matches are found, we try the next pair
+	//	of symbols in the lists and follow all matches as far as possible.
+	//	• When searching for matches, we search along a diagonal going through
+	//	through the "frontier" point. If no matches are found, we advance the
+	//	frontier towards the opposite corner.
+	//	• This algorithm terminates when either the X coordinates or the
+	//	Y coordinates of the forward and reverse frontier points ever intersect.
+	//
+	// This algorithm is correct even if searching only in the forward direction
+	// or in the reverse direction. We do both because it is commonly observed
+	// that two lists commonly differ because elements were added to the front
+	// or end of the other list.
+	//
+	// Running the tests with the "cmp_debug" build tag prints a visualization
+	// of the algorithm running in real-time. This is educational for
+	// understanding how the algorithm works. See debug_enable.go.
+	f = debug.Begin(nx, ny, f, &fwdPath.es, &revPath.es)
+	for {
+		// Forward search from the beginning.
+		if fwdFrontier.X >= revFrontier.X || fwdFrontier.Y >= revFrontier.Y || searchBudget == 0 {
+			break
+		}
+		for stop1, stop2, i := false, false, 0; !(stop1 && stop2) && searchBudget > 0; i++ {
+			// Search in a diagonal pattern for a match.
+			z := zigzag(i)
+			p := point{fwdFrontier.X + z, fwdFrontier.Y - z}
+			switch {
+			case p.X >= revPath.X || p.Y < fwdPath.Y:
+				stop1 = true // Hit top-right corner
+			case p.Y >= revPath.Y || p.X < fwdPath.X:
+				stop2 = true // Hit bottom-left corner
+			case f(p.X, p.Y).Equal():
+				// Match found, so connect the path to this point.
+				fwdPath.connect(p, f)
+				fwdPath.append(Identity)
+				// Follow sequence of matches as far as possible.
+				for fwdPath.X < revPath.X && fwdPath.Y < revPath.Y {
+					if !f(fwdPath.X, fwdPath.Y).Equal() {
+						break
+					}
+					fwdPath.append(Identity)
+				}
+				fwdFrontier = fwdPath.point
+				stop1, stop2 = true, true
+			default:
+				searchBudget-- // Match not found
+			}
+			debug.Update()
+		}
+		// Advance the frontier towards reverse point.
+		if revPath.X-fwdFrontier.X >= revPath.Y-fwdFrontier.Y {
+			fwdFrontier.X++
+		} else {
+			fwdFrontier.Y++
+		}
+
+		// Reverse search from the end.
+		if fwdFrontier.X >= revFrontier.X || fwdFrontier.Y >= revFrontier.Y || searchBudget == 0 {
+			break
+		}
+		for stop1, stop2, i := false, false, 0; !(stop1 && stop2) && searchBudget > 0; i++ {
+			// Search in a diagonal pattern for a match.
+			z := zigzag(i)
+			p := point{revFrontier.X - z, revFrontier.Y + z}
+			switch {
+			case fwdPath.X >= p.X || revPath.Y < p.Y:
+				stop1 = true // Hit bottom-left corner
+			case fwdPath.Y >= p.Y || revPath.X < p.X:
+				stop2 = true // Hit top-right corner
+			case f(p.X-1, p.Y-1).Equal():
+				// Match found, so connect the path to this point.
+				revPath.connect(p, f)
+				revPath.append(Identity)
+				// Follow sequence of matches as far as possible.
+				for fwdPath.X < revPath.X && fwdPath.Y < revPath.Y {
+					if !f(revPath.X-1, revPath.Y-1).Equal() {
+						break
+					}
+					revPath.append(Identity)
+				}
+				revFrontier = revPath.point
+				stop1, stop2 = true, true
+			default:
+				searchBudget-- // Match not found
+			}
+			debug.Update()
+		}
+		// Advance the frontier towards forward point.
+		if revFrontier.X-fwdPath.X >= revFrontier.Y-fwdPath.Y {
+			revFrontier.X--
+		} else {
+			revFrontier.Y--
+		}
+	}
+
+	// Join the forward and reverse paths and then append the reverse path.
+	fwdPath.connect(revPath.point, f)
+	for i := len(revPath.es) - 1; i >= 0; i-- {
+		t := revPath.es[i]
+		revPath.es = revPath.es[:i]
+		fwdPath.append(t)
+	}
+	debug.Finish()
+	return fwdPath.es
+}
+
+type path struct {
+	dir   int // +1 if forward, -1 if reverse
+	point     // Leading point of the EditScript path
+	es    EditScript
+}
+
+// connect appends any necessary Identity, Modified, UniqueX, or UniqueY types
+// to the edit-script to connect p.point to dst.
+func (p *path) connect(dst point, f EqualFunc) {
+	if p.dir > 0 {
+		// Connect in forward direction.
+		for dst.X > p.X && dst.Y > p.Y {
+			switch r := f(p.X, p.Y); {
+			case r.Equal():
+				p.append(Identity)
+			case r.Similar():
+				p.append(Modified)
+			case dst.X-p.X >= dst.Y-p.Y:
+				p.append(UniqueX)
+			default:
+				p.append(UniqueY)
+			}
+		}
+		for dst.X > p.X {
+			p.append(UniqueX)
+		}
+		for dst.Y > p.Y {
+			p.append(UniqueY)
+		}
+	} else {
+		// Connect in reverse direction.
+		for p.X > dst.X && p.Y > dst.Y {
+			switch r := f(p.X-1, p.Y-1); {
+			case r.Equal():
+				p.append(Identity)
+			case r.Similar():
+				p.append(Modified)
+			case p.Y-dst.Y >= p.X-dst.X:
+				p.append(UniqueY)
+			default:
+				p.append(UniqueX)
+			}
+		}
+		for p.X > dst.X {
+			p.append(UniqueX)
+		}
+		for p.Y > dst.Y {
+			p.append(UniqueY)
+		}
+	}
+}
+
+func (p *path) append(t EditType) {
+	p.es = append(p.es, t)
+	switch t {
+	case Identity, Modified:
+		p.add(p.dir, p.dir)
+	case UniqueX:
+		p.add(p.dir, 0)
+	case UniqueY:
+		p.add(0, p.dir)
+	}
+	debug.Update()
+}
+
+type point struct{ X, Y int }
+
+func (p *point) add(dx, dy int) { p.X += dx; p.Y += dy }
+
+// zigzag maps a consecutive sequence of integers to a zig-zag sequence.
+//	[0 1 2 3 4 5 ...] => [0 -1 +1 -2 +2 ...]
+func zigzag(x int) int {
+	if x&1 != 0 {
+		x = ^x
+	}
+	return x >> 1
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/flags/flags.go b/vendor/github.com/google/go-cmp/cmp/internal/flags/flags.go
new file mode 100644
index 00000000..a9e7fc0b
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/flags/flags.go
@@ -0,0 +1,9 @@
+// Copyright 2019, 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.md file.
+
+package flags
+
+// Deterministic controls whether the output of Diff should be deterministic.
+// This is only used for testing.
+var Deterministic bool
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/flags/toolchain_legacy.go b/vendor/github.com/google/go-cmp/cmp/internal/flags/toolchain_legacy.go
new file mode 100644
index 00000000..01aed0a1
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/flags/toolchain_legacy.go
@@ -0,0 +1,10 @@
+// Copyright 2019, 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.md file.
+
+// +build !go1.10
+
+package flags
+
+// AtLeastGo110 reports whether the Go toolchain is at least Go 1.10.
+const AtLeastGo110 = false
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/flags/toolchain_recent.go b/vendor/github.com/google/go-cmp/cmp/internal/flags/toolchain_recent.go
new file mode 100644
index 00000000..c0b667f5
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/flags/toolchain_recent.go
@@ -0,0 +1,10 @@
+// Copyright 2019, 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.md file.
+
+// +build go1.10
+
+package flags
+
+// AtLeastGo110 reports whether the Go toolchain is at least Go 1.10.
+const AtLeastGo110 = true
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/function/func.go b/vendor/github.com/google/go-cmp/cmp/internal/function/func.go
new file mode 100644
index 00000000..ace1dbe8
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/function/func.go
@@ -0,0 +1,99 @@
+// Copyright 2017, 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.md file.
+
+// Package function provides functionality for identifying function types.
+package function
+
+import (
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+)
+
+type funcType int
+
+const (
+	_ funcType = iota
+
+	tbFunc  // func(T) bool
+	ttbFunc // func(T, T) bool
+	trbFunc // func(T, R) bool
+	tibFunc // func(T, I) bool
+	trFunc  // func(T) R
+
+	Equal             = ttbFunc // func(T, T) bool
+	EqualAssignable   = tibFunc // func(T, I) bool; encapsulates func(T, T) bool
+	Transformer       = trFunc  // func(T) R
+	ValueFilter       = ttbFunc // func(T, T) bool
+	Less              = ttbFunc // func(T, T) bool
+	ValuePredicate    = tbFunc  // func(T) bool
+	KeyValuePredicate = trbFunc // func(T, R) bool
+)
+
+var boolType = reflect.TypeOf(true)
+
+// IsType reports whether the reflect.Type is of the specified function type.
+func IsType(t reflect.Type, ft funcType) bool {
+	if t == nil || t.Kind() != reflect.Func || t.IsVariadic() {
+		return false
+	}
+	ni, no := t.NumIn(), t.NumOut()
+	switch ft {
+	case tbFunc: // func(T) bool
+		if ni == 1 && no == 1 && t.Out(0) == boolType {
+			return true
+		}
+	case ttbFunc: // func(T, T) bool
+		if ni == 2 && no == 1 && t.In(0) == t.In(1) && t.Out(0) == boolType {
+			return true
+		}
+	case trbFunc: // func(T, R) bool
+		if ni == 2 && no == 1 && t.Out(0) == boolType {
+			return true
+		}
+	case tibFunc: // func(T, I) bool
+		if ni == 2 && no == 1 && t.In(0).AssignableTo(t.In(1)) && t.Out(0) == boolType {
+			return true
+		}
+	case trFunc: // func(T) R
+		if ni == 1 && no == 1 {
+			return true
+		}
+	}
+	return false
+}
+
+var lastIdentRx = regexp.MustCompile(`[_\p{L}][_\p{L}\p{N}]*$`)
+
+// NameOf returns the name of the function value.
+func NameOf(v reflect.Value) string {
+	fnc := runtime.FuncForPC(v.Pointer())
+	if fnc == nil {
+		return "<unknown>"
+	}
+	fullName := fnc.Name() // e.g., "long/path/name/mypkg.(*MyType).(long/path/name/mypkg.myMethod)-fm"
+
+	// Method closures have a "-fm" suffix.
+	fullName = strings.TrimSuffix(fullName, "-fm")
+
+	var name string
+	for len(fullName) > 0 {
+		inParen := strings.HasSuffix(fullName, ")")
+		fullName = strings.TrimSuffix(fullName, ")")
+
+		s := lastIdentRx.FindString(fullName)
+		if s == "" {
+			break
+		}
+		name = s + "." + name
+		fullName = strings.TrimSuffix(fullName, s)
+
+		if i := strings.LastIndexByte(fullName, '('); inParen && i >= 0 {
+			fullName = fullName[:i]
+		}
+		fullName = strings.TrimSuffix(fullName, ".")
+	}
+	return strings.TrimSuffix(name, ".")
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/value/pointer_purego.go b/vendor/github.com/google/go-cmp/cmp/internal/value/pointer_purego.go
new file mode 100644
index 00000000..0a01c479
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/value/pointer_purego.go
@@ -0,0 +1,23 @@
+// Copyright 2018, 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.md file.
+
+// +build purego
+
+package value
+
+import "reflect"
+
+// Pointer is an opaque typed pointer and is guaranteed to be comparable.
+type Pointer struct {
+	p uintptr
+	t reflect.Type
+}
+
+// PointerOf returns a Pointer from v, which must be a
+// reflect.Ptr, reflect.Slice, or reflect.Map.
+func PointerOf(v reflect.Value) Pointer {
+	// NOTE: Storing a pointer as an uintptr is technically incorrect as it
+	// assumes that the GC implementation does not use a moving collector.
+	return Pointer{v.Pointer(), v.Type()}
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/value/pointer_unsafe.go b/vendor/github.com/google/go-cmp/cmp/internal/value/pointer_unsafe.go
new file mode 100644
index 00000000..da134ae2
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/value/pointer_unsafe.go
@@ -0,0 +1,26 @@
+// Copyright 2018, 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.md file.
+
+// +build !purego
+
+package value
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// Pointer is an opaque typed pointer and is guaranteed to be comparable.
+type Pointer struct {
+	p unsafe.Pointer
+	t reflect.Type
+}
+
+// PointerOf returns a Pointer from v, which must be a
+// reflect.Ptr, reflect.Slice, or reflect.Map.
+func PointerOf(v reflect.Value) Pointer {
+	// The proper representation of a pointer is unsafe.Pointer,
+	// which is necessary if the GC ever uses a moving collector.
+	return Pointer{unsafe.Pointer(v.Pointer()), v.Type()}
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/value/sort.go b/vendor/github.com/google/go-cmp/cmp/internal/value/sort.go
new file mode 100644
index 00000000..24fbae6e
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/value/sort.go
@@ -0,0 +1,106 @@
+// Copyright 2017, 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.md file.
+
+package value
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+	"sort"
+)
+
+// SortKeys sorts a list of map keys, deduplicating keys if necessary.
+// The type of each value must be comparable.
+func SortKeys(vs []reflect.Value) []reflect.Value {
+	if len(vs) == 0 {
+		return vs
+	}
+
+	// Sort the map keys.
+	sort.SliceStable(vs, func(i, j int) bool { return isLess(vs[i], vs[j]) })
+
+	// Deduplicate keys (fails for NaNs).
+	vs2 := vs[:1]
+	for _, v := range vs[1:] {
+		if isLess(vs2[len(vs2)-1], v) {
+			vs2 = append(vs2, v)
+		}
+	}
+	return vs2
+}
+
+// isLess is a generic function for sorting arbitrary map keys.
+// The inputs must be of the same type and must be comparable.
+func isLess(x, y reflect.Value) bool {
+	switch x.Type().Kind() {
+	case reflect.Bool:
+		return !x.Bool() && y.Bool()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return x.Int() < y.Int()
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return x.Uint() < y.Uint()
+	case reflect.Float32, reflect.Float64:
+		// NOTE: This does not sort -0 as less than +0
+		// since Go maps treat -0 and +0 as equal keys.
+		fx, fy := x.Float(), y.Float()
+		return fx < fy || math.IsNaN(fx) && !math.IsNaN(fy)
+	case reflect.Complex64, reflect.Complex128:
+		cx, cy := x.Complex(), y.Complex()
+		rx, ix, ry, iy := real(cx), imag(cx), real(cy), imag(cy)
+		if rx == ry || (math.IsNaN(rx) && math.IsNaN(ry)) {
+			return ix < iy || math.IsNaN(ix) && !math.IsNaN(iy)
+		}
+		return rx < ry || math.IsNaN(rx) && !math.IsNaN(ry)
+	case reflect.Ptr, reflect.UnsafePointer, reflect.Chan:
+		return x.Pointer() < y.Pointer()
+	case reflect.String:
+		return x.String() < y.String()
+	case reflect.Array:
+		for i := 0; i < x.Len(); i++ {
+			if isLess(x.Index(i), y.Index(i)) {
+				return true
+			}
+			if isLess(y.Index(i), x.Index(i)) {
+				return false
+			}
+		}
+		return false
+	case reflect.Struct:
+		for i := 0; i < x.NumField(); i++ {
+			if isLess(x.Field(i), y.Field(i)) {
+				return true
+			}
+			if isLess(y.Field(i), x.Field(i)) {
+				return false
+			}
+		}
+		return false
+	case reflect.Interface:
+		vx, vy := x.Elem(), y.Elem()
+		if !vx.IsValid() || !vy.IsValid() {
+			return !vx.IsValid() && vy.IsValid()
+		}
+		tx, ty := vx.Type(), vy.Type()
+		if tx == ty {
+			return isLess(x.Elem(), y.Elem())
+		}
+		if tx.Kind() != ty.Kind() {
+			return vx.Kind() < vy.Kind()
+		}
+		if tx.String() != ty.String() {
+			return tx.String() < ty.String()
+		}
+		if tx.PkgPath() != ty.PkgPath() {
+			return tx.PkgPath() < ty.PkgPath()
+		}
+		// This can happen in rare situations, so we fallback to just comparing
+		// the unique pointer for a reflect.Type. This guarantees deterministic
+		// ordering within a program, but it is obviously not stable.
+		return reflect.ValueOf(vx.Type()).Pointer() < reflect.ValueOf(vy.Type()).Pointer()
+	default:
+		// Must be Func, Map, or Slice; which are not comparable.
+		panic(fmt.Sprintf("%T is not comparable", x.Type()))
+	}
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/value/zero.go b/vendor/github.com/google/go-cmp/cmp/internal/value/zero.go
new file mode 100644
index 00000000..06a8ffd0
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/value/zero.go
@@ -0,0 +1,48 @@
+// Copyright 2017, 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.md file.
+
+package value
+
+import (
+	"math"
+	"reflect"
+)
+
+// IsZero reports whether v is the zero value.
+// This does not rely on Interface and so can be used on unexported fields.
+func IsZero(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Bool:
+		return v.Bool() == false
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return math.Float64bits(v.Float()) == 0
+	case reflect.Complex64, reflect.Complex128:
+		return math.Float64bits(real(v.Complex())) == 0 && math.Float64bits(imag(v.Complex())) == 0
+	case reflect.String:
+		return v.String() == ""
+	case reflect.UnsafePointer:
+		return v.Pointer() == 0
+	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
+		return v.IsNil()
+	case reflect.Array:
+		for i := 0; i < v.Len(); i++ {
+			if !IsZero(v.Index(i)) {
+				return false
+			}
+		}
+		return true
+	case reflect.Struct:
+		for i := 0; i < v.NumField(); i++ {
+			if !IsZero(v.Field(i)) {
+				return false
+			}
+		}
+		return true
+	}
+	return false
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/options.go b/vendor/github.com/google/go-cmp/cmp/options.go
new file mode 100644
index 00000000..79344816
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/options.go
@@ -0,0 +1,524 @@
+// Copyright 2017, 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.md file.
+
+package cmp
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strings"
+
+	"github.com/google/go-cmp/cmp/internal/function"
+)
+
+// Option configures for specific behavior of Equal and Diff. In particular,
+// the fundamental Option functions (Ignore, Transformer, and Comparer),
+// configure how equality is determined.
+//
+// The fundamental options may be composed with filters (FilterPath and
+// FilterValues) to control the scope over which they are applied.
+//
+// The cmp/cmpopts package provides helper functions for creating options that
+// may be used with Equal and Diff.
+type Option interface {
+	// filter applies all filters and returns the option that remains.
+	// Each option may only read s.curPath and call s.callTTBFunc.
+	//
+	// An Options is returned only if multiple comparers or transformers
+	// can apply simultaneously and will only contain values of those types
+	// or sub-Options containing values of those types.
+	filter(s *state, t reflect.Type, vx, vy reflect.Value) applicableOption
+}
+
+// applicableOption represents the following types:
+//	Fundamental: ignore | validator | *comparer | *transformer
+//	Grouping:    Options
+type applicableOption interface {
+	Option
+
+	// apply executes the option, which may mutate s or panic.
+	apply(s *state, vx, vy reflect.Value)
+}
+
+// coreOption represents the following types:
+//	Fundamental: ignore | validator | *comparer | *transformer
+//	Filters:     *pathFilter | *valuesFilter
+type coreOption interface {
+	Option
+	isCore()
+}
+
+type core struct{}
+
+func (core) isCore() {}
+
+// Options is a list of Option values that also satisfies the Option interface.
+// Helper comparison packages may return an Options value when packing multiple
+// Option values into a single Option. When this package processes an Options,
+// it will be implicitly expanded into a flat list.
+//
+// Applying a filter on an Options is equivalent to applying that same filter
+// on all individual options held within.
+type Options []Option
+
+func (opts Options) filter(s *state, t reflect.Type, vx, vy reflect.Value) (out applicableOption) {
+	for _, opt := range opts {
+		switch opt := opt.filter(s, t, vx, vy); opt.(type) {
+		case ignore:
+			return ignore{} // Only ignore can short-circuit evaluation
+		case validator:
+			out = validator{} // Takes precedence over comparer or transformer
+		case *comparer, *transformer, Options:
+			switch out.(type) {
+			case nil:
+				out = opt
+			case validator:
+				// Keep validator
+			case *comparer, *transformer, Options:
+				out = Options{out, opt} // Conflicting comparers or transformers
+			}
+		}
+	}
+	return out
+}
+
+func (opts Options) apply(s *state, _, _ reflect.Value) {
+	const warning = "ambiguous set of applicable options"
+	const help = "consider using filters to ensure at most one Comparer or Transformer may apply"
+	var ss []string
+	for _, opt := range flattenOptions(nil, opts) {
+		ss = append(ss, fmt.Sprint(opt))
+	}
+	set := strings.Join(ss, "\n\t")
+	panic(fmt.Sprintf("%s at %#v:\n\t%s\n%s", warning, s.curPath, set, help))
+}
+
+func (opts Options) String() string {
+	var ss []string
+	for _, opt := range opts {
+		ss = append(ss, fmt.Sprint(opt))
+	}
+	return fmt.Sprintf("Options{%s}", strings.Join(ss, ", "))
+}
+
+// FilterPath returns a new Option where opt is only evaluated if filter f
+// returns true for the current Path in the value tree.
+//
+// This filter is called even if a slice element or map entry is missing and
+// provides an opportunity to ignore such cases. The filter function must be
+// symmetric such that the filter result is identical regardless of whether the
+// missing value is from x or y.
+//
+// The option passed in may be an Ignore, Transformer, Comparer, Options, or
+// a previously filtered Option.
+func FilterPath(f func(Path) bool, opt Option) Option {
+	if f == nil {
+		panic("invalid path filter function")
+	}
+	if opt := normalizeOption(opt); opt != nil {
+		return &pathFilter{fnc: f, opt: opt}
+	}
+	return nil
+}
+
+type pathFilter struct {
+	core
+	fnc func(Path) bool
+	opt Option
+}
+
+func (f pathFilter) filter(s *state, t reflect.Type, vx, vy reflect.Value) applicableOption {
+	if f.fnc(s.curPath) {
+		return f.opt.filter(s, t, vx, vy)
+	}
+	return nil
+}
+
+func (f pathFilter) String() string {
+	return fmt.Sprintf("FilterPath(%s, %v)", function.NameOf(reflect.ValueOf(f.fnc)), f.opt)
+}
+
+// FilterValues returns a new Option where opt is only evaluated if filter f,
+// which is a function of the form "func(T, T) bool", returns true for the
+// current pair of values being compared. If either value is invalid or
+// the type of the values is not assignable to T, then this filter implicitly
+// returns false.
+//
+// The filter function must be
+// symmetric (i.e., agnostic to the order of the inputs) and
+// deterministic (i.e., produces the same result when given the same inputs).
+// If T is an interface, it is possible that f is called with two values with
+// different concrete types that both implement T.
+//
+// The option passed in may be an Ignore, Transformer, Comparer, Options, or
+// a previously filtered Option.
+func FilterValues(f interface{}, opt Option) Option {
+	v := reflect.ValueOf(f)
+	if !function.IsType(v.Type(), function.ValueFilter) || v.IsNil() {
+		panic(fmt.Sprintf("invalid values filter function: %T", f))
+	}
+	if opt := normalizeOption(opt); opt != nil {
+		vf := &valuesFilter{fnc: v, opt: opt}
+		if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
+			vf.typ = ti
+		}
+		return vf
+	}
+	return nil
+}
+
+type valuesFilter struct {
+	core
+	typ reflect.Type  // T
+	fnc reflect.Value // func(T, T) bool
+	opt Option
+}
+
+func (f valuesFilter) filter(s *state, t reflect.Type, vx, vy reflect.Value) applicableOption {
+	if !vx.IsValid() || !vx.CanInterface() || !vy.IsValid() || !vy.CanInterface() {
+		return nil
+	}
+	if (f.typ == nil || t.AssignableTo(f.typ)) && s.callTTBFunc(f.fnc, vx, vy) {
+		return f.opt.filter(s, t, vx, vy)
+	}
+	return nil
+}
+
+func (f valuesFilter) String() string {
+	return fmt.Sprintf("FilterValues(%s, %v)", function.NameOf(f.fnc), f.opt)
+}
+
+// Ignore is an Option that causes all comparisons to be ignored.
+// This value is intended to be combined with FilterPath or FilterValues.
+// It is an error to pass an unfiltered Ignore option to Equal.
+func Ignore() Option { return ignore{} }
+
+type ignore struct{ core }
+
+func (ignore) isFiltered() bool                                                     { return false }
+func (ignore) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption { return ignore{} }
+func (ignore) apply(s *state, _, _ reflect.Value)                                   { s.report(true, reportByIgnore) }
+func (ignore) String() string                                                       { return "Ignore()" }
+
+// validator is a sentinel Option type to indicate that some options could not
+// be evaluated due to unexported fields, missing slice elements, or
+// missing map entries. Both values are validator only for unexported fields.
+type validator struct{ core }
+
+func (validator) filter(_ *state, _ reflect.Type, vx, vy reflect.Value) applicableOption {
+	if !vx.IsValid() || !vy.IsValid() {
+		return validator{}
+	}
+	if !vx.CanInterface() || !vy.CanInterface() {
+		return validator{}
+	}
+	return nil
+}
+func (validator) apply(s *state, vx, vy reflect.Value) {
+	// Implies missing slice element or map entry.
+	if !vx.IsValid() || !vy.IsValid() {
+		s.report(vx.IsValid() == vy.IsValid(), 0)
+		return
+	}
+
+	// Unable to Interface implies unexported field without visibility access.
+	if !vx.CanInterface() || !vy.CanInterface() {
+		const help = "consider using a custom Comparer; if you control the implementation of type, you can also consider AllowUnexported or cmpopts.IgnoreUnexported"
+		panic(fmt.Sprintf("cannot handle unexported field: %#v\n%s", s.curPath, help))
+	}
+
+	panic("not reachable")
+}
+
+// identRx represents a valid identifier according to the Go specification.
+const identRx = `[_\p{L}][_\p{L}\p{N}]*`
+
+var identsRx = regexp.MustCompile(`^` + identRx + `(\.` + identRx + `)*$`)
+
+// Transformer returns an Option that applies a transformation function that
+// converts values of a certain type into that of another.
+//
+// The transformer f must be a function "func(T) R" that converts values of
+// type T to those of type R and is implicitly filtered to input values
+// assignable to T. The transformer must not mutate T in any way.
+//
+// To help prevent some cases of infinite recursive cycles applying the
+// same transform to the output of itself (e.g., in the case where the
+// input and output types are the same), an implicit filter is added such that
+// a transformer is applicable only if that exact transformer is not already
+// in the tail of the Path since the last non-Transform step.
+// For situations where the implicit filter is still insufficient,
+// consider using cmpopts.AcyclicTransformer, which adds a filter
+// to prevent the transformer from being recursively applied upon itself.
+//
+// The name is a user provided label that is used as the Transform.Name in the
+// transformation PathStep (and eventually shown in the Diff output).
+// The name must be a valid identifier or qualified identifier in Go syntax.
+// If empty, an arbitrary name is used.
+func Transformer(name string, f interface{}) Option {
+	v := reflect.ValueOf(f)
+	if !function.IsType(v.Type(), function.Transformer) || v.IsNil() {
+		panic(fmt.Sprintf("invalid transformer function: %T", f))
+	}
+	if name == "" {
+		name = function.NameOf(v)
+		if !identsRx.MatchString(name) {
+			name = "λ" // Lambda-symbol as placeholder name
+		}
+	} else if !identsRx.MatchString(name) {
+		panic(fmt.Sprintf("invalid name: %q", name))
+	}
+	tr := &transformer{name: name, fnc: reflect.ValueOf(f)}
+	if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
+		tr.typ = ti
+	}
+	return tr
+}
+
+type transformer struct {
+	core
+	name string
+	typ  reflect.Type  // T
+	fnc  reflect.Value // func(T) R
+}
+
+func (tr *transformer) isFiltered() bool { return tr.typ != nil }
+
+func (tr *transformer) filter(s *state, t reflect.Type, _, _ reflect.Value) applicableOption {
+	for i := len(s.curPath) - 1; i >= 0; i-- {
+		if t, ok := s.curPath[i].(Transform); !ok {
+			break // Hit most recent non-Transform step
+		} else if tr == t.trans {
+			return nil // Cannot directly use same Transform
+		}
+	}
+	if tr.typ == nil || t.AssignableTo(tr.typ) {
+		return tr
+	}
+	return nil
+}
+
+func (tr *transformer) apply(s *state, vx, vy reflect.Value) {
+	step := Transform{&transform{pathStep{typ: tr.fnc.Type().Out(0)}, tr}}
+	vvx := s.callTRFunc(tr.fnc, vx, step)
+	vvy := s.callTRFunc(tr.fnc, vy, step)
+	step.vx, step.vy = vvx, vvy
+	s.compareAny(step)
+}
+
+func (tr transformer) String() string {
+	return fmt.Sprintf("Transformer(%s, %s)", tr.name, function.NameOf(tr.fnc))
+}
+
+// Comparer returns an Option that determines whether two values are equal
+// to each other.
+//
+// The comparer f must be a function "func(T, T) bool" and is implicitly
+// filtered to input values assignable to T. If T is an interface, it is
+// possible that f is called with two values of different concrete types that
+// both implement T.
+//
+// The equality function must be:
+//	• Symmetric: equal(x, y) == equal(y, x)
+//	• Deterministic: equal(x, y) == equal(x, y)
+//	• Pure: equal(x, y) does not modify x or y
+func Comparer(f interface{}) Option {
+	v := reflect.ValueOf(f)
+	if !function.IsType(v.Type(), function.Equal) || v.IsNil() {
+		panic(fmt.Sprintf("invalid comparer function: %T", f))
+	}
+	cm := &comparer{fnc: v}
+	if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
+		cm.typ = ti
+	}
+	return cm
+}
+
+type comparer struct {
+	core
+	typ reflect.Type  // T
+	fnc reflect.Value // func(T, T) bool
+}
+
+func (cm *comparer) isFiltered() bool { return cm.typ != nil }
+
+func (cm *comparer) filter(_ *state, t reflect.Type, _, _ reflect.Value) applicableOption {
+	if cm.typ == nil || t.AssignableTo(cm.typ) {
+		return cm
+	}
+	return nil
+}
+
+func (cm *comparer) apply(s *state, vx, vy reflect.Value) {
+	eq := s.callTTBFunc(cm.fnc, vx, vy)
+	s.report(eq, reportByFunc)
+}
+
+func (cm comparer) String() string {
+	return fmt.Sprintf("Comparer(%s)", function.NameOf(cm.fnc))
+}
+
+// AllowUnexported returns an Option that forcibly allows operations on
+// unexported fields in certain structs, which are specified by passing in a
+// value of each struct type.
+//
+// Users of this option must understand that comparing on unexported fields
+// from external packages is not safe since changes in the internal
+// implementation of some external package may cause the result of Equal
+// to unexpectedly change. However, it may be valid to use this option on types
+// defined in an internal package where the semantic meaning of an unexported
+// field is in the control of the user.
+//
+// In many cases, a custom Comparer should be used instead that defines
+// equality as a function of the public API of a type rather than the underlying
+// unexported implementation.
+//
+// For example, the reflect.Type documentation defines equality to be determined
+// by the == operator on the interface (essentially performing a shallow pointer
+// comparison) and most attempts to compare *regexp.Regexp types are interested
+// in only checking that the regular expression strings are equal.
+// Both of these are accomplished using Comparers:
+//
+//	Comparer(func(x, y reflect.Type) bool { return x == y })
+//	Comparer(func(x, y *regexp.Regexp) bool { return x.String() == y.String() })
+//
+// In other cases, the cmpopts.IgnoreUnexported option can be used to ignore
+// all unexported fields on specified struct types.
+func AllowUnexported(types ...interface{}) Option {
+	if !supportAllowUnexported {
+		panic("AllowUnexported is not supported on purego builds, Google App Engine Standard, or GopherJS")
+	}
+	m := make(map[reflect.Type]bool)
+	for _, typ := range types {
+		t := reflect.TypeOf(typ)
+		if t.Kind() != reflect.Struct {
+			panic(fmt.Sprintf("invalid struct type: %T", typ))
+		}
+		m[t] = true
+	}
+	return visibleStructs(m)
+}
+
+type visibleStructs map[reflect.Type]bool
+
+func (visibleStructs) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption {
+	panic("not implemented")
+}
+
+// Result represents the comparison result for a single node and
+// is provided by cmp when calling Result (see Reporter).
+type Result struct {
+	_     [0]func() // Make Result incomparable
+	flags resultFlags
+}
+
+// Equal reports whether the node was determined to be equal or not.
+// As a special case, ignored nodes are considered equal.
+func (r Result) Equal() bool {
+	return r.flags&(reportEqual|reportByIgnore) != 0
+}
+
+// ByIgnore reports whether the node is equal because it was ignored.
+// This never reports true if Equal reports false.
+func (r Result) ByIgnore() bool {
+	return r.flags&reportByIgnore != 0
+}
+
+// ByMethod reports whether the Equal method determined equality.
+func (r Result) ByMethod() bool {
+	return r.flags&reportByMethod != 0
+}
+
+// ByFunc reports whether a Comparer function determined equality.
+func (r Result) ByFunc() bool {
+	return r.flags&reportByFunc != 0
+}
+
+type resultFlags uint
+
+const (
+	_ resultFlags = (1 << iota) / 2
+
+	reportEqual
+	reportUnequal
+	reportByIgnore
+	reportByMethod
+	reportByFunc
+)
+
+// Reporter is an Option that can be passed to Equal. When Equal traverses
+// the value trees, it calls PushStep as it descends into each node in the
+// tree and PopStep as it ascend out of the node. The leaves of the tree are
+// either compared (determined to be equal or not equal) or ignored and reported
+// as such by calling the Report method.
+func Reporter(r interface {
+	// PushStep is called when a tree-traversal operation is performed.
+	// The PathStep itself is only valid until the step is popped.
+	// The PathStep.Values are valid for the duration of the entire traversal
+	// and must not be mutated.
+	//
+	// Equal always calls PushStep at the start to provide an operation-less
+	// PathStep used to report the root values.
+	//
+	// Within a slice, the exact set of inserted, removed, or modified elements
+	// is unspecified and may change in future implementations.
+	// The entries of a map are iterated through in an unspecified order.
+	PushStep(PathStep)
+
+	// Report is called exactly once on leaf nodes to report whether the
+	// comparison identified the node as equal, unequal, or ignored.
+	// A leaf node is one that is immediately preceded by and followed by
+	// a pair of PushStep and PopStep calls.
+	Report(Result)
+
+	// PopStep ascends back up the value tree.
+	// There is always a matching pop call for every push call.
+	PopStep()
+}) Option {
+	return reporter{r}
+}
+
+type reporter struct{ reporterIface }
+type reporterIface interface {
+	PushStep(PathStep)
+	Report(Result)
+	PopStep()
+}
+
+func (reporter) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption {
+	panic("not implemented")
+}
+
+// normalizeOption normalizes the input options such that all Options groups
+// are flattened and groups with a single element are reduced to that element.
+// Only coreOptions and Options containing coreOptions are allowed.
+func normalizeOption(src Option) Option {
+	switch opts := flattenOptions(nil, Options{src}); len(opts) {
+	case 0:
+		return nil
+	case 1:
+		return opts[0]
+	default:
+		return opts
+	}
+}
+
+// flattenOptions copies all options in src to dst as a flat list.
+// Only coreOptions and Options containing coreOptions are allowed.
+func flattenOptions(dst, src Options) Options {
+	for _, opt := range src {
+		switch opt := opt.(type) {
+		case nil:
+			continue
+		case Options:
+			dst = flattenOptions(dst, opt)
+		case coreOption:
+			dst = append(dst, opt)
+		default:
+			panic(fmt.Sprintf("invalid option type: %T", opt))
+		}
+	}
+	return dst
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/path.go b/vendor/github.com/google/go-cmp/cmp/path.go
new file mode 100644
index 00000000..96fffd29
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/path.go
@@ -0,0 +1,308 @@
+// Copyright 2017, 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.md file.
+
+package cmp
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// Path is a list of PathSteps describing the sequence of operations to get
+// from some root type to the current position in the value tree.
+// The first Path element is always an operation-less PathStep that exists
+// simply to identify the initial type.
+//
+// When traversing structs with embedded structs, the embedded struct will
+// always be accessed as a field before traversing the fields of the
+// embedded struct themselves. That is, an exported field from the
+// embedded struct will never be accessed directly from the parent struct.
+type Path []PathStep
+
+// PathStep is a union-type for specific operations to traverse
+// a value's tree structure. Users of this package never need to implement
+// these types as values of this type will be returned by this package.
+//
+// Implementations of this interface are
+// StructField, SliceIndex, MapIndex, Indirect, TypeAssertion, and Transform.
+type PathStep interface {
+	String() string
+
+	// Type is the resulting type after performing the path step.
+	Type() reflect.Type
+
+	// Values is the resulting values after performing the path step.
+	// The type of each valid value is guaranteed to be identical to Type.
+	//
+	// In some cases, one or both may be invalid or have restrictions:
+	//	• For StructField, both are not interface-able if the current field
+	//	is unexported and the struct type is not explicitly permitted by
+	//	AllowUnexported to traverse unexported fields.
+	//	• For SliceIndex, one may be invalid if an element is missing from
+	//	either the x or y slice.
+	//	• For MapIndex, one may be invalid if an entry is missing from
+	//	either the x or y map.
+	//
+	// The provided values must not be mutated.
+	Values() (vx, vy reflect.Value)
+}
+
+var (
+	_ PathStep = StructField{}
+	_ PathStep = SliceIndex{}
+	_ PathStep = MapIndex{}
+	_ PathStep = Indirect{}
+	_ PathStep = TypeAssertion{}
+	_ PathStep = Transform{}
+)
+
+func (pa *Path) push(s PathStep) {
+	*pa = append(*pa, s)
+}
+
+func (pa *Path) pop() {
+	*pa = (*pa)[:len(*pa)-1]
+}
+
+// Last returns the last PathStep in the Path.
+// If the path is empty, this returns a non-nil PathStep that reports a nil Type.
+func (pa Path) Last() PathStep {
+	return pa.Index(-1)
+}
+
+// Index returns the ith step in the Path and supports negative indexing.
+// A negative index starts counting from the tail of the Path such that -1
+// refers to the last step, -2 refers to the second-to-last step, and so on.
+// If index is invalid, this returns a non-nil PathStep that reports a nil Type.
+func (pa Path) Index(i int) PathStep {
+	if i < 0 {
+		i = len(pa) + i
+	}
+	if i < 0 || i >= len(pa) {
+		return pathStep{}
+	}
+	return pa[i]
+}
+
+// String returns the simplified path to a node.
+// The simplified path only contains struct field accesses.
+//
+// For example:
+//	MyMap.MySlices.MyField
+func (pa Path) String() string {
+	var ss []string
+	for _, s := range pa {
+		if _, ok := s.(StructField); ok {
+			ss = append(ss, s.String())
+		}
+	}
+	return strings.TrimPrefix(strings.Join(ss, ""), ".")
+}
+
+// GoString returns the path to a specific node using Go syntax.
+//
+// For example:
+//	(*root.MyMap["key"].(*mypkg.MyStruct).MySlices)[2][3].MyField
+func (pa Path) GoString() string {
+	var ssPre, ssPost []string
+	var numIndirect int
+	for i, s := range pa {
+		var nextStep PathStep
+		if i+1 < len(pa) {
+			nextStep = pa[i+1]
+		}
+		switch s := s.(type) {
+		case Indirect:
+			numIndirect++
+			pPre, pPost := "(", ")"
+			switch nextStep.(type) {
+			case Indirect:
+				continue // Next step is indirection, so let them batch up
+			case StructField:
+				numIndirect-- // Automatic indirection on struct fields
+			case nil:
+				pPre, pPost = "", "" // Last step; no need for parenthesis
+			}
+			if numIndirect > 0 {
+				ssPre = append(ssPre, pPre+strings.Repeat("*", numIndirect))
+				ssPost = append(ssPost, pPost)
+			}
+			numIndirect = 0
+			continue
+		case Transform:
+			ssPre = append(ssPre, s.trans.name+"(")
+			ssPost = append(ssPost, ")")
+			continue
+		}
+		ssPost = append(ssPost, s.String())
+	}
+	for i, j := 0, len(ssPre)-1; i < j; i, j = i+1, j-1 {
+		ssPre[i], ssPre[j] = ssPre[j], ssPre[i]
+	}
+	return strings.Join(ssPre, "") + strings.Join(ssPost, "")
+}
+
+type pathStep struct {
+	typ    reflect.Type
+	vx, vy reflect.Value
+}
+
+func (ps pathStep) Type() reflect.Type             { return ps.typ }
+func (ps pathStep) Values() (vx, vy reflect.Value) { return ps.vx, ps.vy }
+func (ps pathStep) String() string {
+	if ps.typ == nil {
+		return "<nil>"
+	}
+	s := ps.typ.String()
+	if s == "" || strings.ContainsAny(s, "{}\n") {
+		return "root" // Type too simple or complex to print
+	}
+	return fmt.Sprintf("{%s}", s)
+}
+
+// StructField represents a struct field access on a field called Name.
+type StructField struct{ *structField }
+type structField struct {
+	pathStep
+	name string
+	idx  int
+
+	// These fields are used for forcibly accessing an unexported field.
+	// pvx, pvy, and field are only valid if unexported is true.
+	unexported bool
+	mayForce   bool                // Forcibly allow visibility
+	pvx, pvy   reflect.Value       // Parent values
+	field      reflect.StructField // Field information
+}
+
+func (sf StructField) Type() reflect.Type { return sf.typ }
+func (sf StructField) Values() (vx, vy reflect.Value) {
+	if !sf.unexported {
+		return sf.vx, sf.vy // CanInterface reports true
+	}
+
+	// Forcibly obtain read-write access to an unexported struct field.
+	if sf.mayForce {
+		vx = retrieveUnexportedField(sf.pvx, sf.field)
+		vy = retrieveUnexportedField(sf.pvy, sf.field)
+		return vx, vy // CanInterface reports true
+	}
+	return sf.vx, sf.vy // CanInterface reports false
+}
+func (sf StructField) String() string { return fmt.Sprintf(".%s", sf.name) }
+
+// Name is the field name.
+func (sf StructField) Name() string { return sf.name }
+
+// Index is the index of the field in the parent struct type.
+// See reflect.Type.Field.
+func (sf StructField) Index() int { return sf.idx }
+
+// SliceIndex is an index operation on a slice or array at some index Key.
+type SliceIndex struct{ *sliceIndex }
+type sliceIndex struct {
+	pathStep
+	xkey, ykey int
+}
+
+func (si SliceIndex) Type() reflect.Type             { return si.typ }
+func (si SliceIndex) Values() (vx, vy reflect.Value) { return si.vx, si.vy }
+func (si SliceIndex) String() string {
+	switch {
+	case si.xkey == si.ykey:
+		return fmt.Sprintf("[%d]", si.xkey)
+	case si.ykey == -1:
+		// [5->?] means "I don't know where X[5] went"
+		return fmt.Sprintf("[%d->?]", si.xkey)
+	case si.xkey == -1:
+		// [?->3] means "I don't know where Y[3] came from"
+		return fmt.Sprintf("[?->%d]", si.ykey)
+	default:
+		// [5->3] means "X[5] moved to Y[3]"
+		return fmt.Sprintf("[%d->%d]", si.xkey, si.ykey)
+	}
+}
+
+// Key is the index key; it may return -1 if in a split state
+func (si SliceIndex) Key() int {
+	if si.xkey != si.ykey {
+		return -1
+	}
+	return si.xkey
+}
+
+// SplitKeys are the indexes for indexing into slices in the
+// x and y values, respectively. These indexes may differ due to the
+// insertion or removal of an element in one of the slices, causing
+// all of the indexes to be shifted. If an index is -1, then that
+// indicates that the element does not exist in the associated slice.
+//
+// Key is guaranteed to return -1 if and only if the indexes returned
+// by SplitKeys are not the same. SplitKeys will never return -1 for
+// both indexes.
+func (si SliceIndex) SplitKeys() (ix, iy int) { return si.xkey, si.ykey }
+
+// MapIndex is an index operation on a map at some index Key.
+type MapIndex struct{ *mapIndex }
+type mapIndex struct {
+	pathStep
+	key reflect.Value
+}
+
+func (mi MapIndex) Type() reflect.Type             { return mi.typ }
+func (mi MapIndex) Values() (vx, vy reflect.Value) { return mi.vx, mi.vy }
+func (mi MapIndex) String() string                 { return fmt.Sprintf("[%#v]", mi.key) }
+
+// Key is the value of the map key.
+func (mi MapIndex) Key() reflect.Value { return mi.key }
+
+// Indirect represents pointer indirection on the parent type.
+type Indirect struct{ *indirect }
+type indirect struct {
+	pathStep
+}
+
+func (in Indirect) Type() reflect.Type             { return in.typ }
+func (in Indirect) Values() (vx, vy reflect.Value) { return in.vx, in.vy }
+func (in Indirect) String() string                 { return "*" }
+
+// TypeAssertion represents a type assertion on an interface.
+type TypeAssertion struct{ *typeAssertion }
+type typeAssertion struct {
+	pathStep
+}
+
+func (ta TypeAssertion) Type() reflect.Type             { return ta.typ }
+func (ta TypeAssertion) Values() (vx, vy reflect.Value) { return ta.vx, ta.vy }
+func (ta TypeAssertion) String() string                 { return fmt.Sprintf(".(%v)", ta.typ) }
+
+// Transform is a transformation from the parent type to the current type.
+type Transform struct{ *transform }
+type transform struct {
+	pathStep
+	trans *transformer
+}
+
+func (tf Transform) Type() reflect.Type             { return tf.typ }
+func (tf Transform) Values() (vx, vy reflect.Value) { return tf.vx, tf.vy }
+func (tf Transform) String() string                 { return fmt.Sprintf("%s()", tf.trans.name) }
+
+// Name is the name of the Transformer.
+func (tf Transform) Name() string { return tf.trans.name }
+
+// Func is the function pointer to the transformer function.
+func (tf Transform) Func() reflect.Value { return tf.trans.fnc }
+
+// Option returns the originally constructed Transformer option.
+// The == operator can be used to detect the exact option used.
+func (tf Transform) Option() Option { return tf.trans }
+
+// isExported reports whether the identifier is exported.
+func isExported(id string) bool {
+	r, _ := utf8.DecodeRuneInString(id)
+	return unicode.IsUpper(r)
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/report.go b/vendor/github.com/google/go-cmp/cmp/report.go
new file mode 100644
index 00000000..6ddf2999
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/report.go
@@ -0,0 +1,51 @@
+// Copyright 2017, 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.md file.
+
+package cmp
+
+// defaultReporter implements the reporter interface.
+//
+// As Equal serially calls the PushStep, Report, and PopStep methods, the
+// defaultReporter constructs a tree-based representation of the compared value
+// and the result of each comparison (see valueNode).
+//
+// When the String method is called, the FormatDiff method transforms the
+// valueNode tree into a textNode tree, which is a tree-based representation
+// of the textual output (see textNode).
+//
+// Lastly, the textNode.String method produces the final report as a string.
+type defaultReporter struct {
+	root *valueNode
+	curr *valueNode
+}
+
+func (r *defaultReporter) PushStep(ps PathStep) {
+	r.curr = r.curr.PushStep(ps)
+	if r.root == nil {
+		r.root = r.curr
+	}
+}
+func (r *defaultReporter) Report(rs Result) {
+	r.curr.Report(rs)
+}
+func (r *defaultReporter) PopStep() {
+	r.curr = r.curr.PopStep()
+}
+
+// String provides a full report of the differences detected as a structured
+// literal in pseudo-Go syntax. String may only be called after the entire tree
+// has been traversed.
+func (r *defaultReporter) String() string {
+	assert(r.root != nil && r.curr == nil)
+	if r.root.NumDiff == 0 {
+		return ""
+	}
+	return formatOptions{}.FormatDiff(r.root).String()
+}
+
+func assert(ok bool) {
+	if !ok {
+		panic("assertion failure")
+	}
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/report_compare.go b/vendor/github.com/google/go-cmp/cmp/report_compare.go
new file mode 100644
index 00000000..17a05eed
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/report_compare.go
@@ -0,0 +1,296 @@
+// Copyright 2019, 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.md file.
+
+package cmp
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/google/go-cmp/cmp/internal/value"
+)
+
+// TODO: Enforce limits?
+//	* Enforce maximum number of records to print per node?
+//	* Enforce maximum size in bytes allowed?
+//	* As a heuristic, use less verbosity for equal nodes than unequal nodes.
+// TODO: Enforce unique outputs?
+//	* Avoid Stringer methods if it results in same output?
+//	* Print pointer address if outputs still equal?
+
+// numContextRecords is the number of surrounding equal records to print.
+const numContextRecords = 2
+
+type diffMode byte
+
+const (
+	diffUnknown   diffMode = 0
+	diffIdentical diffMode = ' '
+	diffRemoved   diffMode = '-'
+	diffInserted  diffMode = '+'
+)
+
+type typeMode int
+
+const (
+	// emitType always prints the type.
+	emitType typeMode = iota
+	// elideType never prints the type.
+	elideType
+	// autoType prints the type only for composite kinds
+	// (i.e., structs, slices, arrays, and maps).
+	autoType
+)
+
+type formatOptions struct {
+	// DiffMode controls the output mode of FormatDiff.
+	//
+	// If diffUnknown,   then produce a diff of the x and y values.
+	// If diffIdentical, then emit values as if they were equal.
+	// If diffRemoved,   then only emit x values (ignoring y values).
+	// If diffInserted,  then only emit y values (ignoring x values).
+	DiffMode diffMode
+
+	// TypeMode controls whether to print the type for the current node.
+	//
+	// As a general rule of thumb, we always print the type of the next node
+	// after an interface, and always elide the type of the next node after
+	// a slice or map node.
+	TypeMode typeMode
+
+	// formatValueOptions are options specific to printing reflect.Values.
+	formatValueOptions
+}
+
+func (opts formatOptions) WithDiffMode(d diffMode) formatOptions {
+	opts.DiffMode = d
+	return opts
+}
+func (opts formatOptions) WithTypeMode(t typeMode) formatOptions {
+	opts.TypeMode = t
+	return opts
+}
+
+// FormatDiff converts a valueNode tree into a textNode tree, where the later
+// is a textual representation of the differences detected in the former.
+func (opts formatOptions) FormatDiff(v *valueNode) textNode {
+	// Check whether we have specialized formatting for this node.
+	// This is not necessary, but helpful for producing more readable outputs.
+	if opts.CanFormatDiffSlice(v) {
+		return opts.FormatDiffSlice(v)
+	}
+
+	// For leaf nodes, format the value based on the reflect.Values alone.
+	if v.MaxDepth == 0 {
+		switch opts.DiffMode {
+		case diffUnknown, diffIdentical:
+			// Format Equal.
+			if v.NumDiff == 0 {
+				outx := opts.FormatValue(v.ValueX, visitedPointers{})
+				outy := opts.FormatValue(v.ValueY, visitedPointers{})
+				if v.NumIgnored > 0 && v.NumSame == 0 {
+					return textEllipsis
+				} else if outx.Len() < outy.Len() {
+					return outx
+				} else {
+					return outy
+				}
+			}
+
+			// Format unequal.
+			assert(opts.DiffMode == diffUnknown)
+			var list textList
+			outx := opts.WithTypeMode(elideType).FormatValue(v.ValueX, visitedPointers{})
+			outy := opts.WithTypeMode(elideType).FormatValue(v.ValueY, visitedPointers{})
+			if outx != nil {
+				list = append(list, textRecord{Diff: '-', Value: outx})
+			}
+			if outy != nil {
+				list = append(list, textRecord{Diff: '+', Value: outy})
+			}
+			return opts.WithTypeMode(emitType).FormatType(v.Type, list)
+		case diffRemoved:
+			return opts.FormatValue(v.ValueX, visitedPointers{})
+		case diffInserted:
+			return opts.FormatValue(v.ValueY, visitedPointers{})
+		default:
+			panic("invalid diff mode")
+		}
+	}
+
+	// Descend into the child value node.
+	if v.TransformerName != "" {
+		out := opts.WithTypeMode(emitType).FormatDiff(v.Value)
+		out = textWrap{"Inverse(" + v.TransformerName + ", ", out, ")"}
+		return opts.FormatType(v.Type, out)
+	} else {
+		switch k := v.Type.Kind(); k {
+		case reflect.Struct, reflect.Array, reflect.Slice, reflect.Map:
+			return opts.FormatType(v.Type, opts.formatDiffList(v.Records, k))
+		case reflect.Ptr:
+			return textWrap{"&", opts.FormatDiff(v.Value), ""}
+		case reflect.Interface:
+			return opts.WithTypeMode(emitType).FormatDiff(v.Value)
+		default:
+			panic(fmt.Sprintf("%v cannot have children", k))
+		}
+	}
+}
+
+func (opts formatOptions) formatDiffList(recs []reportRecord, k reflect.Kind) textNode {
+	// Derive record name based on the data structure kind.
+	var name string
+	var formatKey func(reflect.Value) string
+	switch k {
+	case reflect.Struct:
+		name = "field"
+		opts = opts.WithTypeMode(autoType)
+		formatKey = func(v reflect.Value) string { return v.String() }
+	case reflect.Slice, reflect.Array:
+		name = "element"
+		opts = opts.WithTypeMode(elideType)
+		formatKey = func(reflect.Value) string { return "" }
+	case reflect.Map:
+		name = "entry"
+		opts = opts.WithTypeMode(elideType)
+		formatKey = formatMapKey
+	}
+
+	// Handle unification.
+	switch opts.DiffMode {
+	case diffIdentical, diffRemoved, diffInserted:
+		var list textList
+		var deferredEllipsis bool // Add final "..." to indicate records were dropped
+		for _, r := range recs {
+			// Elide struct fields that are zero value.
+			if k == reflect.Struct {
+				var isZero bool
+				switch opts.DiffMode {
+				case diffIdentical:
+					isZero = value.IsZero(r.Value.ValueX) || value.IsZero(r.Value.ValueY)
+				case diffRemoved:
+					isZero = value.IsZero(r.Value.ValueX)
+				case diffInserted:
+					isZero = value.IsZero(r.Value.ValueY)
+				}
+				if isZero {
+					continue
+				}
+			}
+			// Elide ignored nodes.
+			if r.Value.NumIgnored > 0 && r.Value.NumSame+r.Value.NumDiff == 0 {
+				deferredEllipsis = !(k == reflect.Slice || k == reflect.Array)
+				if !deferredEllipsis {
+					list.AppendEllipsis(diffStats{})
+				}
+				continue
+			}
+			if out := opts.FormatDiff(r.Value); out != nil {
+				list = append(list, textRecord{Key: formatKey(r.Key), Value: out})
+			}
+		}
+		if deferredEllipsis {
+			list.AppendEllipsis(diffStats{})
+		}
+		return textWrap{"{", list, "}"}
+	case diffUnknown:
+	default:
+		panic("invalid diff mode")
+	}
+
+	// Handle differencing.
+	var list textList
+	groups := coalesceAdjacentRecords(name, recs)
+	for i, ds := range groups {
+		// Handle equal records.
+		if ds.NumDiff() == 0 {
+			// Compute the number of leading and trailing records to print.
+			var numLo, numHi int
+			numEqual := ds.NumIgnored + ds.NumIdentical
+			for numLo < numContextRecords && numLo+numHi < numEqual && i != 0 {
+				if r := recs[numLo].Value; r.NumIgnored > 0 && r.NumSame+r.NumDiff == 0 {
+					break
+				}
+				numLo++
+			}
+			for numHi < numContextRecords && numLo+numHi < numEqual && i != len(groups)-1 {
+				if r := recs[numEqual-numHi-1].Value; r.NumIgnored > 0 && r.NumSame+r.NumDiff == 0 {
+					break
+				}
+				numHi++
+			}
+			if numEqual-(numLo+numHi) == 1 && ds.NumIgnored == 0 {
+				numHi++ // Avoid pointless coalescing of a single equal record
+			}
+
+			// Format the equal values.
+			for _, r := range recs[:numLo] {
+				out := opts.WithDiffMode(diffIdentical).FormatDiff(r.Value)
+				list = append(list, textRecord{Key: formatKey(r.Key), Value: out})
+			}
+			if numEqual > numLo+numHi {
+				ds.NumIdentical -= numLo + numHi
+				list.AppendEllipsis(ds)
+			}
+			for _, r := range recs[numEqual-numHi : numEqual] {
+				out := opts.WithDiffMode(diffIdentical).FormatDiff(r.Value)
+				list = append(list, textRecord{Key: formatKey(r.Key), Value: out})
+			}
+			recs = recs[numEqual:]
+			continue
+		}
+
+		// Handle unequal records.
+		for _, r := range recs[:ds.NumDiff()] {
+			switch {
+			case opts.CanFormatDiffSlice(r.Value):
+				out := opts.FormatDiffSlice(r.Value)
+				list = append(list, textRecord{Key: formatKey(r.Key), Value: out})
+			case r.Value.NumChildren == r.Value.MaxDepth:
+				outx := opts.WithDiffMode(diffRemoved).FormatDiff(r.Value)
+				outy := opts.WithDiffMode(diffInserted).FormatDiff(r.Value)
+				if outx != nil {
+					list = append(list, textRecord{Diff: diffRemoved, Key: formatKey(r.Key), Value: outx})
+				}
+				if outy != nil {
+					list = append(list, textRecord{Diff: diffInserted, Key: formatKey(r.Key), Value: outy})
+				}
+			default:
+				out := opts.FormatDiff(r.Value)
+				list = append(list, textRecord{Key: formatKey(r.Key), Value: out})
+			}
+		}
+		recs = recs[ds.NumDiff():]
+	}
+	assert(len(recs) == 0)
+	return textWrap{"{", list, "}"}
+}
+
+// coalesceAdjacentRecords coalesces the list of records into groups of
+// adjacent equal, or unequal counts.
+func coalesceAdjacentRecords(name string, recs []reportRecord) (groups []diffStats) {
+	var prevCase int // Arbitrary index into which case last occurred
+	lastStats := func(i int) *diffStats {
+		if prevCase != i {
+			groups = append(groups, diffStats{Name: name})
+			prevCase = i
+		}
+		return &groups[len(groups)-1]
+	}
+	for _, r := range recs {
+		switch rv := r.Value; {
+		case rv.NumIgnored > 0 && rv.NumSame+rv.NumDiff == 0:
+			lastStats(1).NumIgnored++
+		case rv.NumDiff == 0:
+			lastStats(1).NumIdentical++
+		case rv.NumDiff > 0 && !rv.ValueY.IsValid():
+			lastStats(2).NumRemoved++
+		case rv.NumDiff > 0 && !rv.ValueX.IsValid():
+			lastStats(2).NumInserted++
+		default:
+			lastStats(2).NumModified++
+		}
+	}
+	return groups
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/report_reflect.go b/vendor/github.com/google/go-cmp/cmp/report_reflect.go
new file mode 100644
index 00000000..2761b628
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/report_reflect.go
@@ -0,0 +1,278 @@
+// Copyright 2019, 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.md file.
+
+package cmp
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"unicode"
+
+	"github.com/google/go-cmp/cmp/internal/flags"
+	"github.com/google/go-cmp/cmp/internal/value"
+)
+
+type formatValueOptions struct {
+	// AvoidStringer controls whether to avoid calling custom stringer
+	// methods like error.Error or fmt.Stringer.String.
+	AvoidStringer bool
+
+	// ShallowPointers controls whether to avoid descending into pointers.
+	// Useful when printing map keys, where pointer comparison is performed
+	// on the pointer address rather than the pointed-at value.
+	ShallowPointers bool
+
+	// PrintAddresses controls whether to print the address of all pointers,
+	// slice elements, and maps.
+	PrintAddresses bool
+}
+
+// FormatType prints the type as if it were wrapping s.
+// This may return s as-is depending on the current type and TypeMode mode.
+func (opts formatOptions) FormatType(t reflect.Type, s textNode) textNode {
+	// Check whether to emit the type or not.
+	switch opts.TypeMode {
+	case autoType:
+		switch t.Kind() {
+		case reflect.Struct, reflect.Slice, reflect.Array, reflect.Map:
+			if s.Equal(textNil) {
+				return s
+			}
+		default:
+			return s
+		}
+	case elideType:
+		return s
+	}
+
+	// Determine the type label, applying special handling for unnamed types.
+	typeName := t.String()
+	if t.Name() == "" {
+		// According to Go grammar, certain type literals contain symbols that
+		// do not strongly bind to the next lexicographical token (e.g., *T).
+		switch t.Kind() {
+		case reflect.Chan, reflect.Func, reflect.Ptr:
+			typeName = "(" + typeName + ")"
+		}
+		typeName = strings.Replace(typeName, "struct {", "struct{", -1)
+		typeName = strings.Replace(typeName, "interface {", "interface{", -1)
+	}
+
+	// Avoid wrap the value in parenthesis if unnecessary.
+	if s, ok := s.(textWrap); ok {
+		hasParens := strings.HasPrefix(s.Prefix, "(") && strings.HasSuffix(s.Suffix, ")")
+		hasBraces := strings.HasPrefix(s.Prefix, "{") && strings.HasSuffix(s.Suffix, "}")
+		if hasParens || hasBraces {
+			return textWrap{typeName, s, ""}
+		}
+	}
+	return textWrap{typeName + "(", s, ")"}
+}
+
+// FormatValue prints the reflect.Value, taking extra care to avoid descending
+// into pointers already in m. As pointers are visited, m is also updated.
+func (opts formatOptions) FormatValue(v reflect.Value, m visitedPointers) (out textNode) {
+	if !v.IsValid() {
+		return nil
+	}
+	t := v.Type()
+
+	// Check whether there is an Error or String method to call.
+	if !opts.AvoidStringer && v.CanInterface() {
+		// Avoid calling Error or String methods on nil receivers since many
+		// implementations crash when doing so.
+		if (t.Kind() != reflect.Ptr && t.Kind() != reflect.Interface) || !v.IsNil() {
+			switch v := v.Interface().(type) {
+			case error:
+				return textLine("e" + formatString(v.Error()))
+			case fmt.Stringer:
+				return textLine("s" + formatString(v.String()))
+			}
+		}
+	}
+
+	// Check whether to explicitly wrap the result with the type.
+	var skipType bool
+	defer func() {
+		if !skipType {
+			out = opts.FormatType(t, out)
+		}
+	}()
+
+	var ptr string
+	switch t.Kind() {
+	case reflect.Bool:
+		return textLine(fmt.Sprint(v.Bool()))
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return textLine(fmt.Sprint(v.Int()))
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		// Unnamed uints are usually bytes or words, so use hexadecimal.
+		if t.PkgPath() == "" || t.Kind() == reflect.Uintptr {
+			return textLine(formatHex(v.Uint()))
+		}
+		return textLine(fmt.Sprint(v.Uint()))
+	case reflect.Float32, reflect.Float64:
+		return textLine(fmt.Sprint(v.Float()))
+	case reflect.Complex64, reflect.Complex128:
+		return textLine(fmt.Sprint(v.Complex()))
+	case reflect.String:
+		return textLine(formatString(v.String()))
+	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+		return textLine(formatPointer(v))
+	case reflect.Struct:
+		var list textList
+		for i := 0; i < v.NumField(); i++ {
+			vv := v.Field(i)
+			if value.IsZero(vv) {
+				continue // Elide fields with zero values
+			}
+			s := opts.WithTypeMode(autoType).FormatValue(vv, m)
+			list = append(list, textRecord{Key: t.Field(i).Name, Value: s})
+		}
+		return textWrap{"{", list, "}"}
+	case reflect.Slice:
+		if v.IsNil() {
+			return textNil
+		}
+		if opts.PrintAddresses {
+			ptr = formatPointer(v)
+		}
+		fallthrough
+	case reflect.Array:
+		var list textList
+		for i := 0; i < v.Len(); i++ {
+			vi := v.Index(i)
+			if vi.CanAddr() { // Check for cyclic elements
+				p := vi.Addr()
+				if m.Visit(p) {
+					var out textNode
+					out = textLine(formatPointer(p))
+					out = opts.WithTypeMode(emitType).FormatType(p.Type(), out)
+					out = textWrap{"*", out, ""}
+					list = append(list, textRecord{Value: out})
+					continue
+				}
+			}
+			s := opts.WithTypeMode(elideType).FormatValue(vi, m)
+			list = append(list, textRecord{Value: s})
+		}
+		return textWrap{ptr + "{", list, "}"}
+	case reflect.Map:
+		if v.IsNil() {
+			return textNil
+		}
+		if m.Visit(v) {
+			return textLine(formatPointer(v))
+		}
+
+		var list textList
+		for _, k := range value.SortKeys(v.MapKeys()) {
+			sk := formatMapKey(k)
+			sv := opts.WithTypeMode(elideType).FormatValue(v.MapIndex(k), m)
+			list = append(list, textRecord{Key: sk, Value: sv})
+		}
+		if opts.PrintAddresses {
+			ptr = formatPointer(v)
+		}
+		return textWrap{ptr + "{", list, "}"}
+	case reflect.Ptr:
+		if v.IsNil() {
+			return textNil
+		}
+		if m.Visit(v) || opts.ShallowPointers {
+			return textLine(formatPointer(v))
+		}
+		if opts.PrintAddresses {
+			ptr = formatPointer(v)
+		}
+		skipType = true // Let the underlying value print the type instead
+		return textWrap{"&" + ptr, opts.FormatValue(v.Elem(), m), ""}
+	case reflect.Interface:
+		if v.IsNil() {
+			return textNil
+		}
+		// Interfaces accept different concrete types,
+		// so configure the underlying value to explicitly print the type.
+		skipType = true // Print the concrete type instead
+		return opts.WithTypeMode(emitType).FormatValue(v.Elem(), m)
+	default:
+		panic(fmt.Sprintf("%v kind not handled", v.Kind()))
+	}
+}
+
+// formatMapKey formats v as if it were a map key.
+// The result is guaranteed to be a single line.
+func formatMapKey(v reflect.Value) string {
+	var opts formatOptions
+	opts.TypeMode = elideType
+	opts.ShallowPointers = true
+	s := opts.FormatValue(v, visitedPointers{}).String()
+	return strings.TrimSpace(s)
+}
+
+// formatString prints s as a double-quoted or backtick-quoted string.
+func formatString(s string) string {
+	// Use quoted string if it the same length as a raw string literal.
+	// Otherwise, attempt to use the raw string form.
+	qs := strconv.Quote(s)
+	if len(qs) == 1+len(s)+1 {
+		return qs
+	}
+
+	// Disallow newlines to ensure output is a single line.
+	// Only allow printable runes for readability purposes.
+	rawInvalid := func(r rune) bool {
+		return r == '`' || r == '\n' || !(unicode.IsPrint(r) || r == '\t')
+	}
+	if strings.IndexFunc(s, rawInvalid) < 0 {
+		return "`" + s + "`"
+	}
+	return qs
+}
+
+// formatHex prints u as a hexadecimal integer in Go notation.
+func formatHex(u uint64) string {
+	var f string
+	switch {
+	case u <= 0xff:
+		f = "0x%02x"
+	case u <= 0xffff:
+		f = "0x%04x"
+	case u <= 0xffffff:
+		f = "0x%06x"
+	case u <= 0xffffffff:
+		f = "0x%08x"
+	case u <= 0xffffffffff:
+		f = "0x%010x"
+	case u <= 0xffffffffffff:
+		f = "0x%012x"
+	case u <= 0xffffffffffffff:
+		f = "0x%014x"
+	case u <= 0xffffffffffffffff:
+		f = "0x%016x"
+	}
+	return fmt.Sprintf(f, u)
+}
+
+// formatPointer prints the address of the pointer.
+func formatPointer(v reflect.Value) string {
+	p := v.Pointer()
+	if flags.Deterministic {
+		p = 0xdeadf00f // Only used for stable testing purposes
+	}
+	return fmt.Sprintf("⟪0x%x⟫", p)
+}
+
+type visitedPointers map[value.Pointer]struct{}
+
+// Visit inserts pointer v into the visited map and reports whether it had
+// already been visited before.
+func (m visitedPointers) Visit(v reflect.Value) bool {
+	p := value.PointerOf(v)
+	_, visited := m[p]
+	m[p] = struct{}{}
+	return visited
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/report_slices.go b/vendor/github.com/google/go-cmp/cmp/report_slices.go
new file mode 100644
index 00000000..eafcf2e4
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/report_slices.go
@@ -0,0 +1,333 @@
+// Copyright 2019, 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.md file.
+
+package cmp
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/google/go-cmp/cmp/internal/diff"
+)
+
+// CanFormatDiffSlice reports whether we support custom formatting for nodes
+// that are slices of primitive kinds or strings.
+func (opts formatOptions) CanFormatDiffSlice(v *valueNode) bool {
+	switch {
+	case opts.DiffMode != diffUnknown:
+		return false // Must be formatting in diff mode
+	case v.NumDiff == 0:
+		return false // No differences detected
+	case v.NumIgnored+v.NumCompared+v.NumTransformed > 0:
+		// TODO: Handle the case where someone uses bytes.Equal on a large slice.
+		return false // Some custom option was used to determined equality
+	case !v.ValueX.IsValid() || !v.ValueY.IsValid():
+		return false // Both values must be valid
+	}
+
+	switch t := v.Type; t.Kind() {
+	case reflect.String:
+	case reflect.Array, reflect.Slice:
+		// Only slices of primitive types have specialized handling.
+		switch t.Elem().Kind() {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
+			reflect.Bool, reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128:
+		default:
+			return false
+		}
+
+		// If a sufficient number of elements already differ,
+		// use specialized formatting even if length requirement is not met.
+		if v.NumDiff > v.NumSame {
+			return true
+		}
+	default:
+		return false
+	}
+
+	// Use specialized string diffing for longer slices or strings.
+	const minLength = 64
+	return v.ValueX.Len() >= minLength && v.ValueY.Len() >= minLength
+}
+
+// FormatDiffSlice prints a diff for the slices (or strings) represented by v.
+// This provides custom-tailored logic to make printing of differences in
+// textual strings and slices of primitive kinds more readable.
+func (opts formatOptions) FormatDiffSlice(v *valueNode) textNode {
+	assert(opts.DiffMode == diffUnknown)
+	t, vx, vy := v.Type, v.ValueX, v.ValueY
+
+	// Auto-detect the type of the data.
+	var isLinedText, isText, isBinary bool
+	var sx, sy string
+	switch {
+	case t.Kind() == reflect.String:
+		sx, sy = vx.String(), vy.String()
+		isText = true // Initial estimate, verify later
+	case t.Kind() == reflect.Slice && t.Elem() == reflect.TypeOf(byte(0)):
+		sx, sy = string(vx.Bytes()), string(vy.Bytes())
+		isBinary = true // Initial estimate, verify later
+	case t.Kind() == reflect.Array:
+		// Arrays need to be addressable for slice operations to work.
+		vx2, vy2 := reflect.New(t).Elem(), reflect.New(t).Elem()
+		vx2.Set(vx)
+		vy2.Set(vy)
+		vx, vy = vx2, vy2
+	}
+	if isText || isBinary {
+		var numLines, lastLineIdx, maxLineLen int
+		isBinary = false
+		for i, r := range sx + sy {
+			if !(unicode.IsPrint(r) || unicode.IsSpace(r)) || r == utf8.RuneError {
+				isBinary = true
+				break
+			}
+			if r == '\n' {
+				if maxLineLen < i-lastLineIdx {
+					maxLineLen = i - lastLineIdx
+				}
+				lastLineIdx = i + 1
+				numLines++
+			}
+		}
+		isText = !isBinary
+		isLinedText = isText && numLines >= 4 && maxLineLen <= 256
+	}
+
+	// Format the string into printable records.
+	var list textList
+	var delim string
+	switch {
+	// If the text appears to be multi-lined text,
+	// then perform differencing across individual lines.
+	case isLinedText:
+		ssx := strings.Split(sx, "\n")
+		ssy := strings.Split(sy, "\n")
+		list = opts.formatDiffSlice(
+			reflect.ValueOf(ssx), reflect.ValueOf(ssy), 1, "line",
+			func(v reflect.Value, d diffMode) textRecord {
+				s := formatString(v.Index(0).String())
+				return textRecord{Diff: d, Value: textLine(s)}
+			},
+		)
+		delim = "\n"
+	// If the text appears to be single-lined text,
+	// then perform differencing in approximately fixed-sized chunks.
+	// The output is printed as quoted strings.
+	case isText:
+		list = opts.formatDiffSlice(
+			reflect.ValueOf(sx), reflect.ValueOf(sy), 64, "byte",
+			func(v reflect.Value, d diffMode) textRecord {
+				s := formatString(v.String())
+				return textRecord{Diff: d, Value: textLine(s)}
+			},
+		)
+		delim = ""
+	// If the text appears to be binary data,
+	// then perform differencing in approximately fixed-sized chunks.
+	// The output is inspired by hexdump.
+	case isBinary:
+		list = opts.formatDiffSlice(
+			reflect.ValueOf(sx), reflect.ValueOf(sy), 16, "byte",
+			func(v reflect.Value, d diffMode) textRecord {
+				var ss []string
+				for i := 0; i < v.Len(); i++ {
+					ss = append(ss, formatHex(v.Index(i).Uint()))
+				}
+				s := strings.Join(ss, ", ")
+				comment := commentString(fmt.Sprintf("%c|%v|", d, formatASCII(v.String())))
+				return textRecord{Diff: d, Value: textLine(s), Comment: comment}
+			},
+		)
+	// For all other slices of primitive types,
+	// then perform differencing in approximately fixed-sized chunks.
+	// The size of each chunk depends on the width of the element kind.
+	default:
+		var chunkSize int
+		if t.Elem().Kind() == reflect.Bool {
+			chunkSize = 16
+		} else {
+			switch t.Elem().Bits() {
+			case 8:
+				chunkSize = 16
+			case 16:
+				chunkSize = 12
+			case 32:
+				chunkSize = 8
+			default:
+				chunkSize = 8
+			}
+		}
+		list = opts.formatDiffSlice(
+			vx, vy, chunkSize, t.Elem().Kind().String(),
+			func(v reflect.Value, d diffMode) textRecord {
+				var ss []string
+				for i := 0; i < v.Len(); i++ {
+					switch t.Elem().Kind() {
+					case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+						ss = append(ss, fmt.Sprint(v.Index(i).Int()))
+					case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+						ss = append(ss, formatHex(v.Index(i).Uint()))
+					case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128:
+						ss = append(ss, fmt.Sprint(v.Index(i).Interface()))
+					}
+				}
+				s := strings.Join(ss, ", ")
+				return textRecord{Diff: d, Value: textLine(s)}
+			},
+		)
+	}
+
+	// Wrap the output with appropriate type information.
+	var out textNode = textWrap{"{", list, "}"}
+	if !isText {
+		// The "{...}" byte-sequence literal is not valid Go syntax for strings.
+		// Emit the type for extra clarity (e.g. "string{...}").
+		if t.Kind() == reflect.String {
+			opts = opts.WithTypeMode(emitType)
+		}
+		return opts.FormatType(t, out)
+	}
+	switch t.Kind() {
+	case reflect.String:
+		out = textWrap{"strings.Join(", out, fmt.Sprintf(", %q)", delim)}
+		if t != reflect.TypeOf(string("")) {
+			out = opts.FormatType(t, out)
+		}
+	case reflect.Slice:
+		out = textWrap{"bytes.Join(", out, fmt.Sprintf(", %q)", delim)}
+		if t != reflect.TypeOf([]byte(nil)) {
+			out = opts.FormatType(t, out)
+		}
+	}
+	return out
+}
+
+// formatASCII formats s as an ASCII string.
+// This is useful for printing binary strings in a semi-legible way.
+func formatASCII(s string) string {
+	b := bytes.Repeat([]byte{'.'}, len(s))
+	for i := 0; i < len(s); i++ {
+		if ' ' <= s[i] && s[i] <= '~' {
+			b[i] = s[i]
+		}
+	}
+	return string(b)
+}
+
+func (opts formatOptions) formatDiffSlice(
+	vx, vy reflect.Value, chunkSize int, name string,
+	makeRec func(reflect.Value, diffMode) textRecord,
+) (list textList) {
+	es := diff.Difference(vx.Len(), vy.Len(), func(ix int, iy int) diff.Result {
+		return diff.BoolResult(vx.Index(ix).Interface() == vy.Index(iy).Interface())
+	})
+
+	appendChunks := func(v reflect.Value, d diffMode) int {
+		n0 := v.Len()
+		for v.Len() > 0 {
+			n := chunkSize
+			if n > v.Len() {
+				n = v.Len()
+			}
+			list = append(list, makeRec(v.Slice(0, n), d))
+			v = v.Slice(n, v.Len())
+		}
+		return n0 - v.Len()
+	}
+
+	groups := coalesceAdjacentEdits(name, es)
+	groups = coalesceInterveningIdentical(groups, chunkSize/4)
+	for i, ds := range groups {
+		// Print equal.
+		if ds.NumDiff() == 0 {
+			// Compute the number of leading and trailing equal bytes to print.
+			var numLo, numHi int
+			numEqual := ds.NumIgnored + ds.NumIdentical
+			for numLo < chunkSize*numContextRecords && numLo+numHi < numEqual && i != 0 {
+				numLo++
+			}
+			for numHi < chunkSize*numContextRecords && numLo+numHi < numEqual && i != len(groups)-1 {
+				numHi++
+			}
+			if numEqual-(numLo+numHi) <= chunkSize && ds.NumIgnored == 0 {
+				numHi = numEqual - numLo // Avoid pointless coalescing of single equal row
+			}
+
+			// Print the equal bytes.
+			appendChunks(vx.Slice(0, numLo), diffIdentical)
+			if numEqual > numLo+numHi {
+				ds.NumIdentical -= numLo + numHi
+				list.AppendEllipsis(ds)
+			}
+			appendChunks(vx.Slice(numEqual-numHi, numEqual), diffIdentical)
+			vx = vx.Slice(numEqual, vx.Len())
+			vy = vy.Slice(numEqual, vy.Len())
+			continue
+		}
+
+		// Print unequal.
+		nx := appendChunks(vx.Slice(0, ds.NumIdentical+ds.NumRemoved+ds.NumModified), diffRemoved)
+		vx = vx.Slice(nx, vx.Len())
+		ny := appendChunks(vy.Slice(0, ds.NumIdentical+ds.NumInserted+ds.NumModified), diffInserted)
+		vy = vy.Slice(ny, vy.Len())
+	}
+	assert(vx.Len() == 0 && vy.Len() == 0)
+	return list
+}
+
+// coalesceAdjacentEdits coalesces the list of edits into groups of adjacent
+// equal or unequal counts.
+func coalesceAdjacentEdits(name string, es diff.EditScript) (groups []diffStats) {
+	var prevCase int // Arbitrary index into which case last occurred
+	lastStats := func(i int) *diffStats {
+		if prevCase != i {
+			groups = append(groups, diffStats{Name: name})
+			prevCase = i
+		}
+		return &groups[len(groups)-1]
+	}
+	for _, e := range es {
+		switch e {
+		case diff.Identity:
+			lastStats(1).NumIdentical++
+		case diff.UniqueX:
+			lastStats(2).NumRemoved++
+		case diff.UniqueY:
+			lastStats(2).NumInserted++
+		case diff.Modified:
+			lastStats(2).NumModified++
+		}
+	}
+	return groups
+}
+
+// coalesceInterveningIdentical coalesces sufficiently short (<= windowSize)
+// equal groups into adjacent unequal groups that currently result in a
+// dual inserted/removed printout. This acts as a high-pass filter to smooth
+// out high-frequency changes within the windowSize.
+func coalesceInterveningIdentical(groups []diffStats, windowSize int) []diffStats {
+	groups, groupsOrig := groups[:0], groups
+	for i, ds := range groupsOrig {
+		if len(groups) >= 2 && ds.NumDiff() > 0 {
+			prev := &groups[len(groups)-2] // Unequal group
+			curr := &groups[len(groups)-1] // Equal group
+			next := &groupsOrig[i]         // Unequal group
+			hadX, hadY := prev.NumRemoved > 0, prev.NumInserted > 0
+			hasX, hasY := next.NumRemoved > 0, next.NumInserted > 0
+			if ((hadX || hasX) && (hadY || hasY)) && curr.NumIdentical <= windowSize {
+				*prev = prev.Append(*curr).Append(*next)
+				groups = groups[:len(groups)-1] // Truncate off equal group
+				continue
+			}
+		}
+		groups = append(groups, ds)
+	}
+	return groups
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/report_text.go b/vendor/github.com/google/go-cmp/cmp/report_text.go
new file mode 100644
index 00000000..8b8fcab7
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/report_text.go
@@ -0,0 +1,387 @@
+// Copyright 2019, 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.md file.
+
+package cmp
+
+import (
+	"bytes"
+	"fmt"
+	"math/rand"
+	"strings"
+	"time"
+
+	"github.com/google/go-cmp/cmp/internal/flags"
+)
+
+var randBool = rand.New(rand.NewSource(time.Now().Unix())).Intn(2) == 0
+
+type indentMode int
+
+func (n indentMode) appendIndent(b []byte, d diffMode) []byte {
+	// The output of Diff is documented as being unstable to provide future
+	// flexibility in changing the output for more humanly readable reports.
+	// This logic intentionally introduces instability to the exact output
+	// so that users can detect accidental reliance on stability early on,
+	// rather than much later when an actual change to the format occurs.
+	if flags.Deterministic || randBool {
+		// Use regular spaces (U+0020).
+		switch d {
+		case diffUnknown, diffIdentical:
+			b = append(b, "  "...)
+		case diffRemoved:
+			b = append(b, "- "...)
+		case diffInserted:
+			b = append(b, "+ "...)
+		}
+	} else {
+		// Use non-breaking spaces (U+00a0).
+		switch d {
+		case diffUnknown, diffIdentical:
+			b = append(b, "  "...)
+		case diffRemoved:
+			b = append(b, "- "...)
+		case diffInserted:
+			b = append(b, "+ "...)
+		}
+	}
+	return repeatCount(n).appendChar(b, '\t')
+}
+
+type repeatCount int
+
+func (n repeatCount) appendChar(b []byte, c byte) []byte {
+	for ; n > 0; n-- {
+		b = append(b, c)
+	}
+	return b
+}
+
+// textNode is a simplified tree-based representation of structured text.
+// Possible node types are textWrap, textList, or textLine.
+type textNode interface {
+	// Len reports the length in bytes of a single-line version of the tree.
+	// Nested textRecord.Diff and textRecord.Comment fields are ignored.
+	Len() int
+	// Equal reports whether the two trees are structurally identical.
+	// Nested textRecord.Diff and textRecord.Comment fields are compared.
+	Equal(textNode) bool
+	// String returns the string representation of the text tree.
+	// It is not guaranteed that len(x.String()) == x.Len(),
+	// nor that x.String() == y.String() implies that x.Equal(y).
+	String() string
+
+	// formatCompactTo formats the contents of the tree as a single-line string
+	// to the provided buffer. Any nested textRecord.Diff and textRecord.Comment
+	// fields are ignored.
+	//
+	// However, not all nodes in the tree should be collapsed as a single-line.
+	// If a node can be collapsed as a single-line, it is replaced by a textLine
+	// node. Since the top-level node cannot replace itself, this also returns
+	// the current node itself.
+	//
+	// This does not mutate the receiver.
+	formatCompactTo([]byte, diffMode) ([]byte, textNode)
+	// formatExpandedTo formats the contents of the tree as a multi-line string
+	// to the provided buffer. In order for column alignment to operate well,
+	// formatCompactTo must be called before calling formatExpandedTo.
+	formatExpandedTo([]byte, diffMode, indentMode) []byte
+}
+
+// textWrap is a wrapper that concatenates a prefix and/or a suffix
+// to the underlying node.
+type textWrap struct {
+	Prefix string   // e.g., "bytes.Buffer{"
+	Value  textNode // textWrap | textList | textLine
+	Suffix string   // e.g., "}"
+}
+
+func (s textWrap) Len() int {
+	return len(s.Prefix) + s.Value.Len() + len(s.Suffix)
+}
+func (s1 textWrap) Equal(s2 textNode) bool {
+	if s2, ok := s2.(textWrap); ok {
+		return s1.Prefix == s2.Prefix && s1.Value.Equal(s2.Value) && s1.Suffix == s2.Suffix
+	}
+	return false
+}
+func (s textWrap) String() string {
+	var d diffMode
+	var n indentMode
+	_, s2 := s.formatCompactTo(nil, d)
+	b := n.appendIndent(nil, d)      // Leading indent
+	b = s2.formatExpandedTo(b, d, n) // Main body
+	b = append(b, '\n')              // Trailing newline
+	return string(b)
+}
+func (s textWrap) formatCompactTo(b []byte, d diffMode) ([]byte, textNode) {
+	n0 := len(b) // Original buffer length
+	b = append(b, s.Prefix...)
+	b, s.Value = s.Value.formatCompactTo(b, d)
+	b = append(b, s.Suffix...)
+	if _, ok := s.Value.(textLine); ok {
+		return b, textLine(b[n0:])
+	}
+	return b, s
+}
+func (s textWrap) formatExpandedTo(b []byte, d diffMode, n indentMode) []byte {
+	b = append(b, s.Prefix...)
+	b = s.Value.formatExpandedTo(b, d, n)
+	b = append(b, s.Suffix...)
+	return b
+}
+
+// textList is a comma-separated list of textWrap or textLine nodes.
+// The list may be formatted as multi-lines or single-line at the discretion
+// of the textList.formatCompactTo method.
+type textList []textRecord
+type textRecord struct {
+	Diff    diffMode     // e.g., 0 or '-' or '+'
+	Key     string       // e.g., "MyField"
+	Value   textNode     // textWrap | textLine
+	Comment fmt.Stringer // e.g., "6 identical fields"
+}
+
+// AppendEllipsis appends a new ellipsis node to the list if none already
+// exists at the end. If cs is non-zero it coalesces the statistics with the
+// previous diffStats.
+func (s *textList) AppendEllipsis(ds diffStats) {
+	hasStats := ds != diffStats{}
+	if len(*s) == 0 || !(*s)[len(*s)-1].Value.Equal(textEllipsis) {
+		if hasStats {
+			*s = append(*s, textRecord{Value: textEllipsis, Comment: ds})
+		} else {
+			*s = append(*s, textRecord{Value: textEllipsis})
+		}
+		return
+	}
+	if hasStats {
+		(*s)[len(*s)-1].Comment = (*s)[len(*s)-1].Comment.(diffStats).Append(ds)
+	}
+}
+
+func (s textList) Len() (n int) {
+	for i, r := range s {
+		n += len(r.Key)
+		if r.Key != "" {
+			n += len(": ")
+		}
+		n += r.Value.Len()
+		if i < len(s)-1 {
+			n += len(", ")
+		}
+	}
+	return n
+}
+
+func (s1 textList) Equal(s2 textNode) bool {
+	if s2, ok := s2.(textList); ok {
+		if len(s1) != len(s2) {
+			return false
+		}
+		for i := range s1 {
+			r1, r2 := s1[i], s2[i]
+			if !(r1.Diff == r2.Diff && r1.Key == r2.Key && r1.Value.Equal(r2.Value) && r1.Comment == r2.Comment) {
+				return false
+			}
+		}
+		return true
+	}
+	return false
+}
+
+func (s textList) String() string {
+	return textWrap{"{", s, "}"}.String()
+}
+
+func (s textList) formatCompactTo(b []byte, d diffMode) ([]byte, textNode) {
+	s = append(textList(nil), s...) // Avoid mutating original
+
+	// Determine whether we can collapse this list as a single line.
+	n0 := len(b) // Original buffer length
+	var multiLine bool
+	for i, r := range s {
+		if r.Diff == diffInserted || r.Diff == diffRemoved {
+			multiLine = true
+		}
+		b = append(b, r.Key...)
+		if r.Key != "" {
+			b = append(b, ": "...)
+		}
+		b, s[i].Value = r.Value.formatCompactTo(b, d|r.Diff)
+		if _, ok := s[i].Value.(textLine); !ok {
+			multiLine = true
+		}
+		if r.Comment != nil {
+			multiLine = true
+		}
+		if i < len(s)-1 {
+			b = append(b, ", "...)
+		}
+	}
+	// Force multi-lined output when printing a removed/inserted node that
+	// is sufficiently long.
+	if (d == diffInserted || d == diffRemoved) && len(b[n0:]) > 80 {
+		multiLine = true
+	}
+	if !multiLine {
+		return b, textLine(b[n0:])
+	}
+	return b, s
+}
+
+func (s textList) formatExpandedTo(b []byte, d diffMode, n indentMode) []byte {
+	alignKeyLens := s.alignLens(
+		func(r textRecord) bool {
+			_, isLine := r.Value.(textLine)
+			return r.Key == "" || !isLine
+		},
+		func(r textRecord) int { return len(r.Key) },
+	)
+	alignValueLens := s.alignLens(
+		func(r textRecord) bool {
+			_, isLine := r.Value.(textLine)
+			return !isLine || r.Value.Equal(textEllipsis) || r.Comment == nil
+		},
+		func(r textRecord) int { return len(r.Value.(textLine)) },
+	)
+
+	// Format the list as a multi-lined output.
+	n++
+	for i, r := range s {
+		b = n.appendIndent(append(b, '\n'), d|r.Diff)
+		if r.Key != "" {
+			b = append(b, r.Key+": "...)
+		}
+		b = alignKeyLens[i].appendChar(b, ' ')
+
+		b = r.Value.formatExpandedTo(b, d|r.Diff, n)
+		if !r.Value.Equal(textEllipsis) {
+			b = append(b, ',')
+		}
+		b = alignValueLens[i].appendChar(b, ' ')
+
+		if r.Comment != nil {
+			b = append(b, " // "+r.Comment.String()...)
+		}
+	}
+	n--
+
+	return n.appendIndent(append(b, '\n'), d)
+}
+
+func (s textList) alignLens(
+	skipFunc func(textRecord) bool,
+	lenFunc func(textRecord) int,
+) []repeatCount {
+	var startIdx, endIdx, maxLen int
+	lens := make([]repeatCount, len(s))
+	for i, r := range s {
+		if skipFunc(r) {
+			for j := startIdx; j < endIdx && j < len(s); j++ {
+				lens[j] = repeatCount(maxLen - lenFunc(s[j]))
+			}
+			startIdx, endIdx, maxLen = i+1, i+1, 0
+		} else {
+			if maxLen < lenFunc(r) {
+				maxLen = lenFunc(r)
+			}
+			endIdx = i + 1
+		}
+	}
+	for j := startIdx; j < endIdx && j < len(s); j++ {
+		lens[j] = repeatCount(maxLen - lenFunc(s[j]))
+	}
+	return lens
+}
+
+// textLine is a single-line segment of text and is always a leaf node
+// in the textNode tree.
+type textLine []byte
+
+var (
+	textNil      = textLine("nil")
+	textEllipsis = textLine("...")
+)
+
+func (s textLine) Len() int {
+	return len(s)
+}
+func (s1 textLine) Equal(s2 textNode) bool {
+	if s2, ok := s2.(textLine); ok {
+		return bytes.Equal([]byte(s1), []byte(s2))
+	}
+	return false
+}
+func (s textLine) String() string {
+	return string(s)
+}
+func (s textLine) formatCompactTo(b []byte, d diffMode) ([]byte, textNode) {
+	return append(b, s...), s
+}
+func (s textLine) formatExpandedTo(b []byte, _ diffMode, _ indentMode) []byte {
+	return append(b, s...)
+}
+
+type diffStats struct {
+	Name         string
+	NumIgnored   int
+	NumIdentical int
+	NumRemoved   int
+	NumInserted  int
+	NumModified  int
+}
+
+func (s diffStats) NumDiff() int {
+	return s.NumRemoved + s.NumInserted + s.NumModified
+}
+
+func (s diffStats) Append(ds diffStats) diffStats {
+	assert(s.Name == ds.Name)
+	s.NumIgnored += ds.NumIgnored
+	s.NumIdentical += ds.NumIdentical
+	s.NumRemoved += ds.NumRemoved
+	s.NumInserted += ds.NumInserted
+	s.NumModified += ds.NumModified
+	return s
+}
+
+// String prints a humanly-readable summary of coalesced records.
+//
+// Example:
+//	diffStats{Name: "Field", NumIgnored: 5}.String() => "5 ignored fields"
+func (s diffStats) String() string {
+	var ss []string
+	var sum int
+	labels := [...]string{"ignored", "identical", "removed", "inserted", "modified"}
+	counts := [...]int{s.NumIgnored, s.NumIdentical, s.NumRemoved, s.NumInserted, s.NumModified}
+	for i, n := range counts {
+		if n > 0 {
+			ss = append(ss, fmt.Sprintf("%d %v", n, labels[i]))
+		}
+		sum += n
+	}
+
+	// Pluralize the name (adjusting for some obscure English grammar rules).
+	name := s.Name
+	if sum > 1 {
+		name += "s"
+		if strings.HasSuffix(name, "ys") {
+			name = name[:len(name)-2] + "ies" // e.g., "entrys" => "entries"
+		}
+	}
+
+	// Format the list according to English grammar (with Oxford comma).
+	switch n := len(ss); n {
+	case 0:
+		return ""
+	case 1, 2:
+		return strings.Join(ss, " and ") + " " + name
+	default:
+		return strings.Join(ss[:n-1], ", ") + ", and " + ss[n-1] + " " + name
+	}
+}
+
+type commentString string
+
+func (s commentString) String() string { return string(s) }
diff --git a/vendor/github.com/google/go-cmp/cmp/report_value.go b/vendor/github.com/google/go-cmp/cmp/report_value.go
new file mode 100644
index 00000000..83031a7f
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/report_value.go
@@ -0,0 +1,121 @@
+// Copyright 2019, 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.md file.
+
+package cmp
+
+import "reflect"
+
+// valueNode represents a single node within a report, which is a
+// structured representation of the value tree, containing information
+// regarding which nodes are equal or not.
+type valueNode struct {
+	parent *valueNode
+
+	Type   reflect.Type
+	ValueX reflect.Value
+	ValueY reflect.Value
+
+	// NumSame is the number of leaf nodes that are equal.
+	// All descendants are equal only if NumDiff is 0.
+	NumSame int
+	// NumDiff is the number of leaf nodes that are not equal.
+	NumDiff int
+	// NumIgnored is the number of leaf nodes that are ignored.
+	NumIgnored int
+	// NumCompared is the number of leaf nodes that were compared
+	// using an Equal method or Comparer function.
+	NumCompared int
+	// NumTransformed is the number of non-leaf nodes that were transformed.
+	NumTransformed int
+	// NumChildren is the number of transitive descendants of this node.
+	// This counts from zero; thus, leaf nodes have no descendants.
+	NumChildren int
+	// MaxDepth is the maximum depth of the tree. This counts from zero;
+	// thus, leaf nodes have a depth of zero.
+	MaxDepth int
+
+	// Records is a list of struct fields, slice elements, or map entries.
+	Records []reportRecord // If populated, implies Value is not populated
+
+	// Value is the result of a transformation, pointer indirect, of
+	// type assertion.
+	Value *valueNode // If populated, implies Records is not populated
+
+	// TransformerName is the name of the transformer.
+	TransformerName string // If non-empty, implies Value is populated
+}
+type reportRecord struct {
+	Key   reflect.Value // Invalid for slice element
+	Value *valueNode
+}
+
+func (parent *valueNode) PushStep(ps PathStep) (child *valueNode) {
+	vx, vy := ps.Values()
+	child = &valueNode{parent: parent, Type: ps.Type(), ValueX: vx, ValueY: vy}
+	switch s := ps.(type) {
+	case StructField:
+		assert(parent.Value == nil)
+		parent.Records = append(parent.Records, reportRecord{Key: reflect.ValueOf(s.Name()), Value: child})
+	case SliceIndex:
+		assert(parent.Value == nil)
+		parent.Records = append(parent.Records, reportRecord{Value: child})
+	case MapIndex:
+		assert(parent.Value == nil)
+		parent.Records = append(parent.Records, reportRecord{Key: s.Key(), Value: child})
+	case Indirect:
+		assert(parent.Value == nil && parent.Records == nil)
+		parent.Value = child
+	case TypeAssertion:
+		assert(parent.Value == nil && parent.Records == nil)
+		parent.Value = child
+	case Transform:
+		assert(parent.Value == nil && parent.Records == nil)
+		parent.Value = child
+		parent.TransformerName = s.Name()
+		parent.NumTransformed++
+	default:
+		assert(parent == nil) // Must be the root step
+	}
+	return child
+}
+
+func (r *valueNode) Report(rs Result) {
+	assert(r.MaxDepth == 0) // May only be called on leaf nodes
+
+	if rs.ByIgnore() {
+		r.NumIgnored++
+	} else {
+		if rs.Equal() {
+			r.NumSame++
+		} else {
+			r.NumDiff++
+		}
+	}
+	assert(r.NumSame+r.NumDiff+r.NumIgnored == 1)
+
+	if rs.ByMethod() {
+		r.NumCompared++
+	}
+	if rs.ByFunc() {
+		r.NumCompared++
+	}
+	assert(r.NumCompared <= 1)
+}
+
+func (child *valueNode) PopStep() (parent *valueNode) {
+	if child.parent == nil {
+		return nil
+	}
+	parent = child.parent
+	parent.NumSame += child.NumSame
+	parent.NumDiff += child.NumDiff
+	parent.NumIgnored += child.NumIgnored
+	parent.NumCompared += child.NumCompared
+	parent.NumTransformed += child.NumTransformed
+	parent.NumChildren += child.NumChildren + 1
+	if parent.MaxDepth < child.MaxDepth+1 {
+		parent.MaxDepth = child.MaxDepth + 1
+	}
+	return parent
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/ext/customdecode/README.md b/vendor/github.com/hashicorp/hcl/v2/ext/customdecode/README.md
new file mode 100644
index 00000000..1636f577
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/ext/customdecode/README.md
@@ -0,0 +1,209 @@
+# HCL Custom Static Decoding Extension
+
+This HCL extension provides a mechanism for defining arguments in an HCL-based
+language whose values are derived using custom decoding rules against the
+HCL expression syntax, overriding the usual behavior of normal expression
+evaluation.
+
+"Arguments", for the purpose of this extension, currently includes the
+following two contexts:
+
+* For applications using `hcldec` for dynamic decoding, a `hcldec.AttrSpec`
+  or `hcldec.BlockAttrsSpec` can be given a special type constraint that
+  opts in to custom decoding behavior for the attribute(s) that are selected
+  by that specification.
+
+* When working with the HCL native expression syntax, a function given in
+  the `hcl.EvalContext` during evaluation can have parameters with special
+  type constraints that opt in to custom decoding behavior for the argument
+  expression associated with that parameter in any call.
+
+The above use-cases are rather abstract, so we'll consider a motivating
+real-world example: sometimes we (language designers) need to allow users
+to specify type constraints directly in the language itself, such as in
+[Terraform's Input Variables](https://www.terraform.io/docs/configuration/variables.html).
+Terraform's `variable` blocks include an argument called `type` which takes
+a type constraint given using HCL expression building-blocks as defined by
+[the HCL `typeexpr` extension](../typeexpr/README.md).
+
+A "type constraint expression" of that sort is not an expression intended to
+be evaluated in the usual way. Instead, the physical expression is
+deconstructed using [the static analysis operations](../../spec.md#static-analysis)
+to produce a `cty.Type` as the result, rather than a `cty.Value`.
+
+The purpose of this Custom Static Decoding Extension, then, is to provide a
+bridge to allow that sort of custom decoding to be used via mechanisms that
+normally deal in `cty.Value`, such as `hcldec` and native syntax function
+calls as listed above.
+
+(Note: [`gohcl`](https://pkg.go.dev/github.com/hashicorp/hcl/v2/gohcl) has
+its own mechanism to support this use case, exploiting the fact that it is
+working directly with "normal" Go types. Decoding into a struct field of
+type `hcl.Expression` obtains the expression directly without evaluating it
+first. The Custom Static Decoding Extension is not necessary for that `gohcl`
+technique. You can also implement custom decoding by working directly with
+the lowest-level HCL API, which separates extraction of and evaluation of
+expressions into two steps.)
+
+## Custom Decoding Types
+
+This extension relies on a convention implemented in terms of
+[_Capsule Types_ in the underlying `cty` type system](https://github.com/zclconf/go-cty/blob/master/docs/types.md#capsule-types). `cty` allows a capsule type to carry arbitrary
+extension metadata values as an aid to creating higher-level abstractions like
+this extension.
+
+A custom argument decoding mode, then, is implemented by creating a new `cty`
+capsule type that implements the `ExtensionData` custom operation to return
+a decoding function when requested. For example:
+
+```go
+var keywordType cty.Type
+keywordType = cty.CapsuleWithOps("keyword", reflect.TypeOf(""), &cty.CapsuleOps{
+    ExtensionData: func(key interface{}) interface{} {
+        switch key {
+        case customdecode.CustomExpressionDecoder:
+            return customdecode.CustomExpressionDecoderFunc(
+                func(expr hcl.Expression, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+                    var diags hcl.Diagnostics
+                    kw := hcl.ExprAsKeyword(expr)
+                    if kw == "" {
+                        diags = append(diags, &hcl.Diagnostic{
+                            Severity: hcl.DiagError,
+                            Summary:  "Invalid keyword",
+                            Detail:   "A keyword is required",
+                            Subject:  expr.Range().Ptr(),
+                        })
+                        return cty.UnkownVal(keywordType), diags
+                    }
+                    return cty.CapsuleVal(keywordType, &kw)
+                },
+            )
+        default:
+            return nil
+        }
+    },
+})
+```
+
+The boilerplate here is a bit fussy, but the important part for our purposes
+is the `case customdecode.CustomExpressionDecoder:` clause, which uses
+a custom extension key type defined in this package to recognize when a
+component implementing this extension is checking to see if a target type
+has a custom decode implementation.
+
+In the above case we've defined a type that decodes expressions as static
+keywords, so a keyword like `foo` would decode as an encapsulated `"foo"`
+string, while any other sort of expression like `"baz"` or `1 + 1` would
+return an error.
+
+We could then use `keywordType` as a type constraint either for a function
+parameter or a `hcldec` attribute specification, which would require the
+argument for that function parameter or the expression for the matching
+attributes to be a static keyword, rather than an arbitrary expression.
+For example, in a `hcldec.AttrSpec`:
+
+```go
+keywordSpec := &hcldec.AttrSpec{
+    Name: "keyword",
+    Type: keywordType,
+}
+```
+
+The above would accept input like the following and would set its result to
+a `cty.Value` of `keywordType`, after decoding:
+
+```hcl
+keyword = foo
+```
+
+## The Expression and Expression Closure `cty` types
+
+Building on the above, this package also includes two capsule types that use
+the above mechanism to allow calling applications to capture expressions
+directly and thus defer analysis to a later step, after initial decoding.
+
+The `customdecode.ExpressionType` type encapsulates an `hcl.Expression` alone,
+for situations like our type constraint expression example above where it's
+the static structure of the expression we want to inspect, and thus any
+variables and functions defined in the evaluation context are irrelevant.
+
+The `customdecode.ExpressionClosureType` type encapsulates a
+`*customdecode.ExpressionClosure` value, which binds the given expression to
+the `hcl.EvalContext` it was asked to evaluate against and thus allows the
+receiver of that result to later perform normal evaluation of the expression
+with all the same variables and functions that would've been available to it
+naturally.
+
+Both of these types can be used as type constraints either for `hcldec`
+attribute specifications or for function arguments. Here's an example of
+`ExpressionClosureType` to implement a function that can evaluate
+an expression with some additional variables defined locally, which we'll
+call the `with(...)` function:
+
+```go
+var WithFunc = function.New(&function.Spec{
+    Params: []function.Parameter{
+        {
+            Name: "variables",
+            Type: cty.DynamicPseudoType,
+        },
+        {
+            Name: "expression",
+            Type: customdecode.ExpressionClosureType,
+        },
+    },
+    Type: func(args []cty.Value) (cty.Type, error) {
+        varsVal := args[0]
+        exprVal := args[1]
+        if !varsVal.Type().IsObjectType() {
+            return cty.NilVal, function.NewArgErrorf(0, "must be an object defining local variables")
+        }
+        if !varsVal.IsKnown() {
+            // We can't predict our result type until the variables object
+            // is known.
+            return cty.DynamicPseudoType, nil
+        }
+        vars := varsVal.AsValueMap()
+        closure := customdecode.ExpressionClosureFromVal(exprVal)
+        result, err := evalWithLocals(vars, closure)
+        if err != nil {
+            return cty.NilVal, err
+        }
+        return result.Type(), nil
+    },
+    Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+        varsVal := args[0]
+        exprVal := args[1]
+        vars := varsVal.AsValueMap()
+        closure := customdecode.ExpressionClosureFromVal(exprVal)
+        return evalWithLocals(vars, closure)
+    },
+})
+
+func evalWithLocals(locals map[string]cty.Value, closure *customdecode.ExpressionClosure) (cty.Value, error) {
+    childCtx := closure.EvalContext.NewChild()
+    childCtx.Variables = locals
+    val, diags := closure.Expression.Value(childCtx)
+    if diags.HasErrors() {
+        return cty.NilVal, function.NewArgErrorf(1, "couldn't evaluate expression: %s", diags.Error())
+    }
+    return val, nil
+}
+```
+
+If the above function were placed into an `hcl.EvalContext` as `with`, it
+could be used in a native syntax call to that function as follows:
+
+```hcl
+  foo = with({name = "Cory"}, "${greeting}, ${name}!")
+```
+
+The above assumes a variable in the main context called `greeting`, to which
+the `with` function adds `name` before evaluating the expression given in
+its second argument. This makes that second argument context-sensitive -- it
+would behave differently if the user wrote the same thing somewhere else -- so
+this capability should be used with care to make sure it doesn't cause confusion
+for the end-users of your language.
+
+There are some other examples of this capability to evaluate expressions in
+unusual ways in the `tryfunc` directory that is a sibling of this one.
diff --git a/vendor/github.com/hashicorp/hcl/v2/ext/customdecode/customdecode.go b/vendor/github.com/hashicorp/hcl/v2/ext/customdecode/customdecode.go
new file mode 100644
index 00000000..c9d7a1ef
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/ext/customdecode/customdecode.go
@@ -0,0 +1,56 @@
+// Package customdecode contains a HCL extension that allows, in certain
+// contexts, expression evaluation to be overridden by custom static analysis.
+//
+// This mechanism is only supported in certain specific contexts where
+// expressions are decoded with a specific target type in mind. For more
+// information, see the documentation on CustomExpressionDecoder.
+package customdecode
+
+import (
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+)
+
+type customDecoderImpl int
+
+// CustomExpressionDecoder is a value intended to be used as a cty capsule
+// type ExtensionData key for capsule types whose values are to be obtained
+// by static analysis of an expression rather than normal evaluation of that
+// expression.
+//
+// When a cooperating capsule type is asked for ExtensionData with this key,
+// it must return a non-nil CustomExpressionDecoderFunc value.
+//
+// This mechanism is not universally supported; instead, it's handled in a few
+// specific places where expressions are evaluated with the intent of producing
+// a cty.Value of a type given by the calling application.
+//
+// Specifically, this currently works for type constraints given in
+// hcldec.AttrSpec and hcldec.BlockAttrsSpec, and it works for arguments to
+// function calls in the HCL native syntax. HCL extensions implemented outside
+// of the main HCL module may also implement this; consult their own
+// documentation for details.
+const CustomExpressionDecoder = customDecoderImpl(1)
+
+// CustomExpressionDecoderFunc is the type of value that must be returned by
+// a capsule type handling the key CustomExpressionDecoder in its ExtensionData
+// implementation.
+//
+// If no error diagnostics are returned, the result value MUST be of the
+// capsule type that the decoder function was derived from. If the returned
+// error diagnostics prevent producing a value at all, return cty.NilVal.
+type CustomExpressionDecoderFunc func(expr hcl.Expression, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics)
+
+// CustomExpressionDecoderForType takes any cty type and returns its
+// custom expression decoder implementation if it has one. If it is not a
+// capsule type or it does not implement a custom expression decoder, this
+// function returns nil.
+func CustomExpressionDecoderForType(ty cty.Type) CustomExpressionDecoderFunc {
+	if !ty.IsCapsuleType() {
+		return nil
+	}
+	if fn, ok := ty.CapsuleExtensionData(CustomExpressionDecoder).(CustomExpressionDecoderFunc); ok {
+		return fn
+	}
+	return nil
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/ext/customdecode/expression_type.go b/vendor/github.com/hashicorp/hcl/v2/ext/customdecode/expression_type.go
new file mode 100644
index 00000000..af7c66c2
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/ext/customdecode/expression_type.go
@@ -0,0 +1,146 @@
+package customdecode
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// ExpressionType is a cty capsule type that carries hcl.Expression values.
+//
+// This type implements custom decoding in the most general way possible: it
+// just captures whatever expression is given to it, with no further processing
+// whatsoever. It could therefore be useful in situations where an application
+// must defer processing of the expression content until a later step.
+//
+// ExpressionType only captures the expression, not the evaluation context it
+// was destined to be evaluated in. That means this type can be fine for
+// situations where the recipient of the value only intends to do static
+// analysis, but ExpressionClosureType is more appropriate in situations where
+// the recipient will eventually evaluate the given expression.
+var ExpressionType cty.Type
+
+// ExpressionVal returns a new cty value of type ExpressionType, wrapping the
+// given expression.
+func ExpressionVal(expr hcl.Expression) cty.Value {
+	return cty.CapsuleVal(ExpressionType, &expr)
+}
+
+// ExpressionFromVal returns the expression encapsulated in the given value, or
+// panics if the value is not a known value of ExpressionType.
+func ExpressionFromVal(v cty.Value) hcl.Expression {
+	if !v.Type().Equals(ExpressionType) {
+		panic("value is not of ExpressionType")
+	}
+	ptr := v.EncapsulatedValue().(*hcl.Expression)
+	return *ptr
+}
+
+// ExpressionClosureType is a cty capsule type that carries hcl.Expression
+// values along with their original evaluation contexts.
+//
+// This is similar to ExpressionType except that during custom decoding it
+// also captures the hcl.EvalContext that was provided, allowing callers to
+// evaluate the expression later in the same context where it would originally
+// have been evaluated, or a context derived from that one.
+var ExpressionClosureType cty.Type
+
+// ExpressionClosure is the type encapsulated in ExpressionClosureType
+type ExpressionClosure struct {
+	Expression  hcl.Expression
+	EvalContext *hcl.EvalContext
+}
+
+// ExpressionClosureVal returns a new cty value of type ExpressionClosureType,
+// wrapping the given expression closure.
+func ExpressionClosureVal(closure *ExpressionClosure) cty.Value {
+	return cty.CapsuleVal(ExpressionClosureType, closure)
+}
+
+// Value evaluates the closure's expression using the closure's EvalContext,
+// returning the result.
+func (c *ExpressionClosure) Value() (cty.Value, hcl.Diagnostics) {
+	return c.Expression.Value(c.EvalContext)
+}
+
+// ExpressionClosureFromVal returns the expression closure encapsulated in the
+// given value, or panics if the value is not a known value of
+// ExpressionClosureType.
+//
+// The caller MUST NOT modify the returned closure or the EvalContext inside
+// it. To derive a new EvalContext, either create a child context or make
+// a copy.
+func ExpressionClosureFromVal(v cty.Value) *ExpressionClosure {
+	if !v.Type().Equals(ExpressionClosureType) {
+		panic("value is not of ExpressionClosureType")
+	}
+	return v.EncapsulatedValue().(*ExpressionClosure)
+}
+
+func init() {
+	// Getting hold of a reflect.Type for hcl.Expression is a bit tricky because
+	// it's an interface type, but we can do it with some indirection.
+	goExpressionType := reflect.TypeOf((*hcl.Expression)(nil)).Elem()
+
+	ExpressionType = cty.CapsuleWithOps("expression", goExpressionType, &cty.CapsuleOps{
+		ExtensionData: func(key interface{}) interface{} {
+			switch key {
+			case CustomExpressionDecoder:
+				return CustomExpressionDecoderFunc(
+					func(expr hcl.Expression, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+						return ExpressionVal(expr), nil
+					},
+				)
+			default:
+				return nil
+			}
+		},
+		TypeGoString: func(_ reflect.Type) string {
+			return "customdecode.ExpressionType"
+		},
+		GoString: func(raw interface{}) string {
+			exprPtr := raw.(*hcl.Expression)
+			return fmt.Sprintf("customdecode.ExpressionVal(%#v)", *exprPtr)
+		},
+		RawEquals: func(a, b interface{}) bool {
+			aPtr := a.(*hcl.Expression)
+			bPtr := b.(*hcl.Expression)
+			return reflect.DeepEqual(*aPtr, *bPtr)
+		},
+	})
+	ExpressionClosureType = cty.CapsuleWithOps("expression closure", reflect.TypeOf(ExpressionClosure{}), &cty.CapsuleOps{
+		ExtensionData: func(key interface{}) interface{} {
+			switch key {
+			case CustomExpressionDecoder:
+				return CustomExpressionDecoderFunc(
+					func(expr hcl.Expression, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+						return ExpressionClosureVal(&ExpressionClosure{
+							Expression:  expr,
+							EvalContext: ctx,
+						}), nil
+					},
+				)
+			default:
+				return nil
+			}
+		},
+		TypeGoString: func(_ reflect.Type) string {
+			return "customdecode.ExpressionClosureType"
+		},
+		GoString: func(raw interface{}) string {
+			closure := raw.(*ExpressionClosure)
+			return fmt.Sprintf("customdecode.ExpressionClosureVal(%#v)", closure)
+		},
+		RawEquals: func(a, b interface{}) bool {
+			closureA := a.(*ExpressionClosure)
+			closureB := b.(*ExpressionClosure)
+			// The expression itself compares by deep equality, but EvalContexts
+			// conventionally compare by pointer identity, so we'll comply
+			// with both conventions here by testing them separately.
+			return closureA.EvalContext == closureB.EvalContext &&
+				reflect.DeepEqual(closureA.Expression, closureB.Expression)
+		},
+	})
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/gohcl/decode.go b/vendor/github.com/hashicorp/hcl/v2/gohcl/decode.go
new file mode 100644
index 00000000..f0d589d7
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/gohcl/decode.go
@@ -0,0 +1,322 @@
+package gohcl
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+// DecodeBody extracts the configuration within the given body into the given
+// value. This value must be a non-nil pointer to either a struct or
+// a map, where in the former case the configuration will be decoded using
+// struct tags and in the latter case only attributes are allowed and their
+// values are decoded into the map.
+//
+// The given EvalContext is used to resolve any variables or functions in
+// expressions encountered while decoding. This may be nil to require only
+// constant values, for simple applications that do not support variables or
+// functions.
+//
+// The returned diagnostics should be inspected with its HasErrors method to
+// determine if the populated value is valid and complete. If error diagnostics
+// are returned then the given value may have been partially-populated but
+// may still be accessed by a careful caller for static analysis and editor
+// integration use-cases.
+func DecodeBody(body hcl.Body, ctx *hcl.EvalContext, val interface{}) hcl.Diagnostics {
+	rv := reflect.ValueOf(val)
+	if rv.Kind() != reflect.Ptr {
+		panic(fmt.Sprintf("target value must be a pointer, not %s", rv.Type().String()))
+	}
+
+	return decodeBodyToValue(body, ctx, rv.Elem())
+}
+
+func decodeBodyToValue(body hcl.Body, ctx *hcl.EvalContext, val reflect.Value) hcl.Diagnostics {
+	et := val.Type()
+	switch et.Kind() {
+	case reflect.Struct:
+		return decodeBodyToStruct(body, ctx, val)
+	case reflect.Map:
+		return decodeBodyToMap(body, ctx, val)
+	default:
+		panic(fmt.Sprintf("target value must be pointer to struct or map, not %s", et.String()))
+	}
+}
+
+func decodeBodyToStruct(body hcl.Body, ctx *hcl.EvalContext, val reflect.Value) hcl.Diagnostics {
+	schema, partial := ImpliedBodySchema(val.Interface())
+
+	var content *hcl.BodyContent
+	var leftovers hcl.Body
+	var diags hcl.Diagnostics
+	if partial {
+		content, leftovers, diags = body.PartialContent(schema)
+	} else {
+		content, diags = body.Content(schema)
+	}
+	if content == nil {
+		return diags
+	}
+
+	tags := getFieldTags(val.Type())
+
+	if tags.Remain != nil {
+		fieldIdx := *tags.Remain
+		field := val.Type().Field(fieldIdx)
+		fieldV := val.Field(fieldIdx)
+		switch {
+		case bodyType.AssignableTo(field.Type):
+			fieldV.Set(reflect.ValueOf(leftovers))
+		case attrsType.AssignableTo(field.Type):
+			attrs, attrsDiags := leftovers.JustAttributes()
+			if len(attrsDiags) > 0 {
+				diags = append(diags, attrsDiags...)
+			}
+			fieldV.Set(reflect.ValueOf(attrs))
+		default:
+			diags = append(diags, decodeBodyToValue(leftovers, ctx, fieldV)...)
+		}
+	}
+
+	for name, fieldIdx := range tags.Attributes {
+		attr := content.Attributes[name]
+		field := val.Type().Field(fieldIdx)
+		fieldV := val.Field(fieldIdx)
+
+		if attr == nil {
+			if !exprType.AssignableTo(field.Type) {
+				continue
+			}
+
+			// As a special case, if the target is of type hcl.Expression then
+			// we'll assign an actual expression that evalues to a cty null,
+			// so the caller can deal with it within the cty realm rather
+			// than within the Go realm.
+			synthExpr := hcl.StaticExpr(cty.NullVal(cty.DynamicPseudoType), body.MissingItemRange())
+			fieldV.Set(reflect.ValueOf(synthExpr))
+			continue
+		}
+
+		switch {
+		case attrType.AssignableTo(field.Type):
+			fieldV.Set(reflect.ValueOf(attr))
+		case exprType.AssignableTo(field.Type):
+			fieldV.Set(reflect.ValueOf(attr.Expr))
+		default:
+			diags = append(diags, DecodeExpression(
+				attr.Expr, ctx, fieldV.Addr().Interface(),
+			)...)
+		}
+	}
+
+	blocksByType := content.Blocks.ByType()
+
+	for typeName, fieldIdx := range tags.Blocks {
+		blocks := blocksByType[typeName]
+		field := val.Type().Field(fieldIdx)
+
+		ty := field.Type
+		isSlice := false
+		isPtr := false
+		if ty.Kind() == reflect.Slice {
+			isSlice = true
+			ty = ty.Elem()
+		}
+		if ty.Kind() == reflect.Ptr {
+			isPtr = true
+			ty = ty.Elem()
+		}
+
+		if len(blocks) > 1 && !isSlice {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Duplicate %s block", typeName),
+				Detail: fmt.Sprintf(
+					"Only one %s block is allowed. Another was defined at %s.",
+					typeName, blocks[0].DefRange.String(),
+				),
+				Subject: &blocks[1].DefRange,
+			})
+			continue
+		}
+
+		if len(blocks) == 0 {
+			if isSlice || isPtr {
+				if val.Field(fieldIdx).IsNil() {
+					val.Field(fieldIdx).Set(reflect.Zero(field.Type))
+				}
+			} else {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  fmt.Sprintf("Missing %s block", typeName),
+					Detail:   fmt.Sprintf("A %s block is required.", typeName),
+					Subject:  body.MissingItemRange().Ptr(),
+				})
+			}
+			continue
+		}
+
+		switch {
+
+		case isSlice:
+			elemType := ty
+			if isPtr {
+				elemType = reflect.PtrTo(ty)
+			}
+			sli := val.Field(fieldIdx)
+			if sli.IsNil() {
+				sli = reflect.MakeSlice(reflect.SliceOf(elemType), len(blocks), len(blocks))
+			}
+
+			for i, block := range blocks {
+				if isPtr {
+					if i >= sli.Len() {
+						sli = reflect.Append(sli, reflect.New(ty))
+					}
+					v := sli.Index(i)
+					if v.IsNil() {
+						v = reflect.New(ty)
+					}
+					diags = append(diags, decodeBlockToValue(block, ctx, v.Elem())...)
+					sli.Index(i).Set(v)
+				} else {
+					diags = append(diags, decodeBlockToValue(block, ctx, sli.Index(i))...)
+				}
+			}
+
+			if sli.Len() > len(blocks) {
+				sli.SetLen(len(blocks))
+			}
+
+			val.Field(fieldIdx).Set(sli)
+
+		default:
+			block := blocks[0]
+			if isPtr {
+				v := val.Field(fieldIdx)
+				if v.IsNil() {
+					v = reflect.New(ty)
+				}
+				diags = append(diags, decodeBlockToValue(block, ctx, v.Elem())...)
+				val.Field(fieldIdx).Set(v)
+			} else {
+				diags = append(diags, decodeBlockToValue(block, ctx, val.Field(fieldIdx))...)
+			}
+
+		}
+
+	}
+
+	return diags
+}
+
+func decodeBodyToMap(body hcl.Body, ctx *hcl.EvalContext, v reflect.Value) hcl.Diagnostics {
+	attrs, diags := body.JustAttributes()
+	if attrs == nil {
+		return diags
+	}
+
+	mv := reflect.MakeMap(v.Type())
+
+	for k, attr := range attrs {
+		switch {
+		case attrType.AssignableTo(v.Type().Elem()):
+			mv.SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(attr))
+		case exprType.AssignableTo(v.Type().Elem()):
+			mv.SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(attr.Expr))
+		default:
+			ev := reflect.New(v.Type().Elem())
+			diags = append(diags, DecodeExpression(attr.Expr, ctx, ev.Interface())...)
+			mv.SetMapIndex(reflect.ValueOf(k), ev.Elem())
+		}
+	}
+
+	v.Set(mv)
+
+	return diags
+}
+
+func decodeBlockToValue(block *hcl.Block, ctx *hcl.EvalContext, v reflect.Value) hcl.Diagnostics {
+	var diags hcl.Diagnostics
+
+	ty := v.Type()
+
+	switch {
+	case blockType.AssignableTo(ty):
+		v.Elem().Set(reflect.ValueOf(block))
+	case bodyType.AssignableTo(ty):
+		v.Elem().Set(reflect.ValueOf(block.Body))
+	case attrsType.AssignableTo(ty):
+		attrs, attrsDiags := block.Body.JustAttributes()
+		if len(attrsDiags) > 0 {
+			diags = append(diags, attrsDiags...)
+		}
+		v.Elem().Set(reflect.ValueOf(attrs))
+	default:
+		diags = append(diags, decodeBodyToValue(block.Body, ctx, v)...)
+
+		if len(block.Labels) > 0 {
+			blockTags := getFieldTags(ty)
+			for li, lv := range block.Labels {
+				lfieldIdx := blockTags.Labels[li].FieldIndex
+				v.Field(lfieldIdx).Set(reflect.ValueOf(lv))
+			}
+		}
+
+	}
+
+	return diags
+}
+
+// DecodeExpression extracts the value of the given expression into the given
+// value. This value must be something that gocty is able to decode into,
+// since the final decoding is delegated to that package.
+//
+// The given EvalContext is used to resolve any variables or functions in
+// expressions encountered while decoding. This may be nil to require only
+// constant values, for simple applications that do not support variables or
+// functions.
+//
+// The returned diagnostics should be inspected with its HasErrors method to
+// determine if the populated value is valid and complete. If error diagnostics
+// are returned then the given value may have been partially-populated but
+// may still be accessed by a careful caller for static analysis and editor
+// integration use-cases.
+func DecodeExpression(expr hcl.Expression, ctx *hcl.EvalContext, val interface{}) hcl.Diagnostics {
+	srcVal, diags := expr.Value(ctx)
+
+	convTy, err := gocty.ImpliedType(val)
+	if err != nil {
+		panic(fmt.Sprintf("unsuitable DecodeExpression target: %s", err))
+	}
+
+	srcVal, err = convert.Convert(srcVal, convTy)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Unsuitable value type",
+			Detail:   fmt.Sprintf("Unsuitable value: %s", err.Error()),
+			Subject:  expr.StartRange().Ptr(),
+			Context:  expr.Range().Ptr(),
+		})
+		return diags
+	}
+
+	err = gocty.FromCtyValue(srcVal, val)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Unsuitable value type",
+			Detail:   fmt.Sprintf("Unsuitable value: %s", err.Error()),
+			Subject:  expr.StartRange().Ptr(),
+			Context:  expr.Range().Ptr(),
+		})
+	}
+
+	return diags
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/gohcl/doc.go b/vendor/github.com/hashicorp/hcl/v2/gohcl/doc.go
new file mode 100644
index 00000000..c1921cb1
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/gohcl/doc.go
@@ -0,0 +1,57 @@
+// Package gohcl allows decoding HCL configurations into Go data structures.
+//
+// It provides a convenient and concise way of describing the schema for
+// configuration and then accessing the resulting data via native Go
+// types.
+//
+// A struct field tag scheme is used, similar to other decoding and
+// unmarshalling libraries. The tags are formatted as in the following example:
+//
+//    ThingType string `hcl:"thing_type,attr"`
+//
+// Within each tag there are two comma-separated tokens. The first is the
+// name of the corresponding construct in configuration, while the second
+// is a keyword giving the kind of construct expected. The following
+// kind keywords are supported:
+//
+//    attr (the default) indicates that the value is to be populated from an attribute
+//    block indicates that the value is to populated from a block
+//    label indicates that the value is to populated from a block label
+//    optional is the same as attr, but the field is optional
+//    remain indicates that the value is to be populated from the remaining body after populating other fields
+//
+// "attr" fields may either be of type *hcl.Expression, in which case the raw
+// expression is assigned, or of any type accepted by gocty, in which case
+// gocty will be used to assign the value to a native Go type.
+//
+// "block" fields may be of type *hcl.Block or hcl.Body, in which case the
+// corresponding raw value is assigned, or may be a struct that recursively
+// uses the same tags. Block fields may also be slices of any of these types,
+// in which case multiple blocks of the corresponding type are decoded into
+// the slice.
+//
+// "label" fields are considered only in a struct used as the type of a field
+// marked as "block", and are used sequentially to capture the labels of
+// the blocks being decoded. In this case, the name token is used only as
+// an identifier for the label in diagnostic messages.
+//
+// "optional" fields behave like "attr" fields, but they are optional
+// and will not give parsing errors if they are missing.
+//
+// "remain" can be placed on a single field that may be either of type
+// hcl.Body or hcl.Attributes, in which case any remaining body content is
+// placed into this field for delayed processing. If no "remain" field is
+// present then any attributes or blocks not matched by another valid tag
+// will cause an error diagnostic.
+//
+// Only a subset of this tagging/typing vocabulary is supported for the
+// "Encode" family of functions. See the EncodeIntoBody docs for full details
+// on the constraints there.
+//
+// Broadly-speaking this package deals with two types of error. The first is
+// errors in the configuration itself, which are returned as diagnostics
+// written with the configuration author as the target audience. The second
+// is bugs in the calling program, such as invalid struct tags, which are
+// surfaced via panics since there can be no useful runtime handling of such
+// errors and they should certainly not be returned to the user as diagnostics.
+package gohcl
diff --git a/vendor/github.com/hashicorp/hcl/v2/gohcl/encode.go b/vendor/github.com/hashicorp/hcl/v2/gohcl/encode.go
new file mode 100644
index 00000000..d612e09c
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/gohcl/encode.go
@@ -0,0 +1,191 @@
+package gohcl
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+
+	"github.com/hashicorp/hcl/v2/hclwrite"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+// EncodeIntoBody replaces the contents of the given hclwrite Body with
+// attributes and blocks derived from the given value, which must be a
+// struct value or a pointer to a struct value with the struct tags defined
+// in this package.
+//
+// This function can work only with fully-decoded data. It will ignore any
+// fields tagged as "remain", any fields that decode attributes into either
+// hcl.Attribute or hcl.Expression values, and any fields that decode blocks
+// into hcl.Attributes values. This function does not have enough information
+// to complete the decoding of these types.
+//
+// Any fields tagged as "label" are ignored by this function. Use EncodeAsBlock
+// to produce a whole hclwrite.Block including block labels.
+//
+// As long as a suitable value is given to encode and the destination body
+// is non-nil, this function will always complete. It will panic in case of
+// any errors in the calling program, such as passing an inappropriate type
+// or a nil body.
+//
+// The layout of the resulting HCL source is derived from the ordering of
+// the struct fields, with blank lines around nested blocks of different types.
+// Fields representing attributes should usually precede those representing
+// blocks so that the attributes can group togather in the result. For more
+// control, use the hclwrite API directly.
+func EncodeIntoBody(val interface{}, dst *hclwrite.Body) {
+	rv := reflect.ValueOf(val)
+	ty := rv.Type()
+	if ty.Kind() == reflect.Ptr {
+		rv = rv.Elem()
+		ty = rv.Type()
+	}
+	if ty.Kind() != reflect.Struct {
+		panic(fmt.Sprintf("value is %s, not struct", ty.Kind()))
+	}
+
+	tags := getFieldTags(ty)
+	populateBody(rv, ty, tags, dst)
+}
+
+// EncodeAsBlock creates a new hclwrite.Block populated with the data from
+// the given value, which must be a struct or pointer to struct with the
+// struct tags defined in this package.
+//
+// If the given struct type has fields tagged with "label" tags then they
+// will be used in order to annotate the created block with labels.
+//
+// This function has the same constraints as EncodeIntoBody and will panic
+// if they are violated.
+func EncodeAsBlock(val interface{}, blockType string) *hclwrite.Block {
+	rv := reflect.ValueOf(val)
+	ty := rv.Type()
+	if ty.Kind() == reflect.Ptr {
+		rv = rv.Elem()
+		ty = rv.Type()
+	}
+	if ty.Kind() != reflect.Struct {
+		panic(fmt.Sprintf("value is %s, not struct", ty.Kind()))
+	}
+
+	tags := getFieldTags(ty)
+	labels := make([]string, len(tags.Labels))
+	for i, lf := range tags.Labels {
+		lv := rv.Field(lf.FieldIndex)
+		// We just stringify whatever we find. It should always be a string
+		// but if not then we'll still do something reasonable.
+		labels[i] = fmt.Sprintf("%s", lv.Interface())
+	}
+
+	block := hclwrite.NewBlock(blockType, labels)
+	populateBody(rv, ty, tags, block.Body())
+	return block
+}
+
+func populateBody(rv reflect.Value, ty reflect.Type, tags *fieldTags, dst *hclwrite.Body) {
+	nameIdxs := make(map[string]int, len(tags.Attributes)+len(tags.Blocks))
+	namesOrder := make([]string, 0, len(tags.Attributes)+len(tags.Blocks))
+	for n, i := range tags.Attributes {
+		nameIdxs[n] = i
+		namesOrder = append(namesOrder, n)
+	}
+	for n, i := range tags.Blocks {
+		nameIdxs[n] = i
+		namesOrder = append(namesOrder, n)
+	}
+	sort.SliceStable(namesOrder, func(i, j int) bool {
+		ni, nj := namesOrder[i], namesOrder[j]
+		return nameIdxs[ni] < nameIdxs[nj]
+	})
+
+	dst.Clear()
+
+	prevWasBlock := false
+	for _, name := range namesOrder {
+		fieldIdx := nameIdxs[name]
+		field := ty.Field(fieldIdx)
+		fieldTy := field.Type
+		fieldVal := rv.Field(fieldIdx)
+
+		if fieldTy.Kind() == reflect.Ptr {
+			fieldTy = fieldTy.Elem()
+			fieldVal = fieldVal.Elem()
+		}
+
+		if _, isAttr := tags.Attributes[name]; isAttr {
+
+			if exprType.AssignableTo(fieldTy) || attrType.AssignableTo(fieldTy) {
+				continue // ignore undecoded fields
+			}
+			if !fieldVal.IsValid() {
+				continue // ignore (field value is nil pointer)
+			}
+			if fieldTy.Kind() == reflect.Ptr && fieldVal.IsNil() {
+				continue // ignore
+			}
+			if prevWasBlock {
+				dst.AppendNewline()
+				prevWasBlock = false
+			}
+
+			valTy, err := gocty.ImpliedType(fieldVal.Interface())
+			if err != nil {
+				panic(fmt.Sprintf("cannot encode %T as HCL expression: %s", fieldVal.Interface(), err))
+			}
+
+			val, err := gocty.ToCtyValue(fieldVal.Interface(), valTy)
+			if err != nil {
+				// This should never happen, since we should always be able
+				// to decode into the implied type.
+				panic(fmt.Sprintf("failed to encode %T as %#v: %s", fieldVal.Interface(), valTy, err))
+			}
+
+			dst.SetAttributeValue(name, val)
+
+		} else { // must be a block, then
+			elemTy := fieldTy
+			isSeq := false
+			if elemTy.Kind() == reflect.Slice || elemTy.Kind() == reflect.Array {
+				isSeq = true
+				elemTy = elemTy.Elem()
+			}
+
+			if bodyType.AssignableTo(elemTy) || attrsType.AssignableTo(elemTy) {
+				continue // ignore undecoded fields
+			}
+			prevWasBlock = false
+
+			if isSeq {
+				l := fieldVal.Len()
+				for i := 0; i < l; i++ {
+					elemVal := fieldVal.Index(i)
+					if !elemVal.IsValid() {
+						continue // ignore (elem value is nil pointer)
+					}
+					if elemTy.Kind() == reflect.Ptr && elemVal.IsNil() {
+						continue // ignore
+					}
+					block := EncodeAsBlock(elemVal.Interface(), name)
+					if !prevWasBlock {
+						dst.AppendNewline()
+						prevWasBlock = true
+					}
+					dst.AppendBlock(block)
+				}
+			} else {
+				if !fieldVal.IsValid() {
+					continue // ignore (field value is nil pointer)
+				}
+				if elemTy.Kind() == reflect.Ptr && fieldVal.IsNil() {
+					continue // ignore
+				}
+				block := EncodeAsBlock(fieldVal.Interface(), name)
+				if !prevWasBlock {
+					dst.AppendNewline()
+					prevWasBlock = true
+				}
+				dst.AppendBlock(block)
+			}
+		}
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/gohcl/schema.go b/vendor/github.com/hashicorp/hcl/v2/gohcl/schema.go
new file mode 100644
index 00000000..ecf6ddba
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/gohcl/schema.go
@@ -0,0 +1,174 @@
+package gohcl
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+// ImpliedBodySchema produces a hcl.BodySchema derived from the type of the
+// given value, which must be a struct value or a pointer to one. If an
+// inappropriate value is passed, this function will panic.
+//
+// The second return argument indicates whether the given struct includes
+// a "remain" field, and thus the returned schema is non-exhaustive.
+//
+// This uses the tags on the fields of the struct to discover how each
+// field's value should be expressed within configuration. If an invalid
+// mapping is attempted, this function will panic.
+func ImpliedBodySchema(val interface{}) (schema *hcl.BodySchema, partial bool) {
+	ty := reflect.TypeOf(val)
+
+	if ty.Kind() == reflect.Ptr {
+		ty = ty.Elem()
+	}
+
+	if ty.Kind() != reflect.Struct {
+		panic(fmt.Sprintf("given value must be struct, not %T", val))
+	}
+
+	var attrSchemas []hcl.AttributeSchema
+	var blockSchemas []hcl.BlockHeaderSchema
+
+	tags := getFieldTags(ty)
+
+	attrNames := make([]string, 0, len(tags.Attributes))
+	for n := range tags.Attributes {
+		attrNames = append(attrNames, n)
+	}
+	sort.Strings(attrNames)
+	for _, n := range attrNames {
+		idx := tags.Attributes[n]
+		optional := tags.Optional[n]
+		field := ty.Field(idx)
+
+		var required bool
+
+		switch {
+		case field.Type.AssignableTo(exprType):
+			// If we're decoding to hcl.Expression then absense can be
+			// indicated via a null value, so we don't specify that
+			// the field is required during decoding.
+			required = false
+		case field.Type.Kind() != reflect.Ptr && !optional:
+			required = true
+		default:
+			required = false
+		}
+
+		attrSchemas = append(attrSchemas, hcl.AttributeSchema{
+			Name:     n,
+			Required: required,
+		})
+	}
+
+	blockNames := make([]string, 0, len(tags.Blocks))
+	for n := range tags.Blocks {
+		blockNames = append(blockNames, n)
+	}
+	sort.Strings(blockNames)
+	for _, n := range blockNames {
+		idx := tags.Blocks[n]
+		field := ty.Field(idx)
+		fty := field.Type
+		if fty.Kind() == reflect.Slice {
+			fty = fty.Elem()
+		}
+		if fty.Kind() == reflect.Ptr {
+			fty = fty.Elem()
+		}
+		if fty.Kind() != reflect.Struct {
+			panic(fmt.Sprintf(
+				"hcl 'block' tag kind cannot be applied to %s field %s: struct required", field.Type.String(), field.Name,
+			))
+		}
+		ftags := getFieldTags(fty)
+		var labelNames []string
+		if len(ftags.Labels) > 0 {
+			labelNames = make([]string, len(ftags.Labels))
+			for i, l := range ftags.Labels {
+				labelNames[i] = l.Name
+			}
+		}
+
+		blockSchemas = append(blockSchemas, hcl.BlockHeaderSchema{
+			Type:       n,
+			LabelNames: labelNames,
+		})
+	}
+
+	partial = tags.Remain != nil
+	schema = &hcl.BodySchema{
+		Attributes: attrSchemas,
+		Blocks:     blockSchemas,
+	}
+	return schema, partial
+}
+
+type fieldTags struct {
+	Attributes map[string]int
+	Blocks     map[string]int
+	Labels     []labelField
+	Remain     *int
+	Optional   map[string]bool
+}
+
+type labelField struct {
+	FieldIndex int
+	Name       string
+}
+
+func getFieldTags(ty reflect.Type) *fieldTags {
+	ret := &fieldTags{
+		Attributes: map[string]int{},
+		Blocks:     map[string]int{},
+		Optional:   map[string]bool{},
+	}
+
+	ct := ty.NumField()
+	for i := 0; i < ct; i++ {
+		field := ty.Field(i)
+		tag := field.Tag.Get("hcl")
+		if tag == "" {
+			continue
+		}
+
+		comma := strings.Index(tag, ",")
+		var name, kind string
+		if comma != -1 {
+			name = tag[:comma]
+			kind = tag[comma+1:]
+		} else {
+			name = tag
+			kind = "attr"
+		}
+
+		switch kind {
+		case "attr":
+			ret.Attributes[name] = i
+		case "block":
+			ret.Blocks[name] = i
+		case "label":
+			ret.Labels = append(ret.Labels, labelField{
+				FieldIndex: i,
+				Name:       name,
+			})
+		case "remain":
+			if ret.Remain != nil {
+				panic("only one 'remain' tag is permitted")
+			}
+			idx := i // copy, because this loop will continue assigning to i
+			ret.Remain = &idx
+		case "optional":
+			ret.Attributes[name] = i
+			ret.Optional[name] = true
+		default:
+			panic(fmt.Sprintf("invalid hcl field tag kind %q on %s %q", kind, field.Type.String(), field.Name))
+		}
+	}
+
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/gohcl/types.go b/vendor/github.com/hashicorp/hcl/v2/gohcl/types.go
new file mode 100644
index 00000000..a8d00f8f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/gohcl/types.go
@@ -0,0 +1,16 @@
+package gohcl
+
+import (
+	"reflect"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+var victimExpr hcl.Expression
+var victimBody hcl.Body
+
+var exprType = reflect.TypeOf(&victimExpr).Elem()
+var bodyType = reflect.TypeOf(&victimBody).Elem()
+var blockType = reflect.TypeOf((*hcl.Block)(nil))
+var attrType = reflect.TypeOf((*hcl.Attribute)(nil))
+var attrsType = reflect.TypeOf(hcl.Attributes(nil))
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsimple/hclsimple.go b/vendor/github.com/hashicorp/hcl/v2/hclsimple/hclsimple.go
new file mode 100644
index 00000000..09bc4f7f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsimple/hclsimple.go
@@ -0,0 +1,108 @@
+// Package hclsimple is a higher-level entry point for loading HCL
+// configuration files directly into Go struct values in a single step.
+//
+// This package is more opinionated than the rest of the HCL API. See the
+// documentation for function Decode for more information.
+package hclsimple
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/gohcl"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/hashicorp/hcl/v2/json"
+)
+
+// Decode parses, decodes, and evaluates expressions in the given HCL source
+// code, in a single step.
+//
+// The main HCL API is built to allow applications that need to decompose
+// the processing steps into a pipeline, with different tasks done by
+// different parts of the program: parsing the source code into an abstract
+// representation, analysing the block structure, evaluating expressions,
+// and then extracting the results into a form consumable by the rest of
+// the program.
+//
+// This function does all of those steps in one call, going directly from
+// source code to a populated Go struct value.
+//
+// The "filename" and "src" arguments describe the input configuration. The
+// filename is used to add source location context to any returned error
+// messages and its suffix will choose one of the two supported syntaxes:
+// ".hcl" for native syntax, and ".json" for HCL JSON. The src must therefore
+// contain a sequence of bytes that is valid for the selected syntax.
+//
+// The "ctx" argument provides variables and functions for use during
+// expression evaluation. Applications that need no variables nor functions
+// can just pass nil.
+//
+// The "target" argument must be a pointer to a value of a struct type,
+// with struct tags as defined by the sibling package "gohcl".
+//
+// The return type is error but any non-nil error is guaranteed to be
+// type-assertable to hcl.Diagnostics for applications that wish to access
+// the full error details.
+//
+// This is a very opinionated function that is intended to serve the needs of
+// applications that are just using HCL for simple configuration and don't
+// need detailed control over the decoding process. Because this function is
+// just wrapping functionality elsewhere, if it doesn't meet your needs then
+// please consider copying it into your program and adapting it as needed.
+func Decode(filename string, src []byte, ctx *hcl.EvalContext, target interface{}) error {
+	var file *hcl.File
+	var diags hcl.Diagnostics
+
+	switch suffix := strings.ToLower(filepath.Ext(filename)); suffix {
+	case ".hcl":
+		file, diags = hclsyntax.ParseConfig(src, filename, hcl.Pos{Line: 1, Column: 1})
+	case ".json":
+		file, diags = json.Parse(src, filename)
+	default:
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Unsupported file format",
+			Detail:   fmt.Sprintf("Cannot read from %s: unrecognized file format suffix %q.", filename, suffix),
+		})
+		return diags
+	}
+	if diags.HasErrors() {
+		return diags
+	}
+
+	diags = gohcl.DecodeBody(file.Body, ctx, target)
+	if diags.HasErrors() {
+		return diags
+	}
+	return nil
+}
+
+// DecodeFile is a wrapper around Decode that first reads the given filename
+// from disk. See the Decode documentation for more information.
+func DecodeFile(filename string, ctx *hcl.EvalContext, target interface{}) error {
+	src, err := ioutil.ReadFile(filename)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return hcl.Diagnostics{
+				{
+					Severity: hcl.DiagError,
+					Summary:  "Configuration file not found",
+					Detail:   fmt.Sprintf("The configuration file %s does not exist.", filename),
+				},
+			}
+		}
+		return hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Failed to read configuration",
+				Detail:   fmt.Sprintf("Can't read %s: %s.", filename, err),
+			},
+		}
+	}
+
+	return Decode(filename, src, ctx, target)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/diagnostics.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/diagnostics.go
new file mode 100644
index 00000000..8c20286b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/diagnostics.go
@@ -0,0 +1,23 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// setDiagEvalContext is an internal helper that will impose a particular
+// EvalContext on a set of diagnostics in-place, for any diagnostic that
+// does not already have an EvalContext set.
+//
+// We generally expect diagnostics to be immutable, but this is safe to use
+// on any Diagnostics where none of the contained Diagnostic objects have yet
+// been seen by a caller. Its purpose is to apply additional context to a
+// set of diagnostics produced by a "deeper" component as the stack unwinds
+// during expression evaluation.
+func setDiagEvalContext(diags hcl.Diagnostics, expr hcl.Expression, ctx *hcl.EvalContext) {
+	for _, diag := range diags {
+		if diag.Expression == nil {
+			diag.Expression = expr
+			diag.EvalContext = ctx
+		}
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/didyoumean.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/didyoumean.go
new file mode 100644
index 00000000..ccc1c0ae
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/didyoumean.go
@@ -0,0 +1,24 @@
+package hclsyntax
+
+import (
+	"github.com/agext/levenshtein"
+)
+
+// nameSuggestion tries to find a name from the given slice of suggested names
+// that is close to the given name and returns it if found. If no suggestion
+// is close enough, returns the empty string.
+//
+// The suggestions are tried in order, so earlier suggestions take precedence
+// if the given string is similar to two or more suggestions.
+//
+// This function is intended to be used with a relatively-small number of
+// suggestions. It's not optimized for hundreds or thousands of them.
+func nameSuggestion(given string, suggestions []string) string {
+	for _, suggestion := range suggestions {
+		dist := levenshtein.Distance(given, suggestion, nil)
+		if dist < 3 { // threshold determined experimentally
+			return suggestion
+		}
+	}
+	return ""
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/doc.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/doc.go
new file mode 100644
index 00000000..617bc29d
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/doc.go
@@ -0,0 +1,7 @@
+// Package hclsyntax contains the parser, AST, etc for HCL's native language,
+// as opposed to the JSON variant.
+//
+// In normal use applications should rarely depend on this package directly,
+// instead preferring the higher-level interface of the main hcl package and
+// its companion package hclparse.
+package hclsyntax
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression.go
new file mode 100644
index 00000000..3fe84ddc
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression.go
@@ -0,0 +1,1491 @@
+package hclsyntax
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/ext/customdecode"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+// Expression is the abstract type for nodes that behave as HCL expressions.
+type Expression interface {
+	Node
+
+	// The hcl.Expression methods are duplicated here, rather than simply
+	// embedded, because both Node and hcl.Expression have a Range method
+	// and so they conflict.
+
+	Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics)
+	Variables() []hcl.Traversal
+	StartRange() hcl.Range
+}
+
+// Assert that Expression implements hcl.Expression
+var assertExprImplExpr hcl.Expression = Expression(nil)
+
+// LiteralValueExpr is an expression that just always returns a given value.
+type LiteralValueExpr struct {
+	Val      cty.Value
+	SrcRange hcl.Range
+}
+
+func (e *LiteralValueExpr) walkChildNodes(w internalWalkFunc) {
+	// Literal values have no child nodes
+}
+
+func (e *LiteralValueExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	return e.Val, nil
+}
+
+func (e *LiteralValueExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *LiteralValueExpr) StartRange() hcl.Range {
+	return e.SrcRange
+}
+
+// Implementation for hcl.AbsTraversalForExpr.
+func (e *LiteralValueExpr) AsTraversal() hcl.Traversal {
+	// This one's a little weird: the contract for AsTraversal is to interpret
+	// an expression as if it were traversal syntax, and traversal syntax
+	// doesn't have the special keywords "null", "true", and "false" so these
+	// are expected to be treated like variables in that case.
+	// Since our parser already turned them into LiteralValueExpr by the time
+	// we get here, we need to undo this and infer the name that would've
+	// originally led to our value.
+	// We don't do anything for any other values, since they don't overlap
+	// with traversal roots.
+
+	if e.Val.IsNull() {
+		// In practice the parser only generates null values of the dynamic
+		// pseudo-type for literals, so we can safely assume that any null
+		// was orignally the keyword "null".
+		return hcl.Traversal{
+			hcl.TraverseRoot{
+				Name:     "null",
+				SrcRange: e.SrcRange,
+			},
+		}
+	}
+
+	switch e.Val {
+	case cty.True:
+		return hcl.Traversal{
+			hcl.TraverseRoot{
+				Name:     "true",
+				SrcRange: e.SrcRange,
+			},
+		}
+	case cty.False:
+		return hcl.Traversal{
+			hcl.TraverseRoot{
+				Name:     "false",
+				SrcRange: e.SrcRange,
+			},
+		}
+	default:
+		// No traversal is possible for any other value.
+		return nil
+	}
+}
+
+// ScopeTraversalExpr is an Expression that retrieves a value from the scope
+// using a traversal.
+type ScopeTraversalExpr struct {
+	Traversal hcl.Traversal
+	SrcRange  hcl.Range
+}
+
+func (e *ScopeTraversalExpr) walkChildNodes(w internalWalkFunc) {
+	// Scope traversals have no child nodes
+}
+
+func (e *ScopeTraversalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	val, diags := e.Traversal.TraverseAbs(ctx)
+	setDiagEvalContext(diags, e, ctx)
+	return val, diags
+}
+
+func (e *ScopeTraversalExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *ScopeTraversalExpr) StartRange() hcl.Range {
+	return e.SrcRange
+}
+
+// Implementation for hcl.AbsTraversalForExpr.
+func (e *ScopeTraversalExpr) AsTraversal() hcl.Traversal {
+	return e.Traversal
+}
+
+// RelativeTraversalExpr is an Expression that retrieves a value from another
+// value using a _relative_ traversal.
+type RelativeTraversalExpr struct {
+	Source    Expression
+	Traversal hcl.Traversal
+	SrcRange  hcl.Range
+}
+
+func (e *RelativeTraversalExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Source)
+}
+
+func (e *RelativeTraversalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	src, diags := e.Source.Value(ctx)
+	ret, travDiags := e.Traversal.TraverseRel(src)
+	setDiagEvalContext(travDiags, e, ctx)
+	diags = append(diags, travDiags...)
+	return ret, diags
+}
+
+func (e *RelativeTraversalExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *RelativeTraversalExpr) StartRange() hcl.Range {
+	return e.SrcRange
+}
+
+// Implementation for hcl.AbsTraversalForExpr.
+func (e *RelativeTraversalExpr) AsTraversal() hcl.Traversal {
+	// We can produce a traversal only if our source can.
+	st, diags := hcl.AbsTraversalForExpr(e.Source)
+	if diags.HasErrors() {
+		return nil
+	}
+
+	ret := make(hcl.Traversal, len(st)+len(e.Traversal))
+	copy(ret, st)
+	copy(ret[len(st):], e.Traversal)
+	return ret
+}
+
+// FunctionCallExpr is an Expression that calls a function from the EvalContext
+// and returns its result.
+type FunctionCallExpr struct {
+	Name string
+	Args []Expression
+
+	// If true, the final argument should be a tuple, list or set which will
+	// expand to be one argument per element.
+	ExpandFinal bool
+
+	NameRange       hcl.Range
+	OpenParenRange  hcl.Range
+	CloseParenRange hcl.Range
+}
+
+func (e *FunctionCallExpr) walkChildNodes(w internalWalkFunc) {
+	for _, arg := range e.Args {
+		w(arg)
+	}
+}
+
+func (e *FunctionCallExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	var f function.Function
+	exists := false
+	hasNonNilMap := false
+	thisCtx := ctx
+	for thisCtx != nil {
+		if thisCtx.Functions == nil {
+			thisCtx = thisCtx.Parent()
+			continue
+		}
+		hasNonNilMap = true
+		f, exists = thisCtx.Functions[e.Name]
+		if exists {
+			break
+		}
+		thisCtx = thisCtx.Parent()
+	}
+
+	if !exists {
+		if !hasNonNilMap {
+			return cty.DynamicVal, hcl.Diagnostics{
+				{
+					Severity:    hcl.DiagError,
+					Summary:     "Function calls not allowed",
+					Detail:      "Functions may not be called here.",
+					Subject:     e.Range().Ptr(),
+					Expression:  e,
+					EvalContext: ctx,
+				},
+			}
+		}
+
+		avail := make([]string, 0, len(ctx.Functions))
+		for name := range ctx.Functions {
+			avail = append(avail, name)
+		}
+		suggestion := nameSuggestion(e.Name, avail)
+		if suggestion != "" {
+			suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+		}
+
+		return cty.DynamicVal, hcl.Diagnostics{
+			{
+				Severity:    hcl.DiagError,
+				Summary:     "Call to unknown function",
+				Detail:      fmt.Sprintf("There is no function named %q.%s", e.Name, suggestion),
+				Subject:     &e.NameRange,
+				Context:     e.Range().Ptr(),
+				Expression:  e,
+				EvalContext: ctx,
+			},
+		}
+	}
+
+	params := f.Params()
+	varParam := f.VarParam()
+
+	args := e.Args
+	if e.ExpandFinal {
+		if len(args) < 1 {
+			// should never happen if the parser is behaving
+			panic("ExpandFinal set on function call with no arguments")
+		}
+		expandExpr := args[len(args)-1]
+		expandVal, expandDiags := expandExpr.Value(ctx)
+		diags = append(diags, expandDiags...)
+		if expandDiags.HasErrors() {
+			return cty.DynamicVal, diags
+		}
+
+		switch {
+		case expandVal.Type().IsTupleType() || expandVal.Type().IsListType() || expandVal.Type().IsSetType():
+			if expandVal.IsNull() {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity:    hcl.DiagError,
+					Summary:     "Invalid expanding argument value",
+					Detail:      "The expanding argument (indicated by ...) must not be null.",
+					Subject:     expandExpr.Range().Ptr(),
+					Context:     e.Range().Ptr(),
+					Expression:  expandExpr,
+					EvalContext: ctx,
+				})
+				return cty.DynamicVal, diags
+			}
+			if !expandVal.IsKnown() {
+				return cty.DynamicVal, diags
+			}
+
+			newArgs := make([]Expression, 0, (len(args)-1)+expandVal.LengthInt())
+			newArgs = append(newArgs, args[:len(args)-1]...)
+			it := expandVal.ElementIterator()
+			for it.Next() {
+				_, val := it.Element()
+				newArgs = append(newArgs, &LiteralValueExpr{
+					Val:      val,
+					SrcRange: expandExpr.Range(),
+				})
+			}
+			args = newArgs
+		default:
+			diags = append(diags, &hcl.Diagnostic{
+				Severity:    hcl.DiagError,
+				Summary:     "Invalid expanding argument value",
+				Detail:      "The expanding argument (indicated by ...) must be of a tuple, list, or set type.",
+				Subject:     expandExpr.Range().Ptr(),
+				Context:     e.Range().Ptr(),
+				Expression:  expandExpr,
+				EvalContext: ctx,
+			})
+			return cty.DynamicVal, diags
+		}
+	}
+
+	if len(args) < len(params) {
+		missing := params[len(args)]
+		qual := ""
+		if varParam != nil {
+			qual = " at least"
+		}
+		return cty.DynamicVal, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Not enough function arguments",
+				Detail: fmt.Sprintf(
+					"Function %q expects%s %d argument(s). Missing value for %q.",
+					e.Name, qual, len(params), missing.Name,
+				),
+				Subject:     &e.CloseParenRange,
+				Context:     e.Range().Ptr(),
+				Expression:  e,
+				EvalContext: ctx,
+			},
+		}
+	}
+
+	if varParam == nil && len(args) > len(params) {
+		return cty.DynamicVal, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Too many function arguments",
+				Detail: fmt.Sprintf(
+					"Function %q expects only %d argument(s).",
+					e.Name, len(params),
+				),
+				Subject:     args[len(params)].StartRange().Ptr(),
+				Context:     e.Range().Ptr(),
+				Expression:  e,
+				EvalContext: ctx,
+			},
+		}
+	}
+
+	argVals := make([]cty.Value, len(args))
+
+	for i, argExpr := range args {
+		var param *function.Parameter
+		if i < len(params) {
+			param = &params[i]
+		} else {
+			param = varParam
+		}
+
+		var val cty.Value
+		if decodeFn := customdecode.CustomExpressionDecoderForType(param.Type); decodeFn != nil {
+			var argDiags hcl.Diagnostics
+			val, argDiags = decodeFn(argExpr, ctx)
+			diags = append(diags, argDiags...)
+			if val == cty.NilVal {
+				val = cty.UnknownVal(param.Type)
+			}
+		} else {
+			var argDiags hcl.Diagnostics
+			val, argDiags = argExpr.Value(ctx)
+			if len(argDiags) > 0 {
+				diags = append(diags, argDiags...)
+			}
+
+			// Try to convert our value to the parameter type
+			var err error
+			val, err = convert.Convert(val, param.Type)
+			if err != nil {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid function argument",
+					Detail: fmt.Sprintf(
+						"Invalid value for %q parameter: %s.",
+						param.Name, err,
+					),
+					Subject:     argExpr.StartRange().Ptr(),
+					Context:     e.Range().Ptr(),
+					Expression:  argExpr,
+					EvalContext: ctx,
+				})
+			}
+		}
+
+		argVals[i] = val
+	}
+
+	if diags.HasErrors() {
+		// Don't try to execute the function if we already have errors with
+		// the arguments, because the result will probably be a confusing
+		// error message.
+		return cty.DynamicVal, diags
+	}
+
+	resultVal, err := f.Call(argVals)
+	if err != nil {
+		switch terr := err.(type) {
+		case function.ArgError:
+			i := terr.Index
+			var param *function.Parameter
+			if i < len(params) {
+				param = &params[i]
+			} else {
+				param = varParam
+			}
+			argExpr := e.Args[i]
+
+			// TODO: we should also unpick a PathError here and show the
+			// path to the deep value where the error was detected.
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid function argument",
+				Detail: fmt.Sprintf(
+					"Invalid value for %q parameter: %s.",
+					param.Name, err,
+				),
+				Subject:     argExpr.StartRange().Ptr(),
+				Context:     e.Range().Ptr(),
+				Expression:  argExpr,
+				EvalContext: ctx,
+			})
+
+		default:
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Error in function call",
+				Detail: fmt.Sprintf(
+					"Call to function %q failed: %s.",
+					e.Name, err,
+				),
+				Subject:     e.StartRange().Ptr(),
+				Context:     e.Range().Ptr(),
+				Expression:  e,
+				EvalContext: ctx,
+			})
+		}
+
+		return cty.DynamicVal, diags
+	}
+
+	return resultVal, diags
+}
+
+func (e *FunctionCallExpr) Range() hcl.Range {
+	return hcl.RangeBetween(e.NameRange, e.CloseParenRange)
+}
+
+func (e *FunctionCallExpr) StartRange() hcl.Range {
+	return hcl.RangeBetween(e.NameRange, e.OpenParenRange)
+}
+
+// Implementation for hcl.ExprCall.
+func (e *FunctionCallExpr) ExprCall() *hcl.StaticCall {
+	ret := &hcl.StaticCall{
+		Name:      e.Name,
+		NameRange: e.NameRange,
+		Arguments: make([]hcl.Expression, len(e.Args)),
+		ArgsRange: hcl.RangeBetween(e.OpenParenRange, e.CloseParenRange),
+	}
+	// Need to convert our own Expression objects into hcl.Expression.
+	for i, arg := range e.Args {
+		ret.Arguments[i] = arg
+	}
+	return ret
+}
+
+type ConditionalExpr struct {
+	Condition   Expression
+	TrueResult  Expression
+	FalseResult Expression
+
+	SrcRange hcl.Range
+}
+
+func (e *ConditionalExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Condition)
+	w(e.TrueResult)
+	w(e.FalseResult)
+}
+
+func (e *ConditionalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	trueResult, trueDiags := e.TrueResult.Value(ctx)
+	falseResult, falseDiags := e.FalseResult.Value(ctx)
+	var diags hcl.Diagnostics
+
+	resultType := cty.DynamicPseudoType
+	convs := make([]convert.Conversion, 2)
+
+	switch {
+	// If either case is a dynamic null value (which would result from a
+	// literal null in the config), we know that it can convert to the expected
+	// type of the opposite case, and we don't need to speculatively reduce the
+	// final result type to DynamicPseudoType.
+
+	// If we know that either Type is a DynamicPseudoType, we can be certain
+	// that the other value can convert since it's a pass-through, and we don't
+	// need to unify the types. If the final evaluation results in the dynamic
+	// value being returned, there's no conversion we can do, so we return the
+	// value directly.
+	case trueResult.RawEquals(cty.NullVal(cty.DynamicPseudoType)):
+		resultType = falseResult.Type()
+		convs[0] = convert.GetConversionUnsafe(cty.DynamicPseudoType, resultType)
+	case falseResult.RawEquals(cty.NullVal(cty.DynamicPseudoType)):
+		resultType = trueResult.Type()
+		convs[1] = convert.GetConversionUnsafe(cty.DynamicPseudoType, resultType)
+	case trueResult.Type() == cty.DynamicPseudoType, falseResult.Type() == cty.DynamicPseudoType:
+		// the final resultType type is still unknown
+		// we don't need to get the conversion, because both are a noop.
+
+	default:
+		// Try to find a type that both results can be converted to.
+		resultType, convs = convert.UnifyUnsafe([]cty.Type{trueResult.Type(), falseResult.Type()})
+	}
+
+	if resultType == cty.NilType {
+		return cty.DynamicVal, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Inconsistent conditional result types",
+				Detail: fmt.Sprintf(
+					// FIXME: Need a helper function for showing natural-language type diffs,
+					// since this will generate some useless messages in some cases, like
+					// "These expressions are object and object respectively" if the
+					// object types don't exactly match.
+					"The true and false result expressions must have consistent types. The given expressions are %s and %s, respectively.",
+					trueResult.Type().FriendlyName(), falseResult.Type().FriendlyName(),
+				),
+				Subject:     hcl.RangeBetween(e.TrueResult.Range(), e.FalseResult.Range()).Ptr(),
+				Context:     &e.SrcRange,
+				Expression:  e,
+				EvalContext: ctx,
+			},
+		}
+	}
+
+	condResult, condDiags := e.Condition.Value(ctx)
+	diags = append(diags, condDiags...)
+	if condResult.IsNull() {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Null condition",
+			Detail:      "The condition value is null. Conditions must either be true or false.",
+			Subject:     e.Condition.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.Condition,
+			EvalContext: ctx,
+		})
+		return cty.UnknownVal(resultType), diags
+	}
+	if !condResult.IsKnown() {
+		return cty.UnknownVal(resultType), diags
+	}
+	condResult, err := convert.Convert(condResult, cty.Bool)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Incorrect condition type",
+			Detail:      fmt.Sprintf("The condition expression must be of type bool."),
+			Subject:     e.Condition.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.Condition,
+			EvalContext: ctx,
+		})
+		return cty.UnknownVal(resultType), diags
+	}
+
+	if condResult.True() {
+		diags = append(diags, trueDiags...)
+		if convs[0] != nil {
+			var err error
+			trueResult, err = convs[0](trueResult)
+			if err != nil {
+				// Unsafe conversion failed with the concrete result value
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Inconsistent conditional result types",
+					Detail: fmt.Sprintf(
+						"The true result value has the wrong type: %s.",
+						err.Error(),
+					),
+					Subject:     e.TrueResult.Range().Ptr(),
+					Context:     &e.SrcRange,
+					Expression:  e.TrueResult,
+					EvalContext: ctx,
+				})
+				trueResult = cty.UnknownVal(resultType)
+			}
+		}
+		return trueResult, diags
+	} else {
+		diags = append(diags, falseDiags...)
+		if convs[1] != nil {
+			var err error
+			falseResult, err = convs[1](falseResult)
+			if err != nil {
+				// Unsafe conversion failed with the concrete result value
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Inconsistent conditional result types",
+					Detail: fmt.Sprintf(
+						"The false result value has the wrong type: %s.",
+						err.Error(),
+					),
+					Subject:     e.FalseResult.Range().Ptr(),
+					Context:     &e.SrcRange,
+					Expression:  e.FalseResult,
+					EvalContext: ctx,
+				})
+				falseResult = cty.UnknownVal(resultType)
+			}
+		}
+		return falseResult, diags
+	}
+}
+
+func (e *ConditionalExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *ConditionalExpr) StartRange() hcl.Range {
+	return e.Condition.StartRange()
+}
+
+type IndexExpr struct {
+	Collection Expression
+	Key        Expression
+
+	SrcRange     hcl.Range
+	OpenRange    hcl.Range
+	BracketRange hcl.Range
+}
+
+func (e *IndexExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Collection)
+	w(e.Key)
+}
+
+func (e *IndexExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+	coll, collDiags := e.Collection.Value(ctx)
+	key, keyDiags := e.Key.Value(ctx)
+	diags = append(diags, collDiags...)
+	diags = append(diags, keyDiags...)
+
+	val, indexDiags := hcl.Index(coll, key, &e.BracketRange)
+	setDiagEvalContext(indexDiags, e, ctx)
+	diags = append(diags, indexDiags...)
+	return val, diags
+}
+
+func (e *IndexExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *IndexExpr) StartRange() hcl.Range {
+	return e.OpenRange
+}
+
+type TupleConsExpr struct {
+	Exprs []Expression
+
+	SrcRange  hcl.Range
+	OpenRange hcl.Range
+}
+
+func (e *TupleConsExpr) walkChildNodes(w internalWalkFunc) {
+	for _, expr := range e.Exprs {
+		w(expr)
+	}
+}
+
+func (e *TupleConsExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var vals []cty.Value
+	var diags hcl.Diagnostics
+
+	vals = make([]cty.Value, len(e.Exprs))
+	for i, expr := range e.Exprs {
+		val, valDiags := expr.Value(ctx)
+		vals[i] = val
+		diags = append(diags, valDiags...)
+	}
+
+	return cty.TupleVal(vals), diags
+}
+
+func (e *TupleConsExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *TupleConsExpr) StartRange() hcl.Range {
+	return e.OpenRange
+}
+
+// Implementation for hcl.ExprList
+func (e *TupleConsExpr) ExprList() []hcl.Expression {
+	ret := make([]hcl.Expression, len(e.Exprs))
+	for i, expr := range e.Exprs {
+		ret[i] = expr
+	}
+	return ret
+}
+
+type ObjectConsExpr struct {
+	Items []ObjectConsItem
+
+	SrcRange  hcl.Range
+	OpenRange hcl.Range
+}
+
+type ObjectConsItem struct {
+	KeyExpr   Expression
+	ValueExpr Expression
+}
+
+func (e *ObjectConsExpr) walkChildNodes(w internalWalkFunc) {
+	for _, item := range e.Items {
+		w(item.KeyExpr)
+		w(item.ValueExpr)
+	}
+}
+
+func (e *ObjectConsExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var vals map[string]cty.Value
+	var diags hcl.Diagnostics
+
+	// This will get set to true if we fail to produce any of our keys,
+	// either because they are actually unknown or if the evaluation produces
+	// errors. In all of these case we must return DynamicPseudoType because
+	// we're unable to know the full set of keys our object has, and thus
+	// we can't produce a complete value of the intended type.
+	//
+	// We still evaluate all of the item keys and values to make sure that we
+	// get as complete as possible a set of diagnostics.
+	known := true
+
+	vals = make(map[string]cty.Value, len(e.Items))
+	for _, item := range e.Items {
+		key, keyDiags := item.KeyExpr.Value(ctx)
+		diags = append(diags, keyDiags...)
+
+		val, valDiags := item.ValueExpr.Value(ctx)
+		diags = append(diags, valDiags...)
+
+		if keyDiags.HasErrors() {
+			known = false
+			continue
+		}
+
+		if key.IsNull() {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity:    hcl.DiagError,
+				Summary:     "Null value as key",
+				Detail:      "Can't use a null value as a key.",
+				Subject:     item.ValueExpr.Range().Ptr(),
+				Expression:  item.KeyExpr,
+				EvalContext: ctx,
+			})
+			known = false
+			continue
+		}
+
+		var err error
+		key, err = convert.Convert(key, cty.String)
+		if err != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity:    hcl.DiagError,
+				Summary:     "Incorrect key type",
+				Detail:      fmt.Sprintf("Can't use this value as a key: %s.", err.Error()),
+				Subject:     item.KeyExpr.Range().Ptr(),
+				Expression:  item.KeyExpr,
+				EvalContext: ctx,
+			})
+			known = false
+			continue
+		}
+
+		if !key.IsKnown() {
+			known = false
+			continue
+		}
+
+		keyStr := key.AsString()
+
+		vals[keyStr] = val
+	}
+
+	if !known {
+		return cty.DynamicVal, diags
+	}
+
+	return cty.ObjectVal(vals), diags
+}
+
+func (e *ObjectConsExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *ObjectConsExpr) StartRange() hcl.Range {
+	return e.OpenRange
+}
+
+// Implementation for hcl.ExprMap
+func (e *ObjectConsExpr) ExprMap() []hcl.KeyValuePair {
+	ret := make([]hcl.KeyValuePair, len(e.Items))
+	for i, item := range e.Items {
+		ret[i] = hcl.KeyValuePair{
+			Key:   item.KeyExpr,
+			Value: item.ValueExpr,
+		}
+	}
+	return ret
+}
+
+// ObjectConsKeyExpr is a special wrapper used only for ObjectConsExpr keys,
+// which deals with the special case that a naked identifier in that position
+// must be interpreted as a literal string rather than evaluated directly.
+type ObjectConsKeyExpr struct {
+	Wrapped         Expression
+	ForceNonLiteral bool
+}
+
+func (e *ObjectConsKeyExpr) literalName() string {
+	// This is our logic for deciding whether to behave like a literal string.
+	// We lean on our AbsTraversalForExpr implementation here, which already
+	// deals with some awkward cases like the expression being the result
+	// of the keywords "null", "true" and "false" which we'd want to interpret
+	// as keys here too.
+	return hcl.ExprAsKeyword(e.Wrapped)
+}
+
+func (e *ObjectConsKeyExpr) walkChildNodes(w internalWalkFunc) {
+	// We only treat our wrapped expression as a real expression if we're
+	// not going to interpret it as a literal.
+	if e.literalName() == "" {
+		w(e.Wrapped)
+	}
+}
+
+func (e *ObjectConsKeyExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	// Because we accept a naked identifier as a literal key rather than a
+	// reference, it's confusing to accept a traversal containing periods
+	// here since we can't tell if the user intends to create a key with
+	// periods or actually reference something. To avoid confusing downstream
+	// errors we'll just prohibit a naked multi-step traversal here and
+	// require the user to state their intent more clearly.
+	// (This is handled at evaluation time rather than parse time because
+	// an application using static analysis _can_ accept a naked multi-step
+	// traversal here, if desired.)
+	if !e.ForceNonLiteral {
+		if travExpr, isTraversal := e.Wrapped.(*ScopeTraversalExpr); isTraversal && len(travExpr.Traversal) > 1 {
+			var diags hcl.Diagnostics
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Ambiguous attribute key",
+				Detail:   "If this expression is intended to be a reference, wrap it in parentheses. If it's instead intended as a literal name containing periods, wrap it in quotes to create a string literal.",
+				Subject:  e.Range().Ptr(),
+			})
+			return cty.DynamicVal, diags
+		}
+
+		if ln := e.literalName(); ln != "" {
+			return cty.StringVal(ln), nil
+		}
+	}
+	return e.Wrapped.Value(ctx)
+}
+
+func (e *ObjectConsKeyExpr) Range() hcl.Range {
+	return e.Wrapped.Range()
+}
+
+func (e *ObjectConsKeyExpr) StartRange() hcl.Range {
+	return e.Wrapped.StartRange()
+}
+
+// Implementation for hcl.AbsTraversalForExpr.
+func (e *ObjectConsKeyExpr) AsTraversal() hcl.Traversal {
+	// If we're forcing a non-literal then we can never be interpreted
+	// as a traversal.
+	if e.ForceNonLiteral {
+		return nil
+	}
+
+	// We can produce a traversal only if our wrappee can.
+	st, diags := hcl.AbsTraversalForExpr(e.Wrapped)
+	if diags.HasErrors() {
+		return nil
+	}
+
+	return st
+}
+
+func (e *ObjectConsKeyExpr) UnwrapExpression() Expression {
+	return e.Wrapped
+}
+
+// ForExpr represents iteration constructs:
+//
+//     tuple = [for i, v in list: upper(v) if i > 2]
+//     object = {for k, v in map: k => upper(v)}
+//     object_of_tuples = {for v in list: v.key: v...}
+type ForExpr struct {
+	KeyVar string // empty if ignoring the key
+	ValVar string
+
+	CollExpr Expression
+
+	KeyExpr  Expression // nil when producing a tuple
+	ValExpr  Expression
+	CondExpr Expression // null if no "if" clause is present
+
+	Group bool // set if the ellipsis is used on the value in an object for
+
+	SrcRange   hcl.Range
+	OpenRange  hcl.Range
+	CloseRange hcl.Range
+}
+
+func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	collVal, collDiags := e.CollExpr.Value(ctx)
+	diags = append(diags, collDiags...)
+
+	if collVal.IsNull() {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Iteration over null value",
+			Detail:      "A null value cannot be used as the collection in a 'for' expression.",
+			Subject:     e.CollExpr.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.CollExpr,
+			EvalContext: ctx,
+		})
+		return cty.DynamicVal, diags
+	}
+	if collVal.Type() == cty.DynamicPseudoType {
+		return cty.DynamicVal, diags
+	}
+	if !collVal.CanIterateElements() {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Iteration over non-iterable value",
+			Detail: fmt.Sprintf(
+				"A value of type %s cannot be used as the collection in a 'for' expression.",
+				collVal.Type().FriendlyName(),
+			),
+			Subject:     e.CollExpr.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.CollExpr,
+			EvalContext: ctx,
+		})
+		return cty.DynamicVal, diags
+	}
+	if !collVal.IsKnown() {
+		return cty.DynamicVal, diags
+	}
+
+	// Before we start we'll do an early check to see if any CondExpr we've
+	// been given is of the wrong type. This isn't 100% reliable (it may
+	// be DynamicVal until real values are given) but it should catch some
+	// straightforward cases and prevent a barrage of repeated errors.
+	if e.CondExpr != nil {
+		childCtx := ctx.NewChild()
+		childCtx.Variables = map[string]cty.Value{}
+		if e.KeyVar != "" {
+			childCtx.Variables[e.KeyVar] = cty.DynamicVal
+		}
+		childCtx.Variables[e.ValVar] = cty.DynamicVal
+
+		result, condDiags := e.CondExpr.Value(childCtx)
+		diags = append(diags, condDiags...)
+		if result.IsNull() {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity:    hcl.DiagError,
+				Summary:     "Condition is null",
+				Detail:      "The value of the 'if' clause must not be null.",
+				Subject:     e.CondExpr.Range().Ptr(),
+				Context:     &e.SrcRange,
+				Expression:  e.CondExpr,
+				EvalContext: ctx,
+			})
+			return cty.DynamicVal, diags
+		}
+		_, err := convert.Convert(result, cty.Bool)
+		if err != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity:    hcl.DiagError,
+				Summary:     "Invalid 'for' condition",
+				Detail:      fmt.Sprintf("The 'if' clause value is invalid: %s.", err.Error()),
+				Subject:     e.CondExpr.Range().Ptr(),
+				Context:     &e.SrcRange,
+				Expression:  e.CondExpr,
+				EvalContext: ctx,
+			})
+			return cty.DynamicVal, diags
+		}
+		if condDiags.HasErrors() {
+			return cty.DynamicVal, diags
+		}
+	}
+
+	if e.KeyExpr != nil {
+		// Producing an object
+		var vals map[string]cty.Value
+		var groupVals map[string][]cty.Value
+		if e.Group {
+			groupVals = map[string][]cty.Value{}
+		} else {
+			vals = map[string]cty.Value{}
+		}
+
+		it := collVal.ElementIterator()
+
+		known := true
+		for it.Next() {
+			k, v := it.Element()
+			childCtx := ctx.NewChild()
+			childCtx.Variables = map[string]cty.Value{}
+			if e.KeyVar != "" {
+				childCtx.Variables[e.KeyVar] = k
+			}
+			childCtx.Variables[e.ValVar] = v
+
+			if e.CondExpr != nil {
+				includeRaw, condDiags := e.CondExpr.Value(childCtx)
+				diags = append(diags, condDiags...)
+				if includeRaw.IsNull() {
+					if known {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity:    hcl.DiagError,
+							Summary:     "Invalid 'for' condition",
+							Detail:      "The value of the 'if' clause must not be null.",
+							Subject:     e.CondExpr.Range().Ptr(),
+							Context:     &e.SrcRange,
+							Expression:  e.CondExpr,
+							EvalContext: childCtx,
+						})
+					}
+					known = false
+					continue
+				}
+				include, err := convert.Convert(includeRaw, cty.Bool)
+				if err != nil {
+					if known {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity:    hcl.DiagError,
+							Summary:     "Invalid 'for' condition",
+							Detail:      fmt.Sprintf("The 'if' clause value is invalid: %s.", err.Error()),
+							Subject:     e.CondExpr.Range().Ptr(),
+							Context:     &e.SrcRange,
+							Expression:  e.CondExpr,
+							EvalContext: childCtx,
+						})
+					}
+					known = false
+					continue
+				}
+				if !include.IsKnown() {
+					known = false
+					continue
+				}
+
+				if include.False() {
+					// Skip this element
+					continue
+				}
+			}
+
+			keyRaw, keyDiags := e.KeyExpr.Value(childCtx)
+			diags = append(diags, keyDiags...)
+			if keyRaw.IsNull() {
+				if known {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity:    hcl.DiagError,
+						Summary:     "Invalid object key",
+						Detail:      "Key expression in 'for' expression must not produce a null value.",
+						Subject:     e.KeyExpr.Range().Ptr(),
+						Context:     &e.SrcRange,
+						Expression:  e.KeyExpr,
+						EvalContext: childCtx,
+					})
+				}
+				known = false
+				continue
+			}
+			if !keyRaw.IsKnown() {
+				known = false
+				continue
+			}
+
+			key, err := convert.Convert(keyRaw, cty.String)
+			if err != nil {
+				if known {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity:    hcl.DiagError,
+						Summary:     "Invalid object key",
+						Detail:      fmt.Sprintf("The key expression produced an invalid result: %s.", err.Error()),
+						Subject:     e.KeyExpr.Range().Ptr(),
+						Context:     &e.SrcRange,
+						Expression:  e.KeyExpr,
+						EvalContext: childCtx,
+					})
+				}
+				known = false
+				continue
+			}
+
+			val, valDiags := e.ValExpr.Value(childCtx)
+			diags = append(diags, valDiags...)
+
+			if e.Group {
+				k := key.AsString()
+				groupVals[k] = append(groupVals[k], val)
+			} else {
+				k := key.AsString()
+				if _, exists := vals[k]; exists {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Duplicate object key",
+						Detail: fmt.Sprintf(
+							"Two different items produced the key %q in this 'for' expression. If duplicates are expected, use the ellipsis (...) after the value expression to enable grouping by key.",
+							k,
+						),
+						Subject:     e.KeyExpr.Range().Ptr(),
+						Context:     &e.SrcRange,
+						Expression:  e.KeyExpr,
+						EvalContext: childCtx,
+					})
+				} else {
+					vals[key.AsString()] = val
+				}
+			}
+		}
+
+		if !known {
+			return cty.DynamicVal, diags
+		}
+
+		if e.Group {
+			vals = map[string]cty.Value{}
+			for k, gvs := range groupVals {
+				vals[k] = cty.TupleVal(gvs)
+			}
+		}
+
+		return cty.ObjectVal(vals), diags
+
+	} else {
+		// Producing a tuple
+		vals := []cty.Value{}
+
+		it := collVal.ElementIterator()
+
+		known := true
+		for it.Next() {
+			k, v := it.Element()
+			childCtx := ctx.NewChild()
+			childCtx.Variables = map[string]cty.Value{}
+			if e.KeyVar != "" {
+				childCtx.Variables[e.KeyVar] = k
+			}
+			childCtx.Variables[e.ValVar] = v
+
+			if e.CondExpr != nil {
+				includeRaw, condDiags := e.CondExpr.Value(childCtx)
+				diags = append(diags, condDiags...)
+				if includeRaw.IsNull() {
+					if known {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity:    hcl.DiagError,
+							Summary:     "Invalid 'for' condition",
+							Detail:      "The value of the 'if' clause must not be null.",
+							Subject:     e.CondExpr.Range().Ptr(),
+							Context:     &e.SrcRange,
+							Expression:  e.CondExpr,
+							EvalContext: childCtx,
+						})
+					}
+					known = false
+					continue
+				}
+				if !includeRaw.IsKnown() {
+					// We will eventually return DynamicVal, but we'll continue
+					// iterating in case there are other diagnostics to gather
+					// for later elements.
+					known = false
+					continue
+				}
+
+				include, err := convert.Convert(includeRaw, cty.Bool)
+				if err != nil {
+					if known {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity:    hcl.DiagError,
+							Summary:     "Invalid 'for' condition",
+							Detail:      fmt.Sprintf("The 'if' clause value is invalid: %s.", err.Error()),
+							Subject:     e.CondExpr.Range().Ptr(),
+							Context:     &e.SrcRange,
+							Expression:  e.CondExpr,
+							EvalContext: childCtx,
+						})
+					}
+					known = false
+					continue
+				}
+
+				if include.False() {
+					// Skip this element
+					continue
+				}
+			}
+
+			val, valDiags := e.ValExpr.Value(childCtx)
+			diags = append(diags, valDiags...)
+			vals = append(vals, val)
+		}
+
+		if !known {
+			return cty.DynamicVal, diags
+		}
+
+		return cty.TupleVal(vals), diags
+	}
+}
+
+func (e *ForExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.CollExpr)
+
+	scopeNames := map[string]struct{}{}
+	if e.KeyVar != "" {
+		scopeNames[e.KeyVar] = struct{}{}
+	}
+	if e.ValVar != "" {
+		scopeNames[e.ValVar] = struct{}{}
+	}
+
+	if e.KeyExpr != nil {
+		w(ChildScope{
+			LocalNames: scopeNames,
+			Expr:       e.KeyExpr,
+		})
+	}
+	w(ChildScope{
+		LocalNames: scopeNames,
+		Expr:       e.ValExpr,
+	})
+	if e.CondExpr != nil {
+		w(ChildScope{
+			LocalNames: scopeNames,
+			Expr:       e.CondExpr,
+		})
+	}
+}
+
+func (e *ForExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *ForExpr) StartRange() hcl.Range {
+	return e.OpenRange
+}
+
+type SplatExpr struct {
+	Source Expression
+	Each   Expression
+	Item   *AnonSymbolExpr
+
+	SrcRange    hcl.Range
+	MarkerRange hcl.Range
+}
+
+func (e *SplatExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	sourceVal, diags := e.Source.Value(ctx)
+	if diags.HasErrors() {
+		// We'll evaluate our "Each" expression here just to see if it
+		// produces any more diagnostics we can report. Since we're not
+		// assigning a value to our AnonSymbolExpr here it will return
+		// DynamicVal, which should short-circuit any use of it.
+		_, itemDiags := e.Item.Value(ctx)
+		diags = append(diags, itemDiags...)
+		return cty.DynamicVal, diags
+	}
+
+	sourceTy := sourceVal.Type()
+	if sourceTy == cty.DynamicPseudoType {
+		// If we don't even know the _type_ of our source value yet then
+		// we'll need to defer all processing, since we can't decide our
+		// result type either.
+		return cty.DynamicVal, diags
+	}
+
+	// A "special power" of splat expressions is that they can be applied
+	// both to tuples/lists and to other values, and in the latter case
+	// the value will be treated as an implicit single-item tuple, or as
+	// an empty tuple if the value is null.
+	autoUpgrade := !(sourceTy.IsTupleType() || sourceTy.IsListType() || sourceTy.IsSetType())
+
+	if sourceVal.IsNull() {
+		if autoUpgrade {
+			return cty.EmptyTupleVal, diags
+		}
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Splat of null value",
+			Detail:      "Splat expressions (with the * symbol) cannot be applied to null sequences.",
+			Subject:     e.Source.Range().Ptr(),
+			Context:     hcl.RangeBetween(e.Source.Range(), e.MarkerRange).Ptr(),
+			Expression:  e.Source,
+			EvalContext: ctx,
+		})
+		return cty.DynamicVal, diags
+	}
+
+	if autoUpgrade {
+		sourceVal = cty.TupleVal([]cty.Value{sourceVal})
+		sourceTy = sourceVal.Type()
+	}
+
+	// We'll compute our result type lazily if we need it. In the normal case
+	// it's inferred automatically from the value we construct.
+	resultTy := func() (cty.Type, hcl.Diagnostics) {
+		chiCtx := ctx.NewChild()
+		var diags hcl.Diagnostics
+		switch {
+		case sourceTy.IsListType() || sourceTy.IsSetType():
+			ety := sourceTy.ElementType()
+			e.Item.setValue(chiCtx, cty.UnknownVal(ety))
+			val, itemDiags := e.Each.Value(chiCtx)
+			diags = append(diags, itemDiags...)
+			e.Item.clearValue(chiCtx) // clean up our temporary value
+			return cty.List(val.Type()), diags
+		case sourceTy.IsTupleType():
+			etys := sourceTy.TupleElementTypes()
+			resultTys := make([]cty.Type, 0, len(etys))
+			for _, ety := range etys {
+				e.Item.setValue(chiCtx, cty.UnknownVal(ety))
+				val, itemDiags := e.Each.Value(chiCtx)
+				diags = append(diags, itemDiags...)
+				e.Item.clearValue(chiCtx) // clean up our temporary value
+				resultTys = append(resultTys, val.Type())
+			}
+			return cty.Tuple(resultTys), diags
+		default:
+			// Should never happen because of our promotion to list above.
+			return cty.DynamicPseudoType, diags
+		}
+	}
+
+	if !sourceVal.IsKnown() {
+		// We can't produce a known result in this case, but we'll still
+		// indicate what the result type would be, allowing any downstream type
+		// checking to proceed.
+		ty, tyDiags := resultTy()
+		diags = append(diags, tyDiags...)
+		return cty.UnknownVal(ty), diags
+	}
+
+	vals := make([]cty.Value, 0, sourceVal.LengthInt())
+	it := sourceVal.ElementIterator()
+	if ctx == nil {
+		// we need a context to use our AnonSymbolExpr, so we'll just
+		// make an empty one here to use as a placeholder.
+		ctx = ctx.NewChild()
+	}
+	isKnown := true
+	for it.Next() {
+		_, sourceItem := it.Element()
+		e.Item.setValue(ctx, sourceItem)
+		newItem, itemDiags := e.Each.Value(ctx)
+		diags = append(diags, itemDiags...)
+		if itemDiags.HasErrors() {
+			isKnown = false
+		}
+		vals = append(vals, newItem)
+	}
+	e.Item.clearValue(ctx) // clean up our temporary value
+
+	if !isKnown {
+		// We'll ingore the resultTy diagnostics in this case since they
+		// will just be the same errors we saw while iterating above.
+		ty, _ := resultTy()
+		return cty.UnknownVal(ty), diags
+	}
+
+	switch {
+	case sourceTy.IsListType() || sourceTy.IsSetType():
+		if len(vals) == 0 {
+			ty, tyDiags := resultTy()
+			diags = append(diags, tyDiags...)
+			return cty.ListValEmpty(ty.ElementType()), diags
+		}
+		return cty.ListVal(vals), diags
+	default:
+		return cty.TupleVal(vals), diags
+	}
+}
+
+func (e *SplatExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Source)
+	w(e.Each)
+}
+
+func (e *SplatExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *SplatExpr) StartRange() hcl.Range {
+	return e.MarkerRange
+}
+
+// AnonSymbolExpr is used as a placeholder for a value in an expression that
+// can be applied dynamically to any value at runtime.
+//
+// This is a rather odd, synthetic expression. It is used as part of the
+// representation of splat expressions as a placeholder for the current item
+// being visited in the splat evaluation.
+//
+// AnonSymbolExpr cannot be evaluated in isolation. If its Value is called
+// directly then cty.DynamicVal will be returned. Instead, it is evaluated
+// in terms of another node (i.e. a splat expression) which temporarily
+// assigns it a value.
+type AnonSymbolExpr struct {
+	SrcRange hcl.Range
+
+	// values and its associated lock are used to isolate concurrent
+	// evaluations of a symbol from one another. It is the calling application's
+	// responsibility to ensure that the same splat expression is not evalauted
+	// concurrently within the _same_ EvalContext, but it is fine and safe to
+	// do cuncurrent evaluations with distinct EvalContexts.
+	values     map[*hcl.EvalContext]cty.Value
+	valuesLock sync.RWMutex
+}
+
+func (e *AnonSymbolExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	if ctx == nil {
+		return cty.DynamicVal, nil
+	}
+
+	e.valuesLock.RLock()
+	defer e.valuesLock.RUnlock()
+
+	val, exists := e.values[ctx]
+	if !exists {
+		return cty.DynamicVal, nil
+	}
+	return val, nil
+}
+
+// setValue sets a temporary local value for the expression when evaluated
+// in the given context, which must be non-nil.
+func (e *AnonSymbolExpr) setValue(ctx *hcl.EvalContext, val cty.Value) {
+	e.valuesLock.Lock()
+	defer e.valuesLock.Unlock()
+
+	if e.values == nil {
+		e.values = make(map[*hcl.EvalContext]cty.Value)
+	}
+	if ctx == nil {
+		panic("can't setValue for a nil EvalContext")
+	}
+	e.values[ctx] = val
+}
+
+func (e *AnonSymbolExpr) clearValue(ctx *hcl.EvalContext) {
+	e.valuesLock.Lock()
+	defer e.valuesLock.Unlock()
+
+	if e.values == nil {
+		return
+	}
+	if ctx == nil {
+		panic("can't clearValue for a nil EvalContext")
+	}
+	delete(e.values, ctx)
+}
+
+func (e *AnonSymbolExpr) walkChildNodes(w internalWalkFunc) {
+	// AnonSymbolExpr is a leaf node in the tree
+}
+
+func (e *AnonSymbolExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *AnonSymbolExpr) StartRange() hcl.Range {
+	return e.SrcRange
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_ops.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_ops.go
new file mode 100644
index 00000000..c1db0cec
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_ops.go
@@ -0,0 +1,268 @@
+package hclsyntax
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/function/stdlib"
+)
+
+type Operation struct {
+	Impl function.Function
+	Type cty.Type
+}
+
+var (
+	OpLogicalOr = &Operation{
+		Impl: stdlib.OrFunc,
+		Type: cty.Bool,
+	}
+	OpLogicalAnd = &Operation{
+		Impl: stdlib.AndFunc,
+		Type: cty.Bool,
+	}
+	OpLogicalNot = &Operation{
+		Impl: stdlib.NotFunc,
+		Type: cty.Bool,
+	}
+
+	OpEqual = &Operation{
+		Impl: stdlib.EqualFunc,
+		Type: cty.Bool,
+	}
+	OpNotEqual = &Operation{
+		Impl: stdlib.NotEqualFunc,
+		Type: cty.Bool,
+	}
+
+	OpGreaterThan = &Operation{
+		Impl: stdlib.GreaterThanFunc,
+		Type: cty.Bool,
+	}
+	OpGreaterThanOrEqual = &Operation{
+		Impl: stdlib.GreaterThanOrEqualToFunc,
+		Type: cty.Bool,
+	}
+	OpLessThan = &Operation{
+		Impl: stdlib.LessThanFunc,
+		Type: cty.Bool,
+	}
+	OpLessThanOrEqual = &Operation{
+		Impl: stdlib.LessThanOrEqualToFunc,
+		Type: cty.Bool,
+	}
+
+	OpAdd = &Operation{
+		Impl: stdlib.AddFunc,
+		Type: cty.Number,
+	}
+	OpSubtract = &Operation{
+		Impl: stdlib.SubtractFunc,
+		Type: cty.Number,
+	}
+	OpMultiply = &Operation{
+		Impl: stdlib.MultiplyFunc,
+		Type: cty.Number,
+	}
+	OpDivide = &Operation{
+		Impl: stdlib.DivideFunc,
+		Type: cty.Number,
+	}
+	OpModulo = &Operation{
+		Impl: stdlib.ModuloFunc,
+		Type: cty.Number,
+	}
+	OpNegate = &Operation{
+		Impl: stdlib.NegateFunc,
+		Type: cty.Number,
+	}
+)
+
+var binaryOps []map[TokenType]*Operation
+
+func init() {
+	// This operation table maps from the operator's token type
+	// to the AST operation type. All expressions produced from
+	// binary operators are BinaryOp nodes.
+	//
+	// Binary operator groups are listed in order of precedence, with
+	// the *lowest* precedence first. Operators within the same group
+	// have left-to-right associativity.
+	binaryOps = []map[TokenType]*Operation{
+		{
+			TokenOr: OpLogicalOr,
+		},
+		{
+			TokenAnd: OpLogicalAnd,
+		},
+		{
+			TokenEqualOp:  OpEqual,
+			TokenNotEqual: OpNotEqual,
+		},
+		{
+			TokenGreaterThan:   OpGreaterThan,
+			TokenGreaterThanEq: OpGreaterThanOrEqual,
+			TokenLessThan:      OpLessThan,
+			TokenLessThanEq:    OpLessThanOrEqual,
+		},
+		{
+			TokenPlus:  OpAdd,
+			TokenMinus: OpSubtract,
+		},
+		{
+			TokenStar:    OpMultiply,
+			TokenSlash:   OpDivide,
+			TokenPercent: OpModulo,
+		},
+	}
+}
+
+type BinaryOpExpr struct {
+	LHS Expression
+	Op  *Operation
+	RHS Expression
+
+	SrcRange hcl.Range
+}
+
+func (e *BinaryOpExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.LHS)
+	w(e.RHS)
+}
+
+func (e *BinaryOpExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	impl := e.Op.Impl // assumed to be a function taking exactly two arguments
+	params := impl.Params()
+	lhsParam := params[0]
+	rhsParam := params[1]
+
+	var diags hcl.Diagnostics
+
+	givenLHSVal, lhsDiags := e.LHS.Value(ctx)
+	givenRHSVal, rhsDiags := e.RHS.Value(ctx)
+	diags = append(diags, lhsDiags...)
+	diags = append(diags, rhsDiags...)
+
+	lhsVal, err := convert.Convert(givenLHSVal, lhsParam.Type)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Invalid operand",
+			Detail:      fmt.Sprintf("Unsuitable value for left operand: %s.", err),
+			Subject:     e.LHS.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.LHS,
+			EvalContext: ctx,
+		})
+	}
+	rhsVal, err := convert.Convert(givenRHSVal, rhsParam.Type)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Invalid operand",
+			Detail:      fmt.Sprintf("Unsuitable value for right operand: %s.", err),
+			Subject:     e.RHS.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.RHS,
+			EvalContext: ctx,
+		})
+	}
+
+	if diags.HasErrors() {
+		// Don't actually try the call if we have errors already, since the
+		// this will probably just produce a confusing duplicative diagnostic.
+		return cty.UnknownVal(e.Op.Type), diags
+	}
+
+	args := []cty.Value{lhsVal, rhsVal}
+	result, err := impl.Call(args)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			// FIXME: This diagnostic is useless.
+			Severity:    hcl.DiagError,
+			Summary:     "Operation failed",
+			Detail:      fmt.Sprintf("Error during operation: %s.", err),
+			Subject:     &e.SrcRange,
+			Expression:  e,
+			EvalContext: ctx,
+		})
+		return cty.UnknownVal(e.Op.Type), diags
+	}
+
+	return result, diags
+}
+
+func (e *BinaryOpExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *BinaryOpExpr) StartRange() hcl.Range {
+	return e.LHS.StartRange()
+}
+
+type UnaryOpExpr struct {
+	Op  *Operation
+	Val Expression
+
+	SrcRange    hcl.Range
+	SymbolRange hcl.Range
+}
+
+func (e *UnaryOpExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Val)
+}
+
+func (e *UnaryOpExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	impl := e.Op.Impl // assumed to be a function taking exactly one argument
+	params := impl.Params()
+	param := params[0]
+
+	givenVal, diags := e.Val.Value(ctx)
+
+	val, err := convert.Convert(givenVal, param.Type)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Invalid operand",
+			Detail:      fmt.Sprintf("Unsuitable value for unary operand: %s.", err),
+			Subject:     e.Val.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.Val,
+			EvalContext: ctx,
+		})
+	}
+
+	if diags.HasErrors() {
+		// Don't actually try the call if we have errors already, since the
+		// this will probably just produce a confusing duplicative diagnostic.
+		return cty.UnknownVal(e.Op.Type), diags
+	}
+
+	args := []cty.Value{val}
+	result, err := impl.Call(args)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			// FIXME: This diagnostic is useless.
+			Severity:    hcl.DiagError,
+			Summary:     "Operation failed",
+			Detail:      fmt.Sprintf("Error during operation: %s.", err),
+			Subject:     &e.SrcRange,
+			Expression:  e,
+			EvalContext: ctx,
+		})
+		return cty.UnknownVal(e.Op.Type), diags
+	}
+
+	return result, diags
+}
+
+func (e *UnaryOpExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *UnaryOpExpr) StartRange() hcl.Range {
+	return e.SymbolRange
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_template.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_template.go
new file mode 100644
index 00000000..9d425115
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_template.go
@@ -0,0 +1,220 @@
+package hclsyntax
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+)
+
+type TemplateExpr struct {
+	Parts []Expression
+
+	SrcRange hcl.Range
+}
+
+func (e *TemplateExpr) walkChildNodes(w internalWalkFunc) {
+	for _, part := range e.Parts {
+		w(part)
+	}
+}
+
+func (e *TemplateExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	buf := &bytes.Buffer{}
+	var diags hcl.Diagnostics
+	isKnown := true
+
+	for _, part := range e.Parts {
+		partVal, partDiags := part.Value(ctx)
+		diags = append(diags, partDiags...)
+
+		if partVal.IsNull() {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid template interpolation value",
+				Detail: fmt.Sprintf(
+					"The expression result is null. Cannot include a null value in a string template.",
+				),
+				Subject:     part.Range().Ptr(),
+				Context:     &e.SrcRange,
+				Expression:  part,
+				EvalContext: ctx,
+			})
+			continue
+		}
+
+		if !partVal.IsKnown() {
+			// If any part is unknown then the result as a whole must be
+			// unknown too. We'll keep on processing the rest of the parts
+			// anyway, because we want to still emit any diagnostics resulting
+			// from evaluating those.
+			isKnown = false
+			continue
+		}
+
+		strVal, err := convert.Convert(partVal, cty.String)
+		if err != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid template interpolation value",
+				Detail: fmt.Sprintf(
+					"Cannot include the given value in a string template: %s.",
+					err.Error(),
+				),
+				Subject:     part.Range().Ptr(),
+				Context:     &e.SrcRange,
+				Expression:  part,
+				EvalContext: ctx,
+			})
+			continue
+		}
+
+		buf.WriteString(strVal.AsString())
+	}
+
+	if !isKnown {
+		return cty.UnknownVal(cty.String), diags
+	}
+
+	return cty.StringVal(buf.String()), diags
+}
+
+func (e *TemplateExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *TemplateExpr) StartRange() hcl.Range {
+	return e.Parts[0].StartRange()
+}
+
+// IsStringLiteral returns true if and only if the template consists only of
+// single string literal, as would be created for a simple quoted string like
+// "foo".
+//
+// If this function returns true, then calling Value on the same expression
+// with a nil EvalContext will return the literal value.
+//
+// Note that "${"foo"}", "${1}", etc aren't considered literal values for the
+// purposes of this method, because the intent of this method is to identify
+// situations where the user seems to be explicitly intending literal string
+// interpretation, not situations that result in literals as a technicality
+// of the template expression unwrapping behavior.
+func (e *TemplateExpr) IsStringLiteral() bool {
+	if len(e.Parts) != 1 {
+		return false
+	}
+	_, ok := e.Parts[0].(*LiteralValueExpr)
+	return ok
+}
+
+// TemplateJoinExpr is used to convert tuples of strings produced by template
+// constructs (i.e. for loops) into flat strings, by converting the values
+// tos strings and joining them. This AST node is not used directly; it's
+// produced as part of the AST of a "for" loop in a template.
+type TemplateJoinExpr struct {
+	Tuple Expression
+}
+
+func (e *TemplateJoinExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Tuple)
+}
+
+func (e *TemplateJoinExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	tuple, diags := e.Tuple.Value(ctx)
+
+	if tuple.IsNull() {
+		// This indicates a bug in the code that constructed the AST.
+		panic("TemplateJoinExpr got null tuple")
+	}
+	if tuple.Type() == cty.DynamicPseudoType {
+		return cty.UnknownVal(cty.String), diags
+	}
+	if !tuple.Type().IsTupleType() {
+		// This indicates a bug in the code that constructed the AST.
+		panic("TemplateJoinExpr got non-tuple tuple")
+	}
+	if !tuple.IsKnown() {
+		return cty.UnknownVal(cty.String), diags
+	}
+
+	buf := &bytes.Buffer{}
+	it := tuple.ElementIterator()
+	for it.Next() {
+		_, val := it.Element()
+
+		if val.IsNull() {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid template interpolation value",
+				Detail: fmt.Sprintf(
+					"An iteration result is null. Cannot include a null value in a string template.",
+				),
+				Subject:     e.Range().Ptr(),
+				Expression:  e,
+				EvalContext: ctx,
+			})
+			continue
+		}
+		if val.Type() == cty.DynamicPseudoType {
+			return cty.UnknownVal(cty.String), diags
+		}
+		strVal, err := convert.Convert(val, cty.String)
+		if err != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid template interpolation value",
+				Detail: fmt.Sprintf(
+					"Cannot include one of the interpolation results into the string template: %s.",
+					err.Error(),
+				),
+				Subject:     e.Range().Ptr(),
+				Expression:  e,
+				EvalContext: ctx,
+			})
+			continue
+		}
+		if !val.IsKnown() {
+			return cty.UnknownVal(cty.String), diags
+		}
+
+		buf.WriteString(strVal.AsString())
+	}
+
+	return cty.StringVal(buf.String()), diags
+}
+
+func (e *TemplateJoinExpr) Range() hcl.Range {
+	return e.Tuple.Range()
+}
+
+func (e *TemplateJoinExpr) StartRange() hcl.Range {
+	return e.Tuple.StartRange()
+}
+
+// TemplateWrapExpr is used instead of a TemplateExpr when a template
+// consists _only_ of a single interpolation sequence. In that case, the
+// template's result is the single interpolation's result, verbatim with
+// no type conversions.
+type TemplateWrapExpr struct {
+	Wrapped Expression
+
+	SrcRange hcl.Range
+}
+
+func (e *TemplateWrapExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Wrapped)
+}
+
+func (e *TemplateWrapExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	return e.Wrapped.Value(ctx)
+}
+
+func (e *TemplateWrapExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *TemplateWrapExpr) StartRange() hcl.Range {
+	return e.SrcRange
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_vars.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_vars.go
new file mode 100644
index 00000000..a82bf790
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_vars.go
@@ -0,0 +1,76 @@
+package hclsyntax
+
+// Generated by expression_vars_get.go. DO NOT EDIT.
+// Run 'go generate' on this package to update the set of functions here.
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+func (e *AnonSymbolExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *BinaryOpExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *ConditionalExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *ForExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *FunctionCallExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *IndexExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *LiteralValueExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *ObjectConsExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *ObjectConsKeyExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *RelativeTraversalExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *ScopeTraversalExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *SplatExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *TemplateExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *TemplateJoinExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *TemplateWrapExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *TupleConsExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *UnaryOpExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/file.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/file.go
new file mode 100644
index 00000000..f55e9ce2
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/file.go
@@ -0,0 +1,20 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// File is the top-level object resulting from parsing a configuration file.
+type File struct {
+	Body  *Body
+	Bytes []byte
+}
+
+func (f *File) AsHCLFile() *hcl.File {
+	return &hcl.File{
+		Body:  f.Body,
+		Bytes: f.Bytes,
+
+		// TODO: The Nav object, once we have an implementation of it
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/generate.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/generate.go
new file mode 100644
index 00000000..841656a6
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/generate.go
@@ -0,0 +1,9 @@
+package hclsyntax
+
+//go:generate go run expression_vars_gen.go
+//go:generate ruby unicode2ragel.rb --url=http://www.unicode.org/Public/9.0.0/ucd/DerivedCoreProperties.txt -m UnicodeDerived -p ID_Start,ID_Continue -o unicode_derived.rl
+//go:generate ragel -Z scan_tokens.rl
+//go:generate gofmt -w scan_tokens.go
+//go:generate ragel -Z scan_string_lit.rl
+//go:generate gofmt -w scan_string_lit.go
+//go:generate stringer -type TokenType -output token_type_string.go
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/keywords.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/keywords.go
new file mode 100644
index 00000000..eef8b962
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/keywords.go
@@ -0,0 +1,21 @@
+package hclsyntax
+
+import (
+	"bytes"
+)
+
+type Keyword []byte
+
+var forKeyword = Keyword([]byte{'f', 'o', 'r'})
+var inKeyword = Keyword([]byte{'i', 'n'})
+var ifKeyword = Keyword([]byte{'i', 'f'})
+var elseKeyword = Keyword([]byte{'e', 'l', 's', 'e'})
+var endifKeyword = Keyword([]byte{'e', 'n', 'd', 'i', 'f'})
+var endforKeyword = Keyword([]byte{'e', 'n', 'd', 'f', 'o', 'r'})
+
+func (kw Keyword) TokenMatches(token Token) bool {
+	if token.Type != TokenIdent {
+		return false
+	}
+	return bytes.Equal([]byte(kw), token.Bytes)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/navigation.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/navigation.go
new file mode 100644
index 00000000..af98ef04
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/navigation.go
@@ -0,0 +1,59 @@
+package hclsyntax
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+type navigation struct {
+	root *Body
+}
+
+// Implementation of hcled.ContextString
+func (n navigation) ContextString(offset int) string {
+	// We will walk our top-level blocks until we find one that contains
+	// the given offset, and then construct a representation of the header
+	// of the block.
+
+	var block *Block
+	for _, candidate := range n.root.Blocks {
+		if candidate.Range().ContainsOffset(offset) {
+			block = candidate
+			break
+		}
+	}
+
+	if block == nil {
+		return ""
+	}
+
+	if len(block.Labels) == 0 {
+		// Easy case!
+		return block.Type
+	}
+
+	buf := &bytes.Buffer{}
+	buf.WriteString(block.Type)
+	for _, label := range block.Labels {
+		fmt.Fprintf(buf, " %q", label)
+	}
+	return buf.String()
+}
+
+func (n navigation) ContextDefRange(offset int) hcl.Range {
+	var block *Block
+	for _, candidate := range n.root.Blocks {
+		if candidate.Range().ContainsOffset(offset) {
+			block = candidate
+			break
+		}
+	}
+
+	if block == nil {
+		return hcl.Range{}
+	}
+
+	return block.DefRange()
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/node.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/node.go
new file mode 100644
index 00000000..41b35e53
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/node.go
@@ -0,0 +1,22 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// Node is the abstract type that every AST node implements.
+//
+// This is a closed interface, so it cannot be implemented from outside of
+// this package.
+type Node interface {
+	// This is the mechanism by which the public-facing walk functions
+	// are implemented. Implementations should call the given function
+	// for each child node and then replace that node with its return value.
+	// The return value might just be the same node, for non-transforming
+	// walks.
+	walkChildNodes(w internalWalkFunc)
+
+	Range() hcl.Range
+}
+
+type internalWalkFunc func(Node)
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser.go
new file mode 100644
index 00000000..83efd9ad
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser.go
@@ -0,0 +1,2055 @@
+package hclsyntax
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+	"unicode/utf8"
+
+	"github.com/apparentlymart/go-textseg/v12/textseg"
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+)
+
+type parser struct {
+	*peeker
+
+	// set to true if any recovery is attempted. The parser can use this
+	// to attempt to reduce error noise by suppressing "bad token" errors
+	// in recovery mode, assuming that the recovery heuristics have failed
+	// in this case and left the peeker in a wrong place.
+	recovery bool
+}
+
+func (p *parser) ParseBody(end TokenType) (*Body, hcl.Diagnostics) {
+	attrs := Attributes{}
+	blocks := Blocks{}
+	var diags hcl.Diagnostics
+
+	startRange := p.PrevRange()
+	var endRange hcl.Range
+
+Token:
+	for {
+		next := p.Peek()
+		if next.Type == end {
+			endRange = p.NextRange()
+			p.Read()
+			break Token
+		}
+
+		switch next.Type {
+		case TokenNewline:
+			p.Read()
+			continue
+		case TokenIdent:
+			item, itemDiags := p.ParseBodyItem()
+			diags = append(diags, itemDiags...)
+			switch titem := item.(type) {
+			case *Block:
+				blocks = append(blocks, titem)
+			case *Attribute:
+				if existing, exists := attrs[titem.Name]; exists {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Attribute redefined",
+						Detail: fmt.Sprintf(
+							"The argument %q was already set at %s. Each argument may be set only once.",
+							titem.Name, existing.NameRange.String(),
+						),
+						Subject: &titem.NameRange,
+					})
+				} else {
+					attrs[titem.Name] = titem
+				}
+			default:
+				// This should never happen for valid input, but may if a
+				// syntax error was detected in ParseBodyItem that prevented
+				// it from even producing a partially-broken item. In that
+				// case, it would've left at least one error in the diagnostics
+				// slice we already dealt with above.
+				//
+				// We'll assume ParseBodyItem attempted recovery to leave
+				// us in a reasonable position to try parsing the next item.
+				continue
+			}
+		default:
+			bad := p.Read()
+			if !p.recovery {
+				if bad.Type == TokenOQuote {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid argument name",
+						Detail:   "Argument names must not be quoted.",
+						Subject:  &bad.Range,
+					})
+				} else {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Argument or block definition required",
+						Detail:   "An argument or block definition is required here.",
+						Subject:  &bad.Range,
+					})
+				}
+			}
+			endRange = p.PrevRange() // arbitrary, but somewhere inside the body means better diagnostics
+
+			p.recover(end) // attempt to recover to the token after the end of this body
+			break Token
+		}
+	}
+
+	return &Body{
+		Attributes: attrs,
+		Blocks:     blocks,
+
+		SrcRange: hcl.RangeBetween(startRange, endRange),
+		EndRange: hcl.Range{
+			Filename: endRange.Filename,
+			Start:    endRange.End,
+			End:      endRange.End,
+		},
+	}, diags
+}
+
+func (p *parser) ParseBodyItem() (Node, hcl.Diagnostics) {
+	ident := p.Read()
+	if ident.Type != TokenIdent {
+		p.recoverAfterBodyItem()
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Argument or block definition required",
+				Detail:   "An argument or block definition is required here.",
+				Subject:  &ident.Range,
+			},
+		}
+	}
+
+	next := p.Peek()
+
+	switch next.Type {
+	case TokenEqual:
+		return p.finishParsingBodyAttribute(ident, false)
+	case TokenOQuote, TokenOBrace, TokenIdent:
+		return p.finishParsingBodyBlock(ident)
+	default:
+		p.recoverAfterBodyItem()
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Argument or block definition required",
+				Detail:   "An argument or block definition is required here. To set an argument, use the equals sign \"=\" to introduce the argument value.",
+				Subject:  &ident.Range,
+			},
+		}
+	}
+
+	return nil, nil
+}
+
+// parseSingleAttrBody is a weird variant of ParseBody that deals with the
+// body of a nested block containing only one attribute value all on a single
+// line, like foo { bar = baz } . It expects to find a single attribute item
+// immediately followed by the end token type with no intervening newlines.
+func (p *parser) parseSingleAttrBody(end TokenType) (*Body, hcl.Diagnostics) {
+	ident := p.Read()
+	if ident.Type != TokenIdent {
+		p.recoverAfterBodyItem()
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Argument or block definition required",
+				Detail:   "An argument or block definition is required here.",
+				Subject:  &ident.Range,
+			},
+		}
+	}
+
+	var attr *Attribute
+	var diags hcl.Diagnostics
+
+	next := p.Peek()
+
+	switch next.Type {
+	case TokenEqual:
+		node, attrDiags := p.finishParsingBodyAttribute(ident, true)
+		diags = append(diags, attrDiags...)
+		attr = node.(*Attribute)
+	case TokenOQuote, TokenOBrace, TokenIdent:
+		p.recoverAfterBodyItem()
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Argument definition required",
+				Detail:   fmt.Sprintf("A single-line block definition can contain only a single argument. If you meant to define argument %q, use an equals sign to assign it a value. To define a nested block, place it on a line of its own within its parent block.", ident.Bytes),
+				Subject:  hcl.RangeBetween(ident.Range, next.Range).Ptr(),
+			},
+		}
+	default:
+		p.recoverAfterBodyItem()
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Argument or block definition required",
+				Detail:   "An argument or block definition is required here. To set an argument, use the equals sign \"=\" to introduce the argument value.",
+				Subject:  &ident.Range,
+			},
+		}
+	}
+
+	return &Body{
+		Attributes: Attributes{
+			string(ident.Bytes): attr,
+		},
+
+		SrcRange: attr.SrcRange,
+		EndRange: hcl.Range{
+			Filename: attr.SrcRange.Filename,
+			Start:    attr.SrcRange.End,
+			End:      attr.SrcRange.End,
+		},
+	}, diags
+
+}
+
+func (p *parser) finishParsingBodyAttribute(ident Token, singleLine bool) (Node, hcl.Diagnostics) {
+	eqTok := p.Read() // eat equals token
+	if eqTok.Type != TokenEqual {
+		// should never happen if caller behaves
+		panic("finishParsingBodyAttribute called with next not equals")
+	}
+
+	var endRange hcl.Range
+
+	expr, diags := p.ParseExpression()
+	if p.recovery && diags.HasErrors() {
+		// recovery within expressions tends to be tricky, so we've probably
+		// landed somewhere weird. We'll try to reset to the start of a body
+		// item so parsing can continue.
+		endRange = p.PrevRange()
+		p.recoverAfterBodyItem()
+	} else {
+		endRange = p.PrevRange()
+		if !singleLine {
+			end := p.Peek()
+			if end.Type != TokenNewline && end.Type != TokenEOF {
+				if !p.recovery {
+					summary := "Missing newline after argument"
+					detail := "An argument definition must end with a newline."
+
+					if end.Type == TokenComma {
+						summary = "Unexpected comma after argument"
+						detail = "Argument definitions must be separated by newlines, not commas. " + detail
+					}
+
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  summary,
+						Detail:   detail,
+						Subject:  &end.Range,
+						Context:  hcl.RangeBetween(ident.Range, end.Range).Ptr(),
+					})
+				}
+				endRange = p.PrevRange()
+				p.recoverAfterBodyItem()
+			} else {
+				endRange = p.PrevRange()
+				p.Read() // eat newline
+			}
+		}
+	}
+
+	return &Attribute{
+		Name: string(ident.Bytes),
+		Expr: expr,
+
+		SrcRange:    hcl.RangeBetween(ident.Range, endRange),
+		NameRange:   ident.Range,
+		EqualsRange: eqTok.Range,
+	}, diags
+}
+
+func (p *parser) finishParsingBodyBlock(ident Token) (Node, hcl.Diagnostics) {
+	var blockType = string(ident.Bytes)
+	var diags hcl.Diagnostics
+	var labels []string
+	var labelRanges []hcl.Range
+
+	var oBrace Token
+
+Token:
+	for {
+		tok := p.Peek()
+
+		switch tok.Type {
+
+		case TokenOBrace:
+			oBrace = p.Read()
+			break Token
+
+		case TokenOQuote:
+			label, labelRange, labelDiags := p.parseQuotedStringLiteral()
+			diags = append(diags, labelDiags...)
+			labels = append(labels, label)
+			labelRanges = append(labelRanges, labelRange)
+			// parseQuoteStringLiteral recovers up to the closing quote
+			// if it encounters problems, so we can continue looking for
+			// more labels and eventually the block body even.
+
+		case TokenIdent:
+			tok = p.Read() // eat token
+			label, labelRange := string(tok.Bytes), tok.Range
+			labels = append(labels, label)
+			labelRanges = append(labelRanges, labelRange)
+
+		default:
+			switch tok.Type {
+			case TokenEqual:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid block definition",
+					Detail:   "The equals sign \"=\" indicates an argument definition, and must not be used when defining a block.",
+					Subject:  &tok.Range,
+					Context:  hcl.RangeBetween(ident.Range, tok.Range).Ptr(),
+				})
+			case TokenNewline:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid block definition",
+					Detail:   "A block definition must have block content delimited by \"{\" and \"}\", starting on the same line as the block header.",
+					Subject:  &tok.Range,
+					Context:  hcl.RangeBetween(ident.Range, tok.Range).Ptr(),
+				})
+			default:
+				if !p.recovery {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid block definition",
+						Detail:   "Either a quoted string block label or an opening brace (\"{\") is expected here.",
+						Subject:  &tok.Range,
+						Context:  hcl.RangeBetween(ident.Range, tok.Range).Ptr(),
+					})
+				}
+			}
+
+			p.recoverAfterBodyItem()
+
+			return &Block{
+				Type:   blockType,
+				Labels: labels,
+				Body: &Body{
+					SrcRange: ident.Range,
+					EndRange: ident.Range,
+				},
+
+				TypeRange:       ident.Range,
+				LabelRanges:     labelRanges,
+				OpenBraceRange:  ident.Range, // placeholder
+				CloseBraceRange: ident.Range, // placeholder
+			}, diags
+		}
+	}
+
+	// Once we fall out here, the peeker is pointed just after our opening
+	// brace, so we can begin our nested body parsing.
+	var body *Body
+	var bodyDiags hcl.Diagnostics
+	switch p.Peek().Type {
+	case TokenNewline, TokenEOF, TokenCBrace:
+		body, bodyDiags = p.ParseBody(TokenCBrace)
+	default:
+		// Special one-line, single-attribute block parsing mode.
+		body, bodyDiags = p.parseSingleAttrBody(TokenCBrace)
+		switch p.Peek().Type {
+		case TokenCBrace:
+			p.Read() // the happy path - just consume the closing brace
+		case TokenComma:
+			// User seems to be trying to use the object-constructor
+			// comma-separated style, which isn't permitted for blocks.
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid single-argument block definition",
+				Detail:   "Single-line block syntax can include only one argument definition. To define multiple arguments, use the multi-line block syntax with one argument definition per line.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+			p.recover(TokenCBrace)
+		case TokenNewline:
+			// We don't allow weird mixtures of single and multi-line syntax.
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid single-argument block definition",
+				Detail:   "An argument definition on the same line as its containing block creates a single-line block definition, which must also be closed on the same line. Place the block's closing brace immediately after the argument definition.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+			p.recover(TokenCBrace)
+		default:
+			// Some other weird thing is going on. Since we can't guess a likely
+			// user intent for this one, we'll skip it if we're already in
+			// recovery mode.
+			if !p.recovery {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid single-argument block definition",
+					Detail:   "A single-line block definition must end with a closing brace immediately after its single argument definition.",
+					Subject:  p.Peek().Range.Ptr(),
+				})
+			}
+			p.recover(TokenCBrace)
+		}
+	}
+	diags = append(diags, bodyDiags...)
+	cBraceRange := p.PrevRange()
+
+	eol := p.Peek()
+	if eol.Type == TokenNewline || eol.Type == TokenEOF {
+		p.Read() // eat newline
+	} else {
+		if !p.recovery {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing newline after block definition",
+				Detail:   "A block definition must end with a newline.",
+				Subject:  &eol.Range,
+				Context:  hcl.RangeBetween(ident.Range, eol.Range).Ptr(),
+			})
+		}
+		p.recoverAfterBodyItem()
+	}
+
+	// We must never produce a nil body, since the caller may attempt to
+	// do analysis of a partial result when there's an error, so we'll
+	// insert a placeholder if we otherwise failed to produce a valid
+	// body due to one of the syntax error paths above.
+	if body == nil && diags.HasErrors() {
+		body = &Body{
+			SrcRange: hcl.RangeBetween(oBrace.Range, cBraceRange),
+			EndRange: cBraceRange,
+		}
+	}
+
+	return &Block{
+		Type:   blockType,
+		Labels: labels,
+		Body:   body,
+
+		TypeRange:       ident.Range,
+		LabelRanges:     labelRanges,
+		OpenBraceRange:  oBrace.Range,
+		CloseBraceRange: cBraceRange,
+	}, diags
+}
+
+func (p *parser) ParseExpression() (Expression, hcl.Diagnostics) {
+	return p.parseTernaryConditional()
+}
+
+func (p *parser) parseTernaryConditional() (Expression, hcl.Diagnostics) {
+	// The ternary conditional operator (.. ? .. : ..) behaves somewhat
+	// like a binary operator except that the "symbol" is itself
+	// an expression enclosed in two punctuation characters.
+	// The middle expression is parsed as if the ? and : symbols
+	// were parentheses. The "rhs" (the "false expression") is then
+	// treated right-associatively so it behaves similarly to the
+	// middle in terms of precedence.
+
+	startRange := p.NextRange()
+	var condExpr, trueExpr, falseExpr Expression
+	var diags hcl.Diagnostics
+
+	condExpr, condDiags := p.parseBinaryOps(binaryOps)
+	diags = append(diags, condDiags...)
+	if p.recovery && condDiags.HasErrors() {
+		return condExpr, diags
+	}
+
+	questionMark := p.Peek()
+	if questionMark.Type != TokenQuestion {
+		return condExpr, diags
+	}
+
+	p.Read() // eat question mark
+
+	trueExpr, trueDiags := p.ParseExpression()
+	diags = append(diags, trueDiags...)
+	if p.recovery && trueDiags.HasErrors() {
+		return condExpr, diags
+	}
+
+	colon := p.Peek()
+	if colon.Type != TokenColon {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Missing false expression in conditional",
+			Detail:   "The conditional operator (...?...:...) requires a false expression, delimited by a colon.",
+			Subject:  &colon.Range,
+			Context:  hcl.RangeBetween(startRange, colon.Range).Ptr(),
+		})
+		return condExpr, diags
+	}
+
+	p.Read() // eat colon
+
+	falseExpr, falseDiags := p.ParseExpression()
+	diags = append(diags, falseDiags...)
+	if p.recovery && falseDiags.HasErrors() {
+		return condExpr, diags
+	}
+
+	return &ConditionalExpr{
+		Condition:   condExpr,
+		TrueResult:  trueExpr,
+		FalseResult: falseExpr,
+
+		SrcRange: hcl.RangeBetween(startRange, falseExpr.Range()),
+	}, diags
+}
+
+// parseBinaryOps calls itself recursively to work through all of the
+// operator precedence groups, and then eventually calls parseExpressionTerm
+// for each operand.
+func (p *parser) parseBinaryOps(ops []map[TokenType]*Operation) (Expression, hcl.Diagnostics) {
+	if len(ops) == 0 {
+		// We've run out of operators, so now we'll just try to parse a term.
+		return p.parseExpressionWithTraversals()
+	}
+
+	thisLevel := ops[0]
+	remaining := ops[1:]
+
+	var lhs, rhs Expression
+	var operation *Operation
+	var diags hcl.Diagnostics
+
+	// Parse a term that might be the first operand of a binary
+	// operation or it might just be a standalone term.
+	// We won't know until we've parsed it and can look ahead
+	// to see if there's an operator token for this level.
+	lhs, lhsDiags := p.parseBinaryOps(remaining)
+	diags = append(diags, lhsDiags...)
+	if p.recovery && lhsDiags.HasErrors() {
+		return lhs, diags
+	}
+
+	// We'll keep eating up operators until we run out, so that operators
+	// with the same precedence will combine in a left-associative manner:
+	// a+b+c => (a+b)+c, not a+(b+c)
+	//
+	// Should we later want to have right-associative operators, a way
+	// to achieve that would be to call back up to ParseExpression here
+	// instead of iteratively parsing only the remaining operators.
+	for {
+		next := p.Peek()
+		var newOp *Operation
+		var ok bool
+		if newOp, ok = thisLevel[next.Type]; !ok {
+			break
+		}
+
+		// Are we extending an expression started on the previous iteration?
+		if operation != nil {
+			lhs = &BinaryOpExpr{
+				LHS: lhs,
+				Op:  operation,
+				RHS: rhs,
+
+				SrcRange: hcl.RangeBetween(lhs.Range(), rhs.Range()),
+			}
+		}
+
+		operation = newOp
+		p.Read() // eat operator token
+		var rhsDiags hcl.Diagnostics
+		rhs, rhsDiags = p.parseBinaryOps(remaining)
+		diags = append(diags, rhsDiags...)
+		if p.recovery && rhsDiags.HasErrors() {
+			return lhs, diags
+		}
+	}
+
+	if operation == nil {
+		return lhs, diags
+	}
+
+	return &BinaryOpExpr{
+		LHS: lhs,
+		Op:  operation,
+		RHS: rhs,
+
+		SrcRange: hcl.RangeBetween(lhs.Range(), rhs.Range()),
+	}, diags
+}
+
+func (p *parser) parseExpressionWithTraversals() (Expression, hcl.Diagnostics) {
+	term, diags := p.parseExpressionTerm()
+	ret, moreDiags := p.parseExpressionTraversals(term)
+	diags = append(diags, moreDiags...)
+	return ret, diags
+}
+
+func (p *parser) parseExpressionTraversals(from Expression) (Expression, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+	ret := from
+
+Traversal:
+	for {
+		next := p.Peek()
+
+		switch next.Type {
+		case TokenDot:
+			// Attribute access or splat
+			dot := p.Read()
+			attrTok := p.Peek()
+
+			switch attrTok.Type {
+			case TokenIdent:
+				attrTok = p.Read() // eat token
+				name := string(attrTok.Bytes)
+				rng := hcl.RangeBetween(dot.Range, attrTok.Range)
+				step := hcl.TraverseAttr{
+					Name:     name,
+					SrcRange: rng,
+				}
+
+				ret = makeRelativeTraversal(ret, step, rng)
+
+			case TokenNumberLit:
+				// This is a weird form we inherited from HIL, allowing numbers
+				// to be used as attributes as a weird way of writing [n].
+				// This was never actually a first-class thing in HIL, but
+				// HIL tolerated sequences like .0. in its variable names and
+				// calling applications like Terraform exploited that to
+				// introduce indexing syntax where none existed.
+				numTok := p.Read() // eat token
+				attrTok = numTok
+
+				// This syntax is ambiguous if multiple indices are used in
+				// succession, like foo.0.1.baz: that actually parses as
+				// a fractional number 0.1. Since we're only supporting this
+				// syntax for compatibility with legacy Terraform
+				// configurations, and Terraform does not tend to have lists
+				// of lists, we'll choose to reject that here with a helpful
+				// error message, rather than failing later because the index
+				// isn't a whole number.
+				if dotIdx := bytes.IndexByte(numTok.Bytes, '.'); dotIdx >= 0 {
+					first := numTok.Bytes[:dotIdx]
+					second := numTok.Bytes[dotIdx+1:]
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid legacy index syntax",
+						Detail:   fmt.Sprintf("When using the legacy index syntax, chaining two indexes together is not permitted. Use the proper index syntax instead, like [%s][%s].", first, second),
+						Subject:  &attrTok.Range,
+					})
+					rng := hcl.RangeBetween(dot.Range, numTok.Range)
+					step := hcl.TraverseIndex{
+						Key:      cty.DynamicVal,
+						SrcRange: rng,
+					}
+					ret = makeRelativeTraversal(ret, step, rng)
+					break
+				}
+
+				numVal, numDiags := p.numberLitValue(numTok)
+				diags = append(diags, numDiags...)
+
+				rng := hcl.RangeBetween(dot.Range, numTok.Range)
+				step := hcl.TraverseIndex{
+					Key:      numVal,
+					SrcRange: rng,
+				}
+
+				ret = makeRelativeTraversal(ret, step, rng)
+
+			case TokenStar:
+				// "Attribute-only" splat expression.
+				// (This is a kinda weird construct inherited from HIL, which
+				// behaves a bit like a [*] splat except that it is only able
+				// to do attribute traversals into each of its elements,
+				// whereas foo[*] can support _any_ traversal.
+				marker := p.Read() // eat star
+				trav := make(hcl.Traversal, 0, 1)
+				var firstRange, lastRange hcl.Range
+				firstRange = p.NextRange()
+				for p.Peek().Type == TokenDot {
+					dot := p.Read()
+
+					if p.Peek().Type == TokenNumberLit {
+						// Continuing the "weird stuff inherited from HIL"
+						// theme, we also allow numbers as attribute names
+						// inside splats and interpret them as indexing
+						// into a list, for expressions like:
+						// foo.bar.*.baz.0.foo
+						numTok := p.Read()
+
+						// Weird special case if the user writes something
+						// like foo.bar.*.baz.0.0.foo, where 0.0 parses
+						// as a number.
+						if dotIdx := bytes.IndexByte(numTok.Bytes, '.'); dotIdx >= 0 {
+							first := numTok.Bytes[:dotIdx]
+							second := numTok.Bytes[dotIdx+1:]
+							diags = append(diags, &hcl.Diagnostic{
+								Severity: hcl.DiagError,
+								Summary:  "Invalid legacy index syntax",
+								Detail:   fmt.Sprintf("When using the legacy index syntax, chaining two indexes together is not permitted. Use the proper index syntax with a full splat expression [*] instead, like [%s][%s].", first, second),
+								Subject:  &attrTok.Range,
+							})
+							trav = append(trav, hcl.TraverseIndex{
+								Key:      cty.DynamicVal,
+								SrcRange: hcl.RangeBetween(dot.Range, numTok.Range),
+							})
+							lastRange = numTok.Range
+							continue
+						}
+
+						numVal, numDiags := p.numberLitValue(numTok)
+						diags = append(diags, numDiags...)
+						trav = append(trav, hcl.TraverseIndex{
+							Key:      numVal,
+							SrcRange: hcl.RangeBetween(dot.Range, numTok.Range),
+						})
+						lastRange = numTok.Range
+						continue
+					}
+
+					if p.Peek().Type != TokenIdent {
+						if !p.recovery {
+							if p.Peek().Type == TokenStar {
+								diags = append(diags, &hcl.Diagnostic{
+									Severity: hcl.DiagError,
+									Summary:  "Nested splat expression not allowed",
+									Detail:   "A splat expression (*) cannot be used inside another attribute-only splat expression.",
+									Subject:  p.Peek().Range.Ptr(),
+								})
+							} else {
+								diags = append(diags, &hcl.Diagnostic{
+									Severity: hcl.DiagError,
+									Summary:  "Invalid attribute name",
+									Detail:   "An attribute name is required after a dot.",
+									Subject:  &attrTok.Range,
+								})
+							}
+						}
+						p.setRecovery()
+						continue Traversal
+					}
+
+					attrTok := p.Read()
+					trav = append(trav, hcl.TraverseAttr{
+						Name:     string(attrTok.Bytes),
+						SrcRange: hcl.RangeBetween(dot.Range, attrTok.Range),
+					})
+					lastRange = attrTok.Range
+				}
+
+				itemExpr := &AnonSymbolExpr{
+					SrcRange: hcl.RangeBetween(dot.Range, marker.Range),
+				}
+				var travExpr Expression
+				if len(trav) == 0 {
+					travExpr = itemExpr
+				} else {
+					travExpr = &RelativeTraversalExpr{
+						Source:    itemExpr,
+						Traversal: trav,
+						SrcRange:  hcl.RangeBetween(firstRange, lastRange),
+					}
+				}
+
+				ret = &SplatExpr{
+					Source: ret,
+					Each:   travExpr,
+					Item:   itemExpr,
+
+					SrcRange:    hcl.RangeBetween(from.Range(), lastRange),
+					MarkerRange: hcl.RangeBetween(dot.Range, marker.Range),
+				}
+
+			default:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid attribute name",
+					Detail:   "An attribute name is required after a dot.",
+					Subject:  &attrTok.Range,
+				})
+				// This leaves the peeker in a bad place, so following items
+				// will probably be misparsed until we hit something that
+				// allows us to re-sync.
+				//
+				// We will probably need to do something better here eventually
+				// in order to support autocomplete triggered by typing a
+				// period.
+				p.setRecovery()
+			}
+
+		case TokenOBrack:
+			// Indexing of a collection.
+			// This may or may not be a hcl.Traverser, depending on whether
+			// the key value is something constant.
+
+			open := p.Read()
+			switch p.Peek().Type {
+			case TokenStar:
+				// This is a full splat expression, like foo[*], which consumes
+				// the rest of the traversal steps after it using a recursive
+				// call to this function.
+				p.Read() // consume star
+				close := p.Read()
+				if close.Type != TokenCBrack && !p.recovery {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Missing close bracket on splat index",
+						Detail:   "The star for a full splat operator must be immediately followed by a closing bracket (\"]\").",
+						Subject:  &close.Range,
+					})
+					close = p.recover(TokenCBrack)
+				}
+				// Splat expressions use a special "anonymous symbol"  as a
+				// placeholder in an expression to be evaluated once for each
+				// item in the source expression.
+				itemExpr := &AnonSymbolExpr{
+					SrcRange: hcl.RangeBetween(open.Range, close.Range),
+				}
+				// Now we'll recursively call this same function to eat any
+				// remaining traversal steps against the anonymous symbol.
+				travExpr, nestedDiags := p.parseExpressionTraversals(itemExpr)
+				diags = append(diags, nestedDiags...)
+
+				ret = &SplatExpr{
+					Source: ret,
+					Each:   travExpr,
+					Item:   itemExpr,
+
+					SrcRange:    hcl.RangeBetween(from.Range(), travExpr.Range()),
+					MarkerRange: hcl.RangeBetween(open.Range, close.Range),
+				}
+
+			default:
+
+				var close Token
+				p.PushIncludeNewlines(false) // arbitrary newlines allowed in brackets
+				keyExpr, keyDiags := p.ParseExpression()
+				diags = append(diags, keyDiags...)
+				if p.recovery && keyDiags.HasErrors() {
+					close = p.recover(TokenCBrack)
+				} else {
+					close = p.Read()
+					if close.Type != TokenCBrack && !p.recovery {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity: hcl.DiagError,
+							Summary:  "Missing close bracket on index",
+							Detail:   "The index operator must end with a closing bracket (\"]\").",
+							Subject:  &close.Range,
+						})
+						close = p.recover(TokenCBrack)
+					}
+				}
+				p.PopIncludeNewlines()
+
+				if lit, isLit := keyExpr.(*LiteralValueExpr); isLit {
+					litKey, _ := lit.Value(nil)
+					rng := hcl.RangeBetween(open.Range, close.Range)
+					step := hcl.TraverseIndex{
+						Key:      litKey,
+						SrcRange: rng,
+					}
+					ret = makeRelativeTraversal(ret, step, rng)
+				} else if tmpl, isTmpl := keyExpr.(*TemplateExpr); isTmpl && tmpl.IsStringLiteral() {
+					litKey, _ := tmpl.Value(nil)
+					rng := hcl.RangeBetween(open.Range, close.Range)
+					step := hcl.TraverseIndex{
+						Key:      litKey,
+						SrcRange: rng,
+					}
+					ret = makeRelativeTraversal(ret, step, rng)
+				} else {
+					rng := hcl.RangeBetween(open.Range, close.Range)
+					ret = &IndexExpr{
+						Collection: ret,
+						Key:        keyExpr,
+
+						SrcRange:     hcl.RangeBetween(from.Range(), rng),
+						OpenRange:    open.Range,
+						BracketRange: rng,
+					}
+				}
+			}
+
+		default:
+			break Traversal
+		}
+	}
+
+	return ret, diags
+}
+
+// makeRelativeTraversal takes an expression and a traverser and returns
+// a traversal expression that combines the two. If the given expression
+// is already a traversal, it is extended in place (mutating it) and
+// returned. If it isn't, a new RelativeTraversalExpr is created and returned.
+func makeRelativeTraversal(expr Expression, next hcl.Traverser, rng hcl.Range) Expression {
+	switch texpr := expr.(type) {
+	case *ScopeTraversalExpr:
+		texpr.Traversal = append(texpr.Traversal, next)
+		texpr.SrcRange = hcl.RangeBetween(texpr.SrcRange, rng)
+		return texpr
+	case *RelativeTraversalExpr:
+		texpr.Traversal = append(texpr.Traversal, next)
+		texpr.SrcRange = hcl.RangeBetween(texpr.SrcRange, rng)
+		return texpr
+	default:
+		return &RelativeTraversalExpr{
+			Source:    expr,
+			Traversal: hcl.Traversal{next},
+			SrcRange:  hcl.RangeBetween(expr.Range(), rng),
+		}
+	}
+}
+
+func (p *parser) parseExpressionTerm() (Expression, hcl.Diagnostics) {
+	start := p.Peek()
+
+	switch start.Type {
+	case TokenOParen:
+		p.Read() // eat open paren
+
+		p.PushIncludeNewlines(false)
+
+		expr, diags := p.ParseExpression()
+		if diags.HasErrors() {
+			// attempt to place the peeker after our closing paren
+			// before we return, so that the next parser has some
+			// chance of finding a valid expression.
+			p.recover(TokenCParen)
+			p.PopIncludeNewlines()
+			return expr, diags
+		}
+
+		close := p.Peek()
+		if close.Type != TokenCParen {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unbalanced parentheses",
+				Detail:   "Expected a closing parenthesis to terminate the expression.",
+				Subject:  &close.Range,
+				Context:  hcl.RangeBetween(start.Range, close.Range).Ptr(),
+			})
+			p.setRecovery()
+		}
+
+		p.Read() // eat closing paren
+		p.PopIncludeNewlines()
+
+		return expr, diags
+
+	case TokenNumberLit:
+		tok := p.Read() // eat number token
+
+		numVal, diags := p.numberLitValue(tok)
+		return &LiteralValueExpr{
+			Val:      numVal,
+			SrcRange: tok.Range,
+		}, diags
+
+	case TokenIdent:
+		tok := p.Read() // eat identifier token
+
+		if p.Peek().Type == TokenOParen {
+			return p.finishParsingFunctionCall(tok)
+		}
+
+		name := string(tok.Bytes)
+		switch name {
+		case "true":
+			return &LiteralValueExpr{
+				Val:      cty.True,
+				SrcRange: tok.Range,
+			}, nil
+		case "false":
+			return &LiteralValueExpr{
+				Val:      cty.False,
+				SrcRange: tok.Range,
+			}, nil
+		case "null":
+			return &LiteralValueExpr{
+				Val:      cty.NullVal(cty.DynamicPseudoType),
+				SrcRange: tok.Range,
+			}, nil
+		default:
+			return &ScopeTraversalExpr{
+				Traversal: hcl.Traversal{
+					hcl.TraverseRoot{
+						Name:     name,
+						SrcRange: tok.Range,
+					},
+				},
+				SrcRange: tok.Range,
+			}, nil
+		}
+
+	case TokenOQuote, TokenOHeredoc:
+		open := p.Read() // eat opening marker
+		closer := p.oppositeBracket(open.Type)
+		exprs, passthru, _, diags := p.parseTemplateInner(closer, tokenOpensFlushHeredoc(open))
+
+		closeRange := p.PrevRange()
+
+		if passthru {
+			if len(exprs) != 1 {
+				panic("passthru set with len(exprs) != 1")
+			}
+			return &TemplateWrapExpr{
+				Wrapped:  exprs[0],
+				SrcRange: hcl.RangeBetween(open.Range, closeRange),
+			}, diags
+		}
+
+		return &TemplateExpr{
+			Parts:    exprs,
+			SrcRange: hcl.RangeBetween(open.Range, closeRange),
+		}, diags
+
+	case TokenMinus:
+		tok := p.Read() // eat minus token
+
+		// Important to use parseExpressionWithTraversals rather than parseExpression
+		// here, otherwise we can capture a following binary expression into
+		// our negation.
+		// e.g. -46+5 should parse as (-46)+5, not -(46+5)
+		operand, diags := p.parseExpressionWithTraversals()
+		return &UnaryOpExpr{
+			Op:  OpNegate,
+			Val: operand,
+
+			SrcRange:    hcl.RangeBetween(tok.Range, operand.Range()),
+			SymbolRange: tok.Range,
+		}, diags
+
+	case TokenBang:
+		tok := p.Read() // eat bang token
+
+		// Important to use parseExpressionWithTraversals rather than parseExpression
+		// here, otherwise we can capture a following binary expression into
+		// our negation.
+		operand, diags := p.parseExpressionWithTraversals()
+		return &UnaryOpExpr{
+			Op:  OpLogicalNot,
+			Val: operand,
+
+			SrcRange:    hcl.RangeBetween(tok.Range, operand.Range()),
+			SymbolRange: tok.Range,
+		}, diags
+
+	case TokenOBrack:
+		return p.parseTupleCons()
+
+	case TokenOBrace:
+		return p.parseObjectCons()
+
+	default:
+		var diags hcl.Diagnostics
+		if !p.recovery {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid expression",
+				Detail:   "Expected the start of an expression, but found an invalid expression token.",
+				Subject:  &start.Range,
+			})
+		}
+		p.setRecovery()
+
+		// Return a placeholder so that the AST is still structurally sound
+		// even in the presence of parse errors.
+		return &LiteralValueExpr{
+			Val:      cty.DynamicVal,
+			SrcRange: start.Range,
+		}, diags
+	}
+}
+
+func (p *parser) numberLitValue(tok Token) (cty.Value, hcl.Diagnostics) {
+	// The cty.ParseNumberVal is always the same behavior as converting a
+	// string to a number, ensuring we always interpret decimal numbers in
+	// the same way.
+	numVal, err := cty.ParseNumberVal(string(tok.Bytes))
+	if err != nil {
+		ret := cty.UnknownVal(cty.Number)
+		return ret, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid number literal",
+				// FIXME: not a very good error message, but convert only
+				// gives us "a number is required", so not much help either.
+				Detail:  "Failed to recognize the value of this number literal.",
+				Subject: &tok.Range,
+			},
+		}
+	}
+	return numVal, nil
+}
+
+// finishParsingFunctionCall parses a function call assuming that the function
+// name was already read, and so the peeker should be pointing at the opening
+// parenthesis after the name.
+func (p *parser) finishParsingFunctionCall(name Token) (Expression, hcl.Diagnostics) {
+	openTok := p.Read()
+	if openTok.Type != TokenOParen {
+		// should never happen if callers behave
+		panic("finishParsingFunctionCall called with non-parenthesis as next token")
+	}
+
+	var args []Expression
+	var diags hcl.Diagnostics
+	var expandFinal bool
+	var closeTok Token
+
+	// Arbitrary newlines are allowed inside the function call parentheses.
+	p.PushIncludeNewlines(false)
+
+Token:
+	for {
+		tok := p.Peek()
+
+		if tok.Type == TokenCParen {
+			closeTok = p.Read() // eat closing paren
+			break Token
+		}
+
+		arg, argDiags := p.ParseExpression()
+		args = append(args, arg)
+		diags = append(diags, argDiags...)
+		if p.recovery && argDiags.HasErrors() {
+			// if there was a parse error in the argument then we've
+			// probably been left in a weird place in the token stream,
+			// so we'll bail out with a partial argument list.
+			p.recover(TokenCParen)
+			break Token
+		}
+
+		sep := p.Read()
+		if sep.Type == TokenCParen {
+			closeTok = sep
+			break Token
+		}
+
+		if sep.Type == TokenEllipsis {
+			expandFinal = true
+
+			if p.Peek().Type != TokenCParen {
+				if !p.recovery {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Missing closing parenthesis",
+						Detail:   "An expanded function argument (with ...) must be immediately followed by closing parentheses.",
+						Subject:  &sep.Range,
+						Context:  hcl.RangeBetween(name.Range, sep.Range).Ptr(),
+					})
+				}
+				closeTok = p.recover(TokenCParen)
+			} else {
+				closeTok = p.Read() // eat closing paren
+			}
+			break Token
+		}
+
+		if sep.Type != TokenComma {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing argument separator",
+				Detail:   "A comma is required to separate each function argument from the next.",
+				Subject:  &sep.Range,
+				Context:  hcl.RangeBetween(name.Range, sep.Range).Ptr(),
+			})
+			closeTok = p.recover(TokenCParen)
+			break Token
+		}
+
+		if p.Peek().Type == TokenCParen {
+			// A trailing comma after the last argument gets us in here.
+			closeTok = p.Read() // eat closing paren
+			break Token
+		}
+
+	}
+
+	p.PopIncludeNewlines()
+
+	return &FunctionCallExpr{
+		Name: string(name.Bytes),
+		Args: args,
+
+		ExpandFinal: expandFinal,
+
+		NameRange:       name.Range,
+		OpenParenRange:  openTok.Range,
+		CloseParenRange: closeTok.Range,
+	}, diags
+}
+
+func (p *parser) parseTupleCons() (Expression, hcl.Diagnostics) {
+	open := p.Read()
+	if open.Type != TokenOBrack {
+		// Should never happen if callers are behaving
+		panic("parseTupleCons called without peeker pointing to open bracket")
+	}
+
+	p.PushIncludeNewlines(false)
+	defer p.PopIncludeNewlines()
+
+	if forKeyword.TokenMatches(p.Peek()) {
+		return p.finishParsingForExpr(open)
+	}
+
+	var close Token
+
+	var diags hcl.Diagnostics
+	var exprs []Expression
+
+	for {
+		next := p.Peek()
+		if next.Type == TokenCBrack {
+			close = p.Read() // eat closer
+			break
+		}
+
+		expr, exprDiags := p.ParseExpression()
+		exprs = append(exprs, expr)
+		diags = append(diags, exprDiags...)
+
+		if p.recovery && exprDiags.HasErrors() {
+			// If expression parsing failed then we are probably in a strange
+			// place in the token stream, so we'll bail out and try to reset
+			// to after our closing bracket to allow parsing to continue.
+			close = p.recover(TokenCBrack)
+			break
+		}
+
+		next = p.Peek()
+		if next.Type == TokenCBrack {
+			close = p.Read() // eat closer
+			break
+		}
+
+		if next.Type != TokenComma {
+			if !p.recovery {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Missing item separator",
+					Detail:   "Expected a comma to mark the beginning of the next item.",
+					Subject:  &next.Range,
+					Context:  hcl.RangeBetween(open.Range, next.Range).Ptr(),
+				})
+			}
+			close = p.recover(TokenCBrack)
+			break
+		}
+
+		p.Read() // eat comma
+
+	}
+
+	return &TupleConsExpr{
+		Exprs: exprs,
+
+		SrcRange:  hcl.RangeBetween(open.Range, close.Range),
+		OpenRange: open.Range,
+	}, diags
+}
+
+func (p *parser) parseObjectCons() (Expression, hcl.Diagnostics) {
+	open := p.Read()
+	if open.Type != TokenOBrace {
+		// Should never happen if callers are behaving
+		panic("parseObjectCons called without peeker pointing to open brace")
+	}
+
+	// We must temporarily stop looking at newlines here while we check for
+	// a "for" keyword, since for expressions are _not_ newline-sensitive,
+	// even though object constructors are.
+	p.PushIncludeNewlines(false)
+	isFor := forKeyword.TokenMatches(p.Peek())
+	p.PopIncludeNewlines()
+	if isFor {
+		return p.finishParsingForExpr(open)
+	}
+
+	p.PushIncludeNewlines(true)
+	defer p.PopIncludeNewlines()
+
+	var close Token
+
+	var diags hcl.Diagnostics
+	var items []ObjectConsItem
+
+	for {
+		next := p.Peek()
+		if next.Type == TokenNewline {
+			p.Read() // eat newline
+			continue
+		}
+
+		if next.Type == TokenCBrace {
+			close = p.Read() // eat closer
+			break
+		}
+
+		// Wrapping parens are not explicitly represented in the AST, but
+		// we want to use them here to disambiguate intepreting a mapping
+		// key as a full expression rather than just a name, and so
+		// we'll remember this was present and use it to force the
+		// behavior of our final ObjectConsKeyExpr.
+		forceNonLiteral := (p.Peek().Type == TokenOParen)
+
+		var key Expression
+		var keyDiags hcl.Diagnostics
+		key, keyDiags = p.ParseExpression()
+		diags = append(diags, keyDiags...)
+
+		if p.recovery && keyDiags.HasErrors() {
+			// If expression parsing failed then we are probably in a strange
+			// place in the token stream, so we'll bail out and try to reset
+			// to after our closing brace to allow parsing to continue.
+			close = p.recover(TokenCBrace)
+			break
+		}
+
+		// We wrap up the key expression in a special wrapper that deals
+		// with our special case that naked identifiers as object keys
+		// are interpreted as literal strings.
+		key = &ObjectConsKeyExpr{
+			Wrapped:         key,
+			ForceNonLiteral: forceNonLiteral,
+		}
+
+		next = p.Peek()
+		if next.Type != TokenEqual && next.Type != TokenColon {
+			if !p.recovery {
+				switch next.Type {
+				case TokenNewline, TokenComma:
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Missing attribute value",
+						Detail:   "Expected an attribute value, introduced by an equals sign (\"=\").",
+						Subject:  &next.Range,
+						Context:  hcl.RangeBetween(open.Range, next.Range).Ptr(),
+					})
+				case TokenIdent:
+					// Although this might just be a plain old missing equals
+					// sign before a reference, one way to get here is to try
+					// to write an attribute name containing a period followed
+					// by a digit, which was valid in HCL1, like this:
+					//     foo1.2_bar = "baz"
+					// We can't know exactly what the user intended here, but
+					// we'll augment our message with an extra hint in this case
+					// in case it is helpful.
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Missing key/value separator",
+						Detail:   "Expected an equals sign (\"=\") to mark the beginning of the attribute value. If you intended to given an attribute name containing periods or spaces, write the name in quotes to create a string literal.",
+						Subject:  &next.Range,
+						Context:  hcl.RangeBetween(open.Range, next.Range).Ptr(),
+					})
+				default:
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Missing key/value separator",
+						Detail:   "Expected an equals sign (\"=\") to mark the beginning of the attribute value.",
+						Subject:  &next.Range,
+						Context:  hcl.RangeBetween(open.Range, next.Range).Ptr(),
+					})
+				}
+			}
+			close = p.recover(TokenCBrace)
+			break
+		}
+
+		p.Read() // eat equals sign or colon
+
+		value, valueDiags := p.ParseExpression()
+		diags = append(diags, valueDiags...)
+
+		if p.recovery && valueDiags.HasErrors() {
+			// If expression parsing failed then we are probably in a strange
+			// place in the token stream, so we'll bail out and try to reset
+			// to after our closing brace to allow parsing to continue.
+			close = p.recover(TokenCBrace)
+			break
+		}
+
+		items = append(items, ObjectConsItem{
+			KeyExpr:   key,
+			ValueExpr: value,
+		})
+
+		next = p.Peek()
+		if next.Type == TokenCBrace {
+			close = p.Read() // eat closer
+			break
+		}
+
+		if next.Type != TokenComma && next.Type != TokenNewline {
+			if !p.recovery {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Missing attribute separator",
+					Detail:   "Expected a newline or comma to mark the beginning of the next attribute.",
+					Subject:  &next.Range,
+					Context:  hcl.RangeBetween(open.Range, next.Range).Ptr(),
+				})
+			}
+			close = p.recover(TokenCBrace)
+			break
+		}
+
+		p.Read() // eat comma or newline
+
+	}
+
+	return &ObjectConsExpr{
+		Items: items,
+
+		SrcRange:  hcl.RangeBetween(open.Range, close.Range),
+		OpenRange: open.Range,
+	}, diags
+}
+
+func (p *parser) finishParsingForExpr(open Token) (Expression, hcl.Diagnostics) {
+	p.PushIncludeNewlines(false)
+	defer p.PopIncludeNewlines()
+	introducer := p.Read()
+	if !forKeyword.TokenMatches(introducer) {
+		// Should never happen if callers are behaving
+		panic("finishParsingForExpr called without peeker pointing to 'for' identifier")
+	}
+
+	var makeObj bool
+	var closeType TokenType
+	switch open.Type {
+	case TokenOBrace:
+		makeObj = true
+		closeType = TokenCBrace
+	case TokenOBrack:
+		makeObj = false // making a tuple
+		closeType = TokenCBrack
+	default:
+		// Should never happen if callers are behaving
+		panic("finishParsingForExpr called with invalid open token")
+	}
+
+	var diags hcl.Diagnostics
+	var keyName, valName string
+
+	if p.Peek().Type != TokenIdent {
+		if !p.recovery {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "For expression requires variable name after 'for'.",
+				Subject:  p.Peek().Range.Ptr(),
+				Context:  hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(),
+			})
+		}
+		close := p.recover(closeType)
+		return &LiteralValueExpr{
+			Val:      cty.DynamicVal,
+			SrcRange: hcl.RangeBetween(open.Range, close.Range),
+		}, diags
+	}
+
+	valName = string(p.Read().Bytes)
+
+	if p.Peek().Type == TokenComma {
+		// What we just read was actually the key, then.
+		keyName = valName
+		p.Read() // eat comma
+
+		if p.Peek().Type != TokenIdent {
+			if !p.recovery {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid 'for' expression",
+					Detail:   "For expression requires value variable name after comma.",
+					Subject:  p.Peek().Range.Ptr(),
+					Context:  hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(),
+				})
+			}
+			close := p.recover(closeType)
+			return &LiteralValueExpr{
+				Val:      cty.DynamicVal,
+				SrcRange: hcl.RangeBetween(open.Range, close.Range),
+			}, diags
+		}
+
+		valName = string(p.Read().Bytes)
+	}
+
+	if !inKeyword.TokenMatches(p.Peek()) {
+		if !p.recovery {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "For expression requires the 'in' keyword after its name declarations.",
+				Subject:  p.Peek().Range.Ptr(),
+				Context:  hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(),
+			})
+		}
+		close := p.recover(closeType)
+		return &LiteralValueExpr{
+			Val:      cty.DynamicVal,
+			SrcRange: hcl.RangeBetween(open.Range, close.Range),
+		}, diags
+	}
+	p.Read() // eat 'in' keyword
+
+	collExpr, collDiags := p.ParseExpression()
+	diags = append(diags, collDiags...)
+	if p.recovery && collDiags.HasErrors() {
+		close := p.recover(closeType)
+		return &LiteralValueExpr{
+			Val:      cty.DynamicVal,
+			SrcRange: hcl.RangeBetween(open.Range, close.Range),
+		}, diags
+	}
+
+	if p.Peek().Type != TokenColon {
+		if !p.recovery {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "For expression requires a colon after the collection expression.",
+				Subject:  p.Peek().Range.Ptr(),
+				Context:  hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(),
+			})
+		}
+		close := p.recover(closeType)
+		return &LiteralValueExpr{
+			Val:      cty.DynamicVal,
+			SrcRange: hcl.RangeBetween(open.Range, close.Range),
+		}, diags
+	}
+	p.Read() // eat colon
+
+	var keyExpr, valExpr Expression
+	var keyDiags, valDiags hcl.Diagnostics
+	valExpr, valDiags = p.ParseExpression()
+	if p.Peek().Type == TokenFatArrow {
+		// What we just parsed was actually keyExpr
+		p.Read() // eat the fat arrow
+		keyExpr, keyDiags = valExpr, valDiags
+
+		valExpr, valDiags = p.ParseExpression()
+	}
+	diags = append(diags, keyDiags...)
+	diags = append(diags, valDiags...)
+	if p.recovery && (keyDiags.HasErrors() || valDiags.HasErrors()) {
+		close := p.recover(closeType)
+		return &LiteralValueExpr{
+			Val:      cty.DynamicVal,
+			SrcRange: hcl.RangeBetween(open.Range, close.Range),
+		}, diags
+	}
+
+	group := false
+	var ellipsis Token
+	if p.Peek().Type == TokenEllipsis {
+		ellipsis = p.Read()
+		group = true
+	}
+
+	var condExpr Expression
+	var condDiags hcl.Diagnostics
+	if ifKeyword.TokenMatches(p.Peek()) {
+		p.Read() // eat "if"
+		condExpr, condDiags = p.ParseExpression()
+		diags = append(diags, condDiags...)
+		if p.recovery && condDiags.HasErrors() {
+			close := p.recover(p.oppositeBracket(open.Type))
+			return &LiteralValueExpr{
+				Val:      cty.DynamicVal,
+				SrcRange: hcl.RangeBetween(open.Range, close.Range),
+			}, diags
+		}
+	}
+
+	var close Token
+	if p.Peek().Type == closeType {
+		close = p.Read()
+	} else {
+		if !p.recovery {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "Extra characters after the end of the 'for' expression.",
+				Subject:  p.Peek().Range.Ptr(),
+				Context:  hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(),
+			})
+		}
+		close = p.recover(closeType)
+	}
+
+	if !makeObj {
+		if keyExpr != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "Key expression is not valid when building a tuple.",
+				Subject:  keyExpr.Range().Ptr(),
+				Context:  hcl.RangeBetween(open.Range, close.Range).Ptr(),
+			})
+		}
+
+		if group {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "Grouping ellipsis (...) cannot be used when building a tuple.",
+				Subject:  &ellipsis.Range,
+				Context:  hcl.RangeBetween(open.Range, close.Range).Ptr(),
+			})
+		}
+	} else {
+		if keyExpr == nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "Key expression is required when building an object.",
+				Subject:  valExpr.Range().Ptr(),
+				Context:  hcl.RangeBetween(open.Range, close.Range).Ptr(),
+			})
+		}
+	}
+
+	return &ForExpr{
+		KeyVar:   keyName,
+		ValVar:   valName,
+		CollExpr: collExpr,
+		KeyExpr:  keyExpr,
+		ValExpr:  valExpr,
+		CondExpr: condExpr,
+		Group:    group,
+
+		SrcRange:   hcl.RangeBetween(open.Range, close.Range),
+		OpenRange:  open.Range,
+		CloseRange: close.Range,
+	}, diags
+}
+
+// parseQuotedStringLiteral is a helper for parsing quoted strings that
+// aren't allowed to contain any interpolations, such as block labels.
+func (p *parser) parseQuotedStringLiteral() (string, hcl.Range, hcl.Diagnostics) {
+	oQuote := p.Read()
+	if oQuote.Type != TokenOQuote {
+		return "", oQuote.Range, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid string literal",
+				Detail:   "A quoted string is required here.",
+				Subject:  &oQuote.Range,
+			},
+		}
+	}
+
+	var diags hcl.Diagnostics
+	ret := &bytes.Buffer{}
+	var cQuote Token
+
+Token:
+	for {
+		tok := p.Read()
+		switch tok.Type {
+
+		case TokenCQuote:
+			cQuote = tok
+			break Token
+
+		case TokenQuotedLit:
+			s, sDiags := ParseStringLiteralToken(tok)
+			diags = append(diags, sDiags...)
+			ret.WriteString(s)
+
+		case TokenTemplateControl, TokenTemplateInterp:
+			which := "$"
+			if tok.Type == TokenTemplateControl {
+				which = "%"
+			}
+
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid string literal",
+				Detail: fmt.Sprintf(
+					"Template sequences are not allowed in this string. To include a literal %q, double it (as \"%s%s\") to escape it.",
+					which, which, which,
+				),
+				Subject: &tok.Range,
+				Context: hcl.RangeBetween(oQuote.Range, tok.Range).Ptr(),
+			})
+
+			// Now that we're returning an error callers won't attempt to use
+			// the result for any real operations, but they might try to use
+			// the partial AST for other analyses, so we'll leave a marker
+			// to indicate that there was something invalid in the string to
+			// help avoid misinterpretation of the partial result
+			ret.WriteString(which)
+			ret.WriteString("{ ... }")
+
+			p.recover(TokenTemplateSeqEnd) // we'll try to keep parsing after the sequence ends
+
+		case TokenEOF:
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unterminated string literal",
+				Detail:   "Unable to find the closing quote mark before the end of the file.",
+				Subject:  &tok.Range,
+				Context:  hcl.RangeBetween(oQuote.Range, tok.Range).Ptr(),
+			})
+			break Token
+
+		default:
+			// Should never happen, as long as the scanner is behaving itself
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid string literal",
+				Detail:   "This item is not valid in a string literal.",
+				Subject:  &tok.Range,
+				Context:  hcl.RangeBetween(oQuote.Range, tok.Range).Ptr(),
+			})
+			p.recover(TokenCQuote)
+			break Token
+
+		}
+
+	}
+
+	return ret.String(), hcl.RangeBetween(oQuote.Range, cQuote.Range), diags
+}
+
+// ParseStringLiteralToken processes the given token, which must be either a
+// TokenQuotedLit or a TokenStringLit, returning the string resulting from
+// resolving any escape sequences.
+//
+// If any error diagnostics are returned, the returned string may be incomplete
+// or otherwise invalid.
+func ParseStringLiteralToken(tok Token) (string, hcl.Diagnostics) {
+	var quoted bool
+	switch tok.Type {
+	case TokenQuotedLit:
+		quoted = true
+	case TokenStringLit:
+		quoted = false
+	default:
+		panic("ParseStringLiteralToken can only be used with TokenStringLit and TokenQuotedLit tokens")
+	}
+	var diags hcl.Diagnostics
+
+	ret := make([]byte, 0, len(tok.Bytes))
+	slices := scanStringLit(tok.Bytes, quoted)
+
+	// We will mutate rng constantly as we walk through our token slices below.
+	// Any diagnostics must take a copy of this rng rather than simply pointing
+	// to it, e.g. by using rng.Ptr() rather than &rng.
+	rng := tok.Range
+	rng.End = rng.Start
+
+Slices:
+	for _, slice := range slices {
+		if len(slice) == 0 {
+			continue
+		}
+
+		// Advance the start of our range to where the previous token ended
+		rng.Start = rng.End
+
+		// Advance the end of our range to after our token.
+		b := slice
+		for len(b) > 0 {
+			adv, ch, _ := textseg.ScanGraphemeClusters(b, true)
+			rng.End.Byte += adv
+			switch ch[0] {
+			case '\r', '\n':
+				rng.End.Line++
+				rng.End.Column = 1
+			default:
+				rng.End.Column++
+			}
+			b = b[adv:]
+		}
+
+	TokenType:
+		switch slice[0] {
+		case '\\':
+			if !quoted {
+				// If we're not in quoted mode then just treat this token as
+				// normal. (Slices can still start with backslash even if we're
+				// not specifically looking for backslash sequences.)
+				break TokenType
+			}
+			if len(slice) < 2 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid escape sequence",
+					Detail:   "Backslash must be followed by an escape sequence selector character.",
+					Subject:  rng.Ptr(),
+				})
+				break TokenType
+			}
+
+			switch slice[1] {
+
+			case 'n':
+				ret = append(ret, '\n')
+				continue Slices
+			case 'r':
+				ret = append(ret, '\r')
+				continue Slices
+			case 't':
+				ret = append(ret, '\t')
+				continue Slices
+			case '"':
+				ret = append(ret, '"')
+				continue Slices
+			case '\\':
+				ret = append(ret, '\\')
+				continue Slices
+			case 'u', 'U':
+				if slice[1] == 'u' && len(slice) != 6 {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid escape sequence",
+						Detail:   "The \\u escape sequence must be followed by four hexadecimal digits.",
+						Subject:  rng.Ptr(),
+					})
+					break TokenType
+				} else if slice[1] == 'U' && len(slice) != 10 {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid escape sequence",
+						Detail:   "The \\U escape sequence must be followed by eight hexadecimal digits.",
+						Subject:  rng.Ptr(),
+					})
+					break TokenType
+				}
+
+				numHex := string(slice[2:])
+				num, err := strconv.ParseUint(numHex, 16, 32)
+				if err != nil {
+					// Should never happen because the scanner won't match
+					// a sequence of digits that isn't valid.
+					panic(err)
+				}
+
+				r := rune(num)
+				l := utf8.RuneLen(r)
+				if l == -1 {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid escape sequence",
+						Detail:   fmt.Sprintf("Cannot encode character U+%04x in UTF-8.", num),
+						Subject:  rng.Ptr(),
+					})
+					break TokenType
+				}
+				for i := 0; i < l; i++ {
+					ret = append(ret, 0)
+				}
+				rb := ret[len(ret)-l:]
+				utf8.EncodeRune(rb, r)
+
+				continue Slices
+
+			default:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid escape sequence",
+					Detail:   fmt.Sprintf("The symbol %q is not a valid escape sequence selector.", slice[1:]),
+					Subject:  rng.Ptr(),
+				})
+				ret = append(ret, slice[1:]...)
+				continue Slices
+			}
+
+		case '$', '%':
+			if len(slice) != 3 {
+				// Not long enough to be our escape sequence, so it's literal.
+				break TokenType
+			}
+
+			if slice[1] == slice[0] && slice[2] == '{' {
+				ret = append(ret, slice[0])
+				ret = append(ret, '{')
+				continue Slices
+			}
+
+			break TokenType
+		}
+
+		// If we fall out here or break out of here from the switch above
+		// then this slice is just a literal.
+		ret = append(ret, slice...)
+	}
+
+	return string(ret), diags
+}
+
+// setRecovery turns on recovery mode without actually doing any recovery.
+// This can be used when a parser knowingly leaves the peeker in a useless
+// place and wants to suppress errors that might result from that decision.
+func (p *parser) setRecovery() {
+	p.recovery = true
+}
+
+// recover seeks forward in the token stream until it finds TokenType "end",
+// then returns with the peeker pointed at the following token.
+//
+// If the given token type is a bracketer, this function will additionally
+// count nested instances of the brackets to try to leave the peeker at
+// the end of the _current_ instance of that bracketer, skipping over any
+// nested instances. This is a best-effort operation and may have
+// unpredictable results on input with bad bracketer nesting.
+func (p *parser) recover(end TokenType) Token {
+	start := p.oppositeBracket(end)
+	p.recovery = true
+
+	nest := 0
+	for {
+		tok := p.Read()
+		ty := tok.Type
+		if end == TokenTemplateSeqEnd && ty == TokenTemplateControl {
+			// normalize so that our matching behavior can work, since
+			// TokenTemplateControl/TokenTemplateInterp are asymmetrical
+			// with TokenTemplateSeqEnd and thus we need to count both
+			// openers if that's the closer we're looking for.
+			ty = TokenTemplateInterp
+		}
+
+		switch ty {
+		case start:
+			nest++
+		case end:
+			if nest < 1 {
+				return tok
+			}
+
+			nest--
+		case TokenEOF:
+			return tok
+		}
+	}
+}
+
+// recoverOver seeks forward in the token stream until it finds a block
+// starting with TokenType "start", then finds the corresponding end token,
+// leaving the peeker pointed at the token after that end token.
+//
+// The given token type _must_ be a bracketer. For example, if the given
+// start token is TokenOBrace then the parser will be left at the _end_ of
+// the next brace-delimited block encountered, or at EOF if no such block
+// is found or it is unclosed.
+func (p *parser) recoverOver(start TokenType) {
+	end := p.oppositeBracket(start)
+
+	// find the opening bracket first
+Token:
+	for {
+		tok := p.Read()
+		switch tok.Type {
+		case start, TokenEOF:
+			break Token
+		}
+	}
+
+	// Now use our existing recover function to locate the _end_ of the
+	// container we've found.
+	p.recover(end)
+}
+
+func (p *parser) recoverAfterBodyItem() {
+	p.recovery = true
+	var open []TokenType
+
+Token:
+	for {
+		tok := p.Read()
+
+		switch tok.Type {
+
+		case TokenNewline:
+			if len(open) == 0 {
+				break Token
+			}
+
+		case TokenEOF:
+			break Token
+
+		case TokenOBrace, TokenOBrack, TokenOParen, TokenOQuote, TokenOHeredoc, TokenTemplateInterp, TokenTemplateControl:
+			open = append(open, tok.Type)
+
+		case TokenCBrace, TokenCBrack, TokenCParen, TokenCQuote, TokenCHeredoc:
+			opener := p.oppositeBracket(tok.Type)
+			for len(open) > 0 && open[len(open)-1] != opener {
+				open = open[:len(open)-1]
+			}
+			if len(open) > 0 {
+				open = open[:len(open)-1]
+			}
+
+		case TokenTemplateSeqEnd:
+			for len(open) > 0 && open[len(open)-1] != TokenTemplateInterp && open[len(open)-1] != TokenTemplateControl {
+				open = open[:len(open)-1]
+			}
+			if len(open) > 0 {
+				open = open[:len(open)-1]
+			}
+
+		}
+	}
+}
+
+// oppositeBracket finds the bracket that opposes the given bracketer, or
+// NilToken if the given token isn't a bracketer.
+//
+// "Bracketer", for the sake of this function, is one end of a matching
+// open/close set of tokens that establish a bracketing context.
+func (p *parser) oppositeBracket(ty TokenType) TokenType {
+	switch ty {
+
+	case TokenOBrace:
+		return TokenCBrace
+	case TokenOBrack:
+		return TokenCBrack
+	case TokenOParen:
+		return TokenCParen
+	case TokenOQuote:
+		return TokenCQuote
+	case TokenOHeredoc:
+		return TokenCHeredoc
+
+	case TokenCBrace:
+		return TokenOBrace
+	case TokenCBrack:
+		return TokenOBrack
+	case TokenCParen:
+		return TokenOParen
+	case TokenCQuote:
+		return TokenOQuote
+	case TokenCHeredoc:
+		return TokenOHeredoc
+
+	case TokenTemplateControl:
+		return TokenTemplateSeqEnd
+	case TokenTemplateInterp:
+		return TokenTemplateSeqEnd
+	case TokenTemplateSeqEnd:
+		// This is ambigous, but we return Interp here because that's
+		// what's assumed by the "recover" method.
+		return TokenTemplateInterp
+
+	default:
+		return TokenNil
+	}
+}
+
+func errPlaceholderExpr(rng hcl.Range) Expression {
+	return &LiteralValueExpr{
+		Val:      cty.DynamicVal,
+		SrcRange: rng,
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_template.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_template.go
new file mode 100644
index 00000000..bb856461
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_template.go
@@ -0,0 +1,799 @@
+package hclsyntax
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+
+	"github.com/apparentlymart/go-textseg/v12/textseg"
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+)
+
+func (p *parser) ParseTemplate() (Expression, hcl.Diagnostics) {
+	return p.parseTemplate(TokenEOF, false)
+}
+
+func (p *parser) parseTemplate(end TokenType, flushHeredoc bool) (Expression, hcl.Diagnostics) {
+	exprs, passthru, rng, diags := p.parseTemplateInner(end, flushHeredoc)
+
+	if passthru {
+		if len(exprs) != 1 {
+			panic("passthru set with len(exprs) != 1")
+		}
+		return &TemplateWrapExpr{
+			Wrapped:  exprs[0],
+			SrcRange: rng,
+		}, diags
+	}
+
+	return &TemplateExpr{
+		Parts:    exprs,
+		SrcRange: rng,
+	}, diags
+}
+
+func (p *parser) parseTemplateInner(end TokenType, flushHeredoc bool) ([]Expression, bool, hcl.Range, hcl.Diagnostics) {
+	parts, diags := p.parseTemplateParts(end)
+	if flushHeredoc {
+		flushHeredocTemplateParts(parts) // Trim off leading spaces on lines per the flush heredoc spec
+	}
+	tp := templateParser{
+		Tokens:   parts.Tokens,
+		SrcRange: parts.SrcRange,
+	}
+	exprs, exprsDiags := tp.parseRoot()
+	diags = append(diags, exprsDiags...)
+
+	passthru := false
+	if len(parts.Tokens) == 2 { // one real token and one synthetic "end" token
+		if _, isInterp := parts.Tokens[0].(*templateInterpToken); isInterp {
+			passthru = true
+		}
+	}
+
+	return exprs, passthru, parts.SrcRange, diags
+}
+
+type templateParser struct {
+	Tokens   []templateToken
+	SrcRange hcl.Range
+
+	pos int
+}
+
+func (p *templateParser) parseRoot() ([]Expression, hcl.Diagnostics) {
+	var exprs []Expression
+	var diags hcl.Diagnostics
+
+	for {
+		next := p.Peek()
+		if _, isEnd := next.(*templateEndToken); isEnd {
+			break
+		}
+
+		expr, exprDiags := p.parseExpr()
+		diags = append(diags, exprDiags...)
+		exprs = append(exprs, expr)
+	}
+
+	return exprs, diags
+}
+
+func (p *templateParser) parseExpr() (Expression, hcl.Diagnostics) {
+	next := p.Peek()
+	switch tok := next.(type) {
+
+	case *templateLiteralToken:
+		p.Read() // eat literal
+		return &LiteralValueExpr{
+			Val:      cty.StringVal(tok.Val),
+			SrcRange: tok.SrcRange,
+		}, nil
+
+	case *templateInterpToken:
+		p.Read() // eat interp
+		return tok.Expr, nil
+
+	case *templateIfToken:
+		return p.parseIf()
+
+	case *templateForToken:
+		return p.parseFor()
+
+	case *templateEndToken:
+		p.Read() // eat erroneous token
+		return errPlaceholderExpr(tok.SrcRange), hcl.Diagnostics{
+			{
+				// This is a particularly unhelpful diagnostic, so callers
+				// should attempt to pre-empt it and produce a more helpful
+				// diagnostic that is context-aware.
+				Severity: hcl.DiagError,
+				Summary:  "Unexpected end of template",
+				Detail:   "The control directives within this template are unbalanced.",
+				Subject:  &tok.SrcRange,
+			},
+		}
+
+	case *templateEndCtrlToken:
+		p.Read() // eat erroneous token
+		return errPlaceholderExpr(tok.SrcRange), hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Unexpected %s directive", tok.Name()),
+				Detail:   "The control directives within this template are unbalanced.",
+				Subject:  &tok.SrcRange,
+			},
+		}
+
+	default:
+		// should never happen, because above should be exhaustive
+		panic(fmt.Sprintf("unhandled template token type %T", next))
+	}
+}
+
+func (p *templateParser) parseIf() (Expression, hcl.Diagnostics) {
+	open := p.Read()
+	openIf, isIf := open.(*templateIfToken)
+	if !isIf {
+		// should never happen if caller is behaving
+		panic("parseIf called with peeker not pointing at if token")
+	}
+
+	var ifExprs, elseExprs []Expression
+	var diags hcl.Diagnostics
+	var endifRange hcl.Range
+
+	currentExprs := &ifExprs
+Token:
+	for {
+		next := p.Peek()
+		if end, isEnd := next.(*templateEndToken); isEnd {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unexpected end of template",
+				Detail: fmt.Sprintf(
+					"The if directive at %s is missing its corresponding endif directive.",
+					openIf.SrcRange,
+				),
+				Subject: &end.SrcRange,
+			})
+			return errPlaceholderExpr(end.SrcRange), diags
+		}
+		if end, isCtrlEnd := next.(*templateEndCtrlToken); isCtrlEnd {
+			p.Read() // eat end directive
+
+			switch end.Type {
+
+			case templateElse:
+				if currentExprs == &ifExprs {
+					currentExprs = &elseExprs
+					continue Token
+				}
+
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Unexpected else directive",
+					Detail: fmt.Sprintf(
+						"Already in the else clause for the if started at %s.",
+						openIf.SrcRange,
+					),
+					Subject: &end.SrcRange,
+				})
+
+			case templateEndIf:
+				endifRange = end.SrcRange
+				break Token
+
+			default:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  fmt.Sprintf("Unexpected %s directive", end.Name()),
+					Detail: fmt.Sprintf(
+						"Expecting an endif directive for the if started at %s.",
+						openIf.SrcRange,
+					),
+					Subject: &end.SrcRange,
+				})
+			}
+
+			return errPlaceholderExpr(end.SrcRange), diags
+		}
+
+		expr, exprDiags := p.parseExpr()
+		diags = append(diags, exprDiags...)
+		*currentExprs = append(*currentExprs, expr)
+	}
+
+	if len(ifExprs) == 0 {
+		ifExprs = append(ifExprs, &LiteralValueExpr{
+			Val: cty.StringVal(""),
+			SrcRange: hcl.Range{
+				Filename: openIf.SrcRange.Filename,
+				Start:    openIf.SrcRange.End,
+				End:      openIf.SrcRange.End,
+			},
+		})
+	}
+	if len(elseExprs) == 0 {
+		elseExprs = append(elseExprs, &LiteralValueExpr{
+			Val: cty.StringVal(""),
+			SrcRange: hcl.Range{
+				Filename: endifRange.Filename,
+				Start:    endifRange.Start,
+				End:      endifRange.Start,
+			},
+		})
+	}
+
+	trueExpr := &TemplateExpr{
+		Parts:    ifExprs,
+		SrcRange: hcl.RangeBetween(ifExprs[0].Range(), ifExprs[len(ifExprs)-1].Range()),
+	}
+	falseExpr := &TemplateExpr{
+		Parts:    elseExprs,
+		SrcRange: hcl.RangeBetween(elseExprs[0].Range(), elseExprs[len(elseExprs)-1].Range()),
+	}
+
+	return &ConditionalExpr{
+		Condition:   openIf.CondExpr,
+		TrueResult:  trueExpr,
+		FalseResult: falseExpr,
+
+		SrcRange: hcl.RangeBetween(openIf.SrcRange, endifRange),
+	}, diags
+}
+
+func (p *templateParser) parseFor() (Expression, hcl.Diagnostics) {
+	open := p.Read()
+	openFor, isFor := open.(*templateForToken)
+	if !isFor {
+		// should never happen if caller is behaving
+		panic("parseFor called with peeker not pointing at for token")
+	}
+
+	var contentExprs []Expression
+	var diags hcl.Diagnostics
+	var endforRange hcl.Range
+
+Token:
+	for {
+		next := p.Peek()
+		if end, isEnd := next.(*templateEndToken); isEnd {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unexpected end of template",
+				Detail: fmt.Sprintf(
+					"The for directive at %s is missing its corresponding endfor directive.",
+					openFor.SrcRange,
+				),
+				Subject: &end.SrcRange,
+			})
+			return errPlaceholderExpr(end.SrcRange), diags
+		}
+		if end, isCtrlEnd := next.(*templateEndCtrlToken); isCtrlEnd {
+			p.Read() // eat end directive
+
+			switch end.Type {
+
+			case templateElse:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Unexpected else directive",
+					Detail:   "An else clause is not expected for a for directive.",
+					Subject:  &end.SrcRange,
+				})
+
+			case templateEndFor:
+				endforRange = end.SrcRange
+				break Token
+
+			default:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  fmt.Sprintf("Unexpected %s directive", end.Name()),
+					Detail: fmt.Sprintf(
+						"Expecting an endfor directive corresponding to the for directive at %s.",
+						openFor.SrcRange,
+					),
+					Subject: &end.SrcRange,
+				})
+			}
+
+			return errPlaceholderExpr(end.SrcRange), diags
+		}
+
+		expr, exprDiags := p.parseExpr()
+		diags = append(diags, exprDiags...)
+		contentExprs = append(contentExprs, expr)
+	}
+
+	if len(contentExprs) == 0 {
+		contentExprs = append(contentExprs, &LiteralValueExpr{
+			Val: cty.StringVal(""),
+			SrcRange: hcl.Range{
+				Filename: openFor.SrcRange.Filename,
+				Start:    openFor.SrcRange.End,
+				End:      openFor.SrcRange.End,
+			},
+		})
+	}
+
+	contentExpr := &TemplateExpr{
+		Parts:    contentExprs,
+		SrcRange: hcl.RangeBetween(contentExprs[0].Range(), contentExprs[len(contentExprs)-1].Range()),
+	}
+
+	forExpr := &ForExpr{
+		KeyVar: openFor.KeyVar,
+		ValVar: openFor.ValVar,
+
+		CollExpr: openFor.CollExpr,
+		ValExpr:  contentExpr,
+
+		SrcRange:   hcl.RangeBetween(openFor.SrcRange, endforRange),
+		OpenRange:  openFor.SrcRange,
+		CloseRange: endforRange,
+	}
+
+	return &TemplateJoinExpr{
+		Tuple: forExpr,
+	}, diags
+}
+
+func (p *templateParser) Peek() templateToken {
+	return p.Tokens[p.pos]
+}
+
+func (p *templateParser) Read() templateToken {
+	ret := p.Peek()
+	if _, end := ret.(*templateEndToken); !end {
+		p.pos++
+	}
+	return ret
+}
+
+// parseTemplateParts produces a flat sequence of "template tokens", which are
+// either literal values (with any "trimming" already applied), interpolation
+// sequences, or control flow markers.
+//
+// A further pass is required on the result to turn it into an AST.
+func (p *parser) parseTemplateParts(end TokenType) (*templateParts, hcl.Diagnostics) {
+	var parts []templateToken
+	var diags hcl.Diagnostics
+
+	startRange := p.NextRange()
+	ltrimNext := false
+	nextCanTrimPrev := false
+	var endRange hcl.Range
+
+Token:
+	for {
+		next := p.Read()
+		if next.Type == end {
+			// all done!
+			endRange = next.Range
+			break
+		}
+
+		ltrim := ltrimNext
+		ltrimNext = false
+		canTrimPrev := nextCanTrimPrev
+		nextCanTrimPrev = false
+
+		switch next.Type {
+		case TokenStringLit, TokenQuotedLit:
+			str, strDiags := ParseStringLiteralToken(next)
+			diags = append(diags, strDiags...)
+
+			if ltrim {
+				str = strings.TrimLeftFunc(str, unicode.IsSpace)
+			}
+
+			parts = append(parts, &templateLiteralToken{
+				Val:      str,
+				SrcRange: next.Range,
+			})
+			nextCanTrimPrev = true
+
+		case TokenTemplateInterp:
+			// if the opener is ${~ then we want to eat any trailing whitespace
+			// in the preceding literal token, assuming it is indeed a literal
+			// token.
+			if canTrimPrev && len(next.Bytes) == 3 && next.Bytes[2] == '~' && len(parts) > 0 {
+				prevExpr := parts[len(parts)-1]
+				if lexpr, ok := prevExpr.(*templateLiteralToken); ok {
+					lexpr.Val = strings.TrimRightFunc(lexpr.Val, unicode.IsSpace)
+				}
+			}
+
+			p.PushIncludeNewlines(false)
+			expr, exprDiags := p.ParseExpression()
+			diags = append(diags, exprDiags...)
+			close := p.Peek()
+			if close.Type != TokenTemplateSeqEnd {
+				if !p.recovery {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Extra characters after interpolation expression",
+						Detail:   "Expected a closing brace to end the interpolation expression, but found extra characters.",
+						Subject:  &close.Range,
+						Context:  hcl.RangeBetween(startRange, close.Range).Ptr(),
+					})
+				}
+				p.recover(TokenTemplateSeqEnd)
+			} else {
+				p.Read() // eat closing brace
+
+				// If the closer is ~} then we want to eat any leading
+				// whitespace on the next token, if it turns out to be a
+				// literal token.
+				if len(close.Bytes) == 2 && close.Bytes[0] == '~' {
+					ltrimNext = true
+				}
+			}
+			p.PopIncludeNewlines()
+			parts = append(parts, &templateInterpToken{
+				Expr:     expr,
+				SrcRange: hcl.RangeBetween(next.Range, close.Range),
+			})
+
+		case TokenTemplateControl:
+			// if the opener is %{~ then we want to eat any trailing whitespace
+			// in the preceding literal token, assuming it is indeed a literal
+			// token.
+			if canTrimPrev && len(next.Bytes) == 3 && next.Bytes[2] == '~' && len(parts) > 0 {
+				prevExpr := parts[len(parts)-1]
+				if lexpr, ok := prevExpr.(*templateLiteralToken); ok {
+					lexpr.Val = strings.TrimRightFunc(lexpr.Val, unicode.IsSpace)
+				}
+			}
+			p.PushIncludeNewlines(false)
+
+			kw := p.Peek()
+			if kw.Type != TokenIdent {
+				if !p.recovery {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid template directive",
+						Detail:   "A template directive keyword (\"if\", \"for\", etc) is expected at the beginning of a %{ sequence.",
+						Subject:  &kw.Range,
+						Context:  hcl.RangeBetween(next.Range, kw.Range).Ptr(),
+					})
+				}
+				p.recover(TokenTemplateSeqEnd)
+				p.PopIncludeNewlines()
+				continue Token
+			}
+			p.Read() // eat keyword token
+
+			switch {
+
+			case ifKeyword.TokenMatches(kw):
+				condExpr, exprDiags := p.ParseExpression()
+				diags = append(diags, exprDiags...)
+				parts = append(parts, &templateIfToken{
+					CondExpr: condExpr,
+					SrcRange: hcl.RangeBetween(next.Range, p.NextRange()),
+				})
+
+			case elseKeyword.TokenMatches(kw):
+				parts = append(parts, &templateEndCtrlToken{
+					Type:     templateElse,
+					SrcRange: hcl.RangeBetween(next.Range, p.NextRange()),
+				})
+
+			case endifKeyword.TokenMatches(kw):
+				parts = append(parts, &templateEndCtrlToken{
+					Type:     templateEndIf,
+					SrcRange: hcl.RangeBetween(next.Range, p.NextRange()),
+				})
+
+			case forKeyword.TokenMatches(kw):
+				var keyName, valName string
+				if p.Peek().Type != TokenIdent {
+					if !p.recovery {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity: hcl.DiagError,
+							Summary:  "Invalid 'for' directive",
+							Detail:   "For directive requires variable name after 'for'.",
+							Subject:  p.Peek().Range.Ptr(),
+						})
+					}
+					p.recover(TokenTemplateSeqEnd)
+					p.PopIncludeNewlines()
+					continue Token
+				}
+
+				valName = string(p.Read().Bytes)
+
+				if p.Peek().Type == TokenComma {
+					// What we just read was actually the key, then.
+					keyName = valName
+					p.Read() // eat comma
+
+					if p.Peek().Type != TokenIdent {
+						if !p.recovery {
+							diags = append(diags, &hcl.Diagnostic{
+								Severity: hcl.DiagError,
+								Summary:  "Invalid 'for' directive",
+								Detail:   "For directive requires value variable name after comma.",
+								Subject:  p.Peek().Range.Ptr(),
+							})
+						}
+						p.recover(TokenTemplateSeqEnd)
+						p.PopIncludeNewlines()
+						continue Token
+					}
+
+					valName = string(p.Read().Bytes)
+				}
+
+				if !inKeyword.TokenMatches(p.Peek()) {
+					if !p.recovery {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity: hcl.DiagError,
+							Summary:  "Invalid 'for' directive",
+							Detail:   "For directive requires 'in' keyword after names.",
+							Subject:  p.Peek().Range.Ptr(),
+						})
+					}
+					p.recover(TokenTemplateSeqEnd)
+					p.PopIncludeNewlines()
+					continue Token
+				}
+				p.Read() // eat 'in' keyword
+
+				collExpr, collDiags := p.ParseExpression()
+				diags = append(diags, collDiags...)
+				parts = append(parts, &templateForToken{
+					KeyVar:   keyName,
+					ValVar:   valName,
+					CollExpr: collExpr,
+
+					SrcRange: hcl.RangeBetween(next.Range, p.NextRange()),
+				})
+
+			case endforKeyword.TokenMatches(kw):
+				parts = append(parts, &templateEndCtrlToken{
+					Type:     templateEndFor,
+					SrcRange: hcl.RangeBetween(next.Range, p.NextRange()),
+				})
+
+			default:
+				if !p.recovery {
+					suggestions := []string{"if", "for", "else", "endif", "endfor"}
+					given := string(kw.Bytes)
+					suggestion := nameSuggestion(given, suggestions)
+					if suggestion != "" {
+						suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+					}
+
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid template control keyword",
+						Detail:   fmt.Sprintf("%q is not a valid template control keyword.%s", given, suggestion),
+						Subject:  &kw.Range,
+						Context:  hcl.RangeBetween(next.Range, kw.Range).Ptr(),
+					})
+				}
+				p.recover(TokenTemplateSeqEnd)
+				p.PopIncludeNewlines()
+				continue Token
+
+			}
+
+			close := p.Peek()
+			if close.Type != TokenTemplateSeqEnd {
+				if !p.recovery {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  fmt.Sprintf("Extra characters in %s marker", kw.Bytes),
+						Detail:   "Expected a closing brace to end the sequence, but found extra characters.",
+						Subject:  &close.Range,
+						Context:  hcl.RangeBetween(startRange, close.Range).Ptr(),
+					})
+				}
+				p.recover(TokenTemplateSeqEnd)
+			} else {
+				p.Read() // eat closing brace
+
+				// If the closer is ~} then we want to eat any leading
+				// whitespace on the next token, if it turns out to be a
+				// literal token.
+				if len(close.Bytes) == 2 && close.Bytes[0] == '~' {
+					ltrimNext = true
+				}
+			}
+			p.PopIncludeNewlines()
+
+		default:
+			if !p.recovery {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Unterminated template string",
+					Detail:   "No closing marker was found for the string.",
+					Subject:  &next.Range,
+					Context:  hcl.RangeBetween(startRange, next.Range).Ptr(),
+				})
+			}
+			final := p.recover(end)
+			endRange = final.Range
+			break Token
+		}
+	}
+
+	if len(parts) == 0 {
+		// If a sequence has no content, we'll treat it as if it had an
+		// empty string in it because that's what the user probably means
+		// if they write "" in configuration.
+		parts = append(parts, &templateLiteralToken{
+			Val: "",
+			SrcRange: hcl.Range{
+				// Range is the zero-character span immediately after the
+				// opening quote.
+				Filename: startRange.Filename,
+				Start:    startRange.End,
+				End:      startRange.End,
+			},
+		})
+	}
+
+	// Always end with an end token, so the parser can produce diagnostics
+	// about unclosed items with proper position information.
+	parts = append(parts, &templateEndToken{
+		SrcRange: endRange,
+	})
+
+	ret := &templateParts{
+		Tokens:   parts,
+		SrcRange: hcl.RangeBetween(startRange, endRange),
+	}
+
+	return ret, diags
+}
+
+// flushHeredocTemplateParts modifies in-place the line-leading literal strings
+// to apply the flush heredoc processing rule: find the line with the smallest
+// number of whitespace characters as prefix and then trim that number of
+// characters from all of the lines.
+//
+// This rule is applied to static tokens rather than to the rendered result,
+// so interpolating a string with leading whitespace cannot affect the chosen
+// prefix length.
+func flushHeredocTemplateParts(parts *templateParts) {
+	if len(parts.Tokens) == 0 {
+		// Nothing to do
+		return
+	}
+
+	const maxInt = int((^uint(0)) >> 1)
+
+	minSpaces := maxInt
+	newline := true
+	var adjust []*templateLiteralToken
+	for _, ttok := range parts.Tokens {
+		if newline {
+			newline = false
+			var spaces int
+			if lit, ok := ttok.(*templateLiteralToken); ok {
+				orig := lit.Val
+				trimmed := strings.TrimLeftFunc(orig, unicode.IsSpace)
+				// If a token is entirely spaces and ends with a newline
+				// then it's a "blank line" and thus not considered for
+				// space-prefix-counting purposes.
+				if len(trimmed) == 0 && strings.HasSuffix(orig, "\n") {
+					spaces = maxInt
+				} else {
+					spaceBytes := len(lit.Val) - len(trimmed)
+					spaces, _ = textseg.TokenCount([]byte(orig[:spaceBytes]), textseg.ScanGraphemeClusters)
+					adjust = append(adjust, lit)
+				}
+			} else if _, ok := ttok.(*templateEndToken); ok {
+				break // don't process the end token since it never has spaces before it
+			}
+			if spaces < minSpaces {
+				minSpaces = spaces
+			}
+		}
+		if lit, ok := ttok.(*templateLiteralToken); ok {
+			if strings.HasSuffix(lit.Val, "\n") {
+				newline = true // The following token, if any, begins a new line
+			}
+		}
+	}
+
+	for _, lit := range adjust {
+		// Since we want to count space _characters_ rather than space _bytes_,
+		// we can't just do a straightforward slice operation here and instead
+		// need to hunt for the split point with a scanner.
+		valBytes := []byte(lit.Val)
+		spaceByteCount := 0
+		for i := 0; i < minSpaces; i++ {
+			adv, _, _ := textseg.ScanGraphemeClusters(valBytes, true)
+			spaceByteCount += adv
+			valBytes = valBytes[adv:]
+		}
+		lit.Val = lit.Val[spaceByteCount:]
+		lit.SrcRange.Start.Column += minSpaces
+		lit.SrcRange.Start.Byte += spaceByteCount
+	}
+}
+
+type templateParts struct {
+	Tokens   []templateToken
+	SrcRange hcl.Range
+}
+
+// templateToken is a higher-level token that represents a single atom within
+// the template language. Our template parsing first raises the raw token
+// stream to a sequence of templateToken, and then transforms the result into
+// an expression tree.
+type templateToken interface {
+	templateToken() templateToken
+}
+
+type templateLiteralToken struct {
+	Val      string
+	SrcRange hcl.Range
+	isTemplateToken
+}
+
+type templateInterpToken struct {
+	Expr     Expression
+	SrcRange hcl.Range
+	isTemplateToken
+}
+
+type templateIfToken struct {
+	CondExpr Expression
+	SrcRange hcl.Range
+	isTemplateToken
+}
+
+type templateForToken struct {
+	KeyVar   string // empty if ignoring key
+	ValVar   string
+	CollExpr Expression
+	SrcRange hcl.Range
+	isTemplateToken
+}
+
+type templateEndCtrlType int
+
+const (
+	templateEndIf templateEndCtrlType = iota
+	templateElse
+	templateEndFor
+)
+
+type templateEndCtrlToken struct {
+	Type     templateEndCtrlType
+	SrcRange hcl.Range
+	isTemplateToken
+}
+
+func (t *templateEndCtrlToken) Name() string {
+	switch t.Type {
+	case templateEndIf:
+		return "endif"
+	case templateElse:
+		return "else"
+	case templateEndFor:
+		return "endfor"
+	default:
+		// should never happen
+		panic("invalid templateEndCtrlType")
+	}
+}
+
+type templateEndToken struct {
+	SrcRange hcl.Range
+	isTemplateToken
+}
+
+type isTemplateToken [0]int
+
+func (t isTemplateToken) templateToken() templateToken {
+	return t
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_traversal.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_traversal.go
new file mode 100644
index 00000000..7dcb0fd3
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_traversal.go
@@ -0,0 +1,159 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// ParseTraversalAbs parses an absolute traversal that is assumed to consume
+// all of the remaining tokens in the peeker. The usual parser recovery
+// behavior is not supported here because traversals are not expected to
+// be parsed as part of a larger program.
+func (p *parser) ParseTraversalAbs() (hcl.Traversal, hcl.Diagnostics) {
+	var ret hcl.Traversal
+	var diags hcl.Diagnostics
+
+	// Absolute traversal must always begin with a variable name
+	varTok := p.Read()
+	if varTok.Type != TokenIdent {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Variable name required",
+			Detail:   "Must begin with a variable name.",
+			Subject:  &varTok.Range,
+		})
+		return ret, diags
+	}
+
+	varName := string(varTok.Bytes)
+	ret = append(ret, hcl.TraverseRoot{
+		Name:     varName,
+		SrcRange: varTok.Range,
+	})
+
+	for {
+		next := p.Peek()
+
+		if next.Type == TokenEOF {
+			return ret, diags
+		}
+
+		switch next.Type {
+		case TokenDot:
+			// Attribute access
+			dot := p.Read() // eat dot
+			nameTok := p.Read()
+			if nameTok.Type != TokenIdent {
+				if nameTok.Type == TokenStar {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Attribute name required",
+						Detail:   "Splat expressions (.*) may not be used here.",
+						Subject:  &nameTok.Range,
+						Context:  hcl.RangeBetween(varTok.Range, nameTok.Range).Ptr(),
+					})
+				} else {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Attribute name required",
+						Detail:   "Dot must be followed by attribute name.",
+						Subject:  &nameTok.Range,
+						Context:  hcl.RangeBetween(varTok.Range, nameTok.Range).Ptr(),
+					})
+				}
+				return ret, diags
+			}
+
+			attrName := string(nameTok.Bytes)
+			ret = append(ret, hcl.TraverseAttr{
+				Name:     attrName,
+				SrcRange: hcl.RangeBetween(dot.Range, nameTok.Range),
+			})
+		case TokenOBrack:
+			// Index
+			open := p.Read() // eat open bracket
+			next := p.Peek()
+
+			switch next.Type {
+			case TokenNumberLit:
+				tok := p.Read() // eat number
+				numVal, numDiags := p.numberLitValue(tok)
+				diags = append(diags, numDiags...)
+
+				close := p.Read()
+				if close.Type != TokenCBrack {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Unclosed index brackets",
+						Detail:   "Index key must be followed by a closing bracket.",
+						Subject:  &close.Range,
+						Context:  hcl.RangeBetween(open.Range, close.Range).Ptr(),
+					})
+				}
+
+				ret = append(ret, hcl.TraverseIndex{
+					Key:      numVal,
+					SrcRange: hcl.RangeBetween(open.Range, close.Range),
+				})
+
+				if diags.HasErrors() {
+					return ret, diags
+				}
+
+			case TokenOQuote:
+				str, _, strDiags := p.parseQuotedStringLiteral()
+				diags = append(diags, strDiags...)
+
+				close := p.Read()
+				if close.Type != TokenCBrack {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Unclosed index brackets",
+						Detail:   "Index key must be followed by a closing bracket.",
+						Subject:  &close.Range,
+						Context:  hcl.RangeBetween(open.Range, close.Range).Ptr(),
+					})
+				}
+
+				ret = append(ret, hcl.TraverseIndex{
+					Key:      cty.StringVal(str),
+					SrcRange: hcl.RangeBetween(open.Range, close.Range),
+				})
+
+				if diags.HasErrors() {
+					return ret, diags
+				}
+
+			default:
+				if next.Type == TokenStar {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Attribute name required",
+						Detail:   "Splat expressions ([*]) may not be used here.",
+						Subject:  &next.Range,
+						Context:  hcl.RangeBetween(varTok.Range, next.Range).Ptr(),
+					})
+				} else {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Index value required",
+						Detail:   "Index brackets must contain either a literal number or a literal string.",
+						Subject:  &next.Range,
+						Context:  hcl.RangeBetween(varTok.Range, next.Range).Ptr(),
+					})
+				}
+				return ret, diags
+			}
+
+		default:
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid character",
+				Detail:   "Expected an attribute access or an index operator.",
+				Subject:  &next.Range,
+				Context:  hcl.RangeBetween(varTok.Range, next.Range).Ptr(),
+			})
+			return ret, diags
+		}
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/peeker.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/peeker.go
new file mode 100644
index 00000000..f056f906
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/peeker.go
@@ -0,0 +1,212 @@
+package hclsyntax
+
+import (
+	"bytes"
+	"fmt"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+// This is set to true at init() time in tests, to enable more useful output
+// if a stack discipline error is detected. It should not be enabled in
+// normal mode since there is a performance penalty from accessing the
+// runtime stack to produce the traces, but could be temporarily set to
+// true for debugging if desired.
+var tracePeekerNewlinesStack = false
+
+type peeker struct {
+	Tokens    Tokens
+	NextIndex int
+
+	IncludeComments      bool
+	IncludeNewlinesStack []bool
+
+	// used only when tracePeekerNewlinesStack is set
+	newlineStackChanges []peekerNewlineStackChange
+}
+
+// for use in debugging the stack usage only
+type peekerNewlineStackChange struct {
+	Pushing bool // if false, then popping
+	Frame   runtime.Frame
+	Include bool
+}
+
+func newPeeker(tokens Tokens, includeComments bool) *peeker {
+	return &peeker{
+		Tokens:          tokens,
+		IncludeComments: includeComments,
+
+		IncludeNewlinesStack: []bool{true},
+	}
+}
+
+func (p *peeker) Peek() Token {
+	ret, _ := p.nextToken()
+	return ret
+}
+
+func (p *peeker) Read() Token {
+	ret, nextIdx := p.nextToken()
+	p.NextIndex = nextIdx
+	return ret
+}
+
+func (p *peeker) NextRange() hcl.Range {
+	return p.Peek().Range
+}
+
+func (p *peeker) PrevRange() hcl.Range {
+	if p.NextIndex == 0 {
+		return p.NextRange()
+	}
+
+	return p.Tokens[p.NextIndex-1].Range
+}
+
+func (p *peeker) nextToken() (Token, int) {
+	for i := p.NextIndex; i < len(p.Tokens); i++ {
+		tok := p.Tokens[i]
+		switch tok.Type {
+		case TokenComment:
+			if !p.IncludeComments {
+				// Single-line comment tokens, starting with # or //, absorb
+				// the trailing newline that terminates them as part of their
+				// bytes. When we're filtering out comments, we must as a
+				// special case transform these to newline tokens in order
+				// to properly parse newline-terminated block items.
+
+				if p.includingNewlines() {
+					if len(tok.Bytes) > 0 && tok.Bytes[len(tok.Bytes)-1] == '\n' {
+						fakeNewline := Token{
+							Type:  TokenNewline,
+							Bytes: tok.Bytes[len(tok.Bytes)-1 : len(tok.Bytes)],
+
+							// We use the whole token range as the newline
+							// range, even though that's a little... weird,
+							// because otherwise we'd need to go count
+							// characters again in order to figure out the
+							// column of the newline, and that complexity
+							// isn't justified when ranges of newlines are
+							// so rarely printed anyway.
+							Range: tok.Range,
+						}
+						return fakeNewline, i + 1
+					}
+				}
+
+				continue
+			}
+		case TokenNewline:
+			if !p.includingNewlines() {
+				continue
+			}
+		}
+
+		return tok, i + 1
+	}
+
+	// if we fall out here then we'll return the EOF token, and leave
+	// our index pointed off the end of the array so we'll keep
+	// returning EOF in future too.
+	return p.Tokens[len(p.Tokens)-1], len(p.Tokens)
+}
+
+func (p *peeker) includingNewlines() bool {
+	return p.IncludeNewlinesStack[len(p.IncludeNewlinesStack)-1]
+}
+
+func (p *peeker) PushIncludeNewlines(include bool) {
+	if tracePeekerNewlinesStack {
+		// Record who called us so that we can more easily track down any
+		// mismanagement of the stack in the parser.
+		callers := []uintptr{0}
+		runtime.Callers(2, callers)
+		frames := runtime.CallersFrames(callers)
+		frame, _ := frames.Next()
+		p.newlineStackChanges = append(p.newlineStackChanges, peekerNewlineStackChange{
+			true, frame, include,
+		})
+	}
+
+	p.IncludeNewlinesStack = append(p.IncludeNewlinesStack, include)
+}
+
+func (p *peeker) PopIncludeNewlines() bool {
+	stack := p.IncludeNewlinesStack
+	remain, ret := stack[:len(stack)-1], stack[len(stack)-1]
+	p.IncludeNewlinesStack = remain
+
+	if tracePeekerNewlinesStack {
+		// Record who called us so that we can more easily track down any
+		// mismanagement of the stack in the parser.
+		callers := []uintptr{0}
+		runtime.Callers(2, callers)
+		frames := runtime.CallersFrames(callers)
+		frame, _ := frames.Next()
+		p.newlineStackChanges = append(p.newlineStackChanges, peekerNewlineStackChange{
+			false, frame, ret,
+		})
+	}
+
+	return ret
+}
+
+// AssertEmptyNewlinesStack checks if the IncludeNewlinesStack is empty, doing
+// panicking if it is not. This can be used to catch stack mismanagement that
+// might otherwise just cause confusing downstream errors.
+//
+// This function is a no-op if the stack is empty when called.
+//
+// If newlines stack tracing is enabled by setting the global variable
+// tracePeekerNewlinesStack at init time, a full log of all of the push/pop
+// calls will be produced to help identify which caller in the parser is
+// misbehaving.
+func (p *peeker) AssertEmptyIncludeNewlinesStack() {
+	if len(p.IncludeNewlinesStack) != 1 {
+		// Should never happen; indicates mismanagement of the stack inside
+		// the parser.
+		if p.newlineStackChanges != nil { // only if traceNewlinesStack is enabled above
+			panic(fmt.Errorf(
+				"non-empty IncludeNewlinesStack after parse with %d calls unaccounted for:\n%s",
+				len(p.IncludeNewlinesStack)-1,
+				formatPeekerNewlineStackChanges(p.newlineStackChanges),
+			))
+		} else {
+			panic(fmt.Errorf("non-empty IncludeNewlinesStack after parse: %#v", p.IncludeNewlinesStack))
+		}
+	}
+}
+
+func formatPeekerNewlineStackChanges(changes []peekerNewlineStackChange) string {
+	indent := 0
+	var buf bytes.Buffer
+	for _, change := range changes {
+		funcName := change.Frame.Function
+		if idx := strings.LastIndexByte(funcName, '.'); idx != -1 {
+			funcName = funcName[idx+1:]
+		}
+		filename := change.Frame.File
+		if idx := strings.LastIndexByte(filename, filepath.Separator); idx != -1 {
+			filename = filename[idx+1:]
+		}
+
+		switch change.Pushing {
+
+		case true:
+			buf.WriteString(strings.Repeat("    ", indent))
+			fmt.Fprintf(&buf, "PUSH %#v (%s at %s:%d)\n", change.Include, funcName, filename, change.Frame.Line)
+			indent++
+
+		case false:
+			indent--
+			buf.WriteString(strings.Repeat("    ", indent))
+			fmt.Fprintf(&buf, "POP %#v (%s at %s:%d)\n", change.Include, funcName, filename, change.Frame.Line)
+
+		}
+	}
+	return buf.String()
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/public.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/public.go
new file mode 100644
index 00000000..0b68efd6
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/public.go
@@ -0,0 +1,171 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// ParseConfig parses the given buffer as a whole HCL config file, returning
+// a *hcl.File representing its contents. If HasErrors called on the returned
+// diagnostics returns true, the returned body is likely to be incomplete
+// and should therefore be used with care.
+//
+// The body in the returned file has dynamic type *hclsyntax.Body, so callers
+// may freely type-assert this to get access to the full hclsyntax API in
+// situations where detailed access is required. However, most common use-cases
+// should be served using the hcl.Body interface to ensure compatibility with
+// other configurationg syntaxes, such as JSON.
+func ParseConfig(src []byte, filename string, start hcl.Pos) (*hcl.File, hcl.Diagnostics) {
+	tokens, diags := LexConfig(src, filename, start)
+	peeker := newPeeker(tokens, false)
+	parser := &parser{peeker: peeker}
+	body, parseDiags := parser.ParseBody(TokenEOF)
+	diags = append(diags, parseDiags...)
+
+	// Panic if the parser uses incorrect stack discipline with the peeker's
+	// newlines stack, since otherwise it will produce confusing downstream
+	// errors.
+	peeker.AssertEmptyIncludeNewlinesStack()
+
+	return &hcl.File{
+		Body:  body,
+		Bytes: src,
+
+		Nav: navigation{
+			root: body,
+		},
+	}, diags
+}
+
+// ParseExpression parses the given buffer as a standalone HCL expression,
+// returning it as an instance of Expression.
+func ParseExpression(src []byte, filename string, start hcl.Pos) (Expression, hcl.Diagnostics) {
+	tokens, diags := LexExpression(src, filename, start)
+	peeker := newPeeker(tokens, false)
+	parser := &parser{peeker: peeker}
+
+	// Bare expressions are always parsed in  "ignore newlines" mode, as if
+	// they were wrapped in parentheses.
+	parser.PushIncludeNewlines(false)
+
+	expr, parseDiags := parser.ParseExpression()
+	diags = append(diags, parseDiags...)
+
+	next := parser.Peek()
+	if next.Type != TokenEOF && !parser.recovery {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Extra characters after expression",
+			Detail:   "An expression was successfully parsed, but extra characters were found after it.",
+			Subject:  &next.Range,
+		})
+	}
+
+	parser.PopIncludeNewlines()
+
+	// Panic if the parser uses incorrect stack discipline with the peeker's
+	// newlines stack, since otherwise it will produce confusing downstream
+	// errors.
+	peeker.AssertEmptyIncludeNewlinesStack()
+
+	return expr, diags
+}
+
+// ParseTemplate parses the given buffer as a standalone HCL template,
+// returning it as an instance of Expression.
+func ParseTemplate(src []byte, filename string, start hcl.Pos) (Expression, hcl.Diagnostics) {
+	tokens, diags := LexTemplate(src, filename, start)
+	peeker := newPeeker(tokens, false)
+	parser := &parser{peeker: peeker}
+	expr, parseDiags := parser.ParseTemplate()
+	diags = append(diags, parseDiags...)
+
+	// Panic if the parser uses incorrect stack discipline with the peeker's
+	// newlines stack, since otherwise it will produce confusing downstream
+	// errors.
+	peeker.AssertEmptyIncludeNewlinesStack()
+
+	return expr, diags
+}
+
+// ParseTraversalAbs parses the given buffer as a standalone absolute traversal.
+//
+// Parsing as a traversal is more limited than parsing as an expession since
+// it allows only attribute and indexing operations on variables. Traverals
+// are useful as a syntax for referring to objects without necessarily
+// evaluating them.
+func ParseTraversalAbs(src []byte, filename string, start hcl.Pos) (hcl.Traversal, hcl.Diagnostics) {
+	tokens, diags := LexExpression(src, filename, start)
+	peeker := newPeeker(tokens, false)
+	parser := &parser{peeker: peeker}
+
+	// Bare traverals are always parsed in  "ignore newlines" mode, as if
+	// they were wrapped in parentheses.
+	parser.PushIncludeNewlines(false)
+
+	expr, parseDiags := parser.ParseTraversalAbs()
+	diags = append(diags, parseDiags...)
+
+	parser.PopIncludeNewlines()
+
+	// Panic if the parser uses incorrect stack discipline with the peeker's
+	// newlines stack, since otherwise it will produce confusing downstream
+	// errors.
+	peeker.AssertEmptyIncludeNewlinesStack()
+
+	return expr, diags
+}
+
+// LexConfig performs lexical analysis on the given buffer, treating it as a
+// whole HCL config file, and returns the resulting tokens.
+//
+// Only minimal validation is done during lexical analysis, so the returned
+// diagnostics may include errors about lexical issues such as bad character
+// encodings or unrecognized characters, but full parsing is required to
+// detect _all_ syntax errors.
+func LexConfig(src []byte, filename string, start hcl.Pos) (Tokens, hcl.Diagnostics) {
+	tokens := scanTokens(src, filename, start, scanNormal)
+	diags := checkInvalidTokens(tokens)
+	return tokens, diags
+}
+
+// LexExpression performs lexical analysis on the given buffer, treating it as
+// a standalone HCL expression, and returns the resulting tokens.
+//
+// Only minimal validation is done during lexical analysis, so the returned
+// diagnostics may include errors about lexical issues such as bad character
+// encodings or unrecognized characters, but full parsing is required to
+// detect _all_ syntax errors.
+func LexExpression(src []byte, filename string, start hcl.Pos) (Tokens, hcl.Diagnostics) {
+	// This is actually just the same thing as LexConfig, since configs
+	// and expressions lex in the same way.
+	tokens := scanTokens(src, filename, start, scanNormal)
+	diags := checkInvalidTokens(tokens)
+	return tokens, diags
+}
+
+// LexTemplate performs lexical analysis on the given buffer, treating it as a
+// standalone HCL template, and returns the resulting tokens.
+//
+// Only minimal validation is done during lexical analysis, so the returned
+// diagnostics may include errors about lexical issues such as bad character
+// encodings or unrecognized characters, but full parsing is required to
+// detect _all_ syntax errors.
+func LexTemplate(src []byte, filename string, start hcl.Pos) (Tokens, hcl.Diagnostics) {
+	tokens := scanTokens(src, filename, start, scanTemplate)
+	diags := checkInvalidTokens(tokens)
+	return tokens, diags
+}
+
+// ValidIdentifier tests if the given string could be a valid identifier in
+// a native syntax expression.
+//
+// This is useful when accepting names from the user that will be used as
+// variable or attribute names in the scope, to ensure that any name chosen
+// will be traversable using the variable or attribute traversal syntax.
+func ValidIdentifier(s string) bool {
+	// This is a kinda-expensive way to do something pretty simple, but it
+	// is easiest to do with our existing scanner-related infrastructure here
+	// and nobody should be validating identifiers in a tight loop.
+	tokens := scanTokens([]byte(s), "", hcl.Pos{}, scanIdentOnly)
+	return len(tokens) == 2 && tokens[0].Type == TokenIdent && tokens[1].Type == TokenEOF
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.go
new file mode 100644
index 00000000..2895ade7
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.go
@@ -0,0 +1,301 @@
+//line scan_string_lit.rl:1
+
+package hclsyntax
+
+// This file is generated from scan_string_lit.rl. DO NOT EDIT.
+
+//line scan_string_lit.go:9
+var _hclstrtok_actions []byte = []byte{
+	0, 1, 0, 1, 1, 2, 1, 0,
+}
+
+var _hclstrtok_key_offsets []byte = []byte{
+	0, 0, 2, 4, 6, 10, 14, 18,
+	22, 27, 31, 36, 41, 46, 51, 57,
+	62, 74, 85, 96, 107, 118, 129, 140,
+	151,
+}
+
+var _hclstrtok_trans_keys []byte = []byte{
+	128, 191, 128, 191, 128, 191, 10, 13,
+	36, 37, 10, 13, 36, 37, 10, 13,
+	36, 37, 10, 13, 36, 37, 10, 13,
+	36, 37, 123, 10, 13, 36, 37, 10,
+	13, 36, 37, 92, 10, 13, 36, 37,
+	92, 10, 13, 36, 37, 92, 10, 13,
+	36, 37, 92, 10, 13, 36, 37, 92,
+	123, 10, 13, 36, 37, 92, 85, 117,
+	128, 191, 192, 223, 224, 239, 240, 247,
+	248, 255, 10, 13, 36, 37, 92, 48,
+	57, 65, 70, 97, 102, 10, 13, 36,
+	37, 92, 48, 57, 65, 70, 97, 102,
+	10, 13, 36, 37, 92, 48, 57, 65,
+	70, 97, 102, 10, 13, 36, 37, 92,
+	48, 57, 65, 70, 97, 102, 10, 13,
+	36, 37, 92, 48, 57, 65, 70, 97,
+	102, 10, 13, 36, 37, 92, 48, 57,
+	65, 70, 97, 102, 10, 13, 36, 37,
+	92, 48, 57, 65, 70, 97, 102, 10,
+	13, 36, 37, 92, 48, 57, 65, 70,
+	97, 102,
+}
+
+var _hclstrtok_single_lengths []byte = []byte{
+	0, 0, 0, 0, 4, 4, 4, 4,
+	5, 4, 5, 5, 5, 5, 6, 5,
+	2, 5, 5, 5, 5, 5, 5, 5,
+	5,
+}
+
+var _hclstrtok_range_lengths []byte = []byte{
+	0, 1, 1, 1, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	5, 3, 3, 3, 3, 3, 3, 3,
+	3,
+}
+
+var _hclstrtok_index_offsets []byte = []byte{
+	0, 0, 2, 4, 6, 11, 16, 21,
+	26, 32, 37, 43, 49, 55, 61, 68,
+	74, 82, 91, 100, 109, 118, 127, 136,
+	145,
+}
+
+var _hclstrtok_indicies []byte = []byte{
+	0, 1, 2, 1, 3, 1, 5, 6,
+	7, 8, 4, 10, 11, 12, 13, 9,
+	14, 11, 12, 13, 9, 10, 11, 15,
+	13, 9, 10, 11, 12, 13, 14, 9,
+	10, 11, 12, 15, 9, 17, 18, 19,
+	20, 21, 16, 23, 24, 25, 26, 27,
+	22, 0, 24, 25, 26, 27, 22, 23,
+	24, 28, 26, 27, 22, 23, 24, 25,
+	26, 27, 0, 22, 23, 24, 25, 28,
+	27, 22, 29, 30, 22, 2, 3, 31,
+	22, 0, 23, 24, 25, 26, 27, 32,
+	32, 32, 22, 23, 24, 25, 26, 27,
+	33, 33, 33, 22, 23, 24, 25, 26,
+	27, 34, 34, 34, 22, 23, 24, 25,
+	26, 27, 30, 30, 30, 22, 23, 24,
+	25, 26, 27, 35, 35, 35, 22, 23,
+	24, 25, 26, 27, 36, 36, 36, 22,
+	23, 24, 25, 26, 27, 37, 37, 37,
+	22, 23, 24, 25, 26, 27, 0, 0,
+	0, 22,
+}
+
+var _hclstrtok_trans_targs []byte = []byte{
+	11, 0, 1, 2, 4, 5, 6, 7,
+	9, 4, 5, 6, 7, 9, 5, 8,
+	10, 11, 12, 13, 15, 16, 10, 11,
+	12, 13, 15, 16, 14, 17, 21, 3,
+	18, 19, 20, 22, 23, 24,
+}
+
+var _hclstrtok_trans_actions []byte = []byte{
+	0, 0, 0, 0, 0, 1, 1, 1,
+	1, 3, 5, 5, 5, 5, 0, 0,
+	0, 1, 1, 1, 1, 1, 3, 5,
+	5, 5, 5, 5, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0,
+}
+
+var _hclstrtok_eof_actions []byte = []byte{
+	0, 0, 0, 0, 0, 3, 3, 3,
+	3, 3, 0, 3, 3, 3, 3, 3,
+	3, 3, 3, 3, 3, 3, 3, 3,
+	3,
+}
+
+const hclstrtok_start int = 4
+const hclstrtok_first_final int = 4
+const hclstrtok_error int = 0
+
+const hclstrtok_en_quoted int = 10
+const hclstrtok_en_unquoted int = 4
+
+//line scan_string_lit.rl:10
+
+func scanStringLit(data []byte, quoted bool) [][]byte {
+	var ret [][]byte
+
+//line scan_string_lit.rl:61
+
+	// Ragel state
+	p := 0          // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+	ts := 0
+	te := 0
+	eof := pe
+
+	var cs int // current state
+	switch {
+	case quoted:
+		cs = hclstrtok_en_quoted
+	default:
+		cs = hclstrtok_en_unquoted
+	}
+
+	// Make Go compiler happy
+	_ = ts
+	_ = eof
+
+	/*token := func () {
+	    ret = append(ret, data[ts:te])
+	}*/
+
+//line scan_string_lit.go:154
+	{
+	}
+
+//line scan_string_lit.go:158
+	{
+		var _klen int
+		var _trans int
+		var _acts int
+		var _nacts uint
+		var _keys int
+		if p == pe {
+			goto _test_eof
+		}
+		if cs == 0 {
+			goto _out
+		}
+	_resume:
+		_keys = int(_hclstrtok_key_offsets[cs])
+		_trans = int(_hclstrtok_index_offsets[cs])
+
+		_klen = int(_hclstrtok_single_lengths[cs])
+		if _klen > 0 {
+			_lower := int(_keys)
+			var _mid int
+			_upper := int(_keys + _klen - 1)
+			for {
+				if _upper < _lower {
+					break
+				}
+
+				_mid = _lower + ((_upper - _lower) >> 1)
+				switch {
+				case data[p] < _hclstrtok_trans_keys[_mid]:
+					_upper = _mid - 1
+				case data[p] > _hclstrtok_trans_keys[_mid]:
+					_lower = _mid + 1
+				default:
+					_trans += int(_mid - int(_keys))
+					goto _match
+				}
+			}
+			_keys += _klen
+			_trans += _klen
+		}
+
+		_klen = int(_hclstrtok_range_lengths[cs])
+		if _klen > 0 {
+			_lower := int(_keys)
+			var _mid int
+			_upper := int(_keys + (_klen << 1) - 2)
+			for {
+				if _upper < _lower {
+					break
+				}
+
+				_mid = _lower + (((_upper - _lower) >> 1) & ^1)
+				switch {
+				case data[p] < _hclstrtok_trans_keys[_mid]:
+					_upper = _mid - 2
+				case data[p] > _hclstrtok_trans_keys[_mid+1]:
+					_lower = _mid + 2
+				default:
+					_trans += int((_mid - int(_keys)) >> 1)
+					goto _match
+				}
+			}
+			_trans += _klen
+		}
+
+	_match:
+		_trans = int(_hclstrtok_indicies[_trans])
+		cs = int(_hclstrtok_trans_targs[_trans])
+
+		if _hclstrtok_trans_actions[_trans] == 0 {
+			goto _again
+		}
+
+		_acts = int(_hclstrtok_trans_actions[_trans])
+		_nacts = uint(_hclstrtok_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _hclstrtok_actions[_acts-1] {
+			case 0:
+//line scan_string_lit.rl:40
+
+				// If te is behind p then we've skipped over some literal
+				// characters which we must now return.
+				if te < p {
+					ret = append(ret, data[te:p])
+				}
+				ts = p
+
+			case 1:
+//line scan_string_lit.rl:48
+
+				te = p
+				ret = append(ret, data[ts:te])
+
+//line scan_string_lit.go:253
+			}
+		}
+
+	_again:
+		if cs == 0 {
+			goto _out
+		}
+		p++
+		if p != pe {
+			goto _resume
+		}
+	_test_eof:
+		{
+		}
+		if p == eof {
+			__acts := _hclstrtok_eof_actions[cs]
+			__nacts := uint(_hclstrtok_actions[__acts])
+			__acts++
+			for ; __nacts > 0; __nacts-- {
+				__acts++
+				switch _hclstrtok_actions[__acts-1] {
+				case 1:
+//line scan_string_lit.rl:48
+
+					te = p
+					ret = append(ret, data[ts:te])
+
+//line scan_string_lit.go:278
+				}
+			}
+		}
+
+	_out:
+		{
+		}
+	}
+
+//line scan_string_lit.rl:89
+
+	if te < p {
+		// Collect any leftover literal characters at the end of the input
+		ret = append(ret, data[te:p])
+	}
+
+	// If we fall out here without being in a final state then we've
+	// encountered something that the scanner can't match, which should
+	// be impossible (the scanner matches all bytes _somehow_) but we'll
+	// tolerate it and let the caller deal with it.
+	if cs < hclstrtok_first_final {
+		ret = append(ret, data[p:len(data)])
+	}
+
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.rl b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.rl
new file mode 100644
index 00000000..f8ac1175
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.rl
@@ -0,0 +1,105 @@
+
+package hclsyntax
+
+// This file is generated from scan_string_lit.rl. DO NOT EDIT.
+%%{
+  # (except you are actually in scan_string_lit.rl here, so edit away!)
+
+  machine hclstrtok;
+  write data;
+}%%
+
+func scanStringLit(data []byte, quoted bool) [][]byte {
+    var ret [][]byte
+
+    %%{
+        include UnicodeDerived "unicode_derived.rl";
+
+        UTF8Cont = 0x80 .. 0xBF;
+        AnyUTF8 = (
+            0x00..0x7F |
+            0xC0..0xDF . UTF8Cont |
+            0xE0..0xEF . UTF8Cont . UTF8Cont |
+            0xF0..0xF7 . UTF8Cont . UTF8Cont . UTF8Cont
+        );
+        BadUTF8 = any - AnyUTF8;
+
+        Hex = ('0'..'9' | 'a'..'f' | 'A'..'F');
+
+        # Our goal with this patterns is to capture user intent as best as
+        # possible, even if the input is invalid. The caller will then verify
+        # whether each token is valid and generate suitable error messages
+        # if not.
+        UnicodeEscapeShort = "\\u" . Hex{0,4};
+        UnicodeEscapeLong = "\\U" . Hex{0,8};
+        UnicodeEscape = (UnicodeEscapeShort | UnicodeEscapeLong);
+        SimpleEscape = "\\" . (AnyUTF8 - ('U'|'u'))?;
+        TemplateEscape = ("$" . ("$" . ("{"?))?) | ("%" . ("%" . ("{"?))?);
+        Newline = ("\r\n" | "\r" | "\n");
+
+        action Begin {
+            // If te is behind p then we've skipped over some literal
+            // characters which we must now return.
+            if te < p {
+                ret = append(ret, data[te:p])
+            }
+            ts = p;
+        }
+        action End {
+            te = p;
+            ret = append(ret, data[ts:te]);
+        }
+
+        QuotedToken = (UnicodeEscape | SimpleEscape | TemplateEscape | Newline) >Begin %End;
+        UnquotedToken = (TemplateEscape | Newline) >Begin %End;
+        QuotedLiteral = (any - ("\\" | "$" | "%" | "\r" | "\n"));
+        UnquotedLiteral = (any - ("$" | "%" | "\r" | "\n"));
+
+        quoted := (QuotedToken | QuotedLiteral)**;
+        unquoted := (UnquotedToken | UnquotedLiteral)**;
+
+    }%%
+
+    // Ragel state
+	p := 0  // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+    ts := 0
+    te := 0
+    eof := pe
+
+    var cs int // current state
+    switch {
+    case quoted:
+        cs = hclstrtok_en_quoted
+    default:
+        cs = hclstrtok_en_unquoted
+    }
+
+    // Make Go compiler happy
+    _ = ts
+    _ = eof
+
+    /*token := func () {
+        ret = append(ret, data[ts:te])
+    }*/
+
+    %%{
+        write init nocs;
+        write exec;
+    }%%
+
+    if te < p {
+        // Collect any leftover literal characters at the end of the input
+        ret = append(ret, data[te:p])
+    }
+
+    // If we fall out here without being in a final state then we've
+    // encountered something that the scanner can't match, which should
+    // be impossible (the scanner matches all bytes _somehow_) but we'll
+    // tolerate it and let the caller deal with it.
+    if cs < hclstrtok_first_final {
+        ret = append(ret, data[p:len(data)])
+    }
+
+    return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.go
new file mode 100644
index 00000000..794123a8
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.go
@@ -0,0 +1,5265 @@
+//line scan_tokens.rl:1
+
+package hclsyntax
+
+import (
+	"bytes"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+// This file is generated from scan_tokens.rl. DO NOT EDIT.
+
+//line scan_tokens.go:15
+var _hcltok_actions []byte = []byte{
+	0, 1, 0, 1, 1, 1, 3, 1, 4,
+	1, 7, 1, 8, 1, 9, 1, 10,
+	1, 11, 1, 12, 1, 13, 1, 14,
+	1, 15, 1, 16, 1, 17, 1, 18,
+	1, 19, 1, 20, 1, 23, 1, 24,
+	1, 25, 1, 26, 1, 27, 1, 28,
+	1, 29, 1, 30, 1, 31, 1, 32,
+	1, 35, 1, 36, 1, 37, 1, 38,
+	1, 39, 1, 40, 1, 41, 1, 42,
+	1, 43, 1, 44, 1, 47, 1, 48,
+	1, 49, 1, 50, 1, 51, 1, 52,
+	1, 53, 1, 56, 1, 57, 1, 58,
+	1, 59, 1, 60, 1, 61, 1, 62,
+	1, 63, 1, 64, 1, 65, 1, 66,
+	1, 67, 1, 68, 1, 69, 1, 70,
+	1, 71, 1, 72, 1, 73, 1, 74,
+	1, 75, 1, 76, 1, 77, 1, 78,
+	1, 79, 1, 80, 1, 81, 1, 82,
+	1, 83, 1, 84, 1, 85, 2, 0,
+	14, 2, 0, 25, 2, 0, 29, 2,
+	0, 37, 2, 0, 41, 2, 1, 2,
+	2, 4, 5, 2, 4, 6, 2, 4,
+	21, 2, 4, 22, 2, 4, 33, 2,
+	4, 34, 2, 4, 45, 2, 4, 46,
+	2, 4, 54, 2, 4, 55,
+}
+
+var _hcltok_key_offsets []int16 = []int16{
+	0, 0, 1, 2, 4, 9, 13, 15,
+	57, 98, 144, 145, 149, 155, 155, 157,
+	159, 168, 174, 181, 182, 185, 186, 190,
+	195, 204, 208, 212, 220, 222, 224, 226,
+	229, 261, 263, 265, 269, 273, 276, 287,
+	300, 319, 332, 348, 360, 376, 391, 412,
+	422, 434, 445, 459, 474, 484, 496, 505,
+	517, 519, 523, 544, 553, 563, 569, 575,
+	576, 625, 627, 631, 633, 639, 646, 654,
+	661, 664, 670, 674, 678, 680, 684, 688,
+	692, 698, 706, 714, 720, 722, 726, 728,
+	734, 738, 742, 746, 750, 755, 762, 768,
+	770, 772, 776, 778, 784, 788, 792, 802,
+	807, 821, 836, 838, 846, 848, 853, 867,
+	872, 874, 878, 879, 883, 889, 895, 905,
+	915, 926, 934, 937, 940, 944, 948, 950,
+	953, 953, 956, 958, 988, 990, 992, 996,
+	1001, 1005, 1010, 1012, 1014, 1016, 1025, 1029,
+	1033, 1039, 1041, 1049, 1057, 1069, 1072, 1078,
+	1082, 1084, 1088, 1108, 1110, 1112, 1123, 1129,
+	1131, 1133, 1135, 1139, 1145, 1151, 1153, 1158,
+	1162, 1164, 1172, 1190, 1230, 1240, 1244, 1246,
+	1248, 1249, 1253, 1257, 1261, 1265, 1269, 1274,
+	1278, 1282, 1286, 1288, 1290, 1294, 1304, 1308,
+	1310, 1314, 1318, 1322, 1335, 1337, 1339, 1343,
+	1345, 1349, 1351, 1353, 1383, 1387, 1391, 1395,
+	1398, 1405, 1410, 1421, 1425, 1441, 1455, 1459,
+	1464, 1468, 1472, 1478, 1480, 1486, 1488, 1492,
+	1494, 1500, 1505, 1510, 1520, 1522, 1524, 1528,
+	1532, 1534, 1547, 1549, 1553, 1557, 1565, 1567,
+	1571, 1573, 1574, 1577, 1582, 1584, 1586, 1590,
+	1592, 1596, 1602, 1622, 1628, 1634, 1636, 1637,
+	1647, 1648, 1656, 1663, 1665, 1668, 1670, 1672,
+	1674, 1679, 1683, 1687, 1692, 1702, 1712, 1716,
+	1720, 1734, 1760, 1770, 1772, 1774, 1777, 1779,
+	1782, 1784, 1788, 1790, 1791, 1795, 1797, 1800,
+	1807, 1815, 1817, 1819, 1823, 1825, 1831, 1842,
+	1845, 1847, 1851, 1856, 1886, 1891, 1893, 1896,
+	1901, 1915, 1922, 1936, 1941, 1954, 1958, 1971,
+	1976, 1994, 1995, 2004, 2008, 2020, 2025, 2032,
+	2039, 2046, 2048, 2052, 2074, 2079, 2080, 2084,
+	2086, 2136, 2139, 2150, 2154, 2156, 2162, 2168,
+	2170, 2175, 2177, 2181, 2183, 2184, 2186, 2188,
+	2194, 2196, 2198, 2202, 2208, 2221, 2223, 2229,
+	2233, 2241, 2252, 2260, 2263, 2293, 2299, 2302,
+	2307, 2309, 2313, 2317, 2321, 2323, 2330, 2332,
+	2341, 2348, 2356, 2358, 2378, 2390, 2394, 2396,
+	2414, 2453, 2455, 2459, 2461, 2468, 2472, 2500,
+	2502, 2504, 2506, 2508, 2511, 2513, 2517, 2521,
+	2523, 2526, 2528, 2530, 2533, 2535, 2537, 2538,
+	2540, 2542, 2546, 2550, 2553, 2566, 2568, 2574,
+	2578, 2580, 2584, 2588, 2602, 2605, 2614, 2616,
+	2620, 2626, 2626, 2628, 2630, 2639, 2645, 2652,
+	2653, 2656, 2657, 2661, 2666, 2675, 2679, 2683,
+	2691, 2693, 2695, 2697, 2700, 2732, 2734, 2736,
+	2740, 2744, 2747, 2758, 2771, 2790, 2803, 2819,
+	2831, 2847, 2862, 2883, 2893, 2905, 2916, 2930,
+	2945, 2955, 2967, 2976, 2988, 2990, 2994, 3015,
+	3024, 3034, 3040, 3046, 3047, 3096, 3098, 3102,
+	3104, 3110, 3117, 3125, 3132, 3135, 3141, 3145,
+	3149, 3151, 3155, 3159, 3163, 3169, 3177, 3185,
+	3191, 3193, 3197, 3199, 3205, 3209, 3213, 3217,
+	3221, 3226, 3233, 3239, 3241, 3243, 3247, 3249,
+	3255, 3259, 3263, 3273, 3278, 3292, 3307, 3309,
+	3317, 3319, 3324, 3338, 3343, 3345, 3349, 3350,
+	3354, 3360, 3366, 3376, 3386, 3397, 3405, 3408,
+	3411, 3415, 3419, 3421, 3424, 3424, 3427, 3429,
+	3459, 3461, 3463, 3467, 3472, 3476, 3481, 3483,
+	3485, 3487, 3496, 3500, 3504, 3510, 3512, 3520,
+	3528, 3540, 3543, 3549, 3553, 3555, 3559, 3579,
+	3581, 3583, 3594, 3600, 3602, 3604, 3606, 3610,
+	3616, 3622, 3624, 3629, 3633, 3635, 3643, 3661,
+	3701, 3711, 3715, 3717, 3719, 3720, 3724, 3728,
+	3732, 3736, 3740, 3745, 3749, 3753, 3757, 3759,
+	3761, 3765, 3775, 3779, 3781, 3785, 3789, 3793,
+	3806, 3808, 3810, 3814, 3816, 3820, 3822, 3824,
+	3854, 3858, 3862, 3866, 3869, 3876, 3881, 3892,
+	3896, 3912, 3926, 3930, 3935, 3939, 3943, 3949,
+	3951, 3957, 3959, 3963, 3965, 3971, 3976, 3981,
+	3991, 3993, 3995, 3999, 4003, 4005, 4018, 4020,
+	4024, 4028, 4036, 4038, 4042, 4044, 4045, 4048,
+	4053, 4055, 4057, 4061, 4063, 4067, 4073, 4093,
+	4099, 4105, 4107, 4108, 4118, 4119, 4127, 4134,
+	4136, 4139, 4141, 4143, 4145, 4150, 4154, 4158,
+	4163, 4173, 4183, 4187, 4191, 4205, 4231, 4241,
+	4243, 4245, 4248, 4250, 4253, 4255, 4259, 4261,
+	4262, 4266, 4268, 4270, 4277, 4281, 4288, 4295,
+	4304, 4320, 4332, 4350, 4361, 4373, 4381, 4399,
+	4407, 4437, 4440, 4450, 4460, 4472, 4483, 4492,
+	4505, 4517, 4521, 4527, 4554, 4563, 4566, 4571,
+	4577, 4582, 4603, 4607, 4613, 4613, 4620, 4629,
+	4637, 4640, 4644, 4650, 4656, 4659, 4663, 4670,
+	4676, 4685, 4694, 4698, 4702, 4706, 4710, 4717,
+	4721, 4725, 4735, 4741, 4745, 4751, 4755, 4758,
+	4764, 4770, 4782, 4786, 4790, 4800, 4804, 4815,
+	4817, 4819, 4823, 4835, 4840, 4864, 4868, 4874,
+	4896, 4905, 4909, 4912, 4913, 4921, 4929, 4935,
+	4945, 4952, 4970, 4973, 4976, 4984, 4990, 4994,
+	4998, 5002, 5008, 5016, 5021, 5027, 5031, 5039,
+	5046, 5050, 5057, 5063, 5071, 5079, 5085, 5091,
+	5102, 5106, 5118, 5127, 5144, 5161, 5164, 5168,
+	5170, 5176, 5178, 5182, 5197, 5201, 5205, 5209,
+	5213, 5217, 5219, 5225, 5230, 5234, 5240, 5247,
+	5250, 5268, 5270, 5315, 5321, 5327, 5331, 5335,
+	5341, 5345, 5351, 5357, 5364, 5366, 5372, 5378,
+	5382, 5386, 5394, 5407, 5413, 5420, 5428, 5434,
+	5443, 5449, 5453, 5458, 5462, 5470, 5474, 5478,
+	5508, 5514, 5520, 5526, 5532, 5539, 5545, 5552,
+	5557, 5567, 5571, 5578, 5584, 5588, 5595, 5599,
+	5605, 5608, 5612, 5616, 5620, 5624, 5629, 5634,
+	5638, 5649, 5653, 5657, 5663, 5671, 5675, 5692,
+	5696, 5702, 5712, 5718, 5724, 5727, 5732, 5741,
+	5745, 5749, 5755, 5759, 5765, 5773, 5791, 5792,
+	5802, 5803, 5812, 5820, 5822, 5825, 5827, 5829,
+	5831, 5836, 5849, 5853, 5868, 5897, 5908, 5910,
+	5914, 5918, 5923, 5927, 5929, 5936, 5940, 5948,
+	5952, 5964, 5966, 5968, 5970, 5972, 5974, 5975,
+	5977, 5979, 5981, 5983, 5985, 5986, 5988, 5990,
+	5992, 5994, 5996, 6000, 6006, 6006, 6008, 6010,
+	6019, 6025, 6032, 6033, 6036, 6037, 6041, 6046,
+	6055, 6059, 6063, 6071, 6073, 6075, 6077, 6080,
+	6112, 6114, 6116, 6120, 6124, 6127, 6138, 6151,
+	6170, 6183, 6199, 6211, 6227, 6242, 6263, 6273,
+	6285, 6296, 6310, 6325, 6335, 6347, 6356, 6368,
+	6370, 6374, 6395, 6404, 6414, 6420, 6426, 6427,
+	6476, 6478, 6482, 6484, 6490, 6497, 6505, 6512,
+	6515, 6521, 6525, 6529, 6531, 6535, 6539, 6543,
+	6549, 6557, 6565, 6571, 6573, 6577, 6579, 6585,
+	6589, 6593, 6597, 6601, 6606, 6613, 6619, 6621,
+	6623, 6627, 6629, 6635, 6639, 6643, 6653, 6658,
+	6672, 6687, 6689, 6697, 6699, 6704, 6718, 6723,
+	6725, 6729, 6730, 6734, 6740, 6746, 6756, 6766,
+	6777, 6785, 6788, 6791, 6795, 6799, 6801, 6804,
+	6804, 6807, 6809, 6839, 6841, 6843, 6847, 6852,
+	6856, 6861, 6863, 6865, 6867, 6876, 6880, 6884,
+	6890, 6892, 6900, 6908, 6920, 6923, 6929, 6933,
+	6935, 6939, 6959, 6961, 6963, 6974, 6980, 6982,
+	6984, 6986, 6990, 6996, 7002, 7004, 7009, 7013,
+	7015, 7023, 7041, 7081, 7091, 7095, 7097, 7099,
+	7100, 7104, 7108, 7112, 7116, 7120, 7125, 7129,
+	7133, 7137, 7139, 7141, 7145, 7155, 7159, 7161,
+	7165, 7169, 7173, 7186, 7188, 7190, 7194, 7196,
+	7200, 7202, 7204, 7234, 7238, 7242, 7246, 7249,
+	7256, 7261, 7272, 7276, 7292, 7306, 7310, 7315,
+	7319, 7323, 7329, 7331, 7337, 7339, 7343, 7345,
+	7351, 7356, 7361, 7371, 7373, 7375, 7379, 7383,
+	7385, 7398, 7400, 7404, 7408, 7416, 7418, 7422,
+	7424, 7425, 7428, 7433, 7435, 7437, 7441, 7443,
+	7447, 7453, 7473, 7479, 7485, 7487, 7488, 7498,
+	7499, 7507, 7514, 7516, 7519, 7521, 7523, 7525,
+	7530, 7534, 7538, 7543, 7553, 7563, 7567, 7571,
+	7585, 7611, 7621, 7623, 7625, 7628, 7630, 7633,
+	7635, 7639, 7641, 7642, 7646, 7648, 7650, 7657,
+	7661, 7668, 7675, 7684, 7700, 7712, 7730, 7741,
+	7753, 7761, 7779, 7787, 7817, 7820, 7830, 7840,
+	7852, 7863, 7872, 7885, 7897, 7901, 7907, 7934,
+	7943, 7946, 7951, 7957, 7962, 7983, 7987, 7993,
+	7993, 8000, 8009, 8017, 8020, 8024, 8030, 8036,
+	8039, 8043, 8050, 8056, 8065, 8074, 8078, 8082,
+	8086, 8090, 8097, 8101, 8105, 8115, 8121, 8125,
+	8131, 8135, 8138, 8144, 8150, 8162, 8166, 8170,
+	8180, 8184, 8195, 8197, 8199, 8203, 8215, 8220,
+	8244, 8248, 8254, 8276, 8285, 8289, 8292, 8293,
+	8301, 8309, 8315, 8325, 8332, 8350, 8353, 8356,
+	8364, 8370, 8374, 8378, 8382, 8388, 8396, 8401,
+	8407, 8411, 8419, 8426, 8430, 8437, 8443, 8451,
+	8459, 8465, 8471, 8482, 8486, 8498, 8507, 8524,
+	8541, 8544, 8548, 8550, 8556, 8558, 8562, 8577,
+	8581, 8585, 8589, 8593, 8597, 8599, 8605, 8610,
+	8614, 8620, 8627, 8630, 8648, 8650, 8695, 8701,
+	8707, 8711, 8715, 8721, 8725, 8731, 8737, 8744,
+	8746, 8752, 8758, 8762, 8766, 8774, 8787, 8793,
+	8800, 8808, 8814, 8823, 8829, 8833, 8838, 8842,
+	8850, 8854, 8858, 8888, 8894, 8900, 8906, 8912,
+	8919, 8925, 8932, 8937, 8947, 8951, 8958, 8964,
+	8968, 8975, 8979, 8985, 8988, 8992, 8996, 9000,
+	9004, 9009, 9014, 9018, 9029, 9033, 9037, 9043,
+	9051, 9055, 9072, 9076, 9082, 9092, 9098, 9104,
+	9107, 9112, 9121, 9125, 9129, 9135, 9139, 9145,
+	9153, 9171, 9172, 9182, 9183, 9192, 9200, 9202,
+	9205, 9207, 9209, 9211, 9216, 9229, 9233, 9248,
+	9277, 9288, 9290, 9294, 9298, 9303, 9307, 9309,
+	9316, 9320, 9328, 9332, 9407, 9409, 9410, 9411,
+	9412, 9413, 9414, 9416, 9421, 9423, 9425, 9426,
+	9470, 9471, 9472, 9474, 9479, 9483, 9483, 9485,
+	9487, 9498, 9508, 9516, 9517, 9519, 9520, 9524,
+	9528, 9538, 9542, 9549, 9560, 9567, 9571, 9577,
+	9588, 9620, 9669, 9684, 9699, 9704, 9706, 9711,
+	9743, 9751, 9753, 9775, 9797, 9799, 9815, 9831,
+	9833, 9835, 9835, 9836, 9837, 9838, 9840, 9841,
+	9853, 9855, 9857, 9859, 9873, 9887, 9889, 9892,
+	9895, 9897, 9898, 9899, 9901, 9903, 9905, 9919,
+	9933, 9935, 9938, 9941, 9943, 9944, 9945, 9947,
+	9949, 9951, 10000, 10044, 10046, 10051, 10055, 10055,
+	10057, 10059, 10070, 10080, 10088, 10089, 10091, 10092,
+	10096, 10100, 10110, 10114, 10121, 10132, 10139, 10143,
+	10149, 10160, 10192, 10241, 10256, 10271, 10276, 10278,
+	10283, 10315, 10323, 10325, 10347, 10369,
+}
+
+var _hcltok_trans_keys []byte = []byte{
+	46, 42, 42, 47, 46, 69, 101, 48,
+	57, 43, 45, 48, 57, 48, 57, 45,
+	95, 194, 195, 198, 199, 203, 205, 206,
+	207, 210, 212, 213, 214, 215, 216, 217,
+	219, 220, 221, 222, 223, 224, 225, 226,
+	227, 228, 233, 234, 237, 239, 240, 65,
+	90, 97, 122, 196, 202, 208, 218, 229,
+	236, 95, 194, 195, 198, 199, 203, 205,
+	206, 207, 210, 212, 213, 214, 215, 216,
+	217, 219, 220, 221, 222, 223, 224, 225,
+	226, 227, 228, 233, 234, 237, 239, 240,
+	65, 90, 97, 122, 196, 202, 208, 218,
+	229, 236, 10, 13, 45, 95, 194, 195,
+	198, 199, 203, 204, 205, 206, 207, 210,
+	212, 213, 214, 215, 216, 217, 219, 220,
+	221, 222, 223, 224, 225, 226, 227, 228,
+	233, 234, 237, 239, 240, 243, 48, 57,
+	65, 90, 97, 122, 196, 218, 229, 236,
+	10, 170, 181, 183, 186, 128, 150, 152,
+	182, 184, 255, 192, 255, 128, 255, 173,
+	130, 133, 146, 159, 165, 171, 175, 255,
+	181, 190, 184, 185, 192, 255, 140, 134,
+	138, 142, 161, 163, 255, 182, 130, 136,
+	137, 176, 151, 152, 154, 160, 190, 136,
+	144, 192, 255, 135, 129, 130, 132, 133,
+	144, 170, 176, 178, 144, 154, 160, 191,
+	128, 169, 174, 255, 148, 169, 157, 158,
+	189, 190, 192, 255, 144, 255, 139, 140,
+	178, 255, 186, 128, 181, 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, 128, 173, 128,
+	155, 160, 180, 182, 189, 148, 161, 163,
+	255, 176, 164, 165, 132, 169, 177, 141,
+	142, 145, 146, 179, 181, 186, 187, 158,
+	133, 134, 137, 138, 143, 150, 152, 155,
+	164, 165, 178, 255, 188, 129, 131, 133,
+	138, 143, 144, 147, 168, 170, 176, 178,
+	179, 181, 182, 184, 185, 190, 255, 157,
+	131, 134, 137, 138, 142, 144, 146, 152,
+	159, 165, 182, 255, 129, 131, 133, 141,
+	143, 145, 147, 168, 170, 176, 178, 179,
+	181, 185, 188, 255, 134, 138, 142, 143,
+	145, 159, 164, 165, 176, 184, 186, 255,
+	129, 131, 133, 140, 143, 144, 147, 168,
+	170, 176, 178, 179, 181, 185, 188, 191,
+	177, 128, 132, 135, 136, 139, 141, 150,
+	151, 156, 157, 159, 163, 166, 175, 156,
+	130, 131, 133, 138, 142, 144, 146, 149,
+	153, 154, 158, 159, 163, 164, 168, 170,
+	174, 185, 190, 191, 144, 151, 128, 130,
+	134, 136, 138, 141, 166, 175, 128, 131,
+	133, 140, 142, 144, 146, 168, 170, 185,
+	189, 255, 133, 137, 151, 142, 148, 155,
+	159, 164, 165, 176, 255, 128, 131, 133,
+	140, 142, 144, 146, 168, 170, 179, 181,
+	185, 188, 191, 158, 128, 132, 134, 136,
+	138, 141, 149, 150, 160, 163, 166, 175,
+	177, 178, 129, 131, 133, 140, 142, 144,
+	146, 186, 189, 255, 133, 137, 143, 147,
+	152, 158, 164, 165, 176, 185, 192, 255,
+	189, 130, 131, 133, 150, 154, 177, 179,
+	187, 138, 150, 128, 134, 143, 148, 152,
+	159, 166, 175, 178, 179, 129, 186, 128,
+	142, 144, 153, 132, 138, 141, 165, 167,
+	129, 130, 135, 136, 148, 151, 153, 159,
+	161, 163, 170, 171, 173, 185, 187, 189,
+	134, 128, 132, 136, 141, 144, 153, 156,
+	159, 128, 181, 183, 185, 152, 153, 160,
+	169, 190, 191, 128, 135, 137, 172, 177,
+	191, 128, 132, 134, 151, 153, 188, 134,
+	128, 129, 130, 131, 137, 138, 139, 140,
+	141, 142, 143, 144, 153, 154, 155, 156,
+	157, 158, 159, 160, 161, 162, 163, 164,
+	165, 166, 167, 168, 169, 170, 173, 175,
+	176, 177, 178, 179, 181, 182, 183, 188,
+	189, 190, 191, 132, 152, 172, 184, 185,
+	187, 128, 191, 128, 137, 144, 255, 158,
+	159, 134, 187, 136, 140, 142, 143, 137,
+	151, 153, 142, 143, 158, 159, 137, 177,
+	142, 143, 182, 183, 191, 255, 128, 130,
+	133, 136, 150, 152, 255, 145, 150, 151,
+	155, 156, 160, 168, 178, 255, 128, 143,
+	160, 255, 182, 183, 190, 255, 129, 255,
+	173, 174, 192, 255, 129, 154, 160, 255,
+	171, 173, 185, 255, 128, 140, 142, 148,
+	160, 180, 128, 147, 160, 172, 174, 176,
+	178, 179, 148, 150, 152, 155, 158, 159,
+	170, 255, 139, 141, 144, 153, 160, 255,
+	184, 255, 128, 170, 176, 255, 182, 255,
+	128, 158, 160, 171, 176, 187, 134, 173,
+	176, 180, 128, 171, 176, 255, 138, 143,
+	155, 255, 128, 155, 160, 255, 159, 189,
+	190, 192, 255, 167, 128, 137, 144, 153,
+	176, 189, 140, 143, 154, 170, 180, 255,
+	180, 255, 128, 183, 128, 137, 141, 189,
+	128, 136, 144, 146, 148, 182, 184, 185,
+	128, 181, 187, 191, 150, 151, 158, 159,
+	152, 154, 156, 158, 134, 135, 142, 143,
+	190, 255, 190, 128, 180, 182, 188, 130,
+	132, 134, 140, 144, 147, 150, 155, 160,
+	172, 178, 180, 182, 188, 128, 129, 130,
+	131, 132, 133, 134, 176, 177, 178, 179,
+	180, 181, 182, 183, 191, 255, 129, 147,
+	149, 176, 178, 190, 192, 255, 144, 156,
+	161, 144, 156, 165, 176, 130, 135, 149,
+	164, 166, 168, 138, 147, 152, 157, 170,
+	185, 188, 191, 142, 133, 137, 160, 255,
+	137, 255, 128, 174, 176, 255, 159, 165,
+	170, 180, 255, 167, 173, 128, 165, 176,
+	255, 168, 174, 176, 190, 192, 255, 128,
+	150, 160, 166, 168, 174, 176, 182, 184,
+	190, 128, 134, 136, 142, 144, 150, 152,
+	158, 160, 191, 128, 129, 130, 131, 132,
+	133, 134, 135, 144, 145, 255, 133, 135,
+	161, 175, 177, 181, 184, 188, 160, 151,
+	152, 187, 192, 255, 133, 173, 177, 255,
+	143, 159, 187, 255, 176, 191, 182, 183,
+	184, 191, 192, 255, 150, 255, 128, 146,
+	147, 148, 152, 153, 154, 155, 156, 158,
+	159, 160, 161, 162, 163, 164, 165, 166,
+	167, 168, 169, 170, 171, 172, 173, 174,
+	175, 176, 129, 255, 141, 255, 144, 189,
+	141, 143, 172, 255, 191, 128, 175, 180,
+	189, 151, 159, 162, 255, 175, 137, 138,
+	184, 255, 183, 255, 168, 255, 128, 179,
+	188, 134, 143, 154, 159, 184, 186, 190,
+	255, 128, 173, 176, 255, 148, 159, 189,
+	255, 129, 142, 154, 159, 191, 255, 128,
+	182, 128, 141, 144, 153, 160, 182, 186,
+	255, 128, 130, 155, 157, 160, 175, 178,
+	182, 129, 134, 137, 142, 145, 150, 160,
+	166, 168, 174, 176, 255, 155, 166, 175,
+	128, 170, 172, 173, 176, 185, 158, 159,
+	160, 255, 164, 175, 135, 138, 188, 255,
+	164, 169, 171, 172, 173, 174, 175, 180,
+	181, 182, 183, 184, 185, 187, 188, 189,
+	190, 191, 165, 186, 174, 175, 154, 255,
+	190, 128, 134, 147, 151, 157, 168, 170,
+	182, 184, 188, 128, 129, 131, 132, 134,
+	255, 147, 255, 190, 255, 144, 145, 136,
+	175, 188, 255, 128, 143, 160, 175, 179,
+	180, 141, 143, 176, 180, 182, 255, 189,
+	255, 191, 144, 153, 161, 186, 129, 154,
+	166, 255, 191, 255, 130, 135, 138, 143,
+	146, 151, 154, 156, 144, 145, 146, 147,
+	148, 150, 151, 152, 155, 157, 158, 160,
+	170, 171, 172, 175, 161, 169, 128, 129,
+	130, 131, 133, 135, 138, 139, 140, 141,
+	142, 143, 144, 145, 146, 147, 148, 149,
+	152, 156, 157, 160, 161, 162, 163, 164,
+	166, 168, 169, 170, 171, 172, 173, 174,
+	176, 177, 153, 155, 178, 179, 128, 139,
+	141, 166, 168, 186, 188, 189, 191, 255,
+	142, 143, 158, 255, 187, 255, 128, 180,
+	189, 128, 156, 160, 255, 145, 159, 161,
+	255, 128, 159, 176, 255, 139, 143, 187,
+	255, 128, 157, 160, 255, 144, 132, 135,
+	150, 255, 158, 159, 170, 175, 148, 151,
+	188, 255, 128, 167, 176, 255, 164, 255,
+	183, 255, 128, 149, 160, 167, 136, 188,
+	128, 133, 138, 181, 183, 184, 191, 255,
+	150, 159, 183, 255, 128, 158, 160, 178,
+	180, 181, 128, 149, 160, 185, 128, 183,
+	190, 191, 191, 128, 131, 133, 134, 140,
+	147, 149, 151, 153, 179, 184, 186, 160,
+	188, 128, 156, 128, 135, 137, 166, 128,
+	181, 128, 149, 160, 178, 128, 145, 128,
+	178, 129, 130, 131, 132, 133, 135, 136,
+	138, 139, 140, 141, 144, 145, 146, 147,
+	150, 151, 152, 153, 154, 155, 156, 162,
+	163, 171, 176, 177, 178, 128, 134, 135,
+	165, 176, 190, 144, 168, 176, 185, 128,
+	180, 182, 191, 182, 144, 179, 155, 133,
+	137, 141, 143, 157, 255, 190, 128, 145,
+	147, 183, 136, 128, 134, 138, 141, 143,
+	157, 159, 168, 176, 255, 171, 175, 186,
+	255, 128, 131, 133, 140, 143, 144, 147,
+	168, 170, 176, 178, 179, 181, 185, 188,
+	191, 144, 151, 128, 132, 135, 136, 139,
+	141, 157, 163, 166, 172, 176, 180, 128,
+	138, 144, 153, 134, 136, 143, 154, 255,
+	128, 181, 184, 255, 129, 151, 158, 255,
+	129, 131, 133, 143, 154, 255, 128, 137,
+	128, 153, 157, 171, 176, 185, 160, 255,
+	170, 190, 192, 255, 128, 184, 128, 136,
+	138, 182, 184, 191, 128, 144, 153, 178,
+	255, 168, 144, 145, 183, 255, 128, 142,
+	145, 149, 129, 141, 144, 146, 147, 148,
+	175, 255, 132, 255, 128, 144, 129, 143,
+	144, 153, 145, 152, 135, 255, 160, 168,
+	169, 171, 172, 173, 174, 188, 189, 190,
+	191, 161, 167, 185, 255, 128, 158, 160,
+	169, 144, 173, 176, 180, 128, 131, 144,
+	153, 163, 183, 189, 255, 144, 255, 133,
+	143, 191, 255, 143, 159, 160, 128, 129,
+	255, 159, 160, 171, 172, 255, 173, 255,
+	179, 255, 128, 176, 177, 178, 128, 129,
+	171, 175, 189, 255, 128, 136, 144, 153,
+	157, 158, 133, 134, 137, 144, 145, 146,
+	147, 148, 149, 154, 155, 156, 157, 158,
+	159, 168, 169, 170, 150, 153, 165, 169,
+	173, 178, 187, 255, 131, 132, 140, 169,
+	174, 255, 130, 132, 149, 157, 173, 186,
+	188, 160, 161, 163, 164, 167, 168, 132,
+	134, 149, 157, 186, 139, 140, 191, 255,
+	134, 128, 132, 138, 144, 146, 255, 166,
+	167, 129, 155, 187, 149, 181, 143, 175,
+	137, 169, 131, 140, 141, 192, 255, 128,
+	182, 187, 255, 173, 180, 182, 255, 132,
+	155, 159, 161, 175, 128, 160, 163, 164,
+	165, 184, 185, 186, 161, 162, 128, 134,
+	136, 152, 155, 161, 163, 164, 166, 170,
+	133, 143, 151, 255, 139, 143, 154, 255,
+	164, 167, 185, 187, 128, 131, 133, 159,
+	161, 162, 169, 178, 180, 183, 130, 135,
+	137, 139, 148, 151, 153, 155, 157, 159,
+	164, 190, 141, 143, 145, 146, 161, 162,
+	167, 170, 172, 178, 180, 183, 185, 188,
+	128, 137, 139, 155, 161, 163, 165, 169,
+	171, 187, 155, 156, 151, 255, 156, 157,
+	160, 181, 255, 186, 187, 255, 162, 255,
+	160, 168, 161, 167, 158, 255, 160, 132,
+	135, 133, 134, 176, 255, 170, 181, 186,
+	191, 176, 180, 182, 183, 186, 189, 134,
+	140, 136, 138, 142, 161, 163, 255, 130,
+	137, 136, 255, 144, 170, 176, 178, 160,
+	191, 128, 138, 174, 175, 177, 255, 148,
+	150, 164, 167, 173, 176, 185, 189, 190,
+	192, 255, 144, 146, 175, 141, 255, 166,
+	176, 178, 255, 186, 138, 170, 180, 181,
+	160, 161, 162, 164, 165, 166, 167, 168,
+	169, 170, 171, 172, 173, 174, 175, 176,
+	177, 178, 179, 180, 181, 182, 184, 186,
+	187, 188, 189, 190, 183, 185, 154, 164,
+	168, 128, 149, 128, 152, 189, 132, 185,
+	144, 152, 161, 177, 255, 169, 177, 129,
+	132, 141, 142, 145, 146, 179, 181, 186,
+	188, 190, 255, 142, 156, 157, 159, 161,
+	176, 177, 133, 138, 143, 144, 147, 168,
+	170, 176, 178, 179, 181, 182, 184, 185,
+	158, 153, 156, 178, 180, 189, 133, 141,
+	143, 145, 147, 168, 170, 176, 178, 179,
+	181, 185, 144, 185, 160, 161, 189, 133,
+	140, 143, 144, 147, 168, 170, 176, 178,
+	179, 181, 185, 177, 156, 157, 159, 161,
+	131, 156, 133, 138, 142, 144, 146, 149,
+	153, 154, 158, 159, 163, 164, 168, 170,
+	174, 185, 144, 189, 133, 140, 142, 144,
+	146, 168, 170, 185, 152, 154, 160, 161,
+	128, 189, 133, 140, 142, 144, 146, 168,
+	170, 179, 181, 185, 158, 160, 161, 177,
+	178, 189, 133, 140, 142, 144, 146, 186,
+	142, 148, 150, 159, 161, 186, 191, 189,
+	133, 150, 154, 177, 179, 187, 128, 134,
+	129, 176, 178, 179, 132, 138, 141, 165,
+	167, 189, 129, 130, 135, 136, 148, 151,
+	153, 159, 161, 163, 170, 171, 173, 176,
+	178, 179, 134, 128, 132, 156, 159, 128,
+	128, 135, 137, 172, 136, 140, 128, 129,
+	130, 131, 137, 138, 139, 140, 141, 142,
+	143, 144, 153, 154, 155, 156, 157, 158,
+	159, 160, 161, 162, 163, 164, 165, 166,
+	167, 168, 169, 170, 172, 173, 174, 175,
+	176, 177, 178, 179, 180, 181, 182, 184,
+	188, 189, 190, 191, 132, 152, 185, 187,
+	191, 128, 170, 161, 144, 149, 154, 157,
+	165, 166, 174, 176, 181, 255, 130, 141,
+	143, 159, 155, 255, 128, 140, 142, 145,
+	160, 177, 128, 145, 160, 172, 174, 176,
+	151, 156, 170, 128, 168, 176, 255, 138,
+	255, 128, 150, 160, 255, 149, 255, 167,
+	133, 179, 133, 139, 131, 160, 174, 175,
+	186, 255, 166, 255, 128, 163, 141, 143,
+	154, 189, 169, 172, 174, 177, 181, 182,
+	129, 130, 132, 133, 134, 176, 177, 178,
+	179, 180, 181, 182, 183, 177, 191, 165,
+	170, 175, 177, 180, 255, 168, 174, 176,
+	255, 128, 134, 136, 142, 144, 150, 152,
+	158, 128, 129, 130, 131, 132, 133, 134,
+	135, 144, 145, 255, 133, 135, 161, 169,
+	177, 181, 184, 188, 160, 151, 154, 128,
+	146, 147, 148, 152, 153, 154, 155, 156,
+	158, 159, 160, 161, 162, 163, 164, 165,
+	166, 167, 168, 169, 170, 171, 172, 173,
+	174, 175, 176, 129, 255, 141, 143, 160,
+	169, 172, 255, 191, 128, 174, 130, 134,
+	139, 163, 255, 130, 179, 187, 189, 178,
+	183, 138, 165, 176, 255, 135, 159, 189,
+	255, 132, 178, 143, 160, 164, 166, 175,
+	186, 190, 128, 168, 186, 128, 130, 132,
+	139, 160, 182, 190, 255, 176, 178, 180,
+	183, 184, 190, 255, 128, 130, 155, 157,
+	160, 170, 178, 180, 128, 162, 164, 169,
+	171, 172, 173, 174, 175, 180, 181, 182,
+	183, 185, 186, 187, 188, 189, 190, 191,
+	165, 179, 157, 190, 128, 134, 147, 151,
+	159, 168, 170, 182, 184, 188, 176, 180,
+	182, 255, 161, 186, 144, 145, 146, 147,
+	148, 150, 151, 152, 155, 157, 158, 160,
+	170, 171, 172, 175, 161, 169, 128, 129,
+	130, 131, 133, 138, 139, 140, 141, 142,
+	143, 144, 145, 146, 147, 148, 149, 152,
+	156, 157, 160, 161, 162, 163, 164, 166,
+	168, 169, 170, 171, 172, 173, 174, 176,
+	177, 153, 155, 178, 179, 145, 255, 139,
+	143, 182, 255, 158, 175, 128, 144, 147,
+	149, 151, 153, 179, 128, 135, 137, 164,
+	128, 130, 131, 132, 133, 134, 135, 136,
+	138, 139, 140, 141, 144, 145, 146, 147,
+	150, 151, 152, 153, 154, 156, 162, 163,
+	171, 176, 177, 178, 131, 183, 131, 175,
+	144, 168, 131, 166, 182, 144, 178, 131,
+	178, 154, 156, 129, 132, 128, 145, 147,
+	171, 159, 255, 144, 157, 161, 135, 138,
+	128, 175, 135, 132, 133, 128, 174, 152,
+	155, 132, 128, 170, 128, 153, 160, 190,
+	192, 255, 128, 136, 138, 174, 128, 178,
+	255, 160, 168, 169, 171, 172, 173, 174,
+	188, 189, 190, 191, 161, 167, 144, 173,
+	128, 131, 163, 183, 189, 255, 133, 143,
+	145, 255, 147, 159, 128, 176, 177, 178,
+	128, 136, 144, 153, 144, 145, 146, 147,
+	148, 149, 154, 155, 156, 157, 158, 159,
+	150, 153, 131, 140, 255, 160, 163, 164,
+	165, 184, 185, 186, 161, 162, 133, 255,
+	170, 181, 183, 186, 128, 150, 152, 182,
+	184, 255, 192, 255, 128, 255, 173, 130,
+	133, 146, 159, 165, 171, 175, 255, 181,
+	190, 184, 185, 192, 255, 140, 134, 138,
+	142, 161, 163, 255, 182, 130, 136, 137,
+	176, 151, 152, 154, 160, 190, 136, 144,
+	192, 255, 135, 129, 130, 132, 133, 144,
+	170, 176, 178, 144, 154, 160, 191, 128,
+	169, 174, 255, 148, 169, 157, 158, 189,
+	190, 192, 255, 144, 255, 139, 140, 178,
+	255, 186, 128, 181, 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, 128, 173, 128, 155,
+	160, 180, 182, 189, 148, 161, 163, 255,
+	176, 164, 165, 132, 169, 177, 141, 142,
+	145, 146, 179, 181, 186, 187, 158, 133,
+	134, 137, 138, 143, 150, 152, 155, 164,
+	165, 178, 255, 188, 129, 131, 133, 138,
+	143, 144, 147, 168, 170, 176, 178, 179,
+	181, 182, 184, 185, 190, 255, 157, 131,
+	134, 137, 138, 142, 144, 146, 152, 159,
+	165, 182, 255, 129, 131, 133, 141, 143,
+	145, 147, 168, 170, 176, 178, 179, 181,
+	185, 188, 255, 134, 138, 142, 143, 145,
+	159, 164, 165, 176, 184, 186, 255, 129,
+	131, 133, 140, 143, 144, 147, 168, 170,
+	176, 178, 179, 181, 185, 188, 191, 177,
+	128, 132, 135, 136, 139, 141, 150, 151,
+	156, 157, 159, 163, 166, 175, 156, 130,
+	131, 133, 138, 142, 144, 146, 149, 153,
+	154, 158, 159, 163, 164, 168, 170, 174,
+	185, 190, 191, 144, 151, 128, 130, 134,
+	136, 138, 141, 166, 175, 128, 131, 133,
+	140, 142, 144, 146, 168, 170, 185, 189,
+	255, 133, 137, 151, 142, 148, 155, 159,
+	164, 165, 176, 255, 128, 131, 133, 140,
+	142, 144, 146, 168, 170, 179, 181, 185,
+	188, 191, 158, 128, 132, 134, 136, 138,
+	141, 149, 150, 160, 163, 166, 175, 177,
+	178, 129, 131, 133, 140, 142, 144, 146,
+	186, 189, 255, 133, 137, 143, 147, 152,
+	158, 164, 165, 176, 185, 192, 255, 189,
+	130, 131, 133, 150, 154, 177, 179, 187,
+	138, 150, 128, 134, 143, 148, 152, 159,
+	166, 175, 178, 179, 129, 186, 128, 142,
+	144, 153, 132, 138, 141, 165, 167, 129,
+	130, 135, 136, 148, 151, 153, 159, 161,
+	163, 170, 171, 173, 185, 187, 189, 134,
+	128, 132, 136, 141, 144, 153, 156, 159,
+	128, 181, 183, 185, 152, 153, 160, 169,
+	190, 191, 128, 135, 137, 172, 177, 191,
+	128, 132, 134, 151, 153, 188, 134, 128,
+	129, 130, 131, 137, 138, 139, 140, 141,
+	142, 143, 144, 153, 154, 155, 156, 157,
+	158, 159, 160, 161, 162, 163, 164, 165,
+	166, 167, 168, 169, 170, 173, 175, 176,
+	177, 178, 179, 181, 182, 183, 188, 189,
+	190, 191, 132, 152, 172, 184, 185, 187,
+	128, 191, 128, 137, 144, 255, 158, 159,
+	134, 187, 136, 140, 142, 143, 137, 151,
+	153, 142, 143, 158, 159, 137, 177, 142,
+	143, 182, 183, 191, 255, 128, 130, 133,
+	136, 150, 152, 255, 145, 150, 151, 155,
+	156, 160, 168, 178, 255, 128, 143, 160,
+	255, 182, 183, 190, 255, 129, 255, 173,
+	174, 192, 255, 129, 154, 160, 255, 171,
+	173, 185, 255, 128, 140, 142, 148, 160,
+	180, 128, 147, 160, 172, 174, 176, 178,
+	179, 148, 150, 152, 155, 158, 159, 170,
+	255, 139, 141, 144, 153, 160, 255, 184,
+	255, 128, 170, 176, 255, 182, 255, 128,
+	158, 160, 171, 176, 187, 134, 173, 176,
+	180, 128, 171, 176, 255, 138, 143, 155,
+	255, 128, 155, 160, 255, 159, 189, 190,
+	192, 255, 167, 128, 137, 144, 153, 176,
+	189, 140, 143, 154, 170, 180, 255, 180,
+	255, 128, 183, 128, 137, 141, 189, 128,
+	136, 144, 146, 148, 182, 184, 185, 128,
+	181, 187, 191, 150, 151, 158, 159, 152,
+	154, 156, 158, 134, 135, 142, 143, 190,
+	255, 190, 128, 180, 182, 188, 130, 132,
+	134, 140, 144, 147, 150, 155, 160, 172,
+	178, 180, 182, 188, 128, 129, 130, 131,
+	132, 133, 134, 176, 177, 178, 179, 180,
+	181, 182, 183, 191, 255, 129, 147, 149,
+	176, 178, 190, 192, 255, 144, 156, 161,
+	144, 156, 165, 176, 130, 135, 149, 164,
+	166, 168, 138, 147, 152, 157, 170, 185,
+	188, 191, 142, 133, 137, 160, 255, 137,
+	255, 128, 174, 176, 255, 159, 165, 170,
+	180, 255, 167, 173, 128, 165, 176, 255,
+	168, 174, 176, 190, 192, 255, 128, 150,
+	160, 166, 168, 174, 176, 182, 184, 190,
+	128, 134, 136, 142, 144, 150, 152, 158,
+	160, 191, 128, 129, 130, 131, 132, 133,
+	134, 135, 144, 145, 255, 133, 135, 161,
+	175, 177, 181, 184, 188, 160, 151, 152,
+	187, 192, 255, 133, 173, 177, 255, 143,
+	159, 187, 255, 176, 191, 182, 183, 184,
+	191, 192, 255, 150, 255, 128, 146, 147,
+	148, 152, 153, 154, 155, 156, 158, 159,
+	160, 161, 162, 163, 164, 165, 166, 167,
+	168, 169, 170, 171, 172, 173, 174, 175,
+	176, 129, 255, 141, 255, 144, 189, 141,
+	143, 172, 255, 191, 128, 175, 180, 189,
+	151, 159, 162, 255, 175, 137, 138, 184,
+	255, 183, 255, 168, 255, 128, 179, 188,
+	134, 143, 154, 159, 184, 186, 190, 255,
+	128, 173, 176, 255, 148, 159, 189, 255,
+	129, 142, 154, 159, 191, 255, 128, 182,
+	128, 141, 144, 153, 160, 182, 186, 255,
+	128, 130, 155, 157, 160, 175, 178, 182,
+	129, 134, 137, 142, 145, 150, 160, 166,
+	168, 174, 176, 255, 155, 166, 175, 128,
+	170, 172, 173, 176, 185, 158, 159, 160,
+	255, 164, 175, 135, 138, 188, 255, 164,
+	169, 171, 172, 173, 174, 175, 180, 181,
+	182, 183, 184, 185, 187, 188, 189, 190,
+	191, 165, 186, 174, 175, 154, 255, 190,
+	128, 134, 147, 151, 157, 168, 170, 182,
+	184, 188, 128, 129, 131, 132, 134, 255,
+	147, 255, 190, 255, 144, 145, 136, 175,
+	188, 255, 128, 143, 160, 175, 179, 180,
+	141, 143, 176, 180, 182, 255, 189, 255,
+	191, 144, 153, 161, 186, 129, 154, 166,
+	255, 191, 255, 130, 135, 138, 143, 146,
+	151, 154, 156, 144, 145, 146, 147, 148,
+	150, 151, 152, 155, 157, 158, 160, 170,
+	171, 172, 175, 161, 169, 128, 129, 130,
+	131, 133, 135, 138, 139, 140, 141, 142,
+	143, 144, 145, 146, 147, 148, 149, 152,
+	156, 157, 160, 161, 162, 163, 164, 166,
+	168, 169, 170, 171, 172, 173, 174, 176,
+	177, 153, 155, 178, 179, 128, 139, 141,
+	166, 168, 186, 188, 189, 191, 255, 142,
+	143, 158, 255, 187, 255, 128, 180, 189,
+	128, 156, 160, 255, 145, 159, 161, 255,
+	128, 159, 176, 255, 139, 143, 187, 255,
+	128, 157, 160, 255, 144, 132, 135, 150,
+	255, 158, 159, 170, 175, 148, 151, 188,
+	255, 128, 167, 176, 255, 164, 255, 183,
+	255, 128, 149, 160, 167, 136, 188, 128,
+	133, 138, 181, 183, 184, 191, 255, 150,
+	159, 183, 255, 128, 158, 160, 178, 180,
+	181, 128, 149, 160, 185, 128, 183, 190,
+	191, 191, 128, 131, 133, 134, 140, 147,
+	149, 151, 153, 179, 184, 186, 160, 188,
+	128, 156, 128, 135, 137, 166, 128, 181,
+	128, 149, 160, 178, 128, 145, 128, 178,
+	129, 130, 131, 132, 133, 135, 136, 138,
+	139, 140, 141, 144, 145, 146, 147, 150,
+	151, 152, 153, 154, 155, 156, 162, 163,
+	171, 176, 177, 178, 128, 134, 135, 165,
+	176, 190, 144, 168, 176, 185, 128, 180,
+	182, 191, 182, 144, 179, 155, 133, 137,
+	141, 143, 157, 255, 190, 128, 145, 147,
+	183, 136, 128, 134, 138, 141, 143, 157,
+	159, 168, 176, 255, 171, 175, 186, 255,
+	128, 131, 133, 140, 143, 144, 147, 168,
+	170, 176, 178, 179, 181, 185, 188, 191,
+	144, 151, 128, 132, 135, 136, 139, 141,
+	157, 163, 166, 172, 176, 180, 128, 138,
+	144, 153, 134, 136, 143, 154, 255, 128,
+	181, 184, 255, 129, 151, 158, 255, 129,
+	131, 133, 143, 154, 255, 128, 137, 128,
+	153, 157, 171, 176, 185, 160, 255, 170,
+	190, 192, 255, 128, 184, 128, 136, 138,
+	182, 184, 191, 128, 144, 153, 178, 255,
+	168, 144, 145, 183, 255, 128, 142, 145,
+	149, 129, 141, 144, 146, 147, 148, 175,
+	255, 132, 255, 128, 144, 129, 143, 144,
+	153, 145, 152, 135, 255, 160, 168, 169,
+	171, 172, 173, 174, 188, 189, 190, 191,
+	161, 167, 185, 255, 128, 158, 160, 169,
+	144, 173, 176, 180, 128, 131, 144, 153,
+	163, 183, 189, 255, 144, 255, 133, 143,
+	191, 255, 143, 159, 160, 128, 129, 255,
+	159, 160, 171, 172, 255, 173, 255, 179,
+	255, 128, 176, 177, 178, 128, 129, 171,
+	175, 189, 255, 128, 136, 144, 153, 157,
+	158, 133, 134, 137, 144, 145, 146, 147,
+	148, 149, 154, 155, 156, 157, 158, 159,
+	168, 169, 170, 150, 153, 165, 169, 173,
+	178, 187, 255, 131, 132, 140, 169, 174,
+	255, 130, 132, 149, 157, 173, 186, 188,
+	160, 161, 163, 164, 167, 168, 132, 134,
+	149, 157, 186, 139, 140, 191, 255, 134,
+	128, 132, 138, 144, 146, 255, 166, 167,
+	129, 155, 187, 149, 181, 143, 175, 137,
+	169, 131, 140, 141, 192, 255, 128, 182,
+	187, 255, 173, 180, 182, 255, 132, 155,
+	159, 161, 175, 128, 160, 163, 164, 165,
+	184, 185, 186, 161, 162, 128, 134, 136,
+	152, 155, 161, 163, 164, 166, 170, 133,
+	143, 151, 255, 139, 143, 154, 255, 164,
+	167, 185, 187, 128, 131, 133, 159, 161,
+	162, 169, 178, 180, 183, 130, 135, 137,
+	139, 148, 151, 153, 155, 157, 159, 164,
+	190, 141, 143, 145, 146, 161, 162, 167,
+	170, 172, 178, 180, 183, 185, 188, 128,
+	137, 139, 155, 161, 163, 165, 169, 171,
+	187, 155, 156, 151, 255, 156, 157, 160,
+	181, 255, 186, 187, 255, 162, 255, 160,
+	168, 161, 167, 158, 255, 160, 132, 135,
+	133, 134, 176, 255, 128, 191, 154, 164,
+	168, 128, 149, 150, 191, 128, 152, 153,
+	191, 181, 128, 159, 160, 189, 190, 191,
+	189, 128, 131, 132, 185, 186, 191, 144,
+	128, 151, 152, 161, 162, 176, 177, 255,
+	169, 177, 129, 132, 141, 142, 145, 146,
+	179, 181, 186, 188, 190, 191, 192, 255,
+	142, 158, 128, 155, 156, 161, 162, 175,
+	176, 177, 178, 191, 169, 177, 180, 183,
+	128, 132, 133, 138, 139, 142, 143, 144,
+	145, 146, 147, 185, 186, 191, 157, 128,
+	152, 153, 158, 159, 177, 178, 180, 181,
+	191, 142, 146, 169, 177, 180, 189, 128,
+	132, 133, 185, 186, 191, 144, 185, 128,
+	159, 160, 161, 162, 191, 169, 177, 180,
+	189, 128, 132, 133, 140, 141, 142, 143,
+	144, 145, 146, 147, 185, 186, 191, 158,
+	177, 128, 155, 156, 161, 162, 191, 131,
+	145, 155, 157, 128, 132, 133, 138, 139,
+	141, 142, 149, 150, 152, 153, 159, 160,
+	162, 163, 164, 165, 167, 168, 170, 171,
+	173, 174, 185, 186, 191, 144, 128, 191,
+	141, 145, 169, 189, 128, 132, 133, 185,
+	186, 191, 128, 151, 152, 154, 155, 159,
+	160, 161, 162, 191, 128, 141, 145, 169,
+	180, 189, 129, 132, 133, 185, 186, 191,
+	158, 128, 159, 160, 161, 162, 176, 177,
+	178, 179, 191, 141, 145, 189, 128, 132,
+	133, 186, 187, 191, 142, 128, 147, 148,
+	150, 151, 158, 159, 161, 162, 185, 186,
+	191, 178, 188, 128, 132, 133, 150, 151,
+	153, 154, 189, 190, 191, 128, 134, 135,
+	191, 128, 177, 129, 179, 180, 191, 128,
+	131, 137, 141, 152, 160, 164, 166, 172,
+	177, 189, 129, 132, 133, 134, 135, 138,
+	139, 147, 148, 167, 168, 169, 170, 179,
+	180, 191, 133, 128, 134, 135, 155, 156,
+	159, 160, 191, 128, 129, 191, 136, 128,
+	172, 173, 191, 128, 135, 136, 140, 141,
+	191, 191, 128, 170, 171, 190, 161, 128,
+	143, 144, 149, 150, 153, 154, 157, 158,
+	164, 165, 166, 167, 173, 174, 176, 177,
+	180, 181, 255, 130, 141, 143, 159, 134,
+	187, 136, 140, 142, 143, 137, 151, 153,
+	142, 143, 158, 159, 137, 177, 191, 142,
+	143, 182, 183, 192, 255, 129, 151, 128,
+	133, 134, 135, 136, 255, 145, 150, 151,
+	155, 191, 192, 255, 128, 143, 144, 159,
+	160, 255, 182, 183, 190, 191, 192, 255,
+	128, 129, 255, 173, 174, 192, 255, 128,
+	129, 154, 155, 159, 160, 255, 171, 173,
+	185, 191, 192, 255, 141, 128, 145, 146,
+	159, 160, 177, 178, 191, 173, 128, 145,
+	146, 159, 160, 176, 177, 191, 128, 179,
+	180, 191, 151, 156, 128, 191, 128, 159,
+	160, 255, 184, 191, 192, 255, 169, 128,
+	170, 171, 175, 176, 255, 182, 191, 192,
+	255, 128, 158, 159, 191, 128, 143, 144,
+	173, 174, 175, 176, 180, 181, 191, 128,
+	171, 172, 175, 176, 255, 138, 191, 192,
+	255, 128, 150, 151, 159, 160, 255, 149,
+	191, 192, 255, 167, 128, 191, 128, 132,
+	133, 179, 180, 191, 128, 132, 133, 139,
+	140, 191, 128, 130, 131, 160, 161, 173,
+	174, 175, 176, 185, 186, 255, 166, 191,
+	192, 255, 128, 163, 164, 191, 128, 140,
+	141, 143, 144, 153, 154, 189, 190, 191,
+	128, 136, 137, 191, 173, 128, 168, 169,
+	177, 178, 180, 181, 182, 183, 191, 0,
+	127, 192, 255, 150, 151, 158, 159, 152,
+	154, 156, 158, 134, 135, 142, 143, 190,
+	191, 192, 255, 181, 189, 191, 128, 190,
+	133, 181, 128, 129, 130, 140, 141, 143,
+	144, 147, 148, 149, 150, 155, 156, 159,
+	160, 172, 173, 177, 178, 188, 189, 191,
+	177, 191, 128, 190, 128, 143, 144, 156,
+	157, 191, 130, 135, 148, 164, 166, 168,
+	128, 137, 138, 149, 150, 151, 152, 157,
+	158, 169, 170, 185, 186, 187, 188, 191,
+	142, 128, 132, 133, 137, 138, 159, 160,
+	255, 137, 191, 192, 255, 175, 128, 255,
+	159, 165, 170, 175, 177, 180, 191, 192,
+	255, 166, 173, 128, 167, 168, 175, 176,
+	255, 168, 174, 176, 191, 192, 255, 167,
+	175, 183, 191, 128, 150, 151, 159, 160,
+	190, 135, 143, 151, 128, 158, 159, 191,
+	128, 132, 133, 135, 136, 160, 161, 169,
+	170, 176, 177, 181, 182, 183, 184, 188,
+	189, 191, 160, 151, 154, 187, 192, 255,
+	128, 132, 133, 173, 174, 176, 177, 255,
+	143, 159, 187, 191, 192, 255, 128, 175,
+	176, 191, 150, 191, 192, 255, 141, 191,
+	192, 255, 128, 143, 144, 189, 190, 191,
+	141, 143, 160, 169, 172, 191, 192, 255,
+	191, 128, 174, 175, 190, 128, 157, 158,
+	159, 160, 255, 176, 191, 192, 255, 128,
+	150, 151, 159, 160, 161, 162, 255, 175,
+	137, 138, 184, 191, 192, 255, 128, 182,
+	183, 255, 130, 134, 139, 163, 191, 192,
+	255, 128, 129, 130, 179, 180, 191, 187,
+	189, 128, 177, 178, 183, 184, 191, 128,
+	137, 138, 165, 166, 175, 176, 255, 135,
+	159, 189, 191, 192, 255, 128, 131, 132,
+	178, 179, 191, 143, 165, 191, 128, 159,
+	160, 175, 176, 185, 186, 190, 128, 168,
+	169, 191, 131, 186, 128, 139, 140, 159,
+	160, 182, 183, 189, 190, 255, 176, 178,
+	180, 183, 184, 190, 191, 192, 255, 129,
+	128, 130, 131, 154, 155, 157, 158, 159,
+	160, 170, 171, 177, 178, 180, 181, 191,
+	128, 167, 175, 129, 134, 135, 136, 137,
+	142, 143, 144, 145, 150, 151, 159, 160,
+	255, 155, 166, 175, 128, 162, 163, 191,
+	164, 175, 135, 138, 188, 191, 192, 255,
+	174, 175, 154, 191, 192, 255, 157, 169,
+	183, 189, 191, 128, 134, 135, 146, 147,
+	151, 152, 158, 159, 190, 130, 133, 128,
+	255, 178, 191, 192, 255, 128, 146, 147,
+	255, 190, 191, 192, 255, 128, 143, 144,
+	255, 144, 145, 136, 175, 188, 191, 192,
+	255, 181, 128, 175, 176, 255, 189, 191,
+	192, 255, 128, 160, 161, 186, 187, 191,
+	128, 129, 154, 155, 165, 166, 255, 191,
+	192, 255, 128, 129, 130, 135, 136, 137,
+	138, 143, 144, 145, 146, 151, 152, 153,
+	154, 156, 157, 191, 128, 191, 128, 129,
+	130, 131, 133, 138, 139, 140, 141, 142,
+	143, 144, 145, 146, 147, 148, 149, 152,
+	156, 157, 160, 161, 162, 163, 164, 166,
+	168, 169, 170, 171, 172, 173, 174, 176,
+	177, 132, 151, 153, 155, 158, 175, 178,
+	179, 180, 191, 140, 167, 187, 190, 128,
+	255, 142, 143, 158, 191, 192, 255, 187,
+	191, 192, 255, 128, 180, 181, 191, 128,
+	156, 157, 159, 160, 255, 145, 191, 192,
+	255, 128, 159, 160, 175, 176, 255, 139,
+	143, 182, 191, 192, 255, 144, 132, 135,
+	150, 191, 192, 255, 158, 175, 148, 151,
+	188, 191, 192, 255, 128, 167, 168, 175,
+	176, 255, 164, 191, 192, 255, 183, 191,
+	192, 255, 128, 149, 150, 159, 160, 167,
+	168, 191, 136, 182, 188, 128, 133, 134,
+	137, 138, 184, 185, 190, 191, 255, 150,
+	159, 183, 191, 192, 255, 179, 128, 159,
+	160, 181, 182, 191, 128, 149, 150, 159,
+	160, 185, 186, 191, 128, 183, 184, 189,
+	190, 191, 128, 148, 152, 129, 143, 144,
+	179, 180, 191, 128, 159, 160, 188, 189,
+	191, 128, 156, 157, 191, 136, 128, 164,
+	165, 191, 128, 181, 182, 191, 128, 149,
+	150, 159, 160, 178, 179, 191, 128, 145,
+	146, 191, 128, 178, 179, 191, 128, 130,
+	131, 132, 133, 134, 135, 136, 138, 139,
+	140, 141, 144, 145, 146, 147, 150, 151,
+	152, 153, 154, 156, 162, 163, 171, 176,
+	177, 178, 129, 191, 128, 130, 131, 183,
+	184, 191, 128, 130, 131, 175, 176, 191,
+	128, 143, 144, 168, 169, 191, 128, 130,
+	131, 166, 167, 191, 182, 128, 143, 144,
+	178, 179, 191, 128, 130, 131, 178, 179,
+	191, 128, 154, 156, 129, 132, 133, 191,
+	146, 128, 171, 172, 191, 135, 137, 142,
+	158, 128, 168, 169, 175, 176, 255, 159,
+	191, 192, 255, 144, 128, 156, 157, 161,
+	162, 191, 128, 134, 135, 138, 139, 191,
+	128, 175, 176, 191, 134, 128, 131, 132,
+	135, 136, 191, 128, 174, 175, 191, 128,
+	151, 152, 155, 156, 191, 132, 128, 191,
+	128, 170, 171, 191, 128, 153, 154, 191,
+	160, 190, 192, 255, 128, 184, 185, 191,
+	137, 128, 174, 175, 191, 128, 129, 177,
+	178, 255, 144, 191, 192, 255, 128, 142,
+	143, 144, 145, 146, 149, 129, 148, 150,
+	191, 175, 191, 192, 255, 132, 191, 192,
+	255, 128, 144, 129, 143, 145, 191, 144,
+	153, 128, 143, 145, 152, 154, 191, 135,
+	191, 192, 255, 160, 168, 169, 171, 172,
+	173, 174, 188, 189, 190, 191, 128, 159,
+	161, 167, 170, 187, 185, 191, 192, 255,
+	128, 143, 144, 173, 174, 191, 128, 131,
+	132, 162, 163, 183, 184, 188, 189, 255,
+	133, 143, 145, 191, 192, 255, 128, 146,
+	147, 159, 160, 191, 160, 128, 191, 128,
+	129, 191, 192, 255, 159, 160, 171, 128,
+	170, 172, 191, 192, 255, 173, 191, 192,
+	255, 179, 191, 192, 255, 128, 176, 177,
+	178, 129, 191, 128, 129, 130, 191, 171,
+	175, 189, 191, 192, 255, 128, 136, 137,
+	143, 144, 153, 154, 191, 144, 145, 146,
+	147, 148, 149, 154, 155, 156, 157, 158,
+	159, 128, 143, 150, 153, 160, 191, 149,
+	157, 173, 186, 188, 160, 161, 163, 164,
+	167, 168, 132, 134, 149, 157, 186, 191,
+	139, 140, 192, 255, 133, 145, 128, 134,
+	135, 137, 138, 255, 166, 167, 129, 155,
+	187, 149, 181, 143, 175, 137, 169, 131,
+	140, 191, 192, 255, 160, 163, 164, 165,
+	184, 185, 186, 128, 159, 161, 162, 166,
+	191, 133, 191, 192, 255, 132, 160, 163,
+	167, 179, 184, 186, 128, 164, 165, 168,
+	169, 187, 188, 191, 130, 135, 137, 139,
+	144, 147, 151, 153, 155, 157, 159, 163,
+	171, 179, 184, 189, 191, 128, 140, 141,
+	148, 149, 160, 161, 164, 165, 166, 167,
+	190, 138, 164, 170, 128, 155, 156, 160,
+	161, 187, 188, 191, 128, 191, 155, 156,
+	128, 191, 151, 191, 192, 255, 156, 157,
+	160, 128, 191, 181, 191, 192, 255, 158,
+	159, 186, 128, 185, 187, 191, 192, 255,
+	162, 191, 192, 255, 160, 168, 128, 159,
+	161, 167, 169, 191, 158, 191, 192, 255,
+	10, 13, 128, 191, 192, 223, 224, 239,
+	240, 247, 248, 255, 128, 191, 128, 191,
+	128, 191, 128, 191, 128, 191, 10, 128,
+	191, 128, 191, 128, 191, 36, 123, 37,
+	123, 10, 128, 191, 128, 191, 128, 191,
+	36, 123, 37, 123, 170, 181, 183, 186,
+	128, 150, 152, 182, 184, 255, 192, 255,
+	128, 255, 173, 130, 133, 146, 159, 165,
+	171, 175, 255, 181, 190, 184, 185, 192,
+	255, 140, 134, 138, 142, 161, 163, 255,
+	182, 130, 136, 137, 176, 151, 152, 154,
+	160, 190, 136, 144, 192, 255, 135, 129,
+	130, 132, 133, 144, 170, 176, 178, 144,
+	154, 160, 191, 128, 169, 174, 255, 148,
+	169, 157, 158, 189, 190, 192, 255, 144,
+	255, 139, 140, 178, 255, 186, 128, 181,
+	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,
+	128, 173, 128, 155, 160, 180, 182, 189,
+	148, 161, 163, 255, 176, 164, 165, 132,
+	169, 177, 141, 142, 145, 146, 179, 181,
+	186, 187, 158, 133, 134, 137, 138, 143,
+	150, 152, 155, 164, 165, 178, 255, 188,
+	129, 131, 133, 138, 143, 144, 147, 168,
+	170, 176, 178, 179, 181, 182, 184, 185,
+	190, 255, 157, 131, 134, 137, 138, 142,
+	144, 146, 152, 159, 165, 182, 255, 129,
+	131, 133, 141, 143, 145, 147, 168, 170,
+	176, 178, 179, 181, 185, 188, 255, 134,
+	138, 142, 143, 145, 159, 164, 165, 176,
+	184, 186, 255, 129, 131, 133, 140, 143,
+	144, 147, 168, 170, 176, 178, 179, 181,
+	185, 188, 191, 177, 128, 132, 135, 136,
+	139, 141, 150, 151, 156, 157, 159, 163,
+	166, 175, 156, 130, 131, 133, 138, 142,
+	144, 146, 149, 153, 154, 158, 159, 163,
+	164, 168, 170, 174, 185, 190, 191, 144,
+	151, 128, 130, 134, 136, 138, 141, 166,
+	175, 128, 131, 133, 140, 142, 144, 146,
+	168, 170, 185, 189, 255, 133, 137, 151,
+	142, 148, 155, 159, 164, 165, 176, 255,
+	128, 131, 133, 140, 142, 144, 146, 168,
+	170, 179, 181, 185, 188, 191, 158, 128,
+	132, 134, 136, 138, 141, 149, 150, 160,
+	163, 166, 175, 177, 178, 129, 131, 133,
+	140, 142, 144, 146, 186, 189, 255, 133,
+	137, 143, 147, 152, 158, 164, 165, 176,
+	185, 192, 255, 189, 130, 131, 133, 150,
+	154, 177, 179, 187, 138, 150, 128, 134,
+	143, 148, 152, 159, 166, 175, 178, 179,
+	129, 186, 128, 142, 144, 153, 132, 138,
+	141, 165, 167, 129, 130, 135, 136, 148,
+	151, 153, 159, 161, 163, 170, 171, 173,
+	185, 187, 189, 134, 128, 132, 136, 141,
+	144, 153, 156, 159, 128, 181, 183, 185,
+	152, 153, 160, 169, 190, 191, 128, 135,
+	137, 172, 177, 191, 128, 132, 134, 151,
+	153, 188, 134, 128, 129, 130, 131, 137,
+	138, 139, 140, 141, 142, 143, 144, 153,
+	154, 155, 156, 157, 158, 159, 160, 161,
+	162, 163, 164, 165, 166, 167, 168, 169,
+	170, 173, 175, 176, 177, 178, 179, 181,
+	182, 183, 188, 189, 190, 191, 132, 152,
+	172, 184, 185, 187, 128, 191, 128, 137,
+	144, 255, 158, 159, 134, 187, 136, 140,
+	142, 143, 137, 151, 153, 142, 143, 158,
+	159, 137, 177, 142, 143, 182, 183, 191,
+	255, 128, 130, 133, 136, 150, 152, 255,
+	145, 150, 151, 155, 156, 160, 168, 178,
+	255, 128, 143, 160, 255, 182, 183, 190,
+	255, 129, 255, 173, 174, 192, 255, 129,
+	154, 160, 255, 171, 173, 185, 255, 128,
+	140, 142, 148, 160, 180, 128, 147, 160,
+	172, 174, 176, 178, 179, 148, 150, 152,
+	155, 158, 159, 170, 255, 139, 141, 144,
+	153, 160, 255, 184, 255, 128, 170, 176,
+	255, 182, 255, 128, 158, 160, 171, 176,
+	187, 134, 173, 176, 180, 128, 171, 176,
+	255, 138, 143, 155, 255, 128, 155, 160,
+	255, 159, 189, 190, 192, 255, 167, 128,
+	137, 144, 153, 176, 189, 140, 143, 154,
+	170, 180, 255, 180, 255, 128, 183, 128,
+	137, 141, 189, 128, 136, 144, 146, 148,
+	182, 184, 185, 128, 181, 187, 191, 150,
+	151, 158, 159, 152, 154, 156, 158, 134,
+	135, 142, 143, 190, 255, 190, 128, 180,
+	182, 188, 130, 132, 134, 140, 144, 147,
+	150, 155, 160, 172, 178, 180, 182, 188,
+	128, 129, 130, 131, 132, 133, 134, 176,
+	177, 178, 179, 180, 181, 182, 183, 191,
+	255, 129, 147, 149, 176, 178, 190, 192,
+	255, 144, 156, 161, 144, 156, 165, 176,
+	130, 135, 149, 164, 166, 168, 138, 147,
+	152, 157, 170, 185, 188, 191, 142, 133,
+	137, 160, 255, 137, 255, 128, 174, 176,
+	255, 159, 165, 170, 180, 255, 167, 173,
+	128, 165, 176, 255, 168, 174, 176, 190,
+	192, 255, 128, 150, 160, 166, 168, 174,
+	176, 182, 184, 190, 128, 134, 136, 142,
+	144, 150, 152, 158, 160, 191, 128, 129,
+	130, 131, 132, 133, 134, 135, 144, 145,
+	255, 133, 135, 161, 175, 177, 181, 184,
+	188, 160, 151, 152, 187, 192, 255, 133,
+	173, 177, 255, 143, 159, 187, 255, 176,
+	191, 182, 183, 184, 191, 192, 255, 150,
+	255, 128, 146, 147, 148, 152, 153, 154,
+	155, 156, 158, 159, 160, 161, 162, 163,
+	164, 165, 166, 167, 168, 169, 170, 171,
+	172, 173, 174, 175, 176, 129, 255, 141,
+	255, 144, 189, 141, 143, 172, 255, 191,
+	128, 175, 180, 189, 151, 159, 162, 255,
+	175, 137, 138, 184, 255, 183, 255, 168,
+	255, 128, 179, 188, 134, 143, 154, 159,
+	184, 186, 190, 255, 128, 173, 176, 255,
+	148, 159, 189, 255, 129, 142, 154, 159,
+	191, 255, 128, 182, 128, 141, 144, 153,
+	160, 182, 186, 255, 128, 130, 155, 157,
+	160, 175, 178, 182, 129, 134, 137, 142,
+	145, 150, 160, 166, 168, 174, 176, 255,
+	155, 166, 175, 128, 170, 172, 173, 176,
+	185, 158, 159, 160, 255, 164, 175, 135,
+	138, 188, 255, 164, 169, 171, 172, 173,
+	174, 175, 180, 181, 182, 183, 184, 185,
+	187, 188, 189, 190, 191, 165, 186, 174,
+	175, 154, 255, 190, 128, 134, 147, 151,
+	157, 168, 170, 182, 184, 188, 128, 129,
+	131, 132, 134, 255, 147, 255, 190, 255,
+	144, 145, 136, 175, 188, 255, 128, 143,
+	160, 175, 179, 180, 141, 143, 176, 180,
+	182, 255, 189, 255, 191, 144, 153, 161,
+	186, 129, 154, 166, 255, 191, 255, 130,
+	135, 138, 143, 146, 151, 154, 156, 144,
+	145, 146, 147, 148, 150, 151, 152, 155,
+	157, 158, 160, 170, 171, 172, 175, 161,
+	169, 128, 129, 130, 131, 133, 135, 138,
+	139, 140, 141, 142, 143, 144, 145, 146,
+	147, 148, 149, 152, 156, 157, 160, 161,
+	162, 163, 164, 166, 168, 169, 170, 171,
+	172, 173, 174, 176, 177, 153, 155, 178,
+	179, 128, 139, 141, 166, 168, 186, 188,
+	189, 191, 255, 142, 143, 158, 255, 187,
+	255, 128, 180, 189, 128, 156, 160, 255,
+	145, 159, 161, 255, 128, 159, 176, 255,
+	139, 143, 187, 255, 128, 157, 160, 255,
+	144, 132, 135, 150, 255, 158, 159, 170,
+	175, 148, 151, 188, 255, 128, 167, 176,
+	255, 164, 255, 183, 255, 128, 149, 160,
+	167, 136, 188, 128, 133, 138, 181, 183,
+	184, 191, 255, 150, 159, 183, 255, 128,
+	158, 160, 178, 180, 181, 128, 149, 160,
+	185, 128, 183, 190, 191, 191, 128, 131,
+	133, 134, 140, 147, 149, 151, 153, 179,
+	184, 186, 160, 188, 128, 156, 128, 135,
+	137, 166, 128, 181, 128, 149, 160, 178,
+	128, 145, 128, 178, 129, 130, 131, 132,
+	133, 135, 136, 138, 139, 140, 141, 144,
+	145, 146, 147, 150, 151, 152, 153, 154,
+	155, 156, 162, 163, 171, 176, 177, 178,
+	128, 134, 135, 165, 176, 190, 144, 168,
+	176, 185, 128, 180, 182, 191, 182, 144,
+	179, 155, 133, 137, 141, 143, 157, 255,
+	190, 128, 145, 147, 183, 136, 128, 134,
+	138, 141, 143, 157, 159, 168, 176, 255,
+	171, 175, 186, 255, 128, 131, 133, 140,
+	143, 144, 147, 168, 170, 176, 178, 179,
+	181, 185, 188, 191, 144, 151, 128, 132,
+	135, 136, 139, 141, 157, 163, 166, 172,
+	176, 180, 128, 138, 144, 153, 134, 136,
+	143, 154, 255, 128, 181, 184, 255, 129,
+	151, 158, 255, 129, 131, 133, 143, 154,
+	255, 128, 137, 128, 153, 157, 171, 176,
+	185, 160, 255, 170, 190, 192, 255, 128,
+	184, 128, 136, 138, 182, 184, 191, 128,
+	144, 153, 178, 255, 168, 144, 145, 183,
+	255, 128, 142, 145, 149, 129, 141, 144,
+	146, 147, 148, 175, 255, 132, 255, 128,
+	144, 129, 143, 144, 153, 145, 152, 135,
+	255, 160, 168, 169, 171, 172, 173, 174,
+	188, 189, 190, 191, 161, 167, 185, 255,
+	128, 158, 160, 169, 144, 173, 176, 180,
+	128, 131, 144, 153, 163, 183, 189, 255,
+	144, 255, 133, 143, 191, 255, 143, 159,
+	160, 128, 129, 255, 159, 160, 171, 172,
+	255, 173, 255, 179, 255, 128, 176, 177,
+	178, 128, 129, 171, 175, 189, 255, 128,
+	136, 144, 153, 157, 158, 133, 134, 137,
+	144, 145, 146, 147, 148, 149, 154, 155,
+	156, 157, 158, 159, 168, 169, 170, 150,
+	153, 165, 169, 173, 178, 187, 255, 131,
+	132, 140, 169, 174, 255, 130, 132, 149,
+	157, 173, 186, 188, 160, 161, 163, 164,
+	167, 168, 132, 134, 149, 157, 186, 139,
+	140, 191, 255, 134, 128, 132, 138, 144,
+	146, 255, 166, 167, 129, 155, 187, 149,
+	181, 143, 175, 137, 169, 131, 140, 141,
+	192, 255, 128, 182, 187, 255, 173, 180,
+	182, 255, 132, 155, 159, 161, 175, 128,
+	160, 163, 164, 165, 184, 185, 186, 161,
+	162, 128, 134, 136, 152, 155, 161, 163,
+	164, 166, 170, 133, 143, 151, 255, 139,
+	143, 154, 255, 164, 167, 185, 187, 128,
+	131, 133, 159, 161, 162, 169, 178, 180,
+	183, 130, 135, 137, 139, 148, 151, 153,
+	155, 157, 159, 164, 190, 141, 143, 145,
+	146, 161, 162, 167, 170, 172, 178, 180,
+	183, 185, 188, 128, 137, 139, 155, 161,
+	163, 165, 169, 171, 187, 155, 156, 151,
+	255, 156, 157, 160, 181, 255, 186, 187,
+	255, 162, 255, 160, 168, 161, 167, 158,
+	255, 160, 132, 135, 133, 134, 176, 255,
+	128, 191, 154, 164, 168, 128, 149, 150,
+	191, 128, 152, 153, 191, 181, 128, 159,
+	160, 189, 190, 191, 189, 128, 131, 132,
+	185, 186, 191, 144, 128, 151, 152, 161,
+	162, 176, 177, 255, 169, 177, 129, 132,
+	141, 142, 145, 146, 179, 181, 186, 188,
+	190, 191, 192, 255, 142, 158, 128, 155,
+	156, 161, 162, 175, 176, 177, 178, 191,
+	169, 177, 180, 183, 128, 132, 133, 138,
+	139, 142, 143, 144, 145, 146, 147, 185,
+	186, 191, 157, 128, 152, 153, 158, 159,
+	177, 178, 180, 181, 191, 142, 146, 169,
+	177, 180, 189, 128, 132, 133, 185, 186,
+	191, 144, 185, 128, 159, 160, 161, 162,
+	191, 169, 177, 180, 189, 128, 132, 133,
+	140, 141, 142, 143, 144, 145, 146, 147,
+	185, 186, 191, 158, 177, 128, 155, 156,
+	161, 162, 191, 131, 145, 155, 157, 128,
+	132, 133, 138, 139, 141, 142, 149, 150,
+	152, 153, 159, 160, 162, 163, 164, 165,
+	167, 168, 170, 171, 173, 174, 185, 186,
+	191, 144, 128, 191, 141, 145, 169, 189,
+	128, 132, 133, 185, 186, 191, 128, 151,
+	152, 154, 155, 159, 160, 161, 162, 191,
+	128, 141, 145, 169, 180, 189, 129, 132,
+	133, 185, 186, 191, 158, 128, 159, 160,
+	161, 162, 176, 177, 178, 179, 191, 141,
+	145, 189, 128, 132, 133, 186, 187, 191,
+	142, 128, 147, 148, 150, 151, 158, 159,
+	161, 162, 185, 186, 191, 178, 188, 128,
+	132, 133, 150, 151, 153, 154, 189, 190,
+	191, 128, 134, 135, 191, 128, 177, 129,
+	179, 180, 191, 128, 131, 137, 141, 152,
+	160, 164, 166, 172, 177, 189, 129, 132,
+	133, 134, 135, 138, 139, 147, 148, 167,
+	168, 169, 170, 179, 180, 191, 133, 128,
+	134, 135, 155, 156, 159, 160, 191, 128,
+	129, 191, 136, 128, 172, 173, 191, 128,
+	135, 136, 140, 141, 191, 191, 128, 170,
+	171, 190, 161, 128, 143, 144, 149, 150,
+	153, 154, 157, 158, 164, 165, 166, 167,
+	173, 174, 176, 177, 180, 181, 255, 130,
+	141, 143, 159, 134, 187, 136, 140, 142,
+	143, 137, 151, 153, 142, 143, 158, 159,
+	137, 177, 191, 142, 143, 182, 183, 192,
+	255, 129, 151, 128, 133, 134, 135, 136,
+	255, 145, 150, 151, 155, 191, 192, 255,
+	128, 143, 144, 159, 160, 255, 182, 183,
+	190, 191, 192, 255, 128, 129, 255, 173,
+	174, 192, 255, 128, 129, 154, 155, 159,
+	160, 255, 171, 173, 185, 191, 192, 255,
+	141, 128, 145, 146, 159, 160, 177, 178,
+	191, 173, 128, 145, 146, 159, 160, 176,
+	177, 191, 128, 179, 180, 191, 151, 156,
+	128, 191, 128, 159, 160, 255, 184, 191,
+	192, 255, 169, 128, 170, 171, 175, 176,
+	255, 182, 191, 192, 255, 128, 158, 159,
+	191, 128, 143, 144, 173, 174, 175, 176,
+	180, 181, 191, 128, 171, 172, 175, 176,
+	255, 138, 191, 192, 255, 128, 150, 151,
+	159, 160, 255, 149, 191, 192, 255, 167,
+	128, 191, 128, 132, 133, 179, 180, 191,
+	128, 132, 133, 139, 140, 191, 128, 130,
+	131, 160, 161, 173, 174, 175, 176, 185,
+	186, 255, 166, 191, 192, 255, 128, 163,
+	164, 191, 128, 140, 141, 143, 144, 153,
+	154, 189, 190, 191, 128, 136, 137, 191,
+	173, 128, 168, 169, 177, 178, 180, 181,
+	182, 183, 191, 0, 127, 192, 255, 150,
+	151, 158, 159, 152, 154, 156, 158, 134,
+	135, 142, 143, 190, 191, 192, 255, 181,
+	189, 191, 128, 190, 133, 181, 128, 129,
+	130, 140, 141, 143, 144, 147, 148, 149,
+	150, 155, 156, 159, 160, 172, 173, 177,
+	178, 188, 189, 191, 177, 191, 128, 190,
+	128, 143, 144, 156, 157, 191, 130, 135,
+	148, 164, 166, 168, 128, 137, 138, 149,
+	150, 151, 152, 157, 158, 169, 170, 185,
+	186, 187, 188, 191, 142, 128, 132, 133,
+	137, 138, 159, 160, 255, 137, 191, 192,
+	255, 175, 128, 255, 159, 165, 170, 175,
+	177, 180, 191, 192, 255, 166, 173, 128,
+	167, 168, 175, 176, 255, 168, 174, 176,
+	191, 192, 255, 167, 175, 183, 191, 128,
+	150, 151, 159, 160, 190, 135, 143, 151,
+	128, 158, 159, 191, 128, 132, 133, 135,
+	136, 160, 161, 169, 170, 176, 177, 181,
+	182, 183, 184, 188, 189, 191, 160, 151,
+	154, 187, 192, 255, 128, 132, 133, 173,
+	174, 176, 177, 255, 143, 159, 187, 191,
+	192, 255, 128, 175, 176, 191, 150, 191,
+	192, 255, 141, 191, 192, 255, 128, 143,
+	144, 189, 190, 191, 141, 143, 160, 169,
+	172, 191, 192, 255, 191, 128, 174, 175,
+	190, 128, 157, 158, 159, 160, 255, 176,
+	191, 192, 255, 128, 150, 151, 159, 160,
+	161, 162, 255, 175, 137, 138, 184, 191,
+	192, 255, 128, 182, 183, 255, 130, 134,
+	139, 163, 191, 192, 255, 128, 129, 130,
+	179, 180, 191, 187, 189, 128, 177, 178,
+	183, 184, 191, 128, 137, 138, 165, 166,
+	175, 176, 255, 135, 159, 189, 191, 192,
+	255, 128, 131, 132, 178, 179, 191, 143,
+	165, 191, 128, 159, 160, 175, 176, 185,
+	186, 190, 128, 168, 169, 191, 131, 186,
+	128, 139, 140, 159, 160, 182, 183, 189,
+	190, 255, 176, 178, 180, 183, 184, 190,
+	191, 192, 255, 129, 128, 130, 131, 154,
+	155, 157, 158, 159, 160, 170, 171, 177,
+	178, 180, 181, 191, 128, 167, 175, 129,
+	134, 135, 136, 137, 142, 143, 144, 145,
+	150, 151, 159, 160, 255, 155, 166, 175,
+	128, 162, 163, 191, 164, 175, 135, 138,
+	188, 191, 192, 255, 174, 175, 154, 191,
+	192, 255, 157, 169, 183, 189, 191, 128,
+	134, 135, 146, 147, 151, 152, 158, 159,
+	190, 130, 133, 128, 255, 178, 191, 192,
+	255, 128, 146, 147, 255, 190, 191, 192,
+	255, 128, 143, 144, 255, 144, 145, 136,
+	175, 188, 191, 192, 255, 181, 128, 175,
+	176, 255, 189, 191, 192, 255, 128, 160,
+	161, 186, 187, 191, 128, 129, 154, 155,
+	165, 166, 255, 191, 192, 255, 128, 129,
+	130, 135, 136, 137, 138, 143, 144, 145,
+	146, 151, 152, 153, 154, 156, 157, 191,
+	128, 191, 128, 129, 130, 131, 133, 138,
+	139, 140, 141, 142, 143, 144, 145, 146,
+	147, 148, 149, 152, 156, 157, 160, 161,
+	162, 163, 164, 166, 168, 169, 170, 171,
+	172, 173, 174, 176, 177, 132, 151, 153,
+	155, 158, 175, 178, 179, 180, 191, 140,
+	167, 187, 190, 128, 255, 142, 143, 158,
+	191, 192, 255, 187, 191, 192, 255, 128,
+	180, 181, 191, 128, 156, 157, 159, 160,
+	255, 145, 191, 192, 255, 128, 159, 160,
+	175, 176, 255, 139, 143, 182, 191, 192,
+	255, 144, 132, 135, 150, 191, 192, 255,
+	158, 175, 148, 151, 188, 191, 192, 255,
+	128, 167, 168, 175, 176, 255, 164, 191,
+	192, 255, 183, 191, 192, 255, 128, 149,
+	150, 159, 160, 167, 168, 191, 136, 182,
+	188, 128, 133, 134, 137, 138, 184, 185,
+	190, 191, 255, 150, 159, 183, 191, 192,
+	255, 179, 128, 159, 160, 181, 182, 191,
+	128, 149, 150, 159, 160, 185, 186, 191,
+	128, 183, 184, 189, 190, 191, 128, 148,
+	152, 129, 143, 144, 179, 180, 191, 128,
+	159, 160, 188, 189, 191, 128, 156, 157,
+	191, 136, 128, 164, 165, 191, 128, 181,
+	182, 191, 128, 149, 150, 159, 160, 178,
+	179, 191, 128, 145, 146, 191, 128, 178,
+	179, 191, 128, 130, 131, 132, 133, 134,
+	135, 136, 138, 139, 140, 141, 144, 145,
+	146, 147, 150, 151, 152, 153, 154, 156,
+	162, 163, 171, 176, 177, 178, 129, 191,
+	128, 130, 131, 183, 184, 191, 128, 130,
+	131, 175, 176, 191, 128, 143, 144, 168,
+	169, 191, 128, 130, 131, 166, 167, 191,
+	182, 128, 143, 144, 178, 179, 191, 128,
+	130, 131, 178, 179, 191, 128, 154, 156,
+	129, 132, 133, 191, 146, 128, 171, 172,
+	191, 135, 137, 142, 158, 128, 168, 169,
+	175, 176, 255, 159, 191, 192, 255, 144,
+	128, 156, 157, 161, 162, 191, 128, 134,
+	135, 138, 139, 191, 128, 175, 176, 191,
+	134, 128, 131, 132, 135, 136, 191, 128,
+	174, 175, 191, 128, 151, 152, 155, 156,
+	191, 132, 128, 191, 128, 170, 171, 191,
+	128, 153, 154, 191, 160, 190, 192, 255,
+	128, 184, 185, 191, 137, 128, 174, 175,
+	191, 128, 129, 177, 178, 255, 144, 191,
+	192, 255, 128, 142, 143, 144, 145, 146,
+	149, 129, 148, 150, 191, 175, 191, 192,
+	255, 132, 191, 192, 255, 128, 144, 129,
+	143, 145, 191, 144, 153, 128, 143, 145,
+	152, 154, 191, 135, 191, 192, 255, 160,
+	168, 169, 171, 172, 173, 174, 188, 189,
+	190, 191, 128, 159, 161, 167, 170, 187,
+	185, 191, 192, 255, 128, 143, 144, 173,
+	174, 191, 128, 131, 132, 162, 163, 183,
+	184, 188, 189, 255, 133, 143, 145, 191,
+	192, 255, 128, 146, 147, 159, 160, 191,
+	160, 128, 191, 128, 129, 191, 192, 255,
+	159, 160, 171, 128, 170, 172, 191, 192,
+	255, 173, 191, 192, 255, 179, 191, 192,
+	255, 128, 176, 177, 178, 129, 191, 128,
+	129, 130, 191, 171, 175, 189, 191, 192,
+	255, 128, 136, 137, 143, 144, 153, 154,
+	191, 144, 145, 146, 147, 148, 149, 154,
+	155, 156, 157, 158, 159, 128, 143, 150,
+	153, 160, 191, 149, 157, 173, 186, 188,
+	160, 161, 163, 164, 167, 168, 132, 134,
+	149, 157, 186, 191, 139, 140, 192, 255,
+	133, 145, 128, 134, 135, 137, 138, 255,
+	166, 167, 129, 155, 187, 149, 181, 143,
+	175, 137, 169, 131, 140, 191, 192, 255,
+	160, 163, 164, 165, 184, 185, 186, 128,
+	159, 161, 162, 166, 191, 133, 191, 192,
+	255, 132, 160, 163, 167, 179, 184, 186,
+	128, 164, 165, 168, 169, 187, 188, 191,
+	130, 135, 137, 139, 144, 147, 151, 153,
+	155, 157, 159, 163, 171, 179, 184, 189,
+	191, 128, 140, 141, 148, 149, 160, 161,
+	164, 165, 166, 167, 190, 138, 164, 170,
+	128, 155, 156, 160, 161, 187, 188, 191,
+	128, 191, 155, 156, 128, 191, 151, 191,
+	192, 255, 156, 157, 160, 128, 191, 181,
+	191, 192, 255, 158, 159, 186, 128, 185,
+	187, 191, 192, 255, 162, 191, 192, 255,
+	160, 168, 128, 159, 161, 167, 169, 191,
+	158, 191, 192, 255, 9, 10, 13, 32,
+	33, 34, 35, 38, 46, 47, 60, 61,
+	62, 64, 92, 95, 123, 124, 125, 126,
+	127, 194, 195, 198, 199, 203, 204, 205,
+	206, 207, 210, 212, 213, 214, 215, 216,
+	217, 219, 220, 221, 222, 223, 224, 225,
+	226, 227, 228, 233, 234, 237, 238, 239,
+	240, 0, 36, 37, 45, 48, 57, 58,
+	63, 65, 90, 91, 96, 97, 122, 192,
+	193, 196, 218, 229, 236, 241, 247, 9,
+	32, 10, 61, 10, 38, 46, 42, 47,
+	46, 69, 101, 48, 57, 60, 61, 61,
+	62, 61, 45, 95, 194, 195, 198, 199,
+	203, 204, 205, 206, 207, 210, 212, 213,
+	214, 215, 216, 217, 219, 220, 221, 222,
+	223, 224, 225, 226, 227, 228, 233, 234,
+	237, 239, 240, 243, 48, 57, 65, 90,
+	97, 122, 196, 218, 229, 236, 124, 125,
+	128, 191, 170, 181, 186, 128, 191, 151,
+	183, 128, 255, 192, 255, 0, 127, 173,
+	130, 133, 146, 159, 165, 171, 175, 191,
+	192, 255, 181, 190, 128, 175, 176, 183,
+	184, 185, 186, 191, 134, 139, 141, 162,
+	128, 135, 136, 255, 182, 130, 137, 176,
+	151, 152, 154, 160, 136, 191, 192, 255,
+	128, 143, 144, 170, 171, 175, 176, 178,
+	179, 191, 128, 159, 160, 191, 176, 128,
+	138, 139, 173, 174, 255, 148, 150, 164,
+	167, 173, 176, 185, 189, 190, 192, 255,
+	144, 128, 145, 146, 175, 176, 191, 128,
+	140, 141, 255, 166, 176, 178, 191, 192,
+	255, 186, 128, 137, 138, 170, 171, 179,
+	180, 181, 182, 191, 160, 161, 162, 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, 128, 191, 128, 129, 130, 131,
+	137, 138, 139, 140, 141, 142, 143, 144,
+	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, 182, 183, 184, 188,
+	189, 190, 191, 132, 187, 129, 130, 132,
+	133, 134, 176, 177, 178, 179, 180, 181,
+	182, 183, 128, 191, 128, 129, 130, 131,
+	132, 133, 134, 135, 144, 136, 143, 145,
+	191, 192, 255, 182, 183, 184, 128, 191,
+	128, 191, 191, 128, 190, 192, 255, 128,
+	146, 147, 148, 152, 153, 154, 155, 156,
+	158, 159, 160, 161, 162, 163, 164, 165,
+	166, 167, 168, 169, 170, 171, 172, 173,
+	174, 175, 176, 129, 191, 192, 255, 158,
+	159, 128, 157, 160, 191, 192, 255, 128,
+	191, 164, 169, 171, 172, 173, 174, 175,
+	180, 181, 182, 183, 184, 185, 187, 188,
+	189, 190, 191, 128, 163, 165, 186, 144,
+	145, 146, 147, 148, 150, 151, 152, 155,
+	157, 158, 160, 170, 171, 172, 175, 128,
+	159, 161, 169, 173, 191, 128, 191, 10,
+	13, 34, 36, 37, 92, 128, 191, 192,
+	223, 224, 239, 240, 247, 248, 255, 10,
+	13, 34, 92, 36, 37, 128, 191, 192,
+	223, 224, 239, 240, 247, 248, 255, 10,
+	13, 36, 123, 123, 126, 126, 37, 123,
+	126, 10, 13, 128, 191, 192, 223, 224,
+	239, 240, 247, 248, 255, 128, 191, 128,
+	191, 128, 191, 10, 13, 36, 37, 128,
+	191, 192, 223, 224, 239, 240, 247, 248,
+	255, 10, 13, 36, 37, 128, 191, 192,
+	223, 224, 239, 240, 247, 248, 255, 10,
+	13, 10, 13, 123, 10, 13, 126, 10,
+	13, 126, 126, 128, 191, 128, 191, 128,
+	191, 10, 13, 36, 37, 128, 191, 192,
+	223, 224, 239, 240, 247, 248, 255, 10,
+	13, 36, 37, 128, 191, 192, 223, 224,
+	239, 240, 247, 248, 255, 10, 13, 10,
+	13, 123, 10, 13, 126, 10, 13, 126,
+	126, 128, 191, 128, 191, 128, 191, 95,
+	194, 195, 198, 199, 203, 204, 205, 206,
+	207, 210, 212, 213, 214, 215, 216, 217,
+	219, 220, 221, 222, 223, 224, 225, 226,
+	227, 228, 233, 234, 237, 238, 239, 240,
+	65, 90, 97, 122, 128, 191, 192, 193,
+	196, 218, 229, 236, 241, 247, 248, 255,
+	45, 95, 194, 195, 198, 199, 203, 204,
+	205, 206, 207, 210, 212, 213, 214, 215,
+	216, 217, 219, 220, 221, 222, 223, 224,
+	225, 226, 227, 228, 233, 234, 237, 239,
+	240, 243, 48, 57, 65, 90, 97, 122,
+	196, 218, 229, 236, 128, 191, 170, 181,
+	186, 128, 191, 151, 183, 128, 255, 192,
+	255, 0, 127, 173, 130, 133, 146, 159,
+	165, 171, 175, 191, 192, 255, 181, 190,
+	128, 175, 176, 183, 184, 185, 186, 191,
+	134, 139, 141, 162, 128, 135, 136, 255,
+	182, 130, 137, 176, 151, 152, 154, 160,
+	136, 191, 192, 255, 128, 143, 144, 170,
+	171, 175, 176, 178, 179, 191, 128, 159,
+	160, 191, 176, 128, 138, 139, 173, 174,
+	255, 148, 150, 164, 167, 173, 176, 185,
+	189, 190, 192, 255, 144, 128, 145, 146,
+	175, 176, 191, 128, 140, 141, 255, 166,
+	176, 178, 191, 192, 255, 186, 128, 137,
+	138, 170, 171, 179, 180, 181, 182, 191,
+	160, 161, 162, 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, 128, 191,
+	128, 129, 130, 131, 137, 138, 139, 140,
+	141, 142, 143, 144, 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,
+	182, 183, 184, 188, 189, 190, 191, 132,
+	187, 129, 130, 132, 133, 134, 176, 177,
+	178, 179, 180, 181, 182, 183, 128, 191,
+	128, 129, 130, 131, 132, 133, 134, 135,
+	144, 136, 143, 145, 191, 192, 255, 182,
+	183, 184, 128, 191, 128, 191, 191, 128,
+	190, 192, 255, 128, 146, 147, 148, 152,
+	153, 154, 155, 156, 158, 159, 160, 161,
+	162, 163, 164, 165, 166, 167, 168, 169,
+	170, 171, 172, 173, 174, 175, 176, 129,
+	191, 192, 255, 158, 159, 128, 157, 160,
+	191, 192, 255, 128, 191, 164, 169, 171,
+	172, 173, 174, 175, 180, 181, 182, 183,
+	184, 185, 187, 188, 189, 190, 191, 128,
+	163, 165, 186, 144, 145, 146, 147, 148,
+	150, 151, 152, 155, 157, 158, 160, 170,
+	171, 172, 175, 128, 159, 161, 169, 173,
+	191, 128, 191,
+}
+
+var _hcltok_single_lengths []byte = []byte{
+	0, 1, 1, 2, 3, 2, 0, 32,
+	31, 36, 1, 4, 0, 0, 0, 0,
+	1, 2, 1, 1, 1, 1, 0, 1,
+	1, 0, 0, 2, 0, 0, 0, 1,
+	32, 0, 0, 0, 0, 1, 3, 1,
+	1, 1, 0, 2, 0, 1, 1, 2,
+	0, 3, 0, 1, 0, 2, 1, 2,
+	0, 0, 5, 1, 4, 0, 0, 1,
+	43, 0, 0, 0, 2, 3, 2, 1,
+	1, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 1, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 4, 1,
+	0, 15, 0, 0, 0, 1, 6, 1,
+	0, 0, 1, 0, 2, 0, 0, 0,
+	9, 0, 1, 1, 0, 0, 0, 3,
+	0, 1, 0, 28, 0, 0, 0, 1,
+	0, 1, 0, 0, 0, 1, 0, 0,
+	0, 0, 0, 0, 0, 1, 0, 2,
+	0, 0, 18, 0, 0, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 16, 36, 0, 0, 0, 0,
+	1, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 0, 0, 0, 2, 0, 0,
+	0, 0, 0, 1, 0, 0, 0, 0,
+	0, 0, 0, 28, 0, 0, 0, 1,
+	1, 1, 1, 0, 0, 2, 0, 1,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 1, 1, 4, 0, 0, 2, 2,
+	0, 11, 0, 0, 0, 0, 0, 0,
+	0, 1, 1, 3, 0, 0, 4, 0,
+	0, 0, 18, 0, 0, 0, 1, 4,
+	1, 4, 1, 0, 3, 2, 2, 2,
+	1, 0, 0, 1, 8, 0, 0, 0,
+	4, 12, 0, 2, 0, 3, 0, 1,
+	0, 2, 0, 1, 2, 0, 3, 1,
+	2, 0, 0, 0, 0, 0, 1, 1,
+	0, 0, 1, 28, 3, 0, 1, 1,
+	2, 1, 0, 1, 1, 2, 1, 1,
+	2, 1, 1, 0, 2, 1, 1, 1,
+	1, 0, 0, 6, 1, 1, 0, 0,
+	46, 1, 1, 0, 0, 0, 0, 2,
+	1, 0, 0, 0, 1, 0, 0, 0,
+	0, 0, 0, 0, 13, 2, 0, 0,
+	0, 9, 0, 1, 28, 0, 1, 3,
+	0, 2, 0, 0, 0, 1, 0, 1,
+	1, 2, 0, 18, 2, 0, 0, 16,
+	35, 0, 0, 0, 1, 0, 28, 0,
+	0, 0, 0, 1, 0, 2, 0, 0,
+	1, 0, 0, 1, 0, 0, 1, 0,
+	0, 0, 0, 1, 11, 0, 0, 0,
+	0, 4, 0, 12, 1, 7, 0, 4,
+	0, 0, 0, 0, 1, 2, 1, 1,
+	1, 1, 0, 1, 1, 0, 0, 2,
+	0, 0, 0, 1, 32, 0, 0, 0,
+	0, 1, 3, 1, 1, 1, 0, 2,
+	0, 1, 1, 2, 0, 3, 0, 1,
+	0, 2, 1, 2, 0, 0, 5, 1,
+	4, 0, 0, 1, 43, 0, 0, 0,
+	2, 3, 2, 1, 1, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	1, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 4, 1, 0, 15, 0, 0,
+	0, 1, 6, 1, 0, 0, 1, 0,
+	2, 0, 0, 0, 9, 0, 1, 1,
+	0, 0, 0, 3, 0, 1, 0, 28,
+	0, 0, 0, 1, 0, 1, 0, 0,
+	0, 1, 0, 0, 0, 0, 0, 0,
+	0, 1, 0, 2, 0, 0, 18, 0,
+	0, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 1, 0, 0, 0, 16, 36,
+	0, 0, 0, 0, 1, 0, 0, 0,
+	0, 0, 1, 0, 0, 0, 0, 0,
+	0, 2, 0, 0, 0, 0, 0, 1,
+	0, 0, 0, 0, 0, 0, 0, 28,
+	0, 0, 0, 1, 1, 1, 1, 0,
+	0, 2, 0, 1, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 1, 1, 4,
+	0, 0, 2, 2, 0, 11, 0, 0,
+	0, 0, 0, 0, 0, 1, 1, 3,
+	0, 0, 4, 0, 0, 0, 18, 0,
+	0, 0, 1, 4, 1, 4, 1, 0,
+	3, 2, 2, 2, 1, 0, 0, 1,
+	8, 0, 0, 0, 4, 12, 0, 2,
+	0, 3, 0, 1, 0, 2, 0, 1,
+	2, 0, 0, 3, 0, 1, 1, 1,
+	2, 2, 4, 1, 6, 2, 4, 2,
+	4, 1, 4, 0, 6, 1, 3, 1,
+	2, 0, 2, 11, 1, 1, 1, 0,
+	1, 1, 0, 2, 0, 3, 3, 2,
+	1, 0, 0, 0, 1, 0, 1, 0,
+	1, 1, 0, 2, 0, 0, 1, 0,
+	0, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 4, 3, 2, 2, 0, 6,
+	1, 0, 1, 1, 0, 2, 0, 4,
+	3, 0, 1, 1, 0, 0, 0, 0,
+	0, 0, 0, 1, 0, 0, 0, 1,
+	0, 3, 0, 2, 0, 0, 0, 3,
+	0, 2, 1, 1, 3, 1, 0, 0,
+	0, 0, 0, 5, 2, 0, 0, 0,
+	0, 0, 0, 1, 0, 0, 1, 1,
+	0, 0, 35, 4, 0, 0, 0, 0,
+	0, 0, 0, 1, 0, 0, 0, 0,
+	0, 0, 3, 0, 1, 0, 0, 3,
+	0, 0, 1, 0, 0, 0, 0, 28,
+	0, 0, 0, 0, 1, 0, 3, 1,
+	4, 0, 1, 0, 0, 1, 0, 0,
+	1, 0, 0, 0, 0, 1, 1, 0,
+	7, 0, 0, 2, 2, 0, 11, 0,
+	0, 0, 0, 0, 1, 1, 3, 0,
+	0, 4, 0, 0, 0, 12, 1, 4,
+	1, 5, 2, 0, 3, 2, 2, 2,
+	1, 7, 0, 7, 17, 3, 0, 2,
+	0, 3, 0, 0, 1, 0, 2, 0,
+	2, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 2, 2, 1, 0, 0, 0,
+	2, 2, 4, 0, 0, 0, 0, 1,
+	2, 1, 1, 1, 1, 0, 1, 1,
+	0, 0, 2, 0, 0, 0, 1, 32,
+	0, 0, 0, 0, 1, 3, 1, 1,
+	1, 0, 2, 0, 1, 1, 2, 0,
+	3, 0, 1, 0, 2, 1, 2, 0,
+	0, 5, 1, 4, 0, 0, 1, 43,
+	0, 0, 0, 2, 3, 2, 1, 1,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 1, 1, 0, 0, 0,
+	0, 0, 0, 0, 0, 4, 1, 0,
+	15, 0, 0, 0, 1, 6, 1, 0,
+	0, 1, 0, 2, 0, 0, 0, 9,
+	0, 1, 1, 0, 0, 0, 3, 0,
+	1, 0, 28, 0, 0, 0, 1, 0,
+	1, 0, 0, 0, 1, 0, 0, 0,
+	0, 0, 0, 0, 1, 0, 2, 0,
+	0, 18, 0, 0, 1, 0, 0, 0,
+	0, 0, 0, 0, 0, 1, 0, 0,
+	0, 16, 36, 0, 0, 0, 0, 1,
+	0, 0, 0, 0, 0, 1, 0, 0,
+	0, 0, 0, 0, 2, 0, 0, 0,
+	0, 0, 1, 0, 0, 0, 0, 0,
+	0, 0, 28, 0, 0, 0, 1, 1,
+	1, 1, 0, 0, 2, 0, 1, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	1, 1, 4, 0, 0, 2, 2, 0,
+	11, 0, 0, 0, 0, 0, 0, 0,
+	1, 1, 3, 0, 0, 4, 0, 0,
+	0, 18, 0, 0, 0, 1, 4, 1,
+	4, 1, 0, 3, 2, 2, 2, 1,
+	0, 0, 1, 8, 0, 0, 0, 4,
+	12, 0, 2, 0, 3, 0, 1, 0,
+	2, 0, 1, 2, 0, 0, 3, 0,
+	1, 1, 1, 2, 2, 4, 1, 6,
+	2, 4, 2, 4, 1, 4, 0, 6,
+	1, 3, 1, 2, 0, 2, 11, 1,
+	1, 1, 0, 1, 1, 0, 2, 0,
+	3, 3, 2, 1, 0, 0, 0, 1,
+	0, 1, 0, 1, 1, 0, 2, 0,
+	0, 1, 0, 0, 0, 0, 0, 0,
+	0, 1, 0, 0, 0, 0, 0, 0,
+	0, 1, 0, 0, 0, 4, 3, 2,
+	2, 0, 6, 1, 0, 1, 1, 0,
+	2, 0, 4, 3, 0, 1, 1, 0,
+	0, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 1, 0, 3, 0, 2, 0,
+	0, 0, 3, 0, 2, 1, 1, 3,
+	1, 0, 0, 0, 0, 0, 5, 2,
+	0, 0, 0, 0, 0, 0, 1, 0,
+	0, 1, 1, 0, 0, 35, 4, 0,
+	0, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 0, 0, 0, 3, 0, 1,
+	0, 0, 3, 0, 0, 1, 0, 0,
+	0, 0, 28, 0, 0, 0, 0, 1,
+	0, 3, 1, 4, 0, 1, 0, 0,
+	1, 0, 0, 1, 0, 0, 0, 0,
+	1, 1, 0, 7, 0, 0, 2, 2,
+	0, 11, 0, 0, 0, 0, 0, 1,
+	1, 3, 0, 0, 4, 0, 0, 0,
+	12, 1, 4, 1, 5, 2, 0, 3,
+	2, 2, 2, 1, 7, 0, 7, 17,
+	3, 0, 2, 0, 3, 0, 0, 1,
+	0, 2, 0, 53, 2, 1, 1, 1,
+	1, 1, 2, 3, 2, 2, 1, 34,
+	1, 1, 0, 3, 2, 0, 0, 0,
+	1, 2, 4, 1, 0, 1, 0, 0,
+	0, 0, 1, 1, 1, 0, 0, 1,
+	30, 47, 13, 9, 3, 0, 1, 28,
+	2, 0, 18, 16, 0, 6, 4, 2,
+	2, 0, 1, 1, 1, 2, 1, 2,
+	0, 0, 0, 4, 2, 2, 3, 3,
+	2, 1, 1, 0, 0, 0, 4, 2,
+	2, 3, 3, 2, 1, 1, 0, 0,
+	0, 33, 34, 0, 3, 2, 0, 0,
+	0, 1, 2, 4, 1, 0, 1, 0,
+	0, 0, 0, 1, 1, 1, 0, 0,
+	1, 30, 47, 13, 9, 3, 0, 1,
+	28, 2, 0, 18, 16, 0,
+}
+
+var _hcltok_range_lengths []byte = []byte{
+	0, 0, 0, 0, 1, 1, 1, 5,
+	5, 5, 0, 0, 3, 0, 1, 1,
+	4, 2, 3, 0, 1, 0, 2, 2,
+	4, 2, 2, 3, 1, 1, 1, 1,
+	0, 1, 1, 2, 2, 1, 4, 6,
+	9, 6, 8, 5, 8, 7, 10, 4,
+	6, 4, 7, 7, 5, 5, 4, 5,
+	1, 2, 8, 4, 3, 3, 3, 0,
+	3, 1, 2, 1, 2, 2, 3, 3,
+	1, 3, 2, 2, 1, 2, 2, 2,
+	3, 4, 4, 3, 1, 2, 1, 3,
+	2, 2, 2, 2, 2, 3, 3, 1,
+	1, 2, 1, 3, 2, 2, 3, 2,
+	7, 0, 1, 4, 1, 2, 4, 2,
+	1, 2, 0, 2, 2, 3, 5, 5,
+	1, 4, 1, 1, 2, 2, 1, 0,
+	0, 1, 1, 1, 1, 1, 2, 2,
+	2, 2, 1, 1, 1, 4, 2, 2,
+	3, 1, 4, 4, 6, 1, 3, 1,
+	1, 2, 1, 1, 1, 5, 3, 1,
+	1, 1, 2, 3, 3, 1, 2, 2,
+	1, 4, 1, 2, 5, 2, 1, 1,
+	0, 2, 2, 2, 2, 2, 2, 2,
+	2, 2, 1, 1, 2, 4, 2, 1,
+	2, 2, 2, 6, 1, 1, 2, 1,
+	2, 1, 1, 1, 2, 2, 2, 1,
+	3, 2, 5, 2, 8, 6, 2, 2,
+	2, 2, 3, 1, 3, 1, 2, 1,
+	3, 2, 2, 3, 1, 1, 1, 1,
+	1, 1, 1, 2, 2, 4, 1, 2,
+	1, 0, 1, 1, 1, 1, 0, 1,
+	2, 3, 1, 3, 3, 1, 0, 3,
+	0, 2, 3, 1, 0, 0, 0, 0,
+	2, 2, 2, 2, 1, 5, 2, 2,
+	5, 7, 5, 0, 1, 0, 1, 1,
+	1, 1, 1, 0, 1, 1, 0, 3,
+	3, 1, 1, 2, 1, 3, 5, 1,
+	1, 2, 2, 1, 1, 1, 1, 2,
+	6, 3, 7, 2, 6, 1, 6, 2,
+	8, 0, 4, 2, 5, 2, 3, 3,
+	3, 1, 2, 8, 2, 0, 2, 1,
+	2, 1, 5, 2, 1, 3, 3, 0,
+	2, 1, 2, 1, 0, 1, 1, 3,
+	1, 1, 2, 3, 0, 0, 3, 2,
+	4, 1, 4, 1, 1, 3, 1, 1,
+	1, 1, 2, 2, 1, 3, 1, 4,
+	3, 3, 1, 1, 5, 2, 1, 1,
+	2, 1, 2, 1, 3, 2, 0, 1,
+	1, 1, 1, 1, 1, 1, 2, 1,
+	1, 1, 1, 1, 1, 1, 0, 1,
+	1, 2, 2, 1, 1, 1, 3, 2,
+	1, 0, 2, 1, 1, 1, 1, 0,
+	3, 0, 1, 1, 4, 2, 3, 0,
+	1, 0, 2, 2, 4, 2, 2, 3,
+	1, 1, 1, 1, 0, 1, 1, 2,
+	2, 1, 4, 6, 9, 6, 8, 5,
+	8, 7, 10, 4, 6, 4, 7, 7,
+	5, 5, 4, 5, 1, 2, 8, 4,
+	3, 3, 3, 0, 3, 1, 2, 1,
+	2, 2, 3, 3, 1, 3, 2, 2,
+	1, 2, 2, 2, 3, 4, 4, 3,
+	1, 2, 1, 3, 2, 2, 2, 2,
+	2, 3, 3, 1, 1, 2, 1, 3,
+	2, 2, 3, 2, 7, 0, 1, 4,
+	1, 2, 4, 2, 1, 2, 0, 2,
+	2, 3, 5, 5, 1, 4, 1, 1,
+	2, 2, 1, 0, 0, 1, 1, 1,
+	1, 1, 2, 2, 2, 2, 1, 1,
+	1, 4, 2, 2, 3, 1, 4, 4,
+	6, 1, 3, 1, 1, 2, 1, 1,
+	1, 5, 3, 1, 1, 1, 2, 3,
+	3, 1, 2, 2, 1, 4, 1, 2,
+	5, 2, 1, 1, 0, 2, 2, 2,
+	2, 2, 2, 2, 2, 2, 1, 1,
+	2, 4, 2, 1, 2, 2, 2, 6,
+	1, 1, 2, 1, 2, 1, 1, 1,
+	2, 2, 2, 1, 3, 2, 5, 2,
+	8, 6, 2, 2, 2, 2, 3, 1,
+	3, 1, 2, 1, 3, 2, 2, 3,
+	1, 1, 1, 1, 1, 1, 1, 2,
+	2, 4, 1, 2, 1, 0, 1, 1,
+	1, 1, 0, 1, 2, 3, 1, 3,
+	3, 1, 0, 3, 0, 2, 3, 1,
+	0, 0, 0, 0, 2, 2, 2, 2,
+	1, 5, 2, 2, 5, 7, 5, 0,
+	1, 0, 1, 1, 1, 1, 1, 0,
+	1, 1, 1, 2, 2, 3, 3, 4,
+	7, 5, 7, 5, 3, 3, 7, 3,
+	13, 1, 3, 5, 3, 5, 3, 6,
+	5, 2, 2, 8, 4, 1, 2, 3,
+	2, 10, 2, 2, 0, 2, 3, 3,
+	1, 2, 3, 3, 1, 2, 3, 3,
+	4, 4, 2, 1, 2, 2, 3, 2,
+	2, 5, 3, 2, 3, 2, 1, 3,
+	3, 6, 2, 2, 5, 2, 5, 1,
+	1, 2, 4, 1, 11, 1, 3, 8,
+	4, 2, 1, 0, 4, 3, 3, 3,
+	2, 9, 1, 1, 4, 3, 2, 2,
+	2, 3, 4, 2, 3, 2, 4, 3,
+	2, 2, 3, 3, 4, 3, 3, 4,
+	2, 5, 4, 8, 7, 1, 2, 1,
+	3, 1, 2, 5, 1, 2, 2, 2,
+	2, 1, 3, 2, 2, 3, 3, 1,
+	9, 1, 5, 1, 3, 2, 2, 3,
+	2, 3, 3, 3, 1, 3, 3, 2,
+	2, 4, 5, 3, 3, 4, 3, 3,
+	3, 2, 2, 2, 4, 2, 2, 1,
+	3, 3, 3, 3, 3, 3, 2, 2,
+	3, 2, 3, 3, 2, 3, 2, 3,
+	1, 2, 2, 2, 2, 2, 2, 2,
+	2, 2, 2, 2, 3, 2, 3, 2,
+	3, 5, 3, 3, 1, 2, 3, 2,
+	2, 1, 2, 3, 4, 3, 0, 3,
+	0, 2, 3, 1, 0, 0, 0, 0,
+	2, 3, 2, 4, 6, 4, 1, 1,
+	2, 1, 2, 1, 3, 2, 3, 2,
+	5, 1, 1, 1, 1, 1, 0, 1,
+	1, 1, 0, 0, 0, 1, 1, 1,
+	0, 0, 0, 3, 0, 1, 1, 4,
+	2, 3, 0, 1, 0, 2, 2, 4,
+	2, 2, 3, 1, 1, 1, 1, 0,
+	1, 1, 2, 2, 1, 4, 6, 9,
+	6, 8, 5, 8, 7, 10, 4, 6,
+	4, 7, 7, 5, 5, 4, 5, 1,
+	2, 8, 4, 3, 3, 3, 0, 3,
+	1, 2, 1, 2, 2, 3, 3, 1,
+	3, 2, 2, 1, 2, 2, 2, 3,
+	4, 4, 3, 1, 2, 1, 3, 2,
+	2, 2, 2, 2, 3, 3, 1, 1,
+	2, 1, 3, 2, 2, 3, 2, 7,
+	0, 1, 4, 1, 2, 4, 2, 1,
+	2, 0, 2, 2, 3, 5, 5, 1,
+	4, 1, 1, 2, 2, 1, 0, 0,
+	1, 1, 1, 1, 1, 2, 2, 2,
+	2, 1, 1, 1, 4, 2, 2, 3,
+	1, 4, 4, 6, 1, 3, 1, 1,
+	2, 1, 1, 1, 5, 3, 1, 1,
+	1, 2, 3, 3, 1, 2, 2, 1,
+	4, 1, 2, 5, 2, 1, 1, 0,
+	2, 2, 2, 2, 2, 2, 2, 2,
+	2, 1, 1, 2, 4, 2, 1, 2,
+	2, 2, 6, 1, 1, 2, 1, 2,
+	1, 1, 1, 2, 2, 2, 1, 3,
+	2, 5, 2, 8, 6, 2, 2, 2,
+	2, 3, 1, 3, 1, 2, 1, 3,
+	2, 2, 3, 1, 1, 1, 1, 1,
+	1, 1, 2, 2, 4, 1, 2, 1,
+	0, 1, 1, 1, 1, 0, 1, 2,
+	3, 1, 3, 3, 1, 0, 3, 0,
+	2, 3, 1, 0, 0, 0, 0, 2,
+	2, 2, 2, 1, 5, 2, 2, 5,
+	7, 5, 0, 1, 0, 1, 1, 1,
+	1, 1, 0, 1, 1, 1, 2, 2,
+	3, 3, 4, 7, 5, 7, 5, 3,
+	3, 7, 3, 13, 1, 3, 5, 3,
+	5, 3, 6, 5, 2, 2, 8, 4,
+	1, 2, 3, 2, 10, 2, 2, 0,
+	2, 3, 3, 1, 2, 3, 3, 1,
+	2, 3, 3, 4, 4, 2, 1, 2,
+	2, 3, 2, 2, 5, 3, 2, 3,
+	2, 1, 3, 3, 6, 2, 2, 5,
+	2, 5, 1, 1, 2, 4, 1, 11,
+	1, 3, 8, 4, 2, 1, 0, 4,
+	3, 3, 3, 2, 9, 1, 1, 4,
+	3, 2, 2, 2, 3, 4, 2, 3,
+	2, 4, 3, 2, 2, 3, 3, 4,
+	3, 3, 4, 2, 5, 4, 8, 7,
+	1, 2, 1, 3, 1, 2, 5, 1,
+	2, 2, 2, 2, 1, 3, 2, 2,
+	3, 3, 1, 9, 1, 5, 1, 3,
+	2, 2, 3, 2, 3, 3, 3, 1,
+	3, 3, 2, 2, 4, 5, 3, 3,
+	4, 3, 3, 3, 2, 2, 2, 4,
+	2, 2, 1, 3, 3, 3, 3, 3,
+	3, 2, 2, 3, 2, 3, 3, 2,
+	3, 2, 3, 1, 2, 2, 2, 2,
+	2, 2, 2, 2, 2, 2, 2, 3,
+	2, 3, 2, 3, 5, 3, 3, 1,
+	2, 3, 2, 2, 1, 2, 3, 4,
+	3, 0, 3, 0, 2, 3, 1, 0,
+	0, 0, 0, 2, 3, 2, 4, 6,
+	4, 1, 1, 2, 1, 2, 1, 3,
+	2, 3, 2, 11, 0, 0, 0, 0,
+	0, 0, 0, 1, 0, 0, 0, 5,
+	0, 0, 1, 1, 1, 0, 1, 1,
+	5, 4, 2, 0, 1, 0, 2, 2,
+	5, 2, 3, 5, 3, 2, 3, 5,
+	1, 1, 1, 3, 1, 1, 2, 2,
+	3, 1, 2, 3, 1, 5, 6, 0,
+	0, 0, 0, 0, 0, 0, 0, 5,
+	1, 1, 1, 5, 6, 0, 0, 0,
+	0, 0, 0, 1, 1, 1, 5, 6,
+	0, 0, 0, 0, 0, 0, 1, 1,
+	1, 8, 5, 1, 1, 1, 0, 1,
+	1, 5, 4, 2, 0, 1, 0, 2,
+	2, 5, 2, 3, 5, 3, 2, 3,
+	5, 1, 1, 1, 3, 1, 1, 2,
+	2, 3, 1, 2, 3, 1,
+}
+
+var _hcltok_index_offsets []int16 = []int16{
+	0, 0, 2, 4, 7, 12, 16, 18,
+	56, 93, 135, 137, 142, 146, 147, 149,
+	151, 157, 162, 167, 169, 172, 174, 177,
+	181, 187, 190, 193, 199, 201, 203, 205,
+	208, 241, 243, 245, 248, 251, 254, 262,
+	270, 281, 289, 298, 306, 315, 324, 336,
+	343, 350, 358, 366, 375, 381, 389, 395,
+	403, 405, 408, 422, 428, 436, 440, 444,
+	446, 493, 495, 498, 500, 505, 511, 517,
+	522, 525, 529, 532, 535, 537, 540, 543,
+	546, 550, 555, 560, 564, 566, 569, 571,
+	575, 578, 581, 584, 587, 591, 596, 600,
+	602, 604, 607, 609, 613, 616, 619, 627,
+	631, 639, 655, 657, 662, 664, 668, 679,
+	683, 685, 688, 690, 693, 698, 702, 708,
+	714, 725, 730, 733, 736, 739, 742, 744,
+	748, 749, 752, 754, 784, 786, 788, 791,
+	795, 798, 802, 804, 806, 808, 814, 817,
+	820, 824, 826, 831, 836, 843, 846, 850,
+	854, 856, 859, 879, 881, 883, 890, 894,
+	896, 898, 900, 903, 907, 911, 913, 917,
+	920, 922, 927, 945, 984, 990, 993, 995,
+	997, 999, 1002, 1005, 1008, 1011, 1014, 1018,
+	1021, 1024, 1027, 1029, 1031, 1034, 1041, 1044,
+	1046, 1049, 1052, 1055, 1063, 1065, 1067, 1070,
+	1072, 1075, 1077, 1079, 1109, 1112, 1115, 1118,
+	1121, 1126, 1130, 1137, 1140, 1149, 1158, 1161,
+	1165, 1168, 1171, 1175, 1177, 1181, 1183, 1186,
+	1188, 1192, 1196, 1200, 1208, 1210, 1212, 1216,
+	1220, 1222, 1235, 1237, 1240, 1243, 1248, 1250,
+	1253, 1255, 1257, 1260, 1265, 1267, 1269, 1274,
+	1276, 1279, 1283, 1303, 1307, 1311, 1313, 1315,
+	1323, 1325, 1332, 1337, 1339, 1343, 1346, 1349,
+	1352, 1356, 1359, 1362, 1366, 1376, 1382, 1385,
+	1388, 1398, 1418, 1424, 1427, 1429, 1433, 1435,
+	1438, 1440, 1444, 1446, 1448, 1452, 1454, 1458,
+	1463, 1469, 1471, 1473, 1476, 1478, 1482, 1489,
+	1492, 1494, 1497, 1501, 1531, 1536, 1538, 1541,
+	1545, 1554, 1559, 1567, 1571, 1579, 1583, 1591,
+	1595, 1606, 1608, 1614, 1617, 1625, 1629, 1634,
+	1639, 1644, 1646, 1649, 1664, 1668, 1670, 1673,
+	1675, 1724, 1727, 1734, 1737, 1739, 1743, 1747,
+	1750, 1754, 1756, 1759, 1761, 1763, 1765, 1767,
+	1771, 1773, 1775, 1778, 1782, 1796, 1799, 1803,
+	1806, 1811, 1822, 1827, 1830, 1860, 1864, 1867,
+	1872, 1874, 1878, 1881, 1884, 1886, 1891, 1893,
+	1899, 1904, 1910, 1912, 1932, 1940, 1943, 1945,
+	1963, 2001, 2003, 2006, 2008, 2013, 2016, 2045,
+	2047, 2049, 2051, 2053, 2056, 2058, 2062, 2065,
+	2067, 2070, 2072, 2074, 2077, 2079, 2081, 2083,
+	2085, 2087, 2090, 2093, 2096, 2109, 2111, 2115,
+	2118, 2120, 2125, 2128, 2142, 2145, 2154, 2156,
+	2161, 2165, 2166, 2168, 2170, 2176, 2181, 2186,
+	2188, 2191, 2193, 2196, 2200, 2206, 2209, 2212,
+	2218, 2220, 2222, 2224, 2227, 2260, 2262, 2264,
+	2267, 2270, 2273, 2281, 2289, 2300, 2308, 2317,
+	2325, 2334, 2343, 2355, 2362, 2369, 2377, 2385,
+	2394, 2400, 2408, 2414, 2422, 2424, 2427, 2441,
+	2447, 2455, 2459, 2463, 2465, 2512, 2514, 2517,
+	2519, 2524, 2530, 2536, 2541, 2544, 2548, 2551,
+	2554, 2556, 2559, 2562, 2565, 2569, 2574, 2579,
+	2583, 2585, 2588, 2590, 2594, 2597, 2600, 2603,
+	2606, 2610, 2615, 2619, 2621, 2623, 2626, 2628,
+	2632, 2635, 2638, 2646, 2650, 2658, 2674, 2676,
+	2681, 2683, 2687, 2698, 2702, 2704, 2707, 2709,
+	2712, 2717, 2721, 2727, 2733, 2744, 2749, 2752,
+	2755, 2758, 2761, 2763, 2767, 2768, 2771, 2773,
+	2803, 2805, 2807, 2810, 2814, 2817, 2821, 2823,
+	2825, 2827, 2833, 2836, 2839, 2843, 2845, 2850,
+	2855, 2862, 2865, 2869, 2873, 2875, 2878, 2898,
+	2900, 2902, 2909, 2913, 2915, 2917, 2919, 2922,
+	2926, 2930, 2932, 2936, 2939, 2941, 2946, 2964,
+	3003, 3009, 3012, 3014, 3016, 3018, 3021, 3024,
+	3027, 3030, 3033, 3037, 3040, 3043, 3046, 3048,
+	3050, 3053, 3060, 3063, 3065, 3068, 3071, 3074,
+	3082, 3084, 3086, 3089, 3091, 3094, 3096, 3098,
+	3128, 3131, 3134, 3137, 3140, 3145, 3149, 3156,
+	3159, 3168, 3177, 3180, 3184, 3187, 3190, 3194,
+	3196, 3200, 3202, 3205, 3207, 3211, 3215, 3219,
+	3227, 3229, 3231, 3235, 3239, 3241, 3254, 3256,
+	3259, 3262, 3267, 3269, 3272, 3274, 3276, 3279,
+	3284, 3286, 3288, 3293, 3295, 3298, 3302, 3322,
+	3326, 3330, 3332, 3334, 3342, 3344, 3351, 3356,
+	3358, 3362, 3365, 3368, 3371, 3375, 3378, 3381,
+	3385, 3395, 3401, 3404, 3407, 3417, 3437, 3443,
+	3446, 3448, 3452, 3454, 3457, 3459, 3463, 3465,
+	3467, 3471, 3473, 3475, 3481, 3484, 3489, 3494,
+	3500, 3510, 3518, 3530, 3537, 3547, 3553, 3565,
+	3571, 3589, 3592, 3600, 3606, 3616, 3623, 3630,
+	3638, 3646, 3649, 3654, 3674, 3680, 3683, 3687,
+	3691, 3695, 3707, 3710, 3715, 3716, 3722, 3729,
+	3735, 3738, 3741, 3745, 3749, 3752, 3755, 3760,
+	3764, 3770, 3776, 3779, 3783, 3786, 3789, 3794,
+	3797, 3800, 3806, 3810, 3813, 3817, 3820, 3823,
+	3827, 3831, 3838, 3841, 3844, 3850, 3853, 3860,
+	3862, 3864, 3867, 3876, 3881, 3895, 3899, 3903,
+	3918, 3924, 3927, 3930, 3932, 3937, 3943, 3947,
+	3955, 3961, 3971, 3974, 3977, 3982, 3986, 3989,
+	3992, 3995, 3999, 4004, 4008, 4012, 4015, 4020,
+	4025, 4028, 4034, 4038, 4044, 4049, 4053, 4057,
+	4065, 4068, 4076, 4082, 4092, 4103, 4106, 4109,
+	4111, 4115, 4117, 4120, 4131, 4135, 4138, 4141,
+	4144, 4147, 4149, 4153, 4157, 4160, 4164, 4169,
+	4172, 4182, 4184, 4225, 4231, 4235, 4238, 4241,
+	4245, 4248, 4252, 4256, 4261, 4263, 4267, 4271,
+	4274, 4277, 4282, 4291, 4295, 4300, 4305, 4309,
+	4316, 4320, 4323, 4327, 4330, 4335, 4338, 4341,
+	4371, 4375, 4379, 4383, 4387, 4392, 4396, 4402,
+	4406, 4414, 4417, 4422, 4426, 4429, 4434, 4437,
+	4441, 4444, 4447, 4450, 4453, 4456, 4460, 4464,
+	4467, 4477, 4480, 4483, 4488, 4494, 4497, 4512,
+	4515, 4519, 4525, 4529, 4533, 4536, 4540, 4547,
+	4550, 4553, 4559, 4562, 4566, 4571, 4587, 4589,
+	4597, 4599, 4607, 4613, 4615, 4619, 4622, 4625,
+	4628, 4632, 4643, 4646, 4658, 4682, 4690, 4692,
+	4696, 4699, 4704, 4707, 4709, 4714, 4717, 4723,
+	4726, 4734, 4736, 4738, 4740, 4742, 4744, 4746,
+	4748, 4750, 4752, 4755, 4758, 4760, 4762, 4764,
+	4766, 4769, 4772, 4777, 4781, 4782, 4784, 4786,
+	4792, 4797, 4802, 4804, 4807, 4809, 4812, 4816,
+	4822, 4825, 4828, 4834, 4836, 4838, 4840, 4843,
+	4876, 4878, 4880, 4883, 4886, 4889, 4897, 4905,
+	4916, 4924, 4933, 4941, 4950, 4959, 4971, 4978,
+	4985, 4993, 5001, 5010, 5016, 5024, 5030, 5038,
+	5040, 5043, 5057, 5063, 5071, 5075, 5079, 5081,
+	5128, 5130, 5133, 5135, 5140, 5146, 5152, 5157,
+	5160, 5164, 5167, 5170, 5172, 5175, 5178, 5181,
+	5185, 5190, 5195, 5199, 5201, 5204, 5206, 5210,
+	5213, 5216, 5219, 5222, 5226, 5231, 5235, 5237,
+	5239, 5242, 5244, 5248, 5251, 5254, 5262, 5266,
+	5274, 5290, 5292, 5297, 5299, 5303, 5314, 5318,
+	5320, 5323, 5325, 5328, 5333, 5337, 5343, 5349,
+	5360, 5365, 5368, 5371, 5374, 5377, 5379, 5383,
+	5384, 5387, 5389, 5419, 5421, 5423, 5426, 5430,
+	5433, 5437, 5439, 5441, 5443, 5449, 5452, 5455,
+	5459, 5461, 5466, 5471, 5478, 5481, 5485, 5489,
+	5491, 5494, 5514, 5516, 5518, 5525, 5529, 5531,
+	5533, 5535, 5538, 5542, 5546, 5548, 5552, 5555,
+	5557, 5562, 5580, 5619, 5625, 5628, 5630, 5632,
+	5634, 5637, 5640, 5643, 5646, 5649, 5653, 5656,
+	5659, 5662, 5664, 5666, 5669, 5676, 5679, 5681,
+	5684, 5687, 5690, 5698, 5700, 5702, 5705, 5707,
+	5710, 5712, 5714, 5744, 5747, 5750, 5753, 5756,
+	5761, 5765, 5772, 5775, 5784, 5793, 5796, 5800,
+	5803, 5806, 5810, 5812, 5816, 5818, 5821, 5823,
+	5827, 5831, 5835, 5843, 5845, 5847, 5851, 5855,
+	5857, 5870, 5872, 5875, 5878, 5883, 5885, 5888,
+	5890, 5892, 5895, 5900, 5902, 5904, 5909, 5911,
+	5914, 5918, 5938, 5942, 5946, 5948, 5950, 5958,
+	5960, 5967, 5972, 5974, 5978, 5981, 5984, 5987,
+	5991, 5994, 5997, 6001, 6011, 6017, 6020, 6023,
+	6033, 6053, 6059, 6062, 6064, 6068, 6070, 6073,
+	6075, 6079, 6081, 6083, 6087, 6089, 6091, 6097,
+	6100, 6105, 6110, 6116, 6126, 6134, 6146, 6153,
+	6163, 6169, 6181, 6187, 6205, 6208, 6216, 6222,
+	6232, 6239, 6246, 6254, 6262, 6265, 6270, 6290,
+	6296, 6299, 6303, 6307, 6311, 6323, 6326, 6331,
+	6332, 6338, 6345, 6351, 6354, 6357, 6361, 6365,
+	6368, 6371, 6376, 6380, 6386, 6392, 6395, 6399,
+	6402, 6405, 6410, 6413, 6416, 6422, 6426, 6429,
+	6433, 6436, 6439, 6443, 6447, 6454, 6457, 6460,
+	6466, 6469, 6476, 6478, 6480, 6483, 6492, 6497,
+	6511, 6515, 6519, 6534, 6540, 6543, 6546, 6548,
+	6553, 6559, 6563, 6571, 6577, 6587, 6590, 6593,
+	6598, 6602, 6605, 6608, 6611, 6615, 6620, 6624,
+	6628, 6631, 6636, 6641, 6644, 6650, 6654, 6660,
+	6665, 6669, 6673, 6681, 6684, 6692, 6698, 6708,
+	6719, 6722, 6725, 6727, 6731, 6733, 6736, 6747,
+	6751, 6754, 6757, 6760, 6763, 6765, 6769, 6773,
+	6776, 6780, 6785, 6788, 6798, 6800, 6841, 6847,
+	6851, 6854, 6857, 6861, 6864, 6868, 6872, 6877,
+	6879, 6883, 6887, 6890, 6893, 6898, 6907, 6911,
+	6916, 6921, 6925, 6932, 6936, 6939, 6943, 6946,
+	6951, 6954, 6957, 6987, 6991, 6995, 6999, 7003,
+	7008, 7012, 7018, 7022, 7030, 7033, 7038, 7042,
+	7045, 7050, 7053, 7057, 7060, 7063, 7066, 7069,
+	7072, 7076, 7080, 7083, 7093, 7096, 7099, 7104,
+	7110, 7113, 7128, 7131, 7135, 7141, 7145, 7149,
+	7152, 7156, 7163, 7166, 7169, 7175, 7178, 7182,
+	7187, 7203, 7205, 7213, 7215, 7223, 7229, 7231,
+	7235, 7238, 7241, 7244, 7248, 7259, 7262, 7274,
+	7298, 7306, 7308, 7312, 7315, 7320, 7323, 7325,
+	7330, 7333, 7339, 7342, 7407, 7410, 7412, 7414,
+	7416, 7418, 7420, 7423, 7428, 7431, 7434, 7436,
+	7476, 7478, 7480, 7482, 7487, 7491, 7492, 7494,
+	7496, 7503, 7510, 7517, 7519, 7521, 7523, 7526,
+	7529, 7535, 7538, 7543, 7550, 7555, 7558, 7562,
+	7569, 7601, 7650, 7665, 7678, 7683, 7685, 7689,
+	7720, 7726, 7728, 7749, 7769, 7771, 7783, 7794,
+	7797, 7800, 7801, 7803, 7805, 7807, 7810, 7812,
+	7820, 7822, 7824, 7826, 7836, 7845, 7848, 7852,
+	7856, 7859, 7861, 7863, 7865, 7867, 7869, 7879,
+	7888, 7891, 7895, 7899, 7902, 7904, 7906, 7908,
+	7910, 7912, 7954, 7994, 7996, 8001, 8005, 8006,
+	8008, 8010, 8017, 8024, 8031, 8033, 8035, 8037,
+	8040, 8043, 8049, 8052, 8057, 8064, 8069, 8072,
+	8076, 8083, 8115, 8164, 8179, 8192, 8197, 8199,
+	8203, 8234, 8240, 8242, 8263, 8283,
+}
+
+var _hcltok_indicies []int16 = []int16{
+	1, 0, 3, 2, 3, 4, 2, 6,
+	8, 8, 7, 5, 9, 9, 7, 5,
+	7, 5, 10, 11, 12, 13, 15, 16,
+	17, 18, 19, 20, 21, 22, 23, 24,
+	25, 26, 27, 28, 29, 30, 31, 32,
+	33, 34, 35, 36, 37, 39, 40, 41,
+	42, 43, 11, 11, 14, 14, 38, 0,
+	11, 12, 13, 15, 16, 17, 18, 19,
+	20, 21, 22, 23, 24, 25, 26, 27,
+	28, 29, 30, 31, 32, 33, 34, 35,
+	36, 37, 39, 40, 41, 42, 43, 11,
+	11, 14, 14, 38, 0, 44, 45, 11,
+	11, 46, 13, 15, 16, 17, 16, 47,
+	48, 20, 49, 22, 23, 50, 51, 52,
+	53, 54, 55, 56, 57, 58, 59, 60,
+	61, 62, 37, 39, 63, 41, 64, 65,
+	66, 11, 11, 11, 14, 38, 0, 44,
+	0, 11, 11, 11, 11, 0, 11, 11,
+	11, 0, 11, 0, 11, 11, 0, 0,
+	0, 0, 0, 0, 11, 0, 0, 0,
+	0, 11, 11, 11, 11, 11, 0, 0,
+	11, 0, 0, 11, 0, 11, 0, 0,
+	11, 0, 0, 0, 11, 11, 11, 11,
+	11, 11, 0, 11, 11, 0, 11, 11,
+	0, 0, 0, 0, 0, 0, 11, 11,
+	0, 0, 11, 0, 11, 11, 11, 0,
+	67, 68, 69, 70, 14, 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,
+	0, 11, 0, 11, 0, 11, 11, 0,
+	11, 11, 0, 0, 0, 11, 0, 0,
+	0, 0, 0, 0, 0, 11, 0, 0,
+	0, 0, 0, 0, 0, 11, 11, 11,
+	11, 11, 11, 11, 11, 11, 11, 11,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	11, 11, 11, 11, 11, 11, 11, 11,
+	11, 0, 0, 0, 0, 0, 0, 0,
+	0, 11, 11, 11, 11, 11, 11, 11,
+	11, 11, 0, 11, 11, 11, 11, 11,
+	11, 11, 11, 0, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 11, 11, 0,
+	11, 11, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 11, 11, 0, 0, 0,
+	0, 0, 0, 0, 0, 11, 11, 11,
+	11, 11, 11, 11, 11, 0, 11, 11,
+	11, 11, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 11, 0, 0, 0, 0,
+	0, 0, 0, 0, 11, 11, 11, 11,
+	11, 11, 0, 11, 11, 11, 11, 11,
+	11, 11, 0, 11, 0, 11, 11, 0,
+	11, 11, 11, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 0, 11, 11,
+	11, 11, 11, 0, 11, 11, 11, 11,
+	11, 11, 11, 0, 11, 11, 11, 0,
+	11, 11, 11, 0, 11, 0, 98, 99,
+	100, 101, 102, 103, 104, 105, 106, 107,
+	108, 109, 110, 111, 112, 113, 114, 16,
+	115, 116, 117, 118, 119, 120, 121, 122,
+	123, 124, 125, 126, 127, 128, 129, 130,
+	131, 132, 14, 15, 133, 134, 135, 136,
+	137, 14, 16, 14, 0, 11, 0, 11,
+	11, 0, 0, 11, 0, 0, 0, 0,
+	11, 0, 0, 0, 0, 0, 11, 0,
+	0, 0, 0, 0, 11, 11, 11, 11,
+	11, 0, 0, 0, 11, 0, 0, 0,
+	11, 11, 11, 0, 0, 0, 11, 11,
+	0, 0, 0, 11, 11, 11, 0, 0,
+	0, 11, 11, 11, 11, 0, 11, 11,
+	11, 11, 0, 0, 0, 0, 0, 11,
+	11, 11, 11, 0, 0, 11, 11, 11,
+	0, 0, 11, 11, 11, 11, 0, 11,
+	11, 0, 11, 11, 0, 0, 0, 11,
+	11, 11, 0, 0, 0, 0, 11, 11,
+	11, 11, 11, 0, 0, 0, 0, 11,
+	0, 11, 11, 0, 11, 11, 0, 11,
+	0, 11, 11, 11, 0, 11, 11, 0,
+	0, 0, 11, 0, 0, 0, 0, 0,
+	0, 0, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 11, 11, 11, 0, 138,
+	139, 140, 141, 142, 143, 144, 145, 146,
+	14, 147, 148, 149, 150, 151, 0, 11,
+	0, 0, 0, 0, 0, 11, 11, 0,
+	11, 11, 11, 0, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 11, 0, 11,
+	11, 11, 0, 0, 11, 11, 11, 0,
+	0, 11, 0, 0, 11, 11, 11, 11,
+	11, 0, 0, 0, 0, 11, 11, 11,
+	11, 11, 11, 0, 11, 11, 11, 11,
+	11, 0, 152, 109, 153, 154, 155, 14,
+	156, 157, 16, 14, 0, 11, 11, 11,
+	11, 0, 0, 0, 11, 0, 0, 11,
+	11, 11, 0, 0, 0, 11, 11, 0,
+	119, 0, 16, 14, 14, 158, 0, 14,
+	0, 11, 16, 159, 160, 16, 161, 162,
+	16, 57, 163, 164, 165, 166, 167, 16,
+	168, 169, 170, 16, 171, 172, 173, 15,
+	174, 175, 176, 15, 177, 16, 14, 0,
+	0, 11, 11, 0, 0, 0, 11, 11,
+	11, 11, 0, 11, 11, 0, 0, 0,
+	0, 11, 11, 0, 0, 11, 11, 0,
+	0, 0, 0, 0, 0, 11, 11, 11,
+	0, 0, 0, 11, 0, 0, 0, 11,
+	11, 0, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 0, 11, 11, 11, 11,
+	11, 11, 0, 0, 0, 11, 11, 11,
+	11, 0, 178, 179, 0, 14, 0, 11,
+	0, 0, 11, 16, 180, 181, 182, 183,
+	57, 184, 185, 55, 186, 187, 188, 189,
+	190, 191, 192, 193, 194, 14, 0, 0,
+	11, 0, 11, 11, 11, 11, 11, 11,
+	11, 0, 11, 11, 11, 0, 11, 0,
+	0, 11, 0, 11, 0, 0, 11, 11,
+	11, 11, 0, 11, 11, 11, 0, 0,
+	11, 11, 11, 11, 0, 11, 11, 0,
+	0, 11, 11, 11, 11, 11, 0, 195,
+	196, 197, 198, 199, 200, 201, 202, 203,
+	204, 205, 201, 206, 207, 208, 209, 38,
+	0, 210, 211, 16, 212, 213, 214, 215,
+	216, 217, 218, 219, 220, 16, 14, 221,
+	222, 223, 224, 16, 225, 226, 227, 228,
+	229, 230, 231, 232, 233, 234, 235, 236,
+	237, 238, 239, 16, 144, 14, 240, 0,
+	11, 11, 11, 11, 11, 0, 0, 0,
+	11, 0, 11, 11, 0, 11, 0, 11,
+	11, 0, 0, 0, 11, 11, 11, 0,
+	0, 0, 11, 11, 11, 0, 0, 0,
+	0, 11, 0, 0, 11, 0, 0, 11,
+	11, 11, 0, 0, 11, 0, 11, 11,
+	11, 0, 11, 11, 11, 11, 11, 11,
+	0, 0, 0, 11, 11, 0, 11, 11,
+	0, 11, 11, 0, 11, 11, 0, 11,
+	11, 11, 11, 11, 11, 11, 0, 11,
+	0, 11, 0, 11, 11, 0, 11, 0,
+	11, 11, 0, 11, 0, 11, 0, 241,
+	212, 242, 243, 244, 245, 246, 247, 248,
+	249, 250, 98, 251, 16, 252, 253, 254,
+	16, 255, 129, 256, 257, 258, 259, 260,
+	261, 262, 263, 16, 0, 0, 0, 11,
+	11, 11, 0, 11, 11, 0, 11, 11,
+	0, 0, 0, 0, 0, 11, 11, 11,
+	11, 0, 11, 11, 11, 11, 11, 11,
+	0, 0, 0, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 0, 11, 11, 11,
+	11, 11, 11, 11, 11, 0, 11, 11,
+	0, 0, 0, 0, 11, 11, 11, 0,
+	0, 0, 11, 0, 0, 0, 11, 11,
+	0, 11, 11, 11, 0, 11, 0, 0,
+	0, 11, 11, 0, 11, 11, 11, 0,
+	11, 11, 11, 0, 0, 0, 0, 11,
+	16, 181, 264, 265, 14, 16, 14, 0,
+	0, 11, 0, 11, 16, 264, 14, 0,
+	16, 266, 14, 0, 0, 11, 16, 267,
+	268, 269, 172, 270, 271, 16, 272, 273,
+	274, 14, 0, 0, 11, 11, 11, 0,
+	11, 11, 0, 11, 11, 11, 11, 0,
+	0, 11, 0, 0, 11, 11, 0, 11,
+	0, 16, 14, 0, 275, 16, 276, 0,
+	14, 0, 11, 0, 11, 277, 16, 278,
+	279, 0, 11, 0, 0, 0, 11, 11,
+	11, 11, 0, 280, 281, 282, 16, 283,
+	284, 285, 286, 287, 288, 289, 290, 291,
+	292, 293, 294, 295, 296, 14, 0, 11,
+	11, 11, 0, 0, 0, 0, 11, 11,
+	0, 0, 11, 0, 0, 0, 0, 0,
+	0, 0, 11, 0, 11, 0, 0, 0,
+	0, 0, 0, 11, 11, 11, 11, 11,
+	0, 0, 11, 0, 0, 0, 11, 0,
+	0, 11, 0, 0, 11, 0, 0, 11,
+	0, 0, 0, 11, 11, 11, 0, 0,
+	0, 11, 11, 11, 11, 0, 297, 16,
+	298, 16, 299, 300, 301, 302, 14, 0,
+	11, 11, 11, 11, 11, 0, 0, 0,
+	11, 0, 0, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 0, 11, 11,
+	11, 11, 11, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 11, 11, 11,
+	11, 0, 11, 11, 11, 11, 11, 0,
+	303, 16, 14, 0, 11, 304, 16, 100,
+	14, 0, 11, 305, 0, 14, 0, 11,
+	16, 306, 14, 0, 0, 11, 307, 0,
+	16, 308, 14, 0, 0, 11, 11, 11,
+	11, 0, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 11, 0, 0, 11, 0,
+	11, 11, 11, 0, 11, 0, 11, 11,
+	11, 0, 0, 0, 0, 0, 0, 0,
+	11, 11, 11, 0, 11, 0, 0, 0,
+	11, 11, 11, 11, 0, 309, 310, 69,
+	311, 312, 313, 314, 315, 316, 317, 318,
+	319, 320, 321, 322, 323, 324, 325, 326,
+	327, 328, 329, 331, 332, 333, 334, 335,
+	336, 330, 0, 11, 11, 11, 11, 0,
+	11, 0, 11, 11, 0, 11, 11, 11,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 11, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 11, 11, 11, 0, 11,
+	11, 11, 0, 11, 11, 11, 11, 11,
+	11, 11, 0, 11, 11, 11, 0, 11,
+	11, 11, 11, 11, 11, 11, 0, 11,
+	11, 11, 0, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 0, 11, 0,
+	11, 11, 11, 11, 11, 0, 11, 11,
+	0, 11, 11, 11, 11, 11, 11, 11,
+	0, 11, 11, 11, 0, 11, 11, 11,
+	11, 0, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 0, 11, 0, 11, 11,
+	0, 11, 11, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 11, 11, 0,
+	11, 11, 11, 0, 11, 0, 11, 11,
+	0, 11, 0, 337, 338, 339, 101, 102,
+	103, 104, 105, 340, 107, 108, 109, 110,
+	111, 112, 341, 342, 167, 343, 258, 117,
+	344, 119, 229, 269, 122, 345, 346, 347,
+	348, 349, 350, 351, 352, 353, 354, 131,
+	355, 16, 14, 15, 16, 134, 135, 136,
+	137, 14, 14, 0, 11, 11, 0, 11,
+	11, 11, 11, 11, 11, 0, 0, 0,
+	11, 0, 11, 11, 11, 11, 0, 11,
+	11, 11, 0, 11, 11, 0, 11, 11,
+	11, 0, 0, 11, 11, 11, 0, 0,
+	11, 11, 0, 11, 0, 11, 0, 11,
+	11, 11, 0, 0, 11, 11, 0, 11,
+	11, 0, 11, 11, 11, 0, 356, 140,
+	142, 143, 144, 145, 146, 14, 357, 148,
+	358, 150, 359, 0, 11, 11, 0, 0,
+	0, 0, 11, 0, 0, 11, 11, 11,
+	11, 11, 0, 360, 109, 361, 154, 155,
+	14, 156, 157, 16, 14, 0, 11, 11,
+	11, 11, 0, 0, 0, 11, 16, 159,
+	160, 16, 362, 363, 219, 308, 163, 164,
+	165, 364, 167, 365, 366, 367, 368, 369,
+	370, 371, 372, 373, 374, 175, 176, 15,
+	375, 16, 14, 0, 0, 0, 0, 11,
+	11, 11, 0, 0, 0, 0, 0, 11,
+	11, 0, 11, 11, 11, 0, 11, 11,
+	0, 0, 0, 11, 11, 0, 11, 11,
+	11, 11, 0, 11, 0, 11, 11, 11,
+	11, 11, 0, 0, 0, 0, 0, 11,
+	11, 11, 11, 11, 11, 0, 11, 0,
+	16, 180, 181, 376, 183, 57, 184, 185,
+	55, 186, 187, 377, 14, 190, 378, 192,
+	193, 194, 14, 0, 11, 11, 11, 11,
+	11, 11, 11, 0, 11, 11, 0, 11,
+	0, 379, 380, 197, 198, 199, 381, 201,
+	202, 382, 383, 384, 201, 206, 207, 208,
+	209, 38, 0, 210, 211, 16, 212, 213,
+	215, 385, 217, 386, 219, 220, 16, 14,
+	387, 222, 223, 224, 16, 225, 226, 227,
+	228, 229, 230, 231, 232, 388, 234, 235,
+	389, 237, 238, 239, 16, 144, 14, 240,
+	0, 0, 11, 0, 0, 11, 0, 11,
+	11, 11, 11, 11, 0, 11, 11, 0,
+	390, 391, 392, 393, 394, 395, 396, 397,
+	247, 398, 319, 399, 213, 400, 401, 402,
+	403, 404, 401, 405, 406, 407, 258, 408,
+	260, 409, 410, 271, 0, 11, 0, 11,
+	0, 11, 0, 11, 0, 11, 11, 0,
+	11, 0, 11, 11, 11, 0, 11, 11,
+	0, 0, 11, 11, 11, 0, 11, 0,
+	11, 0, 11, 11, 0, 11, 0, 11,
+	0, 11, 0, 11, 0, 11, 0, 0,
+	0, 11, 11, 11, 0, 11, 11, 0,
+	16, 267, 229, 411, 401, 412, 271, 16,
+	413, 414, 274, 14, 0, 11, 0, 11,
+	11, 11, 0, 0, 0, 11, 11, 0,
+	277, 16, 278, 415, 0, 11, 11, 0,
+	16, 283, 284, 285, 286, 287, 288, 289,
+	290, 291, 292, 416, 14, 0, 0, 0,
+	11, 16, 417, 16, 265, 300, 301, 302,
+	14, 0, 0, 11, 419, 419, 419, 419,
+	418, 419, 419, 419, 418, 419, 418, 419,
+	419, 418, 418, 418, 418, 418, 418, 419,
+	418, 418, 418, 418, 419, 419, 419, 419,
+	419, 418, 418, 419, 418, 418, 419, 418,
+	419, 418, 418, 419, 418, 418, 418, 419,
+	419, 419, 419, 419, 419, 418, 419, 419,
+	418, 419, 419, 418, 418, 418, 418, 418,
+	418, 419, 419, 418, 418, 419, 418, 419,
+	419, 419, 418, 421, 422, 423, 424, 425,
+	426, 427, 428, 429, 430, 431, 432, 433,
+	434, 435, 436, 437, 438, 439, 440, 441,
+	442, 443, 444, 445, 446, 447, 448, 449,
+	450, 451, 452, 418, 419, 418, 419, 418,
+	419, 419, 418, 419, 419, 418, 418, 418,
+	419, 418, 418, 418, 418, 418, 418, 418,
+	419, 418, 418, 418, 418, 418, 418, 418,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 418, 418, 418, 418, 418,
+	418, 418, 418, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 418, 418, 418, 418,
+	418, 418, 418, 418, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 418, 419, 419,
+	419, 419, 419, 419, 419, 419, 418, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 418, 419, 419, 419, 419, 419,
+	419, 418, 419, 419, 419, 419, 419, 419,
+	418, 418, 418, 418, 418, 418, 418, 418,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	418, 419, 419, 419, 419, 419, 419, 419,
+	419, 418, 419, 419, 419, 419, 419, 418,
+	418, 418, 418, 418, 418, 418, 418, 419,
+	419, 419, 419, 419, 419, 418, 419, 419,
+	419, 419, 419, 419, 419, 418, 419, 418,
+	419, 419, 418, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	418, 419, 419, 419, 419, 419, 418, 419,
+	419, 419, 419, 419, 419, 419, 418, 419,
+	419, 419, 418, 419, 419, 419, 418, 419,
+	418, 453, 454, 455, 456, 457, 458, 459,
+	460, 461, 462, 463, 464, 465, 466, 467,
+	468, 469, 470, 471, 472, 473, 474, 475,
+	476, 477, 478, 479, 480, 481, 482, 483,
+	484, 485, 486, 487, 488, 425, 489, 490,
+	491, 492, 493, 494, 425, 470, 425, 418,
+	419, 418, 419, 419, 418, 418, 419, 418,
+	418, 418, 418, 419, 418, 418, 418, 418,
+	418, 419, 418, 418, 418, 418, 418, 419,
+	419, 419, 419, 419, 418, 418, 418, 419,
+	418, 418, 418, 419, 419, 419, 418, 418,
+	418, 419, 419, 418, 418, 418, 419, 419,
+	419, 418, 418, 418, 419, 419, 419, 419,
+	418, 419, 419, 419, 419, 418, 418, 418,
+	418, 418, 419, 419, 419, 419, 418, 418,
+	419, 419, 419, 418, 418, 419, 419, 419,
+	419, 418, 419, 419, 418, 419, 419, 418,
+	418, 418, 419, 419, 419, 418, 418, 418,
+	418, 419, 419, 419, 419, 419, 418, 418,
+	418, 418, 419, 418, 419, 419, 418, 419,
+	419, 418, 419, 418, 419, 419, 419, 418,
+	419, 419, 418, 418, 418, 419, 418, 418,
+	418, 418, 418, 418, 418, 419, 419, 419,
+	419, 418, 419, 419, 419, 419, 419, 419,
+	419, 418, 495, 496, 497, 498, 499, 500,
+	501, 502, 503, 425, 504, 505, 506, 507,
+	508, 418, 419, 418, 418, 418, 418, 418,
+	419, 419, 418, 419, 419, 419, 418, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 418, 419, 419, 419, 418, 418, 419,
+	419, 419, 418, 418, 419, 418, 418, 419,
+	419, 419, 419, 419, 418, 418, 418, 418,
+	419, 419, 419, 419, 419, 419, 418, 419,
+	419, 419, 419, 419, 418, 509, 464, 510,
+	511, 512, 425, 513, 514, 470, 425, 418,
+	419, 419, 419, 419, 418, 418, 418, 419,
+	418, 418, 419, 419, 419, 418, 418, 418,
+	419, 419, 418, 475, 418, 470, 425, 425,
+	515, 418, 425, 418, 419, 470, 516, 517,
+	470, 518, 519, 470, 520, 521, 522, 523,
+	524, 525, 470, 526, 527, 528, 470, 529,
+	530, 531, 489, 532, 533, 534, 489, 535,
+	470, 425, 418, 418, 419, 419, 418, 418,
+	418, 419, 419, 419, 419, 418, 419, 419,
+	418, 418, 418, 418, 419, 419, 418, 418,
+	419, 419, 418, 418, 418, 418, 418, 418,
+	419, 419, 419, 418, 418, 418, 419, 418,
+	418, 418, 419, 419, 418, 419, 419, 419,
+	419, 418, 419, 419, 419, 419, 418, 419,
+	419, 419, 419, 419, 419, 418, 418, 418,
+	419, 419, 419, 419, 418, 536, 537, 418,
+	425, 418, 419, 418, 418, 419, 470, 538,
+	539, 540, 541, 520, 542, 543, 544, 545,
+	546, 547, 548, 549, 550, 551, 552, 553,
+	425, 418, 418, 419, 418, 419, 419, 419,
+	419, 419, 419, 419, 418, 419, 419, 419,
+	418, 419, 418, 418, 419, 418, 419, 418,
+	418, 419, 419, 419, 419, 418, 419, 419,
+	419, 418, 418, 419, 419, 419, 419, 418,
+	419, 419, 418, 418, 419, 419, 419, 419,
+	419, 418, 554, 555, 556, 557, 558, 559,
+	560, 561, 562, 563, 564, 560, 566, 567,
+	568, 569, 565, 418, 570, 571, 470, 572,
+	573, 574, 575, 576, 577, 578, 579, 580,
+	470, 425, 581, 582, 583, 584, 470, 585,
+	586, 587, 588, 589, 590, 591, 592, 593,
+	594, 595, 596, 597, 598, 599, 470, 501,
+	425, 600, 418, 419, 419, 419, 419, 419,
+	418, 418, 418, 419, 418, 419, 419, 418,
+	419, 418, 419, 419, 418, 418, 418, 419,
+	419, 419, 418, 418, 418, 419, 419, 419,
+	418, 418, 418, 418, 419, 418, 418, 419,
+	418, 418, 419, 419, 419, 418, 418, 419,
+	418, 419, 419, 419, 418, 419, 419, 419,
+	419, 419, 419, 418, 418, 418, 419, 419,
+	418, 419, 419, 418, 419, 419, 418, 419,
+	419, 418, 419, 419, 419, 419, 419, 419,
+	419, 418, 419, 418, 419, 418, 419, 419,
+	418, 419, 418, 419, 419, 418, 419, 418,
+	419, 418, 601, 572, 602, 603, 604, 605,
+	606, 607, 608, 609, 610, 453, 611, 470,
+	612, 613, 614, 470, 615, 485, 616, 617,
+	618, 619, 620, 621, 622, 623, 470, 418,
+	418, 418, 419, 419, 419, 418, 419, 419,
+	418, 419, 419, 418, 418, 418, 418, 418,
+	419, 419, 419, 419, 418, 419, 419, 419,
+	419, 419, 419, 418, 418, 418, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 418,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	418, 419, 419, 418, 418, 418, 418, 419,
+	419, 419, 418, 418, 418, 419, 418, 418,
+	418, 419, 419, 418, 419, 419, 419, 418,
+	419, 418, 418, 418, 419, 419, 418, 419,
+	419, 419, 418, 419, 419, 419, 418, 418,
+	418, 418, 419, 470, 539, 624, 625, 425,
+	470, 425, 418, 418, 419, 418, 419, 470,
+	624, 425, 418, 470, 626, 425, 418, 418,
+	419, 470, 627, 628, 629, 530, 630, 631,
+	470, 632, 633, 634, 425, 418, 418, 419,
+	419, 419, 418, 419, 419, 418, 419, 419,
+	419, 419, 418, 418, 419, 418, 418, 419,
+	419, 418, 419, 418, 470, 425, 418, 635,
+	470, 636, 418, 425, 418, 419, 418, 419,
+	637, 470, 638, 639, 418, 419, 418, 418,
+	418, 419, 419, 419, 419, 418, 640, 641,
+	642, 470, 643, 644, 645, 646, 647, 648,
+	649, 650, 651, 652, 653, 654, 655, 656,
+	425, 418, 419, 419, 419, 418, 418, 418,
+	418, 419, 419, 418, 418, 419, 418, 418,
+	418, 418, 418, 418, 418, 419, 418, 419,
+	418, 418, 418, 418, 418, 418, 419, 419,
+	419, 419, 419, 418, 418, 419, 418, 418,
+	418, 419, 418, 418, 419, 418, 418, 419,
+	418, 418, 419, 418, 418, 418, 419, 419,
+	419, 418, 418, 418, 419, 419, 419, 419,
+	418, 657, 470, 658, 470, 659, 660, 661,
+	662, 425, 418, 419, 419, 419, 419, 419,
+	418, 418, 418, 419, 418, 418, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	418, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 418, 419, 419, 419,
+	419, 419, 418, 663, 470, 425, 418, 419,
+	664, 470, 455, 425, 418, 419, 665, 418,
+	425, 418, 419, 470, 666, 425, 418, 418,
+	419, 667, 418, 470, 668, 425, 418, 418,
+	419, 670, 669, 419, 419, 419, 419, 670,
+	669, 419, 670, 669, 670, 670, 419, 670,
+	669, 419, 670, 419, 670, 669, 419, 670,
+	419, 670, 419, 669, 670, 670, 670, 670,
+	670, 670, 670, 670, 669, 419, 419, 670,
+	670, 419, 670, 419, 670, 669, 670, 670,
+	670, 670, 670, 419, 670, 419, 670, 419,
+	670, 669, 670, 670, 419, 670, 419, 670,
+	669, 670, 670, 670, 670, 670, 419, 670,
+	419, 670, 669, 419, 419, 670, 419, 670,
+	669, 670, 670, 670, 419, 670, 419, 670,
+	419, 670, 419, 670, 669, 670, 419, 670,
+	419, 670, 669, 419, 670, 670, 670, 670,
+	419, 670, 419, 670, 419, 670, 419, 670,
+	419, 670, 419, 670, 669, 419, 670, 669,
+	670, 670, 670, 419, 670, 419, 670, 669,
+	670, 419, 670, 419, 670, 669, 419, 670,
+	670, 670, 670, 419, 670, 419, 670, 669,
+	419, 670, 419, 670, 419, 670, 669, 670,
+	670, 419, 670, 419, 670, 669, 419, 670,
+	419, 670, 419, 670, 419, 669, 670, 670,
+	670, 419, 670, 419, 670, 669, 419, 670,
+	669, 670, 670, 419, 670, 669, 670, 670,
+	670, 419, 670, 670, 670, 670, 670, 670,
+	419, 419, 670, 419, 670, 419, 670, 419,
+	670, 669, 670, 419, 670, 419, 670, 669,
+	419, 670, 669, 670, 419, 670, 669, 670,
+	419, 670, 669, 419, 419, 670, 669, 419,
+	670, 419, 670, 419, 670, 419, 670, 419,
+	670, 419, 669, 670, 670, 419, 670, 670,
+	670, 670, 419, 419, 670, 670, 670, 670,
+	670, 419, 670, 670, 670, 670, 670, 669,
+	419, 670, 670, 419, 670, 419, 669, 670,
+	670, 419, 670, 669, 419, 419, 670, 419,
+	669, 670, 670, 669, 419, 670, 419, 669,
+	670, 669, 419, 670, 419, 670, 419, 669,
+	670, 670, 669, 419, 670, 419, 670, 419,
+	670, 669, 670, 419, 670, 419, 670, 669,
+	419, 670, 669, 419, 419, 670, 669, 670,
+	419, 669, 670, 669, 419, 670, 419, 670,
+	419, 669, 670, 669, 419, 419, 670, 669,
+	670, 419, 670, 419, 670, 669, 419, 670,
+	419, 669, 670, 669, 419, 419, 670, 419,
+	669, 670, 669, 419, 419, 670, 669, 670,
+	419, 670, 669, 670, 419, 670, 669, 670,
+	419, 670, 419, 670, 419, 669, 670, 669,
+	419, 419, 670, 669, 670, 419, 670, 419,
+	670, 669, 419, 670, 669, 670, 670, 419,
+	670, 419, 670, 669, 669, 419, 669, 419,
+	670, 670, 419, 670, 670, 670, 670, 670,
+	670, 670, 669, 419, 670, 670, 670, 419,
+	669, 670, 670, 670, 419, 670, 419, 670,
+	419, 670, 419, 670, 419, 670, 669, 419,
+	419, 670, 669, 670, 419, 670, 669, 419,
+	419, 670, 419, 419, 419, 670, 419, 670,
+	419, 670, 419, 670, 419, 669, 419, 670,
+	419, 670, 419, 669, 670, 669, 419, 670,
+	419, 669, 670, 419, 670, 670, 670, 669,
+	419, 670, 419, 419, 670, 419, 669, 670,
+	670, 669, 419, 670, 670, 670, 670, 419,
+	670, 419, 669, 670, 670, 670, 419, 670,
+	669, 670, 419, 670, 419, 670, 419, 670,
+	419, 670, 669, 670, 670, 419, 670, 669,
+	419, 670, 419, 670, 419, 669, 670, 670,
+	669, 419, 670, 419, 669, 670, 669, 419,
+	670, 669, 419, 670, 419, 670, 669, 670,
+	670, 670, 669, 419, 419, 419, 670, 669,
+	419, 670, 419, 669, 670, 669, 419, 670,
+	419, 670, 419, 669, 670, 670, 670, 669,
+	419, 670, 419, 669, 670, 670, 670, 670,
+	669, 419, 670, 419, 670, 669, 419, 419,
+	670, 419, 670, 669, 670, 419, 670, 419,
+	669, 670, 670, 669, 419, 670, 419, 670,
+	669, 419, 670, 670, 670, 419, 670, 419,
+	669, 419, 670, 669, 670, 419, 419, 670,
+	419, 670, 419, 669, 670, 670, 670, 670,
+	669, 419, 670, 419, 670, 419, 670, 419,
+	670, 419, 670, 669, 670, 670, 670, 419,
+	670, 419, 670, 419, 670, 419, 669, 670,
+	670, 419, 419, 670, 669, 670, 419, 670,
+	670, 669, 419, 670, 419, 670, 669, 419,
+	419, 670, 670, 670, 670, 419, 670, 419,
+	670, 419, 669, 670, 670, 419, 669, 670,
+	669, 419, 670, 419, 669, 670, 669, 419,
+	670, 419, 669, 670, 419, 670, 670, 669,
+	419, 670, 670, 419, 669, 670, 669, 419,
+	670, 419, 670, 669, 670, 419, 670, 419,
+	669, 670, 669, 419, 670, 419, 670, 419,
+	670, 419, 670, 419, 670, 669, 671, 669,
+	672, 673, 674, 675, 676, 677, 678, 679,
+	680, 681, 682, 674, 683, 684, 685, 686,
+	687, 674, 688, 689, 690, 691, 692, 693,
+	694, 695, 696, 697, 698, 699, 700, 701,
+	702, 674, 703, 671, 683, 671, 704, 671,
+	669, 670, 670, 670, 670, 419, 669, 670,
+	670, 669, 419, 670, 669, 419, 419, 670,
+	669, 419, 670, 419, 669, 670, 669, 419,
+	419, 670, 419, 669, 670, 670, 669, 419,
+	670, 670, 670, 669, 419, 670, 419, 670,
+	670, 669, 419, 419, 670, 419, 669, 670,
+	669, 419, 670, 669, 419, 419, 670, 419,
+	670, 669, 419, 670, 419, 419, 670, 419,
+	670, 419, 669, 670, 670, 669, 419, 670,
+	670, 419, 670, 669, 419, 670, 419, 670,
+	669, 419, 670, 419, 669, 419, 670, 670,
+	670, 419, 670, 669, 670, 419, 670, 669,
+	419, 670, 669, 670, 419, 670, 669, 419,
+	670, 669, 419, 670, 419, 670, 669, 419,
+	670, 669, 419, 670, 669, 705, 706, 707,
+	708, 709, 710, 711, 712, 713, 714, 715,
+	716, 676, 717, 718, 719, 720, 721, 718,
+	722, 723, 724, 725, 726, 727, 728, 729,
+	730, 671, 669, 670, 419, 670, 669, 670,
+	419, 670, 669, 670, 419, 670, 669, 670,
+	419, 670, 669, 419, 670, 419, 670, 669,
+	670, 419, 670, 669, 670, 419, 419, 419,
+	670, 669, 670, 419, 670, 669, 670, 670,
+	670, 670, 419, 670, 419, 669, 670, 669,
+	419, 419, 670, 419, 670, 669, 670, 419,
+	670, 669, 419, 670, 669, 670, 670, 419,
+	670, 669, 419, 670, 669, 670, 419, 670,
+	669, 419, 670, 669, 419, 670, 669, 419,
+	670, 669, 670, 669, 419, 419, 670, 669,
+	670, 419, 670, 669, 419, 670, 419, 669,
+	670, 669, 419, 674, 731, 671, 674, 732,
+	674, 733, 683, 671, 669, 670, 669, 419,
+	670, 669, 419, 674, 732, 683, 671, 669,
+	674, 734, 671, 683, 671, 669, 670, 669,
+	419, 674, 735, 692, 736, 718, 737, 730,
+	674, 738, 739, 740, 671, 683, 671, 669,
+	670, 669, 419, 670, 419, 670, 669, 419,
+	670, 419, 670, 419, 669, 670, 670, 669,
+	419, 670, 419, 670, 669, 419, 670, 669,
+	674, 683, 425, 669, 741, 674, 742, 683,
+	671, 669, 425, 670, 669, 419, 670, 669,
+	419, 743, 674, 744, 745, 671, 669, 419,
+	670, 669, 670, 670, 669, 419, 419, 670,
+	419, 670, 669, 674, 746, 747, 748, 749,
+	750, 751, 752, 753, 754, 755, 756, 671,
+	683, 671, 669, 670, 419, 670, 670, 670,
+	670, 670, 670, 670, 419, 670, 419, 670,
+	670, 670, 670, 670, 670, 669, 419, 670,
+	670, 419, 670, 419, 669, 670, 419, 670,
+	670, 670, 419, 670, 670, 419, 670, 670,
+	419, 670, 670, 419, 670, 670, 669, 419,
+	674, 757, 674, 733, 758, 759, 760, 671,
+	683, 671, 669, 670, 669, 419, 670, 670,
+	670, 419, 670, 670, 670, 419, 670, 419,
+	670, 669, 419, 419, 419, 419, 670, 670,
+	419, 419, 419, 419, 419, 670, 670, 670,
+	670, 670, 670, 670, 419, 670, 419, 670,
+	419, 669, 670, 670, 670, 419, 670, 419,
+	670, 669, 683, 425, 761, 674, 683, 425,
+	670, 669, 419, 762, 674, 763, 683, 425,
+	670, 669, 419, 670, 419, 764, 683, 671,
+	669, 425, 670, 669, 419, 674, 765, 671,
+	683, 671, 669, 670, 669, 419, 766, 766,
+	766, 768, 769, 770, 766, 767, 767, 771,
+	768, 771, 769, 771, 767, 772, 773, 772,
+	775, 774, 776, 774, 777, 774, 779, 778,
+	781, 782, 780, 781, 783, 780, 785, 784,
+	786, 784, 787, 784, 789, 788, 791, 792,
+	790, 791, 793, 790, 795, 795, 795, 795,
+	794, 795, 795, 795, 794, 795, 794, 795,
+	795, 794, 794, 794, 794, 794, 794, 795,
+	794, 794, 794, 794, 795, 795, 795, 795,
+	795, 794, 794, 795, 794, 794, 795, 794,
+	795, 794, 794, 795, 794, 794, 794, 795,
+	795, 795, 795, 795, 795, 794, 795, 795,
+	794, 795, 795, 794, 794, 794, 794, 794,
+	794, 795, 795, 794, 794, 795, 794, 795,
+	795, 795, 794, 797, 798, 799, 800, 801,
+	802, 803, 804, 805, 806, 807, 808, 809,
+	810, 811, 812, 813, 814, 815, 816, 817,
+	818, 819, 820, 821, 822, 823, 824, 825,
+	826, 827, 828, 794, 795, 794, 795, 794,
+	795, 795, 794, 795, 795, 794, 794, 794,
+	795, 794, 794, 794, 794, 794, 794, 794,
+	795, 794, 794, 794, 794, 794, 794, 794,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 794, 794, 794, 794, 794,
+	794, 794, 794, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 794, 794, 794, 794,
+	794, 794, 794, 794, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 794, 795, 795,
+	795, 795, 795, 795, 795, 795, 794, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 794, 795, 795, 795, 795, 795,
+	795, 794, 795, 795, 795, 795, 795, 795,
+	794, 794, 794, 794, 794, 794, 794, 794,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	794, 795, 795, 795, 795, 795, 795, 795,
+	795, 794, 795, 795, 795, 795, 795, 794,
+	794, 794, 794, 794, 794, 794, 794, 795,
+	795, 795, 795, 795, 795, 794, 795, 795,
+	795, 795, 795, 795, 795, 794, 795, 794,
+	795, 795, 794, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	794, 795, 795, 795, 795, 795, 794, 795,
+	795, 795, 795, 795, 795, 795, 794, 795,
+	795, 795, 794, 795, 795, 795, 794, 795,
+	794, 829, 830, 831, 832, 833, 834, 835,
+	836, 837, 838, 839, 840, 841, 842, 843,
+	844, 845, 846, 847, 848, 849, 850, 851,
+	852, 853, 854, 855, 856, 857, 858, 859,
+	860, 861, 862, 863, 864, 801, 865, 866,
+	867, 868, 869, 870, 801, 846, 801, 794,
+	795, 794, 795, 795, 794, 794, 795, 794,
+	794, 794, 794, 795, 794, 794, 794, 794,
+	794, 795, 794, 794, 794, 794, 794, 795,
+	795, 795, 795, 795, 794, 794, 794, 795,
+	794, 794, 794, 795, 795, 795, 794, 794,
+	794, 795, 795, 794, 794, 794, 795, 795,
+	795, 794, 794, 794, 795, 795, 795, 795,
+	794, 795, 795, 795, 795, 794, 794, 794,
+	794, 794, 795, 795, 795, 795, 794, 794,
+	795, 795, 795, 794, 794, 795, 795, 795,
+	795, 794, 795, 795, 794, 795, 795, 794,
+	794, 794, 795, 795, 795, 794, 794, 794,
+	794, 795, 795, 795, 795, 795, 794, 794,
+	794, 794, 795, 794, 795, 795, 794, 795,
+	795, 794, 795, 794, 795, 795, 795, 794,
+	795, 795, 794, 794, 794, 795, 794, 794,
+	794, 794, 794, 794, 794, 795, 795, 795,
+	795, 794, 795, 795, 795, 795, 795, 795,
+	795, 794, 871, 872, 873, 874, 875, 876,
+	877, 878, 879, 801, 880, 881, 882, 883,
+	884, 794, 795, 794, 794, 794, 794, 794,
+	795, 795, 794, 795, 795, 795, 794, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 794, 795, 795, 795, 794, 794, 795,
+	795, 795, 794, 794, 795, 794, 794, 795,
+	795, 795, 795, 795, 794, 794, 794, 794,
+	795, 795, 795, 795, 795, 795, 794, 795,
+	795, 795, 795, 795, 794, 885, 840, 886,
+	887, 888, 801, 889, 890, 846, 801, 794,
+	795, 795, 795, 795, 794, 794, 794, 795,
+	794, 794, 795, 795, 795, 794, 794, 794,
+	795, 795, 794, 851, 794, 846, 801, 801,
+	891, 794, 801, 794, 795, 846, 892, 893,
+	846, 894, 895, 846, 896, 897, 898, 899,
+	900, 901, 846, 902, 903, 904, 846, 905,
+	906, 907, 865, 908, 909, 910, 865, 911,
+	846, 801, 794, 794, 795, 795, 794, 794,
+	794, 795, 795, 795, 795, 794, 795, 795,
+	794, 794, 794, 794, 795, 795, 794, 794,
+	795, 795, 794, 794, 794, 794, 794, 794,
+	795, 795, 795, 794, 794, 794, 795, 794,
+	794, 794, 795, 795, 794, 795, 795, 795,
+	795, 794, 795, 795, 795, 795, 794, 795,
+	795, 795, 795, 795, 795, 794, 794, 794,
+	795, 795, 795, 795, 794, 912, 913, 794,
+	801, 794, 795, 794, 794, 795, 846, 914,
+	915, 916, 917, 896, 918, 919, 920, 921,
+	922, 923, 924, 925, 926, 927, 928, 929,
+	801, 794, 794, 795, 794, 795, 795, 795,
+	795, 795, 795, 795, 794, 795, 795, 795,
+	794, 795, 794, 794, 795, 794, 795, 794,
+	794, 795, 795, 795, 795, 794, 795, 795,
+	795, 794, 794, 795, 795, 795, 795, 794,
+	795, 795, 794, 794, 795, 795, 795, 795,
+	795, 794, 930, 931, 932, 933, 934, 935,
+	936, 937, 938, 939, 940, 936, 942, 943,
+	944, 945, 941, 794, 946, 947, 846, 948,
+	949, 950, 951, 952, 953, 954, 955, 956,
+	846, 801, 957, 958, 959, 960, 846, 961,
+	962, 963, 964, 965, 966, 967, 968, 969,
+	970, 971, 972, 973, 974, 975, 846, 877,
+	801, 976, 794, 795, 795, 795, 795, 795,
+	794, 794, 794, 795, 794, 795, 795, 794,
+	795, 794, 795, 795, 794, 794, 794, 795,
+	795, 795, 794, 794, 794, 795, 795, 795,
+	794, 794, 794, 794, 795, 794, 794, 795,
+	794, 794, 795, 795, 795, 794, 794, 795,
+	794, 795, 795, 795, 794, 795, 795, 795,
+	795, 795, 795, 794, 794, 794, 795, 795,
+	794, 795, 795, 794, 795, 795, 794, 795,
+	795, 794, 795, 795, 795, 795, 795, 795,
+	795, 794, 795, 794, 795, 794, 795, 795,
+	794, 795, 794, 795, 795, 794, 795, 794,
+	795, 794, 977, 948, 978, 979, 980, 981,
+	982, 983, 984, 985, 986, 829, 987, 846,
+	988, 989, 990, 846, 991, 861, 992, 993,
+	994, 995, 996, 997, 998, 999, 846, 794,
+	794, 794, 795, 795, 795, 794, 795, 795,
+	794, 795, 795, 794, 794, 794, 794, 794,
+	795, 795, 795, 795, 794, 795, 795, 795,
+	795, 795, 795, 794, 794, 794, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 794,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	794, 795, 795, 794, 794, 794, 794, 795,
+	795, 795, 794, 794, 794, 795, 794, 794,
+	794, 795, 795, 794, 795, 795, 795, 794,
+	795, 794, 794, 794, 795, 795, 794, 795,
+	795, 795, 794, 795, 795, 795, 794, 794,
+	794, 794, 795, 846, 915, 1000, 1001, 801,
+	846, 801, 794, 794, 795, 794, 795, 846,
+	1000, 801, 794, 846, 1002, 801, 794, 794,
+	795, 846, 1003, 1004, 1005, 906, 1006, 1007,
+	846, 1008, 1009, 1010, 801, 794, 794, 795,
+	795, 795, 794, 795, 795, 794, 795, 795,
+	795, 795, 794, 794, 795, 794, 794, 795,
+	795, 794, 795, 794, 846, 801, 794, 1011,
+	846, 1012, 794, 801, 794, 795, 794, 795,
+	1013, 846, 1014, 1015, 794, 795, 794, 794,
+	794, 795, 795, 795, 795, 794, 1016, 1017,
+	1018, 846, 1019, 1020, 1021, 1022, 1023, 1024,
+	1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032,
+	801, 794, 795, 795, 795, 794, 794, 794,
+	794, 795, 795, 794, 794, 795, 794, 794,
+	794, 794, 794, 794, 794, 795, 794, 795,
+	794, 794, 794, 794, 794, 794, 795, 795,
+	795, 795, 795, 794, 794, 795, 794, 794,
+	794, 795, 794, 794, 795, 794, 794, 795,
+	794, 794, 795, 794, 794, 794, 795, 795,
+	795, 794, 794, 794, 795, 795, 795, 795,
+	794, 1033, 846, 1034, 846, 1035, 1036, 1037,
+	1038, 801, 794, 795, 795, 795, 795, 795,
+	794, 794, 794, 795, 794, 794, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	794, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 794, 795, 795, 795,
+	795, 795, 794, 1039, 846, 801, 794, 795,
+	1040, 846, 831, 801, 794, 795, 1041, 794,
+	801, 794, 795, 846, 1042, 801, 794, 794,
+	795, 1043, 794, 846, 1044, 801, 794, 794,
+	795, 1046, 1045, 795, 795, 795, 795, 1046,
+	1045, 795, 1046, 1045, 1046, 1046, 795, 1046,
+	1045, 795, 1046, 795, 1046, 1045, 795, 1046,
+	795, 1046, 795, 1045, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1045, 795, 795, 1046,
+	1046, 795, 1046, 795, 1046, 1045, 1046, 1046,
+	1046, 1046, 1046, 795, 1046, 795, 1046, 795,
+	1046, 1045, 1046, 1046, 795, 1046, 795, 1046,
+	1045, 1046, 1046, 1046, 1046, 1046, 795, 1046,
+	795, 1046, 1045, 795, 795, 1046, 795, 1046,
+	1045, 1046, 1046, 1046, 795, 1046, 795, 1046,
+	795, 1046, 795, 1046, 1045, 1046, 795, 1046,
+	795, 1046, 1045, 795, 1046, 1046, 1046, 1046,
+	795, 1046, 795, 1046, 795, 1046, 795, 1046,
+	795, 1046, 795, 1046, 1045, 795, 1046, 1045,
+	1046, 1046, 1046, 795, 1046, 795, 1046, 1045,
+	1046, 795, 1046, 795, 1046, 1045, 795, 1046,
+	1046, 1046, 1046, 795, 1046, 795, 1046, 1045,
+	795, 1046, 795, 1046, 795, 1046, 1045, 1046,
+	1046, 795, 1046, 795, 1046, 1045, 795, 1046,
+	795, 1046, 795, 1046, 795, 1045, 1046, 1046,
+	1046, 795, 1046, 795, 1046, 1045, 795, 1046,
+	1045, 1046, 1046, 795, 1046, 1045, 1046, 1046,
+	1046, 795, 1046, 1046, 1046, 1046, 1046, 1046,
+	795, 795, 1046, 795, 1046, 795, 1046, 795,
+	1046, 1045, 1046, 795, 1046, 795, 1046, 1045,
+	795, 1046, 1045, 1046, 795, 1046, 1045, 1046,
+	795, 1046, 1045, 795, 795, 1046, 1045, 795,
+	1046, 795, 1046, 795, 1046, 795, 1046, 795,
+	1046, 795, 1045, 1046, 1046, 795, 1046, 1046,
+	1046, 1046, 795, 795, 1046, 1046, 1046, 1046,
+	1046, 795, 1046, 1046, 1046, 1046, 1046, 1045,
+	795, 1046, 1046, 795, 1046, 795, 1045, 1046,
+	1046, 795, 1046, 1045, 795, 795, 1046, 795,
+	1045, 1046, 1046, 1045, 795, 1046, 795, 1045,
+	1046, 1045, 795, 1046, 795, 1046, 795, 1045,
+	1046, 1046, 1045, 795, 1046, 795, 1046, 795,
+	1046, 1045, 1046, 795, 1046, 795, 1046, 1045,
+	795, 1046, 1045, 795, 795, 1046, 1045, 1046,
+	795, 1045, 1046, 1045, 795, 1046, 795, 1046,
+	795, 1045, 1046, 1045, 795, 795, 1046, 1045,
+	1046, 795, 1046, 795, 1046, 1045, 795, 1046,
+	795, 1045, 1046, 1045, 795, 795, 1046, 795,
+	1045, 1046, 1045, 795, 795, 1046, 1045, 1046,
+	795, 1046, 1045, 1046, 795, 1046, 1045, 1046,
+	795, 1046, 795, 1046, 795, 1045, 1046, 1045,
+	795, 795, 1046, 1045, 1046, 795, 1046, 795,
+	1046, 1045, 795, 1046, 1045, 1046, 1046, 795,
+	1046, 795, 1046, 1045, 1045, 795, 1045, 795,
+	1046, 1046, 795, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1045, 795, 1046, 1046, 1046, 795,
+	1045, 1046, 1046, 1046, 795, 1046, 795, 1046,
+	795, 1046, 795, 1046, 795, 1046, 1045, 795,
+	795, 1046, 1045, 1046, 795, 1046, 1045, 795,
+	795, 1046, 795, 795, 795, 1046, 795, 1046,
+	795, 1046, 795, 1046, 795, 1045, 795, 1046,
+	795, 1046, 795, 1045, 1046, 1045, 795, 1046,
+	795, 1045, 1046, 795, 1046, 1046, 1046, 1045,
+	795, 1046, 795, 795, 1046, 795, 1045, 1046,
+	1046, 1045, 795, 1046, 1046, 1046, 1046, 795,
+	1046, 795, 1045, 1046, 1046, 1046, 795, 1046,
+	1045, 1046, 795, 1046, 795, 1046, 795, 1046,
+	795, 1046, 1045, 1046, 1046, 795, 1046, 1045,
+	795, 1046, 795, 1046, 795, 1045, 1046, 1046,
+	1045, 795, 1046, 795, 1045, 1046, 1045, 795,
+	1046, 1045, 795, 1046, 795, 1046, 1045, 1046,
+	1046, 1046, 1045, 795, 795, 795, 1046, 1045,
+	795, 1046, 795, 1045, 1046, 1045, 795, 1046,
+	795, 1046, 795, 1045, 1046, 1046, 1046, 1045,
+	795, 1046, 795, 1045, 1046, 1046, 1046, 1046,
+	1045, 795, 1046, 795, 1046, 1045, 795, 795,
+	1046, 795, 1046, 1045, 1046, 795, 1046, 795,
+	1045, 1046, 1046, 1045, 795, 1046, 795, 1046,
+	1045, 795, 1046, 1046, 1046, 795, 1046, 795,
+	1045, 795, 1046, 1045, 1046, 795, 795, 1046,
+	795, 1046, 795, 1045, 1046, 1046, 1046, 1046,
+	1045, 795, 1046, 795, 1046, 795, 1046, 795,
+	1046, 795, 1046, 1045, 1046, 1046, 1046, 795,
+	1046, 795, 1046, 795, 1046, 795, 1045, 1046,
+	1046, 795, 795, 1046, 1045, 1046, 795, 1046,
+	1046, 1045, 795, 1046, 795, 1046, 1045, 795,
+	795, 1046, 1046, 1046, 1046, 795, 1046, 795,
+	1046, 795, 1045, 1046, 1046, 795, 1045, 1046,
+	1045, 795, 1046, 795, 1045, 1046, 1045, 795,
+	1046, 795, 1045, 1046, 795, 1046, 1046, 1045,
+	795, 1046, 1046, 795, 1045, 1046, 1045, 795,
+	1046, 795, 1046, 1045, 1046, 795, 1046, 795,
+	1045, 1046, 1045, 795, 1046, 795, 1046, 795,
+	1046, 795, 1046, 795, 1046, 1045, 1047, 1045,
+	1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055,
+	1056, 1057, 1058, 1050, 1059, 1060, 1061, 1062,
+	1063, 1050, 1064, 1065, 1066, 1067, 1068, 1069,
+	1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077,
+	1078, 1050, 1079, 1047, 1059, 1047, 1080, 1047,
+	1045, 1046, 1046, 1046, 1046, 795, 1045, 1046,
+	1046, 1045, 795, 1046, 1045, 795, 795, 1046,
+	1045, 795, 1046, 795, 1045, 1046, 1045, 795,
+	795, 1046, 795, 1045, 1046, 1046, 1045, 795,
+	1046, 1046, 1046, 1045, 795, 1046, 795, 1046,
+	1046, 1045, 795, 795, 1046, 795, 1045, 1046,
+	1045, 795, 1046, 1045, 795, 795, 1046, 795,
+	1046, 1045, 795, 1046, 795, 795, 1046, 795,
+	1046, 795, 1045, 1046, 1046, 1045, 795, 1046,
+	1046, 795, 1046, 1045, 795, 1046, 795, 1046,
+	1045, 795, 1046, 795, 1045, 795, 1046, 1046,
+	1046, 795, 1046, 1045, 1046, 795, 1046, 1045,
+	795, 1046, 1045, 1046, 795, 1046, 1045, 795,
+	1046, 1045, 795, 1046, 795, 1046, 1045, 795,
+	1046, 1045, 795, 1046, 1045, 1081, 1082, 1083,
+	1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091,
+	1092, 1052, 1093, 1094, 1095, 1096, 1097, 1094,
+	1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105,
+	1106, 1047, 1045, 1046, 795, 1046, 1045, 1046,
+	795, 1046, 1045, 1046, 795, 1046, 1045, 1046,
+	795, 1046, 1045, 795, 1046, 795, 1046, 1045,
+	1046, 795, 1046, 1045, 1046, 795, 795, 795,
+	1046, 1045, 1046, 795, 1046, 1045, 1046, 1046,
+	1046, 1046, 795, 1046, 795, 1045, 1046, 1045,
+	795, 795, 1046, 795, 1046, 1045, 1046, 795,
+	1046, 1045, 795, 1046, 1045, 1046, 1046, 795,
+	1046, 1045, 795, 1046, 1045, 1046, 795, 1046,
+	1045, 795, 1046, 1045, 795, 1046, 1045, 795,
+	1046, 1045, 1046, 1045, 795, 795, 1046, 1045,
+	1046, 795, 1046, 1045, 795, 1046, 795, 1045,
+	1046, 1045, 795, 1050, 1107, 1047, 1050, 1108,
+	1050, 1109, 1059, 1047, 1045, 1046, 1045, 795,
+	1046, 1045, 795, 1050, 1108, 1059, 1047, 1045,
+	1050, 1110, 1047, 1059, 1047, 1045, 1046, 1045,
+	795, 1050, 1111, 1068, 1112, 1094, 1113, 1106,
+	1050, 1114, 1115, 1116, 1047, 1059, 1047, 1045,
+	1046, 1045, 795, 1046, 795, 1046, 1045, 795,
+	1046, 795, 1046, 795, 1045, 1046, 1046, 1045,
+	795, 1046, 795, 1046, 1045, 795, 1046, 1045,
+	1050, 1059, 801, 1045, 1117, 1050, 1118, 1059,
+	1047, 1045, 801, 1046, 1045, 795, 1046, 1045,
+	795, 1119, 1050, 1120, 1121, 1047, 1045, 795,
+	1046, 1045, 1046, 1046, 1045, 795, 795, 1046,
+	795, 1046, 1045, 1050, 1122, 1123, 1124, 1125,
+	1126, 1127, 1128, 1129, 1130, 1131, 1132, 1047,
+	1059, 1047, 1045, 1046, 795, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 795, 1046, 795, 1046,
+	1046, 1046, 1046, 1046, 1046, 1045, 795, 1046,
+	1046, 795, 1046, 795, 1045, 1046, 795, 1046,
+	1046, 1046, 795, 1046, 1046, 795, 1046, 1046,
+	795, 1046, 1046, 795, 1046, 1046, 1045, 795,
+	1050, 1133, 1050, 1109, 1134, 1135, 1136, 1047,
+	1059, 1047, 1045, 1046, 1045, 795, 1046, 1046,
+	1046, 795, 1046, 1046, 1046, 795, 1046, 795,
+	1046, 1045, 795, 795, 795, 795, 1046, 1046,
+	795, 795, 795, 795, 795, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 795, 1046, 795, 1046,
+	795, 1045, 1046, 1046, 1046, 795, 1046, 795,
+	1046, 1045, 1059, 801, 1137, 1050, 1059, 801,
+	1046, 1045, 795, 1138, 1050, 1139, 1059, 801,
+	1046, 1045, 795, 1046, 795, 1140, 1059, 1047,
+	1045, 801, 1046, 1045, 795, 1050, 1141, 1047,
+	1059, 1047, 1045, 1046, 1045, 795, 1142, 1143,
+	1144, 1142, 1145, 1146, 1147, 1149, 1150, 1151,
+	1152, 1153, 1154, 670, 670, 419, 1155, 1156,
+	1157, 1158, 670, 1161, 1162, 1164, 1165, 1166,
+	1160, 1167, 1168, 1169, 1170, 1171, 1172, 1173,
+	1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181,
+	1182, 1183, 1184, 1185, 1186, 1188, 1189, 1190,
+	1191, 1192, 1193, 670, 1148, 7, 1148, 419,
+	1148, 419, 1160, 1163, 1187, 1194, 1159, 1142,
+	1142, 1195, 1143, 1196, 1198, 1197, 4, 1147,
+	1200, 1197, 1201, 1197, 2, 1147, 1197, 6,
+	8, 8, 7, 1202, 1203, 1204, 1197, 1205,
+	1206, 1197, 1207, 1197, 419, 419, 1209, 1210,
+	489, 470, 1211, 470, 1212, 1213, 1214, 1215,
+	1216, 1217, 1218, 1219, 1220, 1221, 1222, 544,
+	1223, 520, 1224, 1225, 1226, 1227, 1228, 1229,
+	1230, 1231, 1232, 1233, 1234, 1235, 419, 419,
+	419, 425, 565, 1208, 1236, 1197, 1237, 1197,
+	670, 1238, 419, 419, 419, 670, 1238, 670,
+	670, 419, 1238, 419, 1238, 419, 1238, 419,
+	670, 670, 670, 670, 670, 1238, 419, 670,
+	670, 670, 419, 670, 419, 1238, 419, 670,
+	670, 670, 670, 419, 1238, 670, 419, 670,
+	419, 670, 419, 670, 670, 419, 670, 1238,
+	419, 670, 419, 670, 419, 670, 1238, 670,
+	419, 1238, 670, 419, 670, 419, 1238, 670,
+	670, 670, 670, 670, 1238, 419, 419, 670,
+	419, 670, 1238, 670, 419, 1238, 670, 670,
+	1238, 419, 419, 670, 419, 670, 419, 670,
+	1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245,
+	1246, 1247, 1248, 1249, 715, 1250, 1251, 1252,
+	1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260,
+	1261, 1260, 1262, 1263, 1264, 1265, 1266, 671,
+	1238, 1267, 1268, 1269, 1270, 1271, 1272, 1273,
+	1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281,
+	1282, 1283, 1284, 1285, 725, 1286, 1287, 1288,
+	692, 1289, 1290, 1291, 1292, 1293, 1294, 671,
+	1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302,
+	674, 1303, 671, 674, 1304, 1305, 1306, 1307,
+	683, 1238, 1308, 1309, 1310, 1311, 703, 1312,
+	1313, 683, 1314, 1315, 1316, 1317, 1318, 671,
+	1238, 1319, 1278, 1320, 1321, 1322, 683, 1323,
+	1324, 674, 671, 683, 425, 1238, 1288, 671,
+	674, 683, 425, 683, 425, 1325, 683, 1238,
+	425, 674, 1326, 1327, 674, 1328, 1329, 681,
+	1330, 1331, 1332, 1333, 1334, 1284, 1335, 1336,
+	1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344,
+	1345, 1346, 1303, 1347, 674, 683, 425, 1238,
+	1348, 1349, 683, 671, 1238, 425, 671, 1238,
+	674, 1350, 731, 1351, 1352, 1353, 1354, 1355,
+	1356, 1357, 1358, 671, 1359, 1360, 1361, 1362,
+	1363, 1364, 671, 683, 1238, 1366, 1367, 1368,
+	1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376,
+	1372, 1378, 1379, 1380, 1381, 1365, 1377, 1365,
+	1238, 1365, 1238, 1382, 1382, 1383, 1384, 1385,
+	1386, 1387, 1388, 1389, 1390, 1387, 767, 1391,
+	1391, 1391, 1392, 1391, 1391, 768, 769, 770,
+	1391, 767, 1382, 1382, 1393, 1396, 1397, 1395,
+	1398, 1399, 1398, 1400, 1391, 1402, 1401, 1396,
+	1403, 1395, 1405, 1404, 1394, 1394, 1394, 768,
+	769, 770, 1394, 767, 767, 1406, 773, 1406,
+	1407, 1406, 775, 1408, 1409, 1410, 1411, 1412,
+	1413, 1414, 1411, 776, 775, 1408, 1415, 1415,
+	777, 779, 1416, 1415, 776, 1418, 1419, 1417,
+	1418, 1419, 1420, 1417, 775, 1408, 1421, 1415,
+	775, 1408, 1415, 1423, 1422, 1425, 1424, 776,
+	1426, 777, 1426, 779, 1426, 785, 1427, 1428,
+	1429, 1430, 1431, 1432, 1433, 1430, 786, 785,
+	1427, 1434, 1434, 787, 789, 1435, 1434, 786,
+	1437, 1438, 1436, 1437, 1438, 1439, 1436, 785,
+	1427, 1440, 1434, 785, 1427, 1434, 1442, 1441,
+	1444, 1443, 786, 1445, 787, 1445, 789, 1445,
+	795, 1448, 1449, 1451, 1452, 1453, 1447, 1454,
+	1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462,
+	1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470,
+	1471, 1472, 1473, 1475, 1476, 1477, 1478, 1479,
+	1480, 795, 795, 1446, 1447, 1450, 1474, 1481,
+	1446, 1046, 795, 795, 1483, 1484, 865, 846,
+	1485, 846, 1486, 1487, 1488, 1489, 1490, 1491,
+	1492, 1493, 1494, 1495, 1496, 920, 1497, 896,
+	1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505,
+	1506, 1507, 1508, 1509, 795, 795, 795, 801,
+	941, 1482, 1046, 1510, 795, 795, 795, 1046,
+	1510, 1046, 1046, 795, 1510, 795, 1510, 795,
+	1510, 795, 1046, 1046, 1046, 1046, 1046, 1510,
+	795, 1046, 1046, 1046, 795, 1046, 795, 1510,
+	795, 1046, 1046, 1046, 1046, 795, 1510, 1046,
+	795, 1046, 795, 1046, 795, 1046, 1046, 795,
+	1046, 1510, 795, 1046, 795, 1046, 795, 1046,
+	1510, 1046, 795, 1510, 1046, 795, 1046, 795,
+	1510, 1046, 1046, 1046, 1046, 1046, 1510, 795,
+	795, 1046, 795, 1046, 1510, 1046, 795, 1510,
+	1046, 1046, 1510, 795, 795, 1046, 795, 1046,
+	795, 1046, 1510, 1511, 1512, 1513, 1514, 1515,
+	1516, 1517, 1518, 1519, 1520, 1521, 1091, 1522,
+	1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530,
+	1531, 1532, 1533, 1532, 1534, 1535, 1536, 1537,
+	1538, 1047, 1510, 1539, 1540, 1541, 1542, 1543,
+	1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551,
+	1552, 1553, 1554, 1555, 1556, 1557, 1101, 1558,
+	1559, 1560, 1068, 1561, 1562, 1563, 1564, 1565,
+	1566, 1047, 1567, 1568, 1569, 1570, 1571, 1572,
+	1573, 1574, 1050, 1575, 1047, 1050, 1576, 1577,
+	1578, 1579, 1059, 1510, 1580, 1581, 1582, 1583,
+	1079, 1584, 1585, 1059, 1586, 1587, 1588, 1589,
+	1590, 1047, 1510, 1591, 1550, 1592, 1593, 1594,
+	1059, 1595, 1596, 1050, 1047, 1059, 801, 1510,
+	1560, 1047, 1050, 1059, 801, 1059, 801, 1597,
+	1059, 1510, 801, 1050, 1598, 1599, 1050, 1600,
+	1601, 1057, 1602, 1603, 1604, 1605, 1606, 1556,
+	1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614,
+	1615, 1616, 1617, 1618, 1575, 1619, 1050, 1059,
+	801, 1510, 1620, 1621, 1059, 1047, 1510, 801,
+	1047, 1510, 1050, 1622, 1107, 1623, 1624, 1625,
+	1626, 1627, 1628, 1629, 1630, 1047, 1631, 1632,
+	1633, 1634, 1635, 1636, 1047, 1059, 1510, 1638,
+	1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646,
+	1647, 1648, 1644, 1650, 1651, 1652, 1653, 1637,
+	1649, 1637, 1510, 1637, 1510,
+}
+
+var _hcltok_trans_targs []int16 = []int16{
+	1459, 1459, 2, 3, 1459, 1459, 4, 1467,
+	5, 6, 8, 9, 286, 12, 13, 14,
+	15, 16, 287, 288, 19, 289, 21, 22,
+	290, 291, 292, 293, 294, 295, 296, 297,
+	298, 299, 328, 348, 353, 127, 128, 129,
+	356, 151, 371, 375, 1459, 10, 11, 17,
+	18, 20, 23, 24, 25, 26, 27, 28,
+	29, 30, 31, 32, 64, 105, 120, 131,
+	154, 170, 283, 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, 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, 106, 107, 108, 109, 110, 111,
+	112, 113, 114, 115, 116, 117, 118, 119,
+	121, 122, 123, 124, 125, 126, 130, 132,
+	133, 134, 135, 136, 137, 138, 139, 140,
+	141, 142, 143, 144, 145, 146, 147, 148,
+	149, 150, 152, 153, 155, 156, 157, 158,
+	159, 160, 161, 162, 163, 164, 165, 166,
+	167, 168, 169, 171, 203, 227, 230, 231,
+	233, 242, 243, 246, 250, 268, 275, 277,
+	279, 281, 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, 204, 205, 206, 207, 208, 209, 210,
+	211, 212, 213, 214, 215, 216, 217, 218,
+	219, 220, 221, 222, 223, 224, 225, 226,
+	228, 229, 232, 234, 235, 236, 237, 238,
+	239, 240, 241, 244, 245, 247, 248, 249,
+	251, 252, 253, 254, 255, 256, 257, 258,
+	259, 260, 261, 262, 263, 264, 265, 266,
+	267, 269, 270, 271, 272, 273, 274, 276,
+	278, 280, 282, 284, 285, 300, 301, 302,
+	303, 304, 305, 306, 307, 308, 309, 310,
+	311, 312, 313, 314, 315, 316, 317, 318,
+	319, 320, 321, 322, 323, 324, 325, 326,
+	327, 329, 330, 331, 332, 333, 334, 335,
+	336, 337, 338, 339, 340, 341, 342, 343,
+	344, 345, 346, 347, 349, 350, 351, 352,
+	354, 355, 357, 358, 359, 360, 361, 362,
+	363, 364, 365, 366, 367, 368, 369, 370,
+	372, 373, 374, 376, 382, 404, 409, 411,
+	413, 377, 378, 379, 380, 381, 383, 384,
+	385, 386, 387, 388, 389, 390, 391, 392,
+	393, 394, 395, 396, 397, 398, 399, 400,
+	401, 402, 403, 405, 406, 407, 408, 410,
+	412, 414, 1459, 1471, 1459, 437, 438, 439,
+	440, 417, 441, 442, 443, 444, 445, 446,
+	447, 448, 449, 450, 451, 452, 453, 454,
+	455, 456, 457, 458, 459, 460, 461, 462,
+	463, 464, 465, 466, 467, 469, 470, 471,
+	472, 473, 474, 475, 476, 477, 478, 479,
+	480, 481, 482, 483, 484, 485, 419, 486,
+	487, 488, 489, 490, 491, 492, 493, 494,
+	495, 496, 497, 498, 499, 500, 501, 502,
+	503, 418, 504, 505, 506, 507, 508, 510,
+	511, 512, 513, 514, 515, 516, 517, 518,
+	519, 520, 521, 522, 523, 525, 526, 527,
+	528, 529, 530, 534, 536, 537, 538, 539,
+	434, 540, 541, 542, 543, 544, 545, 546,
+	547, 548, 549, 550, 551, 552, 553, 554,
+	556, 557, 559, 560, 561, 562, 563, 564,
+	432, 565, 566, 567, 568, 569, 570, 571,
+	572, 573, 575, 607, 631, 634, 635, 637,
+	646, 647, 650, 654, 672, 532, 679, 681,
+	683, 685, 576, 577, 578, 579, 580, 581,
+	582, 583, 584, 585, 586, 587, 588, 589,
+	590, 591, 592, 593, 594, 595, 596, 597,
+	598, 599, 600, 601, 602, 603, 604, 605,
+	606, 608, 609, 610, 611, 612, 613, 614,
+	615, 616, 617, 618, 619, 620, 621, 622,
+	623, 624, 625, 626, 627, 628, 629, 630,
+	632, 633, 636, 638, 639, 640, 641, 642,
+	643, 644, 645, 648, 649, 651, 652, 653,
+	655, 656, 657, 658, 659, 660, 661, 662,
+	663, 664, 665, 666, 667, 668, 669, 670,
+	671, 673, 674, 675, 676, 677, 678, 680,
+	682, 684, 686, 688, 689, 1459, 1459, 690,
+	827, 828, 759, 829, 830, 831, 832, 833,
+	834, 788, 835, 724, 836, 837, 838, 839,
+	840, 841, 842, 843, 744, 844, 845, 846,
+	847, 848, 849, 850, 851, 852, 853, 769,
+	854, 856, 857, 858, 859, 860, 861, 862,
+	863, 864, 865, 702, 866, 867, 868, 869,
+	870, 871, 872, 873, 874, 740, 875, 876,
+	877, 878, 879, 810, 881, 882, 885, 887,
+	888, 889, 890, 891, 892, 895, 896, 898,
+	899, 900, 902, 903, 904, 905, 906, 907,
+	908, 909, 910, 911, 912, 914, 915, 916,
+	917, 920, 922, 923, 925, 927, 1509, 1510,
+	929, 930, 931, 1509, 1509, 932, 1523, 1523,
+	1524, 935, 1523, 936, 1525, 1526, 1529, 1530,
+	1534, 1534, 1535, 941, 1534, 942, 1536, 1537,
+	1540, 1541, 1545, 1546, 1545, 968, 969, 970,
+	971, 948, 972, 973, 974, 975, 976, 977,
+	978, 979, 980, 981, 982, 983, 984, 985,
+	986, 987, 988, 989, 990, 991, 992, 993,
+	994, 995, 996, 997, 998, 1000, 1001, 1002,
+	1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010,
+	1011, 1012, 1013, 1014, 1015, 1016, 950, 1017,
+	1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025,
+	1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033,
+	1034, 949, 1035, 1036, 1037, 1038, 1039, 1041,
+	1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049,
+	1050, 1051, 1052, 1053, 1054, 1056, 1057, 1058,
+	1059, 1060, 1061, 1065, 1067, 1068, 1069, 1070,
+	965, 1071, 1072, 1073, 1074, 1075, 1076, 1077,
+	1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085,
+	1087, 1088, 1090, 1091, 1092, 1093, 1094, 1095,
+	963, 1096, 1097, 1098, 1099, 1100, 1101, 1102,
+	1103, 1104, 1106, 1138, 1162, 1165, 1166, 1168,
+	1177, 1178, 1181, 1185, 1203, 1063, 1210, 1212,
+	1214, 1216, 1107, 1108, 1109, 1110, 1111, 1112,
+	1113, 1114, 1115, 1116, 1117, 1118, 1119, 1120,
+	1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128,
+	1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136,
+	1137, 1139, 1140, 1141, 1142, 1143, 1144, 1145,
+	1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153,
+	1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161,
+	1163, 1164, 1167, 1169, 1170, 1171, 1172, 1173,
+	1174, 1175, 1176, 1179, 1180, 1182, 1183, 1184,
+	1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193,
+	1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201,
+	1202, 1204, 1205, 1206, 1207, 1208, 1209, 1211,
+	1213, 1215, 1217, 1219, 1220, 1545, 1545, 1221,
+	1358, 1359, 1290, 1360, 1361, 1362, 1363, 1364,
+	1365, 1319, 1366, 1255, 1367, 1368, 1369, 1370,
+	1371, 1372, 1373, 1374, 1275, 1375, 1376, 1377,
+	1378, 1379, 1380, 1381, 1382, 1383, 1384, 1300,
+	1385, 1387, 1388, 1389, 1390, 1391, 1392, 1393,
+	1394, 1395, 1396, 1233, 1397, 1398, 1399, 1400,
+	1401, 1402, 1403, 1404, 1405, 1271, 1406, 1407,
+	1408, 1409, 1410, 1341, 1412, 1413, 1416, 1418,
+	1419, 1420, 1421, 1422, 1423, 1426, 1427, 1429,
+	1430, 1431, 1433, 1434, 1435, 1436, 1437, 1438,
+	1439, 1440, 1441, 1442, 1443, 1445, 1446, 1447,
+	1448, 1451, 1453, 1454, 1456, 1458, 1460, 1459,
+	1461, 1462, 1459, 1463, 1459, 1464, 1465, 1466,
+	1468, 1469, 1470, 1459, 1472, 1459, 1473, 1459,
+	1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481,
+	1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489,
+	1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497,
+	1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505,
+	1506, 1507, 1508, 1459, 1459, 1459, 1459, 1459,
+	1459, 1, 1459, 7, 1459, 1459, 1459, 1459,
+	1459, 415, 416, 420, 421, 422, 423, 424,
+	425, 426, 427, 428, 429, 430, 431, 433,
+	435, 436, 468, 509, 524, 531, 533, 535,
+	555, 558, 574, 687, 1459, 1459, 1459, 691,
+	692, 693, 694, 695, 696, 697, 698, 699,
+	700, 701, 703, 704, 705, 706, 707, 708,
+	709, 710, 711, 712, 713, 714, 715, 716,
+	717, 718, 719, 720, 721, 722, 723, 725,
+	726, 727, 728, 729, 730, 731, 732, 733,
+	734, 735, 736, 737, 738, 739, 741, 742,
+	743, 745, 746, 747, 748, 749, 750, 751,
+	752, 753, 754, 755, 756, 757, 758, 760,
+	761, 762, 763, 764, 765, 766, 767, 768,
+	770, 771, 772, 773, 774, 775, 776, 777,
+	778, 779, 780, 781, 782, 783, 784, 785,
+	786, 787, 789, 790, 791, 792, 793, 794,
+	795, 796, 797, 798, 799, 800, 801, 802,
+	803, 804, 805, 806, 807, 808, 809, 811,
+	812, 813, 814, 815, 816, 817, 818, 819,
+	820, 821, 822, 823, 824, 825, 826, 855,
+	880, 883, 884, 886, 893, 894, 897, 901,
+	913, 918, 919, 921, 924, 926, 1511, 1509,
+	1512, 1517, 1519, 1509, 1520, 1521, 1522, 1509,
+	928, 1509, 1509, 1513, 1514, 1516, 1509, 1515,
+	1509, 1509, 1509, 1518, 1509, 1509, 1509, 933,
+	934, 938, 939, 1523, 1531, 1532, 1533, 1523,
+	937, 1523, 1523, 934, 1527, 1528, 1523, 1523,
+	1523, 1523, 1523, 940, 944, 945, 1534, 1542,
+	1543, 1544, 1534, 943, 1534, 1534, 940, 1538,
+	1539, 1534, 1534, 1534, 1534, 1534, 1545, 1547,
+	1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555,
+	1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563,
+	1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571,
+	1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579,
+	1580, 1581, 1545, 946, 947, 951, 952, 953,
+	954, 955, 956, 957, 958, 959, 960, 961,
+	962, 964, 966, 967, 999, 1040, 1055, 1062,
+	1064, 1066, 1086, 1089, 1105, 1218, 1545, 1222,
+	1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230,
+	1231, 1232, 1234, 1235, 1236, 1237, 1238, 1239,
+	1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247,
+	1248, 1249, 1250, 1251, 1252, 1253, 1254, 1256,
+	1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264,
+	1265, 1266, 1267, 1268, 1269, 1270, 1272, 1273,
+	1274, 1276, 1277, 1278, 1279, 1280, 1281, 1282,
+	1283, 1284, 1285, 1286, 1287, 1288, 1289, 1291,
+	1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299,
+	1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308,
+	1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316,
+	1317, 1318, 1320, 1321, 1322, 1323, 1324, 1325,
+	1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333,
+	1334, 1335, 1336, 1337, 1338, 1339, 1340, 1342,
+	1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350,
+	1351, 1352, 1353, 1354, 1355, 1356, 1357, 1386,
+	1411, 1414, 1415, 1417, 1424, 1425, 1428, 1432,
+	1444, 1449, 1450, 1452, 1455, 1457,
+}
+
+var _hcltok_trans_actions []byte = []byte{
+	145, 107, 0, 0, 91, 141, 0, 7,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 121, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 143, 193, 149, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 147, 125, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 31, 169,
+	0, 0, 0, 35, 33, 0, 55, 41,
+	175, 0, 53, 0, 175, 175, 0, 0,
+	75, 61, 181, 0, 73, 0, 181, 181,
+	0, 0, 85, 187, 89, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 87, 79, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 93,
+	0, 0, 119, 0, 111, 0, 7, 7,
+	7, 0, 0, 113, 0, 115, 0, 123,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 7, 7,
+	7, 196, 196, 196, 196, 196, 196, 7,
+	7, 196, 7, 127, 139, 135, 97, 133,
+	103, 0, 129, 0, 101, 95, 109, 99,
+	131, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 105, 117, 137, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 13,
+	0, 0, 172, 17, 0, 7, 7, 23,
+	0, 25, 27, 0, 0, 0, 151, 0,
+	15, 19, 9, 0, 21, 11, 29, 0,
+	0, 0, 0, 43, 0, 178, 178, 49,
+	0, 157, 154, 1, 175, 175, 45, 37,
+	47, 39, 51, 0, 0, 0, 63, 0,
+	184, 184, 69, 0, 163, 160, 1, 181,
+	181, 65, 57, 67, 59, 71, 77, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 7, 7, 7,
+	190, 190, 190, 190, 190, 190, 7, 7,
+	190, 7, 81, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 83, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0,
+}
+
+var _hcltok_to_state_actions []byte = []byte{
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 3, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 3, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 166, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 166, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 3, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0,
+}
+
+var _hcltok_from_state_actions []byte = []byte{
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 5, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 5, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 5, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 5, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 5, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0,
+}
+
+var _hcltok_eof_trans []int16 = []int16{
+	0, 1, 1, 1, 6, 6, 6, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 419,
+	419, 421, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	767, 772, 772, 772, 773, 773, 775, 775,
+	775, 779, 0, 0, 785, 785, 785, 789,
+	0, 0, 795, 795, 797, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 0, 1196, 1197, 1198, 1200,
+	1198, 1198, 1198, 1203, 1198, 1198, 1198, 1209,
+	1198, 1198, 1239, 1239, 1239, 1239, 1239, 1239,
+	1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239,
+	1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239,
+	1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239,
+	1239, 1239, 1239, 1239, 1239, 0, 1392, 1394,
+	1395, 1399, 1399, 1392, 1402, 1395, 1405, 1395,
+	1407, 1407, 1407, 0, 1416, 1418, 1418, 1416,
+	1416, 1423, 1425, 1427, 1427, 1427, 0, 1435,
+	1437, 1437, 1435, 1435, 1442, 1444, 1446, 1446,
+	1446, 0, 1483, 1511, 1511, 1511, 1511, 1511,
+	1511, 1511, 1511, 1511, 1511, 1511, 1511, 1511,
+	1511, 1511, 1511, 1511, 1511, 1511, 1511, 1511,
+	1511, 1511, 1511, 1511, 1511, 1511, 1511, 1511,
+	1511, 1511, 1511, 1511, 1511, 1511,
+}
+
+const hcltok_start int = 1459
+const hcltok_first_final int = 1459
+const hcltok_error int = 0
+
+const hcltok_en_stringTemplate int = 1509
+const hcltok_en_heredocTemplate int = 1523
+const hcltok_en_bareTemplate int = 1534
+const hcltok_en_identOnly int = 1545
+const hcltok_en_main int = 1459
+
+//line scan_tokens.rl:16
+
+func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []Token {
+	stripData := stripUTF8BOM(data)
+	start.Byte += len(data) - len(stripData)
+	data = stripData
+
+	f := &tokenAccum{
+		Filename:  filename,
+		Bytes:     data,
+		Pos:       start,
+		StartByte: start.Byte,
+	}
+
+//line scan_tokens.rl:305
+
+	// Ragel state
+	p := 0          // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+	ts := 0
+	te := 0
+	act := 0
+	eof := pe
+	var stack []int
+	var top int
+
+	var cs int // current state
+	switch mode {
+	case scanNormal:
+		cs = hcltok_en_main
+	case scanTemplate:
+		cs = hcltok_en_bareTemplate
+	case scanIdentOnly:
+		cs = hcltok_en_identOnly
+	default:
+		panic("invalid scanMode")
+	}
+
+	braces := 0
+	var retBraces []int              // stack of brace levels that cause us to use fret
+	var heredocs []heredocInProgress // stack of heredocs we're currently processing
+
+//line scan_tokens.rl:340
+
+	// Make Go compiler happy
+	_ = ts
+	_ = te
+	_ = act
+	_ = eof
+
+	token := func(ty TokenType) {
+		f.emitToken(ty, ts, te)
+	}
+	selfToken := func() {
+		b := data[ts:te]
+		if len(b) != 1 {
+			// should never happen
+			panic("selfToken only works for single-character tokens")
+		}
+		f.emitToken(TokenType(b[0]), ts, te)
+	}
+
+//line scan_tokens.go:4289
+	{
+		top = 0
+		ts = 0
+		te = 0
+		act = 0
+	}
+
+//line scan_tokens.go:4297
+	{
+		var _klen int
+		var _trans int
+		var _acts int
+		var _nacts uint
+		var _keys int
+		if p == pe {
+			goto _test_eof
+		}
+		if cs == 0 {
+			goto _out
+		}
+	_resume:
+		_acts = int(_hcltok_from_state_actions[cs])
+		_nacts = uint(_hcltok_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _hcltok_actions[_acts-1] {
+			case 3:
+//line NONE:1
+				ts = p
+
+//line scan_tokens.go:4320
+			}
+		}
+
+		_keys = int(_hcltok_key_offsets[cs])
+		_trans = int(_hcltok_index_offsets[cs])
+
+		_klen = int(_hcltok_single_lengths[cs])
+		if _klen > 0 {
+			_lower := int(_keys)
+			var _mid int
+			_upper := int(_keys + _klen - 1)
+			for {
+				if _upper < _lower {
+					break
+				}
+
+				_mid = _lower + ((_upper - _lower) >> 1)
+				switch {
+				case data[p] < _hcltok_trans_keys[_mid]:
+					_upper = _mid - 1
+				case data[p] > _hcltok_trans_keys[_mid]:
+					_lower = _mid + 1
+				default:
+					_trans += int(_mid - int(_keys))
+					goto _match
+				}
+			}
+			_keys += _klen
+			_trans += _klen
+		}
+
+		_klen = int(_hcltok_range_lengths[cs])
+		if _klen > 0 {
+			_lower := int(_keys)
+			var _mid int
+			_upper := int(_keys + (_klen << 1) - 2)
+			for {
+				if _upper < _lower {
+					break
+				}
+
+				_mid = _lower + (((_upper - _lower) >> 1) & ^1)
+				switch {
+				case data[p] < _hcltok_trans_keys[_mid]:
+					_upper = _mid - 2
+				case data[p] > _hcltok_trans_keys[_mid+1]:
+					_lower = _mid + 2
+				default:
+					_trans += int((_mid - int(_keys)) >> 1)
+					goto _match
+				}
+			}
+			_trans += _klen
+		}
+
+	_match:
+		_trans = int(_hcltok_indicies[_trans])
+	_eof_trans:
+		cs = int(_hcltok_trans_targs[_trans])
+
+		if _hcltok_trans_actions[_trans] == 0 {
+			goto _again
+		}
+
+		_acts = int(_hcltok_trans_actions[_trans])
+		_nacts = uint(_hcltok_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _hcltok_actions[_acts-1] {
+			case 0:
+//line scan_tokens.rl:224
+				p--
+
+			case 4:
+//line NONE:1
+				te = p + 1
+
+			case 5:
+//line scan_tokens.rl:248
+				act = 4
+			case 6:
+//line scan_tokens.rl:250
+				act = 6
+			case 7:
+//line scan_tokens.rl:160
+				te = p + 1
+				{
+					token(TokenTemplateInterp)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 8:
+//line scan_tokens.rl:170
+				te = p + 1
+				{
+					token(TokenTemplateControl)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 9:
+//line scan_tokens.rl:84
+				te = p + 1
+				{
+					token(TokenCQuote)
+					top--
+					cs = stack[top]
+					{
+						stack = stack[:len(stack)-1]
+					}
+					goto _again
+
+				}
+			case 10:
+//line scan_tokens.rl:248
+				te = p + 1
+				{
+					token(TokenQuotedLit)
+				}
+			case 11:
+//line scan_tokens.rl:251
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 12:
+//line scan_tokens.rl:160
+				te = p
+				p--
+				{
+					token(TokenTemplateInterp)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 13:
+//line scan_tokens.rl:170
+				te = p
+				p--
+				{
+					token(TokenTemplateControl)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 14:
+//line scan_tokens.rl:248
+				te = p
+				p--
+				{
+					token(TokenQuotedLit)
+				}
+			case 15:
+//line scan_tokens.rl:249
+				te = p
+				p--
+				{
+					token(TokenQuotedNewline)
+				}
+			case 16:
+//line scan_tokens.rl:250
+				te = p
+				p--
+				{
+					token(TokenInvalid)
+				}
+			case 17:
+//line scan_tokens.rl:251
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 18:
+//line scan_tokens.rl:248
+				p = (te) - 1
+				{
+					token(TokenQuotedLit)
+				}
+			case 19:
+//line scan_tokens.rl:251
+				p = (te) - 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 20:
+//line NONE:1
+				switch act {
+				case 4:
+					{
+						p = (te) - 1
+						token(TokenQuotedLit)
+					}
+				case 6:
+					{
+						p = (te) - 1
+						token(TokenInvalid)
+					}
+				}
+
+			case 21:
+//line scan_tokens.rl:148
+				act = 11
+			case 22:
+//line scan_tokens.rl:259
+				act = 12
+			case 23:
+//line scan_tokens.rl:160
+				te = p + 1
+				{
+					token(TokenTemplateInterp)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 24:
+//line scan_tokens.rl:170
+				te = p + 1
+				{
+					token(TokenTemplateControl)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 25:
+//line scan_tokens.rl:111
+				te = p + 1
+				{
+					// This action is called specificially when a heredoc literal
+					// ends with a newline character.
+
+					// This might actually be our end marker.
+					topdoc := &heredocs[len(heredocs)-1]
+					if topdoc.StartOfLine {
+						maybeMarker := bytes.TrimSpace(data[ts:te])
+						if bytes.Equal(maybeMarker, topdoc.Marker) {
+							// We actually emit two tokens here: the end-of-heredoc
+							// marker first, and then separately the newline that
+							// follows it. This then avoids issues with the closing
+							// marker consuming a newline that would normally be used
+							// to mark the end of an attribute definition.
+							// We might have either a \n sequence or an \r\n sequence
+							// here, so we must handle both.
+							nls := te - 1
+							nle := te
+							te--
+							if data[te-1] == '\r' {
+								// back up one more byte
+								nls--
+								te--
+							}
+							token(TokenCHeredoc)
+							ts = nls
+							te = nle
+							token(TokenNewline)
+							heredocs = heredocs[:len(heredocs)-1]
+							top--
+							cs = stack[top]
+							{
+								stack = stack[:len(stack)-1]
+							}
+							goto _again
+
+						}
+					}
+
+					topdoc.StartOfLine = true
+					token(TokenStringLit)
+				}
+			case 26:
+//line scan_tokens.rl:259
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 27:
+//line scan_tokens.rl:160
+				te = p
+				p--
+				{
+					token(TokenTemplateInterp)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 28:
+//line scan_tokens.rl:170
+				te = p
+				p--
+				{
+					token(TokenTemplateControl)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 29:
+//line scan_tokens.rl:148
+				te = p
+				p--
+				{
+					// This action is called when a heredoc literal _doesn't_ end
+					// with a newline character, e.g. because we're about to enter
+					// an interpolation sequence.
+					heredocs[len(heredocs)-1].StartOfLine = false
+					token(TokenStringLit)
+				}
+			case 30:
+//line scan_tokens.rl:259
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 31:
+//line scan_tokens.rl:148
+				p = (te) - 1
+				{
+					// This action is called when a heredoc literal _doesn't_ end
+					// with a newline character, e.g. because we're about to enter
+					// an interpolation sequence.
+					heredocs[len(heredocs)-1].StartOfLine = false
+					token(TokenStringLit)
+				}
+			case 32:
+//line NONE:1
+				switch act {
+				case 0:
+					{
+						cs = 0
+						goto _again
+					}
+				case 11:
+					{
+						p = (te) - 1
+
+						// This action is called when a heredoc literal _doesn't_ end
+						// with a newline character, e.g. because we're about to enter
+						// an interpolation sequence.
+						heredocs[len(heredocs)-1].StartOfLine = false
+						token(TokenStringLit)
+					}
+				case 12:
+					{
+						p = (te) - 1
+						token(TokenBadUTF8)
+					}
+				}
+
+			case 33:
+//line scan_tokens.rl:156
+				act = 15
+			case 34:
+//line scan_tokens.rl:266
+				act = 16
+			case 35:
+//line scan_tokens.rl:160
+				te = p + 1
+				{
+					token(TokenTemplateInterp)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 36:
+//line scan_tokens.rl:170
+				te = p + 1
+				{
+					token(TokenTemplateControl)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 37:
+//line scan_tokens.rl:156
+				te = p + 1
+				{
+					token(TokenStringLit)
+				}
+			case 38:
+//line scan_tokens.rl:266
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 39:
+//line scan_tokens.rl:160
+				te = p
+				p--
+				{
+					token(TokenTemplateInterp)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 40:
+//line scan_tokens.rl:170
+				te = p
+				p--
+				{
+					token(TokenTemplateControl)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 41:
+//line scan_tokens.rl:156
+				te = p
+				p--
+				{
+					token(TokenStringLit)
+				}
+			case 42:
+//line scan_tokens.rl:266
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 43:
+//line scan_tokens.rl:156
+				p = (te) - 1
+				{
+					token(TokenStringLit)
+				}
+			case 44:
+//line NONE:1
+				switch act {
+				case 0:
+					{
+						cs = 0
+						goto _again
+					}
+				case 15:
+					{
+						p = (te) - 1
+
+						token(TokenStringLit)
+					}
+				case 16:
+					{
+						p = (te) - 1
+						token(TokenBadUTF8)
+					}
+				}
+
+			case 45:
+//line scan_tokens.rl:270
+				act = 17
+			case 46:
+//line scan_tokens.rl:271
+				act = 18
+			case 47:
+//line scan_tokens.rl:271
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 48:
+//line scan_tokens.rl:272
+				te = p + 1
+				{
+					token(TokenInvalid)
+				}
+			case 49:
+//line scan_tokens.rl:270
+				te = p
+				p--
+				{
+					token(TokenIdent)
+				}
+			case 50:
+//line scan_tokens.rl:271
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 51:
+//line scan_tokens.rl:270
+				p = (te) - 1
+				{
+					token(TokenIdent)
+				}
+			case 52:
+//line scan_tokens.rl:271
+				p = (te) - 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 53:
+//line NONE:1
+				switch act {
+				case 17:
+					{
+						p = (te) - 1
+						token(TokenIdent)
+					}
+				case 18:
+					{
+						p = (te) - 1
+						token(TokenBadUTF8)
+					}
+				}
+
+			case 54:
+//line scan_tokens.rl:278
+				act = 22
+			case 55:
+//line scan_tokens.rl:301
+				act = 39
+			case 56:
+//line scan_tokens.rl:280
+				te = p + 1
+				{
+					token(TokenComment)
+				}
+			case 57:
+//line scan_tokens.rl:281
+				te = p + 1
+				{
+					token(TokenNewline)
+				}
+			case 58:
+//line scan_tokens.rl:283
+				te = p + 1
+				{
+					token(TokenEqualOp)
+				}
+			case 59:
+//line scan_tokens.rl:284
+				te = p + 1
+				{
+					token(TokenNotEqual)
+				}
+			case 60:
+//line scan_tokens.rl:285
+				te = p + 1
+				{
+					token(TokenGreaterThanEq)
+				}
+			case 61:
+//line scan_tokens.rl:286
+				te = p + 1
+				{
+					token(TokenLessThanEq)
+				}
+			case 62:
+//line scan_tokens.rl:287
+				te = p + 1
+				{
+					token(TokenAnd)
+				}
+			case 63:
+//line scan_tokens.rl:288
+				te = p + 1
+				{
+					token(TokenOr)
+				}
+			case 64:
+//line scan_tokens.rl:289
+				te = p + 1
+				{
+					token(TokenEllipsis)
+				}
+			case 65:
+//line scan_tokens.rl:290
+				te = p + 1
+				{
+					token(TokenFatArrow)
+				}
+			case 66:
+//line scan_tokens.rl:291
+				te = p + 1
+				{
+					selfToken()
+				}
+			case 67:
+//line scan_tokens.rl:180
+				te = p + 1
+				{
+					token(TokenOBrace)
+					braces++
+				}
+			case 68:
+//line scan_tokens.rl:185
+				te = p + 1
+				{
+					if len(retBraces) > 0 && retBraces[len(retBraces)-1] == braces {
+						token(TokenTemplateSeqEnd)
+						braces--
+						retBraces = retBraces[0 : len(retBraces)-1]
+						top--
+						cs = stack[top]
+						{
+							stack = stack[:len(stack)-1]
+						}
+						goto _again
+
+					} else {
+						token(TokenCBrace)
+						braces--
+					}
+				}
+			case 69:
+//line scan_tokens.rl:197
+				te = p + 1
+				{
+					// Only consume from the retBraces stack and return if we are at
+					// a suitable brace nesting level, otherwise things will get
+					// confused. (Not entering this branch indicates a syntax error,
+					// which we will catch in the parser.)
+					if len(retBraces) > 0 && retBraces[len(retBraces)-1] == braces {
+						token(TokenTemplateSeqEnd)
+						braces--
+						retBraces = retBraces[0 : len(retBraces)-1]
+						top--
+						cs = stack[top]
+						{
+							stack = stack[:len(stack)-1]
+						}
+						goto _again
+
+					} else {
+						// We intentionally generate a TokenTemplateSeqEnd here,
+						// even though the user apparently wanted a brace, because
+						// we want to allow the parser to catch the incorrect use
+						// of a ~} to balance a generic opening brace, rather than
+						// a template sequence.
+						token(TokenTemplateSeqEnd)
+						braces--
+					}
+				}
+			case 70:
+//line scan_tokens.rl:79
+				te = p + 1
+				{
+					token(TokenOQuote)
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1509
+						goto _again
+					}
+				}
+			case 71:
+//line scan_tokens.rl:89
+				te = p + 1
+				{
+					token(TokenOHeredoc)
+					// the token is currently the whole heredoc introducer, like
+					// <<EOT or <<-EOT, followed by a newline. We want to extract
+					// just the "EOT" portion that we'll use as the closing marker.
+
+					marker := data[ts+2 : te-1]
+					if marker[0] == '-' {
+						marker = marker[1:]
+					}
+					if marker[len(marker)-1] == '\r' {
+						marker = marker[:len(marker)-1]
+					}
+
+					heredocs = append(heredocs, heredocInProgress{
+						Marker:      marker,
+						StartOfLine: true,
+					})
+
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1523
+						goto _again
+					}
+				}
+			case 72:
+//line scan_tokens.rl:301
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 73:
+//line scan_tokens.rl:302
+				te = p + 1
+				{
+					token(TokenInvalid)
+				}
+			case 74:
+//line scan_tokens.rl:276
+				te = p
+				p--
+
+			case 75:
+//line scan_tokens.rl:277
+				te = p
+				p--
+				{
+					token(TokenNumberLit)
+				}
+			case 76:
+//line scan_tokens.rl:278
+				te = p
+				p--
+				{
+					token(TokenIdent)
+				}
+			case 77:
+//line scan_tokens.rl:280
+				te = p
+				p--
+				{
+					token(TokenComment)
+				}
+			case 78:
+//line scan_tokens.rl:291
+				te = p
+				p--
+				{
+					selfToken()
+				}
+			case 79:
+//line scan_tokens.rl:301
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 80:
+//line scan_tokens.rl:302
+				te = p
+				p--
+				{
+					token(TokenInvalid)
+				}
+			case 81:
+//line scan_tokens.rl:277
+				p = (te) - 1
+				{
+					token(TokenNumberLit)
+				}
+			case 82:
+//line scan_tokens.rl:278
+				p = (te) - 1
+				{
+					token(TokenIdent)
+				}
+			case 83:
+//line scan_tokens.rl:291
+				p = (te) - 1
+				{
+					selfToken()
+				}
+			case 84:
+//line scan_tokens.rl:301
+				p = (te) - 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 85:
+//line NONE:1
+				switch act {
+				case 22:
+					{
+						p = (te) - 1
+						token(TokenIdent)
+					}
+				case 39:
+					{
+						p = (te) - 1
+						token(TokenBadUTF8)
+					}
+				}
+
+//line scan_tokens.go:5055
+			}
+		}
+
+	_again:
+		_acts = int(_hcltok_to_state_actions[cs])
+		_nacts = uint(_hcltok_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _hcltok_actions[_acts-1] {
+			case 1:
+//line NONE:1
+				ts = 0
+
+			case 2:
+//line NONE:1
+				act = 0
+
+//line scan_tokens.go:5073
+			}
+		}
+
+		if cs == 0 {
+			goto _out
+		}
+		p++
+		if p != pe {
+			goto _resume
+		}
+	_test_eof:
+		{
+		}
+		if p == eof {
+			if _hcltok_eof_trans[cs] > 0 {
+				_trans = int(_hcltok_eof_trans[cs] - 1)
+				goto _eof_trans
+			}
+		}
+
+	_out:
+		{
+		}
+	}
+
+//line scan_tokens.rl:363
+
+	// If we fall out here without being in a final state then we've
+	// encountered something that the scanner can't match, which we'll
+	// deal with as an invalid.
+	if cs < hcltok_first_final {
+		if mode == scanTemplate && len(stack) == 0 {
+			// If we're scanning a bare template then any straggling
+			// top-level stuff is actually literal string, rather than
+			// invalid. This handles the case where the template ends
+			// with a single "$" or "%", which trips us up because we
+			// want to see another character to decide if it's a sequence
+			// or an escape.
+			f.emitToken(TokenStringLit, ts, len(data))
+		} else {
+			f.emitToken(TokenInvalid, ts, len(data))
+		}
+	}
+
+	// We always emit a synthetic EOF token at the end, since it gives the
+	// parser position information for an "unexpected EOF" diagnostic.
+	f.emitToken(TokenEOF, len(data), len(data))
+
+	return f.Tokens
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.rl b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.rl
new file mode 100644
index 00000000..942ad92b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.rl
@@ -0,0 +1,395 @@
+
+package hclsyntax
+
+import (
+    "bytes"
+
+    "github.com/hashicorp/hcl/v2"
+)
+
+// This file is generated from scan_tokens.rl. DO NOT EDIT.
+%%{
+  # (except when you are actually in scan_tokens.rl here, so edit away!)
+
+  machine hcltok;
+  write data;
+}%%
+
+func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []Token {
+    stripData := stripUTF8BOM(data)
+    start.Byte += len(data) - len(stripData)
+    data = stripData
+
+    f := &tokenAccum{
+        Filename:  filename,
+        Bytes:     data,
+        Pos:       start,
+        StartByte: start.Byte,
+    }
+
+    %%{
+        include UnicodeDerived "unicode_derived.rl";
+
+        UTF8Cont = 0x80 .. 0xBF;
+        AnyUTF8 = (
+            0x00..0x7F |
+            0xC0..0xDF . UTF8Cont |
+            0xE0..0xEF . UTF8Cont . UTF8Cont |
+            0xF0..0xF7 . UTF8Cont . UTF8Cont . UTF8Cont
+        );
+        BrokenUTF8 = any - AnyUTF8;
+
+        NumberLitContinue = (digit|'.'|('e'|'E') ('+'|'-')? digit);
+        NumberLit = digit ("" | (NumberLitContinue - '.') | (NumberLitContinue* (NumberLitContinue - '.')));
+        Ident = (ID_Start | '_') (ID_Continue | '-')*;
+
+        # Symbols that just represent themselves are handled as a single rule.
+        SelfToken = "[" | "]" | "(" | ")" | "." | "," | "*" | "/" | "%" | "+" | "-" | "=" | "<" | ">" | "!" | "?" | ":" | "\n" | "&" | "|" | "~" | "^" | ";" | "`" | "'";
+
+        EqualOp = "==";
+        NotEqual = "!=";
+        GreaterThanEqual = ">=";
+        LessThanEqual = "<=";
+        LogicalAnd = "&&";
+        LogicalOr = "||";
+
+        Ellipsis = "...";
+        FatArrow = "=>";
+
+        Newline = '\r' ? '\n';
+        EndOfLine = Newline;
+
+        BeginStringTmpl = '"';
+        BeginHeredocTmpl = '<<' ('-')? Ident Newline;
+
+        Comment = (
+            # The :>> operator in these is a "finish-guarded concatenation",
+            # which terminates the sequence on its left when it completes
+            # the sequence on its right.
+            # In the single-line comment cases this is allowing us to make
+            # the trailing EndOfLine optional while still having the overall
+            # pattern terminate. In the multi-line case it ensures that
+            # the first comment in the file ends at the first */, rather than
+            # gobbling up all of the "any*" until the _final_ */ in the file.
+            ("#" (any - EndOfLine)* :>> EndOfLine?) |
+            ("//" (any - EndOfLine)* :>> EndOfLine?) |
+            ("/*" any* :>> "*/")
+        );
+
+        # Note: hclwrite assumes that only ASCII spaces appear between tokens,
+        # and uses this assumption to recreate the spaces between tokens by
+        # looking at byte offset differences. This means it will produce
+        # incorrect results in the presence of tabs, but that's acceptable
+        # because the canonical style (which hclwrite itself can impose
+        # automatically is to never use tabs).
+        Spaces = (' ' | 0x09)+;
+
+        action beginStringTemplate {
+            token(TokenOQuote);
+            fcall stringTemplate;
+        }
+
+        action endStringTemplate {
+            token(TokenCQuote);
+            fret;
+        }
+
+        action beginHeredocTemplate {
+            token(TokenOHeredoc);
+            // the token is currently the whole heredoc introducer, like
+            // <<EOT or <<-EOT, followed by a newline. We want to extract
+            // just the "EOT" portion that we'll use as the closing marker.
+
+            marker := data[ts+2:te-1]
+            if marker[0] == '-' {
+                marker = marker[1:]
+            }
+            if marker[len(marker)-1] == '\r' {
+                marker = marker[:len(marker)-1]
+            }
+
+            heredocs = append(heredocs, heredocInProgress{
+                Marker:      marker,
+                StartOfLine: true,
+            })
+
+            fcall heredocTemplate;
+        }
+
+        action heredocLiteralEOL {
+            // This action is called specificially when a heredoc literal
+            // ends with a newline character.
+
+            // This might actually be our end marker.
+            topdoc := &heredocs[len(heredocs)-1]
+            if topdoc.StartOfLine {
+                maybeMarker := bytes.TrimSpace(data[ts:te])
+                if bytes.Equal(maybeMarker, topdoc.Marker) {
+                    // We actually emit two tokens here: the end-of-heredoc
+                    // marker first, and then separately the newline that
+                    // follows it. This then avoids issues with the closing
+                    // marker consuming a newline that would normally be used
+                    // to mark the end of an attribute definition.
+                    // We might have either a \n sequence or an \r\n sequence
+                    // here, so we must handle both.
+                    nls := te-1
+                    nle := te
+                    te--
+                    if data[te-1] == '\r' {
+                        // back up one more byte
+                        nls--
+                        te--
+                    }
+                    token(TokenCHeredoc);
+                    ts = nls
+                    te = nle
+                    token(TokenNewline);
+                    heredocs = heredocs[:len(heredocs)-1]
+                    fret;
+                }
+            }
+
+            topdoc.StartOfLine = true;
+            token(TokenStringLit);
+        }
+
+        action heredocLiteralMidline {
+            // This action is called when a heredoc literal _doesn't_ end
+            // with a newline character, e.g. because we're about to enter
+            // an interpolation sequence.
+            heredocs[len(heredocs)-1].StartOfLine = false;
+            token(TokenStringLit);
+        }
+
+        action bareTemplateLiteral {
+            token(TokenStringLit);
+        }
+
+        action beginTemplateInterp {
+            token(TokenTemplateInterp);
+            braces++;
+            retBraces = append(retBraces, braces);
+            if len(heredocs) > 0 {
+                heredocs[len(heredocs)-1].StartOfLine = false;
+            }
+            fcall main;
+        }
+
+        action beginTemplateControl {
+            token(TokenTemplateControl);
+            braces++;
+            retBraces = append(retBraces, braces);
+            if len(heredocs) > 0 {
+                heredocs[len(heredocs)-1].StartOfLine = false;
+            }
+            fcall main;
+        }
+
+        action openBrace {
+            token(TokenOBrace);
+            braces++;
+        }
+
+        action closeBrace {
+            if len(retBraces) > 0 && retBraces[len(retBraces)-1] == braces {
+                token(TokenTemplateSeqEnd);
+                braces--;
+                retBraces = retBraces[0:len(retBraces)-1]
+                fret;
+            } else {
+                token(TokenCBrace);
+                braces--;
+            }
+        }
+
+        action closeTemplateSeqEatWhitespace {
+            // Only consume from the retBraces stack and return if we are at
+            // a suitable brace nesting level, otherwise things will get
+            // confused. (Not entering this branch indicates a syntax error,
+            // which we will catch in the parser.)
+            if len(retBraces) > 0 && retBraces[len(retBraces)-1] == braces {
+                token(TokenTemplateSeqEnd);
+                braces--;
+                retBraces = retBraces[0:len(retBraces)-1]
+                fret;
+            } else {
+                // We intentionally generate a TokenTemplateSeqEnd here,
+                // even though the user apparently wanted a brace, because
+                // we want to allow the parser to catch the incorrect use
+                // of a ~} to balance a generic opening brace, rather than
+                // a template sequence.
+                token(TokenTemplateSeqEnd);
+                braces--;
+            }
+        }
+
+        TemplateInterp = "${" ("~")?;
+        TemplateControl = "%{" ("~")?;
+        EndStringTmpl = '"';
+        NewlineChars = ("\r"|"\n");
+        NewlineCharsSeq = NewlineChars+;
+        StringLiteralChars = (AnyUTF8 - NewlineChars);
+        TemplateIgnoredNonBrace = (^'{' %{ fhold; });
+        TemplateNotInterp = '$' (TemplateIgnoredNonBrace | TemplateInterp);
+        TemplateNotControl = '%' (TemplateIgnoredNonBrace | TemplateControl);
+        QuotedStringLiteralWithEsc = ('\\' StringLiteralChars) | (StringLiteralChars - ("$" | '%' | '"' | "\\"));
+        TemplateStringLiteral = (
+            (TemplateNotInterp) |
+            (TemplateNotControl) |
+            (QuotedStringLiteralWithEsc)+
+        );
+        HeredocStringLiteral = (
+            (TemplateNotInterp) |
+            (TemplateNotControl) |
+            (StringLiteralChars - ("$" | '%'))*
+        );
+        BareStringLiteral = (
+            (TemplateNotInterp) |
+            (TemplateNotControl) |
+            (StringLiteralChars - ("$" | '%'))*
+        ) Newline?;
+
+        stringTemplate := |*
+            TemplateInterp        => beginTemplateInterp;
+            TemplateControl       => beginTemplateControl;
+            EndStringTmpl         => endStringTemplate;
+            TemplateStringLiteral => { token(TokenQuotedLit); };
+            NewlineCharsSeq       => { token(TokenQuotedNewline); };
+            AnyUTF8               => { token(TokenInvalid); };
+            BrokenUTF8            => { token(TokenBadUTF8); };
+        *|;
+
+        heredocTemplate := |*
+            TemplateInterp        => beginTemplateInterp;
+            TemplateControl       => beginTemplateControl;
+            HeredocStringLiteral EndOfLine => heredocLiteralEOL;
+            HeredocStringLiteral  => heredocLiteralMidline;
+            BrokenUTF8            => { token(TokenBadUTF8); };
+        *|;
+
+        bareTemplate := |*
+            TemplateInterp        => beginTemplateInterp;
+            TemplateControl       => beginTemplateControl;
+            BareStringLiteral     => bareTemplateLiteral;
+            BrokenUTF8            => { token(TokenBadUTF8); };
+        *|;
+
+        identOnly := |*
+            Ident            => { token(TokenIdent) };
+            BrokenUTF8       => { token(TokenBadUTF8) };
+            AnyUTF8          => { token(TokenInvalid) };
+        *|;
+
+        main := |*
+            Spaces           => {};
+            NumberLit        => { token(TokenNumberLit) };
+            Ident            => { token(TokenIdent) };
+
+            Comment          => { token(TokenComment) };
+            Newline          => { token(TokenNewline) };
+
+            EqualOp          => { token(TokenEqualOp); };
+            NotEqual         => { token(TokenNotEqual); };
+            GreaterThanEqual => { token(TokenGreaterThanEq); };
+            LessThanEqual    => { token(TokenLessThanEq); };
+            LogicalAnd       => { token(TokenAnd); };
+            LogicalOr        => { token(TokenOr); };
+            Ellipsis         => { token(TokenEllipsis); };
+            FatArrow         => { token(TokenFatArrow); };
+            SelfToken        => { selfToken() };
+
+            "{"              => openBrace;
+            "}"              => closeBrace;
+
+            "~}"             => closeTemplateSeqEatWhitespace;
+
+            BeginStringTmpl  => beginStringTemplate;
+            BeginHeredocTmpl => beginHeredocTemplate;
+
+            BrokenUTF8       => { token(TokenBadUTF8) };
+            AnyUTF8          => { token(TokenInvalid) };
+        *|;
+
+    }%%
+
+    // Ragel state
+	p := 0  // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+    ts := 0
+    te := 0
+    act := 0
+    eof := pe
+    var stack []int
+    var top int
+
+    var cs int // current state
+    switch mode {
+    case scanNormal:
+        cs = hcltok_en_main
+    case scanTemplate:
+        cs = hcltok_en_bareTemplate
+    case scanIdentOnly:
+        cs = hcltok_en_identOnly
+    default:
+        panic("invalid scanMode")
+    }
+
+    braces := 0
+    var retBraces []int // stack of brace levels that cause us to use fret
+    var heredocs []heredocInProgress // stack of heredocs we're currently processing
+
+    %%{
+        prepush {
+            stack = append(stack, 0);
+        }
+        postpop {
+            stack = stack[:len(stack)-1];
+        }
+    }%%
+
+    // Make Go compiler happy
+    _ = ts
+    _ = te
+    _ = act
+    _ = eof
+
+    token := func (ty TokenType) {
+        f.emitToken(ty, ts, te)
+    }
+    selfToken := func () {
+        b := data[ts:te]
+        if len(b) != 1 {
+            // should never happen
+            panic("selfToken only works for single-character tokens")
+        }
+        f.emitToken(TokenType(b[0]), ts, te)
+    }
+
+    %%{
+        write init nocs;
+        write exec;
+    }%%
+
+    // If we fall out here without being in a final state then we've
+    // encountered something that the scanner can't match, which we'll
+    // deal with as an invalid.
+    if cs < hcltok_first_final {
+        if mode == scanTemplate && len(stack) == 0 {
+            // If we're scanning a bare template then any straggling
+            // top-level stuff is actually literal string, rather than
+            // invalid. This handles the case where the template ends
+            // with a single "$" or "%", which trips us up because we
+            // want to see another character to decide if it's a sequence
+            // or an escape.
+            f.emitToken(TokenStringLit, ts, len(data))
+        } else {
+            f.emitToken(TokenInvalid, ts, len(data))
+        }
+    }
+
+    // We always emit a synthetic EOF token at the end, since it gives the
+    // parser position information for an "unexpected EOF" diagnostic.
+    f.emitToken(TokenEOF, len(data), len(data))
+
+    return f.Tokens
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/spec.md b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/spec.md
new file mode 100644
index 00000000..550bd93a
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/spec.md
@@ -0,0 +1,941 @@
+# HCL Native Syntax Specification
+
+This is the specification of the syntax and semantics of the native syntax
+for HCL. HCL is a system for defining configuration languages for applications.
+The HCL information model is designed to support multiple concrete syntaxes
+for configuration, but this native syntax is considered the primary format
+and is optimized for human authoring and maintenance, as opposed to machine
+generation of configuration.
+
+The language consists of three integrated sub-languages:
+
+- The _structural_ language defines the overall hierarchical configuration
+  structure, and is a serialization of HCL bodies, blocks and attributes.
+
+- The _expression_ language is used to express attribute values, either as
+  literals or as derivations of other values.
+
+- The _template_ language is used to compose values together into strings,
+  as one of several types of expression in the expression language.
+
+In normal use these three sub-languages are used together within configuration
+files to describe an overall configuration, with the structural language
+being used at the top level. The expression and template languages can also
+be used in isolation, to implement features such as REPLs, debuggers, and
+integration into more limited HCL syntaxes such as the JSON profile.
+
+## Syntax Notation
+
+Within this specification a semi-formal notation is used to illustrate the
+details of syntax. This notation is intended for human consumption rather
+than machine consumption, with the following conventions:
+
+- A naked name starting with an uppercase letter is a global production,
+  common to all of the syntax specifications in this document.
+- A naked name starting with a lowercase letter is a local production,
+  meaningful only within the specification where it is defined.
+- Double and single quotes (`"` and `'`) are used to mark literal character
+  sequences, which may be either punctuation markers or keywords.
+- The default operator for combining items, which has no punctuation,
+  is concatenation.
+- The symbol `|` indicates that any one of its left and right operands may
+  be present.
+- The `*` symbol indicates zero or more repetitions of the item to its left.
+- The `?` symbol indicates zero or one of the item to its left.
+- Parentheses (`(` and `)`) are used to group items together to apply
+  the `|`, `*` and `?` operators to them collectively.
+
+The grammar notation does not fully describe the language. The prose may
+augment or conflict with the illustrated grammar. In case of conflict, prose
+has priority.
+
+## Source Code Representation
+
+Source code is unicode text expressed in the UTF-8 encoding. The language
+itself does not perform unicode normalization, so syntax features such as
+identifiers are sequences of unicode code points and so e.g. a precombined
+accented character is distinct from a letter associated with a combining
+accent. (String literals have some special handling with regard to Unicode
+normalization which will be covered later in the relevant section.)
+
+UTF-8 encoded Unicode byte order marks are not permitted. Invalid or
+non-normalized UTF-8 encoding is always a parse error.
+
+## Lexical Elements
+
+### Comments and Whitespace
+
+Comments and Whitespace are recognized as lexical elements but are ignored
+except as described below.
+
+Whitespace is defined as a sequence of zero or more space characters
+(U+0020). Newline sequences (either U+000A or U+000D followed by U+000A)
+are _not_ considered whitespace but are ignored as such in certain contexts.
+Horizontal tab characters (U+0009) are also treated as whitespace, but are
+counted only as one "column" for the purpose of reporting source positions.
+
+Comments serve as program documentation and come in two forms:
+
+- _Line comments_ start with either the `//` or `#` sequences and end with
+  the next newline sequence. A line comment is considered equivalent to a
+  newline sequence.
+
+- _Inline comments_ start with the `/*` sequence and end with the `*/`
+  sequence, and may have any characters within except the ending sequence.
+  An inline comments is considered equivalent to a whitespace sequence.
+
+Comments and whitespace cannot begin within within other comments, or within
+template literals except inside an interpolation sequence or template directive.
+
+### Identifiers
+
+Identifiers name entities such as blocks, attributes and expression variables.
+Identifiers are interpreted as per [UAX #31][uax31] Section 2. Specifically,
+their syntax is defined in terms of the `ID_Start` and `ID_Continue`
+character properties as follows:
+
+```ebnf
+Identifier = ID_Start (ID_Continue | '-')*;
+```
+
+The Unicode specification provides the normative requirements for identifier
+parsing. Non-normatively, the spirit of this specification is that `ID_Start`
+consists of Unicode letter and certain unambiguous punctuation tokens, while
+`ID_Continue` augments that set with Unicode digits, combining marks, etc.
+
+The dash character `-` is additionally allowed in identifiers, even though
+that is not part of the unicode `ID_Continue` definition. This is to allow
+attribute names and block type names to contain dashes, although underscores
+as word separators are considered the idiomatic usage.
+
+[uax31]: http://unicode.org/reports/tr31/ "Unicode Identifier and Pattern Syntax"
+
+### Keywords
+
+There are no globally-reserved words, but in some contexts certain identifiers
+are reserved to function as keywords. These are discussed further in the
+relevant documentation sections that follow. In such situations, the
+identifier's role as a keyword supersedes any other valid interpretation that
+may be possible. Outside of these specific situations, the keywords have no
+special meaning and are interpreted as regular identifiers.
+
+### Operators and Delimiters
+
+The following character sequences represent operators, delimiters, and other
+special tokens:
+
+```
++    &&   ==   <    :    {    [    (    ${
+-    ||   !=   >    ?    }    ]    )    %{
+*    !         <=        =         .
+/              >=        =>        ,
+%                                  ...
+```
+
+### Numeric Literals
+
+A numeric literal is a decimal representation of a
+real number. It has an integer part, a fractional part,
+and an exponent part.
+
+```ebnf
+NumericLit = decimal+ ("." decimal+)? (expmark decimal+)?;
+decimal    = '0' .. '9';
+expmark    = ('e' | 'E') ("+" | "-")?;
+```
+
+## Structural Elements
+
+The structural language consists of syntax representing the following
+constructs:
+
+- _Attributes_, which assign a value to a specified name.
+- _Blocks_, which create a child body annotated by a type and optional labels.
+- _Body Content_, which consists of a collection of attributes and blocks.
+
+These constructs correspond to the similarly-named concepts in the
+language-agnostic HCL information model.
+
+```ebnf
+ConfigFile   = Body;
+Body         = (Attribute | Block | OneLineBlock)*;
+Attribute    = Identifier "=" Expression Newline;
+Block        = Identifier (StringLit|Identifier)* "{" Newline Body "}" Newline;
+OneLineBlock = Identifier (StringLit|Identifier)* "{" (Identifier "=" Expression)? "}" Newline;
+```
+
+### Configuration Files
+
+A _configuration file_ is a sequence of characters whose top-level is
+interpreted as a Body.
+
+### Bodies
+
+A _body_ is a collection of associated attributes and blocks. The meaning of
+this association is defined by the calling application.
+
+### Attribute Definitions
+
+An _attribute definition_ assigns a value to a particular attribute name within
+a body. Each distinct attribute name may be defined no more than once within a
+single body.
+
+The attribute value is given as an expression, which is retained literally
+for later evaluation by the calling application.
+
+### Blocks
+
+A _block_ creates a child body that is annotated with a block _type_ and
+zero or more block _labels_. Blocks create a structural hierarchy which can be
+interpreted by the calling application.
+
+Block labels can either be quoted literal strings or naked identifiers.
+
+## Expressions
+
+The expression sub-language is used within attribute definitions to specify
+values.
+
+```ebnf
+Expression = (
+    ExprTerm |
+    Operation |
+    Conditional
+);
+```
+
+### Types
+
+The value types used within the expression language are those defined by the
+syntax-agnostic HCL information model. An expression may return any valid
+type, but only a subset of the available types have first-class syntax.
+A calling application may make other types available via _variables_ and
+_functions_.
+
+### Expression Terms
+
+Expression _terms_ are the operands for unary and binary expressions, as well
+as acting as expressions in their own right.
+
+```ebnf
+ExprTerm = (
+    LiteralValue |
+    CollectionValue |
+    TemplateExpr |
+    VariableExpr |
+    FunctionCall |
+    ForExpr |
+    ExprTerm Index |
+    ExprTerm GetAttr |
+    ExprTerm Splat |
+    "(" Expression ")"
+);
+```
+
+The productions for these different term types are given in their corresponding
+sections.
+
+Between the `(` and `)` characters denoting a sub-expression, newline
+characters are ignored as whitespace.
+
+### Literal Values
+
+A _literal value_ immediately represents a particular value of a primitive
+type.
+
+```ebnf
+LiteralValue = (
+  NumericLit |
+  "true" |
+  "false" |
+  "null"
+);
+```
+
+- Numeric literals represent values of type _number_.
+- The `true` and `false` keywords represent values of type _bool_.
+- The `null` keyword represents a null value of the dynamic pseudo-type.
+
+String literals are not directly available in the expression sub-language, but
+are available via the template sub-language, which can in turn be incorporated
+via _template expressions_.
+
+### Collection Values
+
+A _collection value_ combines zero or more other expressions to produce a
+collection value.
+
+```ebnf
+CollectionValue = tuple | object;
+tuple = "[" (
+    (Expression ("," Expression)* ","?)?
+) "]";
+object = "{" (
+    (objectelem ("," objectelem)* ","?)?
+) "}";
+objectelem = (Identifier | Expression) ("=" | ":") Expression;
+```
+
+Only tuple and object values can be directly constructed via native syntax.
+Tuple and object values can in turn be converted to list, set and map values
+with other operations, which behaves as defined by the syntax-agnostic HCL
+information model.
+
+When specifying an object element, an identifier is interpreted as a literal
+attribute name as opposed to a variable reference. To populate an item key
+from a variable, use parentheses to disambiguate:
+
+- `{foo = "baz"}` is interpreted as an attribute literally named `foo`.
+- `{(foo) = "baz"}` is interpreted as an attribute whose name is taken
+  from the variable named `foo`.
+
+Between the open and closing delimiters of these sequences, newline sequences
+are ignored as whitespace.
+
+There is a syntax ambiguity between _for expressions_ and collection values
+whose first element is a reference to a variable named `for`. The
+_for expression_ interpretation has priority, so to produce a tuple whose
+first element is the value of a variable named `for`, or an object with a
+key named `for`, use parentheses to disambiguate:
+
+- `[for, foo, baz]` is a syntax error.
+- `[(for), foo, baz]` is a tuple whose first element is the value of variable
+  `for`.
+- `{for: 1, baz: 2}` is a syntax error.
+- `{(for): 1, baz: 2}` is an object with an attribute literally named `for`.
+- `{baz: 2, for: 1}` is equivalent to the previous example, and resolves the
+  ambiguity by reordering.
+
+### Template Expressions
+
+A _template expression_ embeds a program written in the template sub-language
+as an expression. Template expressions come in two forms:
+
+- A _quoted_ template expression is delimited by quote characters (`"`) and
+  defines a template as a single-line expression with escape characters.
+- A _heredoc_ template expression is introduced by a `<<` sequence and
+  defines a template via a multi-line sequence terminated by a user-chosen
+  delimiter.
+
+In both cases the template interpolation and directive syntax is available for
+use within the delimiters, and any text outside of these special sequences is
+interpreted as a literal string.
+
+In _quoted_ template expressions any literal string sequences within the
+template behave in a special way: literal newline sequences are not permitted
+and instead _escape sequences_ can be included, starting with the
+backslash `\`:
+
+```
+    \n         Unicode newline control character
+    \r         Unicode carriage return control character
+    \t         Unicode tab control character
+    \"         Literal quote mark, used to prevent interpretation as end of string
+    \\         Literal backslash, used to prevent interpretation as escape sequence
+    \uNNNN     Unicode character from Basic Multilingual Plane (NNNN is four hexadecimal digits)
+    \UNNNNNNNN Unicode character from supplementary planes (NNNNNNNN is eight hexadecimal digits)
+```
+
+The _heredoc_ template expression type is introduced by either `<<` or `<<-`,
+followed by an identifier. The template expression ends when the given
+identifier subsequently appears again on a line of its own.
+
+If a heredoc template is introduced with the `<<-` symbol, any literal string
+at the start of each line is analyzed to find the minimum number of leading
+spaces, and then that number of prefix spaces is removed from all line-leading
+literal strings. The final closing marker may also have an arbitrary number
+of spaces preceding it on its line.
+
+```ebnf
+TemplateExpr = quotedTemplate | heredocTemplate;
+quotedTemplate = (as defined in prose above);
+heredocTemplate = (
+    ("<<" | "<<-") Identifier Newline
+    (content as defined in prose above)
+    Identifier Newline
+);
+```
+
+A quoted template expression containing only a single literal string serves
+as a syntax for defining literal string _expressions_. In certain contexts
+the template syntax is restricted in this manner:
+
+```ebnf
+StringLit = '"' (quoted literals as defined in prose above) '"';
+```
+
+The `StringLit` production permits the escape sequences discussed for quoted
+template expressions as above, but does _not_ permit template interpolation
+or directive sequences.
+
+### Variables and Variable Expressions
+
+A _variable_ is a value that has been assigned a symbolic name. Variables are
+made available for use in expressions by the calling application, by populating
+the _global scope_ used for expression evaluation.
+
+Variables can also be created by expressions themselves, which always creates
+a _child scope_ that incorporates the variables from its parent scope but
+(re-)defines zero or more names with new values.
+
+The value of a variable is accessed using a _variable expression_, which is
+a standalone `Identifier` whose name corresponds to a defined variable:
+
+```ebnf
+VariableExpr = Identifier;
+```
+
+Variables in a particular scope are immutable, but child scopes may _hide_
+a variable from an ancestor scope by defining a new variable of the same name.
+When looking up variables, the most locally-defined variable of the given name
+is used, and ancestor-scoped variables of the same name cannot be accessed.
+
+No direct syntax is provided for declaring or assigning variables, but other
+expression constructs implicitly create child scopes and define variables as
+part of their evaluation.
+
+### Functions and Function Calls
+
+A _function_ is an operation that has been assigned a symbolic name. Functions
+are made available for use in expressions by the calling application, by
+populating the _function table_ used for expression evaluation.
+
+The namespace of functions is distinct from the namespace of variables. A
+function and a variable may share the same name with no implication that they
+are in any way related.
+
+A function can be executed via a _function call_ expression:
+
+```ebnf
+FunctionCall = Identifier "(" arguments ")";
+Arguments = (
+    () ||
+    (Expression ("," Expression)* ("," | "...")?)
+);
+```
+
+The definition of functions and the semantics of calling them are defined by
+the language-agnostic HCL information model. The given arguments are mapped
+onto the function's _parameters_ and the result of a function call expression
+is the return value of the named function when given those arguments.
+
+If the final argument expression is followed by the ellipsis symbol (`...`),
+the final argument expression must evaluate to either a list or tuple value.
+The elements of the value are each mapped to a single parameter of the
+named function, beginning at the first parameter remaining after all other
+argument expressions have been mapped.
+
+Within the parentheses that delimit the function arguments, newline sequences
+are ignored as whitespace.
+
+### For Expressions
+
+A _for expression_ is a construct for constructing a collection by projecting
+the items from another collection.
+
+```ebnf
+ForExpr = forTupleExpr | forObjectExpr;
+forTupleExpr = "[" forIntro Expression forCond? "]";
+forObjectExpr = "{" forIntro Expression "=>" Expression "..."? forCond? "}";
+forIntro = "for" Identifier ("," Identifier)? "in" Expression ":";
+forCond = "if" Expression;
+```
+
+The punctuation used to delimit a for expression decide whether it will produce
+a tuple value (`[` and `]`) or an object value (`{` and `}`).
+
+The "introduction" is equivalent in both cases: the keyword `for` followed by
+either one or two identifiers separated by a comma which define the temporary
+variable names used for iteration, followed by the keyword `in` and then
+an expression that must evaluate to a value that can be iterated. The
+introduction is then terminated by the colon (`:`) symbol.
+
+If only one identifier is provided, it is the name of a variable that will
+be temporarily assigned the value of each element during iteration. If both
+are provided, the first is the key and the second is the value.
+
+Tuple, object, list, map, and set types are iterable. The type of collection
+used defines how the key and value variables are populated:
+
+- For tuple and list types, the _key_ is the zero-based index into the
+  sequence for each element, and the _value_ is the element value. The
+  elements are visited in index order.
+- For object and map types, the _key_ is the string attribute name or element
+  key, and the _value_ is the attribute or element value. The elements are
+  visited in the order defined by a lexicographic sort of the attribute names
+  or keys.
+- For set types, the _key_ and _value_ are both the element value. The elements
+  are visited in an undefined but consistent order.
+
+The expression after the colon and (in the case of object `for`) the expression
+after the `=>` are both evaluated once for each element of the source
+collection, in a local scope that defines the key and value variable names
+specified.
+
+The results of evaluating these expressions for each input element are used
+to populate an element in the new collection. In the case of tuple `for`, the
+single expression becomes an element, appending values to the tuple in visit
+order. In the case of object `for`, the pair of expressions is used as an
+attribute name and value respectively, creating an element in the resulting
+object.
+
+In the case of object `for`, it is an error if two input elements produce
+the same result from the attribute name expression, since duplicate
+attributes are not possible. If the ellipsis symbol (`...`) appears
+immediately after the value expression, this activates the grouping mode in
+which each value in the resulting object is a _tuple_ of all of the values
+that were produced against each distinct key.
+
+- `[for v in ["a", "b"]: v]` returns `["a", "b"]`.
+- `[for i, v in ["a", "b"]: i]` returns `[0, 1]`.
+- `{for i, v in ["a", "b"]: v => i}` returns `{a = 0, b = 1}`.
+- `{for i, v in ["a", "a", "b"]: k => v}` produces an error, because attribute
+  `a` is defined twice.
+- `{for i, v in ["a", "a", "b"]: v => i...}` returns `{a = [0, 1], b = [2]}`.
+
+If the `if` keyword is used after the element expression(s), it applies an
+additional predicate that can be used to conditionally filter elements from
+the source collection from consideration. The expression following `if` is
+evaluated once for each source element, in the same scope used for the
+element expression(s). It must evaluate to a boolean value; if `true`, the
+element will be evaluated as normal, while if `false` the element will be
+skipped.
+
+- `[for i, v in ["a", "b", "c"]: v if i < 2]` returns `["a", "b"]`.
+
+If the collection value, element expression(s) or condition expression return
+unknown values that are otherwise type-valid, the result is a value of the
+dynamic pseudo-type.
+
+### Index Operator
+
+The _index_ operator returns the value of a single element of a collection
+value. It is a postfix operator and can be applied to any value that has
+a tuple, object, map, or list type.
+
+```ebnf
+Index = "[" Expression "]";
+```
+
+The expression delimited by the brackets is the _key_ by which an element
+will be looked up.
+
+If the index operator is applied to a value of tuple or list type, the
+key expression must be an non-negative integer number representing the
+zero-based element index to access. If applied to a value of object or map
+type, the key expression must be a string representing the attribute name
+or element key. If the given key value is not of the appropriate type, a
+conversion is attempted using the conversion rules from the HCL
+syntax-agnostic information model.
+
+An error is produced if the given key expression does not correspond to
+an element in the collection, either because it is of an unconvertable type,
+because it is outside the range of elements for a tuple or list, or because
+the given attribute or key does not exist.
+
+If either the collection or the key are an unknown value of an
+otherwise-suitable type, the return value is an unknown value whose type
+matches what type would be returned given known values, or a value of the
+dynamic pseudo-type if type information alone cannot determine a suitable
+return type.
+
+Within the brackets that delimit the index key, newline sequences are ignored
+as whitespace.
+
+The HCL native syntax also includes a _legacy_ index operator that exists
+only for compatibility with the precursor language HIL:
+
+```ebnf
+LegacyIndex = '.' digit+
+```
+
+This legacy index operator must be supported by parser for compatibility but
+should not be used in new configurations. This allows an attribute-access-like
+syntax for indexing, must still be interpreted as an index operation rather
+than attribute access.
+
+The legacy syntax does not support chaining of index operations, like
+`foo.0.0.bar`, because the interpretation of `0.0` as a number literal token
+takes priority and thus renders the resulting sequence invalid.
+
+### Attribute Access Operator
+
+The _attribute access_ operator returns the value of a single attribute in
+an object value. It is a postfix operator and can be applied to any value
+that has an object type.
+
+```ebnf
+GetAttr = "." Identifier;
+```
+
+The given identifier is interpreted as the name of the attribute to access.
+An error is produced if the object to which the operator is applied does not
+have an attribute with the given name.
+
+If the object is an unknown value of a type that has the attribute named, the
+result is an unknown value of the attribute's type.
+
+### Splat Operators
+
+The _splat operators_ allow convenient access to attributes or elements of
+elements in a tuple, list, or set value.
+
+There are two kinds of "splat" operator:
+
+- The _attribute-only_ splat operator supports only attribute lookups into
+  the elements from a list, but supports an arbitrary number of them.
+
+- The _full_ splat operator additionally supports indexing into the elements
+  from a list, and allows any combination of attribute access and index
+  operations.
+
+```ebnf
+Splat = attrSplat | fullSplat;
+attrSplat = "." "*" GetAttr*;
+fullSplat = "[" "*" "]" (GetAttr | Index)*;
+```
+
+The splat operators can be thought of as shorthands for common operations that
+could otherwise be performed using _for expressions_:
+
+- `tuple.*.foo.bar[0]` is approximately equivalent to
+  `[for v in tuple: v.foo.bar][0]`.
+- `tuple[*].foo.bar[0]` is approximately equivalent to
+  `[for v in tuple: v.foo.bar[0]]`
+
+Note the difference in how the trailing index operator is interpreted in
+each case. This different interpretation is the key difference between the
+_attribute-only_ and _full_ splat operators.
+
+Splat operators have one additional behavior compared to the equivalent
+_for expressions_ shown above: if a splat operator is applied to a value that
+is _not_ of tuple, list, or set type, the value is coerced automatically into
+a single-value list of the value type:
+
+- `any_object.*.id` is equivalent to `[any_object.id]`, assuming that `any_object`
+  is a single object.
+- `any_number.*` is equivalent to `[any_number]`, assuming that `any_number`
+  is a single number.
+
+If applied to a null value that is not tuple, list, or set, the result is always
+an empty tuple, which allows conveniently converting a possibly-null scalar
+value into a tuple of zero or one elements. It is illegal to apply a splat
+operator to a null value of tuple, list, or set type.
+
+### Operations
+
+Operations apply a particular operator to either one or two expression terms.
+
+```ebnf
+Operation = unaryOp | binaryOp;
+unaryOp = ("-" | "!") ExprTerm;
+binaryOp = ExprTerm binaryOperator ExprTerm;
+binaryOperator = compareOperator | arithmeticOperator | logicOperator;
+compareOperator = "==" | "!=" | "<" | ">" | "<=" | ">=";
+arithmeticOperator = "+" | "-" | "*" | "/" | "%";
+logicOperator = "&&" | "||" | "!";
+```
+
+The unary operators have the highest precedence.
+
+The binary operators are grouped into the following precedence levels:
+
+```
+Level    Operators
+  6      * / %
+  5      + -
+  4      > >= < <=
+  3      == !=
+  2      &&
+  1      ||
+```
+
+Higher values of "level" bind tighter. Operators within the same precedence
+level have left-to-right associativity. For example, `x / y * z` is equivalent
+to `(x / y) * z`.
+
+### Comparison Operators
+
+Comparison operators always produce boolean values, as a result of testing
+the relationship between two values.
+
+The two equality operators apply to values of any type:
+
+```
+a == b  equal
+a != b  not equal
+```
+
+Two values are equal if the are of identical types and their values are
+equal as defined in the HCL syntax-agnostic information model. The equality
+operators are commutative and opposite, such that `(a == b) == !(a != b)`
+and `(a == b) == (b == a)` for all values `a` and `b`.
+
+The four numeric comparison operators apply only to numbers:
+
+```
+a < b   less than
+a <= b  less than or equal to
+a > b   greater than
+a >= b  greater than or equal to
+```
+
+If either operand of a comparison operator is a correctly-typed unknown value
+or a value of the dynamic pseudo-type, the result is an unknown boolean.
+
+### Arithmetic Operators
+
+Arithmetic operators apply only to number values and always produce number
+values as results.
+
+```
+a + b   sum        (addition)
+a - b   difference (subtraction)
+a * b   product    (multiplication)
+a / b   quotient   (division)
+a % b   remainder  (modulo)
+-a      negation
+```
+
+Arithmetic operations are considered to be performed in an arbitrary-precision
+number space.
+
+If either operand of an arithmetic operator is an unknown number or a value
+of the dynamic pseudo-type, the result is an unknown number.
+
+### Logic Operators
+
+Logic operators apply only to boolean values and always produce boolean values
+as results.
+
+```
+a && b   logical AND
+a || b   logical OR
+!a       logical NOT
+```
+
+If either operand of a logic operator is an unknown bool value or a value
+of the dynamic pseudo-type, the result is an unknown bool value.
+
+### Conditional Operator
+
+The conditional operator allows selecting from one of two expressions based on
+the outcome of a boolean expression.
+
+```ebnf
+Conditional = Expression "?" Expression ":" Expression;
+```
+
+The first expression is the _predicate_, which is evaluated and must produce
+a boolean result. If the predicate value is `true`, the result of the second
+expression is the result of the conditional. If the predicate value is
+`false`, the result of the third expression is the result of the conditional.
+
+The second and third expressions must be of the same type or must be able to
+unify into a common type using the type unification rules defined in the
+HCL syntax-agnostic information model. This unified type is the result type
+of the conditional, with both expressions converted as necessary to the
+unified type.
+
+If the predicate is an unknown boolean value or a value of the dynamic
+pseudo-type then the result is an unknown value of the unified type of the
+other two expressions.
+
+If either the second or third expressions produce errors when evaluated,
+these errors are passed through only if the erroneous expression is selected.
+This allows for expressions such as
+`length(some_list) > 0 ? some_list[0] : default` (given some suitable `length`
+function) without producing an error when the predicate is `false`.
+
+## Templates
+
+The template sub-language is used within template expressions to concisely
+combine strings and other values to produce other strings. It can also be
+used in isolation as a standalone template language.
+
+```ebnf
+Template = (
+    TemplateLiteral |
+    TemplateInterpolation |
+    TemplateDirective
+)*
+TemplateDirective = TemplateIf | TemplateFor;
+```
+
+A template behaves like an expression that always returns a string value.
+The different elements of the template are evaluated and combined into a
+single string to return. If any of the elements produce an unknown string
+or a value of the dynamic pseudo-type, the result is an unknown string.
+
+An important use-case for standalone templates is to enable the use of
+expressions in alternative HCL syntaxes where a native expression grammar is
+not available. For example, the HCL JSON profile treats the values of JSON
+strings as standalone templates when attributes are evaluated in expression
+mode.
+
+### Template Literals
+
+A template literal is a literal sequence of characters to include in the
+resulting string. When the template sub-language is used standalone, a
+template literal can contain any unicode character, with the exception
+of the sequences that introduce interpolations and directives, and for the
+sequences that escape those introductions.
+
+The interpolation and directive introductions are escaped by doubling their
+leading characters. The `${` sequence is escaped as `$${` and the `%{`
+sequence is escaped as `%%{`.
+
+When the template sub-language is embedded in the expression language via
+_template expressions_, additional constraints and transforms are applied to
+template literals as described in the definition of template expressions.
+
+The value of a template literal can be modified by _strip markers_ in any
+interpolations or directives that are adjacent to it. A strip marker is
+a tilde (`~`) placed immediately after the opening `{` or before the closing
+`}` of a template sequence:
+
+- `hello ${~ "world" }` produces `"helloworld"`.
+- `%{ if true ~} hello %{~ endif }` produces `"hello"`.
+
+When a strip marker is present, any spaces adjacent to it in the corresponding
+string literal (if any) are removed before producing the final value. Space
+characters are interpreted as per Unicode's definition.
+
+Stripping is done at syntax level rather than value level. Values returned
+by interpolations or directives are not subject to stripping:
+
+- `${"hello" ~}${" world"}` produces `"hello world"`, and not `"helloworld"`,
+  because the space is not in a template literal directly adjacent to the
+  strip marker.
+
+### Template Interpolations
+
+An _interpolation sequence_ evaluates an expression (written in the
+expression sub-language), converts the result to a string value, and
+replaces itself with the resulting string.
+
+```ebnf
+TemplateInterpolation = ("${" | "${~") Expression ("}" | "~}";
+```
+
+If the expression result cannot be converted to a string, an error is
+produced.
+
+### Template If Directive
+
+The template `if` directive is the template equivalent of the
+_conditional expression_, allowing selection of one of two sub-templates based
+on the value of a predicate expression.
+
+```ebnf
+TemplateIf = (
+    ("%{" | "%{~") "if" Expression ("}" | "~}")
+    Template
+    (
+        ("%{" | "%{~") "else" ("}" | "~}")
+        Template
+    )?
+    ("%{" | "%{~") "endif" ("}" | "~}")
+);
+```
+
+The evaluation of the `if` directive is equivalent to the conditional
+expression, with the following exceptions:
+
+- The two sub-templates always produce strings, and thus the result value is
+  also always a string.
+- The `else` clause may be omitted, in which case the conditional's third
+  expression result is implied to be the empty string.
+
+### Template For Directive
+
+The template `for` directive is the template equivalent of the _for expression_,
+producing zero or more copies of its sub-template based on the elements of
+a collection.
+
+```ebnf
+TemplateFor = (
+    ("%{" | "%{~") "for" Identifier ("," Identifier) "in" Expression ("}" | "~}")
+    Template
+    ("%{" | "%{~") "endfor" ("}" | "~}")
+);
+```
+
+The evaluation of the `for` directive is equivalent to the _for expression_
+when producing a tuple, with the following exceptions:
+
+- The sub-template always produces a string.
+- There is no equivalent of the "if" clause on the for expression.
+- The elements of the resulting tuple are all converted to strings and
+  concatenated to produce a flat string result.
+
+### Template Interpolation Unwrapping
+
+As a special case, a template that consists only of a single interpolation,
+with no surrounding literals, directives or other interpolations, is
+"unwrapped". In this case, the result of the interpolation expression is
+returned verbatim, without conversion to string.
+
+This special case exists primarily to enable the native template language
+to be used inside strings in alternative HCL syntaxes that lack a first-class
+template or expression syntax. Unwrapping allows arbitrary expressions to be
+used to populate attributes when strings in such languages are interpreted
+as templates.
+
+- `${true}` produces the boolean value `true`
+- `${"${true}"}` produces the boolean value `true`, because both the inner
+  and outer interpolations are subject to unwrapping.
+- `hello ${true}` produces the string `"hello true"`
+- `${""}${true}` produces the string `"true"` because there are two
+  interpolation sequences, even though one produces an empty result.
+- `%{ for v in [true] }${v}%{ endif }` produces the string `true` because
+  the presence of the `for` directive circumvents the unwrapping even though
+  the final result is a single value.
+
+In some contexts this unwrapping behavior may be circumvented by the calling
+application, by converting the final template result to string. This is
+necessary, for example, if a standalone template is being used to produce
+the direct contents of a file, since the result in that case must always be a
+string.
+
+## Static Analysis
+
+The HCL static analysis operations are implemented for some expression types
+in the native syntax, as described in the following sections.
+
+A goal for static analysis of the native syntax is for the interpretation to
+be as consistent as possible with the dynamic evaluation interpretation of
+the given expression, though some deviations are intentionally made in order
+to maximize the potential for analysis.
+
+### Static List
+
+The tuple construction syntax can be interpreted as a static list. All of
+the expression elements given are returned as the static list elements,
+with no further interpretation.
+
+### Static Map
+
+The object construction syntax can be interpreted as a static map. All of the
+key/value pairs given are returned as the static pairs, with no further
+interpretation.
+
+The usual requirement that an attribute name be interpretable as a string
+does not apply to this static analysis, allowing callers to provide map-like
+constructs with different key types by building on the map syntax.
+
+### Static Call
+
+The function call syntax can be interpreted as a static call. The called
+function name is returned verbatim and the given argument expressions are
+returned as the static arguments, with no further interpretation.
+
+### Static Traversal
+
+A variable expression and any attached attribute access operations and
+constant index operations can be interpreted as a static traversal.
+
+The keywords `true`, `false` and `null` can also be interpreted as
+static traversals, behaving as if they were references to variables of those
+names, to allow callers to redefine the meaning of those keywords in certain
+contexts.
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure.go
new file mode 100644
index 00000000..2f7470c7
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure.go
@@ -0,0 +1,394 @@
+package hclsyntax
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+// AsHCLBlock returns the block data expressed as a *hcl.Block.
+func (b *Block) AsHCLBlock() *hcl.Block {
+	if b == nil {
+		return nil
+	}
+
+	lastHeaderRange := b.TypeRange
+	if len(b.LabelRanges) > 0 {
+		lastHeaderRange = b.LabelRanges[len(b.LabelRanges)-1]
+	}
+
+	return &hcl.Block{
+		Type:   b.Type,
+		Labels: b.Labels,
+		Body:   b.Body,
+
+		DefRange:    hcl.RangeBetween(b.TypeRange, lastHeaderRange),
+		TypeRange:   b.TypeRange,
+		LabelRanges: b.LabelRanges,
+	}
+}
+
+// Body is the implementation of hcl.Body for the HCL native syntax.
+type Body struct {
+	Attributes Attributes
+	Blocks     Blocks
+
+	// These are used with PartialContent to produce a "remaining items"
+	// body to return. They are nil on all bodies fresh out of the parser.
+	hiddenAttrs  map[string]struct{}
+	hiddenBlocks map[string]struct{}
+
+	SrcRange hcl.Range
+	EndRange hcl.Range // Final token of the body, for reporting missing items
+}
+
+// Assert that *Body implements hcl.Body
+var assertBodyImplBody hcl.Body = &Body{}
+
+func (b *Body) walkChildNodes(w internalWalkFunc) {
+	w(b.Attributes)
+	w(b.Blocks)
+}
+
+func (b *Body) Range() hcl.Range {
+	return b.SrcRange
+}
+
+func (b *Body) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) {
+	content, remainHCL, diags := b.PartialContent(schema)
+
+	// No we'll see if anything actually remains, to produce errors about
+	// extraneous items.
+	remain := remainHCL.(*Body)
+
+	for name, attr := range b.Attributes {
+		if _, hidden := remain.hiddenAttrs[name]; !hidden {
+			var suggestions []string
+			for _, attrS := range schema.Attributes {
+				if _, defined := content.Attributes[attrS.Name]; defined {
+					continue
+				}
+				suggestions = append(suggestions, attrS.Name)
+			}
+			suggestion := nameSuggestion(name, suggestions)
+			if suggestion != "" {
+				suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+			} else {
+				// Is there a block of the same name?
+				for _, blockS := range schema.Blocks {
+					if blockS.Type == name {
+						suggestion = fmt.Sprintf(" Did you mean to define a block of type %q?", name)
+						break
+					}
+				}
+			}
+
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unsupported argument",
+				Detail:   fmt.Sprintf("An argument named %q is not expected here.%s", name, suggestion),
+				Subject:  &attr.NameRange,
+			})
+		}
+	}
+
+	for _, block := range b.Blocks {
+		blockTy := block.Type
+		if _, hidden := remain.hiddenBlocks[blockTy]; !hidden {
+			var suggestions []string
+			for _, blockS := range schema.Blocks {
+				suggestions = append(suggestions, blockS.Type)
+			}
+			suggestion := nameSuggestion(blockTy, suggestions)
+			if suggestion != "" {
+				suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+			} else {
+				// Is there an attribute of the same name?
+				for _, attrS := range schema.Attributes {
+					if attrS.Name == blockTy {
+						suggestion = fmt.Sprintf(" Did you mean to define argument %q? If so, use the equals sign to assign it a value.", blockTy)
+						break
+					}
+				}
+			}
+
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unsupported block type",
+				Detail:   fmt.Sprintf("Blocks of type %q are not expected here.%s", blockTy, suggestion),
+				Subject:  &block.TypeRange,
+			})
+		}
+	}
+
+	return content, diags
+}
+
+func (b *Body) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
+	attrs := make(hcl.Attributes)
+	var blocks hcl.Blocks
+	var diags hcl.Diagnostics
+	hiddenAttrs := make(map[string]struct{})
+	hiddenBlocks := make(map[string]struct{})
+
+	if b.hiddenAttrs != nil {
+		for k, v := range b.hiddenAttrs {
+			hiddenAttrs[k] = v
+		}
+	}
+	if b.hiddenBlocks != nil {
+		for k, v := range b.hiddenBlocks {
+			hiddenBlocks[k] = v
+		}
+	}
+
+	for _, attrS := range schema.Attributes {
+		name := attrS.Name
+		attr, exists := b.Attributes[name]
+		_, hidden := hiddenAttrs[name]
+		if hidden || !exists {
+			if attrS.Required {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Missing required argument",
+					Detail:   fmt.Sprintf("The argument %q is required, but no definition was found.", attrS.Name),
+					Subject:  b.MissingItemRange().Ptr(),
+				})
+			}
+			continue
+		}
+
+		hiddenAttrs[name] = struct{}{}
+		attrs[name] = attr.AsHCLAttribute()
+	}
+
+	blocksWanted := make(map[string]hcl.BlockHeaderSchema)
+	for _, blockS := range schema.Blocks {
+		blocksWanted[blockS.Type] = blockS
+	}
+
+	for _, block := range b.Blocks {
+		if _, hidden := hiddenBlocks[block.Type]; hidden {
+			continue
+		}
+		blockS, wanted := blocksWanted[block.Type]
+		if !wanted {
+			continue
+		}
+
+		if len(block.Labels) > len(blockS.LabelNames) {
+			name := block.Type
+			if len(blockS.LabelNames) == 0 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  fmt.Sprintf("Extraneous label for %s", name),
+					Detail: fmt.Sprintf(
+						"No labels are expected for %s blocks.", name,
+					),
+					Subject: block.LabelRanges[0].Ptr(),
+					Context: hcl.RangeBetween(block.TypeRange, block.OpenBraceRange).Ptr(),
+				})
+			} else {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  fmt.Sprintf("Extraneous label for %s", name),
+					Detail: fmt.Sprintf(
+						"Only %d labels (%s) are expected for %s blocks.",
+						len(blockS.LabelNames), strings.Join(blockS.LabelNames, ", "), name,
+					),
+					Subject: block.LabelRanges[len(blockS.LabelNames)].Ptr(),
+					Context: hcl.RangeBetween(block.TypeRange, block.OpenBraceRange).Ptr(),
+				})
+			}
+			continue
+		}
+
+		if len(block.Labels) < len(blockS.LabelNames) {
+			name := block.Type
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Missing %s for %s", blockS.LabelNames[len(block.Labels)], name),
+				Detail: fmt.Sprintf(
+					"All %s blocks must have %d labels (%s).",
+					name, len(blockS.LabelNames), strings.Join(blockS.LabelNames, ", "),
+				),
+				Subject: &block.OpenBraceRange,
+				Context: hcl.RangeBetween(block.TypeRange, block.OpenBraceRange).Ptr(),
+			})
+			continue
+		}
+
+		blocks = append(blocks, block.AsHCLBlock())
+	}
+
+	// We hide blocks only after we've processed all of them, since otherwise
+	// we can't process more than one of the same type.
+	for _, blockS := range schema.Blocks {
+		hiddenBlocks[blockS.Type] = struct{}{}
+	}
+
+	remain := &Body{
+		Attributes: b.Attributes,
+		Blocks:     b.Blocks,
+
+		hiddenAttrs:  hiddenAttrs,
+		hiddenBlocks: hiddenBlocks,
+
+		SrcRange: b.SrcRange,
+		EndRange: b.EndRange,
+	}
+
+	return &hcl.BodyContent{
+		Attributes: attrs,
+		Blocks:     blocks,
+
+		MissingItemRange: b.MissingItemRange(),
+	}, remain, diags
+}
+
+func (b *Body) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
+	attrs := make(hcl.Attributes)
+	var diags hcl.Diagnostics
+
+	if len(b.Blocks) > 0 {
+		example := b.Blocks[0]
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Unexpected %q block", example.Type),
+			Detail:   "Blocks are not allowed here.",
+			Subject:  &example.TypeRange,
+		})
+		// we will continue processing anyway, and return the attributes
+		// we are able to find so that certain analyses can still be done
+		// in the face of errors.
+	}
+
+	if b.Attributes == nil {
+		return attrs, diags
+	}
+
+	for name, attr := range b.Attributes {
+		if _, hidden := b.hiddenAttrs[name]; hidden {
+			continue
+		}
+		attrs[name] = attr.AsHCLAttribute()
+	}
+
+	return attrs, diags
+}
+
+func (b *Body) MissingItemRange() hcl.Range {
+	return hcl.Range{
+		Filename: b.SrcRange.Filename,
+		Start:    b.SrcRange.Start,
+		End:      b.SrcRange.Start,
+	}
+}
+
+// Attributes is the collection of attribute definitions within a body.
+type Attributes map[string]*Attribute
+
+func (a Attributes) walkChildNodes(w internalWalkFunc) {
+	for _, attr := range a {
+		w(attr)
+	}
+}
+
+// Range returns the range of some arbitrary point within the set of
+// attributes, or an invalid range if there are no attributes.
+//
+// This is provided only to complete the Node interface, but has no practical
+// use.
+func (a Attributes) Range() hcl.Range {
+	// An attributes doesn't really have a useful range to report, since
+	// it's just a grouping construct. So we'll arbitrarily take the
+	// range of one of the attributes, or produce an invalid range if we have
+	// none. In practice, there's little reason to ask for the range of
+	// an Attributes.
+	for _, attr := range a {
+		return attr.Range()
+	}
+	return hcl.Range{
+		Filename: "<unknown>",
+	}
+}
+
+// Attribute represents a single attribute definition within a body.
+type Attribute struct {
+	Name string
+	Expr Expression
+
+	SrcRange    hcl.Range
+	NameRange   hcl.Range
+	EqualsRange hcl.Range
+}
+
+func (a *Attribute) walkChildNodes(w internalWalkFunc) {
+	w(a.Expr)
+}
+
+func (a *Attribute) Range() hcl.Range {
+	return a.SrcRange
+}
+
+// AsHCLAttribute returns the block data expressed as a *hcl.Attribute.
+func (a *Attribute) AsHCLAttribute() *hcl.Attribute {
+	if a == nil {
+		return nil
+	}
+	return &hcl.Attribute{
+		Name: a.Name,
+		Expr: a.Expr,
+
+		Range:     a.SrcRange,
+		NameRange: a.NameRange,
+	}
+}
+
+// Blocks is the list of nested blocks within a body.
+type Blocks []*Block
+
+func (bs Blocks) walkChildNodes(w internalWalkFunc) {
+	for _, block := range bs {
+		w(block)
+	}
+}
+
+// Range returns the range of some arbitrary point within the list of
+// blocks, or an invalid range if there are no blocks.
+//
+// This is provided only to complete the Node interface, but has no practical
+// use.
+func (bs Blocks) Range() hcl.Range {
+	if len(bs) > 0 {
+		return bs[0].Range()
+	}
+	return hcl.Range{
+		Filename: "<unknown>",
+	}
+}
+
+// Block represents a nested block structure
+type Block struct {
+	Type   string
+	Labels []string
+	Body   *Body
+
+	TypeRange       hcl.Range
+	LabelRanges     []hcl.Range
+	OpenBraceRange  hcl.Range
+	CloseBraceRange hcl.Range
+}
+
+func (b *Block) walkChildNodes(w internalWalkFunc) {
+	w(b.Body)
+}
+
+func (b *Block) Range() hcl.Range {
+	return hcl.RangeBetween(b.TypeRange, b.CloseBraceRange)
+}
+
+func (b *Block) DefRange() hcl.Range {
+	return hcl.RangeBetween(b.TypeRange, b.OpenBraceRange)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure_at_pos.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure_at_pos.go
new file mode 100644
index 00000000..587844ac
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure_at_pos.go
@@ -0,0 +1,118 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// -----------------------------------------------------------------------------
+// The methods in this file are all optional extension methods that serve to
+// implement the methods of the same name on *hcl.File when its root body
+// is provided by this package.
+// -----------------------------------------------------------------------------
+
+// BlocksAtPos implements the method of the same name for an *hcl.File that
+// is backed by a *Body.
+func (b *Body) BlocksAtPos(pos hcl.Pos) []*hcl.Block {
+	list, _ := b.blocksAtPos(pos, true)
+	return list
+}
+
+// InnermostBlockAtPos implements the method of the same name for an *hcl.File
+// that is backed by a *Body.
+func (b *Body) InnermostBlockAtPos(pos hcl.Pos) *hcl.Block {
+	_, innermost := b.blocksAtPos(pos, false)
+	return innermost.AsHCLBlock()
+}
+
+// OutermostBlockAtPos implements the method of the same name for an *hcl.File
+// that is backed by a *Body.
+func (b *Body) OutermostBlockAtPos(pos hcl.Pos) *hcl.Block {
+	return b.outermostBlockAtPos(pos).AsHCLBlock()
+}
+
+// blocksAtPos is the internal engine of both BlocksAtPos and
+// InnermostBlockAtPos, which both need to do the same logic but return a
+// differently-shaped result.
+//
+// list is nil if makeList is false, avoiding an allocation. Innermost is
+// always set, and if the returned list is non-nil it will always match the
+// final element from that list.
+func (b *Body) blocksAtPos(pos hcl.Pos, makeList bool) (list []*hcl.Block, innermost *Block) {
+	current := b
+
+Blocks:
+	for current != nil {
+		for _, block := range current.Blocks {
+			wholeRange := hcl.RangeBetween(block.TypeRange, block.CloseBraceRange)
+			if wholeRange.ContainsPos(pos) {
+				innermost = block
+				if makeList {
+					list = append(list, innermost.AsHCLBlock())
+				}
+				current = block.Body
+				continue Blocks
+			}
+		}
+
+		// If we fall out here then none of the current body's nested blocks
+		// contain the position we are looking for, and so we're done.
+		break
+	}
+
+	return
+}
+
+// outermostBlockAtPos is the internal version of OutermostBlockAtPos that
+// returns a hclsyntax.Block rather than an hcl.Block, allowing for further
+// analysis if necessary.
+func (b *Body) outermostBlockAtPos(pos hcl.Pos) *Block {
+	// This is similar to blocksAtPos, but simpler because we know it only
+	// ever needs to search the first level of nested blocks.
+
+	for _, block := range b.Blocks {
+		wholeRange := hcl.RangeBetween(block.TypeRange, block.CloseBraceRange)
+		if wholeRange.ContainsPos(pos) {
+			return block
+		}
+	}
+
+	return nil
+}
+
+// AttributeAtPos implements the method of the same name for an *hcl.File
+// that is backed by a *Body.
+func (b *Body) AttributeAtPos(pos hcl.Pos) *hcl.Attribute {
+	return b.attributeAtPos(pos).AsHCLAttribute()
+}
+
+// attributeAtPos is the internal version of AttributeAtPos that returns a
+// hclsyntax.Block rather than an hcl.Block, allowing for further analysis if
+// necessary.
+func (b *Body) attributeAtPos(pos hcl.Pos) *Attribute {
+	searchBody := b
+	_, block := b.blocksAtPos(pos, false)
+	if block != nil {
+		searchBody = block.Body
+	}
+
+	for _, attr := range searchBody.Attributes {
+		if attr.SrcRange.ContainsPos(pos) {
+			return attr
+		}
+	}
+
+	return nil
+}
+
+// OutermostExprAtPos implements the method of the same name for an *hcl.File
+// that is backed by a *Body.
+func (b *Body) OutermostExprAtPos(pos hcl.Pos) hcl.Expression {
+	attr := b.attributeAtPos(pos)
+	if attr == nil {
+		return nil
+	}
+	if !attr.Expr.Range().ContainsPos(pos) {
+		return nil
+	}
+	return attr.Expr
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/token.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/token.go
new file mode 100644
index 00000000..688b90ca
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/token.go
@@ -0,0 +1,320 @@
+package hclsyntax
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/apparentlymart/go-textseg/v12/textseg"
+	"github.com/hashicorp/hcl/v2"
+)
+
+// Token represents a sequence of bytes from some HCL code that has been
+// tagged with a type and its range within the source file.
+type Token struct {
+	Type  TokenType
+	Bytes []byte
+	Range hcl.Range
+}
+
+// Tokens is a slice of Token.
+type Tokens []Token
+
+// TokenType is an enumeration used for the Type field on Token.
+type TokenType rune
+
+const (
+	// Single-character tokens are represented by their own character, for
+	// convenience in producing these within the scanner. However, the values
+	// are otherwise arbitrary and just intended to be mnemonic for humans
+	// who might see them in debug output.
+
+	TokenOBrace   TokenType = '{'
+	TokenCBrace   TokenType = '}'
+	TokenOBrack   TokenType = '['
+	TokenCBrack   TokenType = ']'
+	TokenOParen   TokenType = '('
+	TokenCParen   TokenType = ')'
+	TokenOQuote   TokenType = '«'
+	TokenCQuote   TokenType = '»'
+	TokenOHeredoc TokenType = 'H'
+	TokenCHeredoc TokenType = 'h'
+
+	TokenStar    TokenType = '*'
+	TokenSlash   TokenType = '/'
+	TokenPlus    TokenType = '+'
+	TokenMinus   TokenType = '-'
+	TokenPercent TokenType = '%'
+
+	TokenEqual         TokenType = '='
+	TokenEqualOp       TokenType = '≔'
+	TokenNotEqual      TokenType = '≠'
+	TokenLessThan      TokenType = '<'
+	TokenLessThanEq    TokenType = '≤'
+	TokenGreaterThan   TokenType = '>'
+	TokenGreaterThanEq TokenType = '≥'
+
+	TokenAnd  TokenType = '∧'
+	TokenOr   TokenType = '∨'
+	TokenBang TokenType = '!'
+
+	TokenDot   TokenType = '.'
+	TokenComma TokenType = ','
+
+	TokenEllipsis TokenType = '…'
+	TokenFatArrow TokenType = '⇒'
+
+	TokenQuestion TokenType = '?'
+	TokenColon    TokenType = ':'
+
+	TokenTemplateInterp  TokenType = '∫'
+	TokenTemplateControl TokenType = 'λ'
+	TokenTemplateSeqEnd  TokenType = '∎'
+
+	TokenQuotedLit TokenType = 'Q' // might contain backslash escapes
+	TokenStringLit TokenType = 'S' // cannot contain backslash escapes
+	TokenNumberLit TokenType = 'N'
+	TokenIdent     TokenType = 'I'
+
+	TokenComment TokenType = 'C'
+
+	TokenNewline TokenType = '\n'
+	TokenEOF     TokenType = '␄'
+
+	// The rest are not used in the language but recognized by the scanner so
+	// we can generate good diagnostics in the parser when users try to write
+	// things that might work in other languages they are familiar with, or
+	// simply make incorrect assumptions about the HCL language.
+
+	TokenBitwiseAnd    TokenType = '&'
+	TokenBitwiseOr     TokenType = '|'
+	TokenBitwiseNot    TokenType = '~'
+	TokenBitwiseXor    TokenType = '^'
+	TokenStarStar      TokenType = '➚'
+	TokenApostrophe    TokenType = '\''
+	TokenBacktick      TokenType = '`'
+	TokenSemicolon     TokenType = ';'
+	TokenTabs          TokenType = '␉'
+	TokenInvalid       TokenType = '�'
+	TokenBadUTF8       TokenType = '💩'
+	TokenQuotedNewline TokenType = '␤'
+
+	// TokenNil is a placeholder for when a token is required but none is
+	// available, e.g. when reporting errors. The scanner will never produce
+	// this as part of a token stream.
+	TokenNil TokenType = '\x00'
+)
+
+func (t TokenType) GoString() string {
+	return fmt.Sprintf("hclsyntax.%s", t.String())
+}
+
+type scanMode int
+
+const (
+	scanNormal scanMode = iota
+	scanTemplate
+	scanIdentOnly
+)
+
+type tokenAccum struct {
+	Filename  string
+	Bytes     []byte
+	Pos       hcl.Pos
+	Tokens    []Token
+	StartByte int
+}
+
+func (f *tokenAccum) emitToken(ty TokenType, startOfs, endOfs int) {
+	// Walk through our buffer to figure out how much we need to adjust
+	// the start pos to get our end pos.
+
+	start := f.Pos
+	start.Column += startOfs + f.StartByte - f.Pos.Byte // Safe because only ASCII spaces can be in the offset
+	start.Byte = startOfs + f.StartByte
+
+	end := start
+	end.Byte = endOfs + f.StartByte
+	b := f.Bytes[startOfs:endOfs]
+	for len(b) > 0 {
+		advance, seq, _ := textseg.ScanGraphemeClusters(b, true)
+		if (len(seq) == 1 && seq[0] == '\n') || (len(seq) == 2 && seq[0] == '\r' && seq[1] == '\n') {
+			end.Line++
+			end.Column = 1
+		} else {
+			end.Column++
+		}
+		b = b[advance:]
+	}
+
+	f.Pos = end
+
+	f.Tokens = append(f.Tokens, Token{
+		Type:  ty,
+		Bytes: f.Bytes[startOfs:endOfs],
+		Range: hcl.Range{
+			Filename: f.Filename,
+			Start:    start,
+			End:      end,
+		},
+	})
+}
+
+type heredocInProgress struct {
+	Marker      []byte
+	StartOfLine bool
+}
+
+func tokenOpensFlushHeredoc(tok Token) bool {
+	if tok.Type != TokenOHeredoc {
+		return false
+	}
+	return bytes.HasPrefix(tok.Bytes, []byte{'<', '<', '-'})
+}
+
+// checkInvalidTokens does a simple pass across the given tokens and generates
+// diagnostics for tokens that should _never_ appear in HCL source. This
+// is intended to avoid the need for the parser to have special support
+// for them all over.
+//
+// Returns a diagnostics with no errors if everything seems acceptable.
+// Otherwise, returns zero or more error diagnostics, though tries to limit
+// repetition of the same information.
+func checkInvalidTokens(tokens Tokens) hcl.Diagnostics {
+	var diags hcl.Diagnostics
+
+	toldBitwise := 0
+	toldExponent := 0
+	toldBacktick := 0
+	toldApostrophe := 0
+	toldSemicolon := 0
+	toldTabs := 0
+	toldBadUTF8 := 0
+
+	for _, tok := range tokens {
+		// copy token so it's safe to point to it
+		tok := tok
+
+		switch tok.Type {
+		case TokenBitwiseAnd, TokenBitwiseOr, TokenBitwiseXor, TokenBitwiseNot:
+			if toldBitwise < 4 {
+				var suggestion string
+				switch tok.Type {
+				case TokenBitwiseAnd:
+					suggestion = " Did you mean boolean AND (\"&&\")?"
+				case TokenBitwiseOr:
+					suggestion = " Did you mean boolean OR (\"&&\")?"
+				case TokenBitwiseNot:
+					suggestion = " Did you mean boolean NOT (\"!\")?"
+				}
+
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Unsupported operator",
+					Detail:   fmt.Sprintf("Bitwise operators are not supported.%s", suggestion),
+					Subject:  &tok.Range,
+				})
+				toldBitwise++
+			}
+		case TokenStarStar:
+			if toldExponent < 1 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Unsupported operator",
+					Detail:   "\"**\" is not a supported operator. Exponentiation is not supported as an operator.",
+					Subject:  &tok.Range,
+				})
+
+				toldExponent++
+			}
+		case TokenBacktick:
+			// Only report for alternating (even) backticks, so we won't report both start and ends of the same
+			// backtick-quoted string.
+			if (toldBacktick % 2) == 0 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid character",
+					Detail:   "The \"`\" character is not valid. To create a multi-line string, use the \"heredoc\" syntax, like \"<<EOT\".",
+					Subject:  &tok.Range,
+				})
+			}
+			if toldBacktick <= 2 {
+				toldBacktick++
+			}
+		case TokenApostrophe:
+			if (toldApostrophe % 2) == 0 {
+				newDiag := &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid character",
+					Detail:   "Single quotes are not valid. Use double quotes (\") to enclose strings.",
+					Subject:  &tok.Range,
+				}
+				diags = append(diags, newDiag)
+			}
+			if toldApostrophe <= 2 {
+				toldApostrophe++
+			}
+		case TokenSemicolon:
+			if toldSemicolon < 1 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid character",
+					Detail:   "The \";\" character is not valid. Use newlines to separate arguments and blocks, and commas to separate items in collection values.",
+					Subject:  &tok.Range,
+				})
+
+				toldSemicolon++
+			}
+		case TokenTabs:
+			if toldTabs < 1 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid character",
+					Detail:   "Tab characters may not be used. The recommended indentation style is two spaces per indent.",
+					Subject:  &tok.Range,
+				})
+
+				toldTabs++
+			}
+		case TokenBadUTF8:
+			if toldBadUTF8 < 1 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid character encoding",
+					Detail:   "All input files must be UTF-8 encoded. Ensure that UTF-8 encoding is selected in your editor.",
+					Subject:  &tok.Range,
+				})
+
+				toldBadUTF8++
+			}
+		case TokenQuotedNewline:
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid multi-line string",
+				Detail:   "Quoted strings may not be split over multiple lines. To produce a multi-line string, either use the \\n escape to represent a newline character or use the \"heredoc\" multi-line template syntax.",
+				Subject:  &tok.Range,
+			})
+		case TokenInvalid:
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid character",
+				Detail:   "This character is not used within the language.",
+				Subject:  &tok.Range,
+			})
+		}
+	}
+	return diags
+}
+
+var utf8BOM = []byte{0xef, 0xbb, 0xbf}
+
+// stripUTF8BOM checks whether the given buffer begins with a UTF-8 byte order
+// mark (0xEF 0xBB 0xBF) and, if so, returns a truncated slice with the same
+// backing array but with the BOM skipped.
+//
+// If there is no BOM present, the given slice is returned verbatim.
+func stripUTF8BOM(src []byte) []byte {
+	if bytes.HasPrefix(src, utf8BOM) {
+		return src[3:]
+	}
+	return src
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/token_type_string.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/token_type_string.go
new file mode 100644
index 00000000..c23c4f0b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/token_type_string.go
@@ -0,0 +1,131 @@
+// Code generated by "stringer -type TokenType -output token_type_string.go"; DO NOT EDIT.
+
+package hclsyntax
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[TokenOBrace-123]
+	_ = x[TokenCBrace-125]
+	_ = x[TokenOBrack-91]
+	_ = x[TokenCBrack-93]
+	_ = x[TokenOParen-40]
+	_ = x[TokenCParen-41]
+	_ = x[TokenOQuote-171]
+	_ = x[TokenCQuote-187]
+	_ = x[TokenOHeredoc-72]
+	_ = x[TokenCHeredoc-104]
+	_ = x[TokenStar-42]
+	_ = x[TokenSlash-47]
+	_ = x[TokenPlus-43]
+	_ = x[TokenMinus-45]
+	_ = x[TokenPercent-37]
+	_ = x[TokenEqual-61]
+	_ = x[TokenEqualOp-8788]
+	_ = x[TokenNotEqual-8800]
+	_ = x[TokenLessThan-60]
+	_ = x[TokenLessThanEq-8804]
+	_ = x[TokenGreaterThan-62]
+	_ = x[TokenGreaterThanEq-8805]
+	_ = x[TokenAnd-8743]
+	_ = x[TokenOr-8744]
+	_ = x[TokenBang-33]
+	_ = x[TokenDot-46]
+	_ = x[TokenComma-44]
+	_ = x[TokenEllipsis-8230]
+	_ = x[TokenFatArrow-8658]
+	_ = x[TokenQuestion-63]
+	_ = x[TokenColon-58]
+	_ = x[TokenTemplateInterp-8747]
+	_ = x[TokenTemplateControl-955]
+	_ = x[TokenTemplateSeqEnd-8718]
+	_ = x[TokenQuotedLit-81]
+	_ = x[TokenStringLit-83]
+	_ = x[TokenNumberLit-78]
+	_ = x[TokenIdent-73]
+	_ = x[TokenComment-67]
+	_ = x[TokenNewline-10]
+	_ = x[TokenEOF-9220]
+	_ = x[TokenBitwiseAnd-38]
+	_ = x[TokenBitwiseOr-124]
+	_ = x[TokenBitwiseNot-126]
+	_ = x[TokenBitwiseXor-94]
+	_ = x[TokenStarStar-10138]
+	_ = x[TokenApostrophe-39]
+	_ = x[TokenBacktick-96]
+	_ = x[TokenSemicolon-59]
+	_ = x[TokenTabs-9225]
+	_ = x[TokenInvalid-65533]
+	_ = x[TokenBadUTF8-128169]
+	_ = x[TokenQuotedNewline-9252]
+	_ = x[TokenNil-0]
+}
+
+const _TokenType_name = "TokenNilTokenNewlineTokenBangTokenPercentTokenBitwiseAndTokenApostropheTokenOParenTokenCParenTokenStarTokenPlusTokenCommaTokenMinusTokenDotTokenSlashTokenColonTokenSemicolonTokenLessThanTokenEqualTokenGreaterThanTokenQuestionTokenCommentTokenOHeredocTokenIdentTokenNumberLitTokenQuotedLitTokenStringLitTokenOBrackTokenCBrackTokenBitwiseXorTokenBacktickTokenCHeredocTokenOBraceTokenBitwiseOrTokenCBraceTokenBitwiseNotTokenOQuoteTokenCQuoteTokenTemplateControlTokenEllipsisTokenFatArrowTokenTemplateSeqEndTokenAndTokenOrTokenTemplateInterpTokenEqualOpTokenNotEqualTokenLessThanEqTokenGreaterThanEqTokenEOFTokenTabsTokenQuotedNewlineTokenStarStarTokenInvalidTokenBadUTF8"
+
+var _TokenType_map = map[TokenType]string{
+	0:      _TokenType_name[0:8],
+	10:     _TokenType_name[8:20],
+	33:     _TokenType_name[20:29],
+	37:     _TokenType_name[29:41],
+	38:     _TokenType_name[41:56],
+	39:     _TokenType_name[56:71],
+	40:     _TokenType_name[71:82],
+	41:     _TokenType_name[82:93],
+	42:     _TokenType_name[93:102],
+	43:     _TokenType_name[102:111],
+	44:     _TokenType_name[111:121],
+	45:     _TokenType_name[121:131],
+	46:     _TokenType_name[131:139],
+	47:     _TokenType_name[139:149],
+	58:     _TokenType_name[149:159],
+	59:     _TokenType_name[159:173],
+	60:     _TokenType_name[173:186],
+	61:     _TokenType_name[186:196],
+	62:     _TokenType_name[196:212],
+	63:     _TokenType_name[212:225],
+	67:     _TokenType_name[225:237],
+	72:     _TokenType_name[237:250],
+	73:     _TokenType_name[250:260],
+	78:     _TokenType_name[260:274],
+	81:     _TokenType_name[274:288],
+	83:     _TokenType_name[288:302],
+	91:     _TokenType_name[302:313],
+	93:     _TokenType_name[313:324],
+	94:     _TokenType_name[324:339],
+	96:     _TokenType_name[339:352],
+	104:    _TokenType_name[352:365],
+	123:    _TokenType_name[365:376],
+	124:    _TokenType_name[376:390],
+	125:    _TokenType_name[390:401],
+	126:    _TokenType_name[401:416],
+	171:    _TokenType_name[416:427],
+	187:    _TokenType_name[427:438],
+	955:    _TokenType_name[438:458],
+	8230:   _TokenType_name[458:471],
+	8658:   _TokenType_name[471:484],
+	8718:   _TokenType_name[484:503],
+	8743:   _TokenType_name[503:511],
+	8744:   _TokenType_name[511:518],
+	8747:   _TokenType_name[518:537],
+	8788:   _TokenType_name[537:549],
+	8800:   _TokenType_name[549:562],
+	8804:   _TokenType_name[562:577],
+	8805:   _TokenType_name[577:595],
+	9220:   _TokenType_name[595:603],
+	9225:   _TokenType_name[603:612],
+	9252:   _TokenType_name[612:630],
+	10138:  _TokenType_name[630:643],
+	65533:  _TokenType_name[643:655],
+	128169: _TokenType_name[655:667],
+}
+
+func (i TokenType) String() string {
+	if str, ok := _TokenType_map[i]; ok {
+		return str
+	}
+	return "TokenType(" + strconv.FormatInt(int64(i), 10) + ")"
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode2ragel.rb b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode2ragel.rb
new file mode 100644
index 00000000..422e4e5c
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode2ragel.rb
@@ -0,0 +1,335 @@
+#!/usr/bin/env ruby
+#
+# This scripted has been updated to accept more command-line arguments:
+#
+#    -u, --url                        URL to process
+#    -m, --machine                    Machine name
+#    -p, --properties                 Properties to add to the machine
+#    -o, --output                     Write output to file
+#
+# Updated by: Marty Schoch <marty.schoch@gmail.com>
+# 
+# This script uses the unicode spec to generate a Ragel state machine
+# that recognizes unicode alphanumeric characters.  It generates 5
+# character classes: uupper, ulower, ualpha, udigit, and ualnum.
+# Currently supported encodings are UTF-8 [default] and UCS-4.
+#
+# Usage: unicode2ragel.rb [options]
+#    -e, --encoding [ucs4 | utf8]     Data encoding
+#    -h, --help                       Show this message
+#
+# This script was originally written as part of the Ferret search
+# engine library.
+#
+# Author: Rakan El-Khalil <rakan@well.com>
+
+require 'optparse'
+require 'open-uri'
+
+ENCODINGS = [ :utf8, :ucs4 ]
+ALPHTYPES = { :utf8 => "byte", :ucs4 => "rune" }
+DEFAULT_CHART_URL = "http://www.unicode.org/Public/5.1.0/ucd/DerivedCoreProperties.txt"
+DEFAULT_MACHINE_NAME= "WChar"
+
+###
+# Display vars & default option
+
+TOTAL_WIDTH = 80
+RANGE_WIDTH = 23
+@encoding = :utf8
+@chart_url = DEFAULT_CHART_URL
+machine_name = DEFAULT_MACHINE_NAME
+properties = []
+@output = $stdout
+
+###
+# Option parsing
+
+cli_opts = OptionParser.new do |opts|
+  opts.on("-e", "--encoding [ucs4 | utf8]", "Data encoding") do |o|
+    @encoding = o.downcase.to_sym
+  end
+  opts.on("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+  opts.on("-u", "--url URL", "URL to process") do |o|
+    @chart_url = o 
+  end
+  opts.on("-m", "--machine MACHINE_NAME", "Machine name") do |o|
+    machine_name = o
+  end
+  opts.on("-p", "--properties x,y,z", Array, "Properties to add to machine") do |o|
+    properties = o
+  end
+  opts.on("-o", "--output FILE", "output file") do |o|
+    @output = File.new(o, "w+")
+  end
+end
+
+cli_opts.parse(ARGV)
+unless ENCODINGS.member? @encoding
+  puts "Invalid encoding: #{@encoding}"
+  puts cli_opts
+  exit
+end
+
+##
+# Downloads the document at url and yields every alpha line's hex
+# range and description.
+
+def each_alpha( url, property ) 
+  open( url ) do |file|
+    file.each_line do |line|
+      next if line =~ /^#/;
+      next if line !~ /; #{property} #/;
+
+      range, description = line.split(/;/)
+      range.strip!
+      description.gsub!(/.*#/, '').strip!
+
+      if range =~ /\.\./
+           start, stop = range.split '..'
+      else start = stop = range
+      end
+
+      yield start.hex .. stop.hex, description
+    end
+  end
+end
+
+###
+# Formats to hex at minimum width
+
+def to_hex( n )
+  r = "%0X" % n
+  r = "0#{r}" unless (r.length % 2).zero?
+  r
+end
+
+###
+# UCS4 is just a straight hex conversion of the unicode codepoint.
+
+def to_ucs4( range )
+  rangestr  =   "0x" + to_hex(range.begin)
+  rangestr << "..0x" + to_hex(range.end) if range.begin != range.end
+  [ rangestr ]
+end
+
+##
+# 0x00     - 0x7f     -> 0zzzzzzz[7]
+# 0x80     - 0x7ff    -> 110yyyyy[5] 10zzzzzz[6]
+# 0x800    - 0xffff   -> 1110xxxx[4] 10yyyyyy[6] 10zzzzzz[6]
+# 0x010000 - 0x10ffff -> 11110www[3] 10xxxxxx[6] 10yyyyyy[6] 10zzzzzz[6] 
+
+UTF8_BOUNDARIES = [0x7f, 0x7ff, 0xffff, 0x10ffff]
+
+def to_utf8_enc( n )
+  r = 0
+  if n <= 0x7f
+    r = n
+  elsif n <= 0x7ff
+    y = 0xc0 | (n >> 6)
+    z = 0x80 | (n & 0x3f)
+    r = y << 8 | z
+  elsif n <= 0xffff
+    x = 0xe0 | (n >> 12)
+    y = 0x80 | (n >>  6) & 0x3f
+    z = 0x80 |  n        & 0x3f
+    r = x << 16 | y << 8 | z
+  elsif n <= 0x10ffff
+    w = 0xf0 | (n >> 18)
+    x = 0x80 | (n >> 12) & 0x3f
+    y = 0x80 | (n >>  6) & 0x3f
+    z = 0x80 |  n        & 0x3f
+    r = w << 24 | x << 16 | y << 8 | z
+  end
+
+  to_hex(r)
+end
+
+def from_utf8_enc( n )
+  n = n.hex
+  r = 0
+  if n <= 0x7f
+    r = n
+  elsif n <= 0xdfff
+    y = (n >> 8) & 0x1f
+    z =  n       & 0x3f
+    r = y << 6 | z
+  elsif n <= 0xefffff
+    x = (n >> 16) & 0x0f
+    y = (n >>  8) & 0x3f
+    z =  n        & 0x3f
+    r = x << 10 | y << 6 | z
+  elsif n <= 0xf7ffffff
+    w = (n >> 24) & 0x07
+    x = (n >> 16) & 0x3f
+    y = (n >>  8) & 0x3f
+    z =  n        & 0x3f
+    r = w << 18 | x << 12 | y << 6 | z
+  end
+  r
+end
+
+###
+# Given a range, splits it up into ranges that can be continuously
+# encoded into utf8.  Eg: 0x00 .. 0xff => [0x00..0x7f, 0x80..0xff]
+# This is not strictly needed since the current [5.1] unicode standard
+# doesn't have ranges that straddle utf8 boundaries.  This is included
+# for completeness as there is no telling if that will ever change.
+
+def utf8_ranges( range )
+  ranges = []
+  UTF8_BOUNDARIES.each do |max|
+    if range.begin <= max
+      if range.end <= max
+        ranges << range
+        return ranges
+      end
+
+      ranges << (range.begin .. max)
+      range = (max + 1) .. range.end
+    end
+  end
+  ranges
+end
+
+def build_range( start, stop )
+  size = start.size/2
+  left = size - 1
+  return [""] if size < 1
+
+  a = start[0..1]
+  b = stop[0..1]
+
+  ###
+  # Shared prefix
+
+  if a == b
+    return build_range(start[2..-1], stop[2..-1]).map do |elt|
+      "0x#{a} " + elt
+    end
+  end
+
+  ###
+  # Unshared prefix, end of run
+
+  return ["0x#{a}..0x#{b} "] if left.zero?
+  
+  ###
+  # Unshared prefix, not end of run
+  # Range can be 0x123456..0x56789A
+  # Which is equivalent to:
+  #     0x123456 .. 0x12FFFF
+  #     0x130000 .. 0x55FFFF
+  #     0x560000 .. 0x56789A
+
+  ret = []
+  ret << build_range(start, a + "FF" * left)
+
+  ###
+  # Only generate middle range if need be.
+
+  if a.hex+1 != b.hex
+    max = to_hex(b.hex - 1)
+    max = "FF" if b == "FF"
+    ret << "0x#{to_hex(a.hex+1)}..0x#{max} " + "0x00..0xFF " * left
+  end
+
+  ###
+  # Don't generate last range if it is covered by first range
+  
+  ret << build_range(b + "00" * left, stop) unless b == "FF"
+  ret.flatten!
+end
+
+def to_utf8( range )
+  utf8_ranges( range ).map do |r|   
+    begin_enc = to_utf8_enc(r.begin)
+    end_enc = to_utf8_enc(r.end)
+    build_range begin_enc, end_enc
+  end.flatten!
+end
+
+##
+# Perform a 3-way comparison of the number of codepoints advertised by
+# the unicode spec for the given range, the originally parsed range,
+# and the resulting utf8 encoded range.
+
+def count_codepoints( code )
+  code.split(' ').inject(1) do |acc, elt|
+    if elt =~ /0x(.+)\.\.0x(.+)/
+      if @encoding == :utf8
+        acc * (from_utf8_enc($2) - from_utf8_enc($1) + 1)
+      else
+        acc * ($2.hex - $1.hex + 1)
+      end
+    else
+      acc
+    end
+  end
+end
+
+def is_valid?( range, desc, codes )
+  spec_count  = 1
+  spec_count  = $1.to_i if desc =~ /\[(\d+)\]/
+  range_count = range.end - range.begin + 1
+
+  sum = codes.inject(0) { |acc, elt| acc + count_codepoints(elt) }
+  sum == spec_count and sum == range_count
+end
+
+##
+# Generate the state maching to stdout
+
+def generate_machine( name, property )
+  pipe = " "
+  @output.puts "    #{name} = "
+  each_alpha( @chart_url, property ) do |range, desc|
+
+    codes = (@encoding == :ucs4) ? to_ucs4(range) : to_utf8(range)
+
+    #raise "Invalid encoding of range #{range}: #{codes.inspect}" unless 
+    #  is_valid? range, desc, codes
+
+    range_width = codes.map { |a| a.size }.max
+    range_width = RANGE_WIDTH if range_width < RANGE_WIDTH
+
+    desc_width  = TOTAL_WIDTH - RANGE_WIDTH - 11
+    desc_width -= (range_width - RANGE_WIDTH) if range_width > RANGE_WIDTH
+
+    if desc.size > desc_width
+      desc = desc[0..desc_width - 4] + "..."
+    end
+
+    codes.each_with_index do |r, idx|
+      desc = "" unless idx.zero?
+      code = "%-#{range_width}s" % r
+      @output.puts "      #{pipe} #{code} ##{desc}"
+      pipe = "|"
+    end
+  end
+  @output.puts "      ;"
+  @output.puts ""
+end
+
+@output.puts <<EOF
+# The following Ragel file was autogenerated with #{$0} 
+# from: #{@chart_url}
+#
+# It defines #{properties}.
+#
+# To use this, make sure that your alphtype is set to #{ALPHTYPES[@encoding]},
+# and that your input is in #{@encoding}.
+
+%%{
+    machine #{machine_name};
+    
+EOF
+
+properties.each { |x| generate_machine( x, x ) }
+
+@output.puts <<EOF
+}%%
+EOF
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode_derived.rl b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode_derived.rl
new file mode 100644
index 00000000..612ad622
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode_derived.rl
@@ -0,0 +1,2135 @@
+# The following Ragel file was autogenerated with unicode2ragel.rb 
+# from: http://www.unicode.org/Public/9.0.0/ucd/DerivedCoreProperties.txt
+#
+# It defines ["ID_Start", "ID_Continue"].
+#
+# To use this, make sure that your alphtype is set to byte,
+# and that your input is in utf8.
+
+%%{
+    machine UnicodeDerived;
+    
+    ID_Start = 
+        0x41..0x5A              #L&  [26] LATIN CAPITAL LETTER A..LATIN CAPI...
+      | 0x61..0x7A              #L&  [26] LATIN SMALL LETTER A..LATIN SMALL ...
+      | 0xC2 0xAA               #Lo       FEMININE ORDINAL INDICATOR
+      | 0xC2 0xB5               #L&       MICRO SIGN
+      | 0xC2 0xBA               #Lo       MASCULINE ORDINAL INDICATOR
+      | 0xC3 0x80..0x96         #L&  [23] LATIN CAPITAL LETTER A WITH GRAVE....
+      | 0xC3 0x98..0xB6         #L&  [31] LATIN CAPITAL LETTER O WITH STROKE...
+      | 0xC3 0xB8..0xFF         #L& [195] LATIN SMALL LETTER O WITH STROKE.....
+      | 0xC4..0xC5 0x00..0xFF   #
+      | 0xC6 0x00..0xBA         #
+      | 0xC6 0xBB               #Lo       LATIN LETTER TWO WITH STROKE
+      | 0xC6 0xBC..0xBF         #L&   [4] LATIN CAPITAL LETTER TONE FIVE..LA...
+      | 0xC7 0x80..0x83         #Lo   [4] LATIN LETTER DENTAL CLICK..LATIN L...
+      | 0xC7 0x84..0xFF         #L& [208] LATIN CAPITAL LETTER DZ WITH CARON...
+      | 0xC8..0xC9 0x00..0xFF   #
+      | 0xCA 0x00..0x93         #
+      | 0xCA 0x94               #Lo       LATIN LETTER GLOTTAL STOP
+      | 0xCA 0x95..0xAF         #L&  [27] LATIN LETTER PHARYNGEAL VOICED FRI...
+      | 0xCA 0xB0..0xFF         #Lm  [18] MODIFIER LETTER SMALL H..MODIFIER ...
+      | 0xCB 0x00..0x81         #
+      | 0xCB 0x86..0x91         #Lm  [12] MODIFIER LETTER CIRCUMFLEX ACCENT....
+      | 0xCB 0xA0..0xA4         #Lm   [5] MODIFIER LETTER SMALL GAMMA..MODIF...
+      | 0xCB 0xAC               #Lm       MODIFIER LETTER VOICING
+      | 0xCB 0xAE               #Lm       MODIFIER LETTER DOUBLE APOSTROPHE
+      | 0xCD 0xB0..0xB3         #L&   [4] GREEK CAPITAL LETTER HETA..GREEK S...
+      | 0xCD 0xB4               #Lm       GREEK NUMERAL SIGN
+      | 0xCD 0xB6..0xB7         #L&   [2] GREEK CAPITAL LETTER PAMPHYLIAN DI...
+      | 0xCD 0xBA               #Lm       GREEK YPOGEGRAMMENI
+      | 0xCD 0xBB..0xBD         #L&   [3] GREEK SMALL REVERSED LUNATE SIGMA ...
+      | 0xCD 0xBF               #L&       GREEK CAPITAL LETTER YOT
+      | 0xCE 0x86               #L&       GREEK CAPITAL LETTER ALPHA WITH TONOS
+      | 0xCE 0x88..0x8A         #L&   [3] GREEK CAPITAL LETTER EPSILON WITH ...
+      | 0xCE 0x8C               #L&       GREEK CAPITAL LETTER OMICRON WITH ...
+      | 0xCE 0x8E..0xA1         #L&  [20] GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xCE 0xA3..0xFF         #L&  [83] GREEK CAPITAL LETTER SIGMA..GREEK ...
+      | 0xCF 0x00..0xB5         #
+      | 0xCF 0xB7..0xFF         #L& [139] GREEK CAPITAL LETTER SHO..CYRILLIC...
+      | 0xD0..0xD1 0x00..0xFF   #
+      | 0xD2 0x00..0x81         #
+      | 0xD2 0x8A..0xFF         #L& [166] CYRILLIC CAPITAL LETTER SHORT I WI...
+      | 0xD3..0xD3 0x00..0xFF   #
+      | 0xD4 0x00..0xAF         #
+      | 0xD4 0xB1..0xFF         #L&  [38] ARMENIAN CAPITAL LETTER AYB..ARMEN...
+      | 0xD5 0x00..0x96         #
+      | 0xD5 0x99               #Lm       ARMENIAN MODIFIER LETTER LEFT HALF...
+      | 0xD5 0xA1..0xFF         #L&  [39] ARMENIAN SMALL LETTER AYB..ARMENIA...
+      | 0xD6 0x00..0x87         #
+      | 0xD7 0x90..0xAA         #Lo  [27] HEBREW LETTER ALEF..HEBREW LETTER TAV
+      | 0xD7 0xB0..0xB2         #Lo   [3] HEBREW LIGATURE YIDDISH DOUBLE VAV...
+      | 0xD8 0xA0..0xBF         #Lo  [32] ARABIC LETTER KASHMIRI YEH..ARABIC...
+      | 0xD9 0x80               #Lm       ARABIC TATWEEL
+      | 0xD9 0x81..0x8A         #Lo  [10] ARABIC LETTER FEH..ARABIC LETTER YEH
+      | 0xD9 0xAE..0xAF         #Lo   [2] ARABIC LETTER DOTLESS BEH..ARABIC ...
+      | 0xD9 0xB1..0xFF         #Lo  [99] ARABIC LETTER ALEF WASLA..ARABIC L...
+      | 0xDA..0xDA 0x00..0xFF   #
+      | 0xDB 0x00..0x93         #
+      | 0xDB 0x95               #Lo       ARABIC LETTER AE
+      | 0xDB 0xA5..0xA6         #Lm   [2] ARABIC SMALL WAW..ARABIC SMALL YEH
+      | 0xDB 0xAE..0xAF         #Lo   [2] ARABIC LETTER DAL WITH INVERTED V....
+      | 0xDB 0xBA..0xBC         #Lo   [3] ARABIC LETTER SHEEN WITH DOT BELOW...
+      | 0xDB 0xBF               #Lo       ARABIC LETTER HEH WITH INVERTED V
+      | 0xDC 0x90               #Lo       SYRIAC LETTER ALAPH
+      | 0xDC 0x92..0xAF         #Lo  [30] SYRIAC LETTER BETH..SYRIAC LETTER ...
+      | 0xDD 0x8D..0xFF         #Lo  [89] SYRIAC LETTER SOGDIAN ZHAIN..THAAN...
+      | 0xDE 0x00..0xA5         #
+      | 0xDE 0xB1               #Lo       THAANA LETTER NAA
+      | 0xDF 0x8A..0xAA         #Lo  [33] NKO LETTER A..NKO LETTER JONA RA
+      | 0xDF 0xB4..0xB5         #Lm   [2] NKO HIGH TONE APOSTROPHE..NKO LOW ...
+      | 0xDF 0xBA               #Lm       NKO LAJANYALAN
+      | 0xE0 0xA0 0x80..0x95    #Lo  [22] SAMARITAN LETTER ALAF..SAMARITAN L...
+      | 0xE0 0xA0 0x9A          #Lm       SAMARITAN MODIFIER LETTER EPENTHET...
+      | 0xE0 0xA0 0xA4          #Lm       SAMARITAN MODIFIER LETTER SHORT A
+      | 0xE0 0xA0 0xA8          #Lm       SAMARITAN MODIFIER LETTER I
+      | 0xE0 0xA1 0x80..0x98    #Lo  [25] MANDAIC LETTER HALQA..MANDAIC LETT...
+      | 0xE0 0xA2 0xA0..0xB4    #Lo  [21] ARABIC LETTER BEH WITH SMALL V BEL...
+      | 0xE0 0xA2 0xB6..0xBD    #Lo   [8] ARABIC LETTER BEH WITH SMALL MEEM ...
+      | 0xE0 0xA4 0x84..0xB9    #Lo  [54] DEVANAGARI LETTER SHORT A..DEVANAG...
+      | 0xE0 0xA4 0xBD          #Lo       DEVANAGARI SIGN AVAGRAHA
+      | 0xE0 0xA5 0x90          #Lo       DEVANAGARI OM
+      | 0xE0 0xA5 0x98..0xA1    #Lo  [10] DEVANAGARI LETTER QA..DEVANAGARI L...
+      | 0xE0 0xA5 0xB1          #Lm       DEVANAGARI SIGN HIGH SPACING DOT
+      | 0xE0 0xA5 0xB2..0xFF    #Lo  [15] DEVANAGARI LETTER CANDRA A..BENGAL...
+      | 0xE0 0xA6 0x00..0x80    #
+      | 0xE0 0xA6 0x85..0x8C    #Lo   [8] BENGALI LETTER A..BENGALI LETTER V...
+      | 0xE0 0xA6 0x8F..0x90    #Lo   [2] BENGALI LETTER E..BENGALI LETTER AI
+      | 0xE0 0xA6 0x93..0xA8    #Lo  [22] BENGALI LETTER O..BENGALI LETTER NA
+      | 0xE0 0xA6 0xAA..0xB0    #Lo   [7] BENGALI LETTER PA..BENGALI LETTER RA
+      | 0xE0 0xA6 0xB2          #Lo       BENGALI LETTER LA
+      | 0xE0 0xA6 0xB6..0xB9    #Lo   [4] BENGALI LETTER SHA..BENGALI LETTER HA
+      | 0xE0 0xA6 0xBD          #Lo       BENGALI SIGN AVAGRAHA
+      | 0xE0 0xA7 0x8E          #Lo       BENGALI LETTER KHANDA TA
+      | 0xE0 0xA7 0x9C..0x9D    #Lo   [2] BENGALI LETTER RRA..BENGALI LETTER...
+      | 0xE0 0xA7 0x9F..0xA1    #Lo   [3] BENGALI LETTER YYA..BENGALI LETTER...
+      | 0xE0 0xA7 0xB0..0xB1    #Lo   [2] BENGALI LETTER RA WITH MIDDLE DIAG...
+      | 0xE0 0xA8 0x85..0x8A    #Lo   [6] GURMUKHI LETTER A..GURMUKHI LETTER UU
+      | 0xE0 0xA8 0x8F..0x90    #Lo   [2] GURMUKHI LETTER EE..GURMUKHI LETTE...
+      | 0xE0 0xA8 0x93..0xA8    #Lo  [22] GURMUKHI LETTER OO..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xAA..0xB0    #Lo   [7] GURMUKHI LETTER PA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xB2..0xB3    #Lo   [2] GURMUKHI LETTER LA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xB5..0xB6    #Lo   [2] GURMUKHI LETTER VA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xB8..0xB9    #Lo   [2] GURMUKHI LETTER SA..GURMUKHI LETTE...
+      | 0xE0 0xA9 0x99..0x9C    #Lo   [4] GURMUKHI LETTER KHHA..GURMUKHI LET...
+      | 0xE0 0xA9 0x9E          #Lo       GURMUKHI LETTER FA
+      | 0xE0 0xA9 0xB2..0xB4    #Lo   [3] GURMUKHI IRI..GURMUKHI EK ONKAR
+      | 0xE0 0xAA 0x85..0x8D    #Lo   [9] GUJARATI LETTER A..GUJARATI VOWEL ...
+      | 0xE0 0xAA 0x8F..0x91    #Lo   [3] GUJARATI LETTER E..GUJARATI VOWEL ...
+      | 0xE0 0xAA 0x93..0xA8    #Lo  [22] GUJARATI LETTER O..GUJARATI LETTER NA
+      | 0xE0 0xAA 0xAA..0xB0    #Lo   [7] GUJARATI LETTER PA..GUJARATI LETTE...
+      | 0xE0 0xAA 0xB2..0xB3    #Lo   [2] GUJARATI LETTER LA..GUJARATI LETTE...
+      | 0xE0 0xAA 0xB5..0xB9    #Lo   [5] GUJARATI LETTER VA..GUJARATI LETTE...
+      | 0xE0 0xAA 0xBD          #Lo       GUJARATI SIGN AVAGRAHA
+      | 0xE0 0xAB 0x90          #Lo       GUJARATI OM
+      | 0xE0 0xAB 0xA0..0xA1    #Lo   [2] GUJARATI LETTER VOCALIC RR..GUJARA...
+      | 0xE0 0xAB 0xB9          #Lo       GUJARATI LETTER ZHA
+      | 0xE0 0xAC 0x85..0x8C    #Lo   [8] ORIYA LETTER A..ORIYA LETTER VOCAL...
+      | 0xE0 0xAC 0x8F..0x90    #Lo   [2] ORIYA LETTER E..ORIYA LETTER AI
+      | 0xE0 0xAC 0x93..0xA8    #Lo  [22] ORIYA LETTER O..ORIYA LETTER NA
+      | 0xE0 0xAC 0xAA..0xB0    #Lo   [7] ORIYA LETTER PA..ORIYA LETTER RA
+      | 0xE0 0xAC 0xB2..0xB3    #Lo   [2] ORIYA LETTER LA..ORIYA LETTER LLA
+      | 0xE0 0xAC 0xB5..0xB9    #Lo   [5] ORIYA LETTER VA..ORIYA LETTER HA
+      | 0xE0 0xAC 0xBD          #Lo       ORIYA SIGN AVAGRAHA
+      | 0xE0 0xAD 0x9C..0x9D    #Lo   [2] ORIYA LETTER RRA..ORIYA LETTER RHA
+      | 0xE0 0xAD 0x9F..0xA1    #Lo   [3] ORIYA LETTER YYA..ORIYA LETTER VOC...
+      | 0xE0 0xAD 0xB1          #Lo       ORIYA LETTER WA
+      | 0xE0 0xAE 0x83          #Lo       TAMIL SIGN VISARGA
+      | 0xE0 0xAE 0x85..0x8A    #Lo   [6] TAMIL LETTER A..TAMIL LETTER UU
+      | 0xE0 0xAE 0x8E..0x90    #Lo   [3] TAMIL LETTER E..TAMIL LETTER AI
+      | 0xE0 0xAE 0x92..0x95    #Lo   [4] TAMIL LETTER O..TAMIL LETTER KA
+      | 0xE0 0xAE 0x99..0x9A    #Lo   [2] TAMIL LETTER NGA..TAMIL LETTER CA
+      | 0xE0 0xAE 0x9C          #Lo       TAMIL LETTER JA
+      | 0xE0 0xAE 0x9E..0x9F    #Lo   [2] TAMIL LETTER NYA..TAMIL LETTER TTA
+      | 0xE0 0xAE 0xA3..0xA4    #Lo   [2] TAMIL LETTER NNA..TAMIL LETTER TA
+      | 0xE0 0xAE 0xA8..0xAA    #Lo   [3] TAMIL LETTER NA..TAMIL LETTER PA
+      | 0xE0 0xAE 0xAE..0xB9    #Lo  [12] TAMIL LETTER MA..TAMIL LETTER HA
+      | 0xE0 0xAF 0x90          #Lo       TAMIL OM
+      | 0xE0 0xB0 0x85..0x8C    #Lo   [8] TELUGU LETTER A..TELUGU LETTER VOC...
+      | 0xE0 0xB0 0x8E..0x90    #Lo   [3] TELUGU LETTER E..TELUGU LETTER AI
+      | 0xE0 0xB0 0x92..0xA8    #Lo  [23] TELUGU LETTER O..TELUGU LETTER NA
+      | 0xE0 0xB0 0xAA..0xB9    #Lo  [16] TELUGU LETTER PA..TELUGU LETTER HA
+      | 0xE0 0xB0 0xBD          #Lo       TELUGU SIGN AVAGRAHA
+      | 0xE0 0xB1 0x98..0x9A    #Lo   [3] TELUGU LETTER TSA..TELUGU LETTER RRRA
+      | 0xE0 0xB1 0xA0..0xA1    #Lo   [2] TELUGU LETTER VOCALIC RR..TELUGU L...
+      | 0xE0 0xB2 0x80          #Lo       KANNADA SIGN SPACING CANDRABINDU
+      | 0xE0 0xB2 0x85..0x8C    #Lo   [8] KANNADA LETTER A..KANNADA LETTER V...
+      | 0xE0 0xB2 0x8E..0x90    #Lo   [3] KANNADA LETTER E..KANNADA LETTER AI
+      | 0xE0 0xB2 0x92..0xA8    #Lo  [23] KANNADA LETTER O..KANNADA LETTER NA
+      | 0xE0 0xB2 0xAA..0xB3    #Lo  [10] KANNADA LETTER PA..KANNADA LETTER LLA
+      | 0xE0 0xB2 0xB5..0xB9    #Lo   [5] KANNADA LETTER VA..KANNADA LETTER HA
+      | 0xE0 0xB2 0xBD          #Lo       KANNADA SIGN AVAGRAHA
+      | 0xE0 0xB3 0x9E          #Lo       KANNADA LETTER FA
+      | 0xE0 0xB3 0xA0..0xA1    #Lo   [2] KANNADA LETTER VOCALIC RR..KANNADA...
+      | 0xE0 0xB3 0xB1..0xB2    #Lo   [2] KANNADA SIGN JIHVAMULIYA..KANNADA ...
+      | 0xE0 0xB4 0x85..0x8C    #Lo   [8] MALAYALAM LETTER A..MALAYALAM LETT...
+      | 0xE0 0xB4 0x8E..0x90    #Lo   [3] MALAYALAM LETTER E..MALAYALAM LETT...
+      | 0xE0 0xB4 0x92..0xBA    #Lo  [41] MALAYALAM LETTER O..MALAYALAM LETT...
+      | 0xE0 0xB4 0xBD          #Lo       MALAYALAM SIGN AVAGRAHA
+      | 0xE0 0xB5 0x8E          #Lo       MALAYALAM LETTER DOT REPH
+      | 0xE0 0xB5 0x94..0x96    #Lo   [3] MALAYALAM LETTER CHILLU M..MALAYAL...
+      | 0xE0 0xB5 0x9F..0xA1    #Lo   [3] MALAYALAM LETTER ARCHAIC II..MALAY...
+      | 0xE0 0xB5 0xBA..0xBF    #Lo   [6] MALAYALAM LETTER CHILLU NN..MALAYA...
+      | 0xE0 0xB6 0x85..0x96    #Lo  [18] SINHALA LETTER AYANNA..SINHALA LET...
+      | 0xE0 0xB6 0x9A..0xB1    #Lo  [24] SINHALA LETTER ALPAPRAANA KAYANNA....
+      | 0xE0 0xB6 0xB3..0xBB    #Lo   [9] SINHALA LETTER SANYAKA DAYANNA..SI...
+      | 0xE0 0xB6 0xBD          #Lo       SINHALA LETTER DANTAJA LAYANNA
+      | 0xE0 0xB7 0x80..0x86    #Lo   [7] SINHALA LETTER VAYANNA..SINHALA LE...
+      | 0xE0 0xB8 0x81..0xB0    #Lo  [48] THAI CHARACTER KO KAI..THAI CHARAC...
+      | 0xE0 0xB8 0xB2..0xB3    #Lo   [2] THAI CHARACTER SARA AA..THAI CHARA...
+      | 0xE0 0xB9 0x80..0x85    #Lo   [6] THAI CHARACTER SARA E..THAI CHARAC...
+      | 0xE0 0xB9 0x86          #Lm       THAI CHARACTER MAIYAMOK
+      | 0xE0 0xBA 0x81..0x82    #Lo   [2] LAO LETTER KO..LAO LETTER KHO SUNG
+      | 0xE0 0xBA 0x84          #Lo       LAO LETTER KHO TAM
+      | 0xE0 0xBA 0x87..0x88    #Lo   [2] LAO LETTER NGO..LAO LETTER CO
+      | 0xE0 0xBA 0x8A          #Lo       LAO LETTER SO TAM
+      | 0xE0 0xBA 0x8D          #Lo       LAO LETTER NYO
+      | 0xE0 0xBA 0x94..0x97    #Lo   [4] LAO LETTER DO..LAO LETTER THO TAM
+      | 0xE0 0xBA 0x99..0x9F    #Lo   [7] LAO LETTER NO..LAO LETTER FO SUNG
+      | 0xE0 0xBA 0xA1..0xA3    #Lo   [3] LAO LETTER MO..LAO LETTER LO LING
+      | 0xE0 0xBA 0xA5          #Lo       LAO LETTER LO LOOT
+      | 0xE0 0xBA 0xA7          #Lo       LAO LETTER WO
+      | 0xE0 0xBA 0xAA..0xAB    #Lo   [2] LAO LETTER SO SUNG..LAO LETTER HO ...
+      | 0xE0 0xBA 0xAD..0xB0    #Lo   [4] LAO LETTER O..LAO VOWEL SIGN A
+      | 0xE0 0xBA 0xB2..0xB3    #Lo   [2] LAO VOWEL SIGN AA..LAO VOWEL SIGN AM
+      | 0xE0 0xBA 0xBD          #Lo       LAO SEMIVOWEL SIGN NYO
+      | 0xE0 0xBB 0x80..0x84    #Lo   [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI
+      | 0xE0 0xBB 0x86          #Lm       LAO KO LA
+      | 0xE0 0xBB 0x9C..0x9F    #Lo   [4] LAO HO NO..LAO LETTER KHMU NYO
+      | 0xE0 0xBC 0x80          #Lo       TIBETAN SYLLABLE OM
+      | 0xE0 0xBD 0x80..0x87    #Lo   [8] TIBETAN LETTER KA..TIBETAN LETTER JA
+      | 0xE0 0xBD 0x89..0xAC    #Lo  [36] TIBETAN LETTER NYA..TIBETAN LETTER...
+      | 0xE0 0xBE 0x88..0x8C    #Lo   [5] TIBETAN SIGN LCE TSA CAN..TIBETAN ...
+      | 0xE1 0x80 0x80..0xAA    #Lo  [43] MYANMAR LETTER KA..MYANMAR LETTER AU
+      | 0xE1 0x80 0xBF          #Lo       MYANMAR LETTER GREAT SA
+      | 0xE1 0x81 0x90..0x95    #Lo   [6] MYANMAR LETTER SHA..MYANMAR LETTER...
+      | 0xE1 0x81 0x9A..0x9D    #Lo   [4] MYANMAR LETTER MON NGA..MYANMAR LE...
+      | 0xE1 0x81 0xA1          #Lo       MYANMAR LETTER SGAW KAREN SHA
+      | 0xE1 0x81 0xA5..0xA6    #Lo   [2] MYANMAR LETTER WESTERN PWO KAREN T...
+      | 0xE1 0x81 0xAE..0xB0    #Lo   [3] MYANMAR LETTER EASTERN PWO KAREN N...
+      | 0xE1 0x81 0xB5..0xFF    #Lo  [13] MYANMAR LETTER SHAN KA..MYANMAR LE...
+      | 0xE1 0x82 0x00..0x81    #
+      | 0xE1 0x82 0x8E          #Lo       MYANMAR LETTER RUMAI PALAUNG FA
+      | 0xE1 0x82 0xA0..0xFF    #L&  [38] GEORGIAN CAPITAL LETTER AN..GEORGI...
+      | 0xE1 0x83 0x00..0x85    #
+      | 0xE1 0x83 0x87          #L&       GEORGIAN CAPITAL LETTER YN
+      | 0xE1 0x83 0x8D          #L&       GEORGIAN CAPITAL LETTER AEN
+      | 0xE1 0x83 0x90..0xBA    #Lo  [43] GEORGIAN LETTER AN..GEORGIAN LETTE...
+      | 0xE1 0x83 0xBC          #Lm       MODIFIER LETTER GEORGIAN NAR
+      | 0xE1 0x83 0xBD..0xFF        #Lo [332] GEORGIAN LETTER AEN..ETHIOPIC ...
+      | 0xE1 0x84..0x88 0x00..0xFF  #
+      | 0xE1 0x89 0x00..0x88        #
+      | 0xE1 0x89 0x8A..0x8D    #Lo   [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SY...
+      | 0xE1 0x89 0x90..0x96    #Lo   [7] ETHIOPIC SYLLABLE QHA..ETHIOPIC SY...
+      | 0xE1 0x89 0x98          #Lo       ETHIOPIC SYLLABLE QHWA
+      | 0xE1 0x89 0x9A..0x9D    #Lo   [4] ETHIOPIC SYLLABLE QHWI..ETHIOPIC S...
+      | 0xE1 0x89 0xA0..0xFF    #Lo  [41] ETHIOPIC SYLLABLE BA..ETHIOPIC SYL...
+      | 0xE1 0x8A 0x00..0x88    #
+      | 0xE1 0x8A 0x8A..0x8D    #Lo   [4] ETHIOPIC SYLLABLE XWI..ETHIOPIC SY...
+      | 0xE1 0x8A 0x90..0xB0    #Lo  [33] ETHIOPIC SYLLABLE NA..ETHIOPIC SYL...
+      | 0xE1 0x8A 0xB2..0xB5    #Lo   [4] ETHIOPIC SYLLABLE KWI..ETHIOPIC SY...
+      | 0xE1 0x8A 0xB8..0xBE    #Lo   [7] ETHIOPIC SYLLABLE KXA..ETHIOPIC SY...
+      | 0xE1 0x8B 0x80          #Lo       ETHIOPIC SYLLABLE KXWA
+      | 0xE1 0x8B 0x82..0x85    #Lo   [4] ETHIOPIC SYLLABLE KXWI..ETHIOPIC S...
+      | 0xE1 0x8B 0x88..0x96    #Lo  [15] ETHIOPIC SYLLABLE WA..ETHIOPIC SYL...
+      | 0xE1 0x8B 0x98..0xFF    #Lo  [57] ETHIOPIC SYLLABLE ZA..ETHIOPIC SYL...
+      | 0xE1 0x8C 0x00..0x90    #
+      | 0xE1 0x8C 0x92..0x95    #Lo   [4] ETHIOPIC SYLLABLE GWI..ETHIOPIC SY...
+      | 0xE1 0x8C 0x98..0xFF    #Lo  [67] ETHIOPIC SYLLABLE GGA..ETHIOPIC SY...
+      | 0xE1 0x8D 0x00..0x9A    #
+      | 0xE1 0x8E 0x80..0x8F    #Lo  [16] ETHIOPIC SYLLABLE SEBATBEIT MWA..E...
+      | 0xE1 0x8E 0xA0..0xFF    #L&  [86] CHEROKEE LETTER A..CHEROKEE LETTER MV
+      | 0xE1 0x8F 0x00..0xB5    #
+      | 0xE1 0x8F 0xB8..0xBD    #L&   [6] CHEROKEE SMALL LETTER YE..CHEROKEE...
+      | 0xE1 0x90 0x81..0xFF        #Lo [620] CANADIAN SYLLABICS E..CANADIAN...
+      | 0xE1 0x91..0x98 0x00..0xFF  #
+      | 0xE1 0x99 0x00..0xAC        #
+      | 0xE1 0x99 0xAF..0xBF    #Lo  [17] CANADIAN SYLLABICS QAI..CANADIAN S...
+      | 0xE1 0x9A 0x81..0x9A    #Lo  [26] OGHAM LETTER BEITH..OGHAM LETTER P...
+      | 0xE1 0x9A 0xA0..0xFF    #Lo  [75] RUNIC LETTER FEHU FEOH FE F..RUNIC...
+      | 0xE1 0x9B 0x00..0xAA    #
+      | 0xE1 0x9B 0xAE..0xB0    #Nl   [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHO...
+      | 0xE1 0x9B 0xB1..0xB8    #Lo   [8] RUNIC LETTER K..RUNIC LETTER FRANK...
+      | 0xE1 0x9C 0x80..0x8C    #Lo  [13] TAGALOG LETTER A..TAGALOG LETTER YA
+      | 0xE1 0x9C 0x8E..0x91    #Lo   [4] TAGALOG LETTER LA..TAGALOG LETTER HA
+      | 0xE1 0x9C 0xA0..0xB1    #Lo  [18] HANUNOO LETTER A..HANUNOO LETTER HA
+      | 0xE1 0x9D 0x80..0x91    #Lo  [18] BUHID LETTER A..BUHID LETTER HA
+      | 0xE1 0x9D 0xA0..0xAC    #Lo  [13] TAGBANWA LETTER A..TAGBANWA LETTER YA
+      | 0xE1 0x9D 0xAE..0xB0    #Lo   [3] TAGBANWA LETTER LA..TAGBANWA LETTE...
+      | 0xE1 0x9E 0x80..0xB3    #Lo  [52] KHMER LETTER KA..KHMER INDEPENDENT...
+      | 0xE1 0x9F 0x97          #Lm       KHMER SIGN LEK TOO
+      | 0xE1 0x9F 0x9C          #Lo       KHMER SIGN AVAKRAHASANYA
+      | 0xE1 0xA0 0xA0..0xFF    #Lo  [35] MONGOLIAN LETTER A..MONGOLIAN LETT...
+      | 0xE1 0xA1 0x00..0x82    #
+      | 0xE1 0xA1 0x83          #Lm       MONGOLIAN LETTER TODO LONG VOWEL SIGN
+      | 0xE1 0xA1 0x84..0xB7    #Lo  [52] MONGOLIAN LETTER TODO E..MONGOLIAN...
+      | 0xE1 0xA2 0x80..0x84    #Lo   [5] MONGOLIAN LETTER ALI GALI ANUSVARA...
+      | 0xE1 0xA2 0x85..0x86    #Mn   [2] MONGOLIAN LETTER ALI GALI BALUDA.....
+      | 0xE1 0xA2 0x87..0xA8    #Lo  [34] MONGOLIAN LETTER ALI GALI A..MONGO...
+      | 0xE1 0xA2 0xAA          #Lo       MONGOLIAN LETTER MANCHU ALI GALI LHA
+      | 0xE1 0xA2 0xB0..0xFF    #Lo  [70] CANADIAN SYLLABICS OY..CANADIAN SY...
+      | 0xE1 0xA3 0x00..0xB5    #
+      | 0xE1 0xA4 0x80..0x9E    #Lo  [31] LIMBU VOWEL-CARRIER LETTER..LIMBU ...
+      | 0xE1 0xA5 0x90..0xAD    #Lo  [30] TAI LE LETTER KA..TAI LE LETTER AI
+      | 0xE1 0xA5 0xB0..0xB4    #Lo   [5] TAI LE LETTER TONE-2..TAI LE LETTE...
+      | 0xE1 0xA6 0x80..0xAB    #Lo  [44] NEW TAI LUE LETTER HIGH QA..NEW TA...
+      | 0xE1 0xA6 0xB0..0xFF    #Lo  [26] NEW TAI LUE VOWEL SIGN VOWEL SHORT...
+      | 0xE1 0xA7 0x00..0x89    #
+      | 0xE1 0xA8 0x80..0x96    #Lo  [23] BUGINESE LETTER KA..BUGINESE LETTE...
+      | 0xE1 0xA8 0xA0..0xFF    #Lo  [53] TAI THAM LETTER HIGH KA..TAI THAM ...
+      | 0xE1 0xA9 0x00..0x94    #
+      | 0xE1 0xAA 0xA7          #Lm       TAI THAM SIGN MAI YAMOK
+      | 0xE1 0xAC 0x85..0xB3    #Lo  [47] BALINESE LETTER AKARA..BALINESE LE...
+      | 0xE1 0xAD 0x85..0x8B    #Lo   [7] BALINESE LETTER KAF SASAK..BALINES...
+      | 0xE1 0xAE 0x83..0xA0    #Lo  [30] SUNDANESE LETTER A..SUNDANESE LETT...
+      | 0xE1 0xAE 0xAE..0xAF    #Lo   [2] SUNDANESE LETTER KHA..SUNDANESE LE...
+      | 0xE1 0xAE 0xBA..0xFF    #Lo  [44] SUNDANESE AVAGRAHA..BATAK LETTER U
+      | 0xE1 0xAF 0x00..0xA5    #
+      | 0xE1 0xB0 0x80..0xA3    #Lo  [36] LEPCHA LETTER KA..LEPCHA LETTER A
+      | 0xE1 0xB1 0x8D..0x8F    #Lo   [3] LEPCHA LETTER TTA..LEPCHA LETTER DDA
+      | 0xE1 0xB1 0x9A..0xB7    #Lo  [30] OL CHIKI LETTER LA..OL CHIKI LETTE...
+      | 0xE1 0xB1 0xB8..0xBD    #Lm   [6] OL CHIKI MU TTUDDAG..OL CHIKI AHAD
+      | 0xE1 0xB2 0x80..0x88    #L&   [9] CYRILLIC SMALL LETTER ROUNDED VE.....
+      | 0xE1 0xB3 0xA9..0xAC    #Lo   [4] VEDIC SIGN ANUSVARA ANTARGOMUKHA.....
+      | 0xE1 0xB3 0xAE..0xB1    #Lo   [4] VEDIC SIGN HEXIFORM LONG ANUSVARA....
+      | 0xE1 0xB3 0xB5..0xB6    #Lo   [2] VEDIC SIGN JIHVAMULIYA..VEDIC SIGN...
+      | 0xE1 0xB4 0x80..0xAB    #L&  [44] LATIN LETTER SMALL CAPITAL A..CYRI...
+      | 0xE1 0xB4 0xAC..0xFF    #Lm  [63] MODIFIER LETTER CAPITAL A..GREEK S...
+      | 0xE1 0xB5 0x00..0xAA    #
+      | 0xE1 0xB5 0xAB..0xB7    #L&  [13] LATIN SMALL LETTER UE..LATIN SMALL...
+      | 0xE1 0xB5 0xB8          #Lm       MODIFIER LETTER CYRILLIC EN
+      | 0xE1 0xB5 0xB9..0xFF    #L&  [34] LATIN SMALL LETTER INSULAR G..LATI...
+      | 0xE1 0xB6 0x00..0x9A    #
+      | 0xE1 0xB6 0x9B..0xBF    #Lm  [37] MODIFIER LETTER SMALL TURNED ALPHA...
+      | 0xE1 0xB8 0x80..0xFF        #L& [278] LATIN CAPITAL LETTER A WITH RI...
+      | 0xE1 0xB9..0xBB 0x00..0xFF  #
+      | 0xE1 0xBC 0x00..0x95        #
+      | 0xE1 0xBC 0x98..0x9D    #L&   [6] GREEK CAPITAL LETTER EPSILON WITH ...
+      | 0xE1 0xBC 0xA0..0xFF    #L&  [38] GREEK SMALL LETTER ETA WITH PSILI....
+      | 0xE1 0xBD 0x00..0x85    #
+      | 0xE1 0xBD 0x88..0x8D    #L&   [6] GREEK CAPITAL LETTER OMICRON WITH ...
+      | 0xE1 0xBD 0x90..0x97    #L&   [8] GREEK SMALL LETTER UPSILON WITH PS...
+      | 0xE1 0xBD 0x99          #L&       GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBD 0x9B          #L&       GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBD 0x9D          #L&       GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBD 0x9F..0xBD    #L&  [31] GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBE 0x80..0xB4    #L&  [53] GREEK SMALL LETTER ALPHA WITH PSIL...
+      | 0xE1 0xBE 0xB6..0xBC    #L&   [7] GREEK SMALL LETTER ALPHA WITH PERI...
+      | 0xE1 0xBE 0xBE          #L&       GREEK PROSGEGRAMMENI
+      | 0xE1 0xBF 0x82..0x84    #L&   [3] GREEK SMALL LETTER ETA WITH VARIA ...
+      | 0xE1 0xBF 0x86..0x8C    #L&   [7] GREEK SMALL LETTER ETA WITH PERISP...
+      | 0xE1 0xBF 0x90..0x93    #L&   [4] GREEK SMALL LETTER IOTA WITH VRACH...
+      | 0xE1 0xBF 0x96..0x9B    #L&   [6] GREEK SMALL LETTER IOTA WITH PERIS...
+      | 0xE1 0xBF 0xA0..0xAC    #L&  [13] GREEK SMALL LETTER UPSILON WITH VR...
+      | 0xE1 0xBF 0xB2..0xB4    #L&   [3] GREEK SMALL LETTER OMEGA WITH VARI...
+      | 0xE1 0xBF 0xB6..0xBC    #L&   [7] GREEK SMALL LETTER OMEGA WITH PERI...
+      | 0xE2 0x81 0xB1          #Lm       SUPERSCRIPT LATIN SMALL LETTER I
+      | 0xE2 0x81 0xBF          #Lm       SUPERSCRIPT LATIN SMALL LETTER N
+      | 0xE2 0x82 0x90..0x9C    #Lm  [13] LATIN SUBSCRIPT SMALL LETTER A..LA...
+      | 0xE2 0x84 0x82          #L&       DOUBLE-STRUCK CAPITAL C
+      | 0xE2 0x84 0x87          #L&       EULER CONSTANT
+      | 0xE2 0x84 0x8A..0x93    #L&  [10] SCRIPT SMALL G..SCRIPT SMALL L
+      | 0xE2 0x84 0x95          #L&       DOUBLE-STRUCK CAPITAL N
+      | 0xE2 0x84 0x98          #Sm       SCRIPT CAPITAL P
+      | 0xE2 0x84 0x99..0x9D    #L&   [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-ST...
+      | 0xE2 0x84 0xA4          #L&       DOUBLE-STRUCK CAPITAL Z
+      | 0xE2 0x84 0xA6          #L&       OHM SIGN
+      | 0xE2 0x84 0xA8          #L&       BLACK-LETTER CAPITAL Z
+      | 0xE2 0x84 0xAA..0xAD    #L&   [4] KELVIN SIGN..BLACK-LETTER CAPITAL C
+      | 0xE2 0x84 0xAE          #So       ESTIMATED SYMBOL
+      | 0xE2 0x84 0xAF..0xB4    #L&   [6] SCRIPT SMALL E..SCRIPT SMALL O
+      | 0xE2 0x84 0xB5..0xB8    #Lo   [4] ALEF SYMBOL..DALET SYMBOL
+      | 0xE2 0x84 0xB9          #L&       INFORMATION SOURCE
+      | 0xE2 0x84 0xBC..0xBF    #L&   [4] DOUBLE-STRUCK SMALL PI..DOUBLE-STR...
+      | 0xE2 0x85 0x85..0x89    #L&   [5] DOUBLE-STRUCK ITALIC CAPITAL D..DO...
+      | 0xE2 0x85 0x8E          #L&       TURNED SMALL F
+      | 0xE2 0x85 0xA0..0xFF    #Nl  [35] ROMAN NUMERAL ONE..ROMAN NUMERAL T...
+      | 0xE2 0x86 0x00..0x82    #
+      | 0xE2 0x86 0x83..0x84    #L&   [2] ROMAN NUMERAL REVERSED ONE HUNDRED...
+      | 0xE2 0x86 0x85..0x88    #Nl   [4] ROMAN NUMERAL SIX LATE FORM..ROMAN...
+      | 0xE2 0xB0 0x80..0xAE    #L&  [47] GLAGOLITIC CAPITAL LETTER AZU..GLA...
+      | 0xE2 0xB0 0xB0..0xFF    #L&  [47] GLAGOLITIC SMALL LETTER AZU..GLAGO...
+      | 0xE2 0xB1 0x00..0x9E    #
+      | 0xE2 0xB1 0xA0..0xBB    #L&  [28] LATIN CAPITAL LETTER L WITH DOUBLE...
+      | 0xE2 0xB1 0xBC..0xBD    #Lm   [2] LATIN SUBSCRIPT SMALL LETTER J..MO...
+      | 0xE2 0xB1 0xBE..0xFF        #L& [103] LATIN CAPITAL LETTER S WITH SW...
+      | 0xE2 0xB2..0xB2 0x00..0xFF  #
+      | 0xE2 0xB3 0x00..0xA4        #
+      | 0xE2 0xB3 0xAB..0xAE    #L&   [4] COPTIC CAPITAL LETTER CRYPTOGRAMMI...
+      | 0xE2 0xB3 0xB2..0xB3    #L&   [2] COPTIC CAPITAL LETTER BOHAIRIC KHE...
+      | 0xE2 0xB4 0x80..0xA5    #L&  [38] GEORGIAN SMALL LETTER AN..GEORGIAN...
+      | 0xE2 0xB4 0xA7          #L&       GEORGIAN SMALL LETTER YN
+      | 0xE2 0xB4 0xAD          #L&       GEORGIAN SMALL LETTER AEN
+      | 0xE2 0xB4 0xB0..0xFF    #Lo  [56] TIFINAGH LETTER YA..TIFINAGH LETTE...
+      | 0xE2 0xB5 0x00..0xA7    #
+      | 0xE2 0xB5 0xAF          #Lm       TIFINAGH MODIFIER LETTER LABIALIZA...
+      | 0xE2 0xB6 0x80..0x96    #Lo  [23] ETHIOPIC SYLLABLE LOA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xA0..0xA6    #Lo   [7] ETHIOPIC SYLLABLE SSA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xA8..0xAE    #Lo   [7] ETHIOPIC SYLLABLE CCA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xB0..0xB6    #Lo   [7] ETHIOPIC SYLLABLE ZZA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xB8..0xBE    #Lo   [7] ETHIOPIC SYLLABLE CCHA..ETHIOPIC S...
+      | 0xE2 0xB7 0x80..0x86    #Lo   [7] ETHIOPIC SYLLABLE QYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0x88..0x8E    #Lo   [7] ETHIOPIC SYLLABLE KYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0x90..0x96    #Lo   [7] ETHIOPIC SYLLABLE XYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0x98..0x9E    #Lo   [7] ETHIOPIC SYLLABLE GYA..ETHIOPIC SY...
+      | 0xE3 0x80 0x85          #Lm       IDEOGRAPHIC ITERATION MARK
+      | 0xE3 0x80 0x86          #Lo       IDEOGRAPHIC CLOSING MARK
+      | 0xE3 0x80 0x87          #Nl       IDEOGRAPHIC NUMBER ZERO
+      | 0xE3 0x80 0xA1..0xA9    #Nl   [9] HANGZHOU NUMERAL ONE..HANGZHOU NUM...
+      | 0xE3 0x80 0xB1..0xB5    #Lm   [5] VERTICAL KANA REPEAT MARK..VERTICA...
+      | 0xE3 0x80 0xB8..0xBA    #Nl   [3] HANGZHOU NUMERAL TEN..HANGZHOU NUM...
+      | 0xE3 0x80 0xBB          #Lm       VERTICAL IDEOGRAPHIC ITERATION MARK
+      | 0xE3 0x80 0xBC          #Lo       MASU MARK
+      | 0xE3 0x81 0x81..0xFF    #Lo  [86] HIRAGANA LETTER SMALL A..HIRAGANA ...
+      | 0xE3 0x82 0x00..0x96    #
+      | 0xE3 0x82 0x9B..0x9C    #Sk   [2] KATAKANA-HIRAGANA VOICED SOUND MAR...
+      | 0xE3 0x82 0x9D..0x9E    #Lm   [2] HIRAGANA ITERATION MARK..HIRAGANA ...
+      | 0xE3 0x82 0x9F          #Lo       HIRAGANA DIGRAPH YORI
+      | 0xE3 0x82 0xA1..0xFF    #Lo  [90] KATAKANA LETTER SMALL A..KATAKANA ...
+      | 0xE3 0x83 0x00..0xBA    #
+      | 0xE3 0x83 0xBC..0xBE    #Lm   [3] KATAKANA-HIRAGANA PROLONGED SOUND ...
+      | 0xE3 0x83 0xBF          #Lo       KATAKANA DIGRAPH KOTO
+      | 0xE3 0x84 0x85..0xAD    #Lo  [41] BOPOMOFO LETTER B..BOPOMOFO LETTER IH
+      | 0xE3 0x84 0xB1..0xFF        #Lo  [94] HANGUL LETTER KIYEOK..HANGUL L...
+      | 0xE3 0x85..0x85 0x00..0xFF  #
+      | 0xE3 0x86 0x00..0x8E        #
+      | 0xE3 0x86 0xA0..0xBA    #Lo  [27] BOPOMOFO LETTER BU..BOPOMOFO LETTE...
+      | 0xE3 0x87 0xB0..0xBF    #Lo  [16] KATAKANA LETTER SMALL KU..KATAKANA...
+      | 0xE3 0x90 0x80..0xFF        #Lo [6582] CJK UNIFIED IDEOGRAPH-3400..C...
+      | 0xE3 0x91..0xFF 0x00..0xFF  #
+      | 0xE4 0x00 0x00..0xFF        #
+      | 0xE4 0x01..0xB5 0x00..0xFF  #
+      | 0xE4 0xB6 0x00..0xB5        #
+      | 0xE4 0xB8 0x80..0xFF              #Lo [20950] CJK UNIFIED IDEOGRAPH-...
+      | 0xE4 0xB9..0xFF 0x00..0xFF        #
+      | 0xE5..0xE8 0x00..0xFF 0x00..0xFF  #
+      | 0xE9 0x00 0x00..0xFF              #
+      | 0xE9 0x01..0xBE 0x00..0xFF        #
+      | 0xE9 0xBF 0x00..0x95              #
+      | 0xEA 0x80 0x80..0x94    #Lo  [21] YI SYLLABLE IT..YI SYLLABLE E
+      | 0xEA 0x80 0x95          #Lm       YI SYLLABLE WU
+      | 0xEA 0x80 0x96..0xFF        #Lo [1143] YI SYLLABLE BIT..YI SYLLABLE YYR
+      | 0xEA 0x81..0x91 0x00..0xFF  #
+      | 0xEA 0x92 0x00..0x8C        #
+      | 0xEA 0x93 0x90..0xB7    #Lo  [40] LISU LETTER BA..LISU LETTER OE
+      | 0xEA 0x93 0xB8..0xBD    #Lm   [6] LISU LETTER TONE MYA TI..LISU LETT...
+      | 0xEA 0x94 0x80..0xFF        #Lo [268] VAI SYLLABLE EE..VAI SYLLABLE NG
+      | 0xEA 0x95..0x97 0x00..0xFF  #
+      | 0xEA 0x98 0x00..0x8B        #
+      | 0xEA 0x98 0x8C          #Lm       VAI SYLLABLE LENGTHENER
+      | 0xEA 0x98 0x90..0x9F    #Lo  [16] VAI SYLLABLE NDOLE FA..VAI SYMBOL ...
+      | 0xEA 0x98 0xAA..0xAB    #Lo   [2] VAI SYLLABLE NDOLE MA..VAI SYLLABL...
+      | 0xEA 0x99 0x80..0xAD    #L&  [46] CYRILLIC CAPITAL LETTER ZEMLYA..CY...
+      | 0xEA 0x99 0xAE          #Lo       CYRILLIC LETTER MULTIOCULAR O
+      | 0xEA 0x99 0xBF          #Lm       CYRILLIC PAYEROK
+      | 0xEA 0x9A 0x80..0x9B    #L&  [28] CYRILLIC CAPITAL LETTER DWE..CYRIL...
+      | 0xEA 0x9A 0x9C..0x9D    #Lm   [2] MODIFIER LETTER CYRILLIC HARD SIGN...
+      | 0xEA 0x9A 0xA0..0xFF    #Lo  [70] BAMUM LETTER A..BAMUM LETTER KI
+      | 0xEA 0x9B 0x00..0xA5    #
+      | 0xEA 0x9B 0xA6..0xAF    #Nl  [10] BAMUM LETTER MO..BAMUM LETTER KOGHOM
+      | 0xEA 0x9C 0x97..0x9F    #Lm   [9] MODIFIER LETTER DOT VERTICAL BAR.....
+      | 0xEA 0x9C 0xA2..0xFF    #L&  [78] LATIN CAPITAL LETTER EGYPTOLOGICAL...
+      | 0xEA 0x9D 0x00..0xAF    #
+      | 0xEA 0x9D 0xB0          #Lm       MODIFIER LETTER US
+      | 0xEA 0x9D 0xB1..0xFF    #L&  [23] LATIN SMALL LETTER DUM..LATIN SMAL...
+      | 0xEA 0x9E 0x00..0x87    #
+      | 0xEA 0x9E 0x88          #Lm       MODIFIER LETTER LOW CIRCUMFLEX ACCENT
+      | 0xEA 0x9E 0x8B..0x8E    #L&   [4] LATIN CAPITAL LETTER SALTILLO..LAT...
+      | 0xEA 0x9E 0x8F          #Lo       LATIN LETTER SINOLOGICAL DOT
+      | 0xEA 0x9E 0x90..0xAE    #L&  [31] LATIN CAPITAL LETTER N WITH DESCEN...
+      | 0xEA 0x9E 0xB0..0xB7    #L&   [8] LATIN CAPITAL LETTER TURNED K..LAT...
+      | 0xEA 0x9F 0xB7          #Lo       LATIN EPIGRAPHIC LETTER SIDEWAYS I
+      | 0xEA 0x9F 0xB8..0xB9    #Lm   [2] MODIFIER LETTER CAPITAL H WITH STR...
+      | 0xEA 0x9F 0xBA          #L&       LATIN LETTER SMALL CAPITAL TURNED M
+      | 0xEA 0x9F 0xBB..0xFF    #Lo   [7] LATIN EPIGRAPHIC LETTER REVERSED F...
+      | 0xEA 0xA0 0x00..0x81    #
+      | 0xEA 0xA0 0x83..0x85    #Lo   [3] SYLOTI NAGRI LETTER U..SYLOTI NAGR...
+      | 0xEA 0xA0 0x87..0x8A    #Lo   [4] SYLOTI NAGRI LETTER KO..SYLOTI NAG...
+      | 0xEA 0xA0 0x8C..0xA2    #Lo  [23] SYLOTI NAGRI LETTER CO..SYLOTI NAG...
+      | 0xEA 0xA1 0x80..0xB3    #Lo  [52] PHAGS-PA LETTER KA..PHAGS-PA LETTE...
+      | 0xEA 0xA2 0x82..0xB3    #Lo  [50] SAURASHTRA LETTER A..SAURASHTRA LE...
+      | 0xEA 0xA3 0xB2..0xB7    #Lo   [6] DEVANAGARI SIGN SPACING CANDRABIND...
+      | 0xEA 0xA3 0xBB          #Lo       DEVANAGARI HEADSTROKE
+      | 0xEA 0xA3 0xBD          #Lo       DEVANAGARI JAIN OM
+      | 0xEA 0xA4 0x8A..0xA5    #Lo  [28] KAYAH LI LETTER KA..KAYAH LI LETTE...
+      | 0xEA 0xA4 0xB0..0xFF    #Lo  [23] REJANG LETTER KA..REJANG LETTER A
+      | 0xEA 0xA5 0x00..0x86    #
+      | 0xEA 0xA5 0xA0..0xBC    #Lo  [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANG...
+      | 0xEA 0xA6 0x84..0xB2    #Lo  [47] JAVANESE LETTER A..JAVANESE LETTER HA
+      | 0xEA 0xA7 0x8F          #Lm       JAVANESE PANGRANGKEP
+      | 0xEA 0xA7 0xA0..0xA4    #Lo   [5] MYANMAR LETTER SHAN GHA..MYANMAR L...
+      | 0xEA 0xA7 0xA6          #Lm       MYANMAR MODIFIER LETTER SHAN REDUP...
+      | 0xEA 0xA7 0xA7..0xAF    #Lo   [9] MYANMAR LETTER TAI LAING NYA..MYAN...
+      | 0xEA 0xA7 0xBA..0xBE    #Lo   [5] MYANMAR LETTER TAI LAING LLA..MYAN...
+      | 0xEA 0xA8 0x80..0xA8    #Lo  [41] CHAM LETTER A..CHAM LETTER HA
+      | 0xEA 0xA9 0x80..0x82    #Lo   [3] CHAM LETTER FINAL K..CHAM LETTER F...
+      | 0xEA 0xA9 0x84..0x8B    #Lo   [8] CHAM LETTER FINAL CH..CHAM LETTER ...
+      | 0xEA 0xA9 0xA0..0xAF    #Lo  [16] MYANMAR LETTER KHAMTI GA..MYANMAR ...
+      | 0xEA 0xA9 0xB0          #Lm       MYANMAR MODIFIER LETTER KHAMTI RED...
+      | 0xEA 0xA9 0xB1..0xB6    #Lo   [6] MYANMAR LETTER KHAMTI XA..MYANMAR ...
+      | 0xEA 0xA9 0xBA          #Lo       MYANMAR LETTER AITON RA
+      | 0xEA 0xA9 0xBE..0xFF    #Lo  [50] MYANMAR LETTER SHWE PALAUNG CHA..T...
+      | 0xEA 0xAA 0x00..0xAF    #
+      | 0xEA 0xAA 0xB1          #Lo       TAI VIET VOWEL AA
+      | 0xEA 0xAA 0xB5..0xB6    #Lo   [2] TAI VIET VOWEL E..TAI VIET VOWEL O
+      | 0xEA 0xAA 0xB9..0xBD    #Lo   [5] TAI VIET VOWEL UEA..TAI VIET VOWEL AN
+      | 0xEA 0xAB 0x80          #Lo       TAI VIET TONE MAI NUENG
+      | 0xEA 0xAB 0x82          #Lo       TAI VIET TONE MAI SONG
+      | 0xEA 0xAB 0x9B..0x9C    #Lo   [2] TAI VIET SYMBOL KON..TAI VIET SYMB...
+      | 0xEA 0xAB 0x9D          #Lm       TAI VIET SYMBOL SAM
+      | 0xEA 0xAB 0xA0..0xAA    #Lo  [11] MEETEI MAYEK LETTER E..MEETEI MAYE...
+      | 0xEA 0xAB 0xB2          #Lo       MEETEI MAYEK ANJI
+      | 0xEA 0xAB 0xB3..0xB4    #Lm   [2] MEETEI MAYEK SYLLABLE REPETITION M...
+      | 0xEA 0xAC 0x81..0x86    #Lo   [6] ETHIOPIC SYLLABLE TTHU..ETHIOPIC S...
+      | 0xEA 0xAC 0x89..0x8E    #Lo   [6] ETHIOPIC SYLLABLE DDHU..ETHIOPIC S...
+      | 0xEA 0xAC 0x91..0x96    #Lo   [6] ETHIOPIC SYLLABLE DZU..ETHIOPIC SY...
+      | 0xEA 0xAC 0xA0..0xA6    #Lo   [7] ETHIOPIC SYLLABLE CCHHA..ETHIOPIC ...
+      | 0xEA 0xAC 0xA8..0xAE    #Lo   [7] ETHIOPIC SYLLABLE BBA..ETHIOPIC SY...
+      | 0xEA 0xAC 0xB0..0xFF    #L&  [43] LATIN SMALL LETTER BARRED ALPHA..L...
+      | 0xEA 0xAD 0x00..0x9A    #
+      | 0xEA 0xAD 0x9C..0x9F    #Lm   [4] MODIFIER LETTER SMALL HENG..MODIFI...
+      | 0xEA 0xAD 0xA0..0xA5    #L&   [6] LATIN SMALL LETTER SAKHA YAT..GREE...
+      | 0xEA 0xAD 0xB0..0xFF    #L&  [80] CHEROKEE SMALL LETTER A..CHEROKEE ...
+      | 0xEA 0xAE 0x00..0xBF    #
+      | 0xEA 0xAF 0x80..0xA2    #Lo  [35] MEETEI MAYEK LETTER KOK..MEETEI MA...
+      | 0xEA 0xB0 0x80..0xFF              #Lo [11172] HANGUL SYLLABLE GA..HA...
+      | 0xEA 0xB1..0xFF 0x00..0xFF        #
+      | 0xEB..0xEC 0x00..0xFF 0x00..0xFF  #
+      | 0xED 0x00 0x00..0xFF              #
+      | 0xED 0x01..0x9D 0x00..0xFF        #
+      | 0xED 0x9E 0x00..0xA3              #
+      | 0xED 0x9E 0xB0..0xFF    #Lo  [23] HANGUL JUNGSEONG O-YEO..HANGUL JUN...
+      | 0xED 0x9F 0x00..0x86    #
+      | 0xED 0x9F 0x8B..0xBB    #Lo  [49] HANGUL JONGSEONG NIEUN-RIEUL..HANG...
+      | 0xEF 0xA4 0x80..0xFF        #Lo [366] CJK COMPATIBILITY IDEOGRAPH-F9...
+      | 0xEF 0xA5..0xA8 0x00..0xFF  #
+      | 0xEF 0xA9 0x00..0xAD        #
+      | 0xEF 0xA9 0xB0..0xFF        #Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA...
+      | 0xEF 0xAA..0xAA 0x00..0xFF  #
+      | 0xEF 0xAB 0x00..0x99        #
+      | 0xEF 0xAC 0x80..0x86    #L&   [7] LATIN SMALL LIGATURE FF..LATIN SMA...
+      | 0xEF 0xAC 0x93..0x97    #L&   [5] ARMENIAN SMALL LIGATURE MEN NOW..A...
+      | 0xEF 0xAC 0x9D          #Lo       HEBREW LETTER YOD WITH HIRIQ
+      | 0xEF 0xAC 0x9F..0xA8    #Lo  [10] HEBREW LIGATURE YIDDISH YOD YOD PA...
+      | 0xEF 0xAC 0xAA..0xB6    #Lo  [13] HEBREW LETTER SHIN WITH SHIN DOT.....
+      | 0xEF 0xAC 0xB8..0xBC    #Lo   [5] HEBREW LETTER TET WITH DAGESH..HEB...
+      | 0xEF 0xAC 0xBE          #Lo       HEBREW LETTER MEM WITH DAGESH
+      | 0xEF 0xAD 0x80..0x81    #Lo   [2] HEBREW LETTER NUN WITH DAGESH..HEB...
+      | 0xEF 0xAD 0x83..0x84    #Lo   [2] HEBREW LETTER FINAL PE WITH DAGESH...
+      | 0xEF 0xAD 0x86..0xFF    #Lo [108] HEBREW LETTER TSADI WITH DAGESH..A...
+      | 0xEF 0xAE 0x00..0xB1    #
+      | 0xEF 0xAF 0x93..0xFF        #Lo [363] ARABIC LETTER NG ISOLATED FORM...
+      | 0xEF 0xB0..0xB3 0x00..0xFF  #
+      | 0xEF 0xB4 0x00..0xBD        #
+      | 0xEF 0xB5 0x90..0xFF    #Lo  [64] ARABIC LIGATURE TEH WITH JEEM WITH...
+      | 0xEF 0xB6 0x00..0x8F    #
+      | 0xEF 0xB6 0x92..0xFF    #Lo  [54] ARABIC LIGATURE MEEM WITH JEEM WIT...
+      | 0xEF 0xB7 0x00..0x87    #
+      | 0xEF 0xB7 0xB0..0xBB    #Lo  [12] ARABIC LIGATURE SALLA USED AS KORA...
+      | 0xEF 0xB9 0xB0..0xB4    #Lo   [5] ARABIC FATHATAN ISOLATED FORM..ARA...
+      | 0xEF 0xB9 0xB6..0xFF        #Lo [135] ARABIC FATHA ISOLATED FORM..AR...
+      | 0xEF 0xBA..0xBA 0x00..0xFF  #
+      | 0xEF 0xBB 0x00..0xBC        #
+      | 0xEF 0xBC 0xA1..0xBA    #L&  [26] FULLWIDTH LATIN CAPITAL LETTER A.....
+      | 0xEF 0xBD 0x81..0x9A    #L&  [26] FULLWIDTH LATIN SMALL LETTER A..FU...
+      | 0xEF 0xBD 0xA6..0xAF    #Lo  [10] HALFWIDTH KATAKANA LETTER WO..HALF...
+      | 0xEF 0xBD 0xB0          #Lm       HALFWIDTH KATAKANA-HIRAGANA PROLON...
+      | 0xEF 0xBD 0xB1..0xFF    #Lo  [45] HALFWIDTH KATAKANA LETTER A..HALFW...
+      | 0xEF 0xBE 0x00..0x9D    #
+      | 0xEF 0xBE 0x9E..0x9F    #Lm   [2] HALFWIDTH KATAKANA VOICED SOUND MA...
+      | 0xEF 0xBE 0xA0..0xBE    #Lo  [31] HALFWIDTH HANGUL FILLER..HALFWIDTH...
+      | 0xEF 0xBF 0x82..0x87    #Lo   [6] HALFWIDTH HANGUL LETTER A..HALFWID...
+      | 0xEF 0xBF 0x8A..0x8F    #Lo   [6] HALFWIDTH HANGUL LETTER YEO..HALFW...
+      | 0xEF 0xBF 0x92..0x97    #Lo   [6] HALFWIDTH HANGUL LETTER YO..HALFWI...
+      | 0xEF 0xBF 0x9A..0x9C    #Lo   [3] HALFWIDTH HANGUL LETTER EU..HALFWI...
+      | 0xF0 0x90 0x80 0x80..0x8B  #Lo  [12] LINEAR B SYLLABLE B008 A..LINEA...
+      | 0xF0 0x90 0x80 0x8D..0xA6  #Lo  [26] LINEAR B SYLLABLE B036 JO..LINE...
+      | 0xF0 0x90 0x80 0xA8..0xBA  #Lo  [19] LINEAR B SYLLABLE B060 RA..LINE...
+      | 0xF0 0x90 0x80 0xBC..0xBD  #Lo   [2] LINEAR B SYLLABLE B017 ZA..LINE...
+      | 0xF0 0x90 0x80 0xBF..0xFF  #Lo  [15] LINEAR B SYLLABLE B020 ZO..LINE...
+      | 0xF0 0x90 0x81 0x00..0x8D  #
+      | 0xF0 0x90 0x81 0x90..0x9D  #Lo  [14] LINEAR B SYMBOL B018..LINEAR B ...
+      | 0xF0 0x90 0x82 0x80..0xFF  #Lo [123] LINEAR B IDEOGRAM B100 MAN..LIN...
+      | 0xF0 0x90 0x83 0x00..0xBA  #
+      | 0xF0 0x90 0x85 0x80..0xB4  #Nl  [53] GREEK ACROPHONIC ATTIC ONE QUAR...
+      | 0xF0 0x90 0x8A 0x80..0x9C  #Lo  [29] LYCIAN LETTER A..LYCIAN LETTER X
+      | 0xF0 0x90 0x8A 0xA0..0xFF  #Lo  [49] CARIAN LETTER A..CARIAN LETTER ...
+      | 0xF0 0x90 0x8B 0x00..0x90  #
+      | 0xF0 0x90 0x8C 0x80..0x9F  #Lo  [32] OLD ITALIC LETTER A..OLD ITALIC...
+      | 0xF0 0x90 0x8C 0xB0..0xFF  #Lo  [17] GOTHIC LETTER AHSA..GOTHIC LETT...
+      | 0xF0 0x90 0x8D 0x00..0x80  #
+      | 0xF0 0x90 0x8D 0x81     #Nl       GOTHIC LETTER NINETY
+      | 0xF0 0x90 0x8D 0x82..0x89  #Lo   [8] GOTHIC LETTER RAIDA..GOTHIC LET...
+      | 0xF0 0x90 0x8D 0x8A     #Nl       GOTHIC LETTER NINE HUNDRED
+      | 0xF0 0x90 0x8D 0x90..0xB5  #Lo  [38] OLD PERMIC LETTER AN..OLD PERMI...
+      | 0xF0 0x90 0x8E 0x80..0x9D  #Lo  [30] UGARITIC LETTER ALPA..UGARITIC ...
+      | 0xF0 0x90 0x8E 0xA0..0xFF  #Lo  [36] OLD PERSIAN SIGN A..OLD PERSIAN...
+      | 0xF0 0x90 0x8F 0x00..0x83  #
+      | 0xF0 0x90 0x8F 0x88..0x8F  #Lo   [8] OLD PERSIAN SIGN AURAMAZDAA..OL...
+      | 0xF0 0x90 0x8F 0x91..0x95  #Nl   [5] OLD PERSIAN NUMBER ONE..OLD PER...
+      | 0xF0 0x90 0x90 0x80..0xFF  #L&  [80] DESERET CAPITAL LETTER LONG I.....
+      | 0xF0 0x90 0x91 0x00..0x8F  #
+      | 0xF0 0x90 0x91 0x90..0xFF  #Lo  [78] SHAVIAN LETTER PEEP..OSMANYA LE...
+      | 0xF0 0x90 0x92 0x00..0x9D  #
+      | 0xF0 0x90 0x92 0xB0..0xFF  #L&  [36] OSAGE CAPITAL LETTER A..OSAGE C...
+      | 0xF0 0x90 0x93 0x00..0x93  #
+      | 0xF0 0x90 0x93 0x98..0xBB  #L&  [36] OSAGE SMALL LETTER A..OSAGE SMA...
+      | 0xF0 0x90 0x94 0x80..0xA7  #Lo  [40] ELBASAN LETTER A..ELBASAN LETTE...
+      | 0xF0 0x90 0x94 0xB0..0xFF  #Lo  [52] CAUCASIAN ALBANIAN LETTER ALT.....
+      | 0xF0 0x90 0x95 0x00..0xA3  #
+      | 0xF0 0x90 0x98 0x80..0xFF        #Lo [311] LINEAR A SIGN AB001..LINE...
+      | 0xF0 0x90 0x99..0x9B 0x00..0xFF  #
+      | 0xF0 0x90 0x9C 0x00..0xB6        #
+      | 0xF0 0x90 0x9D 0x80..0x95  #Lo  [22] LINEAR A SIGN A701 A..LINEAR A ...
+      | 0xF0 0x90 0x9D 0xA0..0xA7  #Lo   [8] LINEAR A SIGN A800..LINEAR A SI...
+      | 0xF0 0x90 0xA0 0x80..0x85  #Lo   [6] CYPRIOT SYLLABLE A..CYPRIOT SYL...
+      | 0xF0 0x90 0xA0 0x88     #Lo       CYPRIOT SYLLABLE JO
+      | 0xF0 0x90 0xA0 0x8A..0xB5  #Lo  [44] CYPRIOT SYLLABLE KA..CYPRIOT SY...
+      | 0xF0 0x90 0xA0 0xB7..0xB8  #Lo   [2] CYPRIOT SYLLABLE XA..CYPRIOT SY...
+      | 0xF0 0x90 0xA0 0xBC     #Lo       CYPRIOT SYLLABLE ZA
+      | 0xF0 0x90 0xA0 0xBF..0xFF  #Lo  [23] CYPRIOT SYLLABLE ZO..IMPERIAL A...
+      | 0xF0 0x90 0xA1 0x00..0x95  #
+      | 0xF0 0x90 0xA1 0xA0..0xB6  #Lo  [23] PALMYRENE LETTER ALEPH..PALMYRE...
+      | 0xF0 0x90 0xA2 0x80..0x9E  #Lo  [31] NABATAEAN LETTER FINAL ALEPH..N...
+      | 0xF0 0x90 0xA3 0xA0..0xB2  #Lo  [19] HATRAN LETTER ALEPH..HATRAN LET...
+      | 0xF0 0x90 0xA3 0xB4..0xB5  #Lo   [2] HATRAN LETTER SHIN..HATRAN LETT...
+      | 0xF0 0x90 0xA4 0x80..0x95  #Lo  [22] PHOENICIAN LETTER ALF..PHOENICI...
+      | 0xF0 0x90 0xA4 0xA0..0xB9  #Lo  [26] LYDIAN LETTER A..LYDIAN LETTER C
+      | 0xF0 0x90 0xA6 0x80..0xB7  #Lo  [56] MEROITIC HIEROGLYPHIC LETTER A....
+      | 0xF0 0x90 0xA6 0xBE..0xBF  #Lo   [2] MEROITIC CURSIVE LOGOGRAM RMT.....
+      | 0xF0 0x90 0xA8 0x80     #Lo       KHAROSHTHI LETTER A
+      | 0xF0 0x90 0xA8 0x90..0x93  #Lo   [4] KHAROSHTHI LETTER KA..KHAROSHTH...
+      | 0xF0 0x90 0xA8 0x95..0x97  #Lo   [3] KHAROSHTHI LETTER CA..KHAROSHTH...
+      | 0xF0 0x90 0xA8 0x99..0xB3  #Lo  [27] KHAROSHTHI LETTER NYA..KHAROSHT...
+      | 0xF0 0x90 0xA9 0xA0..0xBC  #Lo  [29] OLD SOUTH ARABIAN LETTER HE..OL...
+      | 0xF0 0x90 0xAA 0x80..0x9C  #Lo  [29] OLD NORTH ARABIAN LETTER HEH..O...
+      | 0xF0 0x90 0xAB 0x80..0x87  #Lo   [8] MANICHAEAN LETTER ALEPH..MANICH...
+      | 0xF0 0x90 0xAB 0x89..0xA4  #Lo  [28] MANICHAEAN LETTER ZAYIN..MANICH...
+      | 0xF0 0x90 0xAC 0x80..0xB5  #Lo  [54] AVESTAN LETTER A..AVESTAN LETTE...
+      | 0xF0 0x90 0xAD 0x80..0x95  #Lo  [22] INSCRIPTIONAL PARTHIAN LETTER A...
+      | 0xF0 0x90 0xAD 0xA0..0xB2  #Lo  [19] INSCRIPTIONAL PAHLAVI LETTER AL...
+      | 0xF0 0x90 0xAE 0x80..0x91  #Lo  [18] PSALTER PAHLAVI LETTER ALEPH..P...
+      | 0xF0 0x90 0xB0 0x80..0xFF  #Lo  [73] OLD TURKIC LETTER ORKHON A..OLD...
+      | 0xF0 0x90 0xB1 0x00..0x88  #
+      | 0xF0 0x90 0xB2 0x80..0xB2  #L&  [51] OLD HUNGARIAN CAPITAL LETTER A....
+      | 0xF0 0x90 0xB3 0x80..0xB2  #L&  [51] OLD HUNGARIAN SMALL LETTER A..O...
+      | 0xF0 0x91 0x80 0x83..0xB7  #Lo  [53] BRAHMI SIGN JIHVAMULIYA..BRAHMI...
+      | 0xF0 0x91 0x82 0x83..0xAF  #Lo  [45] KAITHI LETTER A..KAITHI LETTER HA
+      | 0xF0 0x91 0x83 0x90..0xA8  #Lo  [25] SORA SOMPENG LETTER SAH..SORA S...
+      | 0xF0 0x91 0x84 0x83..0xA6  #Lo  [36] CHAKMA LETTER AA..CHAKMA LETTER...
+      | 0xF0 0x91 0x85 0x90..0xB2  #Lo  [35] MAHAJANI LETTER A..MAHAJANI LET...
+      | 0xF0 0x91 0x85 0xB6     #Lo       MAHAJANI LIGATURE SHRI
+      | 0xF0 0x91 0x86 0x83..0xB2  #Lo  [48] SHARADA LETTER A..SHARADA LETTE...
+      | 0xF0 0x91 0x87 0x81..0x84  #Lo   [4] SHARADA SIGN AVAGRAHA..SHARADA OM
+      | 0xF0 0x91 0x87 0x9A     #Lo       SHARADA EKAM
+      | 0xF0 0x91 0x87 0x9C     #Lo       SHARADA HEADSTROKE
+      | 0xF0 0x91 0x88 0x80..0x91  #Lo  [18] KHOJKI LETTER A..KHOJKI LETTER JJA
+      | 0xF0 0x91 0x88 0x93..0xAB  #Lo  [25] KHOJKI LETTER NYA..KHOJKI LETTE...
+      | 0xF0 0x91 0x8A 0x80..0x86  #Lo   [7] MULTANI LETTER A..MULTANI LETTE...
+      | 0xF0 0x91 0x8A 0x88     #Lo       MULTANI LETTER GHA
+      | 0xF0 0x91 0x8A 0x8A..0x8D  #Lo   [4] MULTANI LETTER CA..MULTANI LETT...
+      | 0xF0 0x91 0x8A 0x8F..0x9D  #Lo  [15] MULTANI LETTER NYA..MULTANI LET...
+      | 0xF0 0x91 0x8A 0x9F..0xA8  #Lo  [10] MULTANI LETTER BHA..MULTANI LET...
+      | 0xF0 0x91 0x8A 0xB0..0xFF  #Lo  [47] KHUDAWADI LETTER A..KHUDAWADI L...
+      | 0xF0 0x91 0x8B 0x00..0x9E  #
+      | 0xF0 0x91 0x8C 0x85..0x8C  #Lo   [8] GRANTHA LETTER A..GRANTHA LETTE...
+      | 0xF0 0x91 0x8C 0x8F..0x90  #Lo   [2] GRANTHA LETTER EE..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0x93..0xA8  #Lo  [22] GRANTHA LETTER OO..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xAA..0xB0  #Lo   [7] GRANTHA LETTER PA..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xB2..0xB3  #Lo   [2] GRANTHA LETTER LA..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xB5..0xB9  #Lo   [5] GRANTHA LETTER VA..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xBD     #Lo       GRANTHA SIGN AVAGRAHA
+      | 0xF0 0x91 0x8D 0x90     #Lo       GRANTHA OM
+      | 0xF0 0x91 0x8D 0x9D..0xA1  #Lo   [5] GRANTHA SIGN PLUTA..GRANTHA LET...
+      | 0xF0 0x91 0x90 0x80..0xB4  #Lo  [53] NEWA LETTER A..NEWA LETTER HA
+      | 0xF0 0x91 0x91 0x87..0x8A  #Lo   [4] NEWA SIGN AVAGRAHA..NEWA SIDDHI
+      | 0xF0 0x91 0x92 0x80..0xAF  #Lo  [48] TIRHUTA ANJI..TIRHUTA LETTER HA
+      | 0xF0 0x91 0x93 0x84..0x85  #Lo   [2] TIRHUTA SIGN AVAGRAHA..TIRHUTA ...
+      | 0xF0 0x91 0x93 0x87     #Lo       TIRHUTA OM
+      | 0xF0 0x91 0x96 0x80..0xAE  #Lo  [47] SIDDHAM LETTER A..SIDDHAM LETTE...
+      | 0xF0 0x91 0x97 0x98..0x9B  #Lo   [4] SIDDHAM LETTER THREE-CIRCLE ALT...
+      | 0xF0 0x91 0x98 0x80..0xAF  #Lo  [48] MODI LETTER A..MODI LETTER LLA
+      | 0xF0 0x91 0x99 0x84     #Lo       MODI SIGN HUVA
+      | 0xF0 0x91 0x9A 0x80..0xAA  #Lo  [43] TAKRI LETTER A..TAKRI LETTER RRA
+      | 0xF0 0x91 0x9C 0x80..0x99  #Lo  [26] AHOM LETTER KA..AHOM LETTER JHA
+      | 0xF0 0x91 0xA2 0xA0..0xFF  #L&  [64] WARANG CITI CAPITAL LETTER NGAA...
+      | 0xF0 0x91 0xA3 0x00..0x9F  #
+      | 0xF0 0x91 0xA3 0xBF     #Lo       WARANG CITI OM
+      | 0xF0 0x91 0xAB 0x80..0xB8  #Lo  [57] PAU CIN HAU LETTER PA..PAU CIN ...
+      | 0xF0 0x91 0xB0 0x80..0x88  #Lo   [9] BHAIKSUKI LETTER A..BHAIKSUKI L...
+      | 0xF0 0x91 0xB0 0x8A..0xAE  #Lo  [37] BHAIKSUKI LETTER E..BHAIKSUKI L...
+      | 0xF0 0x91 0xB1 0x80     #Lo       BHAIKSUKI SIGN AVAGRAHA
+      | 0xF0 0x91 0xB1 0xB2..0xFF  #Lo  [30] MARCHEN LETTER KA..MARCHEN LETT...
+      | 0xF0 0x91 0xB2 0x00..0x8F  #
+      | 0xF0 0x92 0x80 0x80..0xFF        #Lo [922] CUNEIFORM SIGN A..CUNEIFO...
+      | 0xF0 0x92 0x81..0x8D 0x00..0xFF  #
+      | 0xF0 0x92 0x8E 0x00..0x99        #
+      | 0xF0 0x92 0x90 0x80..0xFF  #Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH....
+      | 0xF0 0x92 0x91 0x00..0xAE  #
+      | 0xF0 0x92 0x92 0x80..0xFF        #Lo [196] CUNEIFORM SIGN AB TIMES N...
+      | 0xF0 0x92 0x93..0x94 0x00..0xFF  #
+      | 0xF0 0x92 0x95 0x00..0x83        #
+      | 0xF0 0x93 0x80 0x80..0xFF        #Lo [1071] EGYPTIAN HIEROGLYPH A001...
+      | 0xF0 0x93 0x81..0x8F 0x00..0xFF  #
+      | 0xF0 0x93 0x90 0x00..0xAE        #
+      | 0xF0 0x94 0x90 0x80..0xFF        #Lo [583] ANATOLIAN HIEROGLYPH A001...
+      | 0xF0 0x94 0x91..0x98 0x00..0xFF  #
+      | 0xF0 0x94 0x99 0x00..0x86        #
+      | 0xF0 0x96 0xA0 0x80..0xFF        #Lo [569] BAMUM LETTER PHASE-A NGKU...
+      | 0xF0 0x96 0xA1..0xA7 0x00..0xFF  #
+      | 0xF0 0x96 0xA8 0x00..0xB8        #
+      | 0xF0 0x96 0xA9 0x80..0x9E  #Lo  [31] MRO LETTER TA..MRO LETTER TEK
+      | 0xF0 0x96 0xAB 0x90..0xAD  #Lo  [30] BASSA VAH LETTER ENNI..BASSA VA...
+      | 0xF0 0x96 0xAC 0x80..0xAF  #Lo  [48] PAHAWH HMONG VOWEL KEEB..PAHAWH...
+      | 0xF0 0x96 0xAD 0x80..0x83  #Lm   [4] PAHAWH HMONG SIGN VOS SEEV..PAH...
+      | 0xF0 0x96 0xAD 0xA3..0xB7  #Lo  [21] PAHAWH HMONG SIGN VOS LUB..PAHA...
+      | 0xF0 0x96 0xAD 0xBD..0xFF  #Lo  [19] PAHAWH HMONG CLAN SIGN TSHEEJ.....
+      | 0xF0 0x96 0xAE 0x00..0x8F  #
+      | 0xF0 0x96 0xBC 0x80..0xFF  #Lo  [69] MIAO LETTER PA..MIAO LETTER HHA
+      | 0xF0 0x96 0xBD 0x00..0x84  #
+      | 0xF0 0x96 0xBD 0x90     #Lo       MIAO LETTER NASALIZATION
+      | 0xF0 0x96 0xBE 0x93..0x9F  #Lm  [13] MIAO LETTER TONE-2..MIAO LETTER...
+      | 0xF0 0x96 0xBF 0xA0     #Lm       TANGUT ITERATION MARK
+      | 0xF0 0x97 0x80 0x80..0xFF        #Lo [6125] TANGUT IDEOGRAPH-17000.....
+      | 0xF0 0x97 0x81..0xFF 0x00..0xFF  #
+      | 0xF0 0x98 0x00 0x00..0xFF        #
+      | 0xF0 0x98 0x01..0x9E 0x00..0xFF  #
+      | 0xF0 0x98 0x9F 0x00..0xAC        #
+      | 0xF0 0x98 0xA0 0x80..0xFF        #Lo [755] TANGUT COMPONENT-001..TAN...
+      | 0xF0 0x98 0xA1..0xAA 0x00..0xFF  #
+      | 0xF0 0x98 0xAB 0x00..0xB2        #
+      | 0xF0 0x9B 0x80 0x80..0x81  #Lo   [2] KATAKANA LETTER ARCHAIC E..HIRA...
+      | 0xF0 0x9B 0xB0 0x80..0xFF  #Lo [107] DUPLOYAN LETTER H..DUPLOYAN LET...
+      | 0xF0 0x9B 0xB1 0x00..0xAA  #
+      | 0xF0 0x9B 0xB1 0xB0..0xBC  #Lo  [13] DUPLOYAN AFFIX LEFT HORIZONTAL ...
+      | 0xF0 0x9B 0xB2 0x80..0x88  #Lo   [9] DUPLOYAN AFFIX HIGH ACUTE..DUPL...
+      | 0xF0 0x9B 0xB2 0x90..0x99  #Lo  [10] DUPLOYAN AFFIX LOW ACUTE..DUPLO...
+      | 0xF0 0x9D 0x90 0x80..0xFF  #L&  [85] MATHEMATICAL BOLD CAPITAL A..MA...
+      | 0xF0 0x9D 0x91 0x00..0x94  #
+      | 0xF0 0x9D 0x91 0x96..0xFF  #L&  [71] MATHEMATICAL ITALIC SMALL I..MA...
+      | 0xF0 0x9D 0x92 0x00..0x9C  #
+      | 0xF0 0x9D 0x92 0x9E..0x9F  #L&   [2] MATHEMATICAL SCRIPT CAPITAL C.....
+      | 0xF0 0x9D 0x92 0xA2     #L&       MATHEMATICAL SCRIPT CAPITAL G
+      | 0xF0 0x9D 0x92 0xA5..0xA6  #L&   [2] MATHEMATICAL SCRIPT CAPITAL J.....
+      | 0xF0 0x9D 0x92 0xA9..0xAC  #L&   [4] MATHEMATICAL SCRIPT CAPITAL N.....
+      | 0xF0 0x9D 0x92 0xAE..0xB9  #L&  [12] MATHEMATICAL SCRIPT CAPITAL S.....
+      | 0xF0 0x9D 0x92 0xBB     #L&       MATHEMATICAL SCRIPT SMALL F
+      | 0xF0 0x9D 0x92 0xBD..0xFF  #L&   [7] MATHEMATICAL SCRIPT SMALL H..MA...
+      | 0xF0 0x9D 0x93 0x00..0x83  #
+      | 0xF0 0x9D 0x93 0x85..0xFF  #L&  [65] MATHEMATICAL SCRIPT SMALL P..MA...
+      | 0xF0 0x9D 0x94 0x00..0x85  #
+      | 0xF0 0x9D 0x94 0x87..0x8A  #L&   [4] MATHEMATICAL FRAKTUR CAPITAL D....
+      | 0xF0 0x9D 0x94 0x8D..0x94  #L&   [8] MATHEMATICAL FRAKTUR CAPITAL J....
+      | 0xF0 0x9D 0x94 0x96..0x9C  #L&   [7] MATHEMATICAL FRAKTUR CAPITAL S....
+      | 0xF0 0x9D 0x94 0x9E..0xB9  #L&  [28] MATHEMATICAL FRAKTUR SMALL A..M...
+      | 0xF0 0x9D 0x94 0xBB..0xBE  #L&   [4] MATHEMATICAL DOUBLE-STRUCK CAPI...
+      | 0xF0 0x9D 0x95 0x80..0x84  #L&   [5] MATHEMATICAL DOUBLE-STRUCK CAPI...
+      | 0xF0 0x9D 0x95 0x86     #L&       MATHEMATICAL DOUBLE-STRUCK CAPITAL O
+      | 0xF0 0x9D 0x95 0x8A..0x90  #L&   [7] MATHEMATICAL DOUBLE-STRUCK CAPI...
+      | 0xF0 0x9D 0x95 0x92..0xFF        #L& [340] MATHEMATICAL DOUBLE-STRUC...
+      | 0xF0 0x9D 0x96..0x99 0x00..0xFF  #
+      | 0xF0 0x9D 0x9A 0x00..0xA5        #
+      | 0xF0 0x9D 0x9A 0xA8..0xFF  #L&  [25] MATHEMATICAL BOLD CAPITAL ALPHA...
+      | 0xF0 0x9D 0x9B 0x00..0x80  #
+      | 0xF0 0x9D 0x9B 0x82..0x9A  #L&  [25] MATHEMATICAL BOLD SMALL ALPHA.....
+      | 0xF0 0x9D 0x9B 0x9C..0xBA  #L&  [31] MATHEMATICAL BOLD EPSILON SYMBO...
+      | 0xF0 0x9D 0x9B 0xBC..0xFF  #L&  [25] MATHEMATICAL ITALIC SMALL ALPHA...
+      | 0xF0 0x9D 0x9C 0x00..0x94  #
+      | 0xF0 0x9D 0x9C 0x96..0xB4  #L&  [31] MATHEMATICAL ITALIC EPSILON SYM...
+      | 0xF0 0x9D 0x9C 0xB6..0xFF  #L&  [25] MATHEMATICAL BOLD ITALIC SMALL ...
+      | 0xF0 0x9D 0x9D 0x00..0x8E  #
+      | 0xF0 0x9D 0x9D 0x90..0xAE  #L&  [31] MATHEMATICAL BOLD ITALIC EPSILO...
+      | 0xF0 0x9D 0x9D 0xB0..0xFF  #L&  [25] MATHEMATICAL SANS-SERIF BOLD SM...
+      | 0xF0 0x9D 0x9E 0x00..0x88  #
+      | 0xF0 0x9D 0x9E 0x8A..0xA8  #L&  [31] MATHEMATICAL SANS-SERIF BOLD EP...
+      | 0xF0 0x9D 0x9E 0xAA..0xFF  #L&  [25] MATHEMATICAL SANS-SERIF BOLD IT...
+      | 0xF0 0x9D 0x9F 0x00..0x82  #
+      | 0xF0 0x9D 0x9F 0x84..0x8B  #L&   [8] MATHEMATICAL SANS-SERIF BOLD IT...
+      | 0xF0 0x9E 0xA0 0x80..0xFF        #Lo [197] MENDE KIKAKUI SYLLABLE M0...
+      | 0xF0 0x9E 0xA1..0xA2 0x00..0xFF  #
+      | 0xF0 0x9E 0xA3 0x00..0x84        #
+      | 0xF0 0x9E 0xA4 0x80..0xFF  #L&  [68] ADLAM CAPITAL LETTER ALIF..ADLA...
+      | 0xF0 0x9E 0xA5 0x00..0x83  #
+      | 0xF0 0x9E 0xB8 0x80..0x83  #Lo   [4] ARABIC MATHEMATICAL ALEF..ARABI...
+      | 0xF0 0x9E 0xB8 0x85..0x9F  #Lo  [27] ARABIC MATHEMATICAL WAW..ARABIC...
+      | 0xF0 0x9E 0xB8 0xA1..0xA2  #Lo   [2] ARABIC MATHEMATICAL INITIAL BEH...
+      | 0xF0 0x9E 0xB8 0xA4     #Lo       ARABIC MATHEMATICAL INITIAL HEH
+      | 0xF0 0x9E 0xB8 0xA7     #Lo       ARABIC MATHEMATICAL INITIAL HAH
+      | 0xF0 0x9E 0xB8 0xA9..0xB2  #Lo  [10] ARABIC MATHEMATICAL INITIAL YEH...
+      | 0xF0 0x9E 0xB8 0xB4..0xB7  #Lo   [4] ARABIC MATHEMATICAL INITIAL SHE...
+      | 0xF0 0x9E 0xB8 0xB9     #Lo       ARABIC MATHEMATICAL INITIAL DAD
+      | 0xF0 0x9E 0xB8 0xBB     #Lo       ARABIC MATHEMATICAL INITIAL GHAIN
+      | 0xF0 0x9E 0xB9 0x82     #Lo       ARABIC MATHEMATICAL TAILED JEEM
+      | 0xF0 0x9E 0xB9 0x87     #Lo       ARABIC MATHEMATICAL TAILED HAH
+      | 0xF0 0x9E 0xB9 0x89     #Lo       ARABIC MATHEMATICAL TAILED YEH
+      | 0xF0 0x9E 0xB9 0x8B     #Lo       ARABIC MATHEMATICAL TAILED LAM
+      | 0xF0 0x9E 0xB9 0x8D..0x8F  #Lo   [3] ARABIC MATHEMATICAL TAILED NOON...
+      | 0xF0 0x9E 0xB9 0x91..0x92  #Lo   [2] ARABIC MATHEMATICAL TAILED SAD....
+      | 0xF0 0x9E 0xB9 0x94     #Lo       ARABIC MATHEMATICAL TAILED SHEEN
+      | 0xF0 0x9E 0xB9 0x97     #Lo       ARABIC MATHEMATICAL TAILED KHAH
+      | 0xF0 0x9E 0xB9 0x99     #Lo       ARABIC MATHEMATICAL TAILED DAD
+      | 0xF0 0x9E 0xB9 0x9B     #Lo       ARABIC MATHEMATICAL TAILED GHAIN
+      | 0xF0 0x9E 0xB9 0x9D     #Lo       ARABIC MATHEMATICAL TAILED DOTLESS...
+      | 0xF0 0x9E 0xB9 0x9F     #Lo       ARABIC MATHEMATICAL TAILED DOTLESS...
+      | 0xF0 0x9E 0xB9 0xA1..0xA2  #Lo   [2] ARABIC MATHEMATICAL STRETCHED B...
+      | 0xF0 0x9E 0xB9 0xA4     #Lo       ARABIC MATHEMATICAL STRETCHED HEH
+      | 0xF0 0x9E 0xB9 0xA7..0xAA  #Lo   [4] ARABIC MATHEMATICAL STRETCHED H...
+      | 0xF0 0x9E 0xB9 0xAC..0xB2  #Lo   [7] ARABIC MATHEMATICAL STRETCHED M...
+      | 0xF0 0x9E 0xB9 0xB4..0xB7  #Lo   [4] ARABIC MATHEMATICAL STRETCHED S...
+      | 0xF0 0x9E 0xB9 0xB9..0xBC  #Lo   [4] ARABIC MATHEMATICAL STRETCHED D...
+      | 0xF0 0x9E 0xB9 0xBE     #Lo       ARABIC MATHEMATICAL STRETCHED DOTL...
+      | 0xF0 0x9E 0xBA 0x80..0x89  #Lo  [10] ARABIC MATHEMATICAL LOOPED ALEF...
+      | 0xF0 0x9E 0xBA 0x8B..0x9B  #Lo  [17] ARABIC MATHEMATICAL LOOPED LAM....
+      | 0xF0 0x9E 0xBA 0xA1..0xA3  #Lo   [3] ARABIC MATHEMATICAL DOUBLE-STRU...
+      | 0xF0 0x9E 0xBA 0xA5..0xA9  #Lo   [5] ARABIC MATHEMATICAL DOUBLE-STRU...
+      | 0xF0 0x9E 0xBA 0xAB..0xBB  #Lo  [17] ARABIC MATHEMATICAL DOUBLE-STRU...
+      | 0xF0 0xA0 0x80 0x80..0xFF              #Lo [42711] CJK UNIFIED IDEOG...
+      | 0xF0 0xA0 0x81..0xFF 0x00..0xFF        #
+      | 0xF0 0xA1..0xA9 0x00..0xFF 0x00..0xFF  #
+      | 0xF0 0xAA 0x00 0x00..0xFF              #
+      | 0xF0 0xAA 0x01..0x9A 0x00..0xFF        #
+      | 0xF0 0xAA 0x9B 0x00..0x96              #
+      | 0xF0 0xAA 0x9C 0x80..0xFF        #Lo [4149] CJK UNIFIED IDEOGRAPH-2A...
+      | 0xF0 0xAA 0x9D..0xFF 0x00..0xFF  #
+      | 0xF0 0xAB 0x00 0x00..0xFF        #
+      | 0xF0 0xAB 0x01..0x9B 0x00..0xFF  #
+      | 0xF0 0xAB 0x9C 0x00..0xB4        #
+      | 0xF0 0xAB 0x9D 0x80..0xFF        #Lo [222] CJK UNIFIED IDEOGRAPH-2B7...
+      | 0xF0 0xAB 0x9E..0x9F 0x00..0xFF  #
+      | 0xF0 0xAB 0xA0 0x00..0x9D        #
+      | 0xF0 0xAB 0xA0 0xA0..0xFF        #Lo [5762] CJK UNIFIED IDEOGRAPH-2B...
+      | 0xF0 0xAB 0xA1..0xFF 0x00..0xFF  #
+      | 0xF0 0xAC 0x00 0x00..0xFF        #
+      | 0xF0 0xAC 0x01..0xB9 0x00..0xFF  #
+      | 0xF0 0xAC 0xBA 0x00..0xA1        #
+      | 0xF0 0xAF 0xA0 0x80..0xFF        #Lo [542] CJK COMPATIBILITY IDEOGRA...
+      | 0xF0 0xAF 0xA1..0xA7 0x00..0xFF  #
+      | 0xF0 0xAF 0xA8 0x00..0x9D        #
+      ;
+
+    ID_Continue = 
+        0x30..0x39              #Nd  [10] DIGIT ZERO..DIGIT NINE
+      | 0x41..0x5A              #L&  [26] LATIN CAPITAL LETTER A..LATIN CAPI...
+      | 0x5F                    #Pc       LOW LINE
+      | 0x61..0x7A              #L&  [26] LATIN SMALL LETTER A..LATIN SMALL ...
+      | 0xC2 0xAA               #Lo       FEMININE ORDINAL INDICATOR
+      | 0xC2 0xB5               #L&       MICRO SIGN
+      | 0xC2 0xB7               #Po       MIDDLE DOT
+      | 0xC2 0xBA               #Lo       MASCULINE ORDINAL INDICATOR
+      | 0xC3 0x80..0x96         #L&  [23] LATIN CAPITAL LETTER A WITH GRAVE....
+      | 0xC3 0x98..0xB6         #L&  [31] LATIN CAPITAL LETTER O WITH STROKE...
+      | 0xC3 0xB8..0xFF         #L& [195] LATIN SMALL LETTER O WITH STROKE.....
+      | 0xC4..0xC5 0x00..0xFF   #
+      | 0xC6 0x00..0xBA         #
+      | 0xC6 0xBB               #Lo       LATIN LETTER TWO WITH STROKE
+      | 0xC6 0xBC..0xBF         #L&   [4] LATIN CAPITAL LETTER TONE FIVE..LA...
+      | 0xC7 0x80..0x83         #Lo   [4] LATIN LETTER DENTAL CLICK..LATIN L...
+      | 0xC7 0x84..0xFF         #L& [208] LATIN CAPITAL LETTER DZ WITH CARON...
+      | 0xC8..0xC9 0x00..0xFF   #
+      | 0xCA 0x00..0x93         #
+      | 0xCA 0x94               #Lo       LATIN LETTER GLOTTAL STOP
+      | 0xCA 0x95..0xAF         #L&  [27] LATIN LETTER PHARYNGEAL VOICED FRI...
+      | 0xCA 0xB0..0xFF         #Lm  [18] MODIFIER LETTER SMALL H..MODIFIER ...
+      | 0xCB 0x00..0x81         #
+      | 0xCB 0x86..0x91         #Lm  [12] MODIFIER LETTER CIRCUMFLEX ACCENT....
+      | 0xCB 0xA0..0xA4         #Lm   [5] MODIFIER LETTER SMALL GAMMA..MODIF...
+      | 0xCB 0xAC               #Lm       MODIFIER LETTER VOICING
+      | 0xCB 0xAE               #Lm       MODIFIER LETTER DOUBLE APOSTROPHE
+      | 0xCC 0x80..0xFF         #Mn [112] COMBINING GRAVE ACCENT..COMBINING ...
+      | 0xCD 0x00..0xAF         #
+      | 0xCD 0xB0..0xB3         #L&   [4] GREEK CAPITAL LETTER HETA..GREEK S...
+      | 0xCD 0xB4               #Lm       GREEK NUMERAL SIGN
+      | 0xCD 0xB6..0xB7         #L&   [2] GREEK CAPITAL LETTER PAMPHYLIAN DI...
+      | 0xCD 0xBA               #Lm       GREEK YPOGEGRAMMENI
+      | 0xCD 0xBB..0xBD         #L&   [3] GREEK SMALL REVERSED LUNATE SIGMA ...
+      | 0xCD 0xBF               #L&       GREEK CAPITAL LETTER YOT
+      | 0xCE 0x86               #L&       GREEK CAPITAL LETTER ALPHA WITH TONOS
+      | 0xCE 0x87               #Po       GREEK ANO TELEIA
+      | 0xCE 0x88..0x8A         #L&   [3] GREEK CAPITAL LETTER EPSILON WITH ...
+      | 0xCE 0x8C               #L&       GREEK CAPITAL LETTER OMICRON WITH ...
+      | 0xCE 0x8E..0xA1         #L&  [20] GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xCE 0xA3..0xFF         #L&  [83] GREEK CAPITAL LETTER SIGMA..GREEK ...
+      | 0xCF 0x00..0xB5         #
+      | 0xCF 0xB7..0xFF         #L& [139] GREEK CAPITAL LETTER SHO..CYRILLIC...
+      | 0xD0..0xD1 0x00..0xFF   #
+      | 0xD2 0x00..0x81         #
+      | 0xD2 0x83..0x87         #Mn   [5] COMBINING CYRILLIC TITLO..COMBININ...
+      | 0xD2 0x8A..0xFF         #L& [166] CYRILLIC CAPITAL LETTER SHORT I WI...
+      | 0xD3..0xD3 0x00..0xFF   #
+      | 0xD4 0x00..0xAF         #
+      | 0xD4 0xB1..0xFF         #L&  [38] ARMENIAN CAPITAL LETTER AYB..ARMEN...
+      | 0xD5 0x00..0x96         #
+      | 0xD5 0x99               #Lm       ARMENIAN MODIFIER LETTER LEFT HALF...
+      | 0xD5 0xA1..0xFF         #L&  [39] ARMENIAN SMALL LETTER AYB..ARMENIA...
+      | 0xD6 0x00..0x87         #
+      | 0xD6 0x91..0xBD         #Mn  [45] HEBREW ACCENT ETNAHTA..HEBREW POIN...
+      | 0xD6 0xBF               #Mn       HEBREW POINT RAFE
+      | 0xD7 0x81..0x82         #Mn   [2] HEBREW POINT SHIN DOT..HEBREW POIN...
+      | 0xD7 0x84..0x85         #Mn   [2] HEBREW MARK UPPER DOT..HEBREW MARK...
+      | 0xD7 0x87               #Mn       HEBREW POINT QAMATS QATAN
+      | 0xD7 0x90..0xAA         #Lo  [27] HEBREW LETTER ALEF..HEBREW LETTER TAV
+      | 0xD7 0xB0..0xB2         #Lo   [3] HEBREW LIGATURE YIDDISH DOUBLE VAV...
+      | 0xD8 0x90..0x9A         #Mn  [11] ARABIC SIGN SALLALLAHOU ALAYHE WAS...
+      | 0xD8 0xA0..0xBF         #Lo  [32] ARABIC LETTER KASHMIRI YEH..ARABIC...
+      | 0xD9 0x80               #Lm       ARABIC TATWEEL
+      | 0xD9 0x81..0x8A         #Lo  [10] ARABIC LETTER FEH..ARABIC LETTER YEH
+      | 0xD9 0x8B..0x9F         #Mn  [21] ARABIC FATHATAN..ARABIC WAVY HAMZA...
+      | 0xD9 0xA0..0xA9         #Nd  [10] ARABIC-INDIC DIGIT ZERO..ARABIC-IN...
+      | 0xD9 0xAE..0xAF         #Lo   [2] ARABIC LETTER DOTLESS BEH..ARABIC ...
+      | 0xD9 0xB0               #Mn       ARABIC LETTER SUPERSCRIPT ALEF
+      | 0xD9 0xB1..0xFF         #Lo  [99] ARABIC LETTER ALEF WASLA..ARABIC L...
+      | 0xDA..0xDA 0x00..0xFF   #
+      | 0xDB 0x00..0x93         #
+      | 0xDB 0x95               #Lo       ARABIC LETTER AE
+      | 0xDB 0x96..0x9C         #Mn   [7] ARABIC SMALL HIGH LIGATURE SAD WIT...
+      | 0xDB 0x9F..0xA4         #Mn   [6] ARABIC SMALL HIGH ROUNDED ZERO..AR...
+      | 0xDB 0xA5..0xA6         #Lm   [2] ARABIC SMALL WAW..ARABIC SMALL YEH
+      | 0xDB 0xA7..0xA8         #Mn   [2] ARABIC SMALL HIGH YEH..ARABIC SMAL...
+      | 0xDB 0xAA..0xAD         #Mn   [4] ARABIC EMPTY CENTRE LOW STOP..ARAB...
+      | 0xDB 0xAE..0xAF         #Lo   [2] ARABIC LETTER DAL WITH INVERTED V....
+      | 0xDB 0xB0..0xB9         #Nd  [10] EXTENDED ARABIC-INDIC DIGIT ZERO.....
+      | 0xDB 0xBA..0xBC         #Lo   [3] ARABIC LETTER SHEEN WITH DOT BELOW...
+      | 0xDB 0xBF               #Lo       ARABIC LETTER HEH WITH INVERTED V
+      | 0xDC 0x90               #Lo       SYRIAC LETTER ALAPH
+      | 0xDC 0x91               #Mn       SYRIAC LETTER SUPERSCRIPT ALAPH
+      | 0xDC 0x92..0xAF         #Lo  [30] SYRIAC LETTER BETH..SYRIAC LETTER ...
+      | 0xDC 0xB0..0xFF         #Mn  [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH
+      | 0xDD 0x00..0x8A         #
+      | 0xDD 0x8D..0xFF         #Lo  [89] SYRIAC LETTER SOGDIAN ZHAIN..THAAN...
+      | 0xDE 0x00..0xA5         #
+      | 0xDE 0xA6..0xB0         #Mn  [11] THAANA ABAFILI..THAANA SUKUN
+      | 0xDE 0xB1               #Lo       THAANA LETTER NAA
+      | 0xDF 0x80..0x89         #Nd  [10] NKO DIGIT ZERO..NKO DIGIT NINE
+      | 0xDF 0x8A..0xAA         #Lo  [33] NKO LETTER A..NKO LETTER JONA RA
+      | 0xDF 0xAB..0xB3         #Mn   [9] NKO COMBINING SHORT HIGH TONE..NKO...
+      | 0xDF 0xB4..0xB5         #Lm   [2] NKO HIGH TONE APOSTROPHE..NKO LOW ...
+      | 0xDF 0xBA               #Lm       NKO LAJANYALAN
+      | 0xE0 0xA0 0x80..0x95    #Lo  [22] SAMARITAN LETTER ALAF..SAMARITAN L...
+      | 0xE0 0xA0 0x96..0x99    #Mn   [4] SAMARITAN MARK IN..SAMARITAN MARK ...
+      | 0xE0 0xA0 0x9A          #Lm       SAMARITAN MODIFIER LETTER EPENTHET...
+      | 0xE0 0xA0 0x9B..0xA3    #Mn   [9] SAMARITAN MARK EPENTHETIC YUT..SAM...
+      | 0xE0 0xA0 0xA4          #Lm       SAMARITAN MODIFIER LETTER SHORT A
+      | 0xE0 0xA0 0xA5..0xA7    #Mn   [3] SAMARITAN VOWEL SIGN SHORT A..SAMA...
+      | 0xE0 0xA0 0xA8          #Lm       SAMARITAN MODIFIER LETTER I
+      | 0xE0 0xA0 0xA9..0xAD    #Mn   [5] SAMARITAN VOWEL SIGN LONG I..SAMAR...
+      | 0xE0 0xA1 0x80..0x98    #Lo  [25] MANDAIC LETTER HALQA..MANDAIC LETT...
+      | 0xE0 0xA1 0x99..0x9B    #Mn   [3] MANDAIC AFFRICATION MARK..MANDAIC ...
+      | 0xE0 0xA2 0xA0..0xB4    #Lo  [21] ARABIC LETTER BEH WITH SMALL V BEL...
+      | 0xE0 0xA2 0xB6..0xBD    #Lo   [8] ARABIC LETTER BEH WITH SMALL MEEM ...
+      | 0xE0 0xA3 0x94..0xA1    #Mn  [14] ARABIC SMALL HIGH WORD AR-RUB..ARA...
+      | 0xE0 0xA3 0xA3..0xFF    #Mn  [32] ARABIC TURNED DAMMA BELOW..DEVANAG...
+      | 0xE0 0xA4 0x00..0x82    #
+      | 0xE0 0xA4 0x83          #Mc       DEVANAGARI SIGN VISARGA
+      | 0xE0 0xA4 0x84..0xB9    #Lo  [54] DEVANAGARI LETTER SHORT A..DEVANAG...
+      | 0xE0 0xA4 0xBA          #Mn       DEVANAGARI VOWEL SIGN OE
+      | 0xE0 0xA4 0xBB          #Mc       DEVANAGARI VOWEL SIGN OOE
+      | 0xE0 0xA4 0xBC          #Mn       DEVANAGARI SIGN NUKTA
+      | 0xE0 0xA4 0xBD          #Lo       DEVANAGARI SIGN AVAGRAHA
+      | 0xE0 0xA4 0xBE..0xFF    #Mc   [3] DEVANAGARI VOWEL SIGN AA..DEVANAGA...
+      | 0xE0 0xA5 0x00..0x80    #
+      | 0xE0 0xA5 0x81..0x88    #Mn   [8] DEVANAGARI VOWEL SIGN U..DEVANAGAR...
+      | 0xE0 0xA5 0x89..0x8C    #Mc   [4] DEVANAGARI VOWEL SIGN CANDRA O..DE...
+      | 0xE0 0xA5 0x8D          #Mn       DEVANAGARI SIGN VIRAMA
+      | 0xE0 0xA5 0x8E..0x8F    #Mc   [2] DEVANAGARI VOWEL SIGN PRISHTHAMATR...
+      | 0xE0 0xA5 0x90          #Lo       DEVANAGARI OM
+      | 0xE0 0xA5 0x91..0x97    #Mn   [7] DEVANAGARI STRESS SIGN UDATTA..DEV...
+      | 0xE0 0xA5 0x98..0xA1    #Lo  [10] DEVANAGARI LETTER QA..DEVANAGARI L...
+      | 0xE0 0xA5 0xA2..0xA3    #Mn   [2] DEVANAGARI VOWEL SIGN VOCALIC L..D...
+      | 0xE0 0xA5 0xA6..0xAF    #Nd  [10] DEVANAGARI DIGIT ZERO..DEVANAGARI ...
+      | 0xE0 0xA5 0xB1          #Lm       DEVANAGARI SIGN HIGH SPACING DOT
+      | 0xE0 0xA5 0xB2..0xFF    #Lo  [15] DEVANAGARI LETTER CANDRA A..BENGAL...
+      | 0xE0 0xA6 0x00..0x80    #
+      | 0xE0 0xA6 0x81          #Mn       BENGALI SIGN CANDRABINDU
+      | 0xE0 0xA6 0x82..0x83    #Mc   [2] BENGALI SIGN ANUSVARA..BENGALI SIG...
+      | 0xE0 0xA6 0x85..0x8C    #Lo   [8] BENGALI LETTER A..BENGALI LETTER V...
+      | 0xE0 0xA6 0x8F..0x90    #Lo   [2] BENGALI LETTER E..BENGALI LETTER AI
+      | 0xE0 0xA6 0x93..0xA8    #Lo  [22] BENGALI LETTER O..BENGALI LETTER NA
+      | 0xE0 0xA6 0xAA..0xB0    #Lo   [7] BENGALI LETTER PA..BENGALI LETTER RA
+      | 0xE0 0xA6 0xB2          #Lo       BENGALI LETTER LA
+      | 0xE0 0xA6 0xB6..0xB9    #Lo   [4] BENGALI LETTER SHA..BENGALI LETTER HA
+      | 0xE0 0xA6 0xBC          #Mn       BENGALI SIGN NUKTA
+      | 0xE0 0xA6 0xBD          #Lo       BENGALI SIGN AVAGRAHA
+      | 0xE0 0xA6 0xBE..0xFF    #Mc   [3] BENGALI VOWEL SIGN AA..BENGALI VOW...
+      | 0xE0 0xA7 0x00..0x80    #
+      | 0xE0 0xA7 0x81..0x84    #Mn   [4] BENGALI VOWEL SIGN U..BENGALI VOWE...
+      | 0xE0 0xA7 0x87..0x88    #Mc   [2] BENGALI VOWEL SIGN E..BENGALI VOWE...
+      | 0xE0 0xA7 0x8B..0x8C    #Mc   [2] BENGALI VOWEL SIGN O..BENGALI VOWE...
+      | 0xE0 0xA7 0x8D          #Mn       BENGALI SIGN VIRAMA
+      | 0xE0 0xA7 0x8E          #Lo       BENGALI LETTER KHANDA TA
+      | 0xE0 0xA7 0x97          #Mc       BENGALI AU LENGTH MARK
+      | 0xE0 0xA7 0x9C..0x9D    #Lo   [2] BENGALI LETTER RRA..BENGALI LETTER...
+      | 0xE0 0xA7 0x9F..0xA1    #Lo   [3] BENGALI LETTER YYA..BENGALI LETTER...
+      | 0xE0 0xA7 0xA2..0xA3    #Mn   [2] BENGALI VOWEL SIGN VOCALIC L..BENG...
+      | 0xE0 0xA7 0xA6..0xAF    #Nd  [10] BENGALI DIGIT ZERO..BENGALI DIGIT ...
+      | 0xE0 0xA7 0xB0..0xB1    #Lo   [2] BENGALI LETTER RA WITH MIDDLE DIAG...
+      | 0xE0 0xA8 0x81..0x82    #Mn   [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI...
+      | 0xE0 0xA8 0x83          #Mc       GURMUKHI SIGN VISARGA
+      | 0xE0 0xA8 0x85..0x8A    #Lo   [6] GURMUKHI LETTER A..GURMUKHI LETTER UU
+      | 0xE0 0xA8 0x8F..0x90    #Lo   [2] GURMUKHI LETTER EE..GURMUKHI LETTE...
+      | 0xE0 0xA8 0x93..0xA8    #Lo  [22] GURMUKHI LETTER OO..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xAA..0xB0    #Lo   [7] GURMUKHI LETTER PA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xB2..0xB3    #Lo   [2] GURMUKHI LETTER LA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xB5..0xB6    #Lo   [2] GURMUKHI LETTER VA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xB8..0xB9    #Lo   [2] GURMUKHI LETTER SA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xBC          #Mn       GURMUKHI SIGN NUKTA
+      | 0xE0 0xA8 0xBE..0xFF    #Mc   [3] GURMUKHI VOWEL SIGN AA..GURMUKHI V...
+      | 0xE0 0xA9 0x00..0x80    #
+      | 0xE0 0xA9 0x81..0x82    #Mn   [2] GURMUKHI VOWEL SIGN U..GURMUKHI VO...
+      | 0xE0 0xA9 0x87..0x88    #Mn   [2] GURMUKHI VOWEL SIGN EE..GURMUKHI V...
+      | 0xE0 0xA9 0x8B..0x8D    #Mn   [3] GURMUKHI VOWEL SIGN OO..GURMUKHI S...
+      | 0xE0 0xA9 0x91          #Mn       GURMUKHI SIGN UDAAT
+      | 0xE0 0xA9 0x99..0x9C    #Lo   [4] GURMUKHI LETTER KHHA..GURMUKHI LET...
+      | 0xE0 0xA9 0x9E          #Lo       GURMUKHI LETTER FA
+      | 0xE0 0xA9 0xA6..0xAF    #Nd  [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGI...
+      | 0xE0 0xA9 0xB0..0xB1    #Mn   [2] GURMUKHI TIPPI..GURMUKHI ADDAK
+      | 0xE0 0xA9 0xB2..0xB4    #Lo   [3] GURMUKHI IRI..GURMUKHI EK ONKAR
+      | 0xE0 0xA9 0xB5          #Mn       GURMUKHI SIGN YAKASH
+      | 0xE0 0xAA 0x81..0x82    #Mn   [2] GUJARATI SIGN CANDRABINDU..GUJARAT...
+      | 0xE0 0xAA 0x83          #Mc       GUJARATI SIGN VISARGA
+      | 0xE0 0xAA 0x85..0x8D    #Lo   [9] GUJARATI LETTER A..GUJARATI VOWEL ...
+      | 0xE0 0xAA 0x8F..0x91    #Lo   [3] GUJARATI LETTER E..GUJARATI VOWEL ...
+      | 0xE0 0xAA 0x93..0xA8    #Lo  [22] GUJARATI LETTER O..GUJARATI LETTER NA
+      | 0xE0 0xAA 0xAA..0xB0    #Lo   [7] GUJARATI LETTER PA..GUJARATI LETTE...
+      | 0xE0 0xAA 0xB2..0xB3    #Lo   [2] GUJARATI LETTER LA..GUJARATI LETTE...
+      | 0xE0 0xAA 0xB5..0xB9    #Lo   [5] GUJARATI LETTER VA..GUJARATI LETTE...
+      | 0xE0 0xAA 0xBC          #Mn       GUJARATI SIGN NUKTA
+      | 0xE0 0xAA 0xBD          #Lo       GUJARATI SIGN AVAGRAHA
+      | 0xE0 0xAA 0xBE..0xFF    #Mc   [3] GUJARATI VOWEL SIGN AA..GUJARATI V...
+      | 0xE0 0xAB 0x00..0x80    #
+      | 0xE0 0xAB 0x81..0x85    #Mn   [5] GUJARATI VOWEL SIGN U..GUJARATI VO...
+      | 0xE0 0xAB 0x87..0x88    #Mn   [2] GUJARATI VOWEL SIGN E..GUJARATI VO...
+      | 0xE0 0xAB 0x89          #Mc       GUJARATI VOWEL SIGN CANDRA O
+      | 0xE0 0xAB 0x8B..0x8C    #Mc   [2] GUJARATI VOWEL SIGN O..GUJARATI VO...
+      | 0xE0 0xAB 0x8D          #Mn       GUJARATI SIGN VIRAMA
+      | 0xE0 0xAB 0x90          #Lo       GUJARATI OM
+      | 0xE0 0xAB 0xA0..0xA1    #Lo   [2] GUJARATI LETTER VOCALIC RR..GUJARA...
+      | 0xE0 0xAB 0xA2..0xA3    #Mn   [2] GUJARATI VOWEL SIGN VOCALIC L..GUJ...
+      | 0xE0 0xAB 0xA6..0xAF    #Nd  [10] GUJARATI DIGIT ZERO..GUJARATI DIGI...
+      | 0xE0 0xAB 0xB9          #Lo       GUJARATI LETTER ZHA
+      | 0xE0 0xAC 0x81          #Mn       ORIYA SIGN CANDRABINDU
+      | 0xE0 0xAC 0x82..0x83    #Mc   [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VI...
+      | 0xE0 0xAC 0x85..0x8C    #Lo   [8] ORIYA LETTER A..ORIYA LETTER VOCAL...
+      | 0xE0 0xAC 0x8F..0x90    #Lo   [2] ORIYA LETTER E..ORIYA LETTER AI
+      | 0xE0 0xAC 0x93..0xA8    #Lo  [22] ORIYA LETTER O..ORIYA LETTER NA
+      | 0xE0 0xAC 0xAA..0xB0    #Lo   [7] ORIYA LETTER PA..ORIYA LETTER RA
+      | 0xE0 0xAC 0xB2..0xB3    #Lo   [2] ORIYA LETTER LA..ORIYA LETTER LLA
+      | 0xE0 0xAC 0xB5..0xB9    #Lo   [5] ORIYA LETTER VA..ORIYA LETTER HA
+      | 0xE0 0xAC 0xBC          #Mn       ORIYA SIGN NUKTA
+      | 0xE0 0xAC 0xBD          #Lo       ORIYA SIGN AVAGRAHA
+      | 0xE0 0xAC 0xBE          #Mc       ORIYA VOWEL SIGN AA
+      | 0xE0 0xAC 0xBF          #Mn       ORIYA VOWEL SIGN I
+      | 0xE0 0xAD 0x80          #Mc       ORIYA VOWEL SIGN II
+      | 0xE0 0xAD 0x81..0x84    #Mn   [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SI...
+      | 0xE0 0xAD 0x87..0x88    #Mc   [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SI...
+      | 0xE0 0xAD 0x8B..0x8C    #Mc   [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SI...
+      | 0xE0 0xAD 0x8D          #Mn       ORIYA SIGN VIRAMA
+      | 0xE0 0xAD 0x96          #Mn       ORIYA AI LENGTH MARK
+      | 0xE0 0xAD 0x97          #Mc       ORIYA AU LENGTH MARK
+      | 0xE0 0xAD 0x9C..0x9D    #Lo   [2] ORIYA LETTER RRA..ORIYA LETTER RHA
+      | 0xE0 0xAD 0x9F..0xA1    #Lo   [3] ORIYA LETTER YYA..ORIYA LETTER VOC...
+      | 0xE0 0xAD 0xA2..0xA3    #Mn   [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA ...
+      | 0xE0 0xAD 0xA6..0xAF    #Nd  [10] ORIYA DIGIT ZERO..ORIYA DIGIT NINE
+      | 0xE0 0xAD 0xB1          #Lo       ORIYA LETTER WA
+      | 0xE0 0xAE 0x82          #Mn       TAMIL SIGN ANUSVARA
+      | 0xE0 0xAE 0x83          #Lo       TAMIL SIGN VISARGA
+      | 0xE0 0xAE 0x85..0x8A    #Lo   [6] TAMIL LETTER A..TAMIL LETTER UU
+      | 0xE0 0xAE 0x8E..0x90    #Lo   [3] TAMIL LETTER E..TAMIL LETTER AI
+      | 0xE0 0xAE 0x92..0x95    #Lo   [4] TAMIL LETTER O..TAMIL LETTER KA
+      | 0xE0 0xAE 0x99..0x9A    #Lo   [2] TAMIL LETTER NGA..TAMIL LETTER CA
+      | 0xE0 0xAE 0x9C          #Lo       TAMIL LETTER JA
+      | 0xE0 0xAE 0x9E..0x9F    #Lo   [2] TAMIL LETTER NYA..TAMIL LETTER TTA
+      | 0xE0 0xAE 0xA3..0xA4    #Lo   [2] TAMIL LETTER NNA..TAMIL LETTER TA
+      | 0xE0 0xAE 0xA8..0xAA    #Lo   [3] TAMIL LETTER NA..TAMIL LETTER PA
+      | 0xE0 0xAE 0xAE..0xB9    #Lo  [12] TAMIL LETTER MA..TAMIL LETTER HA
+      | 0xE0 0xAE 0xBE..0xBF    #Mc   [2] TAMIL VOWEL SIGN AA..TAMIL VOWEL S...
+      | 0xE0 0xAF 0x80          #Mn       TAMIL VOWEL SIGN II
+      | 0xE0 0xAF 0x81..0x82    #Mc   [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SI...
+      | 0xE0 0xAF 0x86..0x88    #Mc   [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SI...
+      | 0xE0 0xAF 0x8A..0x8C    #Mc   [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SI...
+      | 0xE0 0xAF 0x8D          #Mn       TAMIL SIGN VIRAMA
+      | 0xE0 0xAF 0x90          #Lo       TAMIL OM
+      | 0xE0 0xAF 0x97          #Mc       TAMIL AU LENGTH MARK
+      | 0xE0 0xAF 0xA6..0xAF    #Nd  [10] TAMIL DIGIT ZERO..TAMIL DIGIT NINE
+      | 0xE0 0xB0 0x80          #Mn       TELUGU SIGN COMBINING CANDRABINDU ...
+      | 0xE0 0xB0 0x81..0x83    #Mc   [3] TELUGU SIGN CANDRABINDU..TELUGU SI...
+      | 0xE0 0xB0 0x85..0x8C    #Lo   [8] TELUGU LETTER A..TELUGU LETTER VOC...
+      | 0xE0 0xB0 0x8E..0x90    #Lo   [3] TELUGU LETTER E..TELUGU LETTER AI
+      | 0xE0 0xB0 0x92..0xA8    #Lo  [23] TELUGU LETTER O..TELUGU LETTER NA
+      | 0xE0 0xB0 0xAA..0xB9    #Lo  [16] TELUGU LETTER PA..TELUGU LETTER HA
+      | 0xE0 0xB0 0xBD          #Lo       TELUGU SIGN AVAGRAHA
+      | 0xE0 0xB0 0xBE..0xFF    #Mn   [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL...
+      | 0xE0 0xB1 0x00..0x80    #
+      | 0xE0 0xB1 0x81..0x84    #Mc   [4] TELUGU VOWEL SIGN U..TELUGU VOWEL ...
+      | 0xE0 0xB1 0x86..0x88    #Mn   [3] TELUGU VOWEL SIGN E..TELUGU VOWEL ...
+      | 0xE0 0xB1 0x8A..0x8D    #Mn   [4] TELUGU VOWEL SIGN O..TELUGU SIGN V...
+      | 0xE0 0xB1 0x95..0x96    #Mn   [2] TELUGU LENGTH MARK..TELUGU AI LENG...
+      | 0xE0 0xB1 0x98..0x9A    #Lo   [3] TELUGU LETTER TSA..TELUGU LETTER RRRA
+      | 0xE0 0xB1 0xA0..0xA1    #Lo   [2] TELUGU LETTER VOCALIC RR..TELUGU L...
+      | 0xE0 0xB1 0xA2..0xA3    #Mn   [2] TELUGU VOWEL SIGN VOCALIC L..TELUG...
+      | 0xE0 0xB1 0xA6..0xAF    #Nd  [10] TELUGU DIGIT ZERO..TELUGU DIGIT NINE
+      | 0xE0 0xB2 0x80          #Lo       KANNADA SIGN SPACING CANDRABINDU
+      | 0xE0 0xB2 0x81          #Mn       KANNADA SIGN CANDRABINDU
+      | 0xE0 0xB2 0x82..0x83    #Mc   [2] KANNADA SIGN ANUSVARA..KANNADA SIG...
+      | 0xE0 0xB2 0x85..0x8C    #Lo   [8] KANNADA LETTER A..KANNADA LETTER V...
+      | 0xE0 0xB2 0x8E..0x90    #Lo   [3] KANNADA LETTER E..KANNADA LETTER AI
+      | 0xE0 0xB2 0x92..0xA8    #Lo  [23] KANNADA LETTER O..KANNADA LETTER NA
+      | 0xE0 0xB2 0xAA..0xB3    #Lo  [10] KANNADA LETTER PA..KANNADA LETTER LLA
+      | 0xE0 0xB2 0xB5..0xB9    #Lo   [5] KANNADA LETTER VA..KANNADA LETTER HA
+      | 0xE0 0xB2 0xBC          #Mn       KANNADA SIGN NUKTA
+      | 0xE0 0xB2 0xBD          #Lo       KANNADA SIGN AVAGRAHA
+      | 0xE0 0xB2 0xBE          #Mc       KANNADA VOWEL SIGN AA
+      | 0xE0 0xB2 0xBF          #Mn       KANNADA VOWEL SIGN I
+      | 0xE0 0xB3 0x80..0x84    #Mc   [5] KANNADA VOWEL SIGN II..KANNADA VOW...
+      | 0xE0 0xB3 0x86          #Mn       KANNADA VOWEL SIGN E
+      | 0xE0 0xB3 0x87..0x88    #Mc   [2] KANNADA VOWEL SIGN EE..KANNADA VOW...
+      | 0xE0 0xB3 0x8A..0x8B    #Mc   [2] KANNADA VOWEL SIGN O..KANNADA VOWE...
+      | 0xE0 0xB3 0x8C..0x8D    #Mn   [2] KANNADA VOWEL SIGN AU..KANNADA SIG...
+      | 0xE0 0xB3 0x95..0x96    #Mc   [2] KANNADA LENGTH MARK..KANNADA AI LE...
+      | 0xE0 0xB3 0x9E          #Lo       KANNADA LETTER FA
+      | 0xE0 0xB3 0xA0..0xA1    #Lo   [2] KANNADA LETTER VOCALIC RR..KANNADA...
+      | 0xE0 0xB3 0xA2..0xA3    #Mn   [2] KANNADA VOWEL SIGN VOCALIC L..KANN...
+      | 0xE0 0xB3 0xA6..0xAF    #Nd  [10] KANNADA DIGIT ZERO..KANNADA DIGIT ...
+      | 0xE0 0xB3 0xB1..0xB2    #Lo   [2] KANNADA SIGN JIHVAMULIYA..KANNADA ...
+      | 0xE0 0xB4 0x81          #Mn       MALAYALAM SIGN CANDRABINDU
+      | 0xE0 0xB4 0x82..0x83    #Mc   [2] MALAYALAM SIGN ANUSVARA..MALAYALAM...
+      | 0xE0 0xB4 0x85..0x8C    #Lo   [8] MALAYALAM LETTER A..MALAYALAM LETT...
+      | 0xE0 0xB4 0x8E..0x90    #Lo   [3] MALAYALAM LETTER E..MALAYALAM LETT...
+      | 0xE0 0xB4 0x92..0xBA    #Lo  [41] MALAYALAM LETTER O..MALAYALAM LETT...
+      | 0xE0 0xB4 0xBD          #Lo       MALAYALAM SIGN AVAGRAHA
+      | 0xE0 0xB4 0xBE..0xFF    #Mc   [3] MALAYALAM VOWEL SIGN AA..MALAYALAM...
+      | 0xE0 0xB5 0x00..0x80    #
+      | 0xE0 0xB5 0x81..0x84    #Mn   [4] MALAYALAM VOWEL SIGN U..MALAYALAM ...
+      | 0xE0 0xB5 0x86..0x88    #Mc   [3] MALAYALAM VOWEL SIGN E..MALAYALAM ...
+      | 0xE0 0xB5 0x8A..0x8C    #Mc   [3] MALAYALAM VOWEL SIGN O..MALAYALAM ...
+      | 0xE0 0xB5 0x8D          #Mn       MALAYALAM SIGN VIRAMA
+      | 0xE0 0xB5 0x8E          #Lo       MALAYALAM LETTER DOT REPH
+      | 0xE0 0xB5 0x94..0x96    #Lo   [3] MALAYALAM LETTER CHILLU M..MALAYAL...
+      | 0xE0 0xB5 0x97          #Mc       MALAYALAM AU LENGTH MARK
+      | 0xE0 0xB5 0x9F..0xA1    #Lo   [3] MALAYALAM LETTER ARCHAIC II..MALAY...
+      | 0xE0 0xB5 0xA2..0xA3    #Mn   [2] MALAYALAM VOWEL SIGN VOCALIC L..MA...
+      | 0xE0 0xB5 0xA6..0xAF    #Nd  [10] MALAYALAM DIGIT ZERO..MALAYALAM DI...
+      | 0xE0 0xB5 0xBA..0xBF    #Lo   [6] MALAYALAM LETTER CHILLU NN..MALAYA...
+      | 0xE0 0xB6 0x82..0x83    #Mc   [2] SINHALA SIGN ANUSVARAYA..SINHALA S...
+      | 0xE0 0xB6 0x85..0x96    #Lo  [18] SINHALA LETTER AYANNA..SINHALA LET...
+      | 0xE0 0xB6 0x9A..0xB1    #Lo  [24] SINHALA LETTER ALPAPRAANA KAYANNA....
+      | 0xE0 0xB6 0xB3..0xBB    #Lo   [9] SINHALA LETTER SANYAKA DAYANNA..SI...
+      | 0xE0 0xB6 0xBD          #Lo       SINHALA LETTER DANTAJA LAYANNA
+      | 0xE0 0xB7 0x80..0x86    #Lo   [7] SINHALA LETTER VAYANNA..SINHALA LE...
+      | 0xE0 0xB7 0x8A          #Mn       SINHALA SIGN AL-LAKUNA
+      | 0xE0 0xB7 0x8F..0x91    #Mc   [3] SINHALA VOWEL SIGN AELA-PILLA..SIN...
+      | 0xE0 0xB7 0x92..0x94    #Mn   [3] SINHALA VOWEL SIGN KETTI IS-PILLA....
+      | 0xE0 0xB7 0x96          #Mn       SINHALA VOWEL SIGN DIGA PAA-PILLA
+      | 0xE0 0xB7 0x98..0x9F    #Mc   [8] SINHALA VOWEL SIGN GAETTA-PILLA..S...
+      | 0xE0 0xB7 0xA6..0xAF    #Nd  [10] SINHALA LITH DIGIT ZERO..SINHALA L...
+      | 0xE0 0xB7 0xB2..0xB3    #Mc   [2] SINHALA VOWEL SIGN DIGA GAETTA-PIL...
+      | 0xE0 0xB8 0x81..0xB0    #Lo  [48] THAI CHARACTER KO KAI..THAI CHARAC...
+      | 0xE0 0xB8 0xB1          #Mn       THAI CHARACTER MAI HAN-AKAT
+      | 0xE0 0xB8 0xB2..0xB3    #Lo   [2] THAI CHARACTER SARA AA..THAI CHARA...
+      | 0xE0 0xB8 0xB4..0xBA    #Mn   [7] THAI CHARACTER SARA I..THAI CHARAC...
+      | 0xE0 0xB9 0x80..0x85    #Lo   [6] THAI CHARACTER SARA E..THAI CHARAC...
+      | 0xE0 0xB9 0x86          #Lm       THAI CHARACTER MAIYAMOK
+      | 0xE0 0xB9 0x87..0x8E    #Mn   [8] THAI CHARACTER MAITAIKHU..THAI CHA...
+      | 0xE0 0xB9 0x90..0x99    #Nd  [10] THAI DIGIT ZERO..THAI DIGIT NINE
+      | 0xE0 0xBA 0x81..0x82    #Lo   [2] LAO LETTER KO..LAO LETTER KHO SUNG
+      | 0xE0 0xBA 0x84          #Lo       LAO LETTER KHO TAM
+      | 0xE0 0xBA 0x87..0x88    #Lo   [2] LAO LETTER NGO..LAO LETTER CO
+      | 0xE0 0xBA 0x8A          #Lo       LAO LETTER SO TAM
+      | 0xE0 0xBA 0x8D          #Lo       LAO LETTER NYO
+      | 0xE0 0xBA 0x94..0x97    #Lo   [4] LAO LETTER DO..LAO LETTER THO TAM
+      | 0xE0 0xBA 0x99..0x9F    #Lo   [7] LAO LETTER NO..LAO LETTER FO SUNG
+      | 0xE0 0xBA 0xA1..0xA3    #Lo   [3] LAO LETTER MO..LAO LETTER LO LING
+      | 0xE0 0xBA 0xA5          #Lo       LAO LETTER LO LOOT
+      | 0xE0 0xBA 0xA7          #Lo       LAO LETTER WO
+      | 0xE0 0xBA 0xAA..0xAB    #Lo   [2] LAO LETTER SO SUNG..LAO LETTER HO ...
+      | 0xE0 0xBA 0xAD..0xB0    #Lo   [4] LAO LETTER O..LAO VOWEL SIGN A
+      | 0xE0 0xBA 0xB1          #Mn       LAO VOWEL SIGN MAI KAN
+      | 0xE0 0xBA 0xB2..0xB3    #Lo   [2] LAO VOWEL SIGN AA..LAO VOWEL SIGN AM
+      | 0xE0 0xBA 0xB4..0xB9    #Mn   [6] LAO VOWEL SIGN I..LAO VOWEL SIGN UU
+      | 0xE0 0xBA 0xBB..0xBC    #Mn   [2] LAO VOWEL SIGN MAI KON..LAO SEMIVO...
+      | 0xE0 0xBA 0xBD          #Lo       LAO SEMIVOWEL SIGN NYO
+      | 0xE0 0xBB 0x80..0x84    #Lo   [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI
+      | 0xE0 0xBB 0x86          #Lm       LAO KO LA
+      | 0xE0 0xBB 0x88..0x8D    #Mn   [6] LAO TONE MAI EK..LAO NIGGAHITA
+      | 0xE0 0xBB 0x90..0x99    #Nd  [10] LAO DIGIT ZERO..LAO DIGIT NINE
+      | 0xE0 0xBB 0x9C..0x9F    #Lo   [4] LAO HO NO..LAO LETTER KHMU NYO
+      | 0xE0 0xBC 0x80          #Lo       TIBETAN SYLLABLE OM
+      | 0xE0 0xBC 0x98..0x99    #Mn   [2] TIBETAN ASTROLOGICAL SIGN -KHYUD P...
+      | 0xE0 0xBC 0xA0..0xA9    #Nd  [10] TIBETAN DIGIT ZERO..TIBETAN DIGIT ...
+      | 0xE0 0xBC 0xB5          #Mn       TIBETAN MARK NGAS BZUNG NYI ZLA
+      | 0xE0 0xBC 0xB7          #Mn       TIBETAN MARK NGAS BZUNG SGOR RTAGS
+      | 0xE0 0xBC 0xB9          #Mn       TIBETAN MARK TSA -PHRU
+      | 0xE0 0xBC 0xBE..0xBF    #Mc   [2] TIBETAN SIGN YAR TSHES..TIBETAN SI...
+      | 0xE0 0xBD 0x80..0x87    #Lo   [8] TIBETAN LETTER KA..TIBETAN LETTER JA
+      | 0xE0 0xBD 0x89..0xAC    #Lo  [36] TIBETAN LETTER NYA..TIBETAN LETTER...
+      | 0xE0 0xBD 0xB1..0xBE    #Mn  [14] TIBETAN VOWEL SIGN AA..TIBETAN SIG...
+      | 0xE0 0xBD 0xBF          #Mc       TIBETAN SIGN RNAM BCAD
+      | 0xE0 0xBE 0x80..0x84    #Mn   [5] TIBETAN VOWEL SIGN REVERSED I..TIB...
+      | 0xE0 0xBE 0x86..0x87    #Mn   [2] TIBETAN SIGN LCI RTAGS..TIBETAN SI...
+      | 0xE0 0xBE 0x88..0x8C    #Lo   [5] TIBETAN SIGN LCE TSA CAN..TIBETAN ...
+      | 0xE0 0xBE 0x8D..0x97    #Mn  [11] TIBETAN SUBJOINED SIGN LCE TSA CAN...
+      | 0xE0 0xBE 0x99..0xBC    #Mn  [36] TIBETAN SUBJOINED LETTER NYA..TIBE...
+      | 0xE0 0xBF 0x86          #Mn       TIBETAN SYMBOL PADMA GDAN
+      | 0xE1 0x80 0x80..0xAA    #Lo  [43] MYANMAR LETTER KA..MYANMAR LETTER AU
+      | 0xE1 0x80 0xAB..0xAC    #Mc   [2] MYANMAR VOWEL SIGN TALL AA..MYANMA...
+      | 0xE1 0x80 0xAD..0xB0    #Mn   [4] MYANMAR VOWEL SIGN I..MYANMAR VOWE...
+      | 0xE1 0x80 0xB1          #Mc       MYANMAR VOWEL SIGN E
+      | 0xE1 0x80 0xB2..0xB7    #Mn   [6] MYANMAR VOWEL SIGN AI..MYANMAR SIG...
+      | 0xE1 0x80 0xB8          #Mc       MYANMAR SIGN VISARGA
+      | 0xE1 0x80 0xB9..0xBA    #Mn   [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ...
+      | 0xE1 0x80 0xBB..0xBC    #Mc   [2] MYANMAR CONSONANT SIGN MEDIAL YA.....
+      | 0xE1 0x80 0xBD..0xBE    #Mn   [2] MYANMAR CONSONANT SIGN MEDIAL WA.....
+      | 0xE1 0x80 0xBF          #Lo       MYANMAR LETTER GREAT SA
+      | 0xE1 0x81 0x80..0x89    #Nd  [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT ...
+      | 0xE1 0x81 0x90..0x95    #Lo   [6] MYANMAR LETTER SHA..MYANMAR LETTER...
+      | 0xE1 0x81 0x96..0x97    #Mc   [2] MYANMAR VOWEL SIGN VOCALIC R..MYAN...
+      | 0xE1 0x81 0x98..0x99    #Mn   [2] MYANMAR VOWEL SIGN VOCALIC L..MYAN...
+      | 0xE1 0x81 0x9A..0x9D    #Lo   [4] MYANMAR LETTER MON NGA..MYANMAR LE...
+      | 0xE1 0x81 0x9E..0xA0    #Mn   [3] MYANMAR CONSONANT SIGN MON MEDIAL ...
+      | 0xE1 0x81 0xA1          #Lo       MYANMAR LETTER SGAW KAREN SHA
+      | 0xE1 0x81 0xA2..0xA4    #Mc   [3] MYANMAR VOWEL SIGN SGAW KAREN EU.....
+      | 0xE1 0x81 0xA5..0xA6    #Lo   [2] MYANMAR LETTER WESTERN PWO KAREN T...
+      | 0xE1 0x81 0xA7..0xAD    #Mc   [7] MYANMAR VOWEL SIGN WESTERN PWO KAR...
+      | 0xE1 0x81 0xAE..0xB0    #Lo   [3] MYANMAR LETTER EASTERN PWO KAREN N...
+      | 0xE1 0x81 0xB1..0xB4    #Mn   [4] MYANMAR VOWEL SIGN GEBA KAREN I..M...
+      | 0xE1 0x81 0xB5..0xFF    #Lo  [13] MYANMAR LETTER SHAN KA..MYANMAR LE...
+      | 0xE1 0x82 0x00..0x81    #
+      | 0xE1 0x82 0x82          #Mn       MYANMAR CONSONANT SIGN SHAN MEDIAL WA
+      | 0xE1 0x82 0x83..0x84    #Mc   [2] MYANMAR VOWEL SIGN SHAN AA..MYANMA...
+      | 0xE1 0x82 0x85..0x86    #Mn   [2] MYANMAR VOWEL SIGN SHAN E ABOVE..M...
+      | 0xE1 0x82 0x87..0x8C    #Mc   [6] MYANMAR SIGN SHAN TONE-2..MYANMAR ...
+      | 0xE1 0x82 0x8D          #Mn       MYANMAR SIGN SHAN COUNCIL EMPHATIC...
+      | 0xE1 0x82 0x8E          #Lo       MYANMAR LETTER RUMAI PALAUNG FA
+      | 0xE1 0x82 0x8F          #Mc       MYANMAR SIGN RUMAI PALAUNG TONE-5
+      | 0xE1 0x82 0x90..0x99    #Nd  [10] MYANMAR SHAN DIGIT ZERO..MYANMAR S...
+      | 0xE1 0x82 0x9A..0x9C    #Mc   [3] MYANMAR SIGN KHAMTI TONE-1..MYANMA...
+      | 0xE1 0x82 0x9D          #Mn       MYANMAR VOWEL SIGN AITON AI
+      | 0xE1 0x82 0xA0..0xFF    #L&  [38] GEORGIAN CAPITAL LETTER AN..GEORGI...
+      | 0xE1 0x83 0x00..0x85    #
+      | 0xE1 0x83 0x87          #L&       GEORGIAN CAPITAL LETTER YN
+      | 0xE1 0x83 0x8D          #L&       GEORGIAN CAPITAL LETTER AEN
+      | 0xE1 0x83 0x90..0xBA    #Lo  [43] GEORGIAN LETTER AN..GEORGIAN LETTE...
+      | 0xE1 0x83 0xBC          #Lm       MODIFIER LETTER GEORGIAN NAR
+      | 0xE1 0x83 0xBD..0xFF        #Lo [332] GEORGIAN LETTER AEN..ETHIOPIC ...
+      | 0xE1 0x84..0x88 0x00..0xFF  #
+      | 0xE1 0x89 0x00..0x88        #
+      | 0xE1 0x89 0x8A..0x8D    #Lo   [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SY...
+      | 0xE1 0x89 0x90..0x96    #Lo   [7] ETHIOPIC SYLLABLE QHA..ETHIOPIC SY...
+      | 0xE1 0x89 0x98          #Lo       ETHIOPIC SYLLABLE QHWA
+      | 0xE1 0x89 0x9A..0x9D    #Lo   [4] ETHIOPIC SYLLABLE QHWI..ETHIOPIC S...
+      | 0xE1 0x89 0xA0..0xFF    #Lo  [41] ETHIOPIC SYLLABLE BA..ETHIOPIC SYL...
+      | 0xE1 0x8A 0x00..0x88    #
+      | 0xE1 0x8A 0x8A..0x8D    #Lo   [4] ETHIOPIC SYLLABLE XWI..ETHIOPIC SY...
+      | 0xE1 0x8A 0x90..0xB0    #Lo  [33] ETHIOPIC SYLLABLE NA..ETHIOPIC SYL...
+      | 0xE1 0x8A 0xB2..0xB5    #Lo   [4] ETHIOPIC SYLLABLE KWI..ETHIOPIC SY...
+      | 0xE1 0x8A 0xB8..0xBE    #Lo   [7] ETHIOPIC SYLLABLE KXA..ETHIOPIC SY...
+      | 0xE1 0x8B 0x80          #Lo       ETHIOPIC SYLLABLE KXWA
+      | 0xE1 0x8B 0x82..0x85    #Lo   [4] ETHIOPIC SYLLABLE KXWI..ETHIOPIC S...
+      | 0xE1 0x8B 0x88..0x96    #Lo  [15] ETHIOPIC SYLLABLE WA..ETHIOPIC SYL...
+      | 0xE1 0x8B 0x98..0xFF    #Lo  [57] ETHIOPIC SYLLABLE ZA..ETHIOPIC SYL...
+      | 0xE1 0x8C 0x00..0x90    #
+      | 0xE1 0x8C 0x92..0x95    #Lo   [4] ETHIOPIC SYLLABLE GWI..ETHIOPIC SY...
+      | 0xE1 0x8C 0x98..0xFF    #Lo  [67] ETHIOPIC SYLLABLE GGA..ETHIOPIC SY...
+      | 0xE1 0x8D 0x00..0x9A    #
+      | 0xE1 0x8D 0x9D..0x9F    #Mn   [3] ETHIOPIC COMBINING GEMINATION AND ...
+      | 0xE1 0x8D 0xA9..0xB1    #No   [9] ETHIOPIC DIGIT ONE..ETHIOPIC DIGIT...
+      | 0xE1 0x8E 0x80..0x8F    #Lo  [16] ETHIOPIC SYLLABLE SEBATBEIT MWA..E...
+      | 0xE1 0x8E 0xA0..0xFF    #L&  [86] CHEROKEE LETTER A..CHEROKEE LETTER MV
+      | 0xE1 0x8F 0x00..0xB5    #
+      | 0xE1 0x8F 0xB8..0xBD    #L&   [6] CHEROKEE SMALL LETTER YE..CHEROKEE...
+      | 0xE1 0x90 0x81..0xFF        #Lo [620] CANADIAN SYLLABICS E..CANADIAN...
+      | 0xE1 0x91..0x98 0x00..0xFF  #
+      | 0xE1 0x99 0x00..0xAC        #
+      | 0xE1 0x99 0xAF..0xBF    #Lo  [17] CANADIAN SYLLABICS QAI..CANADIAN S...
+      | 0xE1 0x9A 0x81..0x9A    #Lo  [26] OGHAM LETTER BEITH..OGHAM LETTER P...
+      | 0xE1 0x9A 0xA0..0xFF    #Lo  [75] RUNIC LETTER FEHU FEOH FE F..RUNIC...
+      | 0xE1 0x9B 0x00..0xAA    #
+      | 0xE1 0x9B 0xAE..0xB0    #Nl   [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHO...
+      | 0xE1 0x9B 0xB1..0xB8    #Lo   [8] RUNIC LETTER K..RUNIC LETTER FRANK...
+      | 0xE1 0x9C 0x80..0x8C    #Lo  [13] TAGALOG LETTER A..TAGALOG LETTER YA
+      | 0xE1 0x9C 0x8E..0x91    #Lo   [4] TAGALOG LETTER LA..TAGALOG LETTER HA
+      | 0xE1 0x9C 0x92..0x94    #Mn   [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN...
+      | 0xE1 0x9C 0xA0..0xB1    #Lo  [18] HANUNOO LETTER A..HANUNOO LETTER HA
+      | 0xE1 0x9C 0xB2..0xB4    #Mn   [3] HANUNOO VOWEL SIGN I..HANUNOO SIGN...
+      | 0xE1 0x9D 0x80..0x91    #Lo  [18] BUHID LETTER A..BUHID LETTER HA
+      | 0xE1 0x9D 0x92..0x93    #Mn   [2] BUHID VOWEL SIGN I..BUHID VOWEL SI...
+      | 0xE1 0x9D 0xA0..0xAC    #Lo  [13] TAGBANWA LETTER A..TAGBANWA LETTER YA
+      | 0xE1 0x9D 0xAE..0xB0    #Lo   [3] TAGBANWA LETTER LA..TAGBANWA LETTE...
+      | 0xE1 0x9D 0xB2..0xB3    #Mn   [2] TAGBANWA VOWEL SIGN I..TAGBANWA VO...
+      | 0xE1 0x9E 0x80..0xB3    #Lo  [52] KHMER LETTER KA..KHMER INDEPENDENT...
+      | 0xE1 0x9E 0xB4..0xB5    #Mn   [2] KHMER VOWEL INHERENT AQ..KHMER VOW...
+      | 0xE1 0x9E 0xB6          #Mc       KHMER VOWEL SIGN AA
+      | 0xE1 0x9E 0xB7..0xBD    #Mn   [7] KHMER VOWEL SIGN I..KHMER VOWEL SI...
+      | 0xE1 0x9E 0xBE..0xFF    #Mc   [8] KHMER VOWEL SIGN OE..KHMER VOWEL S...
+      | 0xE1 0x9F 0x00..0x85    #
+      | 0xE1 0x9F 0x86          #Mn       KHMER SIGN NIKAHIT
+      | 0xE1 0x9F 0x87..0x88    #Mc   [2] KHMER SIGN REAHMUK..KHMER SIGN YUU...
+      | 0xE1 0x9F 0x89..0x93    #Mn  [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN...
+      | 0xE1 0x9F 0x97          #Lm       KHMER SIGN LEK TOO
+      | 0xE1 0x9F 0x9C          #Lo       KHMER SIGN AVAKRAHASANYA
+      | 0xE1 0x9F 0x9D          #Mn       KHMER SIGN ATTHACAN
+      | 0xE1 0x9F 0xA0..0xA9    #Nd  [10] KHMER DIGIT ZERO..KHMER DIGIT NINE
+      | 0xE1 0xA0 0x8B..0x8D    #Mn   [3] MONGOLIAN FREE VARIATION SELECTOR ...
+      | 0xE1 0xA0 0x90..0x99    #Nd  [10] MONGOLIAN DIGIT ZERO..MONGOLIAN DI...
+      | 0xE1 0xA0 0xA0..0xFF    #Lo  [35] MONGOLIAN LETTER A..MONGOLIAN LETT...
+      | 0xE1 0xA1 0x00..0x82    #
+      | 0xE1 0xA1 0x83          #Lm       MONGOLIAN LETTER TODO LONG VOWEL SIGN
+      | 0xE1 0xA1 0x84..0xB7    #Lo  [52] MONGOLIAN LETTER TODO E..MONGOLIAN...
+      | 0xE1 0xA2 0x80..0x84    #Lo   [5] MONGOLIAN LETTER ALI GALI ANUSVARA...
+      | 0xE1 0xA2 0x85..0x86    #Mn   [2] MONGOLIAN LETTER ALI GALI BALUDA.....
+      | 0xE1 0xA2 0x87..0xA8    #Lo  [34] MONGOLIAN LETTER ALI GALI A..MONGO...
+      | 0xE1 0xA2 0xA9          #Mn       MONGOLIAN LETTER ALI GALI DAGALGA
+      | 0xE1 0xA2 0xAA          #Lo       MONGOLIAN LETTER MANCHU ALI GALI LHA
+      | 0xE1 0xA2 0xB0..0xFF    #Lo  [70] CANADIAN SYLLABICS OY..CANADIAN SY...
+      | 0xE1 0xA3 0x00..0xB5    #
+      | 0xE1 0xA4 0x80..0x9E    #Lo  [31] LIMBU VOWEL-CARRIER LETTER..LIMBU ...
+      | 0xE1 0xA4 0xA0..0xA2    #Mn   [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SI...
+      | 0xE1 0xA4 0xA3..0xA6    #Mc   [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL S...
+      | 0xE1 0xA4 0xA7..0xA8    #Mn   [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SI...
+      | 0xE1 0xA4 0xA9..0xAB    #Mc   [3] LIMBU SUBJOINED LETTER YA..LIMBU S...
+      | 0xE1 0xA4 0xB0..0xB1    #Mc   [2] LIMBU SMALL LETTER KA..LIMBU SMALL...
+      | 0xE1 0xA4 0xB2          #Mn       LIMBU SMALL LETTER ANUSVARA
+      | 0xE1 0xA4 0xB3..0xB8    #Mc   [6] LIMBU SMALL LETTER TA..LIMBU SMALL...
+      | 0xE1 0xA4 0xB9..0xBB    #Mn   [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I
+      | 0xE1 0xA5 0x86..0x8F    #Nd  [10] LIMBU DIGIT ZERO..LIMBU DIGIT NINE
+      | 0xE1 0xA5 0x90..0xAD    #Lo  [30] TAI LE LETTER KA..TAI LE LETTER AI
+      | 0xE1 0xA5 0xB0..0xB4    #Lo   [5] TAI LE LETTER TONE-2..TAI LE LETTE...
+      | 0xE1 0xA6 0x80..0xAB    #Lo  [44] NEW TAI LUE LETTER HIGH QA..NEW TA...
+      | 0xE1 0xA6 0xB0..0xFF    #Lo  [26] NEW TAI LUE VOWEL SIGN VOWEL SHORT...
+      | 0xE1 0xA7 0x00..0x89    #
+      | 0xE1 0xA7 0x90..0x99    #Nd  [10] NEW TAI LUE DIGIT ZERO..NEW TAI LU...
+      | 0xE1 0xA7 0x9A          #No       NEW TAI LUE THAM DIGIT ONE
+      | 0xE1 0xA8 0x80..0x96    #Lo  [23] BUGINESE LETTER KA..BUGINESE LETTE...
+      | 0xE1 0xA8 0x97..0x98    #Mn   [2] BUGINESE VOWEL SIGN I..BUGINESE VO...
+      | 0xE1 0xA8 0x99..0x9A    #Mc   [2] BUGINESE VOWEL SIGN E..BUGINESE VO...
+      | 0xE1 0xA8 0x9B          #Mn       BUGINESE VOWEL SIGN AE
+      | 0xE1 0xA8 0xA0..0xFF    #Lo  [53] TAI THAM LETTER HIGH KA..TAI THAM ...
+      | 0xE1 0xA9 0x00..0x94    #
+      | 0xE1 0xA9 0x95          #Mc       TAI THAM CONSONANT SIGN MEDIAL RA
+      | 0xE1 0xA9 0x96          #Mn       TAI THAM CONSONANT SIGN MEDIAL LA
+      | 0xE1 0xA9 0x97          #Mc       TAI THAM CONSONANT SIGN LA TANG LAI
+      | 0xE1 0xA9 0x98..0x9E    #Mn   [7] TAI THAM SIGN MAI KANG LAI..TAI TH...
+      | 0xE1 0xA9 0xA0          #Mn       TAI THAM SIGN SAKOT
+      | 0xE1 0xA9 0xA1          #Mc       TAI THAM VOWEL SIGN A
+      | 0xE1 0xA9 0xA2          #Mn       TAI THAM VOWEL SIGN MAI SAT
+      | 0xE1 0xA9 0xA3..0xA4    #Mc   [2] TAI THAM VOWEL SIGN AA..TAI THAM V...
+      | 0xE1 0xA9 0xA5..0xAC    #Mn   [8] TAI THAM VOWEL SIGN I..TAI THAM VO...
+      | 0xE1 0xA9 0xAD..0xB2    #Mc   [6] TAI THAM VOWEL SIGN OY..TAI THAM V...
+      | 0xE1 0xA9 0xB3..0xBC    #Mn  [10] TAI THAM VOWEL SIGN OA ABOVE..TAI ...
+      | 0xE1 0xA9 0xBF          #Mn       TAI THAM COMBINING CRYPTOGRAMMIC DOT
+      | 0xE1 0xAA 0x80..0x89    #Nd  [10] TAI THAM HORA DIGIT ZERO..TAI THAM...
+      | 0xE1 0xAA 0x90..0x99    #Nd  [10] TAI THAM THAM DIGIT ZERO..TAI THAM...
+      | 0xE1 0xAA 0xA7          #Lm       TAI THAM SIGN MAI YAMOK
+      | 0xE1 0xAA 0xB0..0xBD    #Mn  [14] COMBINING DOUBLED CIRCUMFLEX ACCEN...
+      | 0xE1 0xAC 0x80..0x83    #Mn   [4] BALINESE SIGN ULU RICEM..BALINESE ...
+      | 0xE1 0xAC 0x84          #Mc       BALINESE SIGN BISAH
+      | 0xE1 0xAC 0x85..0xB3    #Lo  [47] BALINESE LETTER AKARA..BALINESE LE...
+      | 0xE1 0xAC 0xB4          #Mn       BALINESE SIGN REREKAN
+      | 0xE1 0xAC 0xB5          #Mc       BALINESE VOWEL SIGN TEDUNG
+      | 0xE1 0xAC 0xB6..0xBA    #Mn   [5] BALINESE VOWEL SIGN ULU..BALINESE ...
+      | 0xE1 0xAC 0xBB          #Mc       BALINESE VOWEL SIGN RA REPA TEDUNG
+      | 0xE1 0xAC 0xBC          #Mn       BALINESE VOWEL SIGN LA LENGA
+      | 0xE1 0xAC 0xBD..0xFF    #Mc   [5] BALINESE VOWEL SIGN LA LENGA TEDUN...
+      | 0xE1 0xAD 0x00..0x81    #
+      | 0xE1 0xAD 0x82          #Mn       BALINESE VOWEL SIGN PEPET
+      | 0xE1 0xAD 0x83..0x84    #Mc   [2] BALINESE VOWEL SIGN PEPET TEDUNG.....
+      | 0xE1 0xAD 0x85..0x8B    #Lo   [7] BALINESE LETTER KAF SASAK..BALINES...
+      | 0xE1 0xAD 0x90..0x99    #Nd  [10] BALINESE DIGIT ZERO..BALINESE DIGI...
+      | 0xE1 0xAD 0xAB..0xB3    #Mn   [9] BALINESE MUSICAL SYMBOL COMBINING ...
+      | 0xE1 0xAE 0x80..0x81    #Mn   [2] SUNDANESE SIGN PANYECEK..SUNDANESE...
+      | 0xE1 0xAE 0x82          #Mc       SUNDANESE SIGN PANGWISAD
+      | 0xE1 0xAE 0x83..0xA0    #Lo  [30] SUNDANESE LETTER A..SUNDANESE LETT...
+      | 0xE1 0xAE 0xA1          #Mc       SUNDANESE CONSONANT SIGN PAMINGKAL
+      | 0xE1 0xAE 0xA2..0xA5    #Mn   [4] SUNDANESE CONSONANT SIGN PANYAKRA....
+      | 0xE1 0xAE 0xA6..0xA7    #Mc   [2] SUNDANESE VOWEL SIGN PANAELAENG..S...
+      | 0xE1 0xAE 0xA8..0xA9    #Mn   [2] SUNDANESE VOWEL SIGN PAMEPET..SUND...
+      | 0xE1 0xAE 0xAA          #Mc       SUNDANESE SIGN PAMAAEH
+      | 0xE1 0xAE 0xAB..0xAD    #Mn   [3] SUNDANESE SIGN VIRAMA..SUNDANESE C...
+      | 0xE1 0xAE 0xAE..0xAF    #Lo   [2] SUNDANESE LETTER KHA..SUNDANESE LE...
+      | 0xE1 0xAE 0xB0..0xB9    #Nd  [10] SUNDANESE DIGIT ZERO..SUNDANESE DI...
+      | 0xE1 0xAE 0xBA..0xFF    #Lo  [44] SUNDANESE AVAGRAHA..BATAK LETTER U
+      | 0xE1 0xAF 0x00..0xA5    #
+      | 0xE1 0xAF 0xA6          #Mn       BATAK SIGN TOMPI
+      | 0xE1 0xAF 0xA7          #Mc       BATAK VOWEL SIGN E
+      | 0xE1 0xAF 0xA8..0xA9    #Mn   [2] BATAK VOWEL SIGN PAKPAK E..BATAK V...
+      | 0xE1 0xAF 0xAA..0xAC    #Mc   [3] BATAK VOWEL SIGN I..BATAK VOWEL SI...
+      | 0xE1 0xAF 0xAD          #Mn       BATAK VOWEL SIGN KARO O
+      | 0xE1 0xAF 0xAE          #Mc       BATAK VOWEL SIGN U
+      | 0xE1 0xAF 0xAF..0xB1    #Mn   [3] BATAK VOWEL SIGN U FOR SIMALUNGUN ...
+      | 0xE1 0xAF 0xB2..0xB3    #Mc   [2] BATAK PANGOLAT..BATAK PANONGONAN
+      | 0xE1 0xB0 0x80..0xA3    #Lo  [36] LEPCHA LETTER KA..LEPCHA LETTER A
+      | 0xE1 0xB0 0xA4..0xAB    #Mc   [8] LEPCHA SUBJOINED LETTER YA..LEPCHA...
+      | 0xE1 0xB0 0xAC..0xB3    #Mn   [8] LEPCHA VOWEL SIGN E..LEPCHA CONSON...
+      | 0xE1 0xB0 0xB4..0xB5    #Mc   [2] LEPCHA CONSONANT SIGN NYIN-DO..LEP...
+      | 0xE1 0xB0 0xB6..0xB7    #Mn   [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA
+      | 0xE1 0xB1 0x80..0x89    #Nd  [10] LEPCHA DIGIT ZERO..LEPCHA DIGIT NINE
+      | 0xE1 0xB1 0x8D..0x8F    #Lo   [3] LEPCHA LETTER TTA..LEPCHA LETTER DDA
+      | 0xE1 0xB1 0x90..0x99    #Nd  [10] OL CHIKI DIGIT ZERO..OL CHIKI DIGI...
+      | 0xE1 0xB1 0x9A..0xB7    #Lo  [30] OL CHIKI LETTER LA..OL CHIKI LETTE...
+      | 0xE1 0xB1 0xB8..0xBD    #Lm   [6] OL CHIKI MU TTUDDAG..OL CHIKI AHAD
+      | 0xE1 0xB2 0x80..0x88    #L&   [9] CYRILLIC SMALL LETTER ROUNDED VE.....
+      | 0xE1 0xB3 0x90..0x92    #Mn   [3] VEDIC TONE KARSHANA..VEDIC TONE PR...
+      | 0xE1 0xB3 0x94..0xA0    #Mn  [13] VEDIC SIGN YAJURVEDIC MIDLINE SVAR...
+      | 0xE1 0xB3 0xA1          #Mc       VEDIC TONE ATHARVAVEDIC INDEPENDEN...
+      | 0xE1 0xB3 0xA2..0xA8    #Mn   [7] VEDIC SIGN VISARGA SVARITA..VEDIC ...
+      | 0xE1 0xB3 0xA9..0xAC    #Lo   [4] VEDIC SIGN ANUSVARA ANTARGOMUKHA.....
+      | 0xE1 0xB3 0xAD          #Mn       VEDIC SIGN TIRYAK
+      | 0xE1 0xB3 0xAE..0xB1    #Lo   [4] VEDIC SIGN HEXIFORM LONG ANUSVARA....
+      | 0xE1 0xB3 0xB2..0xB3    #Mc   [2] VEDIC SIGN ARDHAVISARGA..VEDIC SIG...
+      | 0xE1 0xB3 0xB4          #Mn       VEDIC TONE CANDRA ABOVE
+      | 0xE1 0xB3 0xB5..0xB6    #Lo   [2] VEDIC SIGN JIHVAMULIYA..VEDIC SIGN...
+      | 0xE1 0xB3 0xB8..0xB9    #Mn   [2] VEDIC TONE RING ABOVE..VEDIC TONE ...
+      | 0xE1 0xB4 0x80..0xAB    #L&  [44] LATIN LETTER SMALL CAPITAL A..CYRI...
+      | 0xE1 0xB4 0xAC..0xFF    #Lm  [63] MODIFIER LETTER CAPITAL A..GREEK S...
+      | 0xE1 0xB5 0x00..0xAA    #
+      | 0xE1 0xB5 0xAB..0xB7    #L&  [13] LATIN SMALL LETTER UE..LATIN SMALL...
+      | 0xE1 0xB5 0xB8          #Lm       MODIFIER LETTER CYRILLIC EN
+      | 0xE1 0xB5 0xB9..0xFF    #L&  [34] LATIN SMALL LETTER INSULAR G..LATI...
+      | 0xE1 0xB6 0x00..0x9A    #
+      | 0xE1 0xB6 0x9B..0xBF    #Lm  [37] MODIFIER LETTER SMALL TURNED ALPHA...
+      | 0xE1 0xB7 0x80..0xB5    #Mn  [54] COMBINING DOTTED GRAVE ACCENT..COM...
+      | 0xE1 0xB7 0xBB..0xBF    #Mn   [5] COMBINING DELETION MARK..COMBINING...
+      | 0xE1 0xB8 0x80..0xFF        #L& [278] LATIN CAPITAL LETTER A WITH RI...
+      | 0xE1 0xB9..0xBB 0x00..0xFF  #
+      | 0xE1 0xBC 0x00..0x95        #
+      | 0xE1 0xBC 0x98..0x9D    #L&   [6] GREEK CAPITAL LETTER EPSILON WITH ...
+      | 0xE1 0xBC 0xA0..0xFF    #L&  [38] GREEK SMALL LETTER ETA WITH PSILI....
+      | 0xE1 0xBD 0x00..0x85    #
+      | 0xE1 0xBD 0x88..0x8D    #L&   [6] GREEK CAPITAL LETTER OMICRON WITH ...
+      | 0xE1 0xBD 0x90..0x97    #L&   [8] GREEK SMALL LETTER UPSILON WITH PS...
+      | 0xE1 0xBD 0x99          #L&       GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBD 0x9B          #L&       GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBD 0x9D          #L&       GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBD 0x9F..0xBD    #L&  [31] GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBE 0x80..0xB4    #L&  [53] GREEK SMALL LETTER ALPHA WITH PSIL...
+      | 0xE1 0xBE 0xB6..0xBC    #L&   [7] GREEK SMALL LETTER ALPHA WITH PERI...
+      | 0xE1 0xBE 0xBE          #L&       GREEK PROSGEGRAMMENI
+      | 0xE1 0xBF 0x82..0x84    #L&   [3] GREEK SMALL LETTER ETA WITH VARIA ...
+      | 0xE1 0xBF 0x86..0x8C    #L&   [7] GREEK SMALL LETTER ETA WITH PERISP...
+      | 0xE1 0xBF 0x90..0x93    #L&   [4] GREEK SMALL LETTER IOTA WITH VRACH...
+      | 0xE1 0xBF 0x96..0x9B    #L&   [6] GREEK SMALL LETTER IOTA WITH PERIS...
+      | 0xE1 0xBF 0xA0..0xAC    #L&  [13] GREEK SMALL LETTER UPSILON WITH VR...
+      | 0xE1 0xBF 0xB2..0xB4    #L&   [3] GREEK SMALL LETTER OMEGA WITH VARI...
+      | 0xE1 0xBF 0xB6..0xBC    #L&   [7] GREEK SMALL LETTER OMEGA WITH PERI...
+      | 0xE2 0x80 0xBF..0xFF    #Pc   [2] UNDERTIE..CHARACTER TIE
+      | 0xE2 0x81 0x00..0x80    #
+      | 0xE2 0x81 0x94          #Pc       INVERTED UNDERTIE
+      | 0xE2 0x81 0xB1          #Lm       SUPERSCRIPT LATIN SMALL LETTER I
+      | 0xE2 0x81 0xBF          #Lm       SUPERSCRIPT LATIN SMALL LETTER N
+      | 0xE2 0x82 0x90..0x9C    #Lm  [13] LATIN SUBSCRIPT SMALL LETTER A..LA...
+      | 0xE2 0x83 0x90..0x9C    #Mn  [13] COMBINING LEFT HARPOON ABOVE..COMB...
+      | 0xE2 0x83 0xA1          #Mn       COMBINING LEFT RIGHT ARROW ABOVE
+      | 0xE2 0x83 0xA5..0xB0    #Mn  [12] COMBINING REVERSE SOLIDUS OVERLAY....
+      | 0xE2 0x84 0x82          #L&       DOUBLE-STRUCK CAPITAL C
+      | 0xE2 0x84 0x87          #L&       EULER CONSTANT
+      | 0xE2 0x84 0x8A..0x93    #L&  [10] SCRIPT SMALL G..SCRIPT SMALL L
+      | 0xE2 0x84 0x95          #L&       DOUBLE-STRUCK CAPITAL N
+      | 0xE2 0x84 0x98          #Sm       SCRIPT CAPITAL P
+      | 0xE2 0x84 0x99..0x9D    #L&   [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-ST...
+      | 0xE2 0x84 0xA4          #L&       DOUBLE-STRUCK CAPITAL Z
+      | 0xE2 0x84 0xA6          #L&       OHM SIGN
+      | 0xE2 0x84 0xA8          #L&       BLACK-LETTER CAPITAL Z
+      | 0xE2 0x84 0xAA..0xAD    #L&   [4] KELVIN SIGN..BLACK-LETTER CAPITAL C
+      | 0xE2 0x84 0xAE          #So       ESTIMATED SYMBOL
+      | 0xE2 0x84 0xAF..0xB4    #L&   [6] SCRIPT SMALL E..SCRIPT SMALL O
+      | 0xE2 0x84 0xB5..0xB8    #Lo   [4] ALEF SYMBOL..DALET SYMBOL
+      | 0xE2 0x84 0xB9          #L&       INFORMATION SOURCE
+      | 0xE2 0x84 0xBC..0xBF    #L&   [4] DOUBLE-STRUCK SMALL PI..DOUBLE-STR...
+      | 0xE2 0x85 0x85..0x89    #L&   [5] DOUBLE-STRUCK ITALIC CAPITAL D..DO...
+      | 0xE2 0x85 0x8E          #L&       TURNED SMALL F
+      | 0xE2 0x85 0xA0..0xFF    #Nl  [35] ROMAN NUMERAL ONE..ROMAN NUMERAL T...
+      | 0xE2 0x86 0x00..0x82    #
+      | 0xE2 0x86 0x83..0x84    #L&   [2] ROMAN NUMERAL REVERSED ONE HUNDRED...
+      | 0xE2 0x86 0x85..0x88    #Nl   [4] ROMAN NUMERAL SIX LATE FORM..ROMAN...
+      | 0xE2 0xB0 0x80..0xAE    #L&  [47] GLAGOLITIC CAPITAL LETTER AZU..GLA...
+      | 0xE2 0xB0 0xB0..0xFF    #L&  [47] GLAGOLITIC SMALL LETTER AZU..GLAGO...
+      | 0xE2 0xB1 0x00..0x9E    #
+      | 0xE2 0xB1 0xA0..0xBB    #L&  [28] LATIN CAPITAL LETTER L WITH DOUBLE...
+      | 0xE2 0xB1 0xBC..0xBD    #Lm   [2] LATIN SUBSCRIPT SMALL LETTER J..MO...
+      | 0xE2 0xB1 0xBE..0xFF        #L& [103] LATIN CAPITAL LETTER S WITH SW...
+      | 0xE2 0xB2..0xB2 0x00..0xFF  #
+      | 0xE2 0xB3 0x00..0xA4        #
+      | 0xE2 0xB3 0xAB..0xAE    #L&   [4] COPTIC CAPITAL LETTER CRYPTOGRAMMI...
+      | 0xE2 0xB3 0xAF..0xB1    #Mn   [3] COPTIC COMBINING NI ABOVE..COPTIC ...
+      | 0xE2 0xB3 0xB2..0xB3    #L&   [2] COPTIC CAPITAL LETTER BOHAIRIC KHE...
+      | 0xE2 0xB4 0x80..0xA5    #L&  [38] GEORGIAN SMALL LETTER AN..GEORGIAN...
+      | 0xE2 0xB4 0xA7          #L&       GEORGIAN SMALL LETTER YN
+      | 0xE2 0xB4 0xAD          #L&       GEORGIAN SMALL LETTER AEN
+      | 0xE2 0xB4 0xB0..0xFF    #Lo  [56] TIFINAGH LETTER YA..TIFINAGH LETTE...
+      | 0xE2 0xB5 0x00..0xA7    #
+      | 0xE2 0xB5 0xAF          #Lm       TIFINAGH MODIFIER LETTER LABIALIZA...
+      | 0xE2 0xB5 0xBF          #Mn       TIFINAGH CONSONANT JOINER
+      | 0xE2 0xB6 0x80..0x96    #Lo  [23] ETHIOPIC SYLLABLE LOA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xA0..0xA6    #Lo   [7] ETHIOPIC SYLLABLE SSA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xA8..0xAE    #Lo   [7] ETHIOPIC SYLLABLE CCA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xB0..0xB6    #Lo   [7] ETHIOPIC SYLLABLE ZZA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xB8..0xBE    #Lo   [7] ETHIOPIC SYLLABLE CCHA..ETHIOPIC S...
+      | 0xE2 0xB7 0x80..0x86    #Lo   [7] ETHIOPIC SYLLABLE QYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0x88..0x8E    #Lo   [7] ETHIOPIC SYLLABLE KYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0x90..0x96    #Lo   [7] ETHIOPIC SYLLABLE XYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0x98..0x9E    #Lo   [7] ETHIOPIC SYLLABLE GYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0xA0..0xBF    #Mn  [32] COMBINING CYRILLIC LETTER BE..COMB...
+      | 0xE3 0x80 0x85          #Lm       IDEOGRAPHIC ITERATION MARK
+      | 0xE3 0x80 0x86          #Lo       IDEOGRAPHIC CLOSING MARK
+      | 0xE3 0x80 0x87          #Nl       IDEOGRAPHIC NUMBER ZERO
+      | 0xE3 0x80 0xA1..0xA9    #Nl   [9] HANGZHOU NUMERAL ONE..HANGZHOU NUM...
+      | 0xE3 0x80 0xAA..0xAD    #Mn   [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOG...
+      | 0xE3 0x80 0xAE..0xAF    #Mc   [2] HANGUL SINGLE DOT TONE MARK..HANGU...
+      | 0xE3 0x80 0xB1..0xB5    #Lm   [5] VERTICAL KANA REPEAT MARK..VERTICA...
+      | 0xE3 0x80 0xB8..0xBA    #Nl   [3] HANGZHOU NUMERAL TEN..HANGZHOU NUM...
+      | 0xE3 0x80 0xBB          #Lm       VERTICAL IDEOGRAPHIC ITERATION MARK
+      | 0xE3 0x80 0xBC          #Lo       MASU MARK
+      | 0xE3 0x81 0x81..0xFF    #Lo  [86] HIRAGANA LETTER SMALL A..HIRAGANA ...
+      | 0xE3 0x82 0x00..0x96    #
+      | 0xE3 0x82 0x99..0x9A    #Mn   [2] COMBINING KATAKANA-HIRAGANA VOICED...
+      | 0xE3 0x82 0x9B..0x9C    #Sk   [2] KATAKANA-HIRAGANA VOICED SOUND MAR...
+      | 0xE3 0x82 0x9D..0x9E    #Lm   [2] HIRAGANA ITERATION MARK..HIRAGANA ...
+      | 0xE3 0x82 0x9F          #Lo       HIRAGANA DIGRAPH YORI
+      | 0xE3 0x82 0xA1..0xFF    #Lo  [90] KATAKANA LETTER SMALL A..KATAKANA ...
+      | 0xE3 0x83 0x00..0xBA    #
+      | 0xE3 0x83 0xBC..0xBE    #Lm   [3] KATAKANA-HIRAGANA PROLONGED SOUND ...
+      | 0xE3 0x83 0xBF          #Lo       KATAKANA DIGRAPH KOTO
+      | 0xE3 0x84 0x85..0xAD    #Lo  [41] BOPOMOFO LETTER B..BOPOMOFO LETTER IH
+      | 0xE3 0x84 0xB1..0xFF        #Lo  [94] HANGUL LETTER KIYEOK..HANGUL L...
+      | 0xE3 0x85..0x85 0x00..0xFF  #
+      | 0xE3 0x86 0x00..0x8E        #
+      | 0xE3 0x86 0xA0..0xBA    #Lo  [27] BOPOMOFO LETTER BU..BOPOMOFO LETTE...
+      | 0xE3 0x87 0xB0..0xBF    #Lo  [16] KATAKANA LETTER SMALL KU..KATAKANA...
+      | 0xE3 0x90 0x80..0xFF        #Lo [6582] CJK UNIFIED IDEOGRAPH-3400..C...
+      | 0xE3 0x91..0xFF 0x00..0xFF  #
+      | 0xE4 0x00 0x00..0xFF        #
+      | 0xE4 0x01..0xB5 0x00..0xFF  #
+      | 0xE4 0xB6 0x00..0xB5        #
+      | 0xE4 0xB8 0x80..0xFF              #Lo [20950] CJK UNIFIED IDEOGRAPH-...
+      | 0xE4 0xB9..0xFF 0x00..0xFF        #
+      | 0xE5..0xE8 0x00..0xFF 0x00..0xFF  #
+      | 0xE9 0x00 0x00..0xFF              #
+      | 0xE9 0x01..0xBE 0x00..0xFF        #
+      | 0xE9 0xBF 0x00..0x95              #
+      | 0xEA 0x80 0x80..0x94    #Lo  [21] YI SYLLABLE IT..YI SYLLABLE E
+      | 0xEA 0x80 0x95          #Lm       YI SYLLABLE WU
+      | 0xEA 0x80 0x96..0xFF        #Lo [1143] YI SYLLABLE BIT..YI SYLLABLE YYR
+      | 0xEA 0x81..0x91 0x00..0xFF  #
+      | 0xEA 0x92 0x00..0x8C        #
+      | 0xEA 0x93 0x90..0xB7    #Lo  [40] LISU LETTER BA..LISU LETTER OE
+      | 0xEA 0x93 0xB8..0xBD    #Lm   [6] LISU LETTER TONE MYA TI..LISU LETT...
+      | 0xEA 0x94 0x80..0xFF        #Lo [268] VAI SYLLABLE EE..VAI SYLLABLE NG
+      | 0xEA 0x95..0x97 0x00..0xFF  #
+      | 0xEA 0x98 0x00..0x8B        #
+      | 0xEA 0x98 0x8C          #Lm       VAI SYLLABLE LENGTHENER
+      | 0xEA 0x98 0x90..0x9F    #Lo  [16] VAI SYLLABLE NDOLE FA..VAI SYMBOL ...
+      | 0xEA 0x98 0xA0..0xA9    #Nd  [10] VAI DIGIT ZERO..VAI DIGIT NINE
+      | 0xEA 0x98 0xAA..0xAB    #Lo   [2] VAI SYLLABLE NDOLE MA..VAI SYLLABL...
+      | 0xEA 0x99 0x80..0xAD    #L&  [46] CYRILLIC CAPITAL LETTER ZEMLYA..CY...
+      | 0xEA 0x99 0xAE          #Lo       CYRILLIC LETTER MULTIOCULAR O
+      | 0xEA 0x99 0xAF          #Mn       COMBINING CYRILLIC VZMET
+      | 0xEA 0x99 0xB4..0xBD    #Mn  [10] COMBINING CYRILLIC LETTER UKRAINIA...
+      | 0xEA 0x99 0xBF          #Lm       CYRILLIC PAYEROK
+      | 0xEA 0x9A 0x80..0x9B    #L&  [28] CYRILLIC CAPITAL LETTER DWE..CYRIL...
+      | 0xEA 0x9A 0x9C..0x9D    #Lm   [2] MODIFIER LETTER CYRILLIC HARD SIGN...
+      | 0xEA 0x9A 0x9E..0x9F    #Mn   [2] COMBINING CYRILLIC LETTER EF..COMB...
+      | 0xEA 0x9A 0xA0..0xFF    #Lo  [70] BAMUM LETTER A..BAMUM LETTER KI
+      | 0xEA 0x9B 0x00..0xA5    #
+      | 0xEA 0x9B 0xA6..0xAF    #Nl  [10] BAMUM LETTER MO..BAMUM LETTER KOGHOM
+      | 0xEA 0x9B 0xB0..0xB1    #Mn   [2] BAMUM COMBINING MARK KOQNDON..BAMU...
+      | 0xEA 0x9C 0x97..0x9F    #Lm   [9] MODIFIER LETTER DOT VERTICAL BAR.....
+      | 0xEA 0x9C 0xA2..0xFF    #L&  [78] LATIN CAPITAL LETTER EGYPTOLOGICAL...
+      | 0xEA 0x9D 0x00..0xAF    #
+      | 0xEA 0x9D 0xB0          #Lm       MODIFIER LETTER US
+      | 0xEA 0x9D 0xB1..0xFF    #L&  [23] LATIN SMALL LETTER DUM..LATIN SMAL...
+      | 0xEA 0x9E 0x00..0x87    #
+      | 0xEA 0x9E 0x88          #Lm       MODIFIER LETTER LOW CIRCUMFLEX ACCENT
+      | 0xEA 0x9E 0x8B..0x8E    #L&   [4] LATIN CAPITAL LETTER SALTILLO..LAT...
+      | 0xEA 0x9E 0x8F          #Lo       LATIN LETTER SINOLOGICAL DOT
+      | 0xEA 0x9E 0x90..0xAE    #L&  [31] LATIN CAPITAL LETTER N WITH DESCEN...
+      | 0xEA 0x9E 0xB0..0xB7    #L&   [8] LATIN CAPITAL LETTER TURNED K..LAT...
+      | 0xEA 0x9F 0xB7          #Lo       LATIN EPIGRAPHIC LETTER SIDEWAYS I
+      | 0xEA 0x9F 0xB8..0xB9    #Lm   [2] MODIFIER LETTER CAPITAL H WITH STR...
+      | 0xEA 0x9F 0xBA          #L&       LATIN LETTER SMALL CAPITAL TURNED M
+      | 0xEA 0x9F 0xBB..0xFF    #Lo   [7] LATIN EPIGRAPHIC LETTER REVERSED F...
+      | 0xEA 0xA0 0x00..0x81    #
+      | 0xEA 0xA0 0x82          #Mn       SYLOTI NAGRI SIGN DVISVARA
+      | 0xEA 0xA0 0x83..0x85    #Lo   [3] SYLOTI NAGRI LETTER U..SYLOTI NAGR...
+      | 0xEA 0xA0 0x86          #Mn       SYLOTI NAGRI SIGN HASANTA
+      | 0xEA 0xA0 0x87..0x8A    #Lo   [4] SYLOTI NAGRI LETTER KO..SYLOTI NAG...
+      | 0xEA 0xA0 0x8B          #Mn       SYLOTI NAGRI SIGN ANUSVARA
+      | 0xEA 0xA0 0x8C..0xA2    #Lo  [23] SYLOTI NAGRI LETTER CO..SYLOTI NAG...
+      | 0xEA 0xA0 0xA3..0xA4    #Mc   [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI ...
+      | 0xEA 0xA0 0xA5..0xA6    #Mn   [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI ...
+      | 0xEA 0xA0 0xA7          #Mc       SYLOTI NAGRI VOWEL SIGN OO
+      | 0xEA 0xA1 0x80..0xB3    #Lo  [52] PHAGS-PA LETTER KA..PHAGS-PA LETTE...
+      | 0xEA 0xA2 0x80..0x81    #Mc   [2] SAURASHTRA SIGN ANUSVARA..SAURASHT...
+      | 0xEA 0xA2 0x82..0xB3    #Lo  [50] SAURASHTRA LETTER A..SAURASHTRA LE...
+      | 0xEA 0xA2 0xB4..0xFF    #Mc  [16] SAURASHTRA CONSONANT SIGN HAARU..S...
+      | 0xEA 0xA3 0x00..0x83    #
+      | 0xEA 0xA3 0x84..0x85    #Mn   [2] SAURASHTRA SIGN VIRAMA..SAURASHTRA...
+      | 0xEA 0xA3 0x90..0x99    #Nd  [10] SAURASHTRA DIGIT ZERO..SAURASHTRA ...
+      | 0xEA 0xA3 0xA0..0xB1    #Mn  [18] COMBINING DEVANAGARI DIGIT ZERO..C...
+      | 0xEA 0xA3 0xB2..0xB7    #Lo   [6] DEVANAGARI SIGN SPACING CANDRABIND...
+      | 0xEA 0xA3 0xBB          #Lo       DEVANAGARI HEADSTROKE
+      | 0xEA 0xA3 0xBD          #Lo       DEVANAGARI JAIN OM
+      | 0xEA 0xA4 0x80..0x89    #Nd  [10] KAYAH LI DIGIT ZERO..KAYAH LI DIGI...
+      | 0xEA 0xA4 0x8A..0xA5    #Lo  [28] KAYAH LI LETTER KA..KAYAH LI LETTE...
+      | 0xEA 0xA4 0xA6..0xAD    #Mn   [8] KAYAH LI VOWEL UE..KAYAH LI TONE C...
+      | 0xEA 0xA4 0xB0..0xFF    #Lo  [23] REJANG LETTER KA..REJANG LETTER A
+      | 0xEA 0xA5 0x00..0x86    #
+      | 0xEA 0xA5 0x87..0x91    #Mn  [11] REJANG VOWEL SIGN I..REJANG CONSON...
+      | 0xEA 0xA5 0x92..0x93    #Mc   [2] REJANG CONSONANT SIGN H..REJANG VI...
+      | 0xEA 0xA5 0xA0..0xBC    #Lo  [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANG...
+      | 0xEA 0xA6 0x80..0x82    #Mn   [3] JAVANESE SIGN PANYANGGA..JAVANESE ...
+      | 0xEA 0xA6 0x83          #Mc       JAVANESE SIGN WIGNYAN
+      | 0xEA 0xA6 0x84..0xB2    #Lo  [47] JAVANESE LETTER A..JAVANESE LETTER HA
+      | 0xEA 0xA6 0xB3          #Mn       JAVANESE SIGN CECAK TELU
+      | 0xEA 0xA6 0xB4..0xB5    #Mc   [2] JAVANESE VOWEL SIGN TARUNG..JAVANE...
+      | 0xEA 0xA6 0xB6..0xB9    #Mn   [4] JAVANESE VOWEL SIGN WULU..JAVANESE...
+      | 0xEA 0xA6 0xBA..0xBB    #Mc   [2] JAVANESE VOWEL SIGN TALING..JAVANE...
+      | 0xEA 0xA6 0xBC          #Mn       JAVANESE VOWEL SIGN PEPET
+      | 0xEA 0xA6 0xBD..0xFF    #Mc   [4] JAVANESE CONSONANT SIGN KERET..JAV...
+      | 0xEA 0xA7 0x00..0x80    #
+      | 0xEA 0xA7 0x8F          #Lm       JAVANESE PANGRANGKEP
+      | 0xEA 0xA7 0x90..0x99    #Nd  [10] JAVANESE DIGIT ZERO..JAVANESE DIGI...
+      | 0xEA 0xA7 0xA0..0xA4    #Lo   [5] MYANMAR LETTER SHAN GHA..MYANMAR L...
+      | 0xEA 0xA7 0xA5          #Mn       MYANMAR SIGN SHAN SAW
+      | 0xEA 0xA7 0xA6          #Lm       MYANMAR MODIFIER LETTER SHAN REDUP...
+      | 0xEA 0xA7 0xA7..0xAF    #Lo   [9] MYANMAR LETTER TAI LAING NYA..MYAN...
+      | 0xEA 0xA7 0xB0..0xB9    #Nd  [10] MYANMAR TAI LAING DIGIT ZERO..MYAN...
+      | 0xEA 0xA7 0xBA..0xBE    #Lo   [5] MYANMAR LETTER TAI LAING LLA..MYAN...
+      | 0xEA 0xA8 0x80..0xA8    #Lo  [41] CHAM LETTER A..CHAM LETTER HA
+      | 0xEA 0xA8 0xA9..0xAE    #Mn   [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIG...
+      | 0xEA 0xA8 0xAF..0xB0    #Mc   [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI
+      | 0xEA 0xA8 0xB1..0xB2    #Mn   [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIG...
+      | 0xEA 0xA8 0xB3..0xB4    #Mc   [2] CHAM CONSONANT SIGN YA..CHAM CONSO...
+      | 0xEA 0xA8 0xB5..0xB6    #Mn   [2] CHAM CONSONANT SIGN LA..CHAM CONSO...
+      | 0xEA 0xA9 0x80..0x82    #Lo   [3] CHAM LETTER FINAL K..CHAM LETTER F...
+      | 0xEA 0xA9 0x83          #Mn       CHAM CONSONANT SIGN FINAL NG
+      | 0xEA 0xA9 0x84..0x8B    #Lo   [8] CHAM LETTER FINAL CH..CHAM LETTER ...
+      | 0xEA 0xA9 0x8C          #Mn       CHAM CONSONANT SIGN FINAL M
+      | 0xEA 0xA9 0x8D          #Mc       CHAM CONSONANT SIGN FINAL H
+      | 0xEA 0xA9 0x90..0x99    #Nd  [10] CHAM DIGIT ZERO..CHAM DIGIT NINE
+      | 0xEA 0xA9 0xA0..0xAF    #Lo  [16] MYANMAR LETTER KHAMTI GA..MYANMAR ...
+      | 0xEA 0xA9 0xB0          #Lm       MYANMAR MODIFIER LETTER KHAMTI RED...
+      | 0xEA 0xA9 0xB1..0xB6    #Lo   [6] MYANMAR LETTER KHAMTI XA..MYANMAR ...
+      | 0xEA 0xA9 0xBA          #Lo       MYANMAR LETTER AITON RA
+      | 0xEA 0xA9 0xBB          #Mc       MYANMAR SIGN PAO KAREN TONE
+      | 0xEA 0xA9 0xBC          #Mn       MYANMAR SIGN TAI LAING TONE-2
+      | 0xEA 0xA9 0xBD          #Mc       MYANMAR SIGN TAI LAING TONE-5
+      | 0xEA 0xA9 0xBE..0xFF    #Lo  [50] MYANMAR LETTER SHWE PALAUNG CHA..T...
+      | 0xEA 0xAA 0x00..0xAF    #
+      | 0xEA 0xAA 0xB0          #Mn       TAI VIET MAI KANG
+      | 0xEA 0xAA 0xB1          #Lo       TAI VIET VOWEL AA
+      | 0xEA 0xAA 0xB2..0xB4    #Mn   [3] TAI VIET VOWEL I..TAI VIET VOWEL U
+      | 0xEA 0xAA 0xB5..0xB6    #Lo   [2] TAI VIET VOWEL E..TAI VIET VOWEL O
+      | 0xEA 0xAA 0xB7..0xB8    #Mn   [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA
+      | 0xEA 0xAA 0xB9..0xBD    #Lo   [5] TAI VIET VOWEL UEA..TAI VIET VOWEL AN
+      | 0xEA 0xAA 0xBE..0xBF    #Mn   [2] TAI VIET VOWEL AM..TAI VIET TONE M...
+      | 0xEA 0xAB 0x80          #Lo       TAI VIET TONE MAI NUENG
+      | 0xEA 0xAB 0x81          #Mn       TAI VIET TONE MAI THO
+      | 0xEA 0xAB 0x82          #Lo       TAI VIET TONE MAI SONG
+      | 0xEA 0xAB 0x9B..0x9C    #Lo   [2] TAI VIET SYMBOL KON..TAI VIET SYMB...
+      | 0xEA 0xAB 0x9D          #Lm       TAI VIET SYMBOL SAM
+      | 0xEA 0xAB 0xA0..0xAA    #Lo  [11] MEETEI MAYEK LETTER E..MEETEI MAYE...
+      | 0xEA 0xAB 0xAB          #Mc       MEETEI MAYEK VOWEL SIGN II
+      | 0xEA 0xAB 0xAC..0xAD    #Mn   [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI...
+      | 0xEA 0xAB 0xAE..0xAF    #Mc   [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI...
+      | 0xEA 0xAB 0xB2          #Lo       MEETEI MAYEK ANJI
+      | 0xEA 0xAB 0xB3..0xB4    #Lm   [2] MEETEI MAYEK SYLLABLE REPETITION M...
+      | 0xEA 0xAB 0xB5          #Mc       MEETEI MAYEK VOWEL SIGN VISARGA
+      | 0xEA 0xAB 0xB6          #Mn       MEETEI MAYEK VIRAMA
+      | 0xEA 0xAC 0x81..0x86    #Lo   [6] ETHIOPIC SYLLABLE TTHU..ETHIOPIC S...
+      | 0xEA 0xAC 0x89..0x8E    #Lo   [6] ETHIOPIC SYLLABLE DDHU..ETHIOPIC S...
+      | 0xEA 0xAC 0x91..0x96    #Lo   [6] ETHIOPIC SYLLABLE DZU..ETHIOPIC SY...
+      | 0xEA 0xAC 0xA0..0xA6    #Lo   [7] ETHIOPIC SYLLABLE CCHHA..ETHIOPIC ...
+      | 0xEA 0xAC 0xA8..0xAE    #Lo   [7] ETHIOPIC SYLLABLE BBA..ETHIOPIC SY...
+      | 0xEA 0xAC 0xB0..0xFF    #L&  [43] LATIN SMALL LETTER BARRED ALPHA..L...
+      | 0xEA 0xAD 0x00..0x9A    #
+      | 0xEA 0xAD 0x9C..0x9F    #Lm   [4] MODIFIER LETTER SMALL HENG..MODIFI...
+      | 0xEA 0xAD 0xA0..0xA5    #L&   [6] LATIN SMALL LETTER SAKHA YAT..GREE...
+      | 0xEA 0xAD 0xB0..0xFF    #L&  [80] CHEROKEE SMALL LETTER A..CHEROKEE ...
+      | 0xEA 0xAE 0x00..0xBF    #
+      | 0xEA 0xAF 0x80..0xA2    #Lo  [35] MEETEI MAYEK LETTER KOK..MEETEI MA...
+      | 0xEA 0xAF 0xA3..0xA4    #Mc   [2] MEETEI MAYEK VOWEL SIGN ONAP..MEET...
+      | 0xEA 0xAF 0xA5          #Mn       MEETEI MAYEK VOWEL SIGN ANAP
+      | 0xEA 0xAF 0xA6..0xA7    #Mc   [2] MEETEI MAYEK VOWEL SIGN YENAP..MEE...
+      | 0xEA 0xAF 0xA8          #Mn       MEETEI MAYEK VOWEL SIGN UNAP
+      | 0xEA 0xAF 0xA9..0xAA    #Mc   [2] MEETEI MAYEK VOWEL SIGN CHEINAP..M...
+      | 0xEA 0xAF 0xAC          #Mc       MEETEI MAYEK LUM IYEK
+      | 0xEA 0xAF 0xAD          #Mn       MEETEI MAYEK APUN IYEK
+      | 0xEA 0xAF 0xB0..0xB9    #Nd  [10] MEETEI MAYEK DIGIT ZERO..MEETEI MA...
+      | 0xEA 0xB0 0x80..0xFF              #Lo [11172] HANGUL SYLLABLE GA..HA...
+      | 0xEA 0xB1..0xFF 0x00..0xFF        #
+      | 0xEB..0xEC 0x00..0xFF 0x00..0xFF  #
+      | 0xED 0x00 0x00..0xFF              #
+      | 0xED 0x01..0x9D 0x00..0xFF        #
+      | 0xED 0x9E 0x00..0xA3              #
+      | 0xED 0x9E 0xB0..0xFF    #Lo  [23] HANGUL JUNGSEONG O-YEO..HANGUL JUN...
+      | 0xED 0x9F 0x00..0x86    #
+      | 0xED 0x9F 0x8B..0xBB    #Lo  [49] HANGUL JONGSEONG NIEUN-RIEUL..HANG...
+      | 0xEF 0xA4 0x80..0xFF        #Lo [366] CJK COMPATIBILITY IDEOGRAPH-F9...
+      | 0xEF 0xA5..0xA8 0x00..0xFF  #
+      | 0xEF 0xA9 0x00..0xAD        #
+      | 0xEF 0xA9 0xB0..0xFF        #Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA...
+      | 0xEF 0xAA..0xAA 0x00..0xFF  #
+      | 0xEF 0xAB 0x00..0x99        #
+      | 0xEF 0xAC 0x80..0x86    #L&   [7] LATIN SMALL LIGATURE FF..LATIN SMA...
+      | 0xEF 0xAC 0x93..0x97    #L&   [5] ARMENIAN SMALL LIGATURE MEN NOW..A...
+      | 0xEF 0xAC 0x9D          #Lo       HEBREW LETTER YOD WITH HIRIQ
+      | 0xEF 0xAC 0x9E          #Mn       HEBREW POINT JUDEO-SPANISH VARIKA
+      | 0xEF 0xAC 0x9F..0xA8    #Lo  [10] HEBREW LIGATURE YIDDISH YOD YOD PA...
+      | 0xEF 0xAC 0xAA..0xB6    #Lo  [13] HEBREW LETTER SHIN WITH SHIN DOT.....
+      | 0xEF 0xAC 0xB8..0xBC    #Lo   [5] HEBREW LETTER TET WITH DAGESH..HEB...
+      | 0xEF 0xAC 0xBE          #Lo       HEBREW LETTER MEM WITH DAGESH
+      | 0xEF 0xAD 0x80..0x81    #Lo   [2] HEBREW LETTER NUN WITH DAGESH..HEB...
+      | 0xEF 0xAD 0x83..0x84    #Lo   [2] HEBREW LETTER FINAL PE WITH DAGESH...
+      | 0xEF 0xAD 0x86..0xFF    #Lo [108] HEBREW LETTER TSADI WITH DAGESH..A...
+      | 0xEF 0xAE 0x00..0xB1    #
+      | 0xEF 0xAF 0x93..0xFF        #Lo [363] ARABIC LETTER NG ISOLATED FORM...
+      | 0xEF 0xB0..0xB3 0x00..0xFF  #
+      | 0xEF 0xB4 0x00..0xBD        #
+      | 0xEF 0xB5 0x90..0xFF    #Lo  [64] ARABIC LIGATURE TEH WITH JEEM WITH...
+      | 0xEF 0xB6 0x00..0x8F    #
+      | 0xEF 0xB6 0x92..0xFF    #Lo  [54] ARABIC LIGATURE MEEM WITH JEEM WIT...
+      | 0xEF 0xB7 0x00..0x87    #
+      | 0xEF 0xB7 0xB0..0xBB    #Lo  [12] ARABIC LIGATURE SALLA USED AS KORA...
+      | 0xEF 0xB8 0x80..0x8F    #Mn  [16] VARIATION SELECTOR-1..VARIATION SE...
+      | 0xEF 0xB8 0xA0..0xAF    #Mn  [16] COMBINING LIGATURE LEFT HALF..COMB...
+      | 0xEF 0xB8 0xB3..0xB4    #Pc   [2] PRESENTATION FORM FOR VERTICAL LOW...
+      | 0xEF 0xB9 0x8D..0x8F    #Pc   [3] DASHED LOW LINE..WAVY LOW LINE
+      | 0xEF 0xB9 0xB0..0xB4    #Lo   [5] ARABIC FATHATAN ISOLATED FORM..ARA...
+      | 0xEF 0xB9 0xB6..0xFF        #Lo [135] ARABIC FATHA ISOLATED FORM..AR...
+      | 0xEF 0xBA..0xBA 0x00..0xFF  #
+      | 0xEF 0xBB 0x00..0xBC        #
+      | 0xEF 0xBC 0x90..0x99    #Nd  [10] FULLWIDTH DIGIT ZERO..FULLWIDTH DI...
+      | 0xEF 0xBC 0xA1..0xBA    #L&  [26] FULLWIDTH LATIN CAPITAL LETTER A.....
+      | 0xEF 0xBC 0xBF          #Pc       FULLWIDTH LOW LINE
+      | 0xEF 0xBD 0x81..0x9A    #L&  [26] FULLWIDTH LATIN SMALL LETTER A..FU...
+      | 0xEF 0xBD 0xA6..0xAF    #Lo  [10] HALFWIDTH KATAKANA LETTER WO..HALF...
+      | 0xEF 0xBD 0xB0          #Lm       HALFWIDTH KATAKANA-HIRAGANA PROLON...
+      | 0xEF 0xBD 0xB1..0xFF    #Lo  [45] HALFWIDTH KATAKANA LETTER A..HALFW...
+      | 0xEF 0xBE 0x00..0x9D    #
+      | 0xEF 0xBE 0x9E..0x9F    #Lm   [2] HALFWIDTH KATAKANA VOICED SOUND MA...
+      | 0xEF 0xBE 0xA0..0xBE    #Lo  [31] HALFWIDTH HANGUL FILLER..HALFWIDTH...
+      | 0xEF 0xBF 0x82..0x87    #Lo   [6] HALFWIDTH HANGUL LETTER A..HALFWID...
+      | 0xEF 0xBF 0x8A..0x8F    #Lo   [6] HALFWIDTH HANGUL LETTER YEO..HALFW...
+      | 0xEF 0xBF 0x92..0x97    #Lo   [6] HALFWIDTH HANGUL LETTER YO..HALFWI...
+      | 0xEF 0xBF 0x9A..0x9C    #Lo   [3] HALFWIDTH HANGUL LETTER EU..HALFWI...
+      | 0xF0 0x90 0x80 0x80..0x8B  #Lo  [12] LINEAR B SYLLABLE B008 A..LINEA...
+      | 0xF0 0x90 0x80 0x8D..0xA6  #Lo  [26] LINEAR B SYLLABLE B036 JO..LINE...
+      | 0xF0 0x90 0x80 0xA8..0xBA  #Lo  [19] LINEAR B SYLLABLE B060 RA..LINE...
+      | 0xF0 0x90 0x80 0xBC..0xBD  #Lo   [2] LINEAR B SYLLABLE B017 ZA..LINE...
+      | 0xF0 0x90 0x80 0xBF..0xFF  #Lo  [15] LINEAR B SYLLABLE B020 ZO..LINE...
+      | 0xF0 0x90 0x81 0x00..0x8D  #
+      | 0xF0 0x90 0x81 0x90..0x9D  #Lo  [14] LINEAR B SYMBOL B018..LINEAR B ...
+      | 0xF0 0x90 0x82 0x80..0xFF  #Lo [123] LINEAR B IDEOGRAM B100 MAN..LIN...
+      | 0xF0 0x90 0x83 0x00..0xBA  #
+      | 0xF0 0x90 0x85 0x80..0xB4  #Nl  [53] GREEK ACROPHONIC ATTIC ONE QUAR...
+      | 0xF0 0x90 0x87 0xBD     #Mn       PHAISTOS DISC SIGN COMBINING OBLIQ...
+      | 0xF0 0x90 0x8A 0x80..0x9C  #Lo  [29] LYCIAN LETTER A..LYCIAN LETTER X
+      | 0xF0 0x90 0x8A 0xA0..0xFF  #Lo  [49] CARIAN LETTER A..CARIAN LETTER ...
+      | 0xF0 0x90 0x8B 0x00..0x90  #
+      | 0xF0 0x90 0x8B 0xA0     #Mn       COPTIC EPACT THOUSANDS MARK
+      | 0xF0 0x90 0x8C 0x80..0x9F  #Lo  [32] OLD ITALIC LETTER A..OLD ITALIC...
+      | 0xF0 0x90 0x8C 0xB0..0xFF  #Lo  [17] GOTHIC LETTER AHSA..GOTHIC LETT...
+      | 0xF0 0x90 0x8D 0x00..0x80  #
+      | 0xF0 0x90 0x8D 0x81     #Nl       GOTHIC LETTER NINETY
+      | 0xF0 0x90 0x8D 0x82..0x89  #Lo   [8] GOTHIC LETTER RAIDA..GOTHIC LET...
+      | 0xF0 0x90 0x8D 0x8A     #Nl       GOTHIC LETTER NINE HUNDRED
+      | 0xF0 0x90 0x8D 0x90..0xB5  #Lo  [38] OLD PERMIC LETTER AN..OLD PERMI...
+      | 0xF0 0x90 0x8D 0xB6..0xBA  #Mn   [5] COMBINING OLD PERMIC LETTER AN....
+      | 0xF0 0x90 0x8E 0x80..0x9D  #Lo  [30] UGARITIC LETTER ALPA..UGARITIC ...
+      | 0xF0 0x90 0x8E 0xA0..0xFF  #Lo  [36] OLD PERSIAN SIGN A..OLD PERSIAN...
+      | 0xF0 0x90 0x8F 0x00..0x83  #
+      | 0xF0 0x90 0x8F 0x88..0x8F  #Lo   [8] OLD PERSIAN SIGN AURAMAZDAA..OL...
+      | 0xF0 0x90 0x8F 0x91..0x95  #Nl   [5] OLD PERSIAN NUMBER ONE..OLD PER...
+      | 0xF0 0x90 0x90 0x80..0xFF  #L&  [80] DESERET CAPITAL LETTER LONG I.....
+      | 0xF0 0x90 0x91 0x00..0x8F  #
+      | 0xF0 0x90 0x91 0x90..0xFF  #Lo  [78] SHAVIAN LETTER PEEP..OSMANYA LE...
+      | 0xF0 0x90 0x92 0x00..0x9D  #
+      | 0xF0 0x90 0x92 0xA0..0xA9  #Nd  [10] OSMANYA DIGIT ZERO..OSMANYA DIG...
+      | 0xF0 0x90 0x92 0xB0..0xFF  #L&  [36] OSAGE CAPITAL LETTER A..OSAGE C...
+      | 0xF0 0x90 0x93 0x00..0x93  #
+      | 0xF0 0x90 0x93 0x98..0xBB  #L&  [36] OSAGE SMALL LETTER A..OSAGE SMA...
+      | 0xF0 0x90 0x94 0x80..0xA7  #Lo  [40] ELBASAN LETTER A..ELBASAN LETTE...
+      | 0xF0 0x90 0x94 0xB0..0xFF  #Lo  [52] CAUCASIAN ALBANIAN LETTER ALT.....
+      | 0xF0 0x90 0x95 0x00..0xA3  #
+      | 0xF0 0x90 0x98 0x80..0xFF        #Lo [311] LINEAR A SIGN AB001..LINE...
+      | 0xF0 0x90 0x99..0x9B 0x00..0xFF  #
+      | 0xF0 0x90 0x9C 0x00..0xB6        #
+      | 0xF0 0x90 0x9D 0x80..0x95  #Lo  [22] LINEAR A SIGN A701 A..LINEAR A ...
+      | 0xF0 0x90 0x9D 0xA0..0xA7  #Lo   [8] LINEAR A SIGN A800..LINEAR A SI...
+      | 0xF0 0x90 0xA0 0x80..0x85  #Lo   [6] CYPRIOT SYLLABLE A..CYPRIOT SYL...
+      | 0xF0 0x90 0xA0 0x88     #Lo       CYPRIOT SYLLABLE JO
+      | 0xF0 0x90 0xA0 0x8A..0xB5  #Lo  [44] CYPRIOT SYLLABLE KA..CYPRIOT SY...
+      | 0xF0 0x90 0xA0 0xB7..0xB8  #Lo   [2] CYPRIOT SYLLABLE XA..CYPRIOT SY...
+      | 0xF0 0x90 0xA0 0xBC     #Lo       CYPRIOT SYLLABLE ZA
+      | 0xF0 0x90 0xA0 0xBF..0xFF  #Lo  [23] CYPRIOT SYLLABLE ZO..IMPERIAL A...
+      | 0xF0 0x90 0xA1 0x00..0x95  #
+      | 0xF0 0x90 0xA1 0xA0..0xB6  #Lo  [23] PALMYRENE LETTER ALEPH..PALMYRE...
+      | 0xF0 0x90 0xA2 0x80..0x9E  #Lo  [31] NABATAEAN LETTER FINAL ALEPH..N...
+      | 0xF0 0x90 0xA3 0xA0..0xB2  #Lo  [19] HATRAN LETTER ALEPH..HATRAN LET...
+      | 0xF0 0x90 0xA3 0xB4..0xB5  #Lo   [2] HATRAN LETTER SHIN..HATRAN LETT...
+      | 0xF0 0x90 0xA4 0x80..0x95  #Lo  [22] PHOENICIAN LETTER ALF..PHOENICI...
+      | 0xF0 0x90 0xA4 0xA0..0xB9  #Lo  [26] LYDIAN LETTER A..LYDIAN LETTER C
+      | 0xF0 0x90 0xA6 0x80..0xB7  #Lo  [56] MEROITIC HIEROGLYPHIC LETTER A....
+      | 0xF0 0x90 0xA6 0xBE..0xBF  #Lo   [2] MEROITIC CURSIVE LOGOGRAM RMT.....
+      | 0xF0 0x90 0xA8 0x80     #Lo       KHAROSHTHI LETTER A
+      | 0xF0 0x90 0xA8 0x81..0x83  #Mn   [3] KHAROSHTHI VOWEL SIGN I..KHAROS...
+      | 0xF0 0x90 0xA8 0x85..0x86  #Mn   [2] KHAROSHTHI VOWEL SIGN E..KHAROS...
+      | 0xF0 0x90 0xA8 0x8C..0x8F  #Mn   [4] KHAROSHTHI VOWEL LENGTH MARK..K...
+      | 0xF0 0x90 0xA8 0x90..0x93  #Lo   [4] KHAROSHTHI LETTER KA..KHAROSHTH...
+      | 0xF0 0x90 0xA8 0x95..0x97  #Lo   [3] KHAROSHTHI LETTER CA..KHAROSHTH...
+      | 0xF0 0x90 0xA8 0x99..0xB3  #Lo  [27] KHAROSHTHI LETTER NYA..KHAROSHT...
+      | 0xF0 0x90 0xA8 0xB8..0xBA  #Mn   [3] KHAROSHTHI SIGN BAR ABOVE..KHAR...
+      | 0xF0 0x90 0xA8 0xBF     #Mn       KHAROSHTHI VIRAMA
+      | 0xF0 0x90 0xA9 0xA0..0xBC  #Lo  [29] OLD SOUTH ARABIAN LETTER HE..OL...
+      | 0xF0 0x90 0xAA 0x80..0x9C  #Lo  [29] OLD NORTH ARABIAN LETTER HEH..O...
+      | 0xF0 0x90 0xAB 0x80..0x87  #Lo   [8] MANICHAEAN LETTER ALEPH..MANICH...
+      | 0xF0 0x90 0xAB 0x89..0xA4  #Lo  [28] MANICHAEAN LETTER ZAYIN..MANICH...
+      | 0xF0 0x90 0xAB 0xA5..0xA6  #Mn   [2] MANICHAEAN ABBREVIATION MARK AB...
+      | 0xF0 0x90 0xAC 0x80..0xB5  #Lo  [54] AVESTAN LETTER A..AVESTAN LETTE...
+      | 0xF0 0x90 0xAD 0x80..0x95  #Lo  [22] INSCRIPTIONAL PARTHIAN LETTER A...
+      | 0xF0 0x90 0xAD 0xA0..0xB2  #Lo  [19] INSCRIPTIONAL PAHLAVI LETTER AL...
+      | 0xF0 0x90 0xAE 0x80..0x91  #Lo  [18] PSALTER PAHLAVI LETTER ALEPH..P...
+      | 0xF0 0x90 0xB0 0x80..0xFF  #Lo  [73] OLD TURKIC LETTER ORKHON A..OLD...
+      | 0xF0 0x90 0xB1 0x00..0x88  #
+      | 0xF0 0x90 0xB2 0x80..0xB2  #L&  [51] OLD HUNGARIAN CAPITAL LETTER A....
+      | 0xF0 0x90 0xB3 0x80..0xB2  #L&  [51] OLD HUNGARIAN SMALL LETTER A..O...
+      | 0xF0 0x91 0x80 0x80     #Mc       BRAHMI SIGN CANDRABINDU
+      | 0xF0 0x91 0x80 0x81     #Mn       BRAHMI SIGN ANUSVARA
+      | 0xF0 0x91 0x80 0x82     #Mc       BRAHMI SIGN VISARGA
+      | 0xF0 0x91 0x80 0x83..0xB7  #Lo  [53] BRAHMI SIGN JIHVAMULIYA..BRAHMI...
+      | 0xF0 0x91 0x80 0xB8..0xFF  #Mn  [15] BRAHMI VOWEL SIGN AA..BRAHMI VI...
+      | 0xF0 0x91 0x81 0x00..0x86  #
+      | 0xF0 0x91 0x81 0xA6..0xAF  #Nd  [10] BRAHMI DIGIT ZERO..BRAHMI DIGIT...
+      | 0xF0 0x91 0x81 0xBF..0xFF  #Mn   [3] BRAHMI NUMBER JOINER..KAITHI SI...
+      | 0xF0 0x91 0x82 0x00..0x81  #
+      | 0xF0 0x91 0x82 0x82     #Mc       KAITHI SIGN VISARGA
+      | 0xF0 0x91 0x82 0x83..0xAF  #Lo  [45] KAITHI LETTER A..KAITHI LETTER HA
+      | 0xF0 0x91 0x82 0xB0..0xB2  #Mc   [3] KAITHI VOWEL SIGN AA..KAITHI VO...
+      | 0xF0 0x91 0x82 0xB3..0xB6  #Mn   [4] KAITHI VOWEL SIGN U..KAITHI VOW...
+      | 0xF0 0x91 0x82 0xB7..0xB8  #Mc   [2] KAITHI VOWEL SIGN O..KAITHI VOW...
+      | 0xF0 0x91 0x82 0xB9..0xBA  #Mn   [2] KAITHI SIGN VIRAMA..KAITHI SIGN...
+      | 0xF0 0x91 0x83 0x90..0xA8  #Lo  [25] SORA SOMPENG LETTER SAH..SORA S...
+      | 0xF0 0x91 0x83 0xB0..0xB9  #Nd  [10] SORA SOMPENG DIGIT ZERO..SORA S...
+      | 0xF0 0x91 0x84 0x80..0x82  #Mn   [3] CHAKMA SIGN CANDRABINDU..CHAKMA...
+      | 0xF0 0x91 0x84 0x83..0xA6  #Lo  [36] CHAKMA LETTER AA..CHAKMA LETTER...
+      | 0xF0 0x91 0x84 0xA7..0xAB  #Mn   [5] CHAKMA VOWEL SIGN A..CHAKMA VOW...
+      | 0xF0 0x91 0x84 0xAC     #Mc       CHAKMA VOWEL SIGN E
+      | 0xF0 0x91 0x84 0xAD..0xB4  #Mn   [8] CHAKMA VOWEL SIGN AI..CHAKMA MA...
+      | 0xF0 0x91 0x84 0xB6..0xBF  #Nd  [10] CHAKMA DIGIT ZERO..CHAKMA DIGIT...
+      | 0xF0 0x91 0x85 0x90..0xB2  #Lo  [35] MAHAJANI LETTER A..MAHAJANI LET...
+      | 0xF0 0x91 0x85 0xB3     #Mn       MAHAJANI SIGN NUKTA
+      | 0xF0 0x91 0x85 0xB6     #Lo       MAHAJANI LIGATURE SHRI
+      | 0xF0 0x91 0x86 0x80..0x81  #Mn   [2] SHARADA SIGN CANDRABINDU..SHARA...
+      | 0xF0 0x91 0x86 0x82     #Mc       SHARADA SIGN VISARGA
+      | 0xF0 0x91 0x86 0x83..0xB2  #Lo  [48] SHARADA LETTER A..SHARADA LETTE...
+      | 0xF0 0x91 0x86 0xB3..0xB5  #Mc   [3] SHARADA VOWEL SIGN AA..SHARADA ...
+      | 0xF0 0x91 0x86 0xB6..0xBE  #Mn   [9] SHARADA VOWEL SIGN U..SHARADA V...
+      | 0xF0 0x91 0x86 0xBF..0xFF  #Mc   [2] SHARADA VOWEL SIGN AU..SHARADA ...
+      | 0xF0 0x91 0x87 0x00..0x80  #
+      | 0xF0 0x91 0x87 0x81..0x84  #Lo   [4] SHARADA SIGN AVAGRAHA..SHARADA OM
+      | 0xF0 0x91 0x87 0x8A..0x8C  #Mn   [3] SHARADA SIGN NUKTA..SHARADA EXT...
+      | 0xF0 0x91 0x87 0x90..0x99  #Nd  [10] SHARADA DIGIT ZERO..SHARADA DIG...
+      | 0xF0 0x91 0x87 0x9A     #Lo       SHARADA EKAM
+      | 0xF0 0x91 0x87 0x9C     #Lo       SHARADA HEADSTROKE
+      | 0xF0 0x91 0x88 0x80..0x91  #Lo  [18] KHOJKI LETTER A..KHOJKI LETTER JJA
+      | 0xF0 0x91 0x88 0x93..0xAB  #Lo  [25] KHOJKI LETTER NYA..KHOJKI LETTE...
+      | 0xF0 0x91 0x88 0xAC..0xAE  #Mc   [3] KHOJKI VOWEL SIGN AA..KHOJKI VO...
+      | 0xF0 0x91 0x88 0xAF..0xB1  #Mn   [3] KHOJKI VOWEL SIGN U..KHOJKI VOW...
+      | 0xF0 0x91 0x88 0xB2..0xB3  #Mc   [2] KHOJKI VOWEL SIGN O..KHOJKI VOW...
+      | 0xF0 0x91 0x88 0xB4     #Mn       KHOJKI SIGN ANUSVARA
+      | 0xF0 0x91 0x88 0xB5     #Mc       KHOJKI SIGN VIRAMA
+      | 0xF0 0x91 0x88 0xB6..0xB7  #Mn   [2] KHOJKI SIGN NUKTA..KHOJKI SIGN ...
+      | 0xF0 0x91 0x88 0xBE     #Mn       KHOJKI SIGN SUKUN
+      | 0xF0 0x91 0x8A 0x80..0x86  #Lo   [7] MULTANI LETTER A..MULTANI LETTE...
+      | 0xF0 0x91 0x8A 0x88     #Lo       MULTANI LETTER GHA
+      | 0xF0 0x91 0x8A 0x8A..0x8D  #Lo   [4] MULTANI LETTER CA..MULTANI LETT...
+      | 0xF0 0x91 0x8A 0x8F..0x9D  #Lo  [15] MULTANI LETTER NYA..MULTANI LET...
+      | 0xF0 0x91 0x8A 0x9F..0xA8  #Lo  [10] MULTANI LETTER BHA..MULTANI LET...
+      | 0xF0 0x91 0x8A 0xB0..0xFF  #Lo  [47] KHUDAWADI LETTER A..KHUDAWADI L...
+      | 0xF0 0x91 0x8B 0x00..0x9E  #
+      | 0xF0 0x91 0x8B 0x9F     #Mn       KHUDAWADI SIGN ANUSVARA
+      | 0xF0 0x91 0x8B 0xA0..0xA2  #Mc   [3] KHUDAWADI VOWEL SIGN AA..KHUDAW...
+      | 0xF0 0x91 0x8B 0xA3..0xAA  #Mn   [8] KHUDAWADI VOWEL SIGN U..KHUDAWA...
+      | 0xF0 0x91 0x8B 0xB0..0xB9  #Nd  [10] KHUDAWADI DIGIT ZERO..KHUDAWADI...
+      | 0xF0 0x91 0x8C 0x80..0x81  #Mn   [2] GRANTHA SIGN COMBINING ANUSVARA...
+      | 0xF0 0x91 0x8C 0x82..0x83  #Mc   [2] GRANTHA SIGN ANUSVARA..GRANTHA ...
+      | 0xF0 0x91 0x8C 0x85..0x8C  #Lo   [8] GRANTHA LETTER A..GRANTHA LETTE...
+      | 0xF0 0x91 0x8C 0x8F..0x90  #Lo   [2] GRANTHA LETTER EE..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0x93..0xA8  #Lo  [22] GRANTHA LETTER OO..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xAA..0xB0  #Lo   [7] GRANTHA LETTER PA..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xB2..0xB3  #Lo   [2] GRANTHA LETTER LA..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xB5..0xB9  #Lo   [5] GRANTHA LETTER VA..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xBC     #Mn       GRANTHA SIGN NUKTA
+      | 0xF0 0x91 0x8C 0xBD     #Lo       GRANTHA SIGN AVAGRAHA
+      | 0xF0 0x91 0x8C 0xBE..0xBF  #Mc   [2] GRANTHA VOWEL SIGN AA..GRANTHA ...
+      | 0xF0 0x91 0x8D 0x80     #Mn       GRANTHA VOWEL SIGN II
+      | 0xF0 0x91 0x8D 0x81..0x84  #Mc   [4] GRANTHA VOWEL SIGN U..GRANTHA V...
+      | 0xF0 0x91 0x8D 0x87..0x88  #Mc   [2] GRANTHA VOWEL SIGN EE..GRANTHA ...
+      | 0xF0 0x91 0x8D 0x8B..0x8D  #Mc   [3] GRANTHA VOWEL SIGN OO..GRANTHA ...
+      | 0xF0 0x91 0x8D 0x90     #Lo       GRANTHA OM
+      | 0xF0 0x91 0x8D 0x97     #Mc       GRANTHA AU LENGTH MARK
+      | 0xF0 0x91 0x8D 0x9D..0xA1  #Lo   [5] GRANTHA SIGN PLUTA..GRANTHA LET...
+      | 0xF0 0x91 0x8D 0xA2..0xA3  #Mc   [2] GRANTHA VOWEL SIGN VOCALIC L..G...
+      | 0xF0 0x91 0x8D 0xA6..0xAC  #Mn   [7] COMBINING GRANTHA DIGIT ZERO..C...
+      | 0xF0 0x91 0x8D 0xB0..0xB4  #Mn   [5] COMBINING GRANTHA LETTER A..COM...
+      | 0xF0 0x91 0x90 0x80..0xB4  #Lo  [53] NEWA LETTER A..NEWA LETTER HA
+      | 0xF0 0x91 0x90 0xB5..0xB7  #Mc   [3] NEWA VOWEL SIGN AA..NEWA VOWEL ...
+      | 0xF0 0x91 0x90 0xB8..0xBF  #Mn   [8] NEWA VOWEL SIGN U..NEWA VOWEL S...
+      | 0xF0 0x91 0x91 0x80..0x81  #Mc   [2] NEWA VOWEL SIGN O..NEWA VOWEL S...
+      | 0xF0 0x91 0x91 0x82..0x84  #Mn   [3] NEWA SIGN VIRAMA..NEWA SIGN ANU...
+      | 0xF0 0x91 0x91 0x85     #Mc       NEWA SIGN VISARGA
+      | 0xF0 0x91 0x91 0x86     #Mn       NEWA SIGN NUKTA
+      | 0xF0 0x91 0x91 0x87..0x8A  #Lo   [4] NEWA SIGN AVAGRAHA..NEWA SIDDHI
+      | 0xF0 0x91 0x91 0x90..0x99  #Nd  [10] NEWA DIGIT ZERO..NEWA DIGIT NINE
+      | 0xF0 0x91 0x92 0x80..0xAF  #Lo  [48] TIRHUTA ANJI..TIRHUTA LETTER HA
+      | 0xF0 0x91 0x92 0xB0..0xB2  #Mc   [3] TIRHUTA VOWEL SIGN AA..TIRHUTA ...
+      | 0xF0 0x91 0x92 0xB3..0xB8  #Mn   [6] TIRHUTA VOWEL SIGN U..TIRHUTA V...
+      | 0xF0 0x91 0x92 0xB9     #Mc       TIRHUTA VOWEL SIGN E
+      | 0xF0 0x91 0x92 0xBA     #Mn       TIRHUTA VOWEL SIGN SHORT E
+      | 0xF0 0x91 0x92 0xBB..0xBE  #Mc   [4] TIRHUTA VOWEL SIGN AI..TIRHUTA ...
+      | 0xF0 0x91 0x92 0xBF..0xFF  #Mn   [2] TIRHUTA SIGN CANDRABINDU..TIRHU...
+      | 0xF0 0x91 0x93 0x00..0x80  #
+      | 0xF0 0x91 0x93 0x81     #Mc       TIRHUTA SIGN VISARGA
+      | 0xF0 0x91 0x93 0x82..0x83  #Mn   [2] TIRHUTA SIGN VIRAMA..TIRHUTA SI...
+      | 0xF0 0x91 0x93 0x84..0x85  #Lo   [2] TIRHUTA SIGN AVAGRAHA..TIRHUTA ...
+      | 0xF0 0x91 0x93 0x87     #Lo       TIRHUTA OM
+      | 0xF0 0x91 0x93 0x90..0x99  #Nd  [10] TIRHUTA DIGIT ZERO..TIRHUTA DIG...
+      | 0xF0 0x91 0x96 0x80..0xAE  #Lo  [47] SIDDHAM LETTER A..SIDDHAM LETTE...
+      | 0xF0 0x91 0x96 0xAF..0xB1  #Mc   [3] SIDDHAM VOWEL SIGN AA..SIDDHAM ...
+      | 0xF0 0x91 0x96 0xB2..0xB5  #Mn   [4] SIDDHAM VOWEL SIGN U..SIDDHAM V...
+      | 0xF0 0x91 0x96 0xB8..0xBB  #Mc   [4] SIDDHAM VOWEL SIGN E..SIDDHAM V...
+      | 0xF0 0x91 0x96 0xBC..0xBD  #Mn   [2] SIDDHAM SIGN CANDRABINDU..SIDDH...
+      | 0xF0 0x91 0x96 0xBE     #Mc       SIDDHAM SIGN VISARGA
+      | 0xF0 0x91 0x96 0xBF..0xFF  #Mn   [2] SIDDHAM SIGN VIRAMA..SIDDHAM SI...
+      | 0xF0 0x91 0x97 0x00..0x80  #
+      | 0xF0 0x91 0x97 0x98..0x9B  #Lo   [4] SIDDHAM LETTER THREE-CIRCLE ALT...
+      | 0xF0 0x91 0x97 0x9C..0x9D  #Mn   [2] SIDDHAM VOWEL SIGN ALTERNATE U....
+      | 0xF0 0x91 0x98 0x80..0xAF  #Lo  [48] MODI LETTER A..MODI LETTER LLA
+      | 0xF0 0x91 0x98 0xB0..0xB2  #Mc   [3] MODI VOWEL SIGN AA..MODI VOWEL ...
+      | 0xF0 0x91 0x98 0xB3..0xBA  #Mn   [8] MODI VOWEL SIGN U..MODI VOWEL S...
+      | 0xF0 0x91 0x98 0xBB..0xBC  #Mc   [2] MODI VOWEL SIGN O..MODI VOWEL S...
+      | 0xF0 0x91 0x98 0xBD     #Mn       MODI SIGN ANUSVARA
+      | 0xF0 0x91 0x98 0xBE     #Mc       MODI SIGN VISARGA
+      | 0xF0 0x91 0x98 0xBF..0xFF  #Mn   [2] MODI SIGN VIRAMA..MODI SIGN ARD...
+      | 0xF0 0x91 0x99 0x00..0x80  #
+      | 0xF0 0x91 0x99 0x84     #Lo       MODI SIGN HUVA
+      | 0xF0 0x91 0x99 0x90..0x99  #Nd  [10] MODI DIGIT ZERO..MODI DIGIT NINE
+      | 0xF0 0x91 0x9A 0x80..0xAA  #Lo  [43] TAKRI LETTER A..TAKRI LETTER RRA
+      | 0xF0 0x91 0x9A 0xAB     #Mn       TAKRI SIGN ANUSVARA
+      | 0xF0 0x91 0x9A 0xAC     #Mc       TAKRI SIGN VISARGA
+      | 0xF0 0x91 0x9A 0xAD     #Mn       TAKRI VOWEL SIGN AA
+      | 0xF0 0x91 0x9A 0xAE..0xAF  #Mc   [2] TAKRI VOWEL SIGN I..TAKRI VOWEL...
+      | 0xF0 0x91 0x9A 0xB0..0xB5  #Mn   [6] TAKRI VOWEL SIGN U..TAKRI VOWEL...
+      | 0xF0 0x91 0x9A 0xB6     #Mc       TAKRI SIGN VIRAMA
+      | 0xF0 0x91 0x9A 0xB7     #Mn       TAKRI SIGN NUKTA
+      | 0xF0 0x91 0x9B 0x80..0x89  #Nd  [10] TAKRI DIGIT ZERO..TAKRI DIGIT NINE
+      | 0xF0 0x91 0x9C 0x80..0x99  #Lo  [26] AHOM LETTER KA..AHOM LETTER JHA
+      | 0xF0 0x91 0x9C 0x9D..0x9F  #Mn   [3] AHOM CONSONANT SIGN MEDIAL LA.....
+      | 0xF0 0x91 0x9C 0xA0..0xA1  #Mc   [2] AHOM VOWEL SIGN A..AHOM VOWEL S...
+      | 0xF0 0x91 0x9C 0xA2..0xA5  #Mn   [4] AHOM VOWEL SIGN I..AHOM VOWEL S...
+      | 0xF0 0x91 0x9C 0xA6     #Mc       AHOM VOWEL SIGN E
+      | 0xF0 0x91 0x9C 0xA7..0xAB  #Mn   [5] AHOM VOWEL SIGN AW..AHOM SIGN K...
+      | 0xF0 0x91 0x9C 0xB0..0xB9  #Nd  [10] AHOM DIGIT ZERO..AHOM DIGIT NINE
+      | 0xF0 0x91 0xA2 0xA0..0xFF  #L&  [64] WARANG CITI CAPITAL LETTER NGAA...
+      | 0xF0 0x91 0xA3 0x00..0x9F  #
+      | 0xF0 0x91 0xA3 0xA0..0xA9  #Nd  [10] WARANG CITI DIGIT ZERO..WARANG ...
+      | 0xF0 0x91 0xA3 0xBF     #Lo       WARANG CITI OM
+      | 0xF0 0x91 0xAB 0x80..0xB8  #Lo  [57] PAU CIN HAU LETTER PA..PAU CIN ...
+      | 0xF0 0x91 0xB0 0x80..0x88  #Lo   [9] BHAIKSUKI LETTER A..BHAIKSUKI L...
+      | 0xF0 0x91 0xB0 0x8A..0xAE  #Lo  [37] BHAIKSUKI LETTER E..BHAIKSUKI L...
+      | 0xF0 0x91 0xB0 0xAF     #Mc       BHAIKSUKI VOWEL SIGN AA
+      | 0xF0 0x91 0xB0 0xB0..0xB6  #Mn   [7] BHAIKSUKI VOWEL SIGN I..BHAIKSU...
+      | 0xF0 0x91 0xB0 0xB8..0xBD  #Mn   [6] BHAIKSUKI VOWEL SIGN E..BHAIKSU...
+      | 0xF0 0x91 0xB0 0xBE     #Mc       BHAIKSUKI SIGN VISARGA
+      | 0xF0 0x91 0xB0 0xBF     #Mn       BHAIKSUKI SIGN VIRAMA
+      | 0xF0 0x91 0xB1 0x80     #Lo       BHAIKSUKI SIGN AVAGRAHA
+      | 0xF0 0x91 0xB1 0x90..0x99  #Nd  [10] BHAIKSUKI DIGIT ZERO..BHAIKSUKI...
+      | 0xF0 0x91 0xB1 0xB2..0xFF  #Lo  [30] MARCHEN LETTER KA..MARCHEN LETT...
+      | 0xF0 0x91 0xB2 0x00..0x8F  #
+      | 0xF0 0x91 0xB2 0x92..0xA7  #Mn  [22] MARCHEN SUBJOINED LETTER KA..MA...
+      | 0xF0 0x91 0xB2 0xA9     #Mc       MARCHEN SUBJOINED LETTER YA
+      | 0xF0 0x91 0xB2 0xAA..0xB0  #Mn   [7] MARCHEN SUBJOINED LETTER RA..MA...
+      | 0xF0 0x91 0xB2 0xB1     #Mc       MARCHEN VOWEL SIGN I
+      | 0xF0 0x91 0xB2 0xB2..0xB3  #Mn   [2] MARCHEN VOWEL SIGN U..MARCHEN V...
+      | 0xF0 0x91 0xB2 0xB4     #Mc       MARCHEN VOWEL SIGN O
+      | 0xF0 0x91 0xB2 0xB5..0xB6  #Mn   [2] MARCHEN SIGN ANUSVARA..MARCHEN ...
+      | 0xF0 0x92 0x80 0x80..0xFF        #Lo [922] CUNEIFORM SIGN A..CUNEIFO...
+      | 0xF0 0x92 0x81..0x8D 0x00..0xFF  #
+      | 0xF0 0x92 0x8E 0x00..0x99        #
+      | 0xF0 0x92 0x90 0x80..0xFF  #Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH....
+      | 0xF0 0x92 0x91 0x00..0xAE  #
+      | 0xF0 0x92 0x92 0x80..0xFF        #Lo [196] CUNEIFORM SIGN AB TIMES N...
+      | 0xF0 0x92 0x93..0x94 0x00..0xFF  #
+      | 0xF0 0x92 0x95 0x00..0x83        #
+      | 0xF0 0x93 0x80 0x80..0xFF        #Lo [1071] EGYPTIAN HIEROGLYPH A001...
+      | 0xF0 0x93 0x81..0x8F 0x00..0xFF  #
+      | 0xF0 0x93 0x90 0x00..0xAE        #
+      | 0xF0 0x94 0x90 0x80..0xFF        #Lo [583] ANATOLIAN HIEROGLYPH A001...
+      | 0xF0 0x94 0x91..0x98 0x00..0xFF  #
+      | 0xF0 0x94 0x99 0x00..0x86        #
+      | 0xF0 0x96 0xA0 0x80..0xFF        #Lo [569] BAMUM LETTER PHASE-A NGKU...
+      | 0xF0 0x96 0xA1..0xA7 0x00..0xFF  #
+      | 0xF0 0x96 0xA8 0x00..0xB8        #
+      | 0xF0 0x96 0xA9 0x80..0x9E  #Lo  [31] MRO LETTER TA..MRO LETTER TEK
+      | 0xF0 0x96 0xA9 0xA0..0xA9  #Nd  [10] MRO DIGIT ZERO..MRO DIGIT NINE
+      | 0xF0 0x96 0xAB 0x90..0xAD  #Lo  [30] BASSA VAH LETTER ENNI..BASSA VA...
+      | 0xF0 0x96 0xAB 0xB0..0xB4  #Mn   [5] BASSA VAH COMBINING HIGH TONE.....
+      | 0xF0 0x96 0xAC 0x80..0xAF  #Lo  [48] PAHAWH HMONG VOWEL KEEB..PAHAWH...
+      | 0xF0 0x96 0xAC 0xB0..0xB6  #Mn   [7] PAHAWH HMONG MARK CIM TUB..PAHA...
+      | 0xF0 0x96 0xAD 0x80..0x83  #Lm   [4] PAHAWH HMONG SIGN VOS SEEV..PAH...
+      | 0xF0 0x96 0xAD 0x90..0x99  #Nd  [10] PAHAWH HMONG DIGIT ZERO..PAHAWH...
+      | 0xF0 0x96 0xAD 0xA3..0xB7  #Lo  [21] PAHAWH HMONG SIGN VOS LUB..PAHA...
+      | 0xF0 0x96 0xAD 0xBD..0xFF  #Lo  [19] PAHAWH HMONG CLAN SIGN TSHEEJ.....
+      | 0xF0 0x96 0xAE 0x00..0x8F  #
+      | 0xF0 0x96 0xBC 0x80..0xFF  #Lo  [69] MIAO LETTER PA..MIAO LETTER HHA
+      | 0xF0 0x96 0xBD 0x00..0x84  #
+      | 0xF0 0x96 0xBD 0x90     #Lo       MIAO LETTER NASALIZATION
+      | 0xF0 0x96 0xBD 0x91..0xBE  #Mc  [46] MIAO SIGN ASPIRATION..MIAO VOWE...
+      | 0xF0 0x96 0xBE 0x8F..0x92  #Mn   [4] MIAO TONE RIGHT..MIAO TONE BELOW
+      | 0xF0 0x96 0xBE 0x93..0x9F  #Lm  [13] MIAO LETTER TONE-2..MIAO LETTER...
+      | 0xF0 0x96 0xBF 0xA0     #Lm       TANGUT ITERATION MARK
+      | 0xF0 0x97 0x80 0x80..0xFF        #Lo [6125] TANGUT IDEOGRAPH-17000.....
+      | 0xF0 0x97 0x81..0xFF 0x00..0xFF  #
+      | 0xF0 0x98 0x00 0x00..0xFF        #
+      | 0xF0 0x98 0x01..0x9E 0x00..0xFF  #
+      | 0xF0 0x98 0x9F 0x00..0xAC        #
+      | 0xF0 0x98 0xA0 0x80..0xFF        #Lo [755] TANGUT COMPONENT-001..TAN...
+      | 0xF0 0x98 0xA1..0xAA 0x00..0xFF  #
+      | 0xF0 0x98 0xAB 0x00..0xB2        #
+      | 0xF0 0x9B 0x80 0x80..0x81  #Lo   [2] KATAKANA LETTER ARCHAIC E..HIRA...
+      | 0xF0 0x9B 0xB0 0x80..0xFF  #Lo [107] DUPLOYAN LETTER H..DUPLOYAN LET...
+      | 0xF0 0x9B 0xB1 0x00..0xAA  #
+      | 0xF0 0x9B 0xB1 0xB0..0xBC  #Lo  [13] DUPLOYAN AFFIX LEFT HORIZONTAL ...
+      | 0xF0 0x9B 0xB2 0x80..0x88  #Lo   [9] DUPLOYAN AFFIX HIGH ACUTE..DUPL...
+      | 0xF0 0x9B 0xB2 0x90..0x99  #Lo  [10] DUPLOYAN AFFIX LOW ACUTE..DUPLO...
+      | 0xF0 0x9B 0xB2 0x9D..0x9E  #Mn   [2] DUPLOYAN THICK LETTER SELECTOR....
+      | 0xF0 0x9D 0x85 0xA5..0xA6  #Mc   [2] MUSICAL SYMBOL COMBINING STEM.....
+      | 0xF0 0x9D 0x85 0xA7..0xA9  #Mn   [3] MUSICAL SYMBOL COMBINING TREMOL...
+      | 0xF0 0x9D 0x85 0xAD..0xB2  #Mc   [6] MUSICAL SYMBOL COMBINING AUGMEN...
+      | 0xF0 0x9D 0x85 0xBB..0xFF  #Mn   [8] MUSICAL SYMBOL COMBINING ACCENT...
+      | 0xF0 0x9D 0x86 0x00..0x82  #
+      | 0xF0 0x9D 0x86 0x85..0x8B  #Mn   [7] MUSICAL SYMBOL COMBINING DOIT.....
+      | 0xF0 0x9D 0x86 0xAA..0xAD  #Mn   [4] MUSICAL SYMBOL COMBINING DOWN B...
+      | 0xF0 0x9D 0x89 0x82..0x84  #Mn   [3] COMBINING GREEK MUSICAL TRISEME...
+      | 0xF0 0x9D 0x90 0x80..0xFF  #L&  [85] MATHEMATICAL BOLD CAPITAL A..MA...
+      | 0xF0 0x9D 0x91 0x00..0x94  #
+      | 0xF0 0x9D 0x91 0x96..0xFF  #L&  [71] MATHEMATICAL ITALIC SMALL I..MA...
+      | 0xF0 0x9D 0x92 0x00..0x9C  #
+      | 0xF0 0x9D 0x92 0x9E..0x9F  #L&   [2] MATHEMATICAL SCRIPT CAPITAL C.....
+      | 0xF0 0x9D 0x92 0xA2     #L&       MATHEMATICAL SCRIPT CAPITAL G
+      | 0xF0 0x9D 0x92 0xA5..0xA6  #L&   [2] MATHEMATICAL SCRIPT CAPITAL J.....
+      | 0xF0 0x9D 0x92 0xA9..0xAC  #L&   [4] MATHEMATICAL SCRIPT CAPITAL N.....
+      | 0xF0 0x9D 0x92 0xAE..0xB9  #L&  [12] MATHEMATICAL SCRIPT CAPITAL S.....
+      | 0xF0 0x9D 0x92 0xBB     #L&       MATHEMATICAL SCRIPT SMALL F
+      | 0xF0 0x9D 0x92 0xBD..0xFF  #L&   [7] MATHEMATICAL SCRIPT SMALL H..MA...
+      | 0xF0 0x9D 0x93 0x00..0x83  #
+      | 0xF0 0x9D 0x93 0x85..0xFF  #L&  [65] MATHEMATICAL SCRIPT SMALL P..MA...
+      | 0xF0 0x9D 0x94 0x00..0x85  #
+      | 0xF0 0x9D 0x94 0x87..0x8A  #L&   [4] MATHEMATICAL FRAKTUR CAPITAL D....
+      | 0xF0 0x9D 0x94 0x8D..0x94  #L&   [8] MATHEMATICAL FRAKTUR CAPITAL J....
+      | 0xF0 0x9D 0x94 0x96..0x9C  #L&   [7] MATHEMATICAL FRAKTUR CAPITAL S....
+      | 0xF0 0x9D 0x94 0x9E..0xB9  #L&  [28] MATHEMATICAL FRAKTUR SMALL A..M...
+      | 0xF0 0x9D 0x94 0xBB..0xBE  #L&   [4] MATHEMATICAL DOUBLE-STRUCK CAPI...
+      | 0xF0 0x9D 0x95 0x80..0x84  #L&   [5] MATHEMATICAL DOUBLE-STRUCK CAPI...
+      | 0xF0 0x9D 0x95 0x86     #L&       MATHEMATICAL DOUBLE-STRUCK CAPITAL O
+      | 0xF0 0x9D 0x95 0x8A..0x90  #L&   [7] MATHEMATICAL DOUBLE-STRUCK CAPI...
+      | 0xF0 0x9D 0x95 0x92..0xFF        #L& [340] MATHEMATICAL DOUBLE-STRUC...
+      | 0xF0 0x9D 0x96..0x99 0x00..0xFF  #
+      | 0xF0 0x9D 0x9A 0x00..0xA5        #
+      | 0xF0 0x9D 0x9A 0xA8..0xFF  #L&  [25] MATHEMATICAL BOLD CAPITAL ALPHA...
+      | 0xF0 0x9D 0x9B 0x00..0x80  #
+      | 0xF0 0x9D 0x9B 0x82..0x9A  #L&  [25] MATHEMATICAL BOLD SMALL ALPHA.....
+      | 0xF0 0x9D 0x9B 0x9C..0xBA  #L&  [31] MATHEMATICAL BOLD EPSILON SYMBO...
+      | 0xF0 0x9D 0x9B 0xBC..0xFF  #L&  [25] MATHEMATICAL ITALIC SMALL ALPHA...
+      | 0xF0 0x9D 0x9C 0x00..0x94  #
+      | 0xF0 0x9D 0x9C 0x96..0xB4  #L&  [31] MATHEMATICAL ITALIC EPSILON SYM...
+      | 0xF0 0x9D 0x9C 0xB6..0xFF  #L&  [25] MATHEMATICAL BOLD ITALIC SMALL ...
+      | 0xF0 0x9D 0x9D 0x00..0x8E  #
+      | 0xF0 0x9D 0x9D 0x90..0xAE  #L&  [31] MATHEMATICAL BOLD ITALIC EPSILO...
+      | 0xF0 0x9D 0x9D 0xB0..0xFF  #L&  [25] MATHEMATICAL SANS-SERIF BOLD SM...
+      | 0xF0 0x9D 0x9E 0x00..0x88  #
+      | 0xF0 0x9D 0x9E 0x8A..0xA8  #L&  [31] MATHEMATICAL SANS-SERIF BOLD EP...
+      | 0xF0 0x9D 0x9E 0xAA..0xFF  #L&  [25] MATHEMATICAL SANS-SERIF BOLD IT...
+      | 0xF0 0x9D 0x9F 0x00..0x82  #
+      | 0xF0 0x9D 0x9F 0x84..0x8B  #L&   [8] MATHEMATICAL SANS-SERIF BOLD IT...
+      | 0xF0 0x9D 0x9F 0x8E..0xBF  #Nd  [50] MATHEMATICAL BOLD DIGIT ZERO..M...
+      | 0xF0 0x9D 0xA8 0x80..0xB6  #Mn  [55] SIGNWRITING HEAD RIM..SIGNWRITI...
+      | 0xF0 0x9D 0xA8 0xBB..0xFF  #Mn  [50] SIGNWRITING MOUTH CLOSED NEUTRA...
+      | 0xF0 0x9D 0xA9 0x00..0xAC  #
+      | 0xF0 0x9D 0xA9 0xB5     #Mn       SIGNWRITING UPPER BODY TILTING FRO...
+      | 0xF0 0x9D 0xAA 0x84     #Mn       SIGNWRITING LOCATION HEAD NECK
+      | 0xF0 0x9D 0xAA 0x9B..0x9F  #Mn   [5] SIGNWRITING FILL MODIFIER-2..SI...
+      | 0xF0 0x9D 0xAA 0xA1..0xAF  #Mn  [15] SIGNWRITING ROTATION MODIFIER-2...
+      | 0xF0 0x9E 0x80 0x80..0x86  #Mn   [7] COMBINING GLAGOLITIC LETTER AZU...
+      | 0xF0 0x9E 0x80 0x88..0x98  #Mn  [17] COMBINING GLAGOLITIC LETTER ZEM...
+      | 0xF0 0x9E 0x80 0x9B..0xA1  #Mn   [7] COMBINING GLAGOLITIC LETTER SHT...
+      | 0xF0 0x9E 0x80 0xA3..0xA4  #Mn   [2] COMBINING GLAGOLITIC LETTER YU....
+      | 0xF0 0x9E 0x80 0xA6..0xAA  #Mn   [5] COMBINING GLAGOLITIC LETTER YO....
+      | 0xF0 0x9E 0xA0 0x80..0xFF        #Lo [197] MENDE KIKAKUI SYLLABLE M0...
+      | 0xF0 0x9E 0xA1..0xA2 0x00..0xFF  #
+      | 0xF0 0x9E 0xA3 0x00..0x84        #
+      | 0xF0 0x9E 0xA3 0x90..0x96  #Mn   [7] MENDE KIKAKUI COMBINING NUMBER ...
+      | 0xF0 0x9E 0xA4 0x80..0xFF  #L&  [68] ADLAM CAPITAL LETTER ALIF..ADLA...
+      | 0xF0 0x9E 0xA5 0x00..0x83  #
+      | 0xF0 0x9E 0xA5 0x84..0x8A  #Mn   [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA
+      | 0xF0 0x9E 0xA5 0x90..0x99  #Nd  [10] ADLAM DIGIT ZERO..ADLAM DIGIT NINE
+      | 0xF0 0x9E 0xB8 0x80..0x83  #Lo   [4] ARABIC MATHEMATICAL ALEF..ARABI...
+      | 0xF0 0x9E 0xB8 0x85..0x9F  #Lo  [27] ARABIC MATHEMATICAL WAW..ARABIC...
+      | 0xF0 0x9E 0xB8 0xA1..0xA2  #Lo   [2] ARABIC MATHEMATICAL INITIAL BEH...
+      | 0xF0 0x9E 0xB8 0xA4     #Lo       ARABIC MATHEMATICAL INITIAL HEH
+      | 0xF0 0x9E 0xB8 0xA7     #Lo       ARABIC MATHEMATICAL INITIAL HAH
+      | 0xF0 0x9E 0xB8 0xA9..0xB2  #Lo  [10] ARABIC MATHEMATICAL INITIAL YEH...
+      | 0xF0 0x9E 0xB8 0xB4..0xB7  #Lo   [4] ARABIC MATHEMATICAL INITIAL SHE...
+      | 0xF0 0x9E 0xB8 0xB9     #Lo       ARABIC MATHEMATICAL INITIAL DAD
+      | 0xF0 0x9E 0xB8 0xBB     #Lo       ARABIC MATHEMATICAL INITIAL GHAIN
+      | 0xF0 0x9E 0xB9 0x82     #Lo       ARABIC MATHEMATICAL TAILED JEEM
+      | 0xF0 0x9E 0xB9 0x87     #Lo       ARABIC MATHEMATICAL TAILED HAH
+      | 0xF0 0x9E 0xB9 0x89     #Lo       ARABIC MATHEMATICAL TAILED YEH
+      | 0xF0 0x9E 0xB9 0x8B     #Lo       ARABIC MATHEMATICAL TAILED LAM
+      | 0xF0 0x9E 0xB9 0x8D..0x8F  #Lo   [3] ARABIC MATHEMATICAL TAILED NOON...
+      | 0xF0 0x9E 0xB9 0x91..0x92  #Lo   [2] ARABIC MATHEMATICAL TAILED SAD....
+      | 0xF0 0x9E 0xB9 0x94     #Lo       ARABIC MATHEMATICAL TAILED SHEEN
+      | 0xF0 0x9E 0xB9 0x97     #Lo       ARABIC MATHEMATICAL TAILED KHAH
+      | 0xF0 0x9E 0xB9 0x99     #Lo       ARABIC MATHEMATICAL TAILED DAD
+      | 0xF0 0x9E 0xB9 0x9B     #Lo       ARABIC MATHEMATICAL TAILED GHAIN
+      | 0xF0 0x9E 0xB9 0x9D     #Lo       ARABIC MATHEMATICAL TAILED DOTLESS...
+      | 0xF0 0x9E 0xB9 0x9F     #Lo       ARABIC MATHEMATICAL TAILED DOTLESS...
+      | 0xF0 0x9E 0xB9 0xA1..0xA2  #Lo   [2] ARABIC MATHEMATICAL STRETCHED B...
+      | 0xF0 0x9E 0xB9 0xA4     #Lo       ARABIC MATHEMATICAL STRETCHED HEH
+      | 0xF0 0x9E 0xB9 0xA7..0xAA  #Lo   [4] ARABIC MATHEMATICAL STRETCHED H...
+      | 0xF0 0x9E 0xB9 0xAC..0xB2  #Lo   [7] ARABIC MATHEMATICAL STRETCHED M...
+      | 0xF0 0x9E 0xB9 0xB4..0xB7  #Lo   [4] ARABIC MATHEMATICAL STRETCHED S...
+      | 0xF0 0x9E 0xB9 0xB9..0xBC  #Lo   [4] ARABIC MATHEMATICAL STRETCHED D...
+      | 0xF0 0x9E 0xB9 0xBE     #Lo       ARABIC MATHEMATICAL STRETCHED DOTL...
+      | 0xF0 0x9E 0xBA 0x80..0x89  #Lo  [10] ARABIC MATHEMATICAL LOOPED ALEF...
+      | 0xF0 0x9E 0xBA 0x8B..0x9B  #Lo  [17] ARABIC MATHEMATICAL LOOPED LAM....
+      | 0xF0 0x9E 0xBA 0xA1..0xA3  #Lo   [3] ARABIC MATHEMATICAL DOUBLE-STRU...
+      | 0xF0 0x9E 0xBA 0xA5..0xA9  #Lo   [5] ARABIC MATHEMATICAL DOUBLE-STRU...
+      | 0xF0 0x9E 0xBA 0xAB..0xBB  #Lo  [17] ARABIC MATHEMATICAL DOUBLE-STRU...
+      | 0xF0 0xA0 0x80 0x80..0xFF              #Lo [42711] CJK UNIFIED IDEOG...
+      | 0xF0 0xA0 0x81..0xFF 0x00..0xFF        #
+      | 0xF0 0xA1..0xA9 0x00..0xFF 0x00..0xFF  #
+      | 0xF0 0xAA 0x00 0x00..0xFF              #
+      | 0xF0 0xAA 0x01..0x9A 0x00..0xFF        #
+      | 0xF0 0xAA 0x9B 0x00..0x96              #
+      | 0xF0 0xAA 0x9C 0x80..0xFF        #Lo [4149] CJK UNIFIED IDEOGRAPH-2A...
+      | 0xF0 0xAA 0x9D..0xFF 0x00..0xFF  #
+      | 0xF0 0xAB 0x00 0x00..0xFF        #
+      | 0xF0 0xAB 0x01..0x9B 0x00..0xFF  #
+      | 0xF0 0xAB 0x9C 0x00..0xB4        #
+      | 0xF0 0xAB 0x9D 0x80..0xFF        #Lo [222] CJK UNIFIED IDEOGRAPH-2B7...
+      | 0xF0 0xAB 0x9E..0x9F 0x00..0xFF  #
+      | 0xF0 0xAB 0xA0 0x00..0x9D        #
+      | 0xF0 0xAB 0xA0 0xA0..0xFF        #Lo [5762] CJK UNIFIED IDEOGRAPH-2B...
+      | 0xF0 0xAB 0xA1..0xFF 0x00..0xFF  #
+      | 0xF0 0xAC 0x00 0x00..0xFF        #
+      | 0xF0 0xAC 0x01..0xB9 0x00..0xFF  #
+      | 0xF0 0xAC 0xBA 0x00..0xA1        #
+      | 0xF0 0xAF 0xA0 0x80..0xFF        #Lo [542] CJK COMPATIBILITY IDEOGRA...
+      | 0xF0 0xAF 0xA1..0xA7 0x00..0xFF  #
+      | 0xF0 0xAF 0xA8 0x00..0x9D        #
+      | 0xF3 0xA0 0x84 0x80..0xFF        #Mn [240] VARIATION SELECTOR-17..VA...
+      | 0xF3 0xA0 0x85..0x86 0x00..0xFF  #
+      | 0xF3 0xA0 0x87 0x00..0xAF        #
+      ;
+
+}%%
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/variables.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/variables.go
new file mode 100644
index 00000000..3d68c413
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/variables.go
@@ -0,0 +1,86 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// Variables returns all of the variables referenced within a given experssion.
+//
+// This is the implementation of the "Variables" method on every native
+// expression.
+func Variables(expr Expression) []hcl.Traversal {
+	var vars []hcl.Traversal
+
+	walker := &variablesWalker{
+		Callback: func(t hcl.Traversal) {
+			vars = append(vars, t)
+		},
+	}
+
+	Walk(expr, walker)
+
+	return vars
+}
+
+// variablesWalker is a Walker implementation that calls its callback for any
+// root scope traversal found while walking.
+type variablesWalker struct {
+	Callback    func(hcl.Traversal)
+	localScopes []map[string]struct{}
+}
+
+func (w *variablesWalker) Enter(n Node) hcl.Diagnostics {
+	switch tn := n.(type) {
+	case *ScopeTraversalExpr:
+		t := tn.Traversal
+
+		// Check if the given root name appears in any of the active
+		// local scopes. We don't want to return local variables here, since
+		// the goal of walking variables is to tell the calling application
+		// which names it needs to populate in the _root_ scope.
+		name := t.RootName()
+		for _, names := range w.localScopes {
+			if _, localized := names[name]; localized {
+				return nil
+			}
+		}
+
+		w.Callback(t)
+	case ChildScope:
+		w.localScopes = append(w.localScopes, tn.LocalNames)
+	}
+	return nil
+}
+
+func (w *variablesWalker) Exit(n Node) hcl.Diagnostics {
+	switch n.(type) {
+	case ChildScope:
+		// pop the latest local scope, assuming that the walker will
+		// behave symmetrically as promised.
+		w.localScopes = w.localScopes[:len(w.localScopes)-1]
+	}
+	return nil
+}
+
+// ChildScope is a synthetic AST node that is visited during a walk to
+// indicate that its descendent will be evaluated in a child scope, which
+// may mask certain variables from the parent scope as locals.
+//
+// ChildScope nodes don't really exist in the AST, but are rather synthesized
+// on the fly during walk. Therefore it doesn't do any good to transform them;
+// instead, transform either parent node that created a scope or the expression
+// that the child scope struct wraps.
+type ChildScope struct {
+	LocalNames map[string]struct{}
+	Expr       Expression
+}
+
+func (e ChildScope) walkChildNodes(w internalWalkFunc) {
+	w(e.Expr)
+}
+
+// Range returns the range of the expression that the ChildScope is
+// encapsulating. It isn't really very useful to call Range on a ChildScope.
+func (e ChildScope) Range() hcl.Range {
+	return e.Expr.Range()
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/walk.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/walk.go
new file mode 100644
index 00000000..89bfe676
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/walk.go
@@ -0,0 +1,41 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// VisitFunc is the callback signature for VisitAll.
+type VisitFunc func(node Node) hcl.Diagnostics
+
+// VisitAll is a basic way to traverse the AST beginning with a particular
+// node. The given function will be called once for each AST node in
+// depth-first order, but no context is provided about the shape of the tree.
+//
+// The VisitFunc may return diagnostics, in which case they will be accumulated
+// and returned as a single set.
+func VisitAll(node Node, f VisitFunc) hcl.Diagnostics {
+	diags := f(node)
+	node.walkChildNodes(func(node Node) {
+		diags = append(diags, VisitAll(node, f)...)
+	})
+	return diags
+}
+
+// Walker is an interface used with Walk.
+type Walker interface {
+	Enter(node Node) hcl.Diagnostics
+	Exit(node Node) hcl.Diagnostics
+}
+
+// Walk is a more complex way to traverse the AST starting with a particular
+// node, which provides information about the tree structure via separate
+// Enter and Exit functions.
+func Walk(node Node, w Walker) hcl.Diagnostics {
+	diags := w.Enter(node)
+	node.walkChildNodes(func(node Node) {
+		diags = append(diags, Walk(node, w)...)
+	})
+	moreDiags := w.Exit(node)
+	diags = append(diags, moreDiags...)
+	return diags
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast.go
new file mode 100644
index 00000000..09041652
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast.go
@@ -0,0 +1,121 @@
+package hclwrite
+
+import (
+	"bytes"
+	"io"
+)
+
+type File struct {
+	inTree
+
+	srcBytes []byte
+	body     *node
+}
+
+// NewEmptyFile constructs a new file with no content, ready to be mutated
+// by other calls that append to its body.
+func NewEmptyFile() *File {
+	f := &File{
+		inTree: newInTree(),
+	}
+	body := newBody()
+	f.body = f.children.Append(body)
+	return f
+}
+
+// Body returns the root body of the file, which contains the top-level
+// attributes and blocks.
+func (f *File) Body() *Body {
+	return f.body.content.(*Body)
+}
+
+// WriteTo writes the tokens underlying the receiving file to the given writer.
+//
+// The tokens first have a simple formatting pass applied that adjusts only
+// the spaces between them.
+func (f *File) WriteTo(wr io.Writer) (int64, error) {
+	tokens := f.inTree.children.BuildTokens(nil)
+	format(tokens)
+	return tokens.WriteTo(wr)
+}
+
+// Bytes returns a buffer containing the source code resulting from the
+// tokens underlying the receiving file. If any updates have been made via
+// the AST API, these will be reflected in the result.
+func (f *File) Bytes() []byte {
+	buf := &bytes.Buffer{}
+	f.WriteTo(buf)
+	return buf.Bytes()
+}
+
+type comments struct {
+	leafNode
+
+	parent *node
+	tokens Tokens
+}
+
+func newComments(tokens Tokens) *comments {
+	return &comments{
+		tokens: tokens,
+	}
+}
+
+func (c *comments) BuildTokens(to Tokens) Tokens {
+	return c.tokens.BuildTokens(to)
+}
+
+type identifier struct {
+	leafNode
+
+	parent *node
+	token  *Token
+}
+
+func newIdentifier(token *Token) *identifier {
+	return &identifier{
+		token: token,
+	}
+}
+
+func (i *identifier) BuildTokens(to Tokens) Tokens {
+	return append(to, i.token)
+}
+
+func (i *identifier) hasName(name string) bool {
+	return name == string(i.token.Bytes)
+}
+
+type number struct {
+	leafNode
+
+	parent *node
+	token  *Token
+}
+
+func newNumber(token *Token) *number {
+	return &number{
+		token: token,
+	}
+}
+
+func (n *number) BuildTokens(to Tokens) Tokens {
+	return append(to, n.token)
+}
+
+type quoted struct {
+	leafNode
+
+	parent *node
+	tokens Tokens
+}
+
+func newQuoted(tokens Tokens) *quoted {
+	return &quoted{
+		tokens: tokens,
+	}
+}
+
+func (q *quoted) BuildTokens(to Tokens) Tokens {
+	return q.tokens.BuildTokens(to)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_attribute.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_attribute.go
new file mode 100644
index 00000000..609419ff
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_attribute.go
@@ -0,0 +1,48 @@
+package hclwrite
+
+import (
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+)
+
+type Attribute struct {
+	inTree
+
+	leadComments *node
+	name         *node
+	expr         *node
+	lineComments *node
+}
+
+func newAttribute() *Attribute {
+	return &Attribute{
+		inTree: newInTree(),
+	}
+}
+
+func (a *Attribute) init(name string, expr *Expression) {
+	expr.assertUnattached()
+
+	nameTok := newIdentToken(name)
+	nameObj := newIdentifier(nameTok)
+	a.leadComments = a.children.Append(newComments(nil))
+	a.name = a.children.Append(nameObj)
+	a.children.AppendUnstructuredTokens(Tokens{
+		{
+			Type:  hclsyntax.TokenEqual,
+			Bytes: []byte{'='},
+		},
+	})
+	a.expr = a.children.Append(expr)
+	a.expr.list = a.children
+	a.lineComments = a.children.Append(newComments(nil))
+	a.children.AppendUnstructuredTokens(Tokens{
+		{
+			Type:  hclsyntax.TokenNewline,
+			Bytes: []byte{'\n'},
+		},
+	})
+}
+
+func (a *Attribute) Expr() *Expression {
+	return a.expr.content.(*Expression)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_block.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_block.go
new file mode 100644
index 00000000..f7d3921b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_block.go
@@ -0,0 +1,118 @@
+package hclwrite
+
+import (
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+)
+
+type Block struct {
+	inTree
+
+	leadComments *node
+	typeName     *node
+	labels       nodeSet
+	open         *node
+	body         *node
+	close        *node
+}
+
+func newBlock() *Block {
+	return &Block{
+		inTree: newInTree(),
+		labels: newNodeSet(),
+	}
+}
+
+// NewBlock constructs a new, empty block with the given type name and labels.
+func NewBlock(typeName string, labels []string) *Block {
+	block := newBlock()
+	block.init(typeName, labels)
+	return block
+}
+
+func (b *Block) init(typeName string, labels []string) {
+	nameTok := newIdentToken(typeName)
+	nameObj := newIdentifier(nameTok)
+	b.leadComments = b.children.Append(newComments(nil))
+	b.typeName = b.children.Append(nameObj)
+	for _, label := range labels {
+		labelToks := TokensForValue(cty.StringVal(label))
+		labelObj := newQuoted(labelToks)
+		labelNode := b.children.Append(labelObj)
+		b.labels.Add(labelNode)
+	}
+	b.open = b.children.AppendUnstructuredTokens(Tokens{
+		{
+			Type:  hclsyntax.TokenOBrace,
+			Bytes: []byte{'{'},
+		},
+		{
+			Type:  hclsyntax.TokenNewline,
+			Bytes: []byte{'\n'},
+		},
+	})
+	body := newBody() // initially totally empty; caller can append to it subsequently
+	b.body = b.children.Append(body)
+	b.close = b.children.AppendUnstructuredTokens(Tokens{
+		{
+			Type:  hclsyntax.TokenCBrace,
+			Bytes: []byte{'}'},
+		},
+		{
+			Type:  hclsyntax.TokenNewline,
+			Bytes: []byte{'\n'},
+		},
+	})
+}
+
+// Body returns the body that represents the content of the receiving block.
+//
+// Appending to or otherwise modifying this body will make changes to the
+// tokens that are generated between the blocks open and close braces.
+func (b *Block) Body() *Body {
+	return b.body.content.(*Body)
+}
+
+// Type returns the type name of the block.
+func (b *Block) Type() string {
+	typeNameObj := b.typeName.content.(*identifier)
+	return string(typeNameObj.token.Bytes)
+}
+
+// Labels returns the labels of the block.
+func (b *Block) Labels() []string {
+	labelNames := make([]string, 0, len(b.labels))
+	list := b.labels.List()
+
+	for _, label := range list {
+		switch labelObj := label.content.(type) {
+		case *identifier:
+			if labelObj.token.Type == hclsyntax.TokenIdent {
+				labelString := string(labelObj.token.Bytes)
+				labelNames = append(labelNames, labelString)
+			}
+
+		case *quoted:
+			tokens := labelObj.tokens
+			if len(tokens) == 3 &&
+				tokens[0].Type == hclsyntax.TokenOQuote &&
+				tokens[1].Type == hclsyntax.TokenQuotedLit &&
+				tokens[2].Type == hclsyntax.TokenCQuote {
+				// Note that TokenQuotedLit may contain escape sequences.
+				labelString, diags := hclsyntax.ParseStringLiteralToken(tokens[1].asHCLSyntax())
+
+				// If parsing the string literal returns error diagnostics
+				// then we can just assume the label doesn't match, because it's invalid in some way.
+				if !diags.HasErrors() {
+					labelNames = append(labelNames, labelString)
+				}
+			}
+
+		default:
+			// If neither of the previous cases are true (should be impossible)
+			// then we can just ignore it, because it's invalid too.
+		}
+	}
+
+	return labelNames
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_body.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_body.go
new file mode 100644
index 00000000..119f53e6
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_body.go
@@ -0,0 +1,239 @@
+package hclwrite
+
+import (
+	"reflect"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+)
+
+type Body struct {
+	inTree
+
+	items nodeSet
+}
+
+func newBody() *Body {
+	return &Body{
+		inTree: newInTree(),
+		items:  newNodeSet(),
+	}
+}
+
+func (b *Body) appendItem(c nodeContent) *node {
+	nn := b.children.Append(c)
+	b.items.Add(nn)
+	return nn
+}
+
+func (b *Body) appendItemNode(nn *node) *node {
+	nn.assertUnattached()
+	b.children.AppendNode(nn)
+	b.items.Add(nn)
+	return nn
+}
+
+// Clear removes all of the items from the body, making it empty.
+func (b *Body) Clear() {
+	b.children.Clear()
+}
+
+func (b *Body) AppendUnstructuredTokens(ts Tokens) {
+	b.inTree.children.Append(ts)
+}
+
+// Attributes returns a new map of all of the attributes in the body, with
+// the attribute names as the keys.
+func (b *Body) Attributes() map[string]*Attribute {
+	ret := make(map[string]*Attribute)
+	for n := range b.items {
+		if attr, isAttr := n.content.(*Attribute); isAttr {
+			nameObj := attr.name.content.(*identifier)
+			name := string(nameObj.token.Bytes)
+			ret[name] = attr
+		}
+	}
+	return ret
+}
+
+// Blocks returns a new slice of all the blocks in the body.
+func (b *Body) Blocks() []*Block {
+	ret := make([]*Block, 0, len(b.items))
+	for _, n := range b.items.List() {
+		if block, isBlock := n.content.(*Block); isBlock {
+			ret = append(ret, block)
+		}
+	}
+	return ret
+}
+
+// GetAttribute returns the attribute from the body that has the given name,
+// or returns nil if there is currently no matching attribute.
+func (b *Body) GetAttribute(name string) *Attribute {
+	for n := range b.items {
+		if attr, isAttr := n.content.(*Attribute); isAttr {
+			nameObj := attr.name.content.(*identifier)
+			if nameObj.hasName(name) {
+				// We've found it!
+				return attr
+			}
+		}
+	}
+
+	return nil
+}
+
+// getAttributeNode is like GetAttribute but it returns the node containing
+// the selected attribute (if one is found) rather than the attribute itself.
+func (b *Body) getAttributeNode(name string) *node {
+	for n := range b.items {
+		if attr, isAttr := n.content.(*Attribute); isAttr {
+			nameObj := attr.name.content.(*identifier)
+			if nameObj.hasName(name) {
+				// We've found it!
+				return n
+			}
+		}
+	}
+
+	return nil
+}
+
+// FirstMatchingBlock returns a first matching block from the body that has the
+// given name and labels or returns nil if there is currently no matching
+// block.
+func (b *Body) FirstMatchingBlock(typeName string, labels []string) *Block {
+	for _, block := range b.Blocks() {
+		if typeName == block.Type() {
+			labelNames := block.Labels()
+			if len(labels) == 0 && len(labelNames) == 0 {
+				return block
+			}
+			if reflect.DeepEqual(labels, labelNames) {
+				return block
+			}
+		}
+	}
+
+	return nil
+}
+
+// RemoveBlock removes the given block from the body, if it's in that body.
+// If it isn't present, this is a no-op.
+//
+// Returns true if it removed something, or false otherwise.
+func (b *Body) RemoveBlock(block *Block) bool {
+	for n := range b.items {
+		if n.content == block {
+			n.Detach()
+			b.items.Remove(n)
+			return true
+		}
+	}
+	return false
+}
+
+// SetAttributeRaw either replaces the expression of an existing attribute
+// of the given name or adds a new attribute definition to the end of the block,
+// using the given tokens verbatim as the expression.
+//
+// The same caveats apply to this function as for NewExpressionRaw on which
+// it is based. If possible, prefer to use SetAttributeValue or
+// SetAttributeTraversal.
+func (b *Body) SetAttributeRaw(name string, tokens Tokens) *Attribute {
+	attr := b.GetAttribute(name)
+	expr := NewExpressionRaw(tokens)
+	if attr != nil {
+		attr.expr = attr.expr.ReplaceWith(expr)
+	} else {
+		attr := newAttribute()
+		attr.init(name, expr)
+		b.appendItem(attr)
+	}
+	return attr
+}
+
+// SetAttributeValue either replaces the expression of an existing attribute
+// of the given name or adds a new attribute definition to the end of the block.
+//
+// The value is given as a cty.Value, and must therefore be a literal. To set
+// a variable reference or other traversal, use SetAttributeTraversal.
+//
+// The return value is the attribute that was either modified in-place or
+// created.
+func (b *Body) SetAttributeValue(name string, val cty.Value) *Attribute {
+	attr := b.GetAttribute(name)
+	expr := NewExpressionLiteral(val)
+	if attr != nil {
+		attr.expr = attr.expr.ReplaceWith(expr)
+	} else {
+		attr := newAttribute()
+		attr.init(name, expr)
+		b.appendItem(attr)
+	}
+	return attr
+}
+
+// SetAttributeTraversal either replaces the expression of an existing attribute
+// of the given name or adds a new attribute definition to the end of the body.
+//
+// The new expression is given as a hcl.Traversal, which must be an absolute
+// traversal. To set a literal value, use SetAttributeValue.
+//
+// The return value is the attribute that was either modified in-place or
+// created.
+func (b *Body) SetAttributeTraversal(name string, traversal hcl.Traversal) *Attribute {
+	attr := b.GetAttribute(name)
+	expr := NewExpressionAbsTraversal(traversal)
+	if attr != nil {
+		attr.expr = attr.expr.ReplaceWith(expr)
+	} else {
+		attr := newAttribute()
+		attr.init(name, expr)
+		b.appendItem(attr)
+	}
+	return attr
+}
+
+// RemoveAttribute removes the attribute with the given name from the body.
+//
+// The return value is the attribute that was removed, or nil if there was
+// no such attribute (in which case the call was a no-op).
+func (b *Body) RemoveAttribute(name string) *Attribute {
+	node := b.getAttributeNode(name)
+	if node == nil {
+		return nil
+	}
+	node.Detach()
+	b.items.Remove(node)
+	return node.content.(*Attribute)
+}
+
+// AppendBlock appends an existing block (which must not be already attached
+// to a body) to the end of the receiving body.
+func (b *Body) AppendBlock(block *Block) *Block {
+	b.appendItem(block)
+	return block
+}
+
+// AppendNewBlock appends a new nested block to the end of the receiving body
+// with the given type name and labels.
+func (b *Body) AppendNewBlock(typeName string, labels []string) *Block {
+	block := newBlock()
+	block.init(typeName, labels)
+	b.appendItem(block)
+	return block
+}
+
+// AppendNewline appends a newline token to th end of the receiving body,
+// which generally serves as a separator between different sets of body
+// contents.
+func (b *Body) AppendNewline() {
+	b.AppendUnstructuredTokens(Tokens{
+		{
+			Type:  hclsyntax.TokenNewline,
+			Bytes: []byte{'\n'},
+		},
+	})
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_expression.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_expression.go
new file mode 100644
index 00000000..073c3087
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_expression.go
@@ -0,0 +1,224 @@
+package hclwrite
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+)
+
+type Expression struct {
+	inTree
+
+	absTraversals nodeSet
+}
+
+func newExpression() *Expression {
+	return &Expression{
+		inTree:        newInTree(),
+		absTraversals: newNodeSet(),
+	}
+}
+
+// NewExpressionRaw constructs an expression containing the given raw tokens.
+//
+// There is no automatic validation that the given tokens produce a valid
+// expression. Callers of thus function must take care to produce invalid
+// expression tokens. Where possible, use the higher-level functions
+// NewExpressionLiteral or NewExpressionAbsTraversal instead.
+//
+// Because NewExpressionRaw does not interpret the given tokens in any way,
+// an expression created by NewExpressionRaw will produce an empty result
+// for calls to its method Variables, even if the given token sequence
+// contains a subslice that would normally be interpreted as a traversal under
+// parsing.
+func NewExpressionRaw(tokens Tokens) *Expression {
+	expr := newExpression()
+	// We copy the tokens here in order to make sure that later mutations
+	// by the caller don't inadvertently cause our expression to become
+	// invalid.
+	copyTokens := make(Tokens, len(tokens))
+	copy(copyTokens, tokens)
+	expr.children.AppendUnstructuredTokens(copyTokens)
+	return expr
+}
+
+// NewExpressionLiteral constructs an an expression that represents the given
+// literal value.
+//
+// Since an unknown value cannot be represented in source code, this function
+// will panic if the given value is unknown or contains a nested unknown value.
+// Use val.IsWhollyKnown before calling to be sure.
+//
+// HCL native syntax does not directly represent lists, maps, and sets, and
+// instead relies on the automatic conversions to those collection types from
+// either list or tuple constructor syntax. Therefore converting collection
+// values to source code and re-reading them will lose type information, and
+// the reader must provide a suitable type at decode time to recover the
+// original value.
+func NewExpressionLiteral(val cty.Value) *Expression {
+	toks := TokensForValue(val)
+	expr := newExpression()
+	expr.children.AppendUnstructuredTokens(toks)
+	return expr
+}
+
+// NewExpressionAbsTraversal constructs an expression that represents the
+// given traversal, which must be absolute or this function will panic.
+func NewExpressionAbsTraversal(traversal hcl.Traversal) *Expression {
+	if traversal.IsRelative() {
+		panic("can't construct expression from relative traversal")
+	}
+
+	physT := newTraversal()
+	rootName := traversal.RootName()
+	steps := traversal[1:]
+
+	{
+		tn := newTraverseName()
+		tn.name = tn.children.Append(newIdentifier(&Token{
+			Type:  hclsyntax.TokenIdent,
+			Bytes: []byte(rootName),
+		}))
+		physT.steps.Add(physT.children.Append(tn))
+	}
+
+	for _, step := range steps {
+		switch ts := step.(type) {
+		case hcl.TraverseAttr:
+			tn := newTraverseName()
+			tn.children.AppendUnstructuredTokens(Tokens{
+				{
+					Type:  hclsyntax.TokenDot,
+					Bytes: []byte{'.'},
+				},
+			})
+			tn.name = tn.children.Append(newIdentifier(&Token{
+				Type:  hclsyntax.TokenIdent,
+				Bytes: []byte(ts.Name),
+			}))
+			physT.steps.Add(physT.children.Append(tn))
+		case hcl.TraverseIndex:
+			ti := newTraverseIndex()
+			ti.children.AppendUnstructuredTokens(Tokens{
+				{
+					Type:  hclsyntax.TokenOBrack,
+					Bytes: []byte{'['},
+				},
+			})
+			indexExpr := NewExpressionLiteral(ts.Key)
+			ti.key = ti.children.Append(indexExpr)
+			ti.children.AppendUnstructuredTokens(Tokens{
+				{
+					Type:  hclsyntax.TokenCBrack,
+					Bytes: []byte{']'},
+				},
+			})
+			physT.steps.Add(physT.children.Append(ti))
+		}
+	}
+
+	expr := newExpression()
+	expr.absTraversals.Add(expr.children.Append(physT))
+	return expr
+}
+
+// Variables returns the absolute traversals that exist within the receiving
+// expression.
+func (e *Expression) Variables() []*Traversal {
+	nodes := e.absTraversals.List()
+	ret := make([]*Traversal, len(nodes))
+	for i, node := range nodes {
+		ret[i] = node.content.(*Traversal)
+	}
+	return ret
+}
+
+// RenameVariablePrefix examines each of the absolute traversals in the
+// receiving expression to see if they have the given sequence of names as
+// a prefix prefix. If so, they are updated in place to have the given
+// replacement names instead of that prefix.
+//
+// This can be used to implement symbol renaming. The calling application can
+// visit all relevant expressions in its input and apply the same renaming
+// to implement a global symbol rename.
+//
+// The search and replacement traversals must be the same length, or this
+// method will panic. Only attribute access operations can be matched and
+// replaced. Index steps never match the prefix.
+func (e *Expression) RenameVariablePrefix(search, replacement []string) {
+	if len(search) != len(replacement) {
+		panic(fmt.Sprintf("search and replacement length mismatch (%d and %d)", len(search), len(replacement)))
+	}
+Traversals:
+	for node := range e.absTraversals {
+		traversal := node.content.(*Traversal)
+		if len(traversal.steps) < len(search) {
+			// If it's shorter then it can't have our prefix
+			continue
+		}
+
+		stepNodes := traversal.steps.List()
+		for i, name := range search {
+			step, isName := stepNodes[i].content.(*TraverseName)
+			if !isName {
+				continue Traversals // only name nodes can match
+			}
+			foundNameBytes := step.name.content.(*identifier).token.Bytes
+			if len(foundNameBytes) != len(name) {
+				continue Traversals
+			}
+			if string(foundNameBytes) != name {
+				continue Traversals
+			}
+		}
+
+		// If we get here then the prefix matched, so now we'll swap in
+		// the replacement strings.
+		for i, name := range replacement {
+			step := stepNodes[i].content.(*TraverseName)
+			token := step.name.content.(*identifier).token
+			token.Bytes = []byte(name)
+		}
+	}
+}
+
+// Traversal represents a sequence of variable, attribute, and/or index
+// operations.
+type Traversal struct {
+	inTree
+
+	steps nodeSet
+}
+
+func newTraversal() *Traversal {
+	return &Traversal{
+		inTree: newInTree(),
+		steps:  newNodeSet(),
+	}
+}
+
+type TraverseName struct {
+	inTree
+
+	name *node
+}
+
+func newTraverseName() *TraverseName {
+	return &TraverseName{
+		inTree: newInTree(),
+	}
+}
+
+type TraverseIndex struct {
+	inTree
+
+	key *node
+}
+
+func newTraverseIndex() *TraverseIndex {
+	return &TraverseIndex{
+		inTree: newInTree(),
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/doc.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/doc.go
new file mode 100644
index 00000000..56d5b775
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/doc.go
@@ -0,0 +1,11 @@
+// Package hclwrite deals with the problem of generating HCL configuration
+// and of making specific surgical changes to existing HCL configurations.
+//
+// It operates at a different level of abstraction than the main HCL parser
+// and AST, since details such as the placement of comments and newlines
+// are preserved when unchanged.
+//
+// The hclwrite API follows a similar principle to XML/HTML DOM, allowing nodes
+// to be read out, created and inserted, etc. Nodes represent syntax constructs
+// rather than semantic concepts.
+package hclwrite
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/format.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/format.go
new file mode 100644
index 00000000..b94bee38
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/format.go
@@ -0,0 +1,463 @@
+package hclwrite
+
+import (
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+)
+
+var inKeyword = hclsyntax.Keyword([]byte{'i', 'n'})
+
+// placeholder token used when we don't have a token but we don't want
+// to pass a real "nil" and complicate things with nil pointer checks
+var nilToken = &Token{
+	Type:         hclsyntax.TokenNil,
+	Bytes:        []byte{},
+	SpacesBefore: 0,
+}
+
+// format rewrites tokens within the given sequence, in-place, to adjust the
+// whitespace around their content to achieve canonical formatting.
+func format(tokens Tokens) {
+	// Formatting is a multi-pass process. More details on the passes below,
+	// but this is the overview:
+	// - adjust the leading space on each line to create appropriate
+	//   indentation
+	// - adjust spaces between tokens in a single cell using a set of rules
+	// - adjust the leading space in the "assign" and "comment" cells on each
+	//   line to vertically align with neighboring lines.
+	// All of these steps operate in-place on the given tokens, so a caller
+	// may collect a flat sequence of all of the tokens underlying an AST
+	// and pass it here and we will then indirectly modify the AST itself.
+	// Formatting must change only whitespace. Specifically, that means
+	// changing the SpacesBefore attribute on a token while leaving the
+	// other token attributes unchanged.
+
+	lines := linesForFormat(tokens)
+	formatIndent(lines)
+	formatSpaces(lines)
+	formatCells(lines)
+}
+
+func formatIndent(lines []formatLine) {
+	// Our methodology for indents is to take the input one line at a time
+	// and count the bracketing delimiters on each line. If a line has a net
+	// increase in open brackets, we increase the indent level by one and
+	// remember how many new openers we had. If the line has a net _decrease_,
+	// we'll compare it to the most recent number of openers and decrease the
+	// dedent level by one each time we pass an indent level remembered
+	// earlier.
+	// The "indent stack" used here allows for us to recognize degenerate
+	// input where brackets are not symmetrical within lines and avoid
+	// pushing things too far left or right, creating confusion.
+
+	// We'll start our indent stack at a reasonable capacity to minimize the
+	// chance of us needing to grow it; 10 here means 10 levels of indent,
+	// which should be more than enough for reasonable HCL uses.
+	indents := make([]int, 0, 10)
+
+	for i := range lines {
+		line := &lines[i]
+		if len(line.lead) == 0 {
+			continue
+		}
+
+		if line.lead[0].Type == hclsyntax.TokenNewline {
+			// Never place spaces before a newline
+			line.lead[0].SpacesBefore = 0
+			continue
+		}
+
+		netBrackets := 0
+		for _, token := range line.lead {
+			netBrackets += tokenBracketChange(token)
+			if token.Type == hclsyntax.TokenOHeredoc {
+				break
+			}
+		}
+
+		for _, token := range line.assign {
+			netBrackets += tokenBracketChange(token)
+		}
+
+		switch {
+		case netBrackets > 0:
+			line.lead[0].SpacesBefore = 2 * len(indents)
+			indents = append(indents, netBrackets)
+		case netBrackets < 0:
+			closed := -netBrackets
+			for closed > 0 && len(indents) > 0 {
+				switch {
+
+				case closed > indents[len(indents)-1]:
+					closed -= indents[len(indents)-1]
+					indents = indents[:len(indents)-1]
+
+				case closed < indents[len(indents)-1]:
+					indents[len(indents)-1] -= closed
+					closed = 0
+
+				default:
+					indents = indents[:len(indents)-1]
+					closed = 0
+				}
+			}
+			line.lead[0].SpacesBefore = 2 * len(indents)
+		default:
+			line.lead[0].SpacesBefore = 2 * len(indents)
+		}
+	}
+}
+
+func formatSpaces(lines []formatLine) {
+	for _, line := range lines {
+		for i, token := range line.lead {
+			var before, after *Token
+			if i > 0 {
+				before = line.lead[i-1]
+			} else {
+				before = nilToken
+			}
+			if i < (len(line.lead) - 1) {
+				after = line.lead[i+1]
+			} else {
+				after = nilToken
+			}
+			if spaceAfterToken(token, before, after) {
+				after.SpacesBefore = 1
+			} else {
+				after.SpacesBefore = 0
+			}
+		}
+		for i, token := range line.assign {
+			if i == 0 {
+				// first token in "assign" always has one space before to
+				// separate the equals sign from what it's assigning.
+				token.SpacesBefore = 1
+			}
+
+			var before, after *Token
+			if i > 0 {
+				before = line.assign[i-1]
+			} else {
+				before = nilToken
+			}
+			if i < (len(line.assign) - 1) {
+				after = line.assign[i+1]
+			} else {
+				after = nilToken
+			}
+			if spaceAfterToken(token, before, after) {
+				after.SpacesBefore = 1
+			} else {
+				after.SpacesBefore = 0
+			}
+		}
+
+	}
+}
+
+func formatCells(lines []formatLine) {
+
+	chainStart := -1
+	maxColumns := 0
+
+	// We'll deal with the "assign" cell first, since moving that will
+	// also impact the "comment" cell.
+	closeAssignChain := func(i int) {
+		for _, chainLine := range lines[chainStart:i] {
+			columns := chainLine.lead.Columns()
+			spaces := (maxColumns - columns) + 1
+			chainLine.assign[0].SpacesBefore = spaces
+		}
+		chainStart = -1
+		maxColumns = 0
+	}
+	for i, line := range lines {
+		if line.assign == nil {
+			if chainStart != -1 {
+				closeAssignChain(i)
+			}
+		} else {
+			if chainStart == -1 {
+				chainStart = i
+			}
+			columns := line.lead.Columns()
+			if columns > maxColumns {
+				maxColumns = columns
+			}
+		}
+	}
+	if chainStart != -1 {
+		closeAssignChain(len(lines))
+	}
+
+	// Now we'll deal with the comments
+	closeCommentChain := func(i int) {
+		for _, chainLine := range lines[chainStart:i] {
+			columns := chainLine.lead.Columns() + chainLine.assign.Columns()
+			spaces := (maxColumns - columns) + 1
+			chainLine.comment[0].SpacesBefore = spaces
+		}
+		chainStart = -1
+		maxColumns = 0
+	}
+	for i, line := range lines {
+		if line.comment == nil {
+			if chainStart != -1 {
+				closeCommentChain(i)
+			}
+		} else {
+			if chainStart == -1 {
+				chainStart = i
+			}
+			columns := line.lead.Columns() + line.assign.Columns()
+			if columns > maxColumns {
+				maxColumns = columns
+			}
+		}
+	}
+	if chainStart != -1 {
+		closeCommentChain(len(lines))
+	}
+
+}
+
+// spaceAfterToken decides whether a particular subject token should have a
+// space after it when surrounded by the given before and after tokens.
+// "before" can be TokenNil, if the subject token is at the start of a sequence.
+func spaceAfterToken(subject, before, after *Token) bool {
+	switch {
+
+	case after.Type == hclsyntax.TokenNewline || after.Type == hclsyntax.TokenNil:
+		// Never add spaces before a newline
+		return false
+
+	case subject.Type == hclsyntax.TokenIdent && after.Type == hclsyntax.TokenOParen:
+		// Don't split a function name from open paren in a call
+		return false
+
+	case subject.Type == hclsyntax.TokenDot || after.Type == hclsyntax.TokenDot:
+		// Don't use spaces around attribute access dots
+		return false
+
+	case after.Type == hclsyntax.TokenComma || after.Type == hclsyntax.TokenEllipsis:
+		// No space right before a comma or ... in an argument list
+		return false
+
+	case subject.Type == hclsyntax.TokenComma:
+		// Always a space after a comma
+		return true
+
+	case subject.Type == hclsyntax.TokenQuotedLit || subject.Type == hclsyntax.TokenStringLit || subject.Type == hclsyntax.TokenOQuote || subject.Type == hclsyntax.TokenOHeredoc || after.Type == hclsyntax.TokenQuotedLit || after.Type == hclsyntax.TokenStringLit || after.Type == hclsyntax.TokenCQuote || after.Type == hclsyntax.TokenCHeredoc:
+		// No extra spaces within templates
+		return false
+
+	case inKeyword.TokenMatches(subject.asHCLSyntax()) && before.Type == hclsyntax.TokenIdent:
+		// This is a special case for inside for expressions where a user
+		// might want to use a literal tuple constructor:
+		// [for x in [foo]: x]
+		// ... in that case, we would normally produce in[foo] thinking that
+		// in is a reference, but we'll recognize it as a keyword here instead
+		// to make the result less confusing.
+		return true
+
+	case after.Type == hclsyntax.TokenOBrack && (subject.Type == hclsyntax.TokenIdent || subject.Type == hclsyntax.TokenNumberLit || tokenBracketChange(subject) < 0):
+		return false
+
+	case subject.Type == hclsyntax.TokenMinus:
+		// Since a minus can either be subtraction or negation, and the latter
+		// should _not_ have a space after it, we need to use some heuristics
+		// to decide which case this is.
+		// We guess that we have a negation if the token before doesn't look
+		// like it could be the end of an expression.
+
+		switch before.Type {
+
+		case hclsyntax.TokenNil:
+			// Minus at the start of input must be a negation
+			return false
+
+		case hclsyntax.TokenOParen, hclsyntax.TokenOBrace, hclsyntax.TokenOBrack, hclsyntax.TokenEqual, hclsyntax.TokenColon, hclsyntax.TokenComma, hclsyntax.TokenQuestion:
+			// Minus immediately after an opening bracket or separator must be a negation.
+			return false
+
+		case hclsyntax.TokenPlus, hclsyntax.TokenStar, hclsyntax.TokenSlash, hclsyntax.TokenPercent, hclsyntax.TokenMinus:
+			// Minus immediately after another arithmetic operator must be negation.
+			return false
+
+		case hclsyntax.TokenEqualOp, hclsyntax.TokenNotEqual, hclsyntax.TokenGreaterThan, hclsyntax.TokenGreaterThanEq, hclsyntax.TokenLessThan, hclsyntax.TokenLessThanEq:
+			// Minus immediately after another comparison operator must be negation.
+			return false
+
+		case hclsyntax.TokenAnd, hclsyntax.TokenOr, hclsyntax.TokenBang:
+			// Minus immediately after logical operator doesn't make sense but probably intended as negation.
+			return false
+
+		default:
+			return true
+		}
+
+	case subject.Type == hclsyntax.TokenOBrace || after.Type == hclsyntax.TokenCBrace:
+		// Unlike other bracket types, braces have spaces on both sides of them,
+		// both in single-line nested blocks foo { bar = baz } and in object
+		// constructor expressions foo = { bar = baz }.
+		if subject.Type == hclsyntax.TokenOBrace && after.Type == hclsyntax.TokenCBrace {
+			// An open brace followed by a close brace is an exception, however.
+			// e.g. foo {} rather than foo { }
+			return false
+		}
+		return true
+
+	// In the unlikely event that an interpolation expression is just
+	// a single object constructor, we'll put a space between the ${ and
+	// the following { to make this more obvious, and then the same
+	// thing for the two braces at the end.
+	case (subject.Type == hclsyntax.TokenTemplateInterp || subject.Type == hclsyntax.TokenTemplateControl) && after.Type == hclsyntax.TokenOBrace:
+		return true
+	case subject.Type == hclsyntax.TokenCBrace && after.Type == hclsyntax.TokenTemplateSeqEnd:
+		return true
+
+	// Don't add spaces between interpolated items
+	case subject.Type == hclsyntax.TokenTemplateSeqEnd && (after.Type == hclsyntax.TokenTemplateInterp || after.Type == hclsyntax.TokenTemplateControl):
+		return false
+
+	case tokenBracketChange(subject) > 0:
+		// No spaces after open brackets
+		return false
+
+	case tokenBracketChange(after) < 0:
+		// No spaces before close brackets
+		return false
+
+	default:
+		// Most tokens are space-separated
+		return true
+
+	}
+}
+
+func linesForFormat(tokens Tokens) []formatLine {
+	if len(tokens) == 0 {
+		return make([]formatLine, 0)
+	}
+
+	// first we'll count our lines, so we can allocate the array for them in
+	// a single block. (We want to minimize memory pressure in this codepath,
+	// so it can be run somewhat-frequently by editor integrations.)
+	lineCount := 1 // if there are zero newlines then there is one line
+	for _, tok := range tokens {
+		if tokenIsNewline(tok) {
+			lineCount++
+		}
+	}
+
+	// To start, we'll just put everything in the "lead" cell on each line,
+	// and then do another pass over the lines afterwards to adjust.
+	lines := make([]formatLine, lineCount)
+	li := 0
+	lineStart := 0
+	for i, tok := range tokens {
+		if tok.Type == hclsyntax.TokenEOF {
+			// The EOF token doesn't belong to any line, and terminates the
+			// token sequence.
+			lines[li].lead = tokens[lineStart:i]
+			break
+		}
+
+		if tokenIsNewline(tok) {
+			lines[li].lead = tokens[lineStart : i+1]
+			lineStart = i + 1
+			li++
+		}
+	}
+
+	// If a set of tokens doesn't end in TokenEOF (e.g. because it's a
+	// fragment of tokens from the middle of a file) then we might fall
+	// out here with a line still pending.
+	if lineStart < len(tokens) {
+		lines[li].lead = tokens[lineStart:]
+		if lines[li].lead[len(lines[li].lead)-1].Type == hclsyntax.TokenEOF {
+			lines[li].lead = lines[li].lead[:len(lines[li].lead)-1]
+		}
+	}
+
+	// Now we'll pick off any trailing comments and attribute assignments
+	// to shuffle off into the "comment" and "assign" cells.
+	for i := range lines {
+		line := &lines[i]
+
+		if len(line.lead) == 0 {
+			// if the line is empty then there's nothing for us to do
+			// (this should happen only for the final line, because all other
+			// lines would have a newline token of some kind)
+			continue
+		}
+
+		if len(line.lead) > 1 && line.lead[len(line.lead)-1].Type == hclsyntax.TokenComment {
+			line.comment = line.lead[len(line.lead)-1:]
+			line.lead = line.lead[:len(line.lead)-1]
+		}
+
+		for i, tok := range line.lead {
+			if i > 0 && tok.Type == hclsyntax.TokenEqual {
+				// We only move the tokens into "assign" if the RHS seems to
+				// be a whole expression, which we determine by counting
+				// brackets. If there's a net positive number of brackets
+				// then that suggests we're introducing a multi-line expression.
+				netBrackets := 0
+				for _, token := range line.lead[i:] {
+					netBrackets += tokenBracketChange(token)
+				}
+
+				if netBrackets == 0 {
+					line.assign = line.lead[i:]
+					line.lead = line.lead[:i]
+				}
+				break
+			}
+		}
+	}
+
+	return lines
+}
+
+func tokenIsNewline(tok *Token) bool {
+	if tok.Type == hclsyntax.TokenNewline {
+		return true
+	} else if tok.Type == hclsyntax.TokenComment {
+		// Single line tokens (# and //) consume their terminating newline,
+		// so we need to treat them as newline tokens as well.
+		if len(tok.Bytes) > 0 && tok.Bytes[len(tok.Bytes)-1] == '\n' {
+			return true
+		}
+	}
+	return false
+}
+
+func tokenBracketChange(tok *Token) int {
+	switch tok.Type {
+	case hclsyntax.TokenOBrace, hclsyntax.TokenOBrack, hclsyntax.TokenOParen, hclsyntax.TokenTemplateControl, hclsyntax.TokenTemplateInterp:
+		return 1
+	case hclsyntax.TokenCBrace, hclsyntax.TokenCBrack, hclsyntax.TokenCParen, hclsyntax.TokenTemplateSeqEnd:
+		return -1
+	default:
+		return 0
+	}
+}
+
+// formatLine represents a single line of source code for formatting purposes,
+// splitting its tokens into up to three "cells":
+//
+// lead: always present, representing everything up to one of the others
+// assign: if line contains an attribute assignment, represents the tokens
+//    starting at (and including) the equals symbol
+// comment: if line contains any non-comment tokens and ends with a
+//    single-line comment token, represents the comment.
+//
+// When formatting, the leading spaces of the first tokens in each of these
+// cells is adjusted to align vertically their occurences on consecutive
+// rows.
+type formatLine struct {
+	lead    Tokens
+	assign  Tokens
+	comment Tokens
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/generate.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/generate.go
new file mode 100644
index 00000000..4d439acd
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/generate.go
@@ -0,0 +1,252 @@
+package hclwrite
+
+import (
+	"fmt"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// TokensForValue returns a sequence of tokens that represents the given
+// constant value.
+//
+// This function only supports types that are used by HCL. In particular, it
+// does not support capsule types and will panic if given one.
+//
+// It is not possible to express an unknown value in source code, so this
+// function will panic if the given value is unknown or contains any unknown
+// values. A caller can call the value's IsWhollyKnown method to verify that
+// no unknown values are present before calling TokensForValue.
+func TokensForValue(val cty.Value) Tokens {
+	toks := appendTokensForValue(val, nil)
+	format(toks) // fiddle with the SpacesBefore field to get canonical spacing
+	return toks
+}
+
+// TokensForTraversal returns a sequence of tokens that represents the given
+// traversal.
+//
+// If the traversal is absolute then the result is a self-contained, valid
+// reference expression. If the traversal is relative then the returned tokens
+// could be appended to some other expression tokens to traverse into the
+// represented expression.
+func TokensForTraversal(traversal hcl.Traversal) Tokens {
+	toks := appendTokensForTraversal(traversal, nil)
+	format(toks) // fiddle with the SpacesBefore field to get canonical spacing
+	return toks
+}
+
+func appendTokensForValue(val cty.Value, toks Tokens) Tokens {
+	switch {
+
+	case !val.IsKnown():
+		panic("cannot produce tokens for unknown value")
+
+	case val.IsNull():
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenIdent,
+			Bytes: []byte(`null`),
+		})
+
+	case val.Type() == cty.Bool:
+		var src []byte
+		if val.True() {
+			src = []byte(`true`)
+		} else {
+			src = []byte(`false`)
+		}
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenIdent,
+			Bytes: src,
+		})
+
+	case val.Type() == cty.Number:
+		bf := val.AsBigFloat()
+		srcStr := bf.Text('f', -1)
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenNumberLit,
+			Bytes: []byte(srcStr),
+		})
+
+	case val.Type() == cty.String:
+		// TODO: If it's a multi-line string ending in a newline, format
+		// it as a HEREDOC instead.
+		src := escapeQuotedStringLit(val.AsString())
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenOQuote,
+			Bytes: []byte{'"'},
+		})
+		if len(src) > 0 {
+			toks = append(toks, &Token{
+				Type:  hclsyntax.TokenQuotedLit,
+				Bytes: src,
+			})
+		}
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenCQuote,
+			Bytes: []byte{'"'},
+		})
+
+	case val.Type().IsListType() || val.Type().IsSetType() || val.Type().IsTupleType():
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenOBrack,
+			Bytes: []byte{'['},
+		})
+
+		i := 0
+		for it := val.ElementIterator(); it.Next(); {
+			if i > 0 {
+				toks = append(toks, &Token{
+					Type:  hclsyntax.TokenComma,
+					Bytes: []byte{','},
+				})
+			}
+			_, eVal := it.Element()
+			toks = appendTokensForValue(eVal, toks)
+			i++
+		}
+
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenCBrack,
+			Bytes: []byte{']'},
+		})
+
+	case val.Type().IsMapType() || val.Type().IsObjectType():
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenOBrace,
+			Bytes: []byte{'{'},
+		})
+
+		i := 0
+		for it := val.ElementIterator(); it.Next(); {
+			if i > 0 {
+				toks = append(toks, &Token{
+					Type:  hclsyntax.TokenComma,
+					Bytes: []byte{','},
+				})
+			}
+			eKey, eVal := it.Element()
+			if hclsyntax.ValidIdentifier(eKey.AsString()) {
+				toks = append(toks, &Token{
+					Type:  hclsyntax.TokenIdent,
+					Bytes: []byte(eKey.AsString()),
+				})
+			} else {
+				toks = appendTokensForValue(eKey, toks)
+			}
+			toks = append(toks, &Token{
+				Type:  hclsyntax.TokenEqual,
+				Bytes: []byte{'='},
+			})
+			toks = appendTokensForValue(eVal, toks)
+			i++
+		}
+
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenCBrace,
+			Bytes: []byte{'}'},
+		})
+
+	default:
+		panic(fmt.Sprintf("cannot produce tokens for %#v", val))
+	}
+
+	return toks
+}
+
+func appendTokensForTraversal(traversal hcl.Traversal, toks Tokens) Tokens {
+	for _, step := range traversal {
+		toks = appendTokensForTraversalStep(step, toks)
+	}
+	return toks
+}
+
+func appendTokensForTraversalStep(step hcl.Traverser, toks Tokens) Tokens {
+	switch ts := step.(type) {
+	case hcl.TraverseRoot:
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenIdent,
+			Bytes: []byte(ts.Name),
+		})
+	case hcl.TraverseAttr:
+		toks = append(
+			toks,
+			&Token{
+				Type:  hclsyntax.TokenDot,
+				Bytes: []byte{'.'},
+			},
+			&Token{
+				Type:  hclsyntax.TokenIdent,
+				Bytes: []byte(ts.Name),
+			},
+		)
+	case hcl.TraverseIndex:
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenOBrack,
+			Bytes: []byte{'['},
+		})
+		toks = appendTokensForValue(ts.Key, toks)
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenCBrack,
+			Bytes: []byte{']'},
+		})
+	default:
+		panic(fmt.Sprintf("unsupported traversal step type %T", step))
+	}
+
+	return toks
+}
+
+func escapeQuotedStringLit(s string) []byte {
+	if len(s) == 0 {
+		return nil
+	}
+	buf := make([]byte, 0, len(s))
+	for i, r := range s {
+		switch r {
+		case '\n':
+			buf = append(buf, '\\', 'n')
+		case '\r':
+			buf = append(buf, '\\', 'r')
+		case '\t':
+			buf = append(buf, '\\', 't')
+		case '"':
+			buf = append(buf, '\\', '"')
+		case '\\':
+			buf = append(buf, '\\', '\\')
+		case '$', '%':
+			buf = appendRune(buf, r)
+			remain := s[i+1:]
+			if len(remain) > 0 && remain[0] == '{' {
+				// Double up our template introducer symbol to escape it.
+				buf = appendRune(buf, r)
+			}
+		default:
+			if !unicode.IsPrint(r) {
+				var fmted string
+				if r < 65536 {
+					fmted = fmt.Sprintf("\\u%04x", r)
+				} else {
+					fmted = fmt.Sprintf("\\U%08x", r)
+				}
+				buf = append(buf, fmted...)
+			} else {
+				buf = appendRune(buf, r)
+			}
+		}
+	}
+	return buf
+}
+
+func appendRune(b []byte, r rune) []byte {
+	l := utf8.RuneLen(r)
+	for i := 0; i < l; i++ {
+		b = append(b, 0) // make room at the end of our buffer
+	}
+	ch := b[len(b)-l:]
+	utf8.EncodeRune(ch, r)
+	return b
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/native_node_sorter.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/native_node_sorter.go
new file mode 100644
index 00000000..cedf6862
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/native_node_sorter.go
@@ -0,0 +1,23 @@
+package hclwrite
+
+import (
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+)
+
+type nativeNodeSorter struct {
+	Nodes []hclsyntax.Node
+}
+
+func (s nativeNodeSorter) Len() int {
+	return len(s.Nodes)
+}
+
+func (s nativeNodeSorter) Less(i, j int) bool {
+	rangeI := s.Nodes[i].Range()
+	rangeJ := s.Nodes[j].Range()
+	return rangeI.Start.Byte < rangeJ.Start.Byte
+}
+
+func (s nativeNodeSorter) Swap(i, j int) {
+	s.Nodes[i], s.Nodes[j] = s.Nodes[j], s.Nodes[i]
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/node.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/node.go
new file mode 100644
index 00000000..45669f7f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/node.go
@@ -0,0 +1,260 @@
+package hclwrite
+
+import (
+	"fmt"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+// node represents a node in the AST.
+type node struct {
+	content nodeContent
+
+	list          *nodes
+	before, after *node
+}
+
+func newNode(c nodeContent) *node {
+	return &node{
+		content: c,
+	}
+}
+
+func (n *node) Equal(other *node) bool {
+	return cmp.Equal(n.content, other.content)
+}
+
+func (n *node) BuildTokens(to Tokens) Tokens {
+	return n.content.BuildTokens(to)
+}
+
+// Detach removes the receiver from the list it currently belongs to. If the
+// node is not currently in a list, this is a no-op.
+func (n *node) Detach() {
+	if n.list == nil {
+		return
+	}
+	if n.before != nil {
+		n.before.after = n.after
+	}
+	if n.after != nil {
+		n.after.before = n.before
+	}
+	if n.list.first == n {
+		n.list.first = n.after
+	}
+	if n.list.last == n {
+		n.list.last = n.before
+	}
+	n.list = nil
+	n.before = nil
+	n.after = nil
+}
+
+// ReplaceWith removes the receiver from the list it currently belongs to and
+// inserts a new node with the given content in its place. If the node is not
+// currently in a list, this function will panic.
+//
+// The return value is the newly-constructed node, containing the given content.
+// After this function returns, the reciever is no longer attached to a list.
+func (n *node) ReplaceWith(c nodeContent) *node {
+	if n.list == nil {
+		panic("can't replace node that is not in a list")
+	}
+
+	before := n.before
+	after := n.after
+	list := n.list
+	n.before, n.after, n.list = nil, nil, nil
+
+	nn := newNode(c)
+	nn.before = before
+	nn.after = after
+	nn.list = list
+	if before != nil {
+		before.after = nn
+	}
+	if after != nil {
+		after.before = nn
+	}
+	return nn
+}
+
+func (n *node) assertUnattached() {
+	if n.list != nil {
+		panic(fmt.Sprintf("attempt to attach already-attached node %#v", n))
+	}
+}
+
+// nodeContent is the interface type implemented by all AST content types.
+type nodeContent interface {
+	walkChildNodes(w internalWalkFunc)
+	BuildTokens(to Tokens) Tokens
+}
+
+// nodes is a list of nodes.
+type nodes struct {
+	first, last *node
+}
+
+func (ns *nodes) BuildTokens(to Tokens) Tokens {
+	for n := ns.first; n != nil; n = n.after {
+		to = n.BuildTokens(to)
+	}
+	return to
+}
+
+func (ns *nodes) Clear() {
+	ns.first = nil
+	ns.last = nil
+}
+
+func (ns *nodes) Append(c nodeContent) *node {
+	n := &node{
+		content: c,
+	}
+	ns.AppendNode(n)
+	n.list = ns
+	return n
+}
+
+func (ns *nodes) AppendNode(n *node) {
+	if ns.last != nil {
+		n.before = ns.last
+		ns.last.after = n
+	}
+	n.list = ns
+	ns.last = n
+	if ns.first == nil {
+		ns.first = n
+	}
+}
+
+func (ns *nodes) AppendUnstructuredTokens(tokens Tokens) *node {
+	if len(tokens) == 0 {
+		return nil
+	}
+	n := newNode(tokens)
+	ns.AppendNode(n)
+	n.list = ns
+	return n
+}
+
+// FindNodeWithContent searches the nodes for a node whose content equals
+// the given content. If it finds one then it returns it. Otherwise it returns
+// nil.
+func (ns *nodes) FindNodeWithContent(content nodeContent) *node {
+	for n := ns.first; n != nil; n = n.after {
+		if n.content == content {
+			return n
+		}
+	}
+	return nil
+}
+
+// nodeSet is an unordered set of nodes. It is used to describe a set of nodes
+// that all belong to the same list that have some role or characteristic
+// in common.
+type nodeSet map[*node]struct{}
+
+func newNodeSet() nodeSet {
+	return make(nodeSet)
+}
+
+func (ns nodeSet) Has(n *node) bool {
+	if ns == nil {
+		return false
+	}
+	_, exists := ns[n]
+	return exists
+}
+
+func (ns nodeSet) Add(n *node) {
+	ns[n] = struct{}{}
+}
+
+func (ns nodeSet) Remove(n *node) {
+	delete(ns, n)
+}
+
+func (ns nodeSet) List() []*node {
+	if len(ns) == 0 {
+		return nil
+	}
+
+	ret := make([]*node, 0, len(ns))
+
+	// Determine which list we are working with. We assume here that all of
+	// the nodes belong to the same list, since that is part of the contract
+	// for nodeSet.
+	var list *nodes
+	for n := range ns {
+		list = n.list
+		break
+	}
+
+	// We recover the order by iterating over the whole list. This is not
+	// the most efficient way to do it, but our node lists should always be
+	// small so not worth making things more complex.
+	for n := list.first; n != nil; n = n.after {
+		if ns.Has(n) {
+			ret = append(ret, n)
+		}
+	}
+	return ret
+}
+
+// FindNodeWithContent searches the nodes for a node whose content equals
+// the given content. If it finds one then it returns it. Otherwise it returns
+// nil.
+func (ns nodeSet) FindNodeWithContent(content nodeContent) *node {
+	for n := range ns {
+		if n.content == content {
+			return n
+		}
+	}
+	return nil
+}
+
+type internalWalkFunc func(*node)
+
+// inTree can be embedded into a content struct that has child nodes to get
+// a standard implementation of the NodeContent interface and a record of
+// a potential parent node.
+type inTree struct {
+	parent   *node
+	children *nodes
+}
+
+func newInTree() inTree {
+	return inTree{
+		children: &nodes{},
+	}
+}
+
+func (it *inTree) assertUnattached() {
+	if it.parent != nil {
+		panic(fmt.Sprintf("node is already attached to %T", it.parent.content))
+	}
+}
+
+func (it *inTree) walkChildNodes(w internalWalkFunc) {
+	for n := it.children.first; n != nil; n = n.after {
+		w(n)
+	}
+}
+
+func (it *inTree) BuildTokens(to Tokens) Tokens {
+	for n := it.children.first; n != nil; n = n.after {
+		to = n.BuildTokens(to)
+	}
+	return to
+}
+
+// leafNode can be embedded into a content struct to give it a do-nothing
+// implementation of walkChildNodes
+type leafNode struct {
+}
+
+func (n *leafNode) walkChildNodes(w internalWalkFunc) {
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/parser.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/parser.go
new file mode 100644
index 00000000..d6cf532e
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/parser.go
@@ -0,0 +1,599 @@
+package hclwrite
+
+import (
+	"fmt"
+	"sort"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// Our "parser" here is actually not doing any parsing of its own. Instead,
+// it leans on the native parser in hclsyntax, and then uses the source ranges
+// from the AST to partition the raw token sequence to match the raw tokens
+// up to AST nodes.
+//
+// This strategy feels somewhat counter-intuitive, since most of the work the
+// parser does is thrown away here, but this strategy is chosen because the
+// normal parsing work done by hclsyntax is considered to be the "main case",
+// while modifying and re-printing source is more of an edge case, used only
+// in ancillary tools, and so it's good to keep all the main parsing logic
+// with the main case but keep all of the extra complexity of token wrangling
+// out of the main parser, which is already rather complex just serving the
+// use-cases it already serves.
+//
+// If the parsing step produces any errors, the returned File is nil because
+// we can't reliably extract tokens from the partial AST produced by an
+// erroneous parse.
+func parse(src []byte, filename string, start hcl.Pos) (*File, hcl.Diagnostics) {
+	file, diags := hclsyntax.ParseConfig(src, filename, start)
+	if diags.HasErrors() {
+		return nil, diags
+	}
+
+	// To do our work here, we use the "native" tokens (those from hclsyntax)
+	// to match against source ranges in the AST, but ultimately produce
+	// slices from our sequence of "writer" tokens, which contain only
+	// *relative* position information that is more appropriate for
+	// transformation/writing use-cases.
+	nativeTokens, diags := hclsyntax.LexConfig(src, filename, start)
+	if diags.HasErrors() {
+		// should never happen, since we would've caught these diags in
+		// the first call above.
+		return nil, diags
+	}
+	writerTokens := writerTokens(nativeTokens)
+
+	from := inputTokens{
+		nativeTokens: nativeTokens,
+		writerTokens: writerTokens,
+	}
+
+	before, root, after := parseBody(file.Body.(*hclsyntax.Body), from)
+	ret := &File{
+		inTree: newInTree(),
+
+		srcBytes: src,
+		body:     root,
+	}
+
+	nodes := ret.inTree.children
+	nodes.Append(before.Tokens())
+	nodes.AppendNode(root)
+	nodes.Append(after.Tokens())
+
+	return ret, diags
+}
+
+type inputTokens struct {
+	nativeTokens hclsyntax.Tokens
+	writerTokens Tokens
+}
+
+func (it inputTokens) Partition(rng hcl.Range) (before, within, after inputTokens) {
+	start, end := partitionTokens(it.nativeTokens, rng)
+	before = it.Slice(0, start)
+	within = it.Slice(start, end)
+	after = it.Slice(end, len(it.nativeTokens))
+	return
+}
+
+func (it inputTokens) PartitionType(ty hclsyntax.TokenType) (before, within, after inputTokens) {
+	for i, t := range it.writerTokens {
+		if t.Type == ty {
+			return it.Slice(0, i), it.Slice(i, i+1), it.Slice(i+1, len(it.nativeTokens))
+		}
+	}
+	panic(fmt.Sprintf("didn't find any token of type %s", ty))
+}
+
+func (it inputTokens) PartitionTypeSingle(ty hclsyntax.TokenType) (before inputTokens, found *Token, after inputTokens) {
+	before, within, after := it.PartitionType(ty)
+	if within.Len() != 1 {
+		panic("PartitionType found more than one token")
+	}
+	return before, within.Tokens()[0], after
+}
+
+// PartitionIncludeComments is like Partition except the returned "within"
+// range includes any lead and line comments associated with the range.
+func (it inputTokens) PartitionIncludingComments(rng hcl.Range) (before, within, after inputTokens) {
+	start, end := partitionTokens(it.nativeTokens, rng)
+	start = partitionLeadCommentTokens(it.nativeTokens[:start])
+	_, afterNewline := partitionLineEndTokens(it.nativeTokens[end:])
+	end += afterNewline
+
+	before = it.Slice(0, start)
+	within = it.Slice(start, end)
+	after = it.Slice(end, len(it.nativeTokens))
+	return
+
+}
+
+// PartitionBlockItem is similar to PartitionIncludeComments but it returns
+// the comments as separate token sequences so that they can be captured into
+// AST attributes. It makes assumptions that apply only to block items, so
+// should not be used for other constructs.
+func (it inputTokens) PartitionBlockItem(rng hcl.Range) (before, leadComments, within, lineComments, newline, after inputTokens) {
+	before, within, after = it.Partition(rng)
+	before, leadComments = before.PartitionLeadComments()
+	lineComments, newline, after = after.PartitionLineEndTokens()
+	return
+}
+
+func (it inputTokens) PartitionLeadComments() (before, within inputTokens) {
+	start := partitionLeadCommentTokens(it.nativeTokens)
+	before = it.Slice(0, start)
+	within = it.Slice(start, len(it.nativeTokens))
+	return
+}
+
+func (it inputTokens) PartitionLineEndTokens() (comments, newline, after inputTokens) {
+	afterComments, afterNewline := partitionLineEndTokens(it.nativeTokens)
+	comments = it.Slice(0, afterComments)
+	newline = it.Slice(afterComments, afterNewline)
+	after = it.Slice(afterNewline, len(it.nativeTokens))
+	return
+}
+
+func (it inputTokens) Slice(start, end int) inputTokens {
+	// When we slice, we create a new slice with no additional capacity because
+	// we expect that these slices will be mutated in order to insert
+	// new code into the AST, and we want to ensure that a new underlying
+	// array gets allocated in that case, rather than writing into some
+	// following slice and corrupting it.
+	return inputTokens{
+		nativeTokens: it.nativeTokens[start:end:end],
+		writerTokens: it.writerTokens[start:end:end],
+	}
+}
+
+func (it inputTokens) Len() int {
+	return len(it.nativeTokens)
+}
+
+func (it inputTokens) Tokens() Tokens {
+	return it.writerTokens
+}
+
+func (it inputTokens) Types() []hclsyntax.TokenType {
+	ret := make([]hclsyntax.TokenType, len(it.nativeTokens))
+	for i, tok := range it.nativeTokens {
+		ret[i] = tok.Type
+	}
+	return ret
+}
+
+// parseBody locates the given body within the given input tokens and returns
+// the resulting *Body object as well as the tokens that appeared before and
+// after it.
+func parseBody(nativeBody *hclsyntax.Body, from inputTokens) (inputTokens, *node, inputTokens) {
+	before, within, after := from.PartitionIncludingComments(nativeBody.SrcRange)
+
+	// The main AST doesn't retain the original source ordering of the
+	// body items, so we need to reconstruct that ordering by inspecting
+	// their source ranges.
+	nativeItems := make([]hclsyntax.Node, 0, len(nativeBody.Attributes)+len(nativeBody.Blocks))
+	for _, nativeAttr := range nativeBody.Attributes {
+		nativeItems = append(nativeItems, nativeAttr)
+	}
+	for _, nativeBlock := range nativeBody.Blocks {
+		nativeItems = append(nativeItems, nativeBlock)
+	}
+	sort.Sort(nativeNodeSorter{nativeItems})
+
+	body := &Body{
+		inTree: newInTree(),
+		items:  newNodeSet(),
+	}
+
+	remain := within
+	for _, nativeItem := range nativeItems {
+		beforeItem, item, afterItem := parseBodyItem(nativeItem, remain)
+
+		if beforeItem.Len() > 0 {
+			body.AppendUnstructuredTokens(beforeItem.Tokens())
+		}
+		body.appendItemNode(item)
+
+		remain = afterItem
+	}
+
+	if remain.Len() > 0 {
+		body.AppendUnstructuredTokens(remain.Tokens())
+	}
+
+	return before, newNode(body), after
+}
+
+func parseBodyItem(nativeItem hclsyntax.Node, from inputTokens) (inputTokens, *node, inputTokens) {
+	before, leadComments, within, lineComments, newline, after := from.PartitionBlockItem(nativeItem.Range())
+
+	var item *node
+
+	switch tItem := nativeItem.(type) {
+	case *hclsyntax.Attribute:
+		item = parseAttribute(tItem, within, leadComments, lineComments, newline)
+	case *hclsyntax.Block:
+		item = parseBlock(tItem, within, leadComments, lineComments, newline)
+	default:
+		// should never happen if caller is behaving
+		panic("unsupported native item type")
+	}
+
+	return before, item, after
+}
+
+func parseAttribute(nativeAttr *hclsyntax.Attribute, from, leadComments, lineComments, newline inputTokens) *node {
+	attr := &Attribute{
+		inTree: newInTree(),
+	}
+	children := attr.inTree.children
+
+	{
+		cn := newNode(newComments(leadComments.Tokens()))
+		attr.leadComments = cn
+		children.AppendNode(cn)
+	}
+
+	before, nameTokens, from := from.Partition(nativeAttr.NameRange)
+	{
+		children.AppendUnstructuredTokens(before.Tokens())
+		if nameTokens.Len() != 1 {
+			// Should never happen with valid input
+			panic("attribute name is not exactly one token")
+		}
+		token := nameTokens.Tokens()[0]
+		in := newNode(newIdentifier(token))
+		attr.name = in
+		children.AppendNode(in)
+	}
+
+	before, equalsTokens, from := from.Partition(nativeAttr.EqualsRange)
+	children.AppendUnstructuredTokens(before.Tokens())
+	children.AppendUnstructuredTokens(equalsTokens.Tokens())
+
+	before, exprTokens, from := from.Partition(nativeAttr.Expr.Range())
+	{
+		children.AppendUnstructuredTokens(before.Tokens())
+		exprNode := parseExpression(nativeAttr.Expr, exprTokens)
+		attr.expr = exprNode
+		children.AppendNode(exprNode)
+	}
+
+	{
+		cn := newNode(newComments(lineComments.Tokens()))
+		attr.lineComments = cn
+		children.AppendNode(cn)
+	}
+
+	children.AppendUnstructuredTokens(newline.Tokens())
+
+	// Collect any stragglers, though there shouldn't be any
+	children.AppendUnstructuredTokens(from.Tokens())
+
+	return newNode(attr)
+}
+
+func parseBlock(nativeBlock *hclsyntax.Block, from, leadComments, lineComments, newline inputTokens) *node {
+	block := &Block{
+		inTree: newInTree(),
+		labels: newNodeSet(),
+	}
+	children := block.inTree.children
+
+	{
+		cn := newNode(newComments(leadComments.Tokens()))
+		block.leadComments = cn
+		children.AppendNode(cn)
+	}
+
+	before, typeTokens, from := from.Partition(nativeBlock.TypeRange)
+	{
+		children.AppendUnstructuredTokens(before.Tokens())
+		if typeTokens.Len() != 1 {
+			// Should never happen with valid input
+			panic("block type name is not exactly one token")
+		}
+		token := typeTokens.Tokens()[0]
+		in := newNode(newIdentifier(token))
+		block.typeName = in
+		children.AppendNode(in)
+	}
+
+	for _, rng := range nativeBlock.LabelRanges {
+		var labelTokens inputTokens
+		before, labelTokens, from = from.Partition(rng)
+		children.AppendUnstructuredTokens(before.Tokens())
+		tokens := labelTokens.Tokens()
+		var ln *node
+		if len(tokens) == 1 && tokens[0].Type == hclsyntax.TokenIdent {
+			ln = newNode(newIdentifier(tokens[0]))
+		} else {
+			ln = newNode(newQuoted(tokens))
+		}
+		block.labels.Add(ln)
+		children.AppendNode(ln)
+	}
+
+	before, oBrace, from := from.Partition(nativeBlock.OpenBraceRange)
+	children.AppendUnstructuredTokens(before.Tokens())
+	children.AppendUnstructuredTokens(oBrace.Tokens())
+
+	// We go a bit out of order here: we go hunting for the closing brace
+	// so that we have a delimited body, but then we'll deal with the body
+	// before we actually append the closing brace and any straggling tokens
+	// that appear after it.
+	bodyTokens, cBrace, from := from.Partition(nativeBlock.CloseBraceRange)
+	before, body, after := parseBody(nativeBlock.Body, bodyTokens)
+	children.AppendUnstructuredTokens(before.Tokens())
+	block.body = body
+	children.AppendNode(body)
+	children.AppendUnstructuredTokens(after.Tokens())
+
+	children.AppendUnstructuredTokens(cBrace.Tokens())
+
+	// stragglers
+	children.AppendUnstructuredTokens(from.Tokens())
+	if lineComments.Len() > 0 {
+		// blocks don't actually have line comments, so we'll just treat
+		// them as extra stragglers
+		children.AppendUnstructuredTokens(lineComments.Tokens())
+	}
+	children.AppendUnstructuredTokens(newline.Tokens())
+
+	return newNode(block)
+}
+
+func parseExpression(nativeExpr hclsyntax.Expression, from inputTokens) *node {
+	expr := newExpression()
+	children := expr.inTree.children
+
+	nativeVars := nativeExpr.Variables()
+
+	for _, nativeTraversal := range nativeVars {
+		before, traversal, after := parseTraversal(nativeTraversal, from)
+		children.AppendUnstructuredTokens(before.Tokens())
+		children.AppendNode(traversal)
+		expr.absTraversals.Add(traversal)
+		from = after
+	}
+	// Attach any stragglers that don't belong to a traversal to the expression
+	// itself. In an expression with no traversals at all, this is just the
+	// entirety of "from".
+	children.AppendUnstructuredTokens(from.Tokens())
+
+	return newNode(expr)
+}
+
+func parseTraversal(nativeTraversal hcl.Traversal, from inputTokens) (before inputTokens, n *node, after inputTokens) {
+	traversal := newTraversal()
+	children := traversal.inTree.children
+	before, from, after = from.Partition(nativeTraversal.SourceRange())
+
+	stepAfter := from
+	for _, nativeStep := range nativeTraversal {
+		before, step, after := parseTraversalStep(nativeStep, stepAfter)
+		children.AppendUnstructuredTokens(before.Tokens())
+		children.AppendNode(step)
+		traversal.steps.Add(step)
+		stepAfter = after
+	}
+
+	return before, newNode(traversal), after
+}
+
+func parseTraversalStep(nativeStep hcl.Traverser, from inputTokens) (before inputTokens, n *node, after inputTokens) {
+	var children *nodes
+	switch tNativeStep := nativeStep.(type) {
+
+	case hcl.TraverseRoot, hcl.TraverseAttr:
+		step := newTraverseName()
+		children = step.inTree.children
+		before, from, after = from.Partition(nativeStep.SourceRange())
+		inBefore, token, inAfter := from.PartitionTypeSingle(hclsyntax.TokenIdent)
+		name := newIdentifier(token)
+		children.AppendUnstructuredTokens(inBefore.Tokens())
+		step.name = children.Append(name)
+		children.AppendUnstructuredTokens(inAfter.Tokens())
+		return before, newNode(step), after
+
+	case hcl.TraverseIndex:
+		step := newTraverseIndex()
+		children = step.inTree.children
+		before, from, after = from.Partition(nativeStep.SourceRange())
+
+		var inBefore, oBrack, keyTokens, cBrack inputTokens
+		inBefore, oBrack, from = from.PartitionType(hclsyntax.TokenOBrack)
+		children.AppendUnstructuredTokens(inBefore.Tokens())
+		children.AppendUnstructuredTokens(oBrack.Tokens())
+		keyTokens, cBrack, from = from.PartitionType(hclsyntax.TokenCBrack)
+
+		keyVal := tNativeStep.Key
+		switch keyVal.Type() {
+		case cty.String:
+			key := newQuoted(keyTokens.Tokens())
+			step.key = children.Append(key)
+		case cty.Number:
+			valBefore, valToken, valAfter := keyTokens.PartitionTypeSingle(hclsyntax.TokenNumberLit)
+			children.AppendUnstructuredTokens(valBefore.Tokens())
+			key := newNumber(valToken)
+			step.key = children.Append(key)
+			children.AppendUnstructuredTokens(valAfter.Tokens())
+		}
+
+		children.AppendUnstructuredTokens(cBrack.Tokens())
+		children.AppendUnstructuredTokens(from.Tokens())
+
+		return before, newNode(step), after
+	default:
+		panic(fmt.Sprintf("unsupported traversal step type %T", nativeStep))
+	}
+
+}
+
+// writerTokens takes a sequence of tokens as produced by the main hclsyntax
+// package and transforms it into an equivalent sequence of tokens using
+// this package's own token model.
+//
+// The resulting list contains the same number of tokens and uses the same
+// indices as the input, allowing the two sets of tokens to be correlated
+// by index.
+func writerTokens(nativeTokens hclsyntax.Tokens) Tokens {
+	// Ultimately we want a slice of token _pointers_, but since we can
+	// predict how much memory we're going to devote to tokens we'll allocate
+	// it all as a single flat buffer and thus give the GC less work to do.
+	tokBuf := make([]Token, len(nativeTokens))
+	var lastByteOffset int
+	for i, mainToken := range nativeTokens {
+		// Create a copy of the bytes so that we can mutate without
+		// corrupting the original token stream.
+		bytes := make([]byte, len(mainToken.Bytes))
+		copy(bytes, mainToken.Bytes)
+
+		tokBuf[i] = Token{
+			Type:  mainToken.Type,
+			Bytes: bytes,
+
+			// We assume here that spaces are always ASCII spaces, since
+			// that's what the scanner also assumes, and thus the number
+			// of bytes skipped is also the number of space characters.
+			SpacesBefore: mainToken.Range.Start.Byte - lastByteOffset,
+		}
+
+		lastByteOffset = mainToken.Range.End.Byte
+	}
+
+	// Now make a slice of pointers into the previous slice.
+	ret := make(Tokens, len(tokBuf))
+	for i := range ret {
+		ret[i] = &tokBuf[i]
+	}
+
+	return ret
+}
+
+// partitionTokens takes a sequence of tokens and a hcl.Range and returns
+// two indices within the token sequence that correspond with the range
+// boundaries, such that the slice operator could be used to produce
+// three token sequences for before, within, and after respectively:
+//
+//     start, end := partitionTokens(toks, rng)
+//     before := toks[:start]
+//     within := toks[start:end]
+//     after := toks[end:]
+//
+// This works best when the range is aligned with token boundaries (e.g.
+// because it was produced in terms of the scanner's result) but if that isn't
+// true then it will make a best effort that may produce strange results at
+// the boundaries.
+//
+// Native hclsyntax tokens are used here, because they contain the necessary
+// absolute position information. However, since writerTokens produces a
+// correlatable sequence of writer tokens, the resulting indices can be
+// used also to index into its result, allowing the partitioning of writer
+// tokens to be driven by the partitioning of native tokens.
+//
+// The tokens are assumed to be in source order and non-overlapping, which
+// will be true if the token sequence from the scanner is used directly.
+func partitionTokens(toks hclsyntax.Tokens, rng hcl.Range) (start, end int) {
+	// We us a linear search here because we assume tha in most cases our
+	// target range is close to the beginning of the sequence, and the seqences
+	// are generally small for most reasonable files anyway.
+	for i := 0; ; i++ {
+		if i >= len(toks) {
+			// No tokens for the given range at all!
+			return len(toks), len(toks)
+		}
+
+		if toks[i].Range.Start.Byte >= rng.Start.Byte {
+			start = i
+			break
+		}
+	}
+
+	for i := start; ; i++ {
+		if i >= len(toks) {
+			// The range "hangs off" the end of the token sequence
+			return start, len(toks)
+		}
+
+		if toks[i].Range.Start.Byte >= rng.End.Byte {
+			end = i // end marker is exclusive
+			break
+		}
+	}
+
+	return start, end
+}
+
+// partitionLeadCommentTokens takes a sequence of tokens that is assumed
+// to immediately precede a construct that can have lead comment tokens,
+// and returns the index into that sequence where the lead comments begin.
+//
+// Lead comments are defined as whole lines containing only comment tokens
+// with no blank lines between. If no such lines are found, the returned
+// index will be len(toks).
+func partitionLeadCommentTokens(toks hclsyntax.Tokens) int {
+	// single-line comments (which is what we're interested in here)
+	// consume their trailing newline, so we can just walk backwards
+	// until we stop seeing comment tokens.
+	for i := len(toks) - 1; i >= 0; i-- {
+		if toks[i].Type != hclsyntax.TokenComment {
+			return i + 1
+		}
+	}
+	return 0
+}
+
+// partitionLineEndTokens takes a sequence of tokens that is assumed
+// to immediately follow a construct that can have a line comment, and
+// returns first the index where any line comments end and then second
+// the index immediately after the trailing newline.
+//
+// Line comments are defined as comments that appear immediately after
+// a construct on the same line where its significant tokens ended.
+//
+// Since single-line comment tokens (# and //) include the newline that
+// terminates them, in the presence of these the two returned indices
+// will be the same since the comment itself serves as the line end.
+func partitionLineEndTokens(toks hclsyntax.Tokens) (afterComment, afterNewline int) {
+	for i := 0; i < len(toks); i++ {
+		tok := toks[i]
+		if tok.Type != hclsyntax.TokenComment {
+			switch tok.Type {
+			case hclsyntax.TokenNewline:
+				return i, i + 1
+			case hclsyntax.TokenEOF:
+				// Although this is valid, we mustn't include the EOF
+				// itself as our "newline" or else strange things will
+				// happen when we try to append new items.
+				return i, i
+			default:
+				// If we have well-formed input here then nothing else should be
+				// possible. This path should never happen, because we only try
+				// to extract tokens from the sequence if the parser succeeded,
+				// and it should catch this problem itself.
+				panic("malformed line trailers: expected only comments and newlines")
+			}
+		}
+
+		if len(tok.Bytes) > 0 && tok.Bytes[len(tok.Bytes)-1] == '\n' {
+			// Newline at the end of a single-line comment serves both as
+			// the end of comments *and* the end of the line.
+			return i + 1, i + 1
+		}
+	}
+	return len(toks), len(toks)
+}
+
+// lexConfig uses the hclsyntax scanner to get a token stream and then
+// rewrites it into this package's token model.
+//
+// Any errors produced during scanning are ignored, so the results of this
+// function should be used with care.
+func lexConfig(src []byte) Tokens {
+	mainTokens, _ := hclsyntax.LexConfig(src, "", hcl.Pos{Byte: 0, Line: 1, Column: 1})
+	return writerTokens(mainTokens)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/public.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/public.go
new file mode 100644
index 00000000..678a3aa4
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/public.go
@@ -0,0 +1,44 @@
+package hclwrite
+
+import (
+	"bytes"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+// NewFile creates a new file object that is empty and ready to have constructs
+// added t it.
+func NewFile() *File {
+	body := &Body{
+		inTree: newInTree(),
+		items:  newNodeSet(),
+	}
+	file := &File{
+		inTree: newInTree(),
+	}
+	file.body = file.inTree.children.Append(body)
+	return file
+}
+
+// ParseConfig interprets the given source bytes into a *hclwrite.File. The
+// resulting AST can be used to perform surgical edits on the source code
+// before turning it back into bytes again.
+func ParseConfig(src []byte, filename string, start hcl.Pos) (*File, hcl.Diagnostics) {
+	return parse(src, filename, start)
+}
+
+// Format takes source code and performs simple whitespace changes to transform
+// it to a canonical layout style.
+//
+// Format skips constructing an AST and works directly with tokens, so it
+// is less expensive than formatting via the AST for situations where no other
+// changes will be made. It also ignores syntax errors and can thus be applied
+// to partial source code, although the result in that case may not be
+// desirable.
+func Format(src []byte) []byte {
+	tokens := lexConfig(src)
+	format(tokens)
+	buf := &bytes.Buffer{}
+	tokens.WriteTo(buf)
+	return buf.Bytes()
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/tokens.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/tokens.go
new file mode 100644
index 00000000..7d21d09d
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/tokens.go
@@ -0,0 +1,122 @@
+package hclwrite
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/apparentlymart/go-textseg/v12/textseg"
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+)
+
+// Token is a single sequence of bytes annotated with a type. It is similar
+// in purpose to hclsyntax.Token, but discards the source position information
+// since that is not useful in code generation.
+type Token struct {
+	Type  hclsyntax.TokenType
+	Bytes []byte
+
+	// We record the number of spaces before each token so that we can
+	// reproduce the exact layout of the original file when we're making
+	// surgical changes in-place. When _new_ code is created it will always
+	// be in the canonical style, but we preserve layout of existing code.
+	SpacesBefore int
+}
+
+// asHCLSyntax returns the receiver expressed as an incomplete hclsyntax.Token.
+// A complete token is not possible since we don't have source location
+// information here, and so this method is unexported so we can be sure it will
+// only be used for internal purposes where we know the range isn't important.
+//
+// This is primarily intended to allow us to re-use certain functionality from
+// hclsyntax rather than re-implementing it against our own token type here.
+func (t *Token) asHCLSyntax() hclsyntax.Token {
+	return hclsyntax.Token{
+		Type:  t.Type,
+		Bytes: t.Bytes,
+		Range: hcl.Range{
+			Filename: "<invalid>",
+		},
+	}
+}
+
+// Tokens is a flat list of tokens.
+type Tokens []*Token
+
+func (ts Tokens) Bytes() []byte {
+	buf := &bytes.Buffer{}
+	ts.WriteTo(buf)
+	return buf.Bytes()
+}
+
+func (ts Tokens) testValue() string {
+	return string(ts.Bytes())
+}
+
+// Columns returns the number of columns (grapheme clusters) the token sequence
+// occupies. The result is not meaningful if there are newline or single-line
+// comment tokens in the sequence.
+func (ts Tokens) Columns() int {
+	ret := 0
+	for _, token := range ts {
+		ret += token.SpacesBefore // spaces are always worth one column each
+		ct, _ := textseg.TokenCount(token.Bytes, textseg.ScanGraphemeClusters)
+		ret += ct
+	}
+	return ret
+}
+
+// WriteTo takes an io.Writer and writes the bytes for each token to it,
+// along with the spacing that separates each token. In other words, this
+// allows serializing the tokens to a file or other such byte stream.
+func (ts Tokens) WriteTo(wr io.Writer) (int64, error) {
+	// We know we're going to be writing a lot of small chunks of repeated
+	// space characters, so we'll prepare a buffer of these that we can
+	// easily pass to wr.Write without any further allocation.
+	spaces := make([]byte, 40)
+	for i := range spaces {
+		spaces[i] = ' '
+	}
+
+	var n int64
+	var err error
+	for _, token := range ts {
+		if err != nil {
+			return n, err
+		}
+
+		for spacesBefore := token.SpacesBefore; spacesBefore > 0; spacesBefore -= len(spaces) {
+			thisChunk := spacesBefore
+			if thisChunk > len(spaces) {
+				thisChunk = len(spaces)
+			}
+			var thisN int
+			thisN, err = wr.Write(spaces[:thisChunk])
+			n += int64(thisN)
+			if err != nil {
+				return n, err
+			}
+		}
+
+		var thisN int
+		thisN, err = wr.Write(token.Bytes)
+		n += int64(thisN)
+	}
+
+	return n, err
+}
+
+func (ts Tokens) walkChildNodes(w internalWalkFunc) {
+	// Unstructured tokens have no child nodes
+}
+
+func (ts Tokens) BuildTokens(to Tokens) Tokens {
+	return append(to, ts...)
+}
+
+func newIdentToken(name string) *Token {
+	return &Token{
+		Type:  hclsyntax.TokenIdent,
+		Bytes: []byte(name),
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/ast.go b/vendor/github.com/hashicorp/hcl/v2/json/ast.go
new file mode 100644
index 00000000..9c580ca3
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/ast.go
@@ -0,0 +1,121 @@
+package json
+
+import (
+	"math/big"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+type node interface {
+	Range() hcl.Range
+	StartRange() hcl.Range
+}
+
+type objectVal struct {
+	Attrs      []*objectAttr
+	SrcRange   hcl.Range // range of the entire object, brace-to-brace
+	OpenRange  hcl.Range // range of the opening brace
+	CloseRange hcl.Range // range of the closing brace
+}
+
+func (n *objectVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n *objectVal) StartRange() hcl.Range {
+	return n.OpenRange
+}
+
+type objectAttr struct {
+	Name      string
+	Value     node
+	NameRange hcl.Range // range of the name string
+}
+
+func (n *objectAttr) Range() hcl.Range {
+	return n.NameRange
+}
+
+func (n *objectAttr) StartRange() hcl.Range {
+	return n.NameRange
+}
+
+type arrayVal struct {
+	Values    []node
+	SrcRange  hcl.Range // range of the entire object, bracket-to-bracket
+	OpenRange hcl.Range // range of the opening bracket
+}
+
+func (n *arrayVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n *arrayVal) StartRange() hcl.Range {
+	return n.OpenRange
+}
+
+type booleanVal struct {
+	Value    bool
+	SrcRange hcl.Range
+}
+
+func (n *booleanVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n *booleanVal) StartRange() hcl.Range {
+	return n.SrcRange
+}
+
+type numberVal struct {
+	Value    *big.Float
+	SrcRange hcl.Range
+}
+
+func (n *numberVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n *numberVal) StartRange() hcl.Range {
+	return n.SrcRange
+}
+
+type stringVal struct {
+	Value    string
+	SrcRange hcl.Range
+}
+
+func (n *stringVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n *stringVal) StartRange() hcl.Range {
+	return n.SrcRange
+}
+
+type nullVal struct {
+	SrcRange hcl.Range
+}
+
+func (n *nullVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n *nullVal) StartRange() hcl.Range {
+	return n.SrcRange
+}
+
+// invalidVal is used as a placeholder where a value is needed for a valid
+// parse tree but the input was invalid enough to prevent one from being
+// created.
+type invalidVal struct {
+	SrcRange hcl.Range
+}
+
+func (n invalidVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n invalidVal) StartRange() hcl.Range {
+	return n.SrcRange
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/didyoumean.go b/vendor/github.com/hashicorp/hcl/v2/json/didyoumean.go
new file mode 100644
index 00000000..fbdd8bff
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/didyoumean.go
@@ -0,0 +1,33 @@
+package json
+
+import (
+	"github.com/agext/levenshtein"
+)
+
+var keywords = []string{"false", "true", "null"}
+
+// keywordSuggestion tries to find a valid JSON keyword that is close to the
+// given string and returns it if found. If no keyword is close enough, returns
+// the empty string.
+func keywordSuggestion(given string) string {
+	return nameSuggestion(given, keywords)
+}
+
+// nameSuggestion tries to find a name from the given slice of suggested names
+// that is close to the given name and returns it if found. If no suggestion
+// is close enough, returns the empty string.
+//
+// The suggestions are tried in order, so earlier suggestions take precedence
+// if the given string is similar to two or more suggestions.
+//
+// This function is intended to be used with a relatively-small number of
+// suggestions. It's not optimized for hundreds or thousands of them.
+func nameSuggestion(given string, suggestions []string) string {
+	for _, suggestion := range suggestions {
+		dist := levenshtein.Distance(given, suggestion, nil)
+		if dist < 3 { // threshold determined experimentally
+			return suggestion
+		}
+	}
+	return ""
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/doc.go b/vendor/github.com/hashicorp/hcl/v2/json/doc.go
new file mode 100644
index 00000000..84d73193
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/doc.go
@@ -0,0 +1,12 @@
+// Package json is the JSON parser for HCL. It parses JSON files and returns
+// implementations of the core HCL structural interfaces in terms of the
+// JSON data inside.
+//
+// This is not a generic JSON parser. Instead, it deals with the mapping from
+// the JSON information model to the HCL information model, using a number
+// of hard-coded structural conventions.
+//
+// In most cases applications will not import this package directly, but will
+// instead access its functionality indirectly through functions in the main
+// "hcl" package and in the "hclparse" package.
+package json
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/navigation.go b/vendor/github.com/hashicorp/hcl/v2/json/navigation.go
new file mode 100644
index 00000000..bc8a97f7
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/navigation.go
@@ -0,0 +1,70 @@
+package json
+
+import (
+	"fmt"
+	"strings"
+)
+
+type navigation struct {
+	root node
+}
+
+// Implementation of hcled.ContextString
+func (n navigation) ContextString(offset int) string {
+	steps := navigationStepsRev(n.root, offset)
+	if steps == nil {
+		return ""
+	}
+
+	// We built our slice backwards, so we'll reverse it in-place now.
+	half := len(steps) / 2 // integer division
+	for i := 0; i < half; i++ {
+		steps[i], steps[len(steps)-1-i] = steps[len(steps)-1-i], steps[i]
+	}
+
+	ret := strings.Join(steps, "")
+	if len(ret) > 0 && ret[0] == '.' {
+		ret = ret[1:]
+	}
+	return ret
+}
+
+func navigationStepsRev(v node, offset int) []string {
+	switch tv := v.(type) {
+	case *objectVal:
+		// Do any of our properties have an object that contains the target
+		// offset?
+		for _, attr := range tv.Attrs {
+			k := attr.Name
+			av := attr.Value
+
+			switch av.(type) {
+			case *objectVal, *arrayVal:
+				// okay
+			default:
+				continue
+			}
+
+			if av.Range().ContainsOffset(offset) {
+				return append(navigationStepsRev(av, offset), "."+k)
+			}
+		}
+	case *arrayVal:
+		// Do any of our elements contain the target offset?
+		for i, elem := range tv.Values {
+
+			switch elem.(type) {
+			case *objectVal, *arrayVal:
+				// okay
+			default:
+				continue
+			}
+
+			if elem.Range().ContainsOffset(offset) {
+				return append(navigationStepsRev(elem, offset), fmt.Sprintf("[%d]", i))
+			}
+		}
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/parser.go b/vendor/github.com/hashicorp/hcl/v2/json/parser.go
new file mode 100644
index 00000000..7a54c51b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/parser.go
@@ -0,0 +1,496 @@
+package json
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+)
+
+func parseFileContent(buf []byte, filename string) (node, hcl.Diagnostics) {
+	tokens := scan(buf, pos{
+		Filename: filename,
+		Pos: hcl.Pos{
+			Byte:   0,
+			Line:   1,
+			Column: 1,
+		},
+	})
+	p := newPeeker(tokens)
+	node, diags := parseValue(p)
+	if len(diags) == 0 && p.Peek().Type != tokenEOF {
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Extraneous data after value",
+			Detail:   "Extra characters appear after the JSON value.",
+			Subject:  p.Peek().Range.Ptr(),
+		})
+	}
+	return node, diags
+}
+
+func parseValue(p *peeker) (node, hcl.Diagnostics) {
+	tok := p.Peek()
+
+	wrapInvalid := func(n node, diags hcl.Diagnostics) (node, hcl.Diagnostics) {
+		if n != nil {
+			return n, diags
+		}
+		return invalidVal{tok.Range}, diags
+	}
+
+	switch tok.Type {
+	case tokenBraceO:
+		return wrapInvalid(parseObject(p))
+	case tokenBrackO:
+		return wrapInvalid(parseArray(p))
+	case tokenNumber:
+		return wrapInvalid(parseNumber(p))
+	case tokenString:
+		return wrapInvalid(parseString(p))
+	case tokenKeyword:
+		return wrapInvalid(parseKeyword(p))
+	case tokenBraceC:
+		return wrapInvalid(nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Missing JSON value",
+				Detail:   "A JSON value must start with a brace, a bracket, a number, a string, or a keyword.",
+				Subject:  &tok.Range,
+			},
+		})
+	case tokenBrackC:
+		return wrapInvalid(nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Missing array element value",
+				Detail:   "A JSON value must start with a brace, a bracket, a number, a string, or a keyword.",
+				Subject:  &tok.Range,
+			},
+		})
+	case tokenEOF:
+		return wrapInvalid(nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Missing value",
+				Detail:   "The JSON data ends prematurely.",
+				Subject:  &tok.Range,
+			},
+		})
+	default:
+		return wrapInvalid(nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid start of value",
+				Detail:   "A JSON value must start with a brace, a bracket, a number, a string, or a keyword.",
+				Subject:  &tok.Range,
+			},
+		})
+	}
+}
+
+func tokenCanStartValue(tok token) bool {
+	switch tok.Type {
+	case tokenBraceO, tokenBrackO, tokenNumber, tokenString, tokenKeyword:
+		return true
+	default:
+		return false
+	}
+}
+
+func parseObject(p *peeker) (node, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	open := p.Read()
+	attrs := []*objectAttr{}
+
+	// recover is used to shift the peeker to what seems to be the end of
+	// our object, so that when we encounter an error we leave the peeker
+	// at a reasonable point in the token stream to continue parsing.
+	recover := func(tok token) {
+		open := 1
+		for {
+			switch tok.Type {
+			case tokenBraceO:
+				open++
+			case tokenBraceC:
+				open--
+				if open <= 1 {
+					return
+				}
+			case tokenEOF:
+				// Ran out of source before we were able to recover,
+				// so we'll bail here and let the caller deal with it.
+				return
+			}
+			tok = p.Read()
+		}
+	}
+
+Token:
+	for {
+		if p.Peek().Type == tokenBraceC {
+			break Token
+		}
+
+		keyNode, keyDiags := parseValue(p)
+		diags = diags.Extend(keyDiags)
+		if keyNode == nil {
+			return nil, diags
+		}
+
+		keyStrNode, ok := keyNode.(*stringVal)
+		if !ok {
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid object property name",
+				Detail:   "A JSON object property name must be a string",
+				Subject:  keyNode.StartRange().Ptr(),
+			})
+		}
+
+		key := keyStrNode.Value
+
+		colon := p.Read()
+		if colon.Type != tokenColon {
+			recover(colon)
+
+			if colon.Type == tokenBraceC || colon.Type == tokenComma {
+				// Catch common mistake of using braces instead of brackets
+				// for an object.
+				return nil, diags.Append(&hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Missing object value",
+					Detail:   "A JSON object attribute must have a value, introduced by a colon.",
+					Subject:  &colon.Range,
+				})
+			}
+
+			if colon.Type == tokenEquals {
+				// Possible confusion with native HCL syntax.
+				return nil, diags.Append(&hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Missing property value colon",
+					Detail:   "JSON uses a colon as its name/value delimiter, not an equals sign.",
+					Subject:  &colon.Range,
+				})
+			}
+
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing property value colon",
+				Detail:   "A colon must appear between an object property's name and its value.",
+				Subject:  &colon.Range,
+			})
+		}
+
+		valNode, valDiags := parseValue(p)
+		diags = diags.Extend(valDiags)
+		if valNode == nil {
+			return nil, diags
+		}
+
+		attrs = append(attrs, &objectAttr{
+			Name:      key,
+			Value:     valNode,
+			NameRange: keyStrNode.SrcRange,
+		})
+
+		switch p.Peek().Type {
+		case tokenComma:
+			comma := p.Read()
+			if p.Peek().Type == tokenBraceC {
+				// Special error message for this common mistake
+				return nil, diags.Append(&hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Trailing comma in object",
+					Detail:   "JSON does not permit a trailing comma after the final property in an object.",
+					Subject:  &comma.Range,
+				})
+			}
+			continue Token
+		case tokenEOF:
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unclosed object",
+				Detail:   "No closing brace was found for this JSON object.",
+				Subject:  &open.Range,
+			})
+		case tokenBrackC:
+			// Consume the bracket anyway, so that we don't return with the peeker
+			// at a strange place.
+			p.Read()
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Mismatched braces",
+				Detail:   "A JSON object must be closed with a brace, not a bracket.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+		case tokenBraceC:
+			break Token
+		default:
+			recover(p.Read())
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing attribute seperator comma",
+				Detail:   "A comma must appear between each property definition in an object.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+		}
+
+	}
+
+	close := p.Read()
+	return &objectVal{
+		Attrs:      attrs,
+		SrcRange:   hcl.RangeBetween(open.Range, close.Range),
+		OpenRange:  open.Range,
+		CloseRange: close.Range,
+	}, diags
+}
+
+func parseArray(p *peeker) (node, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	open := p.Read()
+	vals := []node{}
+
+	// recover is used to shift the peeker to what seems to be the end of
+	// our array, so that when we encounter an error we leave the peeker
+	// at a reasonable point in the token stream to continue parsing.
+	recover := func(tok token) {
+		open := 1
+		for {
+			switch tok.Type {
+			case tokenBrackO:
+				open++
+			case tokenBrackC:
+				open--
+				if open <= 1 {
+					return
+				}
+			case tokenEOF:
+				// Ran out of source before we were able to recover,
+				// so we'll bail here and let the caller deal with it.
+				return
+			}
+			tok = p.Read()
+		}
+	}
+
+Token:
+	for {
+		if p.Peek().Type == tokenBrackC {
+			break Token
+		}
+
+		valNode, valDiags := parseValue(p)
+		diags = diags.Extend(valDiags)
+		if valNode == nil {
+			return nil, diags
+		}
+
+		vals = append(vals, valNode)
+
+		switch p.Peek().Type {
+		case tokenComma:
+			comma := p.Read()
+			if p.Peek().Type == tokenBrackC {
+				// Special error message for this common mistake
+				return nil, diags.Append(&hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Trailing comma in array",
+					Detail:   "JSON does not permit a trailing comma after the final value in an array.",
+					Subject:  &comma.Range,
+				})
+			}
+			continue Token
+		case tokenColon:
+			recover(p.Read())
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid array value",
+				Detail:   "A colon is not used to introduce values in a JSON array.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+		case tokenEOF:
+			recover(p.Read())
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unclosed object",
+				Detail:   "No closing bracket was found for this JSON array.",
+				Subject:  &open.Range,
+			})
+		case tokenBraceC:
+			recover(p.Read())
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Mismatched brackets",
+				Detail:   "A JSON array must be closed with a bracket, not a brace.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+		case tokenBrackC:
+			break Token
+		default:
+			recover(p.Read())
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing attribute seperator comma",
+				Detail:   "A comma must appear between each value in an array.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+		}
+
+	}
+
+	close := p.Read()
+	return &arrayVal{
+		Values:    vals,
+		SrcRange:  hcl.RangeBetween(open.Range, close.Range),
+		OpenRange: open.Range,
+	}, diags
+}
+
+func parseNumber(p *peeker) (node, hcl.Diagnostics) {
+	tok := p.Read()
+
+	// Use encoding/json to validate the number syntax.
+	// TODO: Do this more directly to produce better diagnostics.
+	var num json.Number
+	err := json.Unmarshal(tok.Bytes, &num)
+	if err != nil {
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid JSON number",
+				Detail:   fmt.Sprintf("There is a syntax error in the given JSON number."),
+				Subject:  &tok.Range,
+			},
+		}
+	}
+
+	// We want to guarantee that we parse numbers the same way as cty (and thus
+	// native syntax HCL) would here, so we'll use the cty parser even though
+	// in most other cases we don't actually introduce cty concepts until
+	// decoding time. We'll unwrap the parsed float immediately afterwards, so
+	// the cty value is just a temporary helper.
+	nv, err := cty.ParseNumberVal(string(num))
+	if err != nil {
+		// Should never happen if above passed, since JSON numbers are a subset
+		// of what cty can parse...
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid JSON number",
+				Detail:   fmt.Sprintf("There is a syntax error in the given JSON number."),
+				Subject:  &tok.Range,
+			},
+		}
+	}
+
+	return &numberVal{
+		Value:    nv.AsBigFloat(),
+		SrcRange: tok.Range,
+	}, nil
+}
+
+func parseString(p *peeker) (node, hcl.Diagnostics) {
+	tok := p.Read()
+	var str string
+	err := json.Unmarshal(tok.Bytes, &str)
+
+	if err != nil {
+		var errRange hcl.Range
+		if serr, ok := err.(*json.SyntaxError); ok {
+			errOfs := serr.Offset
+			errPos := tok.Range.Start
+			errPos.Byte += int(errOfs)
+
+			// TODO: Use the byte offset to properly count unicode
+			// characters for the column, and mark the whole of the
+			// character that was wrong as part of our range.
+			errPos.Column += int(errOfs)
+
+			errEndPos := errPos
+			errEndPos.Byte++
+			errEndPos.Column++
+
+			errRange = hcl.Range{
+				Filename: tok.Range.Filename,
+				Start:    errPos,
+				End:      errEndPos,
+			}
+		} else {
+			errRange = tok.Range
+		}
+
+		var contextRange *hcl.Range
+		if errRange != tok.Range {
+			contextRange = &tok.Range
+		}
+
+		// FIXME: Eventually we should parse strings directly here so
+		// we can produce a more useful error message in the face fo things
+		// such as invalid escapes, etc.
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid JSON string",
+				Detail:   fmt.Sprintf("There is a syntax error in the given JSON string."),
+				Subject:  &errRange,
+				Context:  contextRange,
+			},
+		}
+	}
+
+	return &stringVal{
+		Value:    str,
+		SrcRange: tok.Range,
+	}, nil
+}
+
+func parseKeyword(p *peeker) (node, hcl.Diagnostics) {
+	tok := p.Read()
+	s := string(tok.Bytes)
+
+	switch s {
+	case "true":
+		return &booleanVal{
+			Value:    true,
+			SrcRange: tok.Range,
+		}, nil
+	case "false":
+		return &booleanVal{
+			Value:    false,
+			SrcRange: tok.Range,
+		}, nil
+	case "null":
+		return &nullVal{
+			SrcRange: tok.Range,
+		}, nil
+	case "undefined", "NaN", "Infinity":
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid JSON keyword",
+				Detail:   fmt.Sprintf("The JavaScript identifier %q cannot be used in JSON.", s),
+				Subject:  &tok.Range,
+			},
+		}
+	default:
+		var dym string
+		if suggest := keywordSuggestion(s); suggest != "" {
+			dym = fmt.Sprintf(" Did you mean %q?", suggest)
+		}
+
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid JSON keyword",
+				Detail:   fmt.Sprintf("%q is not a valid JSON keyword.%s", s, dym),
+				Subject:  &tok.Range,
+			},
+		}
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/peeker.go b/vendor/github.com/hashicorp/hcl/v2/json/peeker.go
new file mode 100644
index 00000000..fc7bbf58
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/peeker.go
@@ -0,0 +1,25 @@
+package json
+
+type peeker struct {
+	tokens []token
+	pos    int
+}
+
+func newPeeker(tokens []token) *peeker {
+	return &peeker{
+		tokens: tokens,
+		pos:    0,
+	}
+}
+
+func (p *peeker) Peek() token {
+	return p.tokens[p.pos]
+}
+
+func (p *peeker) Read() token {
+	ret := p.tokens[p.pos]
+	if ret.Type != tokenEOF {
+		p.pos++
+	}
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/public.go b/vendor/github.com/hashicorp/hcl/v2/json/public.go
new file mode 100644
index 00000000..8dc4a36a
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/public.go
@@ -0,0 +1,94 @@
+package json
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+// Parse attempts to parse the given buffer as JSON and, if successful, returns
+// a hcl.File for the HCL configuration represented by it.
+//
+// This is not a generic JSON parser. Instead, it deals only with the profile
+// of JSON used to express HCL configuration.
+//
+// The returned file is valid only if the returned diagnostics returns false
+// from its HasErrors method. If HasErrors returns true, the file represents
+// the subset of data that was able to be parsed, which may be none.
+func Parse(src []byte, filename string) (*hcl.File, hcl.Diagnostics) {
+	rootNode, diags := parseFileContent(src, filename)
+
+	switch rootNode.(type) {
+	case *objectVal, *arrayVal:
+		// okay
+	default:
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Root value must be object",
+			Detail:   "The root value in a JSON-based configuration must be either a JSON object or a JSON array of objects.",
+			Subject:  rootNode.StartRange().Ptr(),
+		})
+
+		// Since we've already produced an error message for this being
+		// invalid, we'll return an empty placeholder here so that trying to
+		// extract content from our root body won't produce a redundant
+		// error saying the same thing again in more general terms.
+		fakePos := hcl.Pos{
+			Byte:   0,
+			Line:   1,
+			Column: 1,
+		}
+		fakeRange := hcl.Range{
+			Filename: filename,
+			Start:    fakePos,
+			End:      fakePos,
+		}
+		rootNode = &objectVal{
+			Attrs:     []*objectAttr{},
+			SrcRange:  fakeRange,
+			OpenRange: fakeRange,
+		}
+	}
+
+	file := &hcl.File{
+		Body: &body{
+			val: rootNode,
+		},
+		Bytes: src,
+		Nav:   navigation{rootNode},
+	}
+	return file, diags
+}
+
+// ParseFile is a convenience wrapper around Parse that first attempts to load
+// data from the given filename, passing the result to Parse if successful.
+//
+// If the file cannot be read, an error diagnostic with nil context is returned.
+func ParseFile(filename string) (*hcl.File, hcl.Diagnostics) {
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Failed to open file",
+				Detail:   fmt.Sprintf("The file %q could not be opened.", filename),
+			},
+		}
+	}
+	defer f.Close()
+
+	src, err := ioutil.ReadAll(f)
+	if err != nil {
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Failed to read file",
+				Detail:   fmt.Sprintf("The file %q was opened, but an error occured while reading it.", filename),
+			},
+		}
+	}
+
+	return Parse(src, filename)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/scanner.go b/vendor/github.com/hashicorp/hcl/v2/json/scanner.go
new file mode 100644
index 00000000..ff78a9b5
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/scanner.go
@@ -0,0 +1,306 @@
+package json
+
+import (
+	"fmt"
+
+	"github.com/apparentlymart/go-textseg/v12/textseg"
+	"github.com/hashicorp/hcl/v2"
+)
+
+//go:generate stringer -type tokenType scanner.go
+type tokenType rune
+
+const (
+	tokenBraceO  tokenType = '{'
+	tokenBraceC  tokenType = '}'
+	tokenBrackO  tokenType = '['
+	tokenBrackC  tokenType = ']'
+	tokenComma   tokenType = ','
+	tokenColon   tokenType = ':'
+	tokenKeyword tokenType = 'K'
+	tokenString  tokenType = 'S'
+	tokenNumber  tokenType = 'N'
+	tokenEOF     tokenType = '␄'
+	tokenInvalid tokenType = 0
+	tokenEquals  tokenType = '=' // used only for reminding the user of JSON syntax
+)
+
+type token struct {
+	Type  tokenType
+	Bytes []byte
+	Range hcl.Range
+}
+
+// scan returns the primary tokens for the given JSON buffer in sequence.
+//
+// The responsibility of this pass is to just mark the slices of the buffer
+// as being of various types. It is lax in how it interprets the multi-byte
+// token types keyword, string and number, preferring to capture erroneous
+// extra bytes that we presume the user intended to be part of the token
+// so that we can generate more helpful diagnostics in the parser.
+func scan(buf []byte, start pos) []token {
+	var tokens []token
+	p := start
+	for {
+		if len(buf) == 0 {
+			tokens = append(tokens, token{
+				Type:  tokenEOF,
+				Bytes: nil,
+				Range: posRange(p, p),
+			})
+			return tokens
+		}
+
+		buf, p = skipWhitespace(buf, p)
+
+		if len(buf) == 0 {
+			tokens = append(tokens, token{
+				Type:  tokenEOF,
+				Bytes: nil,
+				Range: posRange(p, p),
+			})
+			return tokens
+		}
+
+		start = p
+
+		first := buf[0]
+		switch {
+		case first == '{' || first == '}' || first == '[' || first == ']' || first == ',' || first == ':' || first == '=':
+			p.Pos.Column++
+			p.Pos.Byte++
+			tokens = append(tokens, token{
+				Type:  tokenType(first),
+				Bytes: buf[0:1],
+				Range: posRange(start, p),
+			})
+			buf = buf[1:]
+		case first == '"':
+			var tokBuf []byte
+			tokBuf, buf, p = scanString(buf, p)
+			tokens = append(tokens, token{
+				Type:  tokenString,
+				Bytes: tokBuf,
+				Range: posRange(start, p),
+			})
+		case byteCanStartNumber(first):
+			var tokBuf []byte
+			tokBuf, buf, p = scanNumber(buf, p)
+			tokens = append(tokens, token{
+				Type:  tokenNumber,
+				Bytes: tokBuf,
+				Range: posRange(start, p),
+			})
+		case byteCanStartKeyword(first):
+			var tokBuf []byte
+			tokBuf, buf, p = scanKeyword(buf, p)
+			tokens = append(tokens, token{
+				Type:  tokenKeyword,
+				Bytes: tokBuf,
+				Range: posRange(start, p),
+			})
+		default:
+			tokens = append(tokens, token{
+				Type:  tokenInvalid,
+				Bytes: buf[:1],
+				Range: start.Range(1, 1),
+			})
+			// If we've encountered an invalid then we might as well stop
+			// scanning since the parser won't proceed beyond this point.
+			// We insert a synthetic EOF marker here to match the expectations
+			// of consumers of this data structure.
+			p.Pos.Column++
+			p.Pos.Byte++
+			tokens = append(tokens, token{
+				Type:  tokenEOF,
+				Bytes: nil,
+				Range: posRange(p, p),
+			})
+			return tokens
+		}
+	}
+}
+
+func byteCanStartNumber(b byte) bool {
+	switch b {
+	// We are slightly more tolerant than JSON requires here since we
+	// expect the parser will make a stricter interpretation of the
+	// number bytes, but we specifically don't allow 'e' or 'E' here
+	// since we want the scanner to treat that as the start of an
+	// invalid keyword instead, to produce more intelligible error messages.
+	case '-', '+', '.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+		return true
+	default:
+		return false
+	}
+}
+
+func scanNumber(buf []byte, start pos) ([]byte, []byte, pos) {
+	// The scanner doesn't check that the sequence of digit-ish bytes is
+	// in a valid order. The parser must do this when decoding a number
+	// token.
+	var i int
+	p := start
+Byte:
+	for i = 0; i < len(buf); i++ {
+		switch buf[i] {
+		case '-', '+', '.', 'e', 'E', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+			p.Pos.Byte++
+			p.Pos.Column++
+		default:
+			break Byte
+		}
+	}
+	return buf[:i], buf[i:], p
+}
+
+func byteCanStartKeyword(b byte) bool {
+	switch {
+	// We allow any sequence of alphabetical characters here, even though
+	// JSON is more constrained, so that we can collect what we presume
+	// the user intended to be a single keyword and then check its validity
+	// in the parser, where we can generate better diagnostics.
+	// So e.g. we want to be able to say:
+	//   unrecognized keyword "True". Did you mean "true"?
+	case isAlphabetical(b):
+		return true
+	default:
+		return false
+	}
+}
+
+func scanKeyword(buf []byte, start pos) ([]byte, []byte, pos) {
+	var i int
+	p := start
+Byte:
+	for i = 0; i < len(buf); i++ {
+		b := buf[i]
+		switch {
+		case isAlphabetical(b) || b == '_':
+			p.Pos.Byte++
+			p.Pos.Column++
+		default:
+			break Byte
+		}
+	}
+	return buf[:i], buf[i:], p
+}
+
+func scanString(buf []byte, start pos) ([]byte, []byte, pos) {
+	// The scanner doesn't validate correct use of escapes, etc. It pays
+	// attention to escapes only for the purpose of identifying the closing
+	// quote character. It's the parser's responsibility to do proper
+	// validation.
+	//
+	// The scanner also doesn't specifically detect unterminated string
+	// literals, though they can be identified in the parser by checking if
+	// the final byte in a string token is the double-quote character.
+
+	// Skip the opening quote symbol
+	i := 1
+	p := start
+	p.Pos.Byte++
+	p.Pos.Column++
+	escaping := false
+Byte:
+	for i < len(buf) {
+		b := buf[i]
+
+		switch {
+		case b == '\\':
+			escaping = !escaping
+			p.Pos.Byte++
+			p.Pos.Column++
+			i++
+		case b == '"':
+			p.Pos.Byte++
+			p.Pos.Column++
+			i++
+			if !escaping {
+				break Byte
+			}
+			escaping = false
+		case b < 32:
+			break Byte
+		default:
+			// Advance by one grapheme cluster, so that we consider each
+			// grapheme to be a "column".
+			// Ignoring error because this scanner cannot produce errors.
+			advance, _, _ := textseg.ScanGraphemeClusters(buf[i:], true)
+
+			p.Pos.Byte += advance
+			p.Pos.Column++
+			i += advance
+
+			escaping = false
+		}
+	}
+	return buf[:i], buf[i:], p
+}
+
+func skipWhitespace(buf []byte, start pos) ([]byte, pos) {
+	var i int
+	p := start
+Byte:
+	for i = 0; i < len(buf); i++ {
+		switch buf[i] {
+		case ' ':
+			p.Pos.Byte++
+			p.Pos.Column++
+		case '\n':
+			p.Pos.Byte++
+			p.Pos.Column = 1
+			p.Pos.Line++
+		case '\r':
+			// For the purpose of line/column counting we consider a
+			// carriage return to take up no space, assuming that it will
+			// be paired up with a newline (on Windows, for example) that
+			// will account for both of them.
+			p.Pos.Byte++
+		case '\t':
+			// We arbitrarily count a tab as if it were two spaces, because
+			// we need to choose _some_ number here. This means any system
+			// that renders code on-screen with markers must itself treat
+			// tabs as a pair of spaces for rendering purposes, or instead
+			// use the byte offset and back into its own column position.
+			p.Pos.Byte++
+			p.Pos.Column += 2
+		default:
+			break Byte
+		}
+	}
+	return buf[i:], p
+}
+
+type pos struct {
+	Filename string
+	Pos      hcl.Pos
+}
+
+func (p *pos) Range(byteLen, charLen int) hcl.Range {
+	start := p.Pos
+	end := p.Pos
+	end.Byte += byteLen
+	end.Column += charLen
+	return hcl.Range{
+		Filename: p.Filename,
+		Start:    start,
+		End:      end,
+	}
+}
+
+func posRange(start, end pos) hcl.Range {
+	return hcl.Range{
+		Filename: start.Filename,
+		Start:    start.Pos,
+		End:      end.Pos,
+	}
+}
+
+func (t token) GoString() string {
+	return fmt.Sprintf("json.token{json.%s, []byte(%q), %#v}", t.Type, t.Bytes, t.Range)
+}
+
+func isAlphabetical(b byte) bool {
+	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/spec.md b/vendor/github.com/hashicorp/hcl/v2/json/spec.md
new file mode 100644
index 00000000..dac5729d
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/spec.md
@@ -0,0 +1,405 @@
+# HCL JSON Syntax Specification
+
+This is the specification for the JSON serialization for hcl. HCL is a system
+for defining configuration languages for applications. The HCL information
+model is designed to support multiple concrete syntaxes for configuration,
+and this JSON-based format complements [the native syntax](../hclsyntax/spec.md)
+by being easy to machine-generate, whereas the native syntax is oriented
+towards human authoring and maintenance
+
+This syntax is defined in terms of JSON as defined in
+[RFC7159](https://tools.ietf.org/html/rfc7159). As such it inherits the JSON
+grammar as-is, and merely defines a specific methodology for interpreting
+JSON constructs into HCL structural elements and expressions.
+
+This mapping is defined such that valid JSON-serialized HCL input can be
+_produced_ using standard JSON implementations in various programming languages.
+_Parsing_ such JSON has some additional constraints not beyond what is normally
+supported by JSON parsers, so a specialized parser may be required that
+is able to:
+
+- Preserve the relative ordering of properties defined in an object.
+- Preserve multiple definitions of the same property name.
+- Preserve numeric values to the precision required by the number type
+  in [the HCL syntax-agnostic information model](../spec.md).
+- Retain source location information for parsed tokens/constructs in order
+  to produce good error messages.
+
+## Structural Elements
+
+[The HCL syntax-agnostic information model](../spec.md) defines a _body_ as an
+abstract container for attribute definitions and child blocks. A body is
+represented in JSON as either a single JSON object or a JSON array of objects.
+
+Body processing is in terms of JSON object properties, visited in the order
+they appear in the input. Where a body is represented by a single JSON object,
+the properties of that object are visited in order. Where a body is
+represented by a JSON array, each of its elements are visited in order and
+each element has its properties visited in order. If any element of the array
+is not a JSON object then the input is erroneous.
+
+When a body is being processed in the _dynamic attributes_ mode, the allowance
+of a JSON array in the previous paragraph does not apply and instead a single
+JSON object is always required.
+
+As defined in the language-agnostic model, body processing is in terms
+of a schema which provides context for interpreting the body's content. For
+JSON bodies, the schema is crucial to allow differentiation of attribute
+definitions and block definitions, both of which are represented via object
+properties.
+
+The special property name `"//"`, when used in an object representing a HCL
+body, is parsed and ignored. A property with this name can be used to
+include human-readable comments. (This special property name is _not_
+processed in this way for any _other_ HCL constructs that are represented as
+JSON objects.)
+
+### Attributes
+
+Where the given schema describes an attribute with a given name, the object
+property with the matching name — if present — serves as the attribute's
+definition.
+
+When a body is being processed in the _dynamic attributes_ mode, each object
+property serves as an attribute definition for the attribute whose name
+matches the property name.
+
+The value of an attribute definition property is interpreted as an _expression_,
+as described in a later section.
+
+Given a schema that calls for an attribute named "foo", a JSON object like
+the following provides a definition for that attribute:
+
+```json
+{
+  "foo": "bar baz"
+}
+```
+
+### Blocks
+
+Where the given schema describes a block with a given type name, each object
+property with the matching name serves as a definition of zero or more blocks
+of that type.
+
+Processing of child blocks is in terms of nested JSON objects and arrays.
+If the schema defines one or more _labels_ for the block type, a nested JSON
+object or JSON array of objects is required for each labelling level. These
+are flattened to a single ordered sequence of object properties using the
+same algorithm as for body content as defined above. Each object property
+serves as a label value at the corresponding level.
+
+After any labelling levels, the next nested value is either a JSON object
+representing a single block body, or a JSON array of JSON objects that each
+represent a single block body. Use of an array accommodates the definition
+of multiple blocks that have identical type and labels.
+
+Given a schema that calls for a block type named "foo" with no labels, the
+following JSON objects are all valid definitions of zero or more blocks of this
+type:
+
+```json
+{
+  "foo": {
+    "child_attr": "baz"
+  }
+}
+```
+
+```json
+{
+  "foo": [
+    {
+      "child_attr": "baz"
+    },
+    {
+      "child_attr": "boz"
+    }
+  ]
+}
+```
+
+```json
+{
+  "foo": []
+}
+```
+
+The first of these defines a single child block of type "foo". The second
+defines _two_ such blocks. The final example shows a degenerate definition
+of zero blocks, though generators should prefer to omit the property entirely
+in this scenario.
+
+Given a schema that calls for a block type named "foo" with _two_ labels, the
+extra label levels must be represented as objects or arrays of objects as in
+the following examples:
+
+```json
+{
+  "foo": {
+    "bar": {
+      "baz": {
+        "child_attr": "baz"
+      },
+      "boz": {
+        "child_attr": "baz"
+      }
+    },
+    "boz": {
+      "baz": {
+        "child_attr": "baz"
+      }
+    }
+  }
+}
+```
+
+```json
+{
+  "foo": {
+    "bar": {
+      "baz": {
+        "child_attr": "baz"
+      },
+      "boz": {
+        "child_attr": "baz"
+      }
+    },
+    "boz": {
+      "baz": [
+        {
+          "child_attr": "baz"
+        },
+        {
+          "child_attr": "boz"
+        }
+      ]
+    }
+  }
+}
+```
+
+```json
+{
+  "foo": [
+    {
+      "bar": {
+        "baz": {
+          "child_attr": "baz"
+        },
+        "boz": {
+          "child_attr": "baz"
+        }
+      }
+    },
+    {
+      "bar": {
+        "baz": [
+          {
+            "child_attr": "baz"
+          },
+          {
+            "child_attr": "boz"
+          }
+        ]
+      }
+    }
+  ]
+}
+```
+
+```json
+{
+  "foo": {
+    "bar": {
+      "baz": {
+        "child_attr": "baz"
+      },
+      "boz": {
+        "child_attr": "baz"
+      }
+    },
+    "bar": {
+      "baz": [
+        {
+          "child_attr": "baz"
+        },
+        {
+          "child_attr": "boz"
+        }
+      ]
+    }
+  }
+}
+```
+
+Arrays can be introduced at either the label definition or block body
+definition levels to define multiple definitions of the same block type
+or labels while preserving order.
+
+A JSON HCL parser _must_ support duplicate definitions of the same property
+name within a single object, preserving all of them and the relative ordering
+between them. The array-based forms are also required so that JSON HCL
+configurations can be produced with JSON producing libraries that are not
+able to preserve property definition order and multiple definitions of
+the same property.
+
+## Expressions
+
+JSON lacks a native expression syntax, so the HCL JSON syntax instead defines
+a mapping for each of the JSON value types, including a special mapping for
+strings that allows optional use of arbitrary expressions.
+
+### Objects
+
+When interpreted as an expression, a JSON object represents a value of a HCL
+object type.
+
+Each property of the JSON object represents an attribute of the HCL object type.
+The property name string given in the JSON input is interpreted as a string
+expression as described below, and its result is converted to string as defined
+by the syntax-agnostic information model. If such a conversion is not possible,
+an error is produced and evaluation fails.
+
+An instance of the constructed object type is then created, whose values
+are interpreted by again recursively applying the mapping rules defined in
+this section to each of the property values.
+
+If any evaluated property name strings produce null values, an error is
+produced and evaluation fails. If any produce _unknown_ values, the _entire
+object's_ result is an unknown value of the dynamic pseudo-type, signalling
+that the type of the object cannot be determined.
+
+It is an error to define the same property name multiple times within a single
+JSON object interpreted as an expression. In full expression mode, this
+constraint applies to the name expression results after conversion to string,
+rather than the raw string that may contain interpolation expressions.
+
+### Arrays
+
+When interpreted as an expression, a JSON array represents a value of a HCL
+tuple type.
+
+Each element of the JSON array represents an element of the HCL tuple type.
+The tuple type is constructed by enumerating the JSON array elements, creating
+for each an element whose type is the result of recursively applying the
+expression mapping rules. Correspondence is preserved between the array element
+indices and the tuple element indices.
+
+An instance of the constructed tuple type is then created, whose values are
+interpreted by again recursively applying the mapping rules defined in this
+section.
+
+### Numbers
+
+When interpreted as an expression, a JSON number represents a HCL number value.
+
+HCL numbers are arbitrary-precision decimal values, so a JSON HCL parser must
+be able to translate exactly the value given to a number of corresponding
+precision, within the constraints set by the HCL syntax-agnostic information
+model.
+
+In practice, off-the-shelf JSON serializers often do not support customizing the
+processing of numbers, and instead force processing as 32-bit or 64-bit
+floating point values.
+
+A _producer_ of JSON HCL that uses such a serializer can provide numeric values
+as JSON strings where they have precision too great for representation in the
+serializer's chosen numeric type in situations where the result will be
+converted to number (using the standard conversion rules) by a calling
+application.
+
+Alternatively, for expressions that are evaluated in full expression mode an
+embedded template interpolation can be used to faithfully represent a number,
+such as `"${1e150}"`, which will then be evaluated by the underlying HCL native
+syntax expression evaluator.
+
+### Boolean Values
+
+The JSON boolean values `true` and `false`, when interpreted as expressions,
+represent the corresponding HCL boolean values.
+
+### The Null Value
+
+The JSON value `null`, when interpreted as an expression, represents a
+HCL null value of the dynamic pseudo-type.
+
+### Strings
+
+When interpreted as an expression, a JSON string may be interpreted in one of
+two ways depending on the evaluation mode.
+
+If evaluating in literal-only mode (as defined by the syntax-agnostic
+information model) the literal string is intepreted directly as a HCL string
+value, by directly using the exact sequence of unicode characters represented.
+Template interpolations and directives MUST NOT be processed in this mode,
+allowing any characters that appear as introduction sequences to pass through
+literally:
+
+```json
+"Hello world! Template sequences like ${ are not intepreted here."
+```
+
+When evaluating in full expression mode (again, as defined by the syntax-
+agnostic information model) the literal string is instead interpreted as a
+_standalone template_ in the HCL Native Syntax. The expression evaluation
+result is then the direct result of evaluating that template with the current
+variable scope and function table.
+
+```json
+"Hello, ${name}! Template sequences are interpreted in full expression mode."
+```
+
+In particular the _Template Interpolation Unwrapping_ requirement from the
+HCL native syntax specification must be implemented, allowing the use of
+single-interpolation templates to represent expressions that would not
+otherwise be representable in JSON, such as the following example where
+the result must be a number, rather than a string representation of a number:
+
+```json
+"${ a + b }"
+```
+
+## Static Analysis
+
+The HCL static analysis operations are implemented for JSON values that
+represent expressions, as described in the following sections.
+
+Due to the limited expressive power of the JSON syntax alone, use of these
+static analyses functions rather than normal expression evaluation is used
+as additional context for how a JSON value is to be interpreted, which means
+that static analyses can result in a different interpretation of a given
+expression than normal evaluation.
+
+### Static List
+
+An expression interpreted as a static list must be a JSON array. Each of the
+values in the array is interpreted as an expression and returned.
+
+### Static Map
+
+An expression interpreted as a static map must be a JSON object. Each of the
+key/value pairs in the object is presented as a pair of expressions. Since
+object property names are always strings, evaluating the key expression with
+a non-`nil` evaluation context will evaluate any template sequences given
+in the property name.
+
+### Static Call
+
+An expression interpreted as a static call must be a string. The content of
+the string is interpreted as a native syntax expression (not a _template_,
+unlike normal evaluation) and then the static call analysis is delegated to
+that expression.
+
+If the original expression is not a string or its contents cannot be parsed
+as a native syntax expression then static call analysis is not supported.
+
+### Static Traversal
+
+An expression interpreted as a static traversal must be a string. The content
+of the string is interpreted as a native syntax expression (not a _template_,
+unlike normal evaluation) and then static traversal analysis is delegated
+to that expression.
+
+If the original expression is not a string or its contents cannot be parsed
+as a native syntax expression then static call analysis is not supported.
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/structure.go b/vendor/github.com/hashicorp/hcl/v2/json/structure.go
new file mode 100644
index 00000000..76c9d739
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/structure.go
@@ -0,0 +1,637 @@
+package json
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+)
+
+// body is the implementation of "Body" used for files processed with the JSON
+// parser.
+type body struct {
+	val node
+
+	// If non-nil, the keys of this map cause the corresponding attributes to
+	// be treated as non-existing. This is used when Body.PartialContent is
+	// called, to produce the "remaining content" Body.
+	hiddenAttrs map[string]struct{}
+}
+
+// expression is the implementation of "Expression" used for files processed
+// with the JSON parser.
+type expression struct {
+	src node
+}
+
+func (b *body) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) {
+	content, newBody, diags := b.PartialContent(schema)
+
+	hiddenAttrs := newBody.(*body).hiddenAttrs
+
+	var nameSuggestions []string
+	for _, attrS := range schema.Attributes {
+		if _, ok := hiddenAttrs[attrS.Name]; !ok {
+			// Only suggest an attribute name if we didn't use it already.
+			nameSuggestions = append(nameSuggestions, attrS.Name)
+		}
+	}
+	for _, blockS := range schema.Blocks {
+		// Blocks can appear multiple times, so we'll suggest their type
+		// names regardless of whether they've already been used.
+		nameSuggestions = append(nameSuggestions, blockS.Type)
+	}
+
+	jsonAttrs, attrDiags := b.collectDeepAttrs(b.val, nil)
+	diags = append(diags, attrDiags...)
+
+	for _, attr := range jsonAttrs {
+		k := attr.Name
+		if k == "//" {
+			// Ignore "//" keys in objects representing bodies, to allow
+			// their use as comments.
+			continue
+		}
+
+		if _, ok := hiddenAttrs[k]; !ok {
+			suggestion := nameSuggestion(k, nameSuggestions)
+			if suggestion != "" {
+				suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+			}
+
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Extraneous JSON object property",
+				Detail:   fmt.Sprintf("No argument or block type is named %q.%s", k, suggestion),
+				Subject:  &attr.NameRange,
+				Context:  attr.Range().Ptr(),
+			})
+		}
+	}
+
+	return content, diags
+}
+
+func (b *body) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	jsonAttrs, attrDiags := b.collectDeepAttrs(b.val, nil)
+	diags = append(diags, attrDiags...)
+
+	usedNames := map[string]struct{}{}
+	if b.hiddenAttrs != nil {
+		for k := range b.hiddenAttrs {
+			usedNames[k] = struct{}{}
+		}
+	}
+
+	content := &hcl.BodyContent{
+		Attributes: map[string]*hcl.Attribute{},
+		Blocks:     nil,
+
+		MissingItemRange: b.MissingItemRange(),
+	}
+
+	// Create some more convenient data structures for our work below.
+	attrSchemas := map[string]hcl.AttributeSchema{}
+	blockSchemas := map[string]hcl.BlockHeaderSchema{}
+	for _, attrS := range schema.Attributes {
+		attrSchemas[attrS.Name] = attrS
+	}
+	for _, blockS := range schema.Blocks {
+		blockSchemas[blockS.Type] = blockS
+	}
+
+	for _, jsonAttr := range jsonAttrs {
+		attrName := jsonAttr.Name
+		if _, used := b.hiddenAttrs[attrName]; used {
+			continue
+		}
+
+		if attrS, defined := attrSchemas[attrName]; defined {
+			if existing, exists := content.Attributes[attrName]; exists {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Duplicate argument",
+					Detail:   fmt.Sprintf("The argument %q was already set at %s.", attrName, existing.Range),
+					Subject:  &jsonAttr.NameRange,
+					Context:  jsonAttr.Range().Ptr(),
+				})
+				continue
+			}
+
+			content.Attributes[attrS.Name] = &hcl.Attribute{
+				Name:      attrS.Name,
+				Expr:      &expression{src: jsonAttr.Value},
+				Range:     hcl.RangeBetween(jsonAttr.NameRange, jsonAttr.Value.Range()),
+				NameRange: jsonAttr.NameRange,
+			}
+			usedNames[attrName] = struct{}{}
+
+		} else if blockS, defined := blockSchemas[attrName]; defined {
+			bv := jsonAttr.Value
+			blockDiags := b.unpackBlock(bv, blockS.Type, &jsonAttr.NameRange, blockS.LabelNames, nil, nil, &content.Blocks)
+			diags = append(diags, blockDiags...)
+			usedNames[attrName] = struct{}{}
+		}
+
+		// We ignore anything that isn't defined because that's the
+		// PartialContent contract. The Content method will catch leftovers.
+	}
+
+	// Make sure we got all the required attributes.
+	for _, attrS := range schema.Attributes {
+		if !attrS.Required {
+			continue
+		}
+		if _, defined := content.Attributes[attrS.Name]; !defined {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing required argument",
+				Detail:   fmt.Sprintf("The argument %q is required, but no definition was found.", attrS.Name),
+				Subject:  b.MissingItemRange().Ptr(),
+			})
+		}
+	}
+
+	unusedBody := &body{
+		val:         b.val,
+		hiddenAttrs: usedNames,
+	}
+
+	return content, unusedBody, diags
+}
+
+// JustAttributes for JSON bodies interprets all properties of the wrapped
+// JSON object as attributes and returns them.
+func (b *body) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+	attrs := make(map[string]*hcl.Attribute)
+
+	obj, ok := b.val.(*objectVal)
+	if !ok {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Incorrect JSON value type",
+			Detail:   "A JSON object is required here, setting the arguments for this block.",
+			Subject:  b.val.StartRange().Ptr(),
+		})
+		return attrs, diags
+	}
+
+	for _, jsonAttr := range obj.Attrs {
+		name := jsonAttr.Name
+		if name == "//" {
+			// Ignore "//" keys in objects representing bodies, to allow
+			// their use as comments.
+			continue
+		}
+
+		if _, hidden := b.hiddenAttrs[name]; hidden {
+			continue
+		}
+
+		if existing, exists := attrs[name]; exists {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Duplicate attribute definition",
+				Detail:   fmt.Sprintf("The argument %q was already set at %s.", name, existing.Range),
+				Subject:  &jsonAttr.NameRange,
+			})
+			continue
+		}
+
+		attrs[name] = &hcl.Attribute{
+			Name:      name,
+			Expr:      &expression{src: jsonAttr.Value},
+			Range:     hcl.RangeBetween(jsonAttr.NameRange, jsonAttr.Value.Range()),
+			NameRange: jsonAttr.NameRange,
+		}
+	}
+
+	// No diagnostics possible here, since the parser already took care of
+	// finding duplicates and every JSON value can be a valid attribute value.
+	return attrs, diags
+}
+
+func (b *body) MissingItemRange() hcl.Range {
+	switch tv := b.val.(type) {
+	case *objectVal:
+		return tv.CloseRange
+	case *arrayVal:
+		return tv.OpenRange
+	default:
+		// Should not happen in correct operation, but might show up if the
+		// input is invalid and we are producing partial results.
+		return tv.StartRange()
+	}
+}
+
+func (b *body) unpackBlock(v node, typeName string, typeRange *hcl.Range, labelsLeft []string, labelsUsed []string, labelRanges []hcl.Range, blocks *hcl.Blocks) (diags hcl.Diagnostics) {
+	if len(labelsLeft) > 0 {
+		labelName := labelsLeft[0]
+		jsonAttrs, attrDiags := b.collectDeepAttrs(v, &labelName)
+		diags = append(diags, attrDiags...)
+
+		if len(jsonAttrs) == 0 {
+			diags = diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing block label",
+				Detail:   fmt.Sprintf("At least one object property is required, whose name represents the %s block's %s.", typeName, labelName),
+				Subject:  v.StartRange().Ptr(),
+			})
+			return
+		}
+		labelsUsed := append(labelsUsed, "")
+		labelRanges := append(labelRanges, hcl.Range{})
+		for _, p := range jsonAttrs {
+			pk := p.Name
+			labelsUsed[len(labelsUsed)-1] = pk
+			labelRanges[len(labelRanges)-1] = p.NameRange
+			diags = append(diags, b.unpackBlock(p.Value, typeName, typeRange, labelsLeft[1:], labelsUsed, labelRanges, blocks)...)
+		}
+		return
+	}
+
+	// By the time we get here, we've peeled off all the labels and we're ready
+	// to deal with the block's actual content.
+
+	// need to copy the label slices because their underlying arrays will
+	// continue to be mutated after we return.
+	labels := make([]string, len(labelsUsed))
+	copy(labels, labelsUsed)
+	labelR := make([]hcl.Range, len(labelRanges))
+	copy(labelR, labelRanges)
+
+	switch tv := v.(type) {
+	case *nullVal:
+		// There is no block content, e.g the value is null.
+		return
+	case *objectVal:
+		// Single instance of the block
+		*blocks = append(*blocks, &hcl.Block{
+			Type:   typeName,
+			Labels: labels,
+			Body: &body{
+				val: tv,
+			},
+
+			DefRange:    tv.OpenRange,
+			TypeRange:   *typeRange,
+			LabelRanges: labelR,
+		})
+	case *arrayVal:
+		// Multiple instances of the block
+		for _, av := range tv.Values {
+			*blocks = append(*blocks, &hcl.Block{
+				Type:   typeName,
+				Labels: labels,
+				Body: &body{
+					val: av, // might be mistyped; we'll find out when content is requested for this body
+				},
+
+				DefRange:    tv.OpenRange,
+				TypeRange:   *typeRange,
+				LabelRanges: labelR,
+			})
+		}
+	default:
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Incorrect JSON value type",
+			Detail:   fmt.Sprintf("Either a JSON object or a JSON array is required, representing the contents of one or more %q blocks.", typeName),
+			Subject:  v.StartRange().Ptr(),
+		})
+	}
+	return
+}
+
+// collectDeepAttrs takes either a single object or an array of objects and
+// flattens it into a list of object attributes, collecting attributes from
+// all of the objects in a given array.
+//
+// Ordering is preserved, so a list of objects that each have one property
+// will result in those properties being returned in the same order as the
+// objects appeared in the array.
+//
+// This is appropriate for use only for objects representing bodies or labels
+// within a block.
+//
+// The labelName argument, if non-null, is used to tailor returned error
+// messages to refer to block labels rather than attributes and child blocks.
+// It has no other effect.
+func (b *body) collectDeepAttrs(v node, labelName *string) ([]*objectAttr, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+	var attrs []*objectAttr
+
+	switch tv := v.(type) {
+	case *nullVal:
+		// If a value is null, then we don't return any attributes or return an error.
+
+	case *objectVal:
+		attrs = append(attrs, tv.Attrs...)
+
+	case *arrayVal:
+		for _, ev := range tv.Values {
+			switch tev := ev.(type) {
+			case *objectVal:
+				attrs = append(attrs, tev.Attrs...)
+			default:
+				if labelName != nil {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Incorrect JSON value type",
+						Detail:   fmt.Sprintf("A JSON object is required here, to specify %s labels for this block.", *labelName),
+						Subject:  ev.StartRange().Ptr(),
+					})
+				} else {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Incorrect JSON value type",
+						Detail:   "A JSON object is required here, to define arguments and child blocks.",
+						Subject:  ev.StartRange().Ptr(),
+					})
+				}
+			}
+		}
+
+	default:
+		if labelName != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Incorrect JSON value type",
+				Detail:   fmt.Sprintf("Either a JSON object or JSON array of objects is required here, to specify %s labels for this block.", *labelName),
+				Subject:  v.StartRange().Ptr(),
+			})
+		} else {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Incorrect JSON value type",
+				Detail:   "Either a JSON object or JSON array of objects is required here, to define arguments and child blocks.",
+				Subject:  v.StartRange().Ptr(),
+			})
+		}
+	}
+
+	return attrs, diags
+}
+
+func (e *expression) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	switch v := e.src.(type) {
+	case *stringVal:
+		if ctx != nil {
+			// Parse string contents as a HCL native language expression.
+			// We only do this if we have a context, so passing a nil context
+			// is how the caller specifies that interpolations are not allowed
+			// and that the string should just be returned verbatim.
+			templateSrc := v.Value
+			expr, diags := hclsyntax.ParseTemplate(
+				[]byte(templateSrc),
+				v.SrcRange.Filename,
+
+				// This won't produce _exactly_ the right result, since
+				// the hclsyntax parser can't "see" any escapes we removed
+				// while parsing JSON, but it's better than nothing.
+				hcl.Pos{
+					Line: v.SrcRange.Start.Line,
+
+					// skip over the opening quote mark
+					Byte:   v.SrcRange.Start.Byte + 1,
+					Column: v.SrcRange.Start.Column + 1,
+				},
+			)
+			if diags.HasErrors() {
+				return cty.DynamicVal, diags
+			}
+			val, evalDiags := expr.Value(ctx)
+			diags = append(diags, evalDiags...)
+			return val, diags
+		}
+
+		return cty.StringVal(v.Value), nil
+	case *numberVal:
+		return cty.NumberVal(v.Value), nil
+	case *booleanVal:
+		return cty.BoolVal(v.Value), nil
+	case *arrayVal:
+		var diags hcl.Diagnostics
+		vals := []cty.Value{}
+		for _, jsonVal := range v.Values {
+			val, valDiags := (&expression{src: jsonVal}).Value(ctx)
+			vals = append(vals, val)
+			diags = append(diags, valDiags...)
+		}
+		return cty.TupleVal(vals), diags
+	case *objectVal:
+		var diags hcl.Diagnostics
+		attrs := map[string]cty.Value{}
+		attrRanges := map[string]hcl.Range{}
+		known := true
+		for _, jsonAttr := range v.Attrs {
+			// In this one context we allow keys to contain interpolation
+			// expressions too, assuming we're evaluating in interpolation
+			// mode. This achieves parity with the native syntax where
+			// object expressions can have dynamic keys, while block contents
+			// may not.
+			name, nameDiags := (&expression{src: &stringVal{
+				Value:    jsonAttr.Name,
+				SrcRange: jsonAttr.NameRange,
+			}}).Value(ctx)
+			valExpr := &expression{src: jsonAttr.Value}
+			val, valDiags := valExpr.Value(ctx)
+			diags = append(diags, nameDiags...)
+			diags = append(diags, valDiags...)
+
+			var err error
+			name, err = convert.Convert(name, cty.String)
+			if err != nil {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity:    hcl.DiagError,
+					Summary:     "Invalid object key expression",
+					Detail:      fmt.Sprintf("Cannot use this expression as an object key: %s.", err),
+					Subject:     &jsonAttr.NameRange,
+					Expression:  valExpr,
+					EvalContext: ctx,
+				})
+				continue
+			}
+			if name.IsNull() {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity:    hcl.DiagError,
+					Summary:     "Invalid object key expression",
+					Detail:      "Cannot use null value as an object key.",
+					Subject:     &jsonAttr.NameRange,
+					Expression:  valExpr,
+					EvalContext: ctx,
+				})
+				continue
+			}
+			if !name.IsKnown() {
+				// This is a bit of a weird case, since our usual rules require
+				// us to tolerate unknowns and just represent the result as
+				// best we can but if we don't know the key then we can't
+				// know the type of our object at all, and thus we must turn
+				// the whole thing into cty.DynamicVal. This is consistent with
+				// how this situation is handled in the native syntax.
+				// We'll keep iterating so we can collect other errors in
+				// subsequent attributes.
+				known = false
+				continue
+			}
+			nameStr := name.AsString()
+			if _, defined := attrs[nameStr]; defined {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity:    hcl.DiagError,
+					Summary:     "Duplicate object attribute",
+					Detail:      fmt.Sprintf("An attribute named %q was already defined at %s.", nameStr, attrRanges[nameStr]),
+					Subject:     &jsonAttr.NameRange,
+					Expression:  e,
+					EvalContext: ctx,
+				})
+				continue
+			}
+			attrs[nameStr] = val
+			attrRanges[nameStr] = jsonAttr.NameRange
+		}
+		if !known {
+			// We encountered an unknown key somewhere along the way, so
+			// we can't know what our type will eventually be.
+			return cty.DynamicVal, diags
+		}
+		return cty.ObjectVal(attrs), diags
+	case *nullVal:
+		return cty.NullVal(cty.DynamicPseudoType), nil
+	default:
+		// Default to DynamicVal so that ASTs containing invalid nodes can
+		// still be partially-evaluated.
+		return cty.DynamicVal, nil
+	}
+}
+
+func (e *expression) Variables() []hcl.Traversal {
+	var vars []hcl.Traversal
+
+	switch v := e.src.(type) {
+	case *stringVal:
+		templateSrc := v.Value
+		expr, diags := hclsyntax.ParseTemplate(
+			[]byte(templateSrc),
+			v.SrcRange.Filename,
+
+			// This won't produce _exactly_ the right result, since
+			// the hclsyntax parser can't "see" any escapes we removed
+			// while parsing JSON, but it's better than nothing.
+			hcl.Pos{
+				Line: v.SrcRange.Start.Line,
+
+				// skip over the opening quote mark
+				Byte:   v.SrcRange.Start.Byte + 1,
+				Column: v.SrcRange.Start.Column + 1,
+			},
+		)
+		if diags.HasErrors() {
+			return vars
+		}
+		return expr.Variables()
+
+	case *arrayVal:
+		for _, jsonVal := range v.Values {
+			vars = append(vars, (&expression{src: jsonVal}).Variables()...)
+		}
+	case *objectVal:
+		for _, jsonAttr := range v.Attrs {
+			keyExpr := &stringVal{ // we're going to treat key as an expression in this context
+				Value:    jsonAttr.Name,
+				SrcRange: jsonAttr.NameRange,
+			}
+			vars = append(vars, (&expression{src: keyExpr}).Variables()...)
+			vars = append(vars, (&expression{src: jsonAttr.Value}).Variables()...)
+		}
+	}
+
+	return vars
+}
+
+func (e *expression) Range() hcl.Range {
+	return e.src.Range()
+}
+
+func (e *expression) StartRange() hcl.Range {
+	return e.src.StartRange()
+}
+
+// Implementation for hcl.AbsTraversalForExpr.
+func (e *expression) AsTraversal() hcl.Traversal {
+	// In JSON-based syntax a traversal is given as a string containing
+	// traversal syntax as defined by hclsyntax.ParseTraversalAbs.
+
+	switch v := e.src.(type) {
+	case *stringVal:
+		traversal, diags := hclsyntax.ParseTraversalAbs([]byte(v.Value), v.SrcRange.Filename, v.SrcRange.Start)
+		if diags.HasErrors() {
+			return nil
+		}
+		return traversal
+	default:
+		return nil
+	}
+}
+
+// Implementation for hcl.ExprCall.
+func (e *expression) ExprCall() *hcl.StaticCall {
+	// In JSON-based syntax a static call is given as a string containing
+	// an expression in the native syntax that also supports ExprCall.
+
+	switch v := e.src.(type) {
+	case *stringVal:
+		expr, diags := hclsyntax.ParseExpression([]byte(v.Value), v.SrcRange.Filename, v.SrcRange.Start)
+		if diags.HasErrors() {
+			return nil
+		}
+
+		call, diags := hcl.ExprCall(expr)
+		if diags.HasErrors() {
+			return nil
+		}
+
+		return call
+	default:
+		return nil
+	}
+}
+
+// Implementation for hcl.ExprList.
+func (e *expression) ExprList() []hcl.Expression {
+	switch v := e.src.(type) {
+	case *arrayVal:
+		ret := make([]hcl.Expression, len(v.Values))
+		for i, node := range v.Values {
+			ret[i] = &expression{src: node}
+		}
+		return ret
+	default:
+		return nil
+	}
+}
+
+// Implementation for hcl.ExprMap.
+func (e *expression) ExprMap() []hcl.KeyValuePair {
+	switch v := e.src.(type) {
+	case *objectVal:
+		ret := make([]hcl.KeyValuePair, len(v.Attrs))
+		for i, jsonAttr := range v.Attrs {
+			ret[i] = hcl.KeyValuePair{
+				Key: &expression{src: &stringVal{
+					Value:    jsonAttr.Name,
+					SrcRange: jsonAttr.NameRange,
+				}},
+				Value: &expression{src: jsonAttr.Value},
+			}
+		}
+		return ret
+	default:
+		return nil
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/tokentype_string.go b/vendor/github.com/hashicorp/hcl/v2/json/tokentype_string.go
new file mode 100644
index 00000000..bbcce5b3
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/tokentype_string.go
@@ -0,0 +1,29 @@
+// Code generated by "stringer -type tokenType scanner.go"; DO NOT EDIT.
+
+package json
+
+import "strconv"
+
+const _tokenType_name = "tokenInvalidtokenCommatokenColontokenEqualstokenKeywordtokenNumbertokenStringtokenBrackOtokenBrackCtokenBraceOtokenBraceCtokenEOF"
+
+var _tokenType_map = map[tokenType]string{
+	0:    _tokenType_name[0:12],
+	44:   _tokenType_name[12:22],
+	58:   _tokenType_name[22:32],
+	61:   _tokenType_name[32:43],
+	75:   _tokenType_name[43:55],
+	78:   _tokenType_name[55:66],
+	83:   _tokenType_name[66:77],
+	91:   _tokenType_name[77:88],
+	93:   _tokenType_name[88:99],
+	123:  _tokenType_name[99:110],
+	125:  _tokenType_name[110:121],
+	9220: _tokenType_name[121:129],
+}
+
+func (i tokenType) String() string {
+	if str, ok := _tokenType_map[i]; ok {
+		return str
+	}
+	return "tokenType(" + strconv.FormatInt(int64(i), 10) + ")"
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
new file mode 100644
index 00000000..4f1ecc8d
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
@@ -0,0 +1,78 @@
+package stdlib
+
+import (
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var NotFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "val",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].Not(), nil
+	},
+})
+
+var AndFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].And(args[1]), nil
+	},
+})
+
+var OrFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].Or(args[1]), nil
+	},
+})
+
+// Not returns the logical complement of the given boolean value.
+func Not(num cty.Value) (cty.Value, error) {
+	return NotFunc.Call([]cty.Value{num})
+}
+
+// And returns true if and only if both of the given boolean values are true.
+func And(a, b cty.Value) (cty.Value, error) {
+	return AndFunc.Call([]cty.Value{a, b})
+}
+
+// Or returns true if either of the given boolean values are true.
+func Or(a, b cty.Value) (cty.Value, error) {
+	return OrFunc.Call([]cty.Value{a, b})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
new file mode 100644
index 00000000..a132e0cd
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
@@ -0,0 +1,112 @@
+package stdlib
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+// Bytes is a capsule type that can be used with the binary functions to
+// support applications that need to support raw buffers in addition to
+// UTF-8 strings.
+var Bytes = cty.Capsule("bytes", reflect.TypeOf([]byte(nil)))
+
+// BytesVal creates a new Bytes value from the given buffer, which must be
+// non-nil or this function will panic.
+//
+// Once a byte slice has been wrapped in a Bytes capsule, its underlying array
+// must be considered immutable.
+func BytesVal(buf []byte) cty.Value {
+	if buf == nil {
+		panic("can't make Bytes value from nil slice")
+	}
+
+	return cty.CapsuleVal(Bytes, &buf)
+}
+
+// BytesLen is a Function that returns the length of the buffer encapsulated
+// in a Bytes value.
+var BytesLenFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "buf",
+			Type:             Bytes,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		bufPtr := args[0].EncapsulatedValue().(*[]byte)
+		return cty.NumberIntVal(int64(len(*bufPtr))), nil
+	},
+})
+
+// BytesSlice is a Function that returns a slice of the given Bytes value.
+var BytesSliceFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "buf",
+			Type:             Bytes,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "offset",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "length",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(Bytes),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		bufPtr := args[0].EncapsulatedValue().(*[]byte)
+
+		var offset, length int
+
+		var err error
+		err = gocty.FromCtyValue(args[1], &offset)
+		if err != nil {
+			return cty.NilVal, err
+		}
+		err = gocty.FromCtyValue(args[2], &length)
+		if err != nil {
+			return cty.NilVal, err
+		}
+
+		if offset < 0 || length < 0 {
+			return cty.NilVal, fmt.Errorf("offset and length must be non-negative")
+		}
+
+		if offset > len(*bufPtr) {
+			return cty.NilVal, fmt.Errorf(
+				"offset %d is greater than total buffer length %d",
+				offset, len(*bufPtr),
+			)
+		}
+
+		end := offset + length
+
+		if end > len(*bufPtr) {
+			return cty.NilVal, fmt.Errorf(
+				"offset %d + length %d is greater than total buffer length %d",
+				offset, length, len(*bufPtr),
+			)
+		}
+
+		return BytesVal((*bufPtr)[offset:end]), nil
+	},
+})
+
+func BytesLen(buf cty.Value) (cty.Value, error) {
+	return BytesLenFunc.Call([]cty.Value{buf})
+}
+
+func BytesSlice(buf cty.Value, offset cty.Value, length cty.Value) (cty.Value, error) {
+	return BytesSliceFunc.Call([]cty.Value{buf, offset, length})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
new file mode 100644
index 00000000..967ba03c
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
@@ -0,0 +1,140 @@
+package stdlib
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+var HasIndexFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "collection",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "key",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		collTy := args[0].Type()
+		if !(collTy.IsTupleType() || collTy.IsListType() || collTy.IsMapType() || collTy == cty.DynamicPseudoType) {
+			return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+		}
+		return cty.Bool, nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].HasIndex(args[1]), nil
+	},
+})
+
+var IndexFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "collection",
+			Type: cty.DynamicPseudoType,
+		},
+		{
+			Name:             "key",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		collTy := args[0].Type()
+		key := args[1]
+		keyTy := key.Type()
+		switch {
+		case collTy.IsTupleType():
+			if keyTy != cty.Number && keyTy != cty.DynamicPseudoType {
+				return cty.NilType, fmt.Errorf("key for tuple must be number")
+			}
+			if !key.IsKnown() {
+				return cty.DynamicPseudoType, nil
+			}
+			var idx int
+			err := gocty.FromCtyValue(key, &idx)
+			if err != nil {
+				return cty.NilType, fmt.Errorf("invalid key for tuple: %s", err)
+			}
+
+			etys := collTy.TupleElementTypes()
+
+			if idx >= len(etys) || idx < 0 {
+				return cty.NilType, fmt.Errorf("key must be between 0 and %d inclusive", len(etys))
+			}
+
+			return etys[idx], nil
+
+		case collTy.IsListType():
+			if keyTy != cty.Number && keyTy != cty.DynamicPseudoType {
+				return cty.NilType, fmt.Errorf("key for list must be number")
+			}
+
+			return collTy.ElementType(), nil
+
+		case collTy.IsMapType():
+			if keyTy != cty.String && keyTy != cty.DynamicPseudoType {
+				return cty.NilType, fmt.Errorf("key for map must be string")
+			}
+
+			return collTy.ElementType(), nil
+
+		default:
+			return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+		}
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		has, err := HasIndex(args[0], args[1])
+		if err != nil {
+			return cty.NilVal, err
+		}
+		if has.False() { // safe because collection and key are guaranteed known here
+			return cty.NilVal, fmt.Errorf("invalid index")
+		}
+
+		return args[0].Index(args[1]), nil
+	},
+})
+
+var LengthFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "collection",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		collTy := args[0].Type()
+		if !(collTy.IsTupleType() || collTy.IsListType() || collTy.IsMapType() || collTy.IsSetType() || collTy == cty.DynamicPseudoType) {
+			return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+		}
+		return cty.Number, nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].Length(), nil
+	},
+})
+
+// HasIndex determines whether the given collection can be indexed with the
+// given key.
+func HasIndex(collection cty.Value, key cty.Value) (cty.Value, error) {
+	return HasIndexFunc.Call([]cty.Value{collection, key})
+}
+
+// Index returns an element from the given collection using the given key,
+// or returns an error if there is no element for the given key.
+func Index(collection cty.Value, key cty.Value) (cty.Value, error) {
+	return IndexFunc.Call([]cty.Value{collection, key})
+}
+
+// Length returns the number of elements in the given collection.
+func Length(collection cty.Value) (cty.Value, error) {
+	return LengthFunc.Call([]cty.Value{collection})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go
new file mode 100644
index 00000000..5070a5ad
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go
@@ -0,0 +1,93 @@
+package stdlib
+
+import (
+	"encoding/csv"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var CSVDecodeFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "str",
+			Type: cty.String,
+		},
+	},
+	Type: func(args []cty.Value) (cty.Type, error) {
+		str := args[0]
+		if !str.IsKnown() {
+			return cty.DynamicPseudoType, nil
+		}
+
+		r := strings.NewReader(str.AsString())
+		cr := csv.NewReader(r)
+		headers, err := cr.Read()
+		if err == io.EOF {
+			return cty.DynamicPseudoType, fmt.Errorf("missing header line")
+		}
+		if err != nil {
+			return cty.DynamicPseudoType, err
+		}
+
+		atys := make(map[string]cty.Type, len(headers))
+		for _, name := range headers {
+			if _, exists := atys[name]; exists {
+				return cty.DynamicPseudoType, fmt.Errorf("duplicate column name %q", name)
+			}
+			atys[name] = cty.String
+		}
+		return cty.List(cty.Object(atys)), nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		ety := retType.ElementType()
+		atys := ety.AttributeTypes()
+		str := args[0]
+		r := strings.NewReader(str.AsString())
+		cr := csv.NewReader(r)
+		cr.FieldsPerRecord = len(atys)
+
+		// Read the header row first, since that'll tell us which indices
+		// map to which attribute names.
+		headers, err := cr.Read()
+		if err != nil {
+			return cty.DynamicVal, err
+		}
+
+		var rows []cty.Value
+		for {
+			cols, err := cr.Read()
+			if err == io.EOF {
+				break
+			}
+			if err != nil {
+				return cty.DynamicVal, err
+			}
+
+			vals := make(map[string]cty.Value, len(cols))
+			for i, str := range cols {
+				name := headers[i]
+				vals[name] = cty.StringVal(str)
+			}
+			rows = append(rows, cty.ObjectVal(vals))
+		}
+
+		if len(rows) == 0 {
+			return cty.ListValEmpty(ety), nil
+		}
+		return cty.ListVal(rows), nil
+	},
+})
+
+// CSVDecode parses the given CSV (RFC 4180) string and, if it is valid,
+// returns a list of objects representing the rows.
+//
+// The result is always a list of some object type. The first row of the
+// input is used to determine the object attributes, and subsequent rows
+// determine the values of those attributes.
+func CSVDecode(str cty.Value) (cty.Value, error) {
+	return CSVDecodeFunc.Call([]cty.Value{str})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go
new file mode 100644
index 00000000..aa15b7bd
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go
@@ -0,0 +1,385 @@
+package stdlib
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var FormatDateFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "format",
+			Type: cty.String,
+		},
+		{
+			Name: "time",
+			Type: cty.String,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		formatStr := args[0].AsString()
+		timeStr := args[1].AsString()
+		t, err := parseTimestamp(timeStr)
+		if err != nil {
+			return cty.DynamicVal, function.NewArgError(1, err)
+		}
+
+		var buf bytes.Buffer
+		sc := bufio.NewScanner(strings.NewReader(formatStr))
+		sc.Split(splitDateFormat)
+		const esc = '\''
+		for sc.Scan() {
+			tok := sc.Bytes()
+
+			// The leading byte signals the token type
+			switch {
+			case tok[0] == esc:
+				if tok[len(tok)-1] != esc || len(tok) == 1 {
+					return cty.DynamicVal, function.NewArgErrorf(0, "unterminated literal '")
+				}
+				if len(tok) == 2 {
+					// Must be a single escaped quote, ''
+					buf.WriteByte(esc)
+				} else {
+					// The content (until a closing esc) is printed out verbatim
+					// except that we must un-double any double-esc escapes in
+					// the middle of the string.
+					raw := tok[1 : len(tok)-1]
+					for i := 0; i < len(raw); i++ {
+						buf.WriteByte(raw[i])
+						if raw[i] == esc {
+							i++ // skip the escaped quote
+						}
+					}
+				}
+
+			case startsDateFormatVerb(tok[0]):
+				switch tok[0] {
+				case 'Y':
+					y := t.Year()
+					switch len(tok) {
+					case 2:
+						fmt.Fprintf(&buf, "%02d", y%100)
+					case 4:
+						fmt.Fprintf(&buf, "%04d", y)
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: year must either be \"YY\" or \"YYYY\"", tok)
+					}
+				case 'M':
+					m := t.Month()
+					switch len(tok) {
+					case 1:
+						fmt.Fprintf(&buf, "%d", m)
+					case 2:
+						fmt.Fprintf(&buf, "%02d", m)
+					case 3:
+						buf.WriteString(m.String()[:3])
+					case 4:
+						buf.WriteString(m.String())
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: month must be \"M\", \"MM\", \"MMM\", or \"MMMM\"", tok)
+					}
+				case 'D':
+					d := t.Day()
+					switch len(tok) {
+					case 1:
+						fmt.Fprintf(&buf, "%d", d)
+					case 2:
+						fmt.Fprintf(&buf, "%02d", d)
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: day of month must either be \"D\" or \"DD\"", tok)
+					}
+				case 'E':
+					d := t.Weekday()
+					switch len(tok) {
+					case 3:
+						buf.WriteString(d.String()[:3])
+					case 4:
+						buf.WriteString(d.String())
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: day of week must either be \"EEE\" or \"EEEE\"", tok)
+					}
+				case 'h':
+					h := t.Hour()
+					switch len(tok) {
+					case 1:
+						fmt.Fprintf(&buf, "%d", h)
+					case 2:
+						fmt.Fprintf(&buf, "%02d", h)
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: 24-hour must either be \"h\" or \"hh\"", tok)
+					}
+				case 'H':
+					h := t.Hour() % 12
+					if h == 0 {
+						h = 12
+					}
+					switch len(tok) {
+					case 1:
+						fmt.Fprintf(&buf, "%d", h)
+					case 2:
+						fmt.Fprintf(&buf, "%02d", h)
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: 12-hour must either be \"H\" or \"HH\"", tok)
+					}
+				case 'A', 'a':
+					if len(tok) != 2 {
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: must be \"%s%s\"", tok, tok[0:1], tok[0:1])
+					}
+					upper := tok[0] == 'A'
+					switch t.Hour() / 12 {
+					case 0:
+						if upper {
+							buf.WriteString("AM")
+						} else {
+							buf.WriteString("am")
+						}
+					case 1:
+						if upper {
+							buf.WriteString("PM")
+						} else {
+							buf.WriteString("pm")
+						}
+					}
+				case 'm':
+					m := t.Minute()
+					switch len(tok) {
+					case 1:
+						fmt.Fprintf(&buf, "%d", m)
+					case 2:
+						fmt.Fprintf(&buf, "%02d", m)
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: minute must either be \"m\" or \"mm\"", tok)
+					}
+				case 's':
+					s := t.Second()
+					switch len(tok) {
+					case 1:
+						fmt.Fprintf(&buf, "%d", s)
+					case 2:
+						fmt.Fprintf(&buf, "%02d", s)
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: second must either be \"s\" or \"ss\"", tok)
+					}
+				case 'Z':
+					// We'll just lean on Go's own formatter for this one, since
+					// the necessary information is unexported.
+					switch len(tok) {
+					case 1:
+						buf.WriteString(t.Format("Z07:00"))
+					case 3:
+						str := t.Format("-0700")
+						switch str {
+						case "+0000":
+							buf.WriteString("UTC")
+						default:
+							buf.WriteString(str)
+						}
+					case 4:
+						buf.WriteString(t.Format("-0700"))
+					case 5:
+						buf.WriteString(t.Format("-07:00"))
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: timezone must be Z, ZZZZ, or ZZZZZ", tok)
+					}
+				default:
+					return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q", tok)
+				}
+
+			default:
+				// Any other starting character indicates a literal sequence
+				buf.Write(tok)
+			}
+		}
+
+		return cty.StringVal(buf.String()), nil
+	},
+})
+
+// FormatDate reformats a timestamp given in RFC3339 syntax into another time
+// syntax defined by a given format string.
+//
+// The format string uses letter mnemonics to represent portions of the
+// timestamp, with repetition signifying length variants of each portion.
+// Single quote characters ' can be used to quote sequences of literal letters
+// that should not be interpreted as formatting mnemonics.
+//
+// The full set of supported mnemonic sequences is listed below:
+//
+//     YY       Year modulo 100 zero-padded to two digits, like "06".
+//     YYYY     Four (or more) digit year, like "2006".
+//     M        Month number, like "1" for January.
+//     MM       Month number zero-padded to two digits, like "01".
+//     MMM      English month name abbreviated to three letters, like "Jan".
+//     MMMM     English month name unabbreviated, like "January".
+//     D        Day of month number, like "2".
+//     DD       Day of month number zero-padded to two digits, like "02".
+//     EEE      English day of week name abbreviated to three letters, like "Mon".
+//     EEEE     English day of week name unabbreviated, like "Monday".
+//     h        24-hour number, like "2".
+//     hh       24-hour number zero-padded to two digits, like "02".
+//     H        12-hour number, like "2".
+//     HH       12-hour number zero-padded to two digits, like "02".
+//     AA       Hour AM/PM marker in uppercase, like "AM".
+//     aa       Hour AM/PM marker in lowercase, like "am".
+//     m        Minute within hour, like "5".
+//     mm       Minute within hour zero-padded to two digits, like "05".
+//     s        Second within minute, like "9".
+//     ss       Second within minute zero-padded to two digits, like "09".
+//     ZZZZ     Timezone offset with just sign and digit, like "-0800".
+//     ZZZZZ    Timezone offset with colon separating hours and minutes, like "-08:00".
+//     Z        Like ZZZZZ but with a special case "Z" for UTC.
+//     ZZZ      Like ZZZZ but with a special case "UTC" for UTC.
+//
+// The format syntax is optimized mainly for generating machine-oriented
+// timestamps rather than human-oriented timestamps; the English language
+// portions of the output reflect the use of English names in a number of
+// machine-readable date formatting standards. For presentation to humans,
+// a locale-aware time formatter (not included in this package) is a better
+// choice.
+//
+// The format syntax is not compatible with that of any other language, but
+// is optimized so that patterns for common standard date formats can be
+// recognized quickly even by a reader unfamiliar with the format syntax.
+func FormatDate(format cty.Value, timestamp cty.Value) (cty.Value, error) {
+	return FormatDateFunc.Call([]cty.Value{format, timestamp})
+}
+
+func parseTimestamp(ts string) (time.Time, error) {
+	t, err := time.Parse(time.RFC3339, ts)
+	if err != nil {
+		switch err := err.(type) {
+		case *time.ParseError:
+			// If err is s time.ParseError then its string representation is not
+			// appropriate since it relies on details of Go's strange date format
+			// representation, which a caller of our functions is not expected
+			// to be familiar with.
+			//
+			// Therefore we do some light transformation to get a more suitable
+			// error that should make more sense to our callers. These are
+			// still not awesome error messages, but at least they refer to
+			// the timestamp portions by name rather than by Go's example
+			// values.
+			if err.LayoutElem == "" && err.ValueElem == "" && err.Message != "" {
+				// For some reason err.Message is populated with a ": " prefix
+				// by the time package.
+				return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp%s", err.Message)
+			}
+			var what string
+			switch err.LayoutElem {
+			case "2006":
+				what = "year"
+			case "01":
+				what = "month"
+			case "02":
+				what = "day of month"
+			case "15":
+				what = "hour"
+			case "04":
+				what = "minute"
+			case "05":
+				what = "second"
+			case "Z07:00":
+				what = "UTC offset"
+			case "T":
+				return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: missing required time introducer 'T'")
+			case ":", "-":
+				if err.ValueElem == "" {
+					return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: end of string where %q is expected", err.LayoutElem)
+				} else {
+					return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: found %q where %q is expected", err.ValueElem, err.LayoutElem)
+				}
+			default:
+				// Should never get here, because time.RFC3339 includes only the
+				// above portions, but since that might change in future we'll
+				// be robust here.
+				what = "timestamp segment"
+			}
+			if err.ValueElem == "" {
+				return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: end of string before %s", what)
+			} else {
+				return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: cannot use %q as %s", err.ValueElem, what)
+			}
+		}
+		return time.Time{}, err
+	}
+	return t, nil
+}
+
+// splitDataFormat is a bufio.SplitFunc used to tokenize a date format.
+func splitDateFormat(data []byte, atEOF bool) (advance int, token []byte, err error) {
+	if len(data) == 0 {
+		return 0, nil, nil
+	}
+
+	const esc = '\''
+
+	switch {
+
+	case data[0] == esc:
+		// If we have another quote immediately after then this is a single
+		// escaped escape.
+		if len(data) > 1 && data[1] == esc {
+			return 2, data[:2], nil
+		}
+
+		// Beginning of quoted sequence, so we will seek forward until we find
+		// the closing quote, ignoring escaped quotes along the way.
+		for i := 1; i < len(data); i++ {
+			if data[i] == esc {
+				if (i + 1) == len(data) {
+					// We need at least one more byte to decide if this is an
+					// escape or a terminator.
+					return 0, nil, nil
+				}
+				if data[i+1] == esc {
+					i++ // doubled-up quotes are an escape sequence
+					continue
+				}
+				// We've found the closing quote
+				return i + 1, data[:i+1], nil
+			}
+		}
+		// If we fall out here then we need more bytes to find the end,
+		// unless we're already at the end with an unclosed quote.
+		if atEOF {
+			return len(data), data, nil
+		}
+		return 0, nil, nil
+
+	case startsDateFormatVerb(data[0]):
+		rep := data[0]
+		for i := 1; i < len(data); i++ {
+			if data[i] != rep {
+				return i, data[:i], nil
+			}
+		}
+		if atEOF {
+			return len(data), data, nil
+		}
+		// We need more data to decide if we've found the end
+		return 0, nil, nil
+
+	default:
+		for i := 1; i < len(data); i++ {
+			if data[i] == esc || startsDateFormatVerb(data[i]) {
+				return i, data[:i], nil
+			}
+		}
+		// We might not actually be at the end of a literal sequence,
+		// but that doesn't matter since we'll concat them back together
+		// anyway.
+		return len(data), data, nil
+	}
+}
+
+func startsDateFormatVerb(b byte) bool {
+	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go
new file mode 100644
index 00000000..cfb613e5
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go
@@ -0,0 +1,13 @@
+// Package stdlib is a collection of cty functions that are expected to be
+// generally useful, and are thus factored out into this shared library in
+// the hope that cty-using applications will have consistent behavior when
+// using these functions.
+//
+// See the parent package "function" for more information on the purpose
+// and usage of cty functions.
+//
+// This package contains both Go functions, which provide convenient access
+// to call the functions from Go code, and the Function objects themselves.
+// The latter follow the naming scheme of appending "Func" to the end of
+// the function name.
+package stdlib
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
new file mode 100644
index 00000000..834e9b6f
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
@@ -0,0 +1,517 @@
+package stdlib
+
+import (
+	"bytes"
+	"fmt"
+	"math/big"
+	"strings"
+
+	"github.com/apparentlymart/go-textseg/textseg"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/json"
+)
+
+//go:generate ragel -Z format_fsm.rl
+//go:generate gofmt -w format_fsm.go
+
+var FormatFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "format",
+			Type: cty.String,
+		},
+	},
+	VarParam: &function.Parameter{
+		Name:      "args",
+		Type:      cty.DynamicPseudoType,
+		AllowNull: true,
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		for _, arg := range args[1:] {
+			if !arg.IsWhollyKnown() {
+				// We require all nested values to be known because the only
+				// thing we can do for a collection/structural type is print
+				// it as JSON and that requires it to be wholly known.
+				return cty.UnknownVal(cty.String), nil
+			}
+		}
+		str, err := formatFSM(args[0].AsString(), args[1:])
+		return cty.StringVal(str), err
+	},
+})
+
+var FormatListFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "format",
+			Type: cty.String,
+		},
+	},
+	VarParam: &function.Parameter{
+		Name:         "args",
+		Type:         cty.DynamicPseudoType,
+		AllowNull:    true,
+		AllowUnknown: true,
+	},
+	Type: function.StaticReturnType(cty.List(cty.String)),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		fmtVal := args[0]
+		args = args[1:]
+
+		if len(args) == 0 {
+			// With no arguments, this function is equivalent to Format, but
+			// returning a single-element list result.
+			result, err := Format(fmtVal, args...)
+			return cty.ListVal([]cty.Value{result}), err
+		}
+
+		fmtStr := fmtVal.AsString()
+
+		// Each of our arguments will be dealt with either as an iterator
+		// or as a single value. Iterators are used for sequence-type values
+		// (lists, sets, tuples) while everything else is treated as a
+		// single value. The sequences we iterate over are required to be
+		// all the same length.
+		iterLen := -1
+		lenChooser := -1
+		iterators := make([]cty.ElementIterator, len(args))
+		singleVals := make([]cty.Value, len(args))
+		unknowns := make([]bool, len(args))
+		for i, arg := range args {
+			argTy := arg.Type()
+			switch {
+			case (argTy.IsListType() || argTy.IsSetType() || argTy.IsTupleType()) && !arg.IsNull():
+				if !argTy.IsTupleType() && !arg.IsKnown() {
+					// We can't iterate this one at all yet then, so we can't
+					// yet produce a result.
+					unknowns[i] = true
+					continue
+				}
+				thisLen := arg.LengthInt()
+				if iterLen == -1 {
+					iterLen = thisLen
+					lenChooser = i
+				} else {
+					if thisLen != iterLen {
+						return cty.NullVal(cty.List(cty.String)), function.NewArgErrorf(
+							i+1,
+							"argument %d has length %d, which is inconsistent with argument %d of length %d",
+							i+1, thisLen,
+							lenChooser+1, iterLen,
+						)
+					}
+				}
+				if !arg.IsKnown() {
+					// We allowed an unknown tuple value to fall through in
+					// our initial check above so that we'd be able to run
+					// the above error checks against it, but we still can't
+					// iterate it if the checks pass.
+					unknowns[i] = true
+					continue
+				}
+				iterators[i] = arg.ElementIterator()
+			default:
+				singleVals[i] = arg
+			}
+		}
+
+		for _, isUnk := range unknowns {
+			if isUnk {
+				return cty.UnknownVal(retType), nil
+			}
+		}
+
+		if iterLen == 0 {
+			// If our sequences are all empty then our result must be empty.
+			return cty.ListValEmpty(cty.String), nil
+		}
+
+		if iterLen == -1 {
+			// If we didn't encounter any iterables at all then we're going
+			// to just do one iteration with items from singleVals.
+			iterLen = 1
+		}
+
+		ret := make([]cty.Value, 0, iterLen)
+		fmtArgs := make([]cty.Value, len(iterators))
+	Results:
+		for iterIdx := 0; iterIdx < iterLen; iterIdx++ {
+
+			// Construct our arguments for a single format call
+			for i := range fmtArgs {
+				switch {
+				case iterators[i] != nil:
+					iterator := iterators[i]
+					iterator.Next()
+					_, val := iterator.Element()
+					fmtArgs[i] = val
+				default:
+					fmtArgs[i] = singleVals[i]
+				}
+
+				// If any of the arguments to this call would be unknown then
+				// this particular result is unknown, but we'll keep going
+				// to see if any other iterations can produce known values.
+				if !fmtArgs[i].IsWhollyKnown() {
+					// We require all nested values to be known because the only
+					// thing we can do for a collection/structural type is print
+					// it as JSON and that requires it to be wholly known.
+					ret = append(ret, cty.UnknownVal(cty.String))
+					continue Results
+				}
+			}
+
+			str, err := formatFSM(fmtStr, fmtArgs)
+			if err != nil {
+				return cty.NullVal(cty.List(cty.String)), fmt.Errorf(
+					"error on format iteration %d: %s", iterIdx, err,
+				)
+			}
+
+			ret = append(ret, cty.StringVal(str))
+		}
+
+		return cty.ListVal(ret), nil
+	},
+})
+
+// Format produces a string representation of zero or more values using a
+// format string similar to the "printf" function in C.
+//
+// It supports the following "verbs":
+//
+//     %%      Literal percent sign, consuming no value
+//     %v      A default formatting of the value based on type, as described below.
+//     %#v     JSON serialization of the value
+//     %t      Converts to boolean and then produces "true" or "false"
+//     %b      Converts to number, requires integer, produces binary representation
+//     %d      Converts to number, requires integer, produces decimal representation
+//     %o      Converts to number, requires integer, produces octal representation
+//     %x      Converts to number, requires integer, produces hexadecimal representation
+//             with lowercase letters
+//     %X      Like %x but with uppercase letters
+//     %e      Converts to number, produces scientific notation like -1.234456e+78
+//     %E      Like %e but with an uppercase "E" representing the exponent
+//     %f      Converts to number, produces decimal representation with fractional
+//             part but no exponent, like 123.456
+//     %g      %e for large exponents or %f otherwise
+//     %G      %E for large exponents or %f otherwise
+//     %s      Converts to string and produces the string's characters
+//     %q      Converts to string and produces JSON-quoted string representation,
+//             like %v.
+//
+// The default format selections made by %v are:
+//
+//     string  %s
+//     number  %g
+//     bool    %t
+//     other   %#v
+//
+// Null values produce the literal keyword "null" for %v and %#v, and produce
+// an error otherwise.
+//
+// Width is specified by an optional decimal number immediately preceding the
+// verb letter. If absent, the width is whatever is necessary to represent the
+// value. Precision is specified after the (optional) width by a period
+// followed by a decimal number. If no period is present, a default precision
+// is used. A period with no following number is invalid.
+// For examples:
+//
+//     %f     default width, default precision
+//     %9f    width 9, default precision
+//     %.2f   default width, precision 2
+//     %9.2f  width 9, precision 2
+//
+// Width and precision are measured in unicode characters (grapheme clusters).
+//
+// For most values, width is the minimum number of characters to output,
+// padding the formatted form with spaces if necessary.
+//
+// For strings, precision limits the length of the input to be formatted (not
+// the size of the output), truncating if necessary.
+//
+// For numbers, width sets the minimum width of the field and precision sets
+// the number of places after the decimal, if appropriate, except that for
+// %g/%G precision sets the total number of significant digits.
+//
+// The following additional symbols can be used immediately after the percent
+// introducer as flags:
+//
+//           (a space) leave a space where the sign would be if number is positive
+//     +     Include a sign for a number even if it is positive (numeric only)
+//     -     Pad with spaces on the left rather than the right
+//     0     Pad with zeros rather than spaces.
+//
+// Flag characters are ignored for verbs that do not support them.
+//
+// By default, % sequences consume successive arguments starting with the first.
+// Introducing a [n] sequence immediately before the verb letter, where n is a
+// decimal integer, explicitly chooses a particular value argument by its
+// one-based index. Subsequent calls without an explicit index will then
+// proceed with n+1, n+2, etc.
+//
+// An error is produced if the format string calls for an impossible conversion
+// or accesses more values than are given. An error is produced also for
+// an unsupported format verb.
+func Format(format cty.Value, vals ...cty.Value) (cty.Value, error) {
+	args := make([]cty.Value, 0, len(vals)+1)
+	args = append(args, format)
+	args = append(args, vals...)
+	return FormatFunc.Call(args)
+}
+
+// FormatList applies the same formatting behavior as Format, but accepts
+// a mixture of list and non-list values as arguments. Any list arguments
+// passed must have the same length, which dictates the length of the
+// resulting list.
+//
+// Any non-list arguments are used repeatedly for each iteration over the
+// list arguments. The list arguments are iterated in order by key, so
+// corresponding items are formatted together.
+func FormatList(format cty.Value, vals ...cty.Value) (cty.Value, error) {
+	args := make([]cty.Value, 0, len(vals)+1)
+	args = append(args, format)
+	args = append(args, vals...)
+	return FormatListFunc.Call(args)
+}
+
+type formatVerb struct {
+	Raw    string
+	Offset int
+
+	ArgNum int
+	Mode   rune
+
+	Zero  bool
+	Sharp bool
+	Plus  bool
+	Minus bool
+	Space bool
+
+	HasPrec bool
+	Prec    int
+
+	HasWidth bool
+	Width    int
+}
+
+// formatAppend is called by formatFSM (generated by format_fsm.rl) for each
+// formatting sequence that is encountered.
+func formatAppend(verb *formatVerb, buf *bytes.Buffer, args []cty.Value) error {
+	argIdx := verb.ArgNum - 1
+	if argIdx >= len(args) {
+		return fmt.Errorf(
+			"not enough arguments for %q at %d: need index %d but have %d total",
+			verb.Raw, verb.Offset,
+			verb.ArgNum, len(args),
+		)
+	}
+	arg := args[argIdx]
+
+	if verb.Mode != 'v' && arg.IsNull() {
+		return fmt.Errorf("unsupported value for %q at %d: null value cannot be formatted", verb.Raw, verb.Offset)
+	}
+
+	// Normalize to make some things easier for downstream formatters
+	if !verb.HasWidth {
+		verb.Width = -1
+	}
+	if !verb.HasPrec {
+		verb.Prec = -1
+	}
+
+	// For our first pass we'll ensure the verb is supported and then fan
+	// out to other functions based on what conversion is needed.
+	switch verb.Mode {
+
+	case 'v':
+		return formatAppendAsIs(verb, buf, arg)
+
+	case 't':
+		return formatAppendBool(verb, buf, arg)
+
+	case 'b', 'd', 'o', 'x', 'X', 'e', 'E', 'f', 'g', 'G':
+		return formatAppendNumber(verb, buf, arg)
+
+	case 's', 'q':
+		return formatAppendString(verb, buf, arg)
+
+	default:
+		return fmt.Errorf("unsupported format verb %q in %q at offset %d", verb.Mode, verb.Raw, verb.Offset)
+	}
+}
+
+func formatAppendAsIs(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+
+	if !verb.Sharp && !arg.IsNull() {
+		// Unless the caller overrode it with the sharp flag, we'll try some
+		// specialized formats before we fall back on JSON.
+		switch arg.Type() {
+		case cty.String:
+			fmted := arg.AsString()
+			fmted = formatPadWidth(verb, fmted)
+			buf.WriteString(fmted)
+			return nil
+		case cty.Number:
+			bf := arg.AsBigFloat()
+			fmted := bf.Text('g', -1)
+			fmted = formatPadWidth(verb, fmted)
+			buf.WriteString(fmted)
+			return nil
+		}
+	}
+
+	jb, err := json.Marshal(arg, arg.Type())
+	if err != nil {
+		return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+	}
+	fmted := formatPadWidth(verb, string(jb))
+	buf.WriteString(fmted)
+
+	return nil
+}
+
+func formatAppendBool(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+	var err error
+	arg, err = convert.Convert(arg, cty.Bool)
+	if err != nil {
+		return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+	}
+
+	if arg.True() {
+		buf.WriteString("true")
+	} else {
+		buf.WriteString("false")
+	}
+	return nil
+}
+
+func formatAppendNumber(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+	var err error
+	arg, err = convert.Convert(arg, cty.Number)
+	if err != nil {
+		return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+	}
+
+	switch verb.Mode {
+	case 'b', 'd', 'o', 'x', 'X':
+		return formatAppendInteger(verb, buf, arg)
+	default:
+		bf := arg.AsBigFloat()
+
+		// For floats our format syntax is a subset of Go's, so it's
+		// safe for us to just lean on the existing Go implementation.
+		fmtstr := formatStripIndexSegment(verb.Raw)
+		fmted := fmt.Sprintf(fmtstr, bf)
+		buf.WriteString(fmted)
+		return nil
+	}
+}
+
+func formatAppendInteger(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+	bf := arg.AsBigFloat()
+	bi, acc := bf.Int(nil)
+	if acc != big.Exact {
+		return fmt.Errorf("unsupported value for %q at %d: an integer is required", verb.Raw, verb.Offset)
+	}
+
+	// For integers our format syntax is a subset of Go's, so it's
+	// safe for us to just lean on the existing Go implementation.
+	fmtstr := formatStripIndexSegment(verb.Raw)
+	fmted := fmt.Sprintf(fmtstr, bi)
+	buf.WriteString(fmted)
+	return nil
+}
+
+func formatAppendString(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+	var err error
+	arg, err = convert.Convert(arg, cty.String)
+	if err != nil {
+		return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+	}
+
+	// We _cannot_ directly use the Go fmt.Sprintf implementation for strings
+	// because it measures widths and precisions in runes rather than grapheme
+	// clusters.
+
+	str := arg.AsString()
+	if verb.Prec > 0 {
+		strB := []byte(str)
+		pos := 0
+		wanted := verb.Prec
+		for i := 0; i < wanted; i++ {
+			next := strB[pos:]
+			if len(next) == 0 {
+				// ran out of characters before we hit our max width
+				break
+			}
+			d, _, _ := textseg.ScanGraphemeClusters(strB[pos:], true)
+			pos += d
+		}
+		str = str[:pos]
+	}
+
+	switch verb.Mode {
+	case 's':
+		fmted := formatPadWidth(verb, str)
+		buf.WriteString(fmted)
+	case 'q':
+		jb, err := json.Marshal(cty.StringVal(str), cty.String)
+		if err != nil {
+			// Should never happen, since we know this is a known, non-null string
+			panic(fmt.Errorf("failed to marshal %#v as JSON: %s", arg, err))
+		}
+		fmted := formatPadWidth(verb, string(jb))
+		buf.WriteString(fmted)
+	default:
+		// Should never happen because formatAppend should've already validated
+		panic(fmt.Errorf("invalid string formatting mode %q", verb.Mode))
+	}
+	return nil
+}
+
+func formatPadWidth(verb *formatVerb, fmted string) string {
+	if verb.Width < 0 {
+		return fmted
+	}
+
+	// Safe to ignore errors because ScanGraphemeClusters cannot produce errors
+	givenLen, _ := textseg.TokenCount([]byte(fmted), textseg.ScanGraphemeClusters)
+	wantLen := verb.Width
+	if givenLen >= wantLen {
+		return fmted
+	}
+
+	padLen := wantLen - givenLen
+	padChar := " "
+	if verb.Zero {
+		padChar = "0"
+	}
+	pads := strings.Repeat(padChar, padLen)
+
+	if verb.Minus {
+		return fmted + pads
+	}
+	return pads + fmted
+}
+
+// formatStripIndexSegment strips out any [nnn] segment present in a verb
+// string so that we can pass it through to Go's fmt.Sprintf with a single
+// argument. This is used in cases where we're just leaning on Go's formatter
+// because it's a superset of ours.
+func formatStripIndexSegment(rawVerb string) string {
+	// We assume the string has already been validated here, since we should
+	// only be using this function with strings that were accepted by our
+	// scanner in formatFSM.
+	start := strings.Index(rawVerb, "[")
+	end := strings.Index(rawVerb, "]")
+	if start == -1 || end == -1 {
+		return rawVerb
+	}
+
+	return rawVerb[:start] + rawVerb[end+1:]
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
new file mode 100644
index 00000000..32b1ac97
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
@@ -0,0 +1,374 @@
+// line 1 "format_fsm.rl"
+// This file is generated from format_fsm.rl. DO NOT EDIT.
+
+// line 5 "format_fsm.rl"
+
+package stdlib
+
+import (
+	"bytes"
+	"fmt"
+	"unicode/utf8"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+// line 21 "format_fsm.go"
+var _formatfsm_actions []byte = []byte{
+	0, 1, 0, 1, 1, 1, 2, 1, 4,
+	1, 5, 1, 6, 1, 7, 1, 8,
+	1, 9, 1, 10, 1, 11, 1, 14,
+	1, 16, 1, 17, 1, 18, 2, 3,
+	4, 2, 12, 10, 2, 12, 16, 2,
+	12, 18, 2, 13, 14, 2, 15, 10,
+	2, 15, 18,
+}
+
+var _formatfsm_key_offsets []byte = []byte{
+	0, 0, 14, 27, 34, 36, 39, 43,
+	51,
+}
+
+var _formatfsm_trans_keys []byte = []byte{
+	32, 35, 37, 43, 45, 46, 48, 91,
+	49, 57, 65, 90, 97, 122, 32, 35,
+	43, 45, 46, 48, 91, 49, 57, 65,
+	90, 97, 122, 91, 48, 57, 65, 90,
+	97, 122, 49, 57, 93, 48, 57, 65,
+	90, 97, 122, 46, 91, 48, 57, 65,
+	90, 97, 122, 37,
+}
+
+var _formatfsm_single_lengths []byte = []byte{
+	0, 8, 7, 1, 0, 1, 0, 2,
+	1,
+}
+
+var _formatfsm_range_lengths []byte = []byte{
+	0, 3, 3, 3, 1, 1, 2, 3,
+	0,
+}
+
+var _formatfsm_index_offsets []byte = []byte{
+	0, 0, 12, 23, 28, 30, 33, 36,
+	42,
+}
+
+var _formatfsm_indicies []byte = []byte{
+	1, 2, 3, 4, 5, 6, 7, 10,
+	8, 9, 9, 0, 1, 2, 4, 5,
+	6, 7, 10, 8, 9, 9, 0, 13,
+	11, 12, 12, 0, 14, 0, 15, 14,
+	0, 9, 9, 0, 16, 19, 17, 18,
+	18, 0, 20, 3,
+}
+
+var _formatfsm_trans_targs []byte = []byte{
+	0, 2, 2, 8, 2, 2, 3, 2,
+	7, 8, 4, 3, 8, 4, 5, 6,
+	3, 7, 8, 4, 1,
+}
+
+var _formatfsm_trans_actions []byte = []byte{
+	7, 17, 9, 3, 15, 13, 25, 11,
+	43, 29, 19, 27, 49, 46, 21, 0,
+	37, 23, 40, 34, 1,
+}
+
+var _formatfsm_eof_actions []byte = []byte{
+	0, 31, 31, 31, 31, 31, 31, 31,
+	5,
+}
+
+const formatfsm_start int = 8
+const formatfsm_first_final int = 8
+const formatfsm_error int = 0
+
+const formatfsm_en_main int = 8
+
+// line 20 "format_fsm.rl"
+
+func formatFSM(format string, a []cty.Value) (string, error) {
+	var buf bytes.Buffer
+	data := format
+	nextArg := 1 // arg numbers are 1-based
+	var verb formatVerb
+	highestArgIdx := 0 // zero means "none", since arg numbers are 1-based
+
+	// line 159 "format_fsm.rl"
+
+	// Ragel state
+	p := 0          // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+	cs := 0         // current state (will be initialized by ragel-generated code)
+	ts := 0
+	te := 0
+	eof := pe
+
+	// Keep Go compiler happy even if generated code doesn't use these
+	_ = ts
+	_ = te
+	_ = eof
+
+	// line 123 "format_fsm.go"
+	{
+		cs = formatfsm_start
+	}
+
+	// line 128 "format_fsm.go"
+	{
+		var _klen int
+		var _trans int
+		var _acts int
+		var _nacts uint
+		var _keys int
+		if p == pe {
+			goto _test_eof
+		}
+		if cs == 0 {
+			goto _out
+		}
+	_resume:
+		_keys = int(_formatfsm_key_offsets[cs])
+		_trans = int(_formatfsm_index_offsets[cs])
+
+		_klen = int(_formatfsm_single_lengths[cs])
+		if _klen > 0 {
+			_lower := int(_keys)
+			var _mid int
+			_upper := int(_keys + _klen - 1)
+			for {
+				if _upper < _lower {
+					break
+				}
+
+				_mid = _lower + ((_upper - _lower) >> 1)
+				switch {
+				case data[p] < _formatfsm_trans_keys[_mid]:
+					_upper = _mid - 1
+				case data[p] > _formatfsm_trans_keys[_mid]:
+					_lower = _mid + 1
+				default:
+					_trans += int(_mid - int(_keys))
+					goto _match
+				}
+			}
+			_keys += _klen
+			_trans += _klen
+		}
+
+		_klen = int(_formatfsm_range_lengths[cs])
+		if _klen > 0 {
+			_lower := int(_keys)
+			var _mid int
+			_upper := int(_keys + (_klen << 1) - 2)
+			for {
+				if _upper < _lower {
+					break
+				}
+
+				_mid = _lower + (((_upper - _lower) >> 1) & ^1)
+				switch {
+				case data[p] < _formatfsm_trans_keys[_mid]:
+					_upper = _mid - 2
+				case data[p] > _formatfsm_trans_keys[_mid+1]:
+					_lower = _mid + 2
+				default:
+					_trans += int((_mid - int(_keys)) >> 1)
+					goto _match
+				}
+			}
+			_trans += _klen
+		}
+
+	_match:
+		_trans = int(_formatfsm_indicies[_trans])
+		cs = int(_formatfsm_trans_targs[_trans])
+
+		if _formatfsm_trans_actions[_trans] == 0 {
+			goto _again
+		}
+
+		_acts = int(_formatfsm_trans_actions[_trans])
+		_nacts = uint(_formatfsm_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _formatfsm_actions[_acts-1] {
+			case 0:
+				// line 31 "format_fsm.rl"
+
+				verb = formatVerb{
+					ArgNum: nextArg,
+					Prec:   -1,
+					Width:  -1,
+				}
+				ts = p
+
+			case 1:
+				// line 40 "format_fsm.rl"
+
+				buf.WriteByte(data[p])
+
+			case 4:
+				// line 51 "format_fsm.rl"
+
+				// We'll try to slurp a whole UTF-8 sequence here, to give the user
+				// better feedback.
+				r, _ := utf8.DecodeRuneInString(data[p:])
+				return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
+
+			case 5:
+				// line 58 "format_fsm.rl"
+
+				verb.Sharp = true
+
+			case 6:
+				// line 61 "format_fsm.rl"
+
+				verb.Zero = true
+
+			case 7:
+				// line 64 "format_fsm.rl"
+
+				verb.Minus = true
+
+			case 8:
+				// line 67 "format_fsm.rl"
+
+				verb.Plus = true
+
+			case 9:
+				// line 70 "format_fsm.rl"
+
+				verb.Space = true
+
+			case 10:
+				// line 74 "format_fsm.rl"
+
+				verb.ArgNum = 0
+
+			case 11:
+				// line 77 "format_fsm.rl"
+
+				verb.ArgNum = (10 * verb.ArgNum) + (int(data[p]) - '0')
+
+			case 12:
+				// line 81 "format_fsm.rl"
+
+				verb.HasWidth = true
+
+			case 13:
+				// line 84 "format_fsm.rl"
+
+				verb.Width = 0
+
+			case 14:
+				// line 87 "format_fsm.rl"
+
+				verb.Width = (10 * verb.Width) + (int(data[p]) - '0')
+
+			case 15:
+				// line 91 "format_fsm.rl"
+
+				verb.HasPrec = true
+
+			case 16:
+				// line 94 "format_fsm.rl"
+
+				verb.Prec = 0
+
+			case 17:
+				// line 97 "format_fsm.rl"
+
+				verb.Prec = (10 * verb.Prec) + (int(data[p]) - '0')
+
+			case 18:
+				// line 101 "format_fsm.rl"
+
+				verb.Mode = rune(data[p])
+				te = p + 1
+				verb.Raw = data[ts:te]
+				verb.Offset = ts
+
+				if verb.ArgNum > highestArgIdx {
+					highestArgIdx = verb.ArgNum
+				}
+
+				err := formatAppend(&verb, &buf, a)
+				if err != nil {
+					return buf.String(), err
+				}
+				nextArg = verb.ArgNum + 1
+
+				// line 330 "format_fsm.go"
+			}
+		}
+
+	_again:
+		if cs == 0 {
+			goto _out
+		}
+		p++
+		if p != pe {
+			goto _resume
+		}
+	_test_eof:
+		{
+		}
+		if p == eof {
+			__acts := _formatfsm_eof_actions[cs]
+			__nacts := uint(_formatfsm_actions[__acts])
+			__acts++
+			for ; __nacts > 0; __nacts-- {
+				__acts++
+				switch _formatfsm_actions[__acts-1] {
+				case 2:
+					// line 44 "format_fsm.rl"
+
+				case 3:
+					// line 47 "format_fsm.rl"
+
+					return buf.String(), fmt.Errorf("invalid format string starting at offset %d", p)
+
+				case 4:
+					// line 51 "format_fsm.rl"
+
+					// We'll try to slurp a whole UTF-8 sequence here, to give the user
+					// better feedback.
+					r, _ := utf8.DecodeRuneInString(data[p:])
+					return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
+
+					// line 369 "format_fsm.go"
+				}
+			}
+		}
+
+	_out:
+		{
+		}
+	}
+
+	// line 177 "format_fsm.rl"
+
+	// If we fall out here without being in a final state then we've
+	// encountered something that the scanner can't match, which should
+	// be impossible (the scanner matches all bytes _somehow_) but we'll
+	// flag it anyway rather than just losing data from the end.
+	if cs < formatfsm_first_final {
+		return buf.String(), fmt.Errorf("extraneous characters beginning at offset %d", p)
+	}
+
+	if highestArgIdx < len(a) {
+		// Extraneous args are an error, to more easily detect mistakes
+		firstBad := highestArgIdx + 1
+		if highestArgIdx == 0 {
+			// Custom error message for this case
+			return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; no verbs in format string")
+		}
+		return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; only %d used by format string", highestArgIdx)
+	}
+
+	return buf.String(), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
new file mode 100644
index 00000000..3c642d9e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
@@ -0,0 +1,198 @@
+// This file is generated from format_fsm.rl. DO NOT EDIT.
+%%{
+	# (except you are actually in scan_tokens.rl here, so edit away!)
+	machine formatfsm;
+}%%
+
+package stdlib
+
+import (
+	"bytes"
+	"fmt"
+	"unicode/utf8"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+%%{
+	write data;
+}%%
+
+func formatFSM(format string, a []cty.Value) (string, error) {
+	var buf bytes.Buffer
+	data := format
+	nextArg := 1 // arg numbers are 1-based
+	var verb formatVerb
+	highestArgIdx := 0 // zero means "none", since arg numbers are 1-based
+
+	%%{
+
+	action begin {
+		verb = formatVerb{
+			ArgNum: nextArg,
+			Prec:   -1,
+			Width:  -1,
+		}
+		ts = p
+	}
+
+	action emit {
+		buf.WriteByte(fc);
+	}
+
+	action finish_ok {
+	}
+
+	action finish_err {
+		return buf.String(), fmt.Errorf("invalid format string starting at offset %d", p)
+	}
+
+	action err_char {
+		// We'll try to slurp a whole UTF-8 sequence here, to give the user
+		// better feedback.
+		r, _ := utf8.DecodeRuneInString(data[p:])
+		return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
+	}
+
+	action flag_sharp {
+		verb.Sharp = true
+	}
+	action flag_zero {
+		verb.Zero = true
+	}
+	action flag_minus {
+		verb.Minus = true
+	}
+	action flag_plus {
+		verb.Plus = true
+	}
+	action flag_space {
+		verb.Space = true
+	}
+
+	action argidx_reset {
+		verb.ArgNum = 0
+	}
+	action argidx_num {
+		verb.ArgNum = (10 * verb.ArgNum) + (int(fc) - '0')
+	}
+
+	action has_width {
+		verb.HasWidth = true
+	}
+	action width_reset {
+		verb.Width = 0
+	}
+	action width_num {
+		verb.Width = (10 * verb.Width) + (int(fc) - '0')
+	}
+
+	action has_prec {
+		verb.HasPrec = true
+	}
+	action prec_reset {
+		verb.Prec = 0
+	}
+	action prec_num {
+		verb.Prec = (10 * verb.Prec) + (int(fc) - '0')
+	}
+
+	action mode {
+		verb.Mode = rune(fc)
+		te = p+1
+		verb.Raw = data[ts:te]
+		verb.Offset = ts
+
+		if verb.ArgNum > highestArgIdx {
+			highestArgIdx = verb.ArgNum
+		}
+
+		err := formatAppend(&verb, &buf, a)
+		if err != nil {
+			return buf.String(), err
+		}
+		nextArg = verb.ArgNum + 1
+	}
+
+	# a number that isn't zero and doesn't have a leading zero
+	num = [1-9] [0-9]*;
+
+	flags = (
+		'0' @flag_zero |
+		'#' @flag_sharp |
+		'-' @flag_minus |
+		'+' @flag_plus |
+		' ' @flag_space
+	)*;
+
+	argidx = ((
+		'[' (num $argidx_num) ']'
+	) >argidx_reset)?;
+
+	width = (
+		( num $width_num ) >width_reset %has_width
+	)?;
+
+	precision = (
+		('.' ( digit* $prec_num )) >prec_reset %has_prec
+	)?;
+
+	# We accept any letter here, but will be more picky in formatAppend
+	mode = ('a'..'z' | 'A'..'Z') @mode;
+
+	fmt_verb = (
+		'%' @begin
+		flags
+		width
+		precision
+		argidx
+		mode
+	);
+
+	main := (
+		[^%] @emit |
+		'%%' @emit |
+		fmt_verb
+	)* @/finish_err %/finish_ok $!err_char;
+
+	}%%
+
+	// Ragel state
+	p := 0  // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+	cs := 0 // current state (will be initialized by ragel-generated code)
+	ts := 0
+	te := 0
+	eof := pe
+
+	// Keep Go compiler happy even if generated code doesn't use these
+	_ = ts
+	_ = te
+	_ = eof
+
+	%%{
+		write init;
+		write exec;
+	}%%
+
+	// If we fall out here without being in a final state then we've
+	// encountered something that the scanner can't match, which should
+	// be impossible (the scanner matches all bytes _somehow_) but we'll
+	// flag it anyway rather than just losing data from the end.
+	if cs < formatfsm_first_final {
+		return buf.String(), fmt.Errorf("extraneous characters beginning at offset %d", p)
+	}
+
+	if highestArgIdx < len(a) {
+		// Extraneous args are an error, to more easily detect mistakes
+		firstBad := highestArgIdx+1
+		if highestArgIdx == 0 {
+			// Custom error message for this case
+			return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; no verbs in format string")
+		}
+		return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; only %d used by format string", highestArgIdx)
+	}
+
+	return buf.String(), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
new file mode 100644
index 00000000..6b31f266
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
@@ -0,0 +1,107 @@
+package stdlib
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var EqualFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.DynamicPseudoType,
+			AllowUnknown:     true,
+			AllowDynamicType: true,
+			AllowNull:        true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.DynamicPseudoType,
+			AllowUnknown:     true,
+			AllowDynamicType: true,
+			AllowNull:        true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].Equals(args[1]), nil
+	},
+})
+
+var NotEqualFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.DynamicPseudoType,
+			AllowUnknown:     true,
+			AllowDynamicType: true,
+			AllowNull:        true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.DynamicPseudoType,
+			AllowUnknown:     true,
+			AllowDynamicType: true,
+			AllowNull:        true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].Equals(args[1]).Not(), nil
+	},
+})
+
+var CoalesceFunc = function.New(&function.Spec{
+	Params: []function.Parameter{},
+	VarParam: &function.Parameter{
+		Name:             "vals",
+		Type:             cty.DynamicPseudoType,
+		AllowUnknown:     true,
+		AllowDynamicType: true,
+		AllowNull:        true,
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		argTypes := make([]cty.Type, len(args))
+		for i, val := range args {
+			argTypes[i] = val.Type()
+		}
+		retType, _ := convert.UnifyUnsafe(argTypes)
+		if retType == cty.NilType {
+			return cty.NilType, fmt.Errorf("all arguments must have the same type")
+		}
+		return retType, nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		for _, argVal := range args {
+			if !argVal.IsKnown() {
+				return cty.UnknownVal(retType), nil
+			}
+			if argVal.IsNull() {
+				continue
+			}
+
+			return convert.Convert(argVal, retType)
+		}
+		return cty.NilVal, fmt.Errorf("no non-null arguments")
+	},
+})
+
+// Equal determines whether the two given values are equal, returning a
+// bool value.
+func Equal(a cty.Value, b cty.Value) (cty.Value, error) {
+	return EqualFunc.Call([]cty.Value{a, b})
+}
+
+// NotEqual is the opposite of Equal.
+func NotEqual(a cty.Value, b cty.Value) (cty.Value, error) {
+	return NotEqualFunc.Call([]cty.Value{a, b})
+}
+
+// Coalesce returns the first of the given arguments that is not null. If
+// all arguments are null, an error is produced.
+func Coalesce(vals ...cty.Value) (cty.Value, error) {
+	return CoalesceFunc.Call(vals)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
new file mode 100644
index 00000000..07901c65
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
@@ -0,0 +1,72 @@
+package stdlib
+
+import (
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/json"
+)
+
+var JSONEncodeFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "val",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		val := args[0]
+		if !val.IsWhollyKnown() {
+			// We can't serialize unknowns, so if the value is unknown or
+			// contains any _nested_ unknowns then our result must be
+			// unknown.
+			return cty.UnknownVal(retType), nil
+		}
+
+		buf, err := json.Marshal(val, val.Type())
+		if err != nil {
+			return cty.NilVal, err
+		}
+
+		return cty.StringVal(string(buf)), nil
+	},
+})
+
+var JSONDecodeFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "str",
+			Type: cty.String,
+		},
+	},
+	Type: func(args []cty.Value) (cty.Type, error) {
+		str := args[0]
+		if !str.IsKnown() {
+			return cty.DynamicPseudoType, nil
+		}
+
+		buf := []byte(str.AsString())
+		return json.ImpliedType(buf)
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		buf := []byte(args[0].AsString())
+		return json.Unmarshal(buf, retType)
+	},
+})
+
+// JSONEncode returns a JSON serialization of the given value.
+func JSONEncode(val cty.Value) (cty.Value, error) {
+	return JSONEncodeFunc.Call([]cty.Value{val})
+}
+
+// JSONDecode parses the given JSON string and, if it is valid, returns the
+// value it represents.
+//
+// Note that applying JSONDecode to the result of JSONEncode may not produce
+// an identically-typed result, since JSON encoding is lossy for cty Types.
+// The resulting value will consist only of primitive types, object types, and
+// tuple types.
+func JSONDecode(str cty.Value) (cty.Value, error) {
+	return JSONDecodeFunc.Call([]cty.Value{str})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
new file mode 100644
index 00000000..480305e8
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
@@ -0,0 +1,438 @@
+package stdlib
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var AbsoluteFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "num",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].Absolute(), nil
+	},
+})
+
+var AddFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Add can panic if the input values are opposing infinities,
+		// so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't compute sum of opposing infinities")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+		return args[0].Add(args[1]), nil
+	},
+})
+
+var SubtractFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Sub can panic if the input values are infinities,
+		// so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't subtract infinity from itself")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+		return args[0].Subtract(args[1]), nil
+	},
+})
+
+var MultiplyFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Mul can panic if the input values are both zero or both
+		// infinity, so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't multiply zero by infinity")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+
+		return args[0].Multiply(args[1]), nil
+	},
+})
+
+var DivideFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Quo can panic if the input values are both zero or both
+		// infinity, so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't divide zero by zero or infinity by infinity")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+
+		return args[0].Divide(args[1]), nil
+	},
+})
+
+var ModuloFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Mul can panic if the input values are both zero or both
+		// infinity, so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't use modulo with zero and infinity")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+
+		return args[0].Modulo(args[1]), nil
+	},
+})
+
+var GreaterThanFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].GreaterThan(args[1]), nil
+	},
+})
+
+var GreaterThanOrEqualToFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].GreaterThanOrEqualTo(args[1]), nil
+	},
+})
+
+var LessThanFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].LessThan(args[1]), nil
+	},
+})
+
+var LessThanOrEqualToFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].LessThanOrEqualTo(args[1]), nil
+	},
+})
+
+var NegateFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "num",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+			AllowMarked:      true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].Negate(), nil
+	},
+})
+
+var MinFunc = function.New(&function.Spec{
+	Params: []function.Parameter{},
+	VarParam: &function.Parameter{
+		Name:             "numbers",
+		Type:             cty.Number,
+		AllowDynamicType: true,
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		if len(args) == 0 {
+			return cty.NilVal, fmt.Errorf("must pass at least one number")
+		}
+
+		min := cty.PositiveInfinity
+		for _, num := range args {
+			if num.LessThan(min).True() {
+				min = num
+			}
+		}
+
+		return min, nil
+	},
+})
+
+var MaxFunc = function.New(&function.Spec{
+	Params: []function.Parameter{},
+	VarParam: &function.Parameter{
+		Name:             "numbers",
+		Type:             cty.Number,
+		AllowDynamicType: true,
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		if len(args) == 0 {
+			return cty.NilVal, fmt.Errorf("must pass at least one number")
+		}
+
+		max := cty.NegativeInfinity
+		for _, num := range args {
+			if num.GreaterThan(max).True() {
+				max = num
+			}
+		}
+
+		return max, nil
+	},
+})
+
+var IntFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "num",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		bf := args[0].AsBigFloat()
+		if bf.IsInt() {
+			return args[0], nil
+		}
+		bi, _ := bf.Int(nil)
+		bf = (&big.Float{}).SetInt(bi)
+		return cty.NumberVal(bf), nil
+	},
+})
+
+// Absolute returns the magnitude of the given number, without its sign.
+// That is, it turns negative values into positive values.
+func Absolute(num cty.Value) (cty.Value, error) {
+	return AbsoluteFunc.Call([]cty.Value{num})
+}
+
+// Add returns the sum of the two given numbers.
+func Add(a cty.Value, b cty.Value) (cty.Value, error) {
+	return AddFunc.Call([]cty.Value{a, b})
+}
+
+// Subtract returns the difference between the two given numbers.
+func Subtract(a cty.Value, b cty.Value) (cty.Value, error) {
+	return SubtractFunc.Call([]cty.Value{a, b})
+}
+
+// Multiply returns the product of the two given numbers.
+func Multiply(a cty.Value, b cty.Value) (cty.Value, error) {
+	return MultiplyFunc.Call([]cty.Value{a, b})
+}
+
+// Divide returns a divided by b, where both a and b are numbers.
+func Divide(a cty.Value, b cty.Value) (cty.Value, error) {
+	return DivideFunc.Call([]cty.Value{a, b})
+}
+
+// Negate returns the given number multipled by -1.
+func Negate(num cty.Value) (cty.Value, error) {
+	return NegateFunc.Call([]cty.Value{num})
+}
+
+// LessThan returns true if a is less than b.
+func LessThan(a cty.Value, b cty.Value) (cty.Value, error) {
+	return LessThanFunc.Call([]cty.Value{a, b})
+}
+
+// LessThanOrEqualTo returns true if a is less than b.
+func LessThanOrEqualTo(a cty.Value, b cty.Value) (cty.Value, error) {
+	return LessThanOrEqualToFunc.Call([]cty.Value{a, b})
+}
+
+// GreaterThan returns true if a is less than b.
+func GreaterThan(a cty.Value, b cty.Value) (cty.Value, error) {
+	return GreaterThanFunc.Call([]cty.Value{a, b})
+}
+
+// GreaterThanOrEqualTo returns true if a is less than b.
+func GreaterThanOrEqualTo(a cty.Value, b cty.Value) (cty.Value, error) {
+	return GreaterThanOrEqualToFunc.Call([]cty.Value{a, b})
+}
+
+// Modulo returns the remainder of a divided by b under integer division,
+// where both a and b are numbers.
+func Modulo(a cty.Value, b cty.Value) (cty.Value, error) {
+	return ModuloFunc.Call([]cty.Value{a, b})
+}
+
+// Min returns the minimum number from the given numbers.
+func Min(numbers ...cty.Value) (cty.Value, error) {
+	return MinFunc.Call(numbers)
+}
+
+// Max returns the maximum number from the given numbers.
+func Max(numbers ...cty.Value) (cty.Value, error) {
+	return MaxFunc.Call(numbers)
+}
+
+// Int removes the fractional component of the given number returning an
+// integer representing the whole number component, rounding towards zero.
+// For example, -1.5 becomes -1.
+//
+// If an infinity is passed to Int, an error is returned.
+func Int(num cty.Value) (cty.Value, error) {
+	if num == cty.PositiveInfinity || num == cty.NegativeInfinity {
+		return cty.NilVal, fmt.Errorf("can't truncate infinity to an integer")
+	}
+	return IntFunc.Call([]cty.Value{num})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go
new file mode 100644
index 00000000..2dd6348a
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go
@@ -0,0 +1,233 @@
+package stdlib
+
+import (
+	"fmt"
+	"regexp"
+	resyntax "regexp/syntax"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var RegexFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "pattern",
+			Type: cty.String,
+		},
+		{
+			Name: "string",
+			Type: cty.String,
+		},
+	},
+	Type: func(args []cty.Value) (cty.Type, error) {
+		if !args[0].IsKnown() {
+			// We can't predict our type without seeing our pattern
+			return cty.DynamicPseudoType, nil
+		}
+
+		retTy, err := regexPatternResultType(args[0].AsString())
+		if err != nil {
+			err = function.NewArgError(0, err)
+		}
+		return retTy, err
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		if retType == cty.DynamicPseudoType {
+			return cty.DynamicVal, nil
+		}
+
+		re, err := regexp.Compile(args[0].AsString())
+		if err != nil {
+			// Should never happen, since we checked this in the Type function above.
+			return cty.NilVal, function.NewArgErrorf(0, "error parsing pattern: %s", err)
+		}
+		str := args[1].AsString()
+
+		captureIdxs := re.FindStringSubmatchIndex(str)
+		if captureIdxs == nil {
+			return cty.NilVal, fmt.Errorf("pattern did not match any part of the given string")
+		}
+
+		return regexPatternResult(re, str, captureIdxs, retType), nil
+	},
+})
+
+var RegexAllFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "pattern",
+			Type: cty.String,
+		},
+		{
+			Name: "string",
+			Type: cty.String,
+		},
+	},
+	Type: func(args []cty.Value) (cty.Type, error) {
+		if !args[0].IsKnown() {
+			// We can't predict our type without seeing our pattern,
+			// but we do know it'll always be a list of something.
+			return cty.List(cty.DynamicPseudoType), nil
+		}
+
+		retTy, err := regexPatternResultType(args[0].AsString())
+		if err != nil {
+			err = function.NewArgError(0, err)
+		}
+		return cty.List(retTy), err
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		ety := retType.ElementType()
+		if ety == cty.DynamicPseudoType {
+			return cty.DynamicVal, nil
+		}
+
+		re, err := regexp.Compile(args[0].AsString())
+		if err != nil {
+			// Should never happen, since we checked this in the Type function above.
+			return cty.NilVal, function.NewArgErrorf(0, "error parsing pattern: %s", err)
+		}
+		str := args[1].AsString()
+
+		captureIdxsEach := re.FindAllStringSubmatchIndex(str, -1)
+		if len(captureIdxsEach) == 0 {
+			return cty.ListValEmpty(ety), nil
+		}
+
+		elems := make([]cty.Value, len(captureIdxsEach))
+		for i, captureIdxs := range captureIdxsEach {
+			elems[i] = regexPatternResult(re, str, captureIdxs, ety)
+		}
+		return cty.ListVal(elems), nil
+	},
+})
+
+// Regex is a function that extracts one or more substrings from a given
+// string by applying a regular expression pattern, describing the first
+// match.
+//
+// The return type depends on the composition of the capture groups (if any)
+// in the pattern:
+//
+//   - If there are no capture groups at all, the result is a single string
+//     representing the entire matched pattern.
+//   - If all of the capture groups are named, the result is an object whose
+//     keys are the named groups and whose values are their sub-matches, or
+//     null if a particular sub-group was inside another group that didn't
+//     match.
+//   - If none of the capture groups are named, the result is a tuple whose
+//     elements are the sub-groups in order and whose values are their
+//     sub-matches, or null if a particular sub-group was inside another group
+//     that didn't match.
+//   - It is invalid to use both named and un-named capture groups together in
+//     the same pattern.
+//
+// If the pattern doesn't match, this function returns an error. To test for
+// a match, call RegexAll and check if the length of the result is greater
+// than zero.
+func Regex(pattern, str cty.Value) (cty.Value, error) {
+	return RegexFunc.Call([]cty.Value{pattern, str})
+}
+
+// RegexAll is similar to Regex but it finds all of the non-overlapping matches
+// in the given string and returns a list of them.
+//
+// The result type is always a list, whose element type is deduced from the
+// pattern in the same way as the return type for Regex is decided.
+//
+// If the pattern doesn't match at all, this function returns an empty list.
+func RegexAll(pattern, str cty.Value) (cty.Value, error) {
+	return RegexAllFunc.Call([]cty.Value{pattern, str})
+}
+
+// regexPatternResultType parses the given regular expression pattern and
+// returns the structural type that would be returned to represent its
+// capture groups.
+//
+// Returns an error if parsing fails or if the pattern uses a mixture of
+// named and unnamed capture groups, which is not permitted.
+func regexPatternResultType(pattern string) (cty.Type, error) {
+	re, rawErr := regexp.Compile(pattern)
+	switch err := rawErr.(type) {
+	case *resyntax.Error:
+		return cty.NilType, fmt.Errorf("invalid regexp pattern: %s in %s", err.Code, err.Expr)
+	case error:
+		// Should never happen, since all regexp compile errors should
+		// be resyntax.Error, but just in case...
+		return cty.NilType, fmt.Errorf("error parsing pattern: %s", err)
+	}
+
+	allNames := re.SubexpNames()[1:]
+	var names []string
+	unnamed := 0
+	for _, name := range allNames {
+		if name == "" {
+			unnamed++
+		} else {
+			if names == nil {
+				names = make([]string, 0, len(allNames))
+			}
+			names = append(names, name)
+		}
+	}
+	switch {
+	case unnamed == 0 && len(names) == 0:
+		// If there are no capture groups at all then we'll return just a
+		// single string for the whole match.
+		return cty.String, nil
+	case unnamed > 0 && len(names) > 0:
+		return cty.NilType, fmt.Errorf("invalid regexp pattern: cannot mix both named and unnamed capture groups")
+	case unnamed > 0:
+		// For unnamed captures, we return a tuple of them all in order.
+		etys := make([]cty.Type, unnamed)
+		for i := range etys {
+			etys[i] = cty.String
+		}
+		return cty.Tuple(etys), nil
+	default:
+		// For named captures, we return an object using the capture names
+		// as keys.
+		atys := make(map[string]cty.Type, len(names))
+		for _, name := range names {
+			atys[name] = cty.String
+		}
+		return cty.Object(atys), nil
+	}
+}
+
+func regexPatternResult(re *regexp.Regexp, str string, captureIdxs []int, retType cty.Type) cty.Value {
+	switch {
+	case retType == cty.String:
+		start, end := captureIdxs[0], captureIdxs[1]
+		return cty.StringVal(str[start:end])
+	case retType.IsTupleType():
+		captureIdxs = captureIdxs[2:] // index 0 is the whole pattern span, which we ignore by skipping one pair
+		vals := make([]cty.Value, len(captureIdxs)/2)
+		for i := range vals {
+			start, end := captureIdxs[i*2], captureIdxs[i*2+1]
+			if start < 0 || end < 0 {
+				vals[i] = cty.NullVal(cty.String) // Did not match anything because containing group didn't match
+				continue
+			}
+			vals[i] = cty.StringVal(str[start:end])
+		}
+		return cty.TupleVal(vals)
+	case retType.IsObjectType():
+		captureIdxs = captureIdxs[2:] // index 0 is the whole pattern span, which we ignore by skipping one pair
+		vals := make(map[string]cty.Value, len(captureIdxs)/2)
+		names := re.SubexpNames()[1:]
+		for i, name := range names {
+			start, end := captureIdxs[i*2], captureIdxs[i*2+1]
+			if start < 0 || end < 0 {
+				vals[name] = cty.NullVal(cty.String) // Did not match anything because containing group didn't match
+				continue
+			}
+			vals[name] = cty.StringVal(str[start:end])
+		}
+		return cty.ObjectVal(vals)
+	default:
+		// Should never happen
+		panic(fmt.Sprintf("invalid return type %#v", retType))
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
new file mode 100644
index 00000000..d3cc341d
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
@@ -0,0 +1,218 @@
+package stdlib
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var ConcatFunc = function.New(&function.Spec{
+	Params: []function.Parameter{},
+	VarParam: &function.Parameter{
+		Name: "seqs",
+		Type: cty.DynamicPseudoType,
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		if len(args) == 0 {
+			return cty.NilType, fmt.Errorf("at least one argument is required")
+		}
+
+		if args[0].Type().IsListType() {
+			// Possibly we're going to return a list, if all of our other
+			// args are also lists and we can find a common element type.
+			tys := make([]cty.Type, len(args))
+			for i, val := range args {
+				ty := val.Type()
+				if !ty.IsListType() {
+					tys = nil
+					break
+				}
+				tys[i] = ty
+			}
+
+			if tys != nil {
+				commonType, _ := convert.UnifyUnsafe(tys)
+				if commonType != cty.NilType {
+					return commonType, nil
+				}
+			}
+		}
+
+		etys := make([]cty.Type, 0, len(args))
+		for i, val := range args {
+			ety := val.Type()
+			switch {
+			case ety.IsTupleType():
+				etys = append(etys, ety.TupleElementTypes()...)
+			case ety.IsListType():
+				if !val.IsKnown() {
+					// We need to know the list to count its elements to
+					// build our tuple type, so any concat of an unknown
+					// list can't be typed yet.
+					return cty.DynamicPseudoType, nil
+				}
+
+				l := val.LengthInt()
+				subEty := ety.ElementType()
+				for j := 0; j < l; j++ {
+					etys = append(etys, subEty)
+				}
+			default:
+				return cty.NilType, function.NewArgErrorf(
+					i, "all arguments must be lists or tuples; got %s",
+					ety.FriendlyName(),
+				)
+			}
+		}
+		return cty.Tuple(etys), nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		switch {
+		case retType.IsListType():
+			// If retType is a list type then we know that all of the
+			// given values will be lists and that they will either be of
+			// retType or of something we can convert to retType.
+			vals := make([]cty.Value, 0, len(args))
+			for i, list := range args {
+				list, err = convert.Convert(list, retType)
+				if err != nil {
+					// Conversion might fail because we used UnifyUnsafe
+					// to choose our return type.
+					return cty.NilVal, function.NewArgError(i, err)
+				}
+
+				it := list.ElementIterator()
+				for it.Next() {
+					_, v := it.Element()
+					vals = append(vals, v)
+				}
+			}
+			if len(vals) == 0 {
+				return cty.ListValEmpty(retType.ElementType()), nil
+			}
+
+			return cty.ListVal(vals), nil
+		case retType.IsTupleType():
+			// If retType is a tuple type then we could have a mixture of
+			// lists and tuples but we know they all have known values
+			// (because our params don't AllowUnknown) and we know that
+			// concatenating them all together will produce a tuple of
+			// retType because of the work we did in the Type function above.
+			vals := make([]cty.Value, 0, len(args))
+
+			for _, seq := range args {
+				// Both lists and tuples support ElementIterator, so this is easy.
+				it := seq.ElementIterator()
+				for it.Next() {
+					_, v := it.Element()
+					vals = append(vals, v)
+				}
+			}
+
+			return cty.TupleVal(vals), nil
+		default:
+			// should never happen if Type is working correctly above
+			panic("unsupported return type")
+		}
+	},
+})
+
+var RangeFunc = function.New(&function.Spec{
+	VarParam: &function.Parameter{
+		Name: "params",
+		Type: cty.Number,
+	},
+	Type: function.StaticReturnType(cty.List(cty.Number)),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		var start, end, step cty.Value
+		switch len(args) {
+		case 1:
+			if args[0].LessThan(cty.Zero).True() {
+				start, end, step = cty.Zero, args[0], cty.NumberIntVal(-1)
+			} else {
+				start, end, step = cty.Zero, args[0], cty.NumberIntVal(1)
+			}
+		case 2:
+			if args[1].LessThan(args[0]).True() {
+				start, end, step = args[0], args[1], cty.NumberIntVal(-1)
+			} else {
+				start, end, step = args[0], args[1], cty.NumberIntVal(1)
+			}
+		case 3:
+			start, end, step = args[0], args[1], args[2]
+		default:
+			return cty.NilVal, fmt.Errorf("must have one, two, or three arguments")
+		}
+
+		var vals []cty.Value
+
+		if step == cty.Zero {
+			return cty.NilVal, function.NewArgErrorf(2, "step must not be zero")
+		}
+		down := step.LessThan(cty.Zero).True()
+
+		if down {
+			if end.GreaterThan(start).True() {
+				return cty.NilVal, function.NewArgErrorf(1, "end must be less than start when step is negative")
+			}
+		} else {
+			if end.LessThan(start).True() {
+				return cty.NilVal, function.NewArgErrorf(1, "end must be greater than start when step is positive")
+			}
+		}
+
+		num := start
+		for {
+			if down {
+				if num.LessThanOrEqualTo(end).True() {
+					break
+				}
+			} else {
+				if num.GreaterThanOrEqualTo(end).True() {
+					break
+				}
+			}
+			if len(vals) >= 1024 {
+				// Artificial limit to prevent bad arguments from consuming huge amounts of memory
+				return cty.NilVal, fmt.Errorf("more than 1024 values were generated; either decrease the difference between start and end or use a smaller step")
+			}
+			vals = append(vals, num)
+			num = num.Add(step)
+		}
+		if len(vals) == 0 {
+			return cty.ListValEmpty(cty.Number), nil
+		}
+		return cty.ListVal(vals), nil
+	},
+})
+
+// Concat takes one or more sequences (lists or tuples) and returns the single
+// sequence that results from concatenating them together in order.
+//
+// If all of the given sequences are lists of the same element type then the
+// result is a list of that type. Otherwise, the result is a of a tuple type
+// constructed from the given sequence types.
+func Concat(seqs ...cty.Value) (cty.Value, error) {
+	return ConcatFunc.Call(seqs)
+}
+
+// Range creates a list of numbers by starting from the given starting value,
+// then adding the given step value until the result is greater than or
+// equal to the given stopping value. Each intermediate result becomes an
+// element in the resulting list.
+//
+// When all three parameters are set, the order is (start, end, step). If
+// only two parameters are set, they are the start and end respectively and
+// step defaults to 1. If only one argument is set, it gives the end value
+// with start defaulting to 0 and step defaulting to 1.
+//
+// Because the resulting list must be fully buffered in memory, there is an
+// artificial cap of 1024 elements, after which this function will return
+// an error to avoid consuming unbounded amounts of memory. The Range function
+// is primarily intended for creating small lists of indices to iterate over,
+// so there should be no reason to generate huge lists with it.
+func Range(params ...cty.Value) (cty.Value, error) {
+	return RangeFunc.Call(params)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go
new file mode 100644
index 00000000..100078fd
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go
@@ -0,0 +1,195 @@
+package stdlib
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty/convert"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var SetHasElementFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "set",
+			Type:             cty.Set(cty.DynamicPseudoType),
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "elem",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].HasElement(args[1]), nil
+	},
+})
+
+var SetUnionFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "first_set",
+			Type:             cty.Set(cty.DynamicPseudoType),
+			AllowDynamicType: true,
+		},
+	},
+	VarParam: &function.Parameter{
+		Name:             "other_sets",
+		Type:             cty.Set(cty.DynamicPseudoType),
+		AllowDynamicType: true,
+	},
+	Type: setOperationReturnType,
+	Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+		return s1.Union(s2)
+	}),
+})
+
+var SetIntersectionFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "first_set",
+			Type:             cty.Set(cty.DynamicPseudoType),
+			AllowDynamicType: true,
+		},
+	},
+	VarParam: &function.Parameter{
+		Name:             "other_sets",
+		Type:             cty.Set(cty.DynamicPseudoType),
+		AllowDynamicType: true,
+	},
+	Type: setOperationReturnType,
+	Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+		return s1.Intersection(s2)
+	}),
+})
+
+var SetSubtractFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Set(cty.DynamicPseudoType),
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Set(cty.DynamicPseudoType),
+			AllowDynamicType: true,
+		},
+	},
+	Type: setOperationReturnType,
+	Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+		return s1.Subtract(s2)
+	}),
+})
+
+var SetSymmetricDifferenceFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "first_set",
+			Type:             cty.Set(cty.DynamicPseudoType),
+			AllowDynamicType: true,
+		},
+	},
+	VarParam: &function.Parameter{
+		Name:             "other_sets",
+		Type:             cty.Set(cty.DynamicPseudoType),
+		AllowDynamicType: true,
+	},
+	Type: setOperationReturnType,
+	Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+		return s1.Subtract(s2)
+	}),
+})
+
+// SetHasElement determines whether the given set contains the given value as an
+// element.
+func SetHasElement(set cty.Value, elem cty.Value) (cty.Value, error) {
+	return SetHasElementFunc.Call([]cty.Value{set, elem})
+}
+
+// SetUnion returns a new set containing all of the elements from the given
+// sets, which must have element types that can all be converted to some
+// common type using the standard type unification rules. If conversion
+// is not possible, an error is returned.
+//
+// The union operation is performed after type conversion, which may result
+// in some previously-distinct values being conflated.
+//
+// At least one set must be provided.
+func SetUnion(sets ...cty.Value) (cty.Value, error) {
+	return SetUnionFunc.Call(sets)
+}
+
+// Intersection returns a new set containing the elements that exist
+// in all of the given sets, which must have element types that can all be
+// converted to some common type using the standard type unification rules.
+// If conversion is not possible, an error is returned.
+//
+// The intersection operation is performed after type conversion, which may
+// result in some previously-distinct values being conflated.
+//
+// At least one set must be provided.
+func SetIntersection(sets ...cty.Value) (cty.Value, error) {
+	return SetIntersectionFunc.Call(sets)
+}
+
+// SetSubtract returns a new set containing the elements from the
+// first set that are not present in the second set. The sets must have
+// element types that can both be converted to some common type using the
+// standard type unification rules. If conversion is not possible, an error
+// is returned.
+//
+// The subtract operation is performed after type conversion, which may
+// result in some previously-distinct values being conflated.
+func SetSubtract(a, b cty.Value) (cty.Value, error) {
+	return SetSubtractFunc.Call([]cty.Value{a, b})
+}
+
+// SetSymmetricDifference returns a new set containing elements that appear
+// in any of the given sets but not multiple. The sets must have
+// element types that can all be converted to some common type using the
+// standard type unification rules. If conversion is not possible, an error
+// is returned.
+//
+// The difference operation is performed after type conversion, which may
+// result in some previously-distinct values being conflated.
+func SetSymmetricDifference(sets ...cty.Value) (cty.Value, error) {
+	return SetSymmetricDifferenceFunc.Call(sets)
+}
+
+func setOperationReturnType(args []cty.Value) (ret cty.Type, err error) {
+	var etys []cty.Type
+	for _, arg := range args {
+		etys = append(etys, arg.Type().ElementType())
+	}
+	newEty, _ := convert.UnifyUnsafe(etys)
+	if newEty == cty.NilType {
+		return cty.NilType, fmt.Errorf("given sets must all have compatible element types")
+	}
+	return cty.Set(newEty), nil
+}
+
+func setOperationImpl(f func(s1, s2 cty.ValueSet) cty.ValueSet) function.ImplFunc {
+	return func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		first := args[0]
+		first, err = convert.Convert(first, retType)
+		if err != nil {
+			return cty.NilVal, function.NewArgError(0, err)
+		}
+
+		set := first.AsValueSet()
+		for i, arg := range args[1:] {
+			arg, err := convert.Convert(arg, retType)
+			if err != nil {
+				return cty.NilVal, function.NewArgError(i+1, err)
+			}
+
+			argSet := arg.AsValueSet()
+			set = f(set, argSet)
+		}
+		return cty.SetValFromValueSet(set), nil
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
new file mode 100644
index 00000000..12e9dbc3
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
@@ -0,0 +1,234 @@
+package stdlib
+
+import (
+	"strings"
+
+	"github.com/apparentlymart/go-textseg/textseg"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+var UpperFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := args[0].AsString()
+		out := strings.ToUpper(in)
+		return cty.StringVal(out), nil
+	},
+})
+
+var LowerFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := args[0].AsString()
+		out := strings.ToLower(in)
+		return cty.StringVal(out), nil
+	},
+})
+
+var ReverseFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := []byte(args[0].AsString())
+		out := make([]byte, len(in))
+		pos := len(out)
+
+		inB := []byte(in)
+		for i := 0; i < len(in); {
+			d, _, _ := textseg.ScanGraphemeClusters(inB[i:], true)
+			cluster := in[i : i+d]
+			pos -= len(cluster)
+			copy(out[pos:], cluster)
+			i += d
+		}
+
+		return cty.StringVal(string(out)), nil
+	},
+})
+
+var StrlenFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := args[0].AsString()
+		l := 0
+
+		inB := []byte(in)
+		for i := 0; i < len(in); {
+			d, _, _ := textseg.ScanGraphemeClusters(inB[i:], true)
+			l++
+			i += d
+		}
+
+		return cty.NumberIntVal(int64(l)), nil
+	},
+})
+
+var SubstrFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "offset",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "length",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := []byte(args[0].AsString())
+		var offset, length int
+
+		var err error
+		err = gocty.FromCtyValue(args[1], &offset)
+		if err != nil {
+			return cty.NilVal, err
+		}
+		err = gocty.FromCtyValue(args[2], &length)
+		if err != nil {
+			return cty.NilVal, err
+		}
+
+		if offset < 0 {
+			totalLenNum, err := Strlen(args[0])
+			if err != nil {
+				// should never happen
+				panic("Stdlen returned an error")
+			}
+
+			var totalLen int
+			err = gocty.FromCtyValue(totalLenNum, &totalLen)
+			if err != nil {
+				// should never happen
+				panic("Stdlen returned a non-int number")
+			}
+
+			offset += totalLen
+		}
+
+		sub := in
+		pos := 0
+		var i int
+
+		// First we'll seek forward to our offset
+		if offset > 0 {
+			for i = 0; i < len(sub); {
+				d, _, _ := textseg.ScanGraphemeClusters(sub[i:], true)
+				i += d
+				pos++
+				if pos == offset {
+					break
+				}
+				if i >= len(in) {
+					return cty.StringVal(""), nil
+				}
+			}
+
+			sub = sub[i:]
+		}
+
+		if length < 0 {
+			// Taking the remainder of the string is a fast path since
+			// we can just return the rest of the buffer verbatim.
+			return cty.StringVal(string(sub)), nil
+		}
+
+		// Otherwise we need to start seeking forward again until we
+		// reach the length we want.
+		pos = 0
+		for i = 0; i < len(sub); {
+			d, _, _ := textseg.ScanGraphemeClusters(sub[i:], true)
+			i += d
+			pos++
+			if pos == length {
+				break
+			}
+		}
+
+		sub = sub[:i]
+
+		return cty.StringVal(string(sub)), nil
+	},
+})
+
+// Upper is a Function that converts a given string to uppercase.
+func Upper(str cty.Value) (cty.Value, error) {
+	return UpperFunc.Call([]cty.Value{str})
+}
+
+// Lower is a Function that converts a given string to lowercase.
+func Lower(str cty.Value) (cty.Value, error) {
+	return LowerFunc.Call([]cty.Value{str})
+}
+
+// Reverse is a Function that reverses the order of the characters in the
+// given string.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+func Reverse(str cty.Value) (cty.Value, error) {
+	return ReverseFunc.Call([]cty.Value{str})
+}
+
+// Strlen is a Function that returns the length of the given string in
+// characters.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+func Strlen(str cty.Value) (cty.Value, error) {
+	return StrlenFunc.Call([]cty.Value{str})
+}
+
+// Substr is a Function that extracts a sequence of characters from another
+// string and creates a new string.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+//
+// The "offset" index may be negative, in which case it is relative to the
+// end of the given string.
+//
+// The "length" may be -1, in which case the remainder of the string after
+// the given offset will be returned.
+func Substr(str cty.Value, offset cty.Value, length cty.Value) (cty.Value, error) {
+	return SubstrFunc.Call([]cty.Value{str, offset, length})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/doc.go b/vendor/github.com/zclconf/go-cty/cty/gocty/doc.go
new file mode 100644
index 00000000..a5177d22
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/doc.go
@@ -0,0 +1,7 @@
+// Package gocty deals with converting between cty Values and native go
+// values.
+//
+// It operates under a similar principle to the encoding/json and
+// encoding/xml packages in the standard library, using reflection to
+// populate native Go data structures from cty values and vice-versa.
+package gocty
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go b/vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go
new file mode 100644
index 00000000..94ffd2fb
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go
@@ -0,0 +1,43 @@
+package gocty
+
+import (
+	"math/big"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+var valueType = reflect.TypeOf(cty.Value{})
+var typeType = reflect.TypeOf(cty.Type{})
+
+var setType = reflect.TypeOf(set.Set{})
+
+var bigFloatType = reflect.TypeOf(big.Float{})
+var bigIntType = reflect.TypeOf(big.Int{})
+
+var emptyInterfaceType = reflect.TypeOf(interface{}(nil))
+
+var stringType = reflect.TypeOf("")
+
+// structTagIndices interrogates the fields of the given type (which must
+// be a struct type, or we'll panic) and returns a map from the cty
+// attribute names declared via struct tags to the indices of the
+// fields holding those tags.
+//
+// This function will panic if two fields within the struct are tagged with
+// the same cty attribute name.
+func structTagIndices(st reflect.Type) map[string]int {
+	ct := st.NumField()
+	ret := make(map[string]int, ct)
+
+	for i := 0; i < ct; i++ {
+		field := st.Field(i)
+		attrName := field.Tag.Get("cty")
+		if attrName != "" {
+			ret[attrName] = i
+		}
+	}
+
+	return ret
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/in.go b/vendor/github.com/zclconf/go-cty/cty/gocty/in.go
new file mode 100644
index 00000000..ca9de21d
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/in.go
@@ -0,0 +1,548 @@
+package gocty
+
+import (
+	"math/big"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+// ToCtyValue produces a cty.Value from a Go value. The result will conform
+// to the given type, or an error will be returned if this is not possible.
+//
+// The target type serves as a hint to resolve ambiguities in the mapping.
+// For example, the Go type set.Set tells us that the value is a set but
+// does not describe the set's element type. This also allows for convenient
+// conversions, such as populating a set from a slice rather than having to
+// first explicitly instantiate a set.Set.
+//
+// The audience of this function is assumed to be the developers of Go code
+// that is integrating with cty, and thus the error messages it returns are
+// presented from Go's perspective. These messages are thus not appropriate
+// for display to end-users. An error returned from ToCtyValue represents a
+// bug in the calling program, not user error.
+func ToCtyValue(val interface{}, ty cty.Type) (cty.Value, error) {
+	// 'path' starts off as empty but will grow for each level of recursive
+	// call we make, so by the time toCtyValue returns it is likely to have
+	// unused capacity on the end of it, depending on how deeply-recursive
+	// the given Type is.
+	path := make(cty.Path, 0)
+	return toCtyValue(reflect.ValueOf(val), ty, path)
+}
+
+func toCtyValue(val reflect.Value, ty cty.Type, path cty.Path) (cty.Value, error) {
+	if val != (reflect.Value{}) && val.Type().AssignableTo(valueType) {
+		// If the source value is a cty.Value then we'll try to just pass
+		// through to the target type directly.
+		return toCtyPassthrough(val, ty, path)
+	}
+
+	switch ty {
+	case cty.Bool:
+		return toCtyBool(val, path)
+	case cty.Number:
+		return toCtyNumber(val, path)
+	case cty.String:
+		return toCtyString(val, path)
+	case cty.DynamicPseudoType:
+		return toCtyDynamic(val, path)
+	}
+
+	switch {
+	case ty.IsListType():
+		return toCtyList(val, ty.ElementType(), path)
+	case ty.IsMapType():
+		return toCtyMap(val, ty.ElementType(), path)
+	case ty.IsSetType():
+		return toCtySet(val, ty.ElementType(), path)
+	case ty.IsObjectType():
+		return toCtyObject(val, ty.AttributeTypes(), path)
+	case ty.IsTupleType():
+		return toCtyTuple(val, ty.TupleElementTypes(), path)
+	case ty.IsCapsuleType():
+		return toCtyCapsule(val, ty, path)
+	}
+
+	// We should never fall out here
+	return cty.NilVal, path.NewErrorf("unsupported target type %#v", ty)
+}
+
+func toCtyBool(val reflect.Value, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Bool), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Bool:
+		return cty.BoolVal(val.Bool()), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to bool", val.Kind())
+
+	}
+
+}
+
+func toCtyNumber(val reflect.Value, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Number), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return cty.NumberIntVal(val.Int()), nil
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return cty.NumberUIntVal(val.Uint()), nil
+
+	case reflect.Float32, reflect.Float64:
+		return cty.NumberFloatVal(val.Float()), nil
+
+	case reflect.Struct:
+		if val.Type().AssignableTo(bigIntType) {
+			bigInt := val.Interface().(big.Int)
+			bigFloat := (&big.Float{}).SetInt(&bigInt)
+			val = reflect.ValueOf(*bigFloat)
+		}
+
+		if val.Type().AssignableTo(bigFloatType) {
+			bigFloat := val.Interface().(big.Float)
+			return cty.NumberVal(&bigFloat), nil
+		}
+
+		fallthrough
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to number", val.Kind())
+
+	}
+
+}
+
+func toCtyString(val reflect.Value, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.String), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.String:
+		return cty.StringVal(val.String()), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to string", val.Kind())
+
+	}
+
+}
+
+func toCtyList(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.List(ety)), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Slice:
+		if val.IsNil() {
+			return cty.NullVal(cty.List(ety)), nil
+		}
+		fallthrough
+	case reflect.Array:
+		if val.Len() == 0 {
+			return cty.ListValEmpty(ety), nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our index step.
+		path = append(path, cty.PathStep(nil))
+
+		vals := make([]cty.Value, val.Len())
+		for i := range vals {
+			var err error
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+			vals[i], err = toCtyValue(val.Index(i), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.ListVal(vals), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.List(ety))
+
+	}
+}
+
+func toCtyMap(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Map(ety)), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Map:
+		if val.IsNil() {
+			return cty.NullVal(cty.Map(ety)), nil
+		}
+
+		if val.Len() == 0 {
+			return cty.MapValEmpty(ety), nil
+		}
+
+		keyType := val.Type().Key()
+		if keyType.Kind() != reflect.String {
+			return cty.NilVal, path.NewErrorf("can't convert Go map with key type %s; key type must be string", keyType)
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our index step.
+		path = append(path, cty.PathStep(nil))
+
+		vals := make(map[string]cty.Value, val.Len())
+		for _, kv := range val.MapKeys() {
+			k := kv.String()
+			var err error
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.StringVal(k),
+			}
+			vals[k], err = toCtyValue(val.MapIndex(reflect.ValueOf(k)), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.MapVal(vals), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Map(ety))
+
+	}
+}
+
+func toCtySet(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Set(ety)), nil
+	}
+
+	var vals []cty.Value
+
+	switch val.Kind() {
+
+	case reflect.Slice:
+		if val.IsNil() {
+			return cty.NullVal(cty.Set(ety)), nil
+		}
+		fallthrough
+	case reflect.Array:
+		if val.Len() == 0 {
+			return cty.SetValEmpty(ety), nil
+		}
+
+		vals = make([]cty.Value, val.Len())
+		for i := range vals {
+			var err error
+			vals[i], err = toCtyValue(val.Index(i), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+	case reflect.Struct:
+
+		if !val.Type().AssignableTo(setType) {
+			return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Type(), cty.Set(ety))
+		}
+
+		rawSet := val.Interface().(set.Set)
+		inVals := rawSet.Values()
+
+		if len(inVals) == 0 {
+			return cty.SetValEmpty(ety), nil
+		}
+
+		vals = make([]cty.Value, len(inVals))
+		for i := range inVals {
+			var err error
+			vals[i], err = toCtyValue(reflect.ValueOf(inVals[i]), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Set(ety))
+
+	}
+
+	return cty.SetVal(vals), nil
+}
+
+func toCtyObject(val reflect.Value, attrTypes map[string]cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Object(attrTypes)), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Map:
+		if val.IsNil() {
+			return cty.NullVal(cty.Object(attrTypes)), nil
+		}
+
+		keyType := val.Type().Key()
+		if keyType.Kind() != reflect.String {
+			return cty.NilVal, path.NewErrorf("can't convert Go map with key type %s; key type must be string", keyType)
+		}
+
+		if len(attrTypes) == 0 {
+			return cty.EmptyObjectVal, nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our GetAttr step.
+		path = append(path, cty.PathStep(nil))
+
+		haveKeys := make(map[string]struct{}, val.Len())
+		for _, kv := range val.MapKeys() {
+			haveKeys[kv.String()] = struct{}{}
+		}
+
+		vals := make(map[string]cty.Value, len(attrTypes))
+		for k, at := range attrTypes {
+			var err error
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+
+			if _, have := haveKeys[k]; !have {
+				vals[k] = cty.NullVal(at)
+				continue
+			}
+
+			vals[k], err = toCtyValue(val.MapIndex(reflect.ValueOf(k)), at, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.ObjectVal(vals), nil
+
+	case reflect.Struct:
+		if len(attrTypes) == 0 {
+			return cty.EmptyObjectVal, nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our GetAttr step.
+		path = append(path, cty.PathStep(nil))
+
+		attrFields := structTagIndices(val.Type())
+
+		vals := make(map[string]cty.Value, len(attrTypes))
+		for k, at := range attrTypes {
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+
+			if fieldIdx, have := attrFields[k]; have {
+				var err error
+				vals[k], err = toCtyValue(val.Field(fieldIdx), at, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			} else {
+				vals[k] = cty.NullVal(at)
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.ObjectVal(vals), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Object(attrTypes))
+
+	}
+}
+
+func toCtyTuple(val reflect.Value, elemTypes []cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Tuple(elemTypes)), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Slice:
+		if val.IsNil() {
+			return cty.NullVal(cty.Tuple(elemTypes)), nil
+		}
+
+		if val.Len() != len(elemTypes) {
+			return cty.NilVal, path.NewErrorf("wrong number of elements %d; need %d", val.Len(), len(elemTypes))
+		}
+
+		if len(elemTypes) == 0 {
+			return cty.EmptyTupleVal, nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our Index step.
+		path = append(path, cty.PathStep(nil))
+
+		vals := make([]cty.Value, len(elemTypes))
+		for i, ety := range elemTypes {
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			vals[i], err = toCtyValue(val.Index(i), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.TupleVal(vals), nil
+
+	case reflect.Struct:
+		fieldCount := val.Type().NumField()
+		if fieldCount != len(elemTypes) {
+			return cty.NilVal, path.NewErrorf("wrong number of struct fields %d; need %d", fieldCount, len(elemTypes))
+		}
+
+		if len(elemTypes) == 0 {
+			return cty.EmptyTupleVal, nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our Index step.
+		path = append(path, cty.PathStep(nil))
+
+		vals := make([]cty.Value, len(elemTypes))
+		for i, ety := range elemTypes {
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			vals[i], err = toCtyValue(val.Field(i), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.TupleVal(vals), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Tuple(elemTypes))
+
+	}
+}
+
+func toCtyCapsule(val reflect.Value, capsuleType cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(capsuleType), nil
+	}
+
+	if val.Kind() != reflect.Ptr {
+		if !val.CanAddr() {
+			return cty.NilVal, path.NewErrorf("source value for capsule %#v must be addressable", capsuleType)
+		}
+
+		val = val.Addr()
+	}
+
+	if !val.Type().Elem().AssignableTo(capsuleType.EncapsulatedType()) {
+		return cty.NilVal, path.NewErrorf("value of type %T not compatible with capsule %#v", val.Interface(), capsuleType)
+	}
+
+	return cty.CapsuleVal(capsuleType, val.Interface()), nil
+}
+
+func toCtyDynamic(val reflect.Value, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.DynamicPseudoType), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Struct:
+		if !val.Type().AssignableTo(valueType) {
+			return cty.NilVal, path.NewErrorf("can't convert Go %s dynamically; only cty.Value allowed", val.Type())
+		}
+
+		return val.Interface().(cty.Value), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s dynamically; only cty.Value allowed", val.Kind())
+
+	}
+
+}
+
+func toCtyPassthrough(wrappedVal reflect.Value, wantTy cty.Type, path cty.Path) (cty.Value, error) {
+	if wrappedVal = toCtyUnwrapPointer(wrappedVal); !wrappedVal.IsValid() {
+		return cty.NullVal(wantTy), nil
+	}
+
+	givenVal := wrappedVal.Interface().(cty.Value)
+
+	val, err := convert.Convert(givenVal, wantTy)
+	if err != nil {
+		return cty.NilVal, path.NewErrorf("unsuitable value: %s", err)
+	}
+	return val, nil
+}
+
+// toCtyUnwrapPointer is a helper for dealing with Go pointers. It has three
+// possible outcomes:
+//
+// - Given value isn't a pointer, so it's just returned as-is.
+// - Given value is a non-nil pointer, in which case it is dereferenced
+//   and the result returned.
+// - Given value is a nil pointer, in which case an invalid value is returned.
+//
+// For nested pointer types, like **int, they are all dereferenced in turn
+// until a non-pointer value is found, or until a nil pointer is encountered.
+func toCtyUnwrapPointer(val reflect.Value) reflect.Value {
+	for val.Kind() == reflect.Ptr || val.Kind() == reflect.Interface {
+		if val.IsNil() {
+			return reflect.Value{}
+		}
+
+		val = val.Elem()
+	}
+
+	return val
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/out.go b/vendor/github.com/zclconf/go-cty/cty/gocty/out.go
new file mode 100644
index 00000000..e9c2599e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/out.go
@@ -0,0 +1,686 @@
+package gocty
+
+import (
+	"math"
+	"math/big"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FromCtyValue assigns a cty.Value to a reflect.Value, which must be a pointer,
+// using a fixed set of conversion rules.
+//
+// This function considers its audience to be the creator of the cty Value
+// given, and thus the error messages it generates are (unlike with ToCtyValue)
+// presented in cty terminology that is generally appropriate to return to
+// end-users in applications where cty data structures are built from
+// user-provided configuration. In particular this means that if incorrect
+// target types are provided by the calling application the resulting error
+// messages are likely to be confusing, since we assume that the given target
+// type is correct and the cty.Value is where the error lies.
+//
+// If an error is returned, the target data structure may have been partially
+// populated, but the degree to which this is true is an implementation
+// detail that the calling application should not rely on.
+//
+// The function will panic if given a non-pointer as the Go value target,
+// since that is considered to be a bug in the calling program.
+func FromCtyValue(val cty.Value, target interface{}) error {
+	tVal := reflect.ValueOf(target)
+	if tVal.Kind() != reflect.Ptr {
+		panic("target value is not a pointer")
+	}
+	if tVal.IsNil() {
+		panic("target value is nil pointer")
+	}
+
+	// 'path' starts off as empty but will grow for each level of recursive
+	// call we make, so by the time fromCtyValue returns it is likely to have
+	// unused capacity on the end of it, depending on how deeply-recursive
+	// the given cty.Value is.
+	path := make(cty.Path, 0)
+	return fromCtyValue(val, tVal, path)
+}
+
+func fromCtyValue(val cty.Value, target reflect.Value, path cty.Path) error {
+	ty := val.Type()
+
+	deepTarget := fromCtyPopulatePtr(target, false)
+
+	// If we're decoding into a cty.Value then we just pass through the
+	// value as-is, to enable partial decoding. This is the only situation
+	// where unknown values are permitted.
+	if deepTarget.Kind() == reflect.Struct && deepTarget.Type().AssignableTo(valueType) {
+		deepTarget.Set(reflect.ValueOf(val))
+		return nil
+	}
+
+	// Lists and maps can be nil without indirection, but everything else
+	// requires a pointer and we set it immediately to nil.
+	// We also make an exception for capsule types because we want to handle
+	// pointers specially for these.
+	// (fromCtyList and fromCtyMap must therefore deal with val.IsNull, while
+	// other types can assume no nulls after this point.)
+	if val.IsNull() && !val.Type().IsListType() && !val.Type().IsMapType() && !val.Type().IsCapsuleType() {
+		target = fromCtyPopulatePtr(target, true)
+		if target.Kind() != reflect.Ptr {
+			return path.NewErrorf("null value is not allowed")
+		}
+
+		target.Set(reflect.Zero(target.Type()))
+		return nil
+	}
+
+	target = deepTarget
+
+	if !val.IsKnown() {
+		return path.NewErrorf("value must be known")
+	}
+
+	switch ty {
+	case cty.Bool:
+		return fromCtyBool(val, target, path)
+	case cty.Number:
+		return fromCtyNumber(val, target, path)
+	case cty.String:
+		return fromCtyString(val, target, path)
+	}
+
+	switch {
+	case ty.IsListType():
+		return fromCtyList(val, target, path)
+	case ty.IsMapType():
+		return fromCtyMap(val, target, path)
+	case ty.IsSetType():
+		return fromCtySet(val, target, path)
+	case ty.IsObjectType():
+		return fromCtyObject(val, target, path)
+	case ty.IsTupleType():
+		return fromCtyTuple(val, target, path)
+	case ty.IsCapsuleType():
+		return fromCtyCapsule(val, target, path)
+	}
+
+	// We should never fall out here; reaching here indicates a bug in this
+	// function.
+	return path.NewErrorf("unsupported source type %#v", ty)
+}
+
+func fromCtyBool(val cty.Value, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+
+	case reflect.Bool:
+		target.SetBool(val.True())
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyNumber(val cty.Value, target reflect.Value, path cty.Path) error {
+	bf := val.AsBigFloat()
+
+	switch target.Kind() {
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return fromCtyNumberInt(bf, target, path)
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return fromCtyNumberUInt(bf, target, path)
+
+	case reflect.Float32, reflect.Float64:
+		return fromCtyNumberFloat(bf, target, path)
+
+	case reflect.Struct:
+		return fromCtyNumberBig(bf, target, path)
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyNumberInt(bf *big.Float, target reflect.Value, path cty.Path) error {
+	// Doing this with switch rather than << arithmetic because << with
+	// result >32-bits is not portable to 32-bit systems.
+	var min int64
+	var max int64
+	switch target.Type().Bits() {
+	case 8:
+		min = math.MinInt8
+		max = math.MaxInt8
+	case 16:
+		min = math.MinInt16
+		max = math.MaxInt16
+	case 32:
+		min = math.MinInt32
+		max = math.MaxInt32
+	case 64:
+		min = math.MinInt64
+		max = math.MaxInt64
+	default:
+		panic("weird number of bits in target int")
+	}
+
+	iv, accuracy := bf.Int64()
+	if accuracy != big.Exact || iv < min || iv > max {
+		return path.NewErrorf("value must be a whole number, between %d and %d", min, max)
+	}
+
+	target.SetInt(iv)
+	return nil
+}
+
+func fromCtyNumberUInt(bf *big.Float, target reflect.Value, path cty.Path) error {
+	// Doing this with switch rather than << arithmetic because << with
+	// result >32-bits is not portable to 32-bit systems.
+	var max uint64
+	switch target.Type().Bits() {
+	case 8:
+		max = math.MaxUint8
+	case 16:
+		max = math.MaxUint16
+	case 32:
+		max = math.MaxUint32
+	case 64:
+		max = math.MaxUint64
+	default:
+		panic("weird number of bits in target uint")
+	}
+
+	iv, accuracy := bf.Uint64()
+	if accuracy != big.Exact || iv > max {
+		return path.NewErrorf("value must be a whole number, between 0 and %d inclusive", max)
+	}
+
+	target.SetUint(iv)
+	return nil
+}
+
+func fromCtyNumberFloat(bf *big.Float, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+	case reflect.Float32, reflect.Float64:
+		fv, accuracy := bf.Float64()
+		if accuracy != big.Exact {
+			// We allow the precision to be truncated as part of our conversion,
+			// but we don't want to silently introduce infinities.
+			if math.IsInf(fv, 0) {
+				return path.NewErrorf("value must be between %f and %f inclusive", -math.MaxFloat64, math.MaxFloat64)
+			}
+		}
+		target.SetFloat(fv)
+		return nil
+	default:
+		panic("unsupported kind of float")
+	}
+}
+
+func fromCtyNumberBig(bf *big.Float, target reflect.Value, path cty.Path) error {
+	switch {
+
+	case bigFloatType.ConvertibleTo(target.Type()):
+		// Easy!
+		target.Set(reflect.ValueOf(bf).Elem().Convert(target.Type()))
+		return nil
+
+	case bigIntType.ConvertibleTo(target.Type()):
+		bi, accuracy := bf.Int(nil)
+		if accuracy != big.Exact {
+			return path.NewErrorf("value must be a whole number")
+		}
+		target.Set(reflect.ValueOf(bi).Elem().Convert(target.Type()))
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+	}
+}
+
+func fromCtyString(val cty.Value, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+	case reflect.String:
+		target.SetString(val.AsString())
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyList(val cty.Value, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+
+	case reflect.Slice:
+		if val.IsNull() {
+			target.Set(reflect.Zero(target.Type()))
+			return nil
+		}
+
+		length := val.LengthInt()
+		tv := reflect.MakeSlice(target.Type(), length, length)
+
+		path = append(path, nil)
+
+		i := 0
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			targetElem := tv.Index(i)
+			err = fromCtyValue(val, targetElem, path)
+			if err != nil {
+				return true
+			}
+
+			i++
+			return false
+		})
+		if err != nil {
+			return err
+		}
+
+		path = path[:len(path)-1]
+
+		target.Set(tv)
+		return nil
+
+	case reflect.Array:
+		if val.IsNull() {
+			return path.NewErrorf("null value is not allowed")
+		}
+
+		length := val.LengthInt()
+		if length != target.Len() {
+			return path.NewErrorf("must be a list of length %d", target.Len())
+		}
+
+		path = append(path, nil)
+
+		i := 0
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			targetElem := target.Index(i)
+			err = fromCtyValue(val, targetElem, path)
+			if err != nil {
+				return true
+			}
+
+			i++
+			return false
+		})
+		if err != nil {
+			return err
+		}
+
+		path = path[:len(path)-1]
+
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyMap(val cty.Value, target reflect.Value, path cty.Path) error {
+
+	switch target.Kind() {
+
+	case reflect.Map:
+		if val.IsNull() {
+			target.Set(reflect.Zero(target.Type()))
+			return nil
+		}
+
+		tv := reflect.MakeMap(target.Type())
+		et := target.Type().Elem()
+
+		path = append(path, nil)
+
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			path[len(path)-1] = cty.IndexStep{
+				Key: key,
+			}
+
+			ks := key.AsString()
+
+			targetElem := reflect.New(et)
+			err = fromCtyValue(val, targetElem, path)
+
+			tv.SetMapIndex(reflect.ValueOf(ks), targetElem.Elem())
+
+			return err != nil
+		})
+		if err != nil {
+			return err
+		}
+
+		path = path[:len(path)-1]
+
+		target.Set(tv)
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtySet(val cty.Value, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+
+	case reflect.Slice:
+		if val.IsNull() {
+			target.Set(reflect.Zero(target.Type()))
+			return nil
+		}
+
+		length := val.LengthInt()
+		tv := reflect.MakeSlice(target.Type(), length, length)
+
+		i := 0
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			targetElem := tv.Index(i)
+			err = fromCtyValue(val, targetElem, path)
+			if err != nil {
+				return true
+			}
+
+			i++
+			return false
+		})
+		if err != nil {
+			return err
+		}
+
+		target.Set(tv)
+		return nil
+
+	case reflect.Array:
+		if val.IsNull() {
+			return path.NewErrorf("null value is not allowed")
+		}
+
+		length := val.LengthInt()
+		if length != target.Len() {
+			return path.NewErrorf("must be a set of length %d", target.Len())
+		}
+
+		i := 0
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			targetElem := target.Index(i)
+			err = fromCtyValue(val, targetElem, path)
+			if err != nil {
+				return true
+			}
+
+			i++
+			return false
+		})
+		if err != nil {
+			return err
+		}
+
+		return nil
+
+	// TODO: decode into set.Set instance
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyObject(val cty.Value, target reflect.Value, path cty.Path) error {
+
+	switch target.Kind() {
+
+	case reflect.Struct:
+
+		attrTypes := val.Type().AttributeTypes()
+		targetFields := structTagIndices(target.Type())
+
+		path = append(path, nil)
+
+		for k, i := range targetFields {
+			if _, exists := attrTypes[k]; !exists {
+				// If the field in question isn't able to represent nil,
+				// that's an error.
+				fk := target.Field(i).Kind()
+				switch fk {
+				case reflect.Ptr, reflect.Slice, reflect.Map, reflect.Interface:
+					// okay
+				default:
+					return path.NewErrorf("missing required attribute %q", k)
+				}
+			}
+		}
+
+		for k := range attrTypes {
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+
+			fieldIdx, exists := targetFields[k]
+			if !exists {
+				return path.NewErrorf("unsupported attribute %q", k)
+			}
+
+			ev := val.GetAttr(k)
+
+			targetField := target.Field(fieldIdx)
+			err := fromCtyValue(ev, targetField, path)
+			if err != nil {
+				return err
+			}
+		}
+
+		path = path[:len(path)-1]
+
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyTuple(val cty.Value, target reflect.Value, path cty.Path) error {
+
+	switch target.Kind() {
+
+	case reflect.Struct:
+
+		elemTypes := val.Type().TupleElementTypes()
+		fieldCount := target.Type().NumField()
+
+		if fieldCount != len(elemTypes) {
+			return path.NewErrorf("a tuple of %d elements is required", fieldCount)
+		}
+
+		path = append(path, nil)
+
+		for i := range elemTypes {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			ev := val.Index(cty.NumberIntVal(int64(i)))
+
+			targetField := target.Field(i)
+			err := fromCtyValue(ev, targetField, path)
+			if err != nil {
+				return err
+			}
+		}
+
+		path = path[:len(path)-1]
+
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyCapsule(val cty.Value, target reflect.Value, path cty.Path) error {
+
+	if target.Kind() == reflect.Ptr {
+		// Walk through indirection until we get to the last pointer,
+		// which we might set to null below.
+		target = fromCtyPopulatePtr(target, true)
+
+		if val.IsNull() {
+			target.Set(reflect.Zero(target.Type()))
+			return nil
+		}
+
+		// Since a capsule contains a pointer to an object, we'll preserve
+		// that pointer on the way out and thus allow the caller to recover
+		// the original object, rather than a copy of it.
+
+		eType := val.Type().EncapsulatedType()
+
+		if !eType.AssignableTo(target.Elem().Type()) {
+			// Our interface contract promises that we won't expose Go
+			// implementation details in error messages, so we need to keep
+			// this vague. This can only arise if a calling application has
+			// more than one capsule type in play and a user mixes them up.
+			return path.NewErrorf("incorrect type %s", val.Type().FriendlyName())
+		}
+
+		target.Set(reflect.ValueOf(val.EncapsulatedValue()))
+
+		return nil
+	} else {
+		if val.IsNull() {
+			return path.NewErrorf("null value is not allowed")
+		}
+
+		// If our target isn't a pointer then we will attempt to copy
+		// the encapsulated value into it.
+
+		eType := val.Type().EncapsulatedType()
+
+		if !eType.AssignableTo(target.Type()) {
+			// Our interface contract promises that we won't expose Go
+			// implementation details in error messages, so we need to keep
+			// this vague. This can only arise if a calling application has
+			// more than one capsule type in play and a user mixes them up.
+			return path.NewErrorf("incorrect type %s", val.Type().FriendlyName())
+		}
+
+		// We know that EncapsulatedValue is always a pointer, so we
+		// can safely call .Elem on its reflect.Value.
+		target.Set(reflect.ValueOf(val.EncapsulatedValue()).Elem())
+
+		return nil
+	}
+
+}
+
+// fromCtyPopulatePtr recognizes when target is a pointer type and allocates
+// a value to assign to that pointer, which it returns.
+//
+// If the given value has multiple levels of indirection, like **int, these
+// will be processed in turn so that the return value is guaranteed to be
+// a non-pointer.
+//
+// As an exception, if decodingNull is true then the returned value will be
+// the final level of pointer, if any, so that the caller can assign it
+// as nil to represent a null value. If the given target value is not a pointer
+// at all then the returned value will be just the given target, so the caller
+// must test if the returned value is a pointer before trying to assign nil
+// to it.
+func fromCtyPopulatePtr(target reflect.Value, decodingNull bool) reflect.Value {
+	for {
+		if target.Kind() == reflect.Interface && !target.IsNil() {
+			e := target.Elem()
+			if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
+				target = e
+			}
+		}
+
+		if target.Kind() != reflect.Ptr {
+			break
+		}
+
+		// Stop early if we're decodingNull and we've found our last indirection
+		if target.Elem().Kind() != reflect.Ptr && decodingNull && target.CanSet() {
+			break
+		}
+
+		if target.IsNil() {
+			target.Set(reflect.New(target.Type().Elem()))
+		}
+
+		target = target.Elem()
+	}
+	return target
+}
+
+// likelyRequiredTypesError returns an error that states which types are
+// acceptable by making some assumptions about what types we support for
+// each target Go kind. It's not a precise science but it allows us to return
+// an error message that is cty-user-oriented rather than Go-oriented.
+//
+// Generally these error messages should be a matter of last resort, since
+// the calling application should be validating user-provided value types
+// before decoding anyway.
+func likelyRequiredTypesError(path cty.Path, target reflect.Value) error {
+	switch target.Kind() {
+
+	case reflect.Bool:
+		return path.NewErrorf("bool value is required")
+
+	case reflect.String:
+		return path.NewErrorf("string value is required")
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		fallthrough
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		fallthrough
+	case reflect.Float32, reflect.Float64:
+		return path.NewErrorf("number value is required")
+
+	case reflect.Slice, reflect.Array:
+		return path.NewErrorf("list or set value is required")
+
+	case reflect.Map:
+		return path.NewErrorf("map or object value is required")
+
+	case reflect.Struct:
+		switch {
+
+		case target.Type().AssignableTo(bigFloatType) || target.Type().AssignableTo(bigIntType):
+			return path.NewErrorf("number value is required")
+
+		case target.Type().AssignableTo(setType):
+			return path.NewErrorf("set or list value is required")
+
+		default:
+			return path.NewErrorf("object or tuple value is required")
+
+		}
+
+	default:
+		// We should avoid getting into this path, since this error
+		// message is rather useless.
+		return path.NewErrorf("incorrect type")
+
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go b/vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go
new file mode 100644
index 00000000..ce4c8f1e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go
@@ -0,0 +1,108 @@
+package gocty
+
+import (
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// ImpliedType takes an arbitrary Go value (as an interface{}) and attempts
+// to find a suitable cty.Type instance that could be used for a conversion
+// with ToCtyValue.
+//
+// This allows -- for simple situations at least -- types to be defined just
+// once in Go and the cty types derived from the Go types, but in the process
+// it makes some assumptions that may be undesirable so applications are
+// encouraged to build their cty types directly if exacting control is
+// required.
+//
+// Not all Go types can be represented as cty types, so an error may be
+// returned which is usually considered to be a bug in the calling program.
+// In particular, ImpliedType will never use capsule types in its returned
+// type, because it cannot know the capsule types supported by the calling
+// program.
+func ImpliedType(gv interface{}) (cty.Type, error) {
+	rt := reflect.TypeOf(gv)
+	var path cty.Path
+	return impliedType(rt, path)
+}
+
+func impliedType(rt reflect.Type, path cty.Path) (cty.Type, error) {
+	switch rt.Kind() {
+
+	case reflect.Ptr:
+		return impliedType(rt.Elem(), path)
+
+	// Primitive types
+	case reflect.Bool:
+		return cty.Bool, nil
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return cty.Number, nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return cty.Number, nil
+	case reflect.Float32, reflect.Float64:
+		return cty.Number, nil
+	case reflect.String:
+		return cty.String, nil
+
+	// Collection types
+	case reflect.Slice:
+		path := append(path, cty.IndexStep{Key: cty.UnknownVal(cty.Number)})
+		ety, err := impliedType(rt.Elem(), path)
+		if err != nil {
+			return cty.NilType, err
+		}
+		return cty.List(ety), nil
+	case reflect.Map:
+		if !stringType.AssignableTo(rt.Key()) {
+			return cty.NilType, path.NewErrorf("no cty.Type for %s (must have string keys)", rt)
+		}
+		path := append(path, cty.IndexStep{Key: cty.UnknownVal(cty.String)})
+		ety, err := impliedType(rt.Elem(), path)
+		if err != nil {
+			return cty.NilType, err
+		}
+		return cty.Map(ety), nil
+
+	// Structural types
+	case reflect.Struct:
+		return impliedStructType(rt, path)
+
+	default:
+		return cty.NilType, path.NewErrorf("no cty.Type for %s", rt)
+	}
+}
+
+func impliedStructType(rt reflect.Type, path cty.Path) (cty.Type, error) {
+	if valueType.AssignableTo(rt) {
+		// Special case: cty.Value represents cty.DynamicPseudoType, for
+		// type conformance checking.
+		return cty.DynamicPseudoType, nil
+	}
+
+	fieldIdxs := structTagIndices(rt)
+	if len(fieldIdxs) == 0 {
+		return cty.NilType, path.NewErrorf("no cty.Type for %s (no cty field tags)", rt)
+	}
+
+	atys := make(map[string]cty.Type, len(fieldIdxs))
+
+	{
+		// Temporary extension of path for attributes
+		path := append(path, nil)
+
+		for k, fi := range fieldIdxs {
+			path[len(path)-1] = cty.GetAttrStep{Name: k}
+
+			ft := rt.Field(fi).Type
+			aty, err := impliedType(ft, path)
+			if err != nil {
+				return cty.NilType, err
+			}
+
+			atys[k] = aty
+		}
+	}
+
+	return cty.Object(atys), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/doc.go b/vendor/github.com/zclconf/go-cty/cty/json/doc.go
new file mode 100644
index 00000000..8916513d
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/doc.go
@@ -0,0 +1,11 @@
+// Package json provides functions for serializing cty types and values in
+// JSON format, and for decoding them again.
+//
+// Since the cty type system is a superset of the JSON type system,
+// round-tripping through JSON is lossy unless type information is provided
+// both at encoding time and decoding time. Callers of this package are
+// therefore suggested to define their expected structure as a cty.Type
+// and pass it in consistently both when encoding and when decoding, though
+// default (type-lossy) behavior is provided for situations where the precise
+// representation of the data is not significant.
+package json
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/marshal.go b/vendor/github.com/zclconf/go-cty/cty/json/marshal.go
new file mode 100644
index 00000000..75e02577
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/marshal.go
@@ -0,0 +1,193 @@
+package json
+
+import (
+	"bytes"
+	"encoding/json"
+	"sort"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+func marshal(val cty.Value, t cty.Type, path cty.Path, b *bytes.Buffer) error {
+	if val.IsMarked() {
+		return path.NewErrorf("value has marks, so it cannot be seralized")
+	}
+
+	// If we're going to decode as DynamicPseudoType then we need to save
+	// dynamic type information to recover the real type.
+	if t == cty.DynamicPseudoType && val.Type() != cty.DynamicPseudoType {
+		return marshalDynamic(val, path, b)
+	}
+
+	if val.IsNull() {
+		b.WriteString("null")
+		return nil
+	}
+
+	if !val.IsKnown() {
+		return path.NewErrorf("value is not known")
+	}
+
+	// The caller should've guaranteed that the given val is conformant with
+	// the given type t, so we'll proceed under that assumption here.
+
+	switch {
+	case t.IsPrimitiveType():
+		switch t {
+		case cty.String:
+			json, err := json.Marshal(val.AsString())
+			if err != nil {
+				return path.NewErrorf("failed to serialize value: %s", err)
+			}
+			b.Write(json)
+			return nil
+		case cty.Number:
+			if val.RawEquals(cty.PositiveInfinity) || val.RawEquals(cty.NegativeInfinity) {
+				return path.NewErrorf("cannot serialize infinity as JSON")
+			}
+			b.WriteString(val.AsBigFloat().Text('f', -1))
+			return nil
+		case cty.Bool:
+			if val.True() {
+				b.WriteString("true")
+			} else {
+				b.WriteString("false")
+			}
+			return nil
+		default:
+			panic("unsupported primitive type")
+		}
+	case t.IsListType(), t.IsSetType():
+		b.WriteRune('[')
+		first := true
+		ety := t.ElementType()
+		it := val.ElementIterator()
+		path := append(path, nil) // local override of 'path' with extra element
+		for it.Next() {
+			if !first {
+				b.WriteRune(',')
+			}
+			ek, ev := it.Element()
+			path[len(path)-1] = cty.IndexStep{
+				Key: ek,
+			}
+			err := marshal(ev, ety, path, b)
+			if err != nil {
+				return err
+			}
+			first = false
+		}
+		b.WriteRune(']')
+		return nil
+	case t.IsMapType():
+		b.WriteRune('{')
+		first := true
+		ety := t.ElementType()
+		it := val.ElementIterator()
+		path := append(path, nil) // local override of 'path' with extra element
+		for it.Next() {
+			if !first {
+				b.WriteRune(',')
+			}
+			ek, ev := it.Element()
+			path[len(path)-1] = cty.IndexStep{
+				Key: ek,
+			}
+			var err error
+			err = marshal(ek, ek.Type(), path, b)
+			if err != nil {
+				return err
+			}
+			b.WriteRune(':')
+			err = marshal(ev, ety, path, b)
+			if err != nil {
+				return err
+			}
+			first = false
+		}
+		b.WriteRune('}')
+		return nil
+	case t.IsTupleType():
+		b.WriteRune('[')
+		etys := t.TupleElementTypes()
+		it := val.ElementIterator()
+		path := append(path, nil) // local override of 'path' with extra element
+		i := 0
+		for it.Next() {
+			if i > 0 {
+				b.WriteRune(',')
+			}
+			ety := etys[i]
+			ek, ev := it.Element()
+			path[len(path)-1] = cty.IndexStep{
+				Key: ek,
+			}
+			err := marshal(ev, ety, path, b)
+			if err != nil {
+				return err
+			}
+			i++
+		}
+		b.WriteRune(']')
+		return nil
+	case t.IsObjectType():
+		b.WriteRune('{')
+		atys := t.AttributeTypes()
+		path := append(path, nil) // local override of 'path' with extra element
+
+		names := make([]string, 0, len(atys))
+		for k := range atys {
+			names = append(names, k)
+		}
+		sort.Strings(names)
+
+		for i, k := range names {
+			aty := atys[k]
+			if i > 0 {
+				b.WriteRune(',')
+			}
+			av := val.GetAttr(k)
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+			var err error
+			err = marshal(cty.StringVal(k), cty.String, path, b)
+			if err != nil {
+				return err
+			}
+			b.WriteRune(':')
+			err = marshal(av, aty, path, b)
+			if err != nil {
+				return err
+			}
+		}
+		b.WriteRune('}')
+		return nil
+	case t.IsCapsuleType():
+		rawVal := val.EncapsulatedValue()
+		jsonVal, err := json.Marshal(rawVal)
+		if err != nil {
+			return path.NewError(err)
+		}
+		b.Write(jsonVal)
+		return nil
+	default:
+		// should never happen
+		return path.NewErrorf("cannot JSON-serialize %s", t.FriendlyName())
+	}
+}
+
+// marshalDynamic adds an extra wrapping object containing dynamic type
+// information for the given value.
+func marshalDynamic(val cty.Value, path cty.Path, b *bytes.Buffer) error {
+	typeJSON, err := MarshalType(val.Type())
+	if err != nil {
+		return path.NewErrorf("failed to serialize type: %s", err)
+	}
+	b.WriteString(`{"value":`)
+	marshal(val, val.Type(), path, b)
+	b.WriteString(`,"type":`)
+	b.Write(typeJSON)
+	b.WriteRune('}')
+	return nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/simple.go b/vendor/github.com/zclconf/go-cty/cty/json/simple.go
new file mode 100644
index 00000000..507c9cc2
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/simple.go
@@ -0,0 +1,41 @@
+package json
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// SimpleJSONValue is a wrapper around cty.Value that adds implementations of
+// json.Marshaler and json.Unmarshaler for simple-but-type-lossy automatic
+// encoding and decoding of values.
+//
+// The couplet Marshal and Unmarshal both take extra type information to
+// inform the encoding and decoding process so that all of the cty types
+// can be represented even though JSON's type system is a subset.
+//
+// SimpleJSONValue instead takes the approach of discarding the value's type
+// information and then deriving a new type from the stored structure when
+// decoding. This results in the same data being returned but not necessarily
+// with exactly the same type.
+//
+// For information on how types are inferred when decoding, see the
+// documentation of the function ImpliedType.
+type SimpleJSONValue struct {
+	cty.Value
+}
+
+// MarshalJSON is an implementation of json.Marshaler. See the documentation
+// of SimpleJSONValue for more information.
+func (v SimpleJSONValue) MarshalJSON() ([]byte, error) {
+	return Marshal(v.Value, v.Type())
+}
+
+// UnmarshalJSON is an implementation of json.Unmarshaler. See the
+// documentation of SimpleJSONValue for more information.
+func (v *SimpleJSONValue) UnmarshalJSON(buf []byte) error {
+	t, err := ImpliedType(buf)
+	if err != nil {
+		return err
+	}
+	v.Value, err = Unmarshal(buf, t)
+	return err
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/type.go b/vendor/github.com/zclconf/go-cty/cty/json/type.go
new file mode 100644
index 00000000..9131c6c7
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/type.go
@@ -0,0 +1,23 @@
+package json
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// MarshalType returns a JSON serialization of the given type.
+//
+// This is just a thin wrapper around t.MarshalJSON, for symmetry with
+// UnmarshalType.
+func MarshalType(t cty.Type) ([]byte, error) {
+	return t.MarshalJSON()
+}
+
+// UnmarshalType decodes a JSON serialization of the given type as produced
+// by either Type.MarshalJSON or MarshalType.
+//
+// This is a convenience wrapper around Type.UnmarshalJSON.
+func UnmarshalType(buf []byte) (cty.Type, error) {
+	var t cty.Type
+	err := t.UnmarshalJSON(buf)
+	return t, err
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go b/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go
new file mode 100644
index 00000000..0fa13f6c
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go
@@ -0,0 +1,170 @@
+package json
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// ImpliedType returns the cty Type implied by the structure of the given
+// JSON-compliant buffer. This function implements the default type mapping
+// behavior used when decoding arbitrary JSON without explicit cty Type
+// information.
+//
+// The rules are as follows:
+//
+// JSON strings, numbers and bools map to their equivalent primitive type in
+// cty.
+//
+// JSON objects map to cty object types, with the attributes defined by the
+// object keys and the types of their values.
+//
+// JSON arrays map to cty tuple types, with the elements defined by the
+// types of the array members.
+//
+// Any nulls are typed as DynamicPseudoType, so callers of this function
+// must be prepared to deal with this. Callers that do not wish to deal with
+// dynamic typing should not use this function and should instead describe
+// their required types explicitly with a cty.Type instance when decoding.
+//
+// Any JSON syntax errors will be returned as an error, and the type will
+// be the invalid value cty.NilType.
+func ImpliedType(buf []byte) (cty.Type, error) {
+	r := bytes.NewReader(buf)
+	dec := json.NewDecoder(r)
+	dec.UseNumber()
+
+	ty, err := impliedType(dec)
+	if err != nil {
+		return cty.NilType, err
+	}
+
+	if dec.More() {
+		return cty.NilType, fmt.Errorf("extraneous data after JSON object")
+	}
+
+	return ty, nil
+}
+
+func impliedType(dec *json.Decoder) (cty.Type, error) {
+	tok, err := dec.Token()
+	if err != nil {
+		return cty.NilType, err
+	}
+
+	return impliedTypeForTok(tok, dec)
+}
+
+func impliedTypeForTok(tok json.Token, dec *json.Decoder) (cty.Type, error) {
+	if tok == nil {
+		return cty.DynamicPseudoType, nil
+	}
+
+	switch ttok := tok.(type) {
+	case bool:
+		return cty.Bool, nil
+
+	case json.Number:
+		return cty.Number, nil
+
+	case string:
+		return cty.String, nil
+
+	case json.Delim:
+
+		switch rune(ttok) {
+		case '{':
+			return impliedObjectType(dec)
+		case '[':
+			return impliedTupleType(dec)
+		default:
+			return cty.NilType, fmt.Errorf("unexpected token %q", ttok)
+		}
+
+	default:
+		return cty.NilType, fmt.Errorf("unsupported JSON token %#v", tok)
+	}
+}
+
+func impliedObjectType(dec *json.Decoder) (cty.Type, error) {
+	// By the time we get in here, we've already consumed the { delimiter
+	// and so our next token should be the first object key.
+
+	var atys map[string]cty.Type
+
+	for {
+		// Read the object key first
+		tok, err := dec.Token()
+		if err != nil {
+			return cty.NilType, err
+		}
+
+		if ttok, ok := tok.(json.Delim); ok {
+			if rune(ttok) != '}' {
+				return cty.NilType, fmt.Errorf("unexpected delimiter %q", ttok)
+			}
+			break
+		}
+
+		key, ok := tok.(string)
+		if !ok {
+			return cty.NilType, fmt.Errorf("expected string but found %T", tok)
+		}
+
+		// Now read the value
+		tok, err = dec.Token()
+		if err != nil {
+			return cty.NilType, err
+		}
+
+		aty, err := impliedTypeForTok(tok, dec)
+		if err != nil {
+			return cty.NilType, err
+		}
+
+		if atys == nil {
+			atys = make(map[string]cty.Type)
+		}
+		atys[key] = aty
+	}
+
+	if len(atys) == 0 {
+		return cty.EmptyObject, nil
+	}
+
+	return cty.Object(atys), nil
+}
+
+func impliedTupleType(dec *json.Decoder) (cty.Type, error) {
+	// By the time we get in here, we've already consumed the [ delimiter
+	// and so our next token should be the first value.
+
+	var etys []cty.Type
+
+	for {
+		tok, err := dec.Token()
+		if err != nil {
+			return cty.NilType, err
+		}
+
+		if ttok, ok := tok.(json.Delim); ok {
+			if rune(ttok) == ']' {
+				break
+			}
+		}
+
+		ety, err := impliedTypeForTok(tok, dec)
+		if err != nil {
+			return cty.NilType, err
+		}
+		etys = append(etys, ety)
+	}
+
+	if len(etys) == 0 {
+		return cty.EmptyTuple, nil
+	}
+
+	return cty.Tuple(etys), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go b/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go
new file mode 100644
index 00000000..38106455
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go
@@ -0,0 +1,459 @@
+package json
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+)
+
+func unmarshal(buf []byte, t cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+
+	tok, err := dec.Token()
+	if err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if tok == nil {
+		return cty.NullVal(t), nil
+	}
+
+	if t == cty.DynamicPseudoType {
+		return unmarshalDynamic(buf, path)
+	}
+
+	switch {
+	case t.IsPrimitiveType():
+		val, err := unmarshalPrimitive(tok, t, path)
+		if err != nil {
+			return cty.NilVal, err
+		}
+		return val, nil
+	case t.IsListType():
+		return unmarshalList(buf, t.ElementType(), path)
+	case t.IsSetType():
+		return unmarshalSet(buf, t.ElementType(), path)
+	case t.IsMapType():
+		return unmarshalMap(buf, t.ElementType(), path)
+	case t.IsTupleType():
+		return unmarshalTuple(buf, t.TupleElementTypes(), path)
+	case t.IsObjectType():
+		return unmarshalObject(buf, t.AttributeTypes(), path)
+	case t.IsCapsuleType():
+		return unmarshalCapsule(buf, t, path)
+	default:
+		return cty.NilVal, path.NewErrorf("unsupported type %s", t.FriendlyName())
+	}
+}
+
+func unmarshalPrimitive(tok json.Token, t cty.Type, path cty.Path) (cty.Value, error) {
+
+	switch t {
+	case cty.Bool:
+		switch v := tok.(type) {
+		case bool:
+			return cty.BoolVal(v), nil
+		case string:
+			val, err := convert.Convert(cty.StringVal(v), t)
+			if err != nil {
+				return cty.NilVal, path.NewError(err)
+			}
+			return val, nil
+		default:
+			return cty.NilVal, path.NewErrorf("bool is required")
+		}
+	case cty.Number:
+		if v, ok := tok.(json.Number); ok {
+			tok = string(v)
+		}
+		switch v := tok.(type) {
+		case string:
+			val, err := cty.ParseNumberVal(v)
+			if err != nil {
+				return cty.NilVal, path.NewError(err)
+			}
+			return val, nil
+		default:
+			return cty.NilVal, path.NewErrorf("number is required")
+		}
+	case cty.String:
+		switch v := tok.(type) {
+		case string:
+			return cty.StringVal(v), nil
+		case json.Number:
+			return cty.StringVal(string(v)), nil
+		case bool:
+			val, err := convert.Convert(cty.BoolVal(v), t)
+			if err != nil {
+				return cty.NilVal, path.NewError(err)
+			}
+			return val, nil
+		default:
+			return cty.NilVal, path.NewErrorf("string is required")
+		}
+	default:
+		// should never happen
+		panic("unsupported primitive type")
+	}
+}
+
+func unmarshalList(buf []byte, ety cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '['); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	var vals []cty.Value
+
+	{
+		path := append(path, nil)
+		var idx int64
+
+		for dec.More() {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(idx),
+			}
+			idx++
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read list value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals = append(vals, el)
+		}
+	}
+
+	if err := requireDelim(dec, ']'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if len(vals) == 0 {
+		return cty.ListValEmpty(ety), nil
+	}
+
+	return cty.ListVal(vals), nil
+}
+
+func unmarshalSet(buf []byte, ety cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '['); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	var vals []cty.Value
+
+	{
+		path := append(path, nil)
+
+		for dec.More() {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.UnknownVal(ety),
+			}
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read set value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals = append(vals, el)
+		}
+	}
+
+	if err := requireDelim(dec, ']'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if len(vals) == 0 {
+		return cty.SetValEmpty(ety), nil
+	}
+
+	return cty.SetVal(vals), nil
+}
+
+func unmarshalMap(buf []byte, ety cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '{'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	vals := make(map[string]cty.Value)
+
+	{
+		path := append(path, nil)
+
+		for dec.More() {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.UnknownVal(cty.String),
+			}
+
+			var err error
+
+			k, err := requireObjectKey(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read map key: %s", err)
+			}
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.StringVal(k),
+			}
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read map value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals[k] = el
+		}
+	}
+
+	if err := requireDelim(dec, '}'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if len(vals) == 0 {
+		return cty.MapValEmpty(ety), nil
+	}
+
+	return cty.MapVal(vals), nil
+}
+
+func unmarshalTuple(buf []byte, etys []cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '['); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	var vals []cty.Value
+
+	{
+		path := append(path, nil)
+		var idx int
+
+		for dec.More() {
+			if idx >= len(etys) {
+				return cty.NilVal, path[:len(path)-1].NewErrorf("too many tuple elements (need %d)", len(etys))
+			}
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(idx)),
+			}
+			ety := etys[idx]
+			idx++
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read tuple value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals = append(vals, el)
+		}
+	}
+
+	if err := requireDelim(dec, ']'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if len(vals) != len(etys) {
+		return cty.NilVal, path[:len(path)-1].NewErrorf("not enough tuple elements (need %d)", len(etys))
+	}
+
+	if len(vals) == 0 {
+		return cty.EmptyTupleVal, nil
+	}
+
+	return cty.TupleVal(vals), nil
+}
+
+func unmarshalObject(buf []byte, atys map[string]cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '{'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	vals := make(map[string]cty.Value)
+
+	{
+		objPath := path           // some errors report from the object's perspective
+		path := append(path, nil) // path to a specific attribute
+
+		for dec.More() {
+
+			var err error
+
+			k, err := requireObjectKey(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read object key: %s", err)
+			}
+
+			aty, ok := atys[k]
+			if !ok {
+				return cty.NilVal, objPath.NewErrorf("unsupported attribute %q", k)
+			}
+
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read object value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, aty, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals[k] = el
+		}
+	}
+
+	if err := requireDelim(dec, '}'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	// Make sure we have a value for every attribute
+	for k, aty := range atys {
+		if _, exists := vals[k]; !exists {
+			vals[k] = cty.NullVal(aty)
+		}
+	}
+
+	if len(vals) == 0 {
+		return cty.EmptyObjectVal, nil
+	}
+
+	return cty.ObjectVal(vals), nil
+}
+
+func unmarshalCapsule(buf []byte, t cty.Type, path cty.Path) (cty.Value, error) {
+	rawType := t.EncapsulatedType()
+	ptrPtr := reflect.New(reflect.PtrTo(rawType))
+	ptrPtr.Elem().Set(reflect.New(rawType))
+	ptr := ptrPtr.Elem().Interface()
+	err := json.Unmarshal(buf, ptr)
+	if err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	return cty.CapsuleVal(t, ptr), nil
+}
+
+func unmarshalDynamic(buf []byte, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '{'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	var t cty.Type
+	var valBody []byte // defer actual decoding until we know the type
+
+	for dec.More() {
+		var err error
+
+		key, err := requireObjectKey(dec)
+		if err != nil {
+			return cty.NilVal, path.NewErrorf("failed to read dynamic type descriptor key: %s", err)
+		}
+
+		rawVal, err := readRawValue(dec)
+		if err != nil {
+			return cty.NilVal, path.NewErrorf("failed to read dynamic type descriptor value: %s", err)
+		}
+
+		switch key {
+		case "type":
+			err := json.Unmarshal(rawVal, &t)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to decode type for dynamic value: %s", err)
+			}
+		case "value":
+			valBody = rawVal
+		default:
+			return cty.NilVal, path.NewErrorf("invalid key %q in dynamically-typed value", key)
+		}
+
+	}
+
+	if err := requireDelim(dec, '}'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if t == cty.NilType {
+		return cty.NilVal, path.NewErrorf("missing type in dynamically-typed value")
+	}
+	if valBody == nil {
+		return cty.NilVal, path.NewErrorf("missing value in dynamically-typed value")
+	}
+
+	val, err := Unmarshal([]byte(valBody), t)
+	if err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+	return val, nil
+}
+
+func requireDelim(dec *json.Decoder, d rune) error {
+	tok, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	if tok != json.Delim(d) {
+		return fmt.Errorf("missing expected %c", d)
+	}
+
+	return nil
+}
+
+func requireObjectKey(dec *json.Decoder) (string, error) {
+	tok, err := dec.Token()
+	if err != nil {
+		return "", err
+	}
+	if s, ok := tok.(string); ok {
+		return s, nil
+	}
+	return "", fmt.Errorf("missing expected object key")
+}
+
+func readRawValue(dec *json.Decoder) ([]byte, error) {
+	var rawVal json.RawMessage
+	err := dec.Decode(&rawVal)
+	if err != nil {
+		return nil, err
+	}
+	return []byte(rawVal), nil
+}
+
+func bufDecoder(buf []byte) *json.Decoder {
+	r := bytes.NewReader(buf)
+	dec := json.NewDecoder(r)
+	dec.UseNumber()
+	return dec
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/value.go b/vendor/github.com/zclconf/go-cty/cty/json/value.go
new file mode 100644
index 00000000..f2f7dd56
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/value.go
@@ -0,0 +1,65 @@
+package json
+
+import (
+	"bytes"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+)
+
+// Marshal produces a JSON representation of the given value that can later
+// be decoded into a value of the given type.
+//
+// A type is specified separately to allow for the given type to include
+// cty.DynamicPseudoType to represent situations where any type is permitted
+// and so type information must be included to allow recovery of the stored
+// structure when decoding.
+//
+// The given type will also be used to attempt automatic conversions of any
+// non-conformant types in the given value, although this will not always
+// be possible. If the value cannot be made to be conformant then an error is
+// returned, which may be a cty.PathError.
+//
+// Capsule-typed values can be marshalled, but with some caveats. Since
+// capsule values are compared by pointer equality, it is impossible to recover
+// a value that will compare equal to the original value. Additionally,
+// it's not possible to JSON-serialize the capsule type itself, so it's not
+// valid to use capsule types within parts of the value that are conformed to
+// cty.DynamicPseudoType. Otherwise, a capsule value can be used as long as
+// the encapsulated type itself is serializable with the Marshal function
+// in encoding/json.
+func Marshal(val cty.Value, t cty.Type) ([]byte, error) {
+	errs := val.Type().TestConformance(t)
+	if errs != nil {
+		// Attempt a conversion
+		var err error
+		val, err = convert.Convert(val, t)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// From this point onward, val can be assumed to be conforming to t.
+
+	buf := &bytes.Buffer{}
+	var path cty.Path
+	err := marshal(val, t, path, buf)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+// Unmarshal decodes a JSON representation of the given value into a cty Value
+// conforming to the given type.
+//
+// While decoding, type conversions will be done where possible to make
+// the result conformant even if the types given in JSON are not exactly
+// correct. If conversion isn't possible then an error is returned, which
+// may be a cty.PathError.
+func Unmarshal(buf []byte, t cty.Type) (cty.Value, error) {
+	var path cty.Path
+	return unmarshal(buf, t, path)
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 3137344d..43a68c1d 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -30,6 +30,8 @@ github.com/agext/levenshtein
 # github.com/agl/ed25519 v0.0.0-20170116200512-5312a6153412
 github.com/agl/ed25519
 github.com/agl/ed25519/edwards25519
+# github.com/apparentlymart/go-textseg v1.0.0
+github.com/apparentlymart/go-textseg/textseg
 # github.com/apparentlymart/go-textseg/v12 v12.0.0
 github.com/apparentlymart/go-textseg/v12/textseg
 # github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973
@@ -179,6 +181,12 @@ github.com/golang/protobuf/ptypes
 github.com/golang/protobuf/ptypes/any
 github.com/golang/protobuf/ptypes/duration
 github.com/golang/protobuf/ptypes/timestamp
+# github.com/google/go-cmp v0.3.1
+github.com/google/go-cmp/cmp
+github.com/google/go-cmp/cmp/internal/diff
+github.com/google/go-cmp/cmp/internal/flags
+github.com/google/go-cmp/cmp/internal/function
+github.com/google/go-cmp/cmp/internal/value
 # github.com/google/gofuzz v1.0.0
 github.com/google/gofuzz
 # github.com/google/shlex v0.0.0-20150127133951-6f45313302b9
@@ -203,6 +211,12 @@ github.com/grpc-ecosystem/grpc-opentracing/go/otgrpc
 github.com/hashicorp/golang-lru/simplelru
 # github.com/hashicorp/hcl/v2 v2.4.0
 github.com/hashicorp/hcl/v2
+github.com/hashicorp/hcl/v2/ext/customdecode
+github.com/hashicorp/hcl/v2/gohcl
+github.com/hashicorp/hcl/v2/hclsimple
+github.com/hashicorp/hcl/v2/hclsyntax
+github.com/hashicorp/hcl/v2/hclwrite
+github.com/hashicorp/hcl/v2/json
 # github.com/imdario/mergo v0.3.7
 github.com/imdario/mergo
 # github.com/inconshreveable/mousetrap v1.0.0
@@ -331,6 +345,9 @@ github.com/xeipuuv/gojsonschema
 github.com/zclconf/go-cty/cty
 github.com/zclconf/go-cty/cty/convert
 github.com/zclconf/go-cty/cty/function
+github.com/zclconf/go-cty/cty/function/stdlib
+github.com/zclconf/go-cty/cty/gocty
+github.com/zclconf/go-cty/cty/json
 github.com/zclconf/go-cty/cty/set
 # go.opencensus.io v0.22.0
 go.opencensus.io