deps: github.com/hashicorp/terraform@sdk-v0.11-with-go-modules

Updated via: go get github.com/hashicorp/terraform@sdk-v0.11-with-go-modules and go mod tidy

59 files changed, 20511 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/hcl2/hcl/diagnostic.go b/vendor/github.com/hashicorp/hcl2/hcl/diagnostic.go
new file mode 100644
index 0000000..6ecf744
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/diagnostic.go
@@ -0,0 +1,103 @@
+package hcl
+
+import (
+        "fmt"
+)
+
+// DiagnosticSeverity represents the severity of a diagnostic.
+type DiagnosticSeverity int
+
+const (
+        // DiagInvalid is the invalid zero value of DiagnosticSeverity
+        DiagInvalid DiagnosticSeverity = iota
+
+        // DiagError indicates that the problem reported by a diagnostic prevents
+        // further progress in parsing and/or evaluating the subject.
+        DiagError
+
+        // DiagWarning indicates that the problem reported by a diagnostic warrants
+        // user attention but does not prevent further progress. It is most
+        // commonly used for showing deprecation notices.
+        DiagWarning
+)
+
+// Diagnostic represents information to be presented to a user about an
+// error or anomoly in parsing or evaluating configuration.
+type Diagnostic struct {
+        Severity DiagnosticSeverity
+
+        // Summary and detail contain the English-language description of the
+        // problem. Summary is a terse description of the general problem and
+        // detail is a more elaborate, often-multi-sentence description of
+        // the probem and what might be done to solve it.
+        Summary string
+        Detail  string
+        Subject *Range
+        Context *Range
+}
+
+// Diagnostics is a list of Diagnostic instances.
+type Diagnostics []*Diagnostic
+
+// error implementation, so that diagnostics can be returned via APIs
+// that normally deal in vanilla Go errors.
+//
+// This presents only minimal context about the error, for compatibility
+// with usual expectations about how errors will present as strings.
+func (d *Diagnostic) Error() string {
+        return fmt.Sprintf("%s: %s; %s", d.Subject, d.Summary, d.Detail)
+}
+
+// error implementation, so that sets of diagnostics can be returned via
+// APIs that normally deal in vanilla Go errors.
+func (d Diagnostics) Error() string {
+        count := len(d)
+        switch {
+        case count == 0:
+                return "no diagnostics"
+        case count == 1:
+                return d[0].Error()
+        default:
+                return fmt.Sprintf("%s, and %d other diagnostic(s)", d[0].Error(), count-1)
+        }
+}
+
+// Append appends a new error to a Diagnostics and return the whole Diagnostics.
+//
+// This is provided as a convenience for returning from a function that
+// collects and then returns a set of diagnostics:
+//
+//     return nil, diags.Append(&hcl.Diagnostic{ ... })
+//
+// Note that this modifies the array underlying the diagnostics slice, so
+// must be used carefully within a single codepath. It is incorrect (and rude)
+// to extend a diagnostics created by a different subsystem.
+func (d Diagnostics) Append(diag *Diagnostic) Diagnostics {
+        return append(d, diag)
+}
+
+// Extend concatenates the given Diagnostics with the receiver and returns
+// the whole new Diagnostics.
+//
+// This is similar to Append but accepts multiple diagnostics to add. It has
+// all the same caveats and constraints.
+func (d Diagnostics) Extend(diags Diagnostics) Diagnostics {
+        return append(d, diags...)
+}
+
+// HasErrors returns true if the receiver contains any diagnostics of
+// severity DiagError.
+func (d Diagnostics) HasErrors() bool {
+        for _, diag := range d {
+                if diag.Severity == DiagError {
+                        return true
+                }
+        }
+        return false
+}
+
+// A DiagnosticWriter emits diagnostics somehow.
+type DiagnosticWriter interface {
+        WriteDiagnostic(*Diagnostic) error
+        WriteDiagnostics(Diagnostics) error
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/diagnostic_text.go b/vendor/github.com/hashicorp/hcl2/hcl/diagnostic_text.go
new file mode 100644
index 0000000..dfa473a
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/diagnostic_text.go
@@ -0,0 +1,168 @@
+package hcl
+
+import (
+        "bufio"
+        "errors"
+        "fmt"
+        "io"
+
+        wordwrap "github.com/mitchellh/go-wordwrap"
+)
+
+type diagnosticTextWriter struct {
+        files map[string]*File
+        wr    io.Writer
+        width uint
+        color bool
+}
+
+// NewDiagnosticTextWriter creates a DiagnosticWriter that writes diagnostics
+// to the given writer as formatted text.
+//
+// It is designed to produce text appropriate to print in a monospaced font
+// in a terminal of a particular width, or optionally with no width limit.
+//
+// The given width may be zero to disable word-wrapping of the detail text
+// and truncation of source code snippets.
+//
+// If color is set to true, the output will include VT100 escape sequences to
+// color-code the severity indicators. It is suggested to turn this off if
+// the target writer is not a terminal.
+func NewDiagnosticTextWriter(wr io.Writer, files map[string]*File, width uint, color bool) DiagnosticWriter {
+        return &diagnosticTextWriter{
+                files: files,
+                wr:    wr,
+                width: width,
+                color: color,
+        }
+}
+
+func (w *diagnosticTextWriter) WriteDiagnostic(diag *Diagnostic) error {
+        if diag == nil {
+                return errors.New("nil diagnostic")
+        }
+
+        var colorCode, highlightCode, resetCode string
+        if w.color {
+                switch diag.Severity {
+                case DiagError:
+                        colorCode = "\x1b[31m"
+                case DiagWarning:
+                        colorCode = "\x1b[33m"
+                }
+                resetCode = "\x1b[0m"
+                highlightCode = "\x1b[1;4m"
+        }
+
+        var severityStr string
+        switch diag.Severity {
+        case DiagError:
+                severityStr = "Error"
+        case DiagWarning:
+                severityStr = "Warning"
+        default:
+                // should never happen
+                severityStr = "???????"
+        }
+
+        fmt.Fprintf(w.wr, "%s%s%s: %s\n\n", colorCode, severityStr, resetCode, diag.Summary)
+
+        if diag.Subject != nil {
+                snipRange := *diag.Subject
+                highlightRange := snipRange
+                if diag.Context != nil {
+                        // Show enough of the source code to include both the subject
+                        // and context ranges, which overlap in all reasonable
+                        // situations.
+                        snipRange = RangeOver(snipRange, *diag.Context)
+                }
+                // We can't illustrate an empty range, so we'll turn such ranges into
+                // single-character ranges, which might not be totally valid (may point
+                // off the end of a line, or off the end of the file) but are good
+                // enough for the bounds checks we do below.
+                if snipRange.Empty() {
+                        snipRange.End.Byte++
+                        snipRange.End.Column++
+                }
+                if highlightRange.Empty() {
+                        highlightRange.End.Byte++
+                        highlightRange.End.Column++
+                }
+
+                file := w.files[diag.Subject.Filename]
+                if file == nil || file.Bytes == nil {
+                        fmt.Fprintf(w.wr, "  on %s line %d:\n  (source code not available)\n\n", diag.Subject.Filename, diag.Subject.Start.Line)
+                } else {
+
+                        var contextLine string
+                        if diag.Subject != nil {
+                                contextLine = contextString(file, diag.Subject.Start.Byte)
+                                if contextLine != "" {
+                                        contextLine = ", in " + contextLine
+                                }
+                        }
+
+                        fmt.Fprintf(w.wr, "  on %s line %d%s:\n", diag.Subject.Filename, diag.Subject.Start.Line, contextLine)
+
+                        src := file.Bytes
+                        sc := NewRangeScanner(src, diag.Subject.Filename, bufio.ScanLines)
+
+                        for sc.Scan() {
+                                lineRange := sc.Range()
+                                if !lineRange.Overlaps(snipRange) {
+                                        continue
+                                }
+
+                                beforeRange, highlightedRange, afterRange := lineRange.PartitionAround(highlightRange)
+                                if highlightedRange.Empty() {
+                                        fmt.Fprintf(w.wr, "%4d: %s\n", lineRange.Start.Line, sc.Bytes())
+                                } else {
+                                        before := beforeRange.SliceBytes(src)
+                                        highlighted := highlightedRange.SliceBytes(src)
+                                        after := afterRange.SliceBytes(src)
+                                        fmt.Fprintf(
+                                                w.wr, "%4d: %s%s%s%s%s\n",
+                                                lineRange.Start.Line,
+                                                before,
+                                                highlightCode, highlighted, resetCode,
+                                                after,
+                                        )
+                                }
+
+                        }
+
+                        w.wr.Write([]byte{'\n'})
+                }
+        }
+
+        if diag.Detail != "" {
+                detail := diag.Detail
+                if w.width != 0 {
+                        detail = wordwrap.WrapString(detail, w.width)
+                }
+                fmt.Fprintf(w.wr, "%s\n\n", detail)
+        }
+
+        return nil
+}
+
+func (w *diagnosticTextWriter) WriteDiagnostics(diags Diagnostics) error {
+        for _, diag := range diags {
+                err := w.WriteDiagnostic(diag)
+                if err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+
+func contextString(file *File, offset int) string {
+        type contextStringer interface {
+                ContextString(offset int) string
+        }
+
+        if cser, ok := file.Nav.(contextStringer); ok {
+                return cser.ContextString(offset)
+        }
+        return ""
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/didyoumean.go b/vendor/github.com/hashicorp/hcl2/hcl/didyoumean.go
new file mode 100644
index 0000000..c128334
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/didyoumean.go
@@ -0,0 +1,24 @@
+package hcl
+
+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/hcl2/hcl/doc.go b/vendor/github.com/hashicorp/hcl2/hcl/doc.go
new file mode 100644
index 0000000..01318c9
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/doc.go
@@ -0,0 +1 @@
+package hcl
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/eval_context.go b/vendor/github.com/hashicorp/hcl2/hcl/eval_context.go
new file mode 100644
index 0000000..915910a
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/eval_context.go
@@ -0,0 +1,25 @@
+package hcl
+
+import (
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+// An EvalContext provides the variables and functions that should be used
+// to evaluate an expression.
+type EvalContext struct {
+        Variables map[string]cty.Value
+        Functions map[string]function.Function
+        parent    *EvalContext
+}
+
+// NewChild returns a new EvalContext that is a child of the receiver.
+func (ctx *EvalContext) NewChild() *EvalContext {
+        return &EvalContext{parent: ctx}
+}
+
+// Parent returns the parent of the receiver, or nil if the receiver has
+// no parent.
+func (ctx *EvalContext) Parent() *EvalContext {
+        return ctx.parent
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/expr_call.go b/vendor/github.com/hashicorp/hcl2/hcl/expr_call.go
new file mode 100644
index 0000000..6963fba
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/expr_call.go
@@ -0,0 +1,46 @@
+package hcl
+
+// ExprCall tests if the given expression is a function call and,
+// if so, extracts the function name and the expressions that represent
+// the arguments. If the given expression is not statically a function call,
+// error diagnostics are returned.
+//
+// A particular Expression implementation can support this function by
+// offering a method called ExprCall that takes no arguments and returns
+// *StaticCall. This method should return nil if a static call cannot
+// be extracted.  Alternatively, an implementation can support
+// UnwrapExpression to delegate handling of this function to a wrapped
+// Expression object.
+func ExprCall(expr Expression) (*StaticCall, Diagnostics) {
+        type exprCall interface {
+                ExprCall() *StaticCall
+        }
+
+        physExpr := UnwrapExpressionUntil(expr, func(expr Expression) bool {
+                _, supported := expr.(exprCall)
+                return supported
+        })
+
+        if exC, supported := physExpr.(exprCall); supported {
+                if call := exC.ExprCall(); call != nil {
+                        return call, nil
+                }
+        }
+        return nil, Diagnostics{
+                &Diagnostic{
+                        Severity: DiagError,
+                        Summary:  "Invalid expression",
+                        Detail:   "A static function call is required.",
+                        Subject:  expr.StartRange().Ptr(),
+                },
+        }
+}
+
+// StaticCall represents a function call that was extracted statically from
+// an expression using ExprCall.
+type StaticCall struct {
+        Name      string
+        NameRange Range
+        Arguments []Expression
+        ArgsRange Range
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/expr_list.go b/vendor/github.com/hashicorp/hcl2/hcl/expr_list.go
new file mode 100644
index 0000000..d05cca0
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/expr_list.go
@@ -0,0 +1,37 @@
+package hcl
+
+// ExprList tests if the given expression is a static list construct and,
+// if so, extracts the expressions that represent the list elements.
+// If the given expression is not a static list, error diagnostics are
+// returned.
+//
+// A particular Expression implementation can support this function by
+// offering a method called ExprList that takes no arguments and returns
+// []Expression. This method should return nil if a static list cannot
+// be extracted.  Alternatively, an implementation can support
+// UnwrapExpression to delegate handling of this function to a wrapped
+// Expression object.
+func ExprList(expr Expression) ([]Expression, Diagnostics) {
+        type exprList interface {
+                ExprList() []Expression
+        }
+
+        physExpr := UnwrapExpressionUntil(expr, func(expr Expression) bool {
+                _, supported := expr.(exprList)
+                return supported
+        })
+
+        if exL, supported := physExpr.(exprList); supported {
+                if list := exL.ExprList(); list != nil {
+                        return list, nil
+                }
+        }
+        return nil, Diagnostics{
+                &Diagnostic{
+                        Severity: DiagError,
+                        Summary:  "Invalid expression",
+                        Detail:   "A static list expression is required.",
+                        Subject:  expr.StartRange().Ptr(),
+                },
+        }
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/expr_map.go b/vendor/github.com/hashicorp/hcl2/hcl/expr_map.go
new file mode 100644
index 0000000..96d1ce4
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/expr_map.go
@@ -0,0 +1,44 @@
+package hcl
+
+// ExprMap tests if the given expression is a static map construct and,
+// if so, extracts the expressions that represent the map elements.
+// If the given expression is not a static map, error diagnostics are
+// returned.
+//
+// A particular Expression implementation can support this function by
+// offering a method called ExprMap that takes no arguments and returns
+// []KeyValuePair. This method should return nil if a static map cannot
+// be extracted.  Alternatively, an implementation can support
+// UnwrapExpression to delegate handling of this function to a wrapped
+// Expression object.
+func ExprMap(expr Expression) ([]KeyValuePair, Diagnostics) {
+        type exprMap interface {
+                ExprMap() []KeyValuePair
+        }
+
+        physExpr := UnwrapExpressionUntil(expr, func(expr Expression) bool {
+                _, supported := expr.(exprMap)
+                return supported
+        })
+
+        if exM, supported := physExpr.(exprMap); supported {
+                if pairs := exM.ExprMap(); pairs != nil {
+                        return pairs, nil
+                }
+        }
+        return nil, Diagnostics{
+                &Diagnostic{
+                        Severity: DiagError,
+                        Summary:  "Invalid expression",
+                        Detail:   "A static map expression is required.",
+                        Subject:  expr.StartRange().Ptr(),
+                },
+        }
+}
+
+// KeyValuePair represents a pair of expressions that serve as a single item
+// within a map or object definition construct.
+type KeyValuePair struct {
+        Key   Expression
+        Value Expression
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/expr_unwrap.go b/vendor/github.com/hashicorp/hcl2/hcl/expr_unwrap.go
new file mode 100644
index 0000000..6d5d205
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/expr_unwrap.go
@@ -0,0 +1,68 @@
+package hcl
+
+type unwrapExpression interface {
+        UnwrapExpression() Expression
+}
+
+// UnwrapExpression removes any "wrapper" expressions from the given expression,
+// to recover the representation of the physical expression given in source
+// code.
+//
+// Sometimes wrapping expressions are used to modify expression behavior, e.g.
+// in extensions that need to make some local variables available to certain
+// sub-trees of the configuration. This can make it difficult to reliably
+// type-assert on the physical AST types used by the underlying syntax.
+//
+// Unwrapping an expression may modify its behavior by stripping away any
+// additional constraints or capabilities being applied to the Value and
+// Variables methods, so this function should generally only be used prior
+// to operations that concern themselves with the static syntax of the input
+// configuration, and not with the effective value of the expression.
+//
+// Wrapper expression types must support unwrapping by implementing a method
+// called UnwrapExpression that takes no arguments and returns the embedded
+// Expression. Implementations of this method should peel away only one level
+// of wrapping, if multiple are present. This method may return nil to
+// indicate _dynamically_ that no wrapped expression is available, for
+// expression types that might only behave as wrappers in certain cases.
+func UnwrapExpression(expr Expression) Expression {
+        for {
+                unwrap, wrapped := expr.(unwrapExpression)
+                if !wrapped {
+                        return expr
+                }
+                innerExpr := unwrap.UnwrapExpression()
+                if innerExpr == nil {
+                        return expr
+                }
+                expr = innerExpr
+        }
+}
+
+// UnwrapExpressionUntil is similar to UnwrapExpression except it gives the
+// caller an opportunity to test each level of unwrapping to see each a
+// particular expression is accepted.
+//
+// This could be used, for example, to unwrap until a particular other
+// interface is satisfied, regardless of wrap wrapping level it is satisfied
+// at.
+//
+// The given callback function must return false to continue wrapping, or
+// true to accept and return the proposed expression given. If the callback
+// function rejects even the final, physical expression then the result of
+// this function is nil.
+func UnwrapExpressionUntil(expr Expression, until func(Expression) bool) Expression {
+        for {
+                if until(expr) {
+                        return expr
+                }
+                unwrap, wrapped := expr.(unwrapExpression)
+                if !wrapped {
+                        return nil
+                }
+                expr = unwrap.UnwrapExpression()
+                if expr == nil {
+                        return nil
+                }
+        }
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/didyoumean.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/didyoumean.go
new file mode 100644
index 0000000..ccc1c0a
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/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/hcl2/hcl/hclsyntax/doc.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/doc.go
new file mode 100644
index 0000000..617bc29
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/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/hcl2/hcl/hclsyntax/expression.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go
new file mode 100644
index 0000000..cfc7cd9
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go
@@ -0,0 +1,1275 @@
+package hclsyntax
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "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) {
+        return e.Traversal.TraverseAbs(ctx)
+}
+
+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) {
+        // Scope traversals have no child nodes
+}
+
+func (e *RelativeTraversalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+        src, diags := e.Source.Value(ctx)
+        ret, travDiags := e.Traversal.TraverseRel(src)
+        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 i, arg := range e.Args {
+                e.Args[i] = w(arg).(Expression)
+        }
+}
+
+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(),
+                                },
+                        }
+                }
+
+                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(),
+                        },
+                }
+        }
+
+        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.",
+                                        Context:  expandExpr.Range().Ptr(),
+                                        Subject:  e.Range().Ptr(),
+                                })
+                                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.",
+                                Context:  expandExpr.Range().Ptr(),
+                                Subject:  e.Range().Ptr(),
+                        })
+                        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(),
+                        },
+                }
+        }
+
+        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(),
+                        },
+                }
+        }
+
+        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
+                }
+
+                val, argDiags := argExpr.Value(ctx)
+                if len(argDiags) > 0 {
+                        diags = append(diags, argDiags...)
+                }
+
+                // Try to convert our value to the parameter type
+                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(),
+                        })
+                }
+
+                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(),
+                        })
+
+                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(),
+                        })
+                }
+
+                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) {
+        e.Condition = w(e.Condition).(Expression)
+        e.TrueResult = w(e.TrueResult).(Expression)
+        e.FalseResult = w(e.FalseResult).(Expression)
+}
+
+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
+
+        // 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(), falseResult.Type(),
+                                ),
+                                Subject: hcl.RangeBetween(e.TrueResult.Range(), e.FalseResult.Range()).Ptr(),
+                                Context: &e.SrcRange,
+                        },
+                }
+        }
+
+        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,
+                })
+                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,
+                })
+                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,
+                                })
+                                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.TrueResult.Range().Ptr(),
+                                        Context: &e.SrcRange,
+                                })
+                                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
+}
+
+func (e *IndexExpr) walkChildNodes(w internalWalkFunc) {
+        e.Collection = w(e.Collection).(Expression)
+        e.Key = w(e.Key).(Expression)
+}
+
+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...)
+
+        return hcl.Index(coll, key, &e.SrcRange)
+}
+
+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 i, expr := range e.Exprs {
+                e.Exprs[i] = w(expr).(Expression)
+        }
+}
+
+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 i, item := range e.Items {
+                e.Items[i].KeyExpr = w(item.KeyExpr).(Expression)
+                e.Items[i].ValueExpr = w(item.ValueExpr).(Expression)
+        }
+}
+
+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(),
+                        })
+                        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.ValueExpr.Range().Ptr(),
+                        })
+                        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
+}
+
+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() == "" {
+                e.Wrapped = w(e.Wrapped).(Expression)
+        }
+}
+
+func (e *ObjectConsKeyExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+        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 {
+        // 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,
+                })
+                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,
+                })
+                return cty.DynamicVal, diags
+        }
+        if !collVal.IsKnown() {
+                return cty.DynamicVal, diags
+        }
+
+        childCtx := ctx.NewChild()
+        childCtx.Variables = map[string]cty.Value{}
+
+        // 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 {
+                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,
+                        })
+                        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,
+                        })
+                        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()
+                        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:  "Condition is null",
+                                                        Detail:   "The value of the 'if' clause must not be null.",
+                                                        Subject:  e.CondExpr.Range().Ptr(),
+                                                        Context:  &e.SrcRange,
+                                                })
+                                        }
+                                        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,
+                                                })
+                                        }
+                                        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,
+                                        })
+                                }
+                                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,
+                                        })
+                                }
+                                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,
+                                        })
+                                } 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()
+                        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:  "Condition is null",
+                                                        Detail:   "The value of the 'if' clause must not be null.",
+                                                        Subject:  e.CondExpr.Range().Ptr(),
+                                                        Context:  &e.SrcRange,
+                                                })
+                                        }
+                                        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,
+                                                })
+                                        }
+                                        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) {
+        e.CollExpr = w(e.CollExpr).(Expression)
+
+        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
+        }
+
+        if sourceVal.IsNull() {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Splat of null value",
+                        Detail:   "Splat expressions (with the * symbol) cannot be applied to null values.",
+                        Subject:  e.Source.Range().Ptr(),
+                        Context:  hcl.RangeBetween(e.Source.Range(), e.MarkerRange).Ptr(),
+                })
+                return cty.DynamicVal, diags
+        }
+        if !sourceVal.IsKnown() {
+                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-value list. We'll
+        // deal with that here first.
+        if !(sourceVal.Type().IsTupleType() || sourceVal.Type().IsListType()) {
+                sourceVal = cty.ListVal([]cty.Value{sourceVal})
+        }
+
+        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 {
+                return cty.DynamicVal, diags
+        }
+
+        return cty.TupleVal(vals), diags
+}
+
+func (e *SplatExpr) walkChildNodes(w internalWalkFunc) {
+        e.Source = w(e.Source).(Expression)
+        e.Each = w(e.Each).(Expression)
+}
+
+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   map[*hcl.EvalContext]cty.Value
+}
+
+func (e *AnonSymbolExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+        if ctx == nil {
+                return cty.DynamicVal, nil
+        }
+        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) {
+        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) {
+        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/hcl2/hcl/hclsyntax/expression_ops.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_ops.go
new file mode 100644
index 0000000..9a5da04
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_ops.go
@@ -0,0 +1,258 @@
+package hclsyntax
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "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) {
+        e.LHS = w(e.LHS).(Expression)
+        e.RHS = w(e.RHS).(Expression)
+}
+
+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,
+                })
+        }
+        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,
+                })
+        }
+
+        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,
+                })
+                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) {
+        e.Val = w(e.Val).(Expression)
+}
+
+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,
+                })
+        }
+
+        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,
+                })
+                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/hcl2/hcl/hclsyntax/expression_template.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go
new file mode 100644
index 0000000..a1c4727
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go
@@ -0,0 +1,192 @@
+package hclsyntax
+
+import (
+        "bytes"
+        "fmt"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "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 i, part := range e.Parts {
+                e.Parts[i] = w(part).(Expression)
+        }
+}
+
+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,
+                        })
+                        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,
+                        })
+                        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()
+}
+
+// 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) {
+        e.Tuple = w(e.Tuple).(Expression)
+}
+
+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(),
+                        })
+                        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(),
+                        })
+                        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) {
+        e.Wrapped = w(e.Wrapped).(Expression)
+}
+
+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/hcl2/hcl/hclsyntax/expression_vars.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_vars.go
new file mode 100644
index 0000000..9177092
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/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/hcl2/hcl"
+)
+
+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/hcl2/hcl/hclsyntax/expression_vars_gen.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_vars_gen.go
new file mode 100644
index 0000000..88f1980
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_vars_gen.go
@@ -0,0 +1,99 @@
+// This is a 'go generate'-oriented program for producing the "Variables"
+// method on every Expression implementation found within this package.
+// All expressions share the same implementation for this method, which
+// just wraps the package-level function "Variables" and uses an AST walk
+// to do its work.
+
+// +build ignore
+
+package main
+
+import (
+        "fmt"
+        "go/ast"
+        "go/parser"
+        "go/token"
+        "os"
+        "sort"
+)
+
+func main() {
+        fs := token.NewFileSet()
+        pkgs, err := parser.ParseDir(fs, ".", nil, 0)
+        if err != nil {
+                fmt.Fprintf(os.Stderr, "error while parsing: %s\n", err)
+                os.Exit(1)
+        }
+        pkg := pkgs["hclsyntax"]
+
+        // Walk all the files and collect the receivers of any "Value" methods
+        // that look like they are trying to implement Expression.
+        var recvs []string
+        for _, f := range pkg.Files {
+                for _, decl := range f.Decls {
+                        fd, ok := decl.(*ast.FuncDecl)
+                        if !ok {
+                                continue
+                        }
+                        if fd.Name.Name != "Value" {
+                                continue
+                        }
+                        results := fd.Type.Results.List
+                        if len(results) != 2 {
+                                continue
+                        }
+                        valResult := fd.Type.Results.List[0].Type.(*ast.SelectorExpr).X.(*ast.Ident)
+                        diagsResult := fd.Type.Results.List[1].Type.(*ast.SelectorExpr).X.(*ast.Ident)
+
+                        if valResult.Name != "cty" && diagsResult.Name != "hcl" {
+                                continue
+                        }
+
+                        // If we have a method called Value and it returns something in
+                        // "cty" followed by something in "hcl" then that's specific enough
+                        // for now, even though this is not 100% exact as a correct
+                        // implementation of Value.
+
+                        recvTy := fd.Recv.List[0].Type
+
+                        switch rtt := recvTy.(type) {
+                        case *ast.StarExpr:
+                                name := rtt.X.(*ast.Ident).Name
+                                recvs = append(recvs, fmt.Sprintf("*%s", name))
+                        default:
+                                fmt.Fprintf(os.Stderr, "don't know what to do with a %T receiver\n", recvTy)
+                        }
+
+                }
+        }
+
+        sort.Strings(recvs)
+
+        of, err := os.OpenFile("expression_vars.go", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, os.ModePerm)
+        if err != nil {
+                fmt.Fprintf(os.Stderr, "failed to open output file: %s\n", err)
+                os.Exit(1)
+        }
+
+        fmt.Fprint(of, outputPreamble)
+        for _, recv := range recvs {
+                fmt.Fprintf(of, outputMethodFmt, recv)
+        }
+        fmt.Fprint(of, "\n")
+
+}
+
+const outputPreamble = `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/hcl2/hcl"
+)`
+
+const outputMethodFmt = `
+
+func (e %s) Variables() []hcl.Traversal {
+        return Variables(e)
+}`
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/file.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/file.go
new file mode 100644
index 0000000..490c025
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/file.go
@@ -0,0 +1,20 @@
+package hclsyntax
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// 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/hcl2/hcl/hclsyntax/generate.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/generate.go
new file mode 100644
index 0000000..841656a
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/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/hcl2/hcl/hclsyntax/keywords.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/keywords.go
new file mode 100644
index 0000000..eef8b96
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/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/hcl2/hcl/hclsyntax/navigation.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/navigation.go
new file mode 100644
index 0000000..4d41b6b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/navigation.go
@@ -0,0 +1,41 @@
+package hclsyntax
+
+import (
+        "bytes"
+        "fmt"
+)
+
+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()
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/node.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/node.go
new file mode 100644
index 0000000..fd426d4
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/node.go
@@ -0,0 +1,22 @@
+package hclsyntax
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// 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) Node
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go
new file mode 100644
index 0000000..002858f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go
@@ -0,0 +1,1836 @@
+package hclsyntax
+
+import (
+        "bytes"
+        "fmt"
+        "strconv"
+        "unicode/utf8"
+
+        "github.com/apparentlymart/go-textseg/textseg"
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+)
+
+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 attribute %q was already defined at %s. Each attribute may be defined 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 attribute name",
+                                                Detail:   "Attribute names must not be quoted.",
+                                                Subject:  &bad.Range,
+                                        })
+                                } else {
+                                        diags = append(diags, &hcl.Diagnostic{
+                                                Severity: hcl.DiagError,
+                                                Summary:  "Attribute or block definition required",
+                                                Detail:   "An attribute 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:  "Attribute or block definition required",
+                                Detail:   "An attribute or block definition is required here.",
+                                Subject:  &ident.Range,
+                        },
+                }
+        }
+
+        next := p.Peek()
+
+        switch next.Type {
+        case TokenEqual:
+                return p.finishParsingBodyAttribute(ident)
+        case TokenOQuote, TokenOBrace, TokenIdent:
+                return p.finishParsingBodyBlock(ident)
+        default:
+                p.recoverAfterBodyItem()
+                return nil, hcl.Diagnostics{
+                        {
+                                Severity: hcl.DiagError,
+                                Summary:  "Attribute or block definition required",
+                                Detail:   "An attribute or block definition is required here. To define an attribute, use the equals sign \"=\" to introduce the attribute value.",
+                                Subject:  &ident.Range,
+                        },
+                }
+        }
+
+        return nil, nil
+}
+
+func (p *parser) finishParsingBodyAttribute(ident Token) (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 {
+                end := p.Peek()
+                if end.Type != TokenNewline && end.Type != TokenEOF {
+                        if !p.recovery {
+                                diags = append(diags, &hcl.Diagnostic{
+                                        Severity: hcl.DiagError,
+                                        Summary:  "Missing newline after attribute definition",
+                                        Detail:   "An attribute definition must end with a newline.",
+                                        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)
+                        if labelDiags.HasErrors() {
+                                p.recoverAfterBodyItem()
+                                return &Block{
+                                        Type:   blockType,
+                                        Labels: labels,
+                                        Body:   nil,
+
+                                        TypeRange:       ident.Range,
+                                        LabelRanges:     labelRanges,
+                                        OpenBraceRange:  ident.Range, // placeholder
+                                        CloseBraceRange: ident.Range, // placeholder
+                                }, diags
+                        }
+
+                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 attribute 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:   nil,
+
+                                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.
+        body, bodyDiags := p.ParseBody(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()
+        }
+
+        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 := term
+
+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(dot.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()
+                        // TODO: If we have a TokenStar inside our brackets, parse as
+                        // a Splat expression: foo[*].baz[0].
+                        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 {
+                                rng := hcl.RangeBetween(open.Range, close.Range)
+                                ret = &IndexExpr{
+                                        Collection: ret,
+                                        Key:        keyExpr,
+
+                                        SrcRange:  rng,
+                                        OpenRange: open.Range,
+                                }
+                        }
+
+                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:  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)
+
+                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) {
+        // We'll lean on the cty converter to do the conversion, to ensure that
+        // the behavior is the same as what would happen if converting a
+        // non-literal string to a number.
+        numStrVal := cty.StringVal(string(tok.Bytes))
+        numVal, err := convert.Convert(numStrVal, cty.Number)
+        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")
+        }
+
+        p.PushIncludeNewlines(true)
+        defer p.PopIncludeNewlines()
+
+        if forKeyword.TokenMatches(p.Peek()) {
+                return p.finishParsingForExpr(open)
+        }
+
+        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
+                }
+
+                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}
+
+                next = p.Peek()
+                if next.Type != TokenEqual && next.Type != TokenColon {
+                        if !p.recovery {
+                                if next.Type == TokenNewline || next.Type == TokenComma {
+                                        diags = append(diags, &hcl.Diagnostic{
+                                                Severity: hcl.DiagError,
+                                                Summary:  "Missing item value",
+                                                Detail:   "Expected an item value, introduced by an equals sign (\"=\").",
+                                                Subject:  &next.Range,
+                                                Context:  hcl.RangeBetween(open.Range, next.Range).Ptr(),
+                                        })
+                                } else {
+                                        diags = append(diags, &hcl.Diagnostic{
+                                                Severity: hcl.DiagError,
+                                                Summary:  "Missing key/value separator",
+                                                Detail:   "Expected an equals sign (\"=\") to mark the beginning of the item 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 item separator",
+                                        Detail:   "Expected a newline or comma to mark the beginning of the next item.",
+                                        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) {
+        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 'in' keyword after names.",
+                                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 colon after 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 := p.decodeStringLit(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(),
+                        })
+                        p.recover(TokenTemplateSeqEnd)
+
+                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(TokenOQuote)
+                        break Token
+
+                }
+
+        }
+
+        return ret.String(), hcl.RangeBetween(oQuote.Range, cQuote.Range), diags
+}
+
+// decodeStringLit 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 (p *parser) decodeStringLit(tok Token) (string, hcl.Diagnostics) {
+        var quoted bool
+        switch tok.Type {
+        case TokenQuotedLit:
+                quoted = true
+        case TokenStringLit:
+                quoted = false
+        default:
+                panic("decodeQuotedLit 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/hcl2/hcl/hclsyntax/parser_template.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser_template.go
new file mode 100644
index 0000000..3711067
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser_template.go
@@ -0,0 +1,728 @@
+package hclsyntax
+
+import (
+        "fmt"
+        "strings"
+        "unicode"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/zclconf/go-cty/cty"
+)
+
+func (p *parser) ParseTemplate() (Expression, hcl.Diagnostics) {
+        return p.parseTemplate(TokenEOF)
+}
+
+func (p *parser) parseTemplate(end TokenType) (Expression, hcl.Diagnostics) {
+        exprs, passthru, rng, diags := p.parseTemplateInner(end)
+
+        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) ([]Expression, bool, hcl.Range, hcl.Diagnostics) {
+        parts, diags := p.parseTemplateParts(end)
+        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 := p.decodeStringLit(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
+}
+
+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/hcl2/hcl/hclsyntax/parser_traversal.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser_traversal.go
new file mode 100644
index 0000000..2ff3ed6
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser_traversal.go
@@ -0,0 +1,159 @@
+package hclsyntax
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+        "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/hcl2/hcl/hclsyntax/peeker.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/peeker.go
new file mode 100644
index 0000000..5a4b50e
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/peeker.go
@@ -0,0 +1,212 @@
+package hclsyntax
+
+import (
+        "bytes"
+        "fmt"
+        "path/filepath"
+        "runtime"
+        "strings"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// 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/hcl2/hcl/hclsyntax/public.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/public.go
new file mode 100644
index 0000000..cf0ee29
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/public.go
@@ -0,0 +1,171 @@
+package hclsyntax
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// 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/hcl2/hcl/hclsyntax/scan_string_lit.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.go
new file mode 100644
index 0000000..de1f524
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.go
@@ -0,0 +1,301 @@
+// line 1 "scan_string_lit.rl"
+
+package hclsyntax
+
+// This file is generated from scan_string_lit.rl. DO NOT EDIT.
+
+// line 9 "scan_string_lit.go"
+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 10 "scan_string_lit.rl"
+
+func scanStringLit(data []byte, quoted bool) [][]byte {
+        var ret [][]byte
+
+        // line 61 "scan_string_lit.rl"
+
+        // 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 154 "scan_string_lit.go"
+        {
+        }
+
+        // line 158 "scan_string_lit.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(_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 40 "scan_string_lit.rl"
+
+                                // 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 48 "scan_string_lit.rl"
+
+                                te = p
+                                ret = append(ret, data[ts:te])
+
+                                // line 255 "scan_string_lit.go"
+                        }
+                }
+
+        _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 48 "scan_string_lit.rl"
+
+                                        te = p
+                                        ret = append(ret, data[ts:te])
+
+                                        // line 281 "scan_string_lit.go"
+                                }
+                        }
+                }
+
+        _out:
+                {
+                }
+        }
+
+        // line 89 "scan_string_lit.rl"
+
+        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/hcl2/hcl/hclsyntax/scan_string_lit.rl b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.rl
new file mode 100644
index 0000000..f8ac117
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/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/hcl2/hcl/hclsyntax/scan_tokens.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.go
new file mode 100644
index 0000000..395e9c1
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.go
@@ -0,0 +1,5443 @@
+// line 1 "scan_tokens.rl"
+
+package hclsyntax
+
+import (
+        "bytes"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// This file is generated from scan_tokens.rl. DO NOT EDIT.
+
+// line 15 "scan_tokens.go"
+var _hcltok_actions []byte = []byte{
+        0, 1, 0, 1, 1, 1, 2, 1, 3,
+        1, 4, 1, 6, 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, 22,
+        1, 23, 1, 24, 1, 25, 1, 26,
+        1, 27, 1, 28, 1, 29, 1, 30,
+        1, 31, 1, 34, 1, 35, 1, 36,
+        1, 37, 1, 38, 1, 39, 1, 40,
+        1, 41, 1, 42, 1, 43, 1, 46,
+        1, 47, 1, 48, 1, 49, 1, 50,
+        1, 51, 1, 52, 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, 1, 86, 1, 87,
+        2, 0, 15, 2, 1, 15, 2, 2,
+        24, 2, 2, 28, 2, 3, 24, 2,
+        3, 28, 2, 4, 5, 2, 7, 0,
+        2, 7, 1, 2, 7, 20, 2, 7,
+        21, 2, 7, 32, 2, 7, 33, 2,
+        7, 44, 2, 7, 45, 2, 7, 53,
+        2, 7, 54, 2, 7, 55, 2, 7,
+        56, 2, 7, 57, 3, 7, 2, 20,
+        3, 7, 3, 20,
+}
+
+var _hcltok_key_offsets []int16 = []int16{
+        0, 0, 1, 2, 3, 5, 10, 14,
+        16, 58, 99, 145, 146, 150, 156, 156,
+        158, 160, 169, 175, 182, 183, 186, 187,
+        191, 196, 205, 209, 213, 221, 223, 225,
+        227, 230, 262, 264, 266, 270, 274, 277,
+        288, 301, 320, 333, 349, 361, 377, 392,
+        413, 423, 435, 446, 460, 475, 485, 497,
+        506, 518, 520, 524, 545, 554, 564, 570,
+        576, 577, 626, 628, 632, 634, 640, 647,
+        655, 662, 665, 671, 675, 679, 681, 685,
+        689, 693, 699, 707, 715, 721, 723, 727,
+        729, 735, 739, 743, 747, 751, 756, 763,
+        769, 771, 773, 777, 779, 785, 789, 793,
+        803, 808, 822, 837, 839, 847, 849, 854,
+        868, 873, 875, 879, 880, 884, 890, 896,
+        906, 916, 927, 935, 938, 941, 945, 949,
+        951, 954, 954, 957, 959, 989, 991, 993,
+        997, 1002, 1006, 1011, 1013, 1015, 1017, 1026,
+        1030, 1034, 1040, 1042, 1050, 1058, 1070, 1073,
+        1079, 1083, 1085, 1089, 1109, 1111, 1113, 1124,
+        1130, 1132, 1134, 1136, 1140, 1146, 1152, 1154,
+        1159, 1163, 1165, 1173, 1191, 1231, 1241, 1245,
+        1247, 1249, 1250, 1254, 1258, 1262, 1266, 1270,
+        1275, 1279, 1283, 1287, 1289, 1291, 1295, 1305,
+        1309, 1311, 1315, 1319, 1323, 1336, 1338, 1340,
+        1344, 1346, 1350, 1352, 1354, 1384, 1388, 1392,
+        1396, 1399, 1406, 1411, 1422, 1426, 1442, 1456,
+        1460, 1465, 1469, 1473, 1479, 1481, 1487, 1489,
+        1493, 1495, 1501, 1506, 1511, 1521, 1523, 1525,
+        1529, 1533, 1535, 1548, 1550, 1554, 1558, 1566,
+        1568, 1572, 1574, 1575, 1578, 1583, 1585, 1587,
+        1591, 1593, 1597, 1603, 1623, 1629, 1635, 1637,
+        1638, 1648, 1649, 1657, 1664, 1666, 1669, 1671,
+        1673, 1675, 1680, 1684, 1688, 1693, 1703, 1713,
+        1717, 1721, 1735, 1761, 1771, 1773, 1775, 1778,
+        1780, 1783, 1785, 1789, 1791, 1792, 1796, 1798,
+        1801, 1808, 1816, 1818, 1820, 1824, 1826, 1832,
+        1843, 1846, 1848, 1852, 1857, 1887, 1892, 1894,
+        1897, 1902, 1916, 1923, 1937, 1942, 1955, 1959,
+        1972, 1977, 1995, 1996, 2005, 2009, 2021, 2026,
+        2033, 2040, 2047, 2049, 2053, 2075, 2080, 2081,
+        2085, 2087, 2137, 2140, 2151, 2155, 2157, 2163,
+        2169, 2171, 2176, 2178, 2182, 2184, 2185, 2187,
+        2189, 2195, 2197, 2199, 2203, 2209, 2222, 2224,
+        2230, 2234, 2242, 2253, 2261, 2264, 2294, 2300,
+        2303, 2308, 2310, 2314, 2318, 2322, 2324, 2331,
+        2333, 2342, 2349, 2357, 2359, 2379, 2391, 2395,
+        2397, 2415, 2454, 2456, 2460, 2462, 2469, 2473,
+        2501, 2503, 2505, 2507, 2509, 2512, 2514, 2518,
+        2522, 2524, 2527, 2529, 2531, 2534, 2536, 2538,
+        2539, 2541, 2543, 2547, 2551, 2554, 2567, 2569,
+        2575, 2579, 2581, 2585, 2589, 2603, 2606, 2615,
+        2617, 2621, 2627, 2627, 2629, 2631, 2640, 2646,
+        2653, 2654, 2657, 2658, 2662, 2667, 2676, 2680,
+        2684, 2692, 2694, 2696, 2698, 2701, 2733, 2735,
+        2737, 2741, 2745, 2748, 2759, 2772, 2791, 2804,
+        2820, 2832, 2848, 2863, 2884, 2894, 2906, 2917,
+        2931, 2946, 2956, 2968, 2977, 2989, 2991, 2995,
+        3016, 3025, 3035, 3041, 3047, 3048, 3097, 3099,
+        3103, 3105, 3111, 3118, 3126, 3133, 3136, 3142,
+        3146, 3150, 3152, 3156, 3160, 3164, 3170, 3178,
+        3186, 3192, 3194, 3198, 3200, 3206, 3210, 3214,
+        3218, 3222, 3227, 3234, 3240, 3242, 3244, 3248,
+        3250, 3256, 3260, 3264, 3274, 3279, 3293, 3308,
+        3310, 3318, 3320, 3325, 3339, 3344, 3346, 3350,
+        3351, 3355, 3361, 3367, 3377, 3387, 3398, 3406,
+        3409, 3412, 3416, 3420, 3422, 3425, 3425, 3428,
+        3430, 3460, 3462, 3464, 3468, 3473, 3477, 3482,
+        3484, 3486, 3488, 3497, 3501, 3505, 3511, 3513,
+        3521, 3529, 3541, 3544, 3550, 3554, 3556, 3560,
+        3580, 3582, 3584, 3595, 3601, 3603, 3605, 3607,
+        3611, 3617, 3623, 3625, 3630, 3634, 3636, 3644,
+        3662, 3702, 3712, 3716, 3718, 3720, 3721, 3725,
+        3729, 3733, 3737, 3741, 3746, 3750, 3754, 3758,
+        3760, 3762, 3766, 3776, 3780, 3782, 3786, 3790,
+        3794, 3807, 3809, 3811, 3815, 3817, 3821, 3823,
+        3825, 3855, 3859, 3863, 3867, 3870, 3877, 3882,
+        3893, 3897, 3913, 3927, 3931, 3936, 3940, 3944,
+        3950, 3952, 3958, 3960, 3964, 3966, 3972, 3977,
+        3982, 3992, 3994, 3996, 4000, 4004, 4006, 4019,
+        4021, 4025, 4029, 4037, 4039, 4043, 4045, 4046,
+        4049, 4054, 4056, 4058, 4062, 4064, 4068, 4074,
+        4094, 4100, 4106, 4108, 4109, 4119, 4120, 4128,
+        4135, 4137, 4140, 4142, 4144, 4146, 4151, 4155,
+        4159, 4164, 4174, 4184, 4188, 4192, 4206, 4232,
+        4242, 4244, 4246, 4249, 4251, 4254, 4256, 4260,
+        4262, 4263, 4267, 4269, 4271, 4278, 4282, 4289,
+        4296, 4305, 4321, 4333, 4351, 4362, 4374, 4382,
+        4400, 4408, 4438, 4441, 4451, 4461, 4473, 4484,
+        4493, 4506, 4518, 4522, 4528, 4555, 4564, 4567,
+        4572, 4578, 4583, 4604, 4608, 4614, 4614, 4621,
+        4630, 4638, 4641, 4645, 4651, 4657, 4660, 4664,
+        4671, 4677, 4686, 4695, 4699, 4703, 4707, 4711,
+        4718, 4722, 4726, 4736, 4742, 4746, 4752, 4756,
+        4759, 4765, 4771, 4783, 4787, 4791, 4801, 4805,
+        4816, 4818, 4820, 4824, 4836, 4841, 4865, 4869,
+        4875, 4897, 4906, 4910, 4913, 4914, 4922, 4930,
+        4936, 4946, 4953, 4971, 4974, 4977, 4985, 4991,
+        4995, 4999, 5003, 5009, 5017, 5022, 5028, 5032,
+        5040, 5047, 5051, 5058, 5064, 5072, 5080, 5086,
+        5092, 5103, 5107, 5119, 5128, 5145, 5162, 5165,
+        5169, 5171, 5177, 5179, 5183, 5198, 5202, 5206,
+        5210, 5214, 5218, 5220, 5226, 5231, 5235, 5241,
+        5248, 5251, 5269, 5271, 5316, 5322, 5328, 5332,
+        5336, 5342, 5346, 5352, 5358, 5365, 5367, 5373,
+        5379, 5383, 5387, 5395, 5408, 5414, 5421, 5429,
+        5435, 5444, 5450, 5454, 5459, 5463, 5471, 5475,
+        5479, 5509, 5515, 5521, 5527, 5533, 5540, 5546,
+        5553, 5558, 5568, 5572, 5579, 5585, 5589, 5596,
+        5600, 5606, 5609, 5613, 5617, 5621, 5625, 5630,
+        5635, 5639, 5650, 5654, 5658, 5664, 5672, 5676,
+        5693, 5697, 5703, 5713, 5719, 5725, 5728, 5733,
+        5742, 5746, 5750, 5756, 5760, 5766, 5774, 5792,
+        5793, 5803, 5804, 5813, 5821, 5823, 5826, 5828,
+        5830, 5832, 5837, 5850, 5854, 5869, 5898, 5909,
+        5911, 5915, 5919, 5924, 5928, 5930, 5937, 5941,
+        5949, 5953, 5954, 5955, 5957, 5959, 5961, 5963,
+        5965, 5966, 5967, 5968, 5970, 5972, 5974, 5975,
+        5976, 5977, 5978, 5980, 5982, 5984, 5985, 5986,
+        5990, 5996, 5996, 5998, 6000, 6009, 6015, 6022,
+        6023, 6026, 6027, 6031, 6036, 6045, 6049, 6053,
+        6061, 6063, 6065, 6067, 6070, 6102, 6104, 6106,
+        6110, 6114, 6117, 6128, 6141, 6160, 6173, 6189,
+        6201, 6217, 6232, 6253, 6263, 6275, 6286, 6300,
+        6315, 6325, 6337, 6346, 6358, 6360, 6364, 6385,
+        6394, 6404, 6410, 6416, 6417, 6466, 6468, 6472,
+        6474, 6480, 6487, 6495, 6502, 6505, 6511, 6515,
+        6519, 6521, 6525, 6529, 6533, 6539, 6547, 6555,
+        6561, 6563, 6567, 6569, 6575, 6579, 6583, 6587,
+        6591, 6596, 6603, 6609, 6611, 6613, 6617, 6619,
+        6625, 6629, 6633, 6643, 6648, 6662, 6677, 6679,
+        6687, 6689, 6694, 6708, 6713, 6715, 6719, 6720,
+        6724, 6730, 6736, 6746, 6756, 6767, 6775, 6778,
+        6781, 6785, 6789, 6791, 6794, 6794, 6797, 6799,
+        6829, 6831, 6833, 6837, 6842, 6846, 6851, 6853,
+        6855, 6857, 6866, 6870, 6874, 6880, 6882, 6890,
+        6898, 6910, 6913, 6919, 6923, 6925, 6929, 6949,
+        6951, 6953, 6964, 6970, 6972, 6974, 6976, 6980,
+        6986, 6992, 6994, 6999, 7003, 7005, 7013, 7031,
+        7071, 7081, 7085, 7087, 7089, 7090, 7094, 7098,
+        7102, 7106, 7110, 7115, 7119, 7123, 7127, 7129,
+        7131, 7135, 7145, 7149, 7151, 7155, 7159, 7163,
+        7176, 7178, 7180, 7184, 7186, 7190, 7192, 7194,
+        7224, 7228, 7232, 7236, 7239, 7246, 7251, 7262,
+        7266, 7282, 7296, 7300, 7305, 7309, 7313, 7319,
+        7321, 7327, 7329, 7333, 7335, 7341, 7346, 7351,
+        7361, 7363, 7365, 7369, 7373, 7375, 7388, 7390,
+        7394, 7398, 7406, 7408, 7412, 7414, 7415, 7418,
+        7423, 7425, 7427, 7431, 7433, 7437, 7443, 7463,
+        7469, 7475, 7477, 7478, 7488, 7489, 7497, 7504,
+        7506, 7509, 7511, 7513, 7515, 7520, 7524, 7528,
+        7533, 7543, 7553, 7557, 7561, 7575, 7601, 7611,
+        7613, 7615, 7618, 7620, 7623, 7625, 7629, 7631,
+        7632, 7636, 7638, 7640, 7647, 7651, 7658, 7665,
+        7674, 7690, 7702, 7720, 7731, 7743, 7751, 7769,
+        7777, 7807, 7810, 7820, 7830, 7842, 7853, 7862,
+        7875, 7887, 7891, 7897, 7924, 7933, 7936, 7941,
+        7947, 7952, 7973, 7977, 7983, 7983, 7990, 7999,
+        8007, 8010, 8014, 8020, 8026, 8029, 8033, 8040,
+        8046, 8055, 8064, 8068, 8072, 8076, 8080, 8087,
+        8091, 8095, 8105, 8111, 8115, 8121, 8125, 8128,
+        8134, 8140, 8152, 8156, 8160, 8170, 8174, 8185,
+        8187, 8189, 8193, 8205, 8210, 8234, 8238, 8244,
+        8266, 8275, 8279, 8282, 8283, 8291, 8299, 8305,
+        8315, 8322, 8340, 8343, 8346, 8354, 8360, 8364,
+        8368, 8372, 8378, 8386, 8391, 8397, 8401, 8409,
+        8416, 8420, 8427, 8433, 8441, 8449, 8455, 8461,
+        8472, 8476, 8488, 8497, 8514, 8531, 8534, 8538,
+        8540, 8546, 8548, 8552, 8567, 8571, 8575, 8579,
+        8583, 8587, 8589, 8595, 8600, 8604, 8610, 8617,
+        8620, 8638, 8640, 8685, 8691, 8697, 8701, 8705,
+        8711, 8715, 8721, 8727, 8734, 8736, 8742, 8748,
+        8752, 8756, 8764, 8777, 8783, 8790, 8798, 8804,
+        8813, 8819, 8823, 8828, 8832, 8840, 8844, 8848,
+        8878, 8884, 8890, 8896, 8902, 8909, 8915, 8922,
+        8927, 8937, 8941, 8948, 8954, 8958, 8965, 8969,
+        8975, 8978, 8982, 8986, 8990, 8994, 8999, 9004,
+        9008, 9019, 9023, 9027, 9033, 9041, 9045, 9062,
+        9066, 9072, 9082, 9088, 9094, 9097, 9102, 9111,
+        9115, 9119, 9125, 9129, 9135, 9143, 9161, 9162,
+        9172, 9173, 9182, 9190, 9192, 9195, 9197, 9199,
+        9201, 9206, 9219, 9223, 9238, 9267, 9278, 9280,
+        9284, 9288, 9293, 9297, 9299, 9306, 9310, 9318,
+        9322, 9398, 9400, 9401, 9402, 9403, 9404, 9405,
+        9407, 9408, 9413, 9415, 9417, 9418, 9462, 9463,
+        9464, 9466, 9471, 9475, 9475, 9477, 9479, 9490,
+        9500, 9508, 9509, 9511, 9512, 9516, 9520, 9530,
+        9534, 9541, 9552, 9559, 9563, 9569, 9580, 9612,
+        9661, 9676, 9691, 9696, 9698, 9703, 9735, 9743,
+        9745, 9767, 9789, 9791, 9807, 9823, 9839, 9855,
+        9870, 9880, 9897, 9914, 9931, 9947, 9957, 9974,
+        9990, 10006, 10022, 10038, 10054, 10070, 10086, 10087,
+        10088, 10089, 10090, 10092, 10094, 10096, 10110, 10124,
+        10138, 10152, 10153, 10154, 10156, 10158, 10160, 10174,
+        10188, 10189, 10190, 10192, 10194, 10196, 10245, 10289,
+        10291, 10296, 10300, 10300, 10302, 10304, 10315, 10325,
+        10333, 10334, 10336, 10337, 10341, 10345, 10355, 10359,
+        10366, 10377, 10384, 10388, 10394, 10405, 10437, 10486,
+        10501, 10516, 10521, 10523, 10528, 10560, 10568, 10570,
+        10592, 10614,
+}
+
+var _hcltok_trans_keys []byte = []byte{
+        10, 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, 0, 127,
+        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, 123, 123, 128, 191, 128, 191, 128,
+        191, 128, 191, 128, 191, 10, 123, 123,
+        128, 191, 128, 191, 128, 191, 123, 123,
+        10, 123, 128, 191, 128, 191, 128, 191,
+        123, 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, 37, 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, 39, 40, 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, 42,
+        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, 36, 37, 92, 128, 191, 192,
+        223, 224, 239, 240, 247, 248, 255, 10,
+        13, 34, 36, 37, 92, 128, 191, 192,
+        223, 224, 239, 240, 247, 248, 255, 10,
+        13, 34, 36, 37, 92, 128, 191, 192,
+        223, 224, 239, 240, 247, 248, 255, 10,
+        13, 36, 37, 92, 128, 191, 192, 223,
+        224, 239, 240, 247, 248, 255, 36, 37,
+        92, 123, 192, 223, 224, 239, 240, 247,
+        10, 13, 34, 36, 37, 92, 123, 128,
+        191, 192, 223, 224, 239, 240, 247, 248,
+        255, 10, 13, 34, 36, 37, 92, 123,
+        128, 191, 192, 223, 224, 239, 240, 247,
+        248, 255, 10, 13, 34, 36, 37, 92,
+        123, 128, 191, 192, 223, 224, 239, 240,
+        247, 248, 255, 10, 13, 34, 36, 37,
+        92, 128, 191, 192, 223, 224, 239, 240,
+        247, 248, 255, 36, 37, 92, 123, 192,
+        223, 224, 239, 240, 247, 10, 13, 34,
+        36, 37, 92, 123, 128, 191, 192, 223,
+        224, 239, 240, 247, 248, 255, 10, 13,
+        34, 36, 37, 92, 128, 191, 192, 223,
+        224, 239, 240, 247, 248, 255, 10, 13,
+        34, 36, 37, 92, 128, 191, 192, 223,
+        224, 239, 240, 247, 248, 255, 10, 13,
+        34, 36, 37, 92, 128, 191, 192, 223,
+        224, 239, 240, 247, 248, 255, 10, 13,
+        34, 36, 37, 92, 128, 191, 192, 223,
+        224, 239, 240, 247, 248, 255, 10, 13,
+        34, 36, 37, 92, 128, 191, 192, 223,
+        224, 239, 240, 247, 248, 255, 10, 13,
+        34, 36, 37, 92, 128, 191, 192, 223,
+        224, 239, 240, 247, 248, 255, 10, 13,
+        34, 36, 37, 92, 128, 191, 192, 223,
+        224, 239, 240, 247, 248, 255, 123, 126,
+        123, 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, 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,
+        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, 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, 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, 1, 1, 0, 0, 0, 0, 0,
+        1, 1, 1, 0, 0, 0, 1, 1,
+        1, 1, 0, 0, 0, 1, 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, 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,
+        54, 2, 1, 1, 1, 1, 1, 2,
+        1, 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, 6, 6, 6, 5,
+        4, 7, 7, 7, 6, 4, 7, 6,
+        6, 6, 6, 6, 6, 6, 1, 1,
+        1, 1, 0, 0, 0, 4, 4, 4,
+        4, 1, 1, 0, 0, 0, 4, 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, 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, 0, 0, 1, 1, 1, 1, 1,
+        0, 0, 0, 1, 1, 1, 0, 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,
+        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, 5, 5, 5, 5,
+        3, 5, 5, 5, 5, 3, 5, 5,
+        5, 5, 5, 5, 5, 5, 0, 0,
+        0, 0, 1, 1, 1, 5, 5, 5,
+        5, 0, 0, 1, 1, 1, 5, 6,
+        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, 6, 9, 14, 18,
+        20, 58, 95, 137, 139, 144, 148, 149,
+        151, 153, 159, 164, 169, 171, 174, 176,
+        179, 183, 189, 192, 195, 201, 203, 205,
+        207, 210, 243, 245, 247, 250, 253, 256,
+        264, 272, 283, 291, 300, 308, 317, 326,
+        338, 345, 352, 360, 368, 377, 383, 391,
+        397, 405, 407, 410, 424, 430, 438, 442,
+        446, 448, 495, 497, 500, 502, 507, 513,
+        519, 524, 527, 531, 534, 537, 539, 542,
+        545, 548, 552, 557, 562, 566, 568, 571,
+        573, 577, 580, 583, 586, 589, 593, 598,
+        602, 604, 606, 609, 611, 615, 618, 621,
+        629, 633, 641, 657, 659, 664, 666, 670,
+        681, 685, 687, 690, 692, 695, 700, 704,
+        710, 716, 727, 732, 735, 738, 741, 744,
+        746, 750, 751, 754, 756, 786, 788, 790,
+        793, 797, 800, 804, 806, 808, 810, 816,
+        819, 822, 826, 828, 833, 838, 845, 848,
+        852, 856, 858, 861, 881, 883, 885, 892,
+        896, 898, 900, 902, 905, 909, 913, 915,
+        919, 922, 924, 929, 947, 986, 992, 995,
+        997, 999, 1001, 1004, 1007, 1010, 1013, 1016,
+        1020, 1023, 1026, 1029, 1031, 1033, 1036, 1043,
+        1046, 1048, 1051, 1054, 1057, 1065, 1067, 1069,
+        1072, 1074, 1077, 1079, 1081, 1111, 1114, 1117,
+        1120, 1123, 1128, 1132, 1139, 1142, 1151, 1160,
+        1163, 1167, 1170, 1173, 1177, 1179, 1183, 1185,
+        1188, 1190, 1194, 1198, 1202, 1210, 1212, 1214,
+        1218, 1222, 1224, 1237, 1239, 1242, 1245, 1250,
+        1252, 1255, 1257, 1259, 1262, 1267, 1269, 1271,
+        1276, 1278, 1281, 1285, 1305, 1309, 1313, 1315,
+        1317, 1325, 1327, 1334, 1339, 1341, 1345, 1348,
+        1351, 1354, 1358, 1361, 1364, 1368, 1378, 1384,
+        1387, 1390, 1400, 1420, 1426, 1429, 1431, 1435,
+        1437, 1440, 1442, 1446, 1448, 1450, 1454, 1456,
+        1460, 1465, 1471, 1473, 1475, 1478, 1480, 1484,
+        1491, 1494, 1496, 1499, 1503, 1533, 1538, 1540,
+        1543, 1547, 1556, 1561, 1569, 1573, 1581, 1585,
+        1593, 1597, 1608, 1610, 1616, 1619, 1627, 1631,
+        1636, 1641, 1646, 1648, 1651, 1666, 1670, 1672,
+        1675, 1677, 1726, 1729, 1736, 1739, 1741, 1745,
+        1749, 1752, 1756, 1758, 1761, 1763, 1765, 1767,
+        1769, 1773, 1775, 1777, 1780, 1784, 1798, 1801,
+        1805, 1808, 1813, 1824, 1829, 1832, 1862, 1866,
+        1869, 1874, 1876, 1880, 1883, 1886, 1888, 1893,
+        1895, 1901, 1906, 1912, 1914, 1934, 1942, 1945,
+        1947, 1965, 2003, 2005, 2008, 2010, 2015, 2018,
+        2047, 2049, 2051, 2053, 2055, 2058, 2060, 2064,
+        2067, 2069, 2072, 2074, 2076, 2079, 2081, 2083,
+        2085, 2087, 2089, 2092, 2095, 2098, 2111, 2113,
+        2117, 2120, 2122, 2127, 2130, 2144, 2147, 2156,
+        2158, 2163, 2167, 2168, 2170, 2172, 2178, 2183,
+        2188, 2190, 2193, 2195, 2198, 2202, 2208, 2211,
+        2214, 2220, 2222, 2224, 2226, 2229, 2262, 2264,
+        2266, 2269, 2272, 2275, 2283, 2291, 2302, 2310,
+        2319, 2327, 2336, 2345, 2357, 2364, 2371, 2379,
+        2387, 2396, 2402, 2410, 2416, 2424, 2426, 2429,
+        2443, 2449, 2457, 2461, 2465, 2467, 2514, 2516,
+        2519, 2521, 2526, 2532, 2538, 2543, 2546, 2550,
+        2553, 2556, 2558, 2561, 2564, 2567, 2571, 2576,
+        2581, 2585, 2587, 2590, 2592, 2596, 2599, 2602,
+        2605, 2608, 2612, 2617, 2621, 2623, 2625, 2628,
+        2630, 2634, 2637, 2640, 2648, 2652, 2660, 2676,
+        2678, 2683, 2685, 2689, 2700, 2704, 2706, 2709,
+        2711, 2714, 2719, 2723, 2729, 2735, 2746, 2751,
+        2754, 2757, 2760, 2763, 2765, 2769, 2770, 2773,
+        2775, 2805, 2807, 2809, 2812, 2816, 2819, 2823,
+        2825, 2827, 2829, 2835, 2838, 2841, 2845, 2847,
+        2852, 2857, 2864, 2867, 2871, 2875, 2877, 2880,
+        2900, 2902, 2904, 2911, 2915, 2917, 2919, 2921,
+        2924, 2928, 2932, 2934, 2938, 2941, 2943, 2948,
+        2966, 3005, 3011, 3014, 3016, 3018, 3020, 3023,
+        3026, 3029, 3032, 3035, 3039, 3042, 3045, 3048,
+        3050, 3052, 3055, 3062, 3065, 3067, 3070, 3073,
+        3076, 3084, 3086, 3088, 3091, 3093, 3096, 3098,
+        3100, 3130, 3133, 3136, 3139, 3142, 3147, 3151,
+        3158, 3161, 3170, 3179, 3182, 3186, 3189, 3192,
+        3196, 3198, 3202, 3204, 3207, 3209, 3213, 3217,
+        3221, 3229, 3231, 3233, 3237, 3241, 3243, 3256,
+        3258, 3261, 3264, 3269, 3271, 3274, 3276, 3278,
+        3281, 3286, 3288, 3290, 3295, 3297, 3300, 3304,
+        3324, 3328, 3332, 3334, 3336, 3344, 3346, 3353,
+        3358, 3360, 3364, 3367, 3370, 3373, 3377, 3380,
+        3383, 3387, 3397, 3403, 3406, 3409, 3419, 3439,
+        3445, 3448, 3450, 3454, 3456, 3459, 3461, 3465,
+        3467, 3469, 3473, 3475, 3477, 3483, 3486, 3491,
+        3496, 3502, 3512, 3520, 3532, 3539, 3549, 3555,
+        3567, 3573, 3591, 3594, 3602, 3608, 3618, 3625,
+        3632, 3640, 3648, 3651, 3656, 3676, 3682, 3685,
+        3689, 3693, 3697, 3709, 3712, 3717, 3718, 3724,
+        3731, 3737, 3740, 3743, 3747, 3751, 3754, 3757,
+        3762, 3766, 3772, 3778, 3781, 3785, 3788, 3791,
+        3796, 3799, 3802, 3808, 3812, 3815, 3819, 3822,
+        3825, 3829, 3833, 3840, 3843, 3846, 3852, 3855,
+        3862, 3864, 3866, 3869, 3878, 3883, 3897, 3901,
+        3905, 3920, 3926, 3929, 3932, 3934, 3939, 3945,
+        3949, 3957, 3963, 3973, 3976, 3979, 3984, 3988,
+        3991, 3994, 3997, 4001, 4006, 4010, 4014, 4017,
+        4022, 4027, 4030, 4036, 4040, 4046, 4051, 4055,
+        4059, 4067, 4070, 4078, 4084, 4094, 4105, 4108,
+        4111, 4113, 4117, 4119, 4122, 4133, 4137, 4140,
+        4143, 4146, 4149, 4151, 4155, 4159, 4162, 4166,
+        4171, 4174, 4184, 4186, 4227, 4233, 4237, 4240,
+        4243, 4247, 4250, 4254, 4258, 4263, 4265, 4269,
+        4273, 4276, 4279, 4284, 4293, 4297, 4302, 4307,
+        4311, 4318, 4322, 4325, 4329, 4332, 4337, 4340,
+        4343, 4373, 4377, 4381, 4385, 4389, 4394, 4398,
+        4404, 4408, 4416, 4419, 4424, 4428, 4431, 4436,
+        4439, 4443, 4446, 4449, 4452, 4455, 4458, 4462,
+        4466, 4469, 4479, 4482, 4485, 4490, 4496, 4499,
+        4514, 4517, 4521, 4527, 4531, 4535, 4538, 4542,
+        4549, 4552, 4555, 4561, 4564, 4568, 4573, 4589,
+        4591, 4599, 4601, 4609, 4615, 4617, 4621, 4624,
+        4627, 4630, 4634, 4645, 4648, 4660, 4684, 4692,
+        4694, 4698, 4701, 4706, 4709, 4711, 4716, 4719,
+        4725, 4728, 4730, 4732, 4734, 4736, 4738, 4740,
+        4742, 4744, 4746, 4748, 4750, 4752, 4754, 4756,
+        4758, 4760, 4762, 4764, 4766, 4768, 4770, 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, 7408, 7411, 7413, 7415, 7417, 7419, 7421,
+        7424, 7426, 7431, 7434, 7437, 7439, 7479, 7481,
+        7483, 7485, 7490, 7494, 7495, 7497, 7499, 7506,
+        7513, 7520, 7522, 7524, 7526, 7529, 7532, 7538,
+        7541, 7546, 7553, 7558, 7561, 7565, 7572, 7604,
+        7653, 7668, 7681, 7686, 7688, 7692, 7723, 7729,
+        7731, 7752, 7772, 7774, 7786, 7798, 7810, 7822,
+        7833, 7841, 7854, 7867, 7880, 7892, 7900, 7913,
+        7925, 7937, 7949, 7961, 7973, 7985, 7997, 7999,
+        8001, 8003, 8005, 8007, 8009, 8011, 8021, 8031,
+        8041, 8051, 8053, 8055, 8057, 8059, 8061, 8071,
+        8080, 8082, 8084, 8086, 8088, 8090, 8132, 8172,
+        8174, 8179, 8183, 8184, 8186, 8188, 8195, 8202,
+        8209, 8211, 8213, 8215, 8218, 8221, 8227, 8230,
+        8235, 8242, 8247, 8250, 8254, 8261, 8293, 8342,
+        8357, 8370, 8375, 8377, 8381, 8412, 8418, 8420,
+        8441, 8461,
+}
+
+var _hcltok_indicies []int16 = []int16{
+        2, 1, 4, 3, 6, 5, 6, 7,
+        5, 9, 11, 11, 10, 8, 12, 12,
+        10, 8, 10, 8, 13, 14, 15, 16,
+        18, 19, 20, 21, 22, 23, 24, 25,
+        26, 27, 28, 29, 30, 31, 32, 33,
+        34, 35, 36, 37, 38, 39, 40, 42,
+        43, 44, 45, 46, 14, 14, 17, 17,
+        41, 3, 14, 15, 16, 18, 19, 20,
+        21, 22, 23, 24, 25, 26, 27, 28,
+        29, 30, 31, 32, 33, 34, 35, 36,
+        37, 38, 39, 40, 42, 43, 44, 45,
+        46, 14, 14, 17, 17, 41, 3, 47,
+        48, 14, 14, 49, 16, 18, 19, 20,
+        19, 50, 51, 23, 52, 25, 26, 53,
+        54, 55, 56, 57, 58, 59, 60, 61,
+        62, 63, 64, 65, 40, 42, 66, 44,
+        67, 68, 69, 14, 14, 14, 17, 41,
+        3, 47, 3, 14, 14, 14, 14, 3,
+        14, 14, 14, 3, 14, 3, 14, 3,
+        14, 3, 3, 3, 3, 3, 14, 3,
+        3, 3, 3, 14, 14, 14, 14, 14,
+        3, 3, 14, 3, 3, 14, 3, 14,
+        3, 3, 14, 3, 3, 3, 14, 14,
+        14, 14, 14, 14, 3, 14, 14, 3,
+        14, 14, 3, 3, 3, 3, 3, 3,
+        14, 14, 3, 3, 14, 3, 14, 14,
+        14, 3, 70, 71, 72, 73, 17, 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, 3, 14, 3, 14, 3, 14,
+        14, 3, 14, 14, 3, 3, 3, 14,
+        3, 3, 3, 3, 3, 3, 3, 14,
+        3, 3, 3, 3, 3, 3, 3, 14,
+        14, 14, 14, 14, 14, 14, 14, 14,
+        14, 14, 3, 3, 3, 3, 3, 3,
+        3, 3, 14, 14, 14, 14, 14, 14,
+        14, 14, 14, 3, 3, 3, 3, 3,
+        3, 3, 3, 14, 14, 14, 14, 14,
+        14, 14, 14, 14, 3, 14, 14, 14,
+        14, 14, 14, 14, 14, 3, 14, 14,
+        14, 14, 14, 14, 14, 14, 14, 14,
+        14, 3, 14, 14, 14, 14, 14, 14,
+        3, 14, 14, 14, 14, 14, 14, 3,
+        3, 3, 3, 3, 3, 3, 3, 14,
+        14, 14, 14, 14, 14, 14, 14, 3,
+        14, 14, 14, 14, 14, 14, 14, 14,
+        3, 14, 14, 14, 14, 14, 3, 3,
+        3, 3, 3, 3, 3, 3, 14, 14,
+        14, 14, 14, 14, 3, 14, 14, 14,
+        14, 14, 14, 14, 3, 14, 3, 14,
+        14, 3, 14, 14, 14, 14, 14, 14,
+        14, 14, 14, 14, 14, 14, 14, 3,
+        14, 14, 14, 14, 14, 3, 14, 14,
+        14, 14, 14, 14, 14, 3, 14, 14,
+        14, 3, 14, 14, 14, 3, 14, 3,
+        101, 102, 103, 104, 105, 106, 107, 108,
+        109, 110, 111, 112, 113, 114, 115, 116,
+        117, 19, 118, 119, 120, 121, 122, 123,
+        124, 125, 126, 127, 128, 129, 130, 131,
+        132, 133, 134, 135, 17, 18, 136, 137,
+        138, 139, 140, 17, 19, 17, 3, 14,
+        3, 14, 14, 3, 3, 14, 3, 3,
+        3, 3, 14, 3, 3, 3, 3, 3,
+        14, 3, 3, 3, 3, 3, 14, 14,
+        14, 14, 14, 3, 3, 3, 14, 3,
+        3, 3, 14, 14, 14, 3, 3, 3,
+        14, 14, 3, 3, 3, 14, 14, 14,
+        3, 3, 3, 14, 14, 14, 14, 3,
+        14, 14, 14, 14, 3, 3, 3, 3,
+        3, 14, 14, 14, 14, 3, 3, 14,
+        14, 14, 3, 3, 14, 14, 14, 14,
+        3, 14, 14, 3, 14, 14, 3, 3,
+        3, 14, 14, 14, 3, 3, 3, 3,
+        14, 14, 14, 14, 14, 3, 3, 3,
+        3, 14, 3, 14, 14, 3, 14, 14,
+        3, 14, 3, 14, 14, 14, 3, 14,
+        14, 3, 3, 3, 14, 3, 3, 3,
+        3, 3, 3, 3, 14, 14, 14, 14,
+        3, 14, 14, 14, 14, 14, 14, 14,
+        3, 141, 142, 143, 144, 145, 146, 147,
+        148, 149, 17, 150, 151, 152, 153, 154,
+        3, 14, 3, 3, 3, 3, 3, 14,
+        14, 3, 14, 14, 14, 3, 14, 14,
+        14, 14, 14, 14, 14, 14, 14, 14,
+        3, 14, 14, 14, 3, 3, 14, 14,
+        14, 3, 3, 14, 3, 3, 14, 14,
+        14, 14, 14, 3, 3, 3, 3, 14,
+        14, 14, 14, 14, 14, 3, 14, 14,
+        14, 14, 14, 3, 155, 112, 156, 157,
+        158, 17, 159, 160, 19, 17, 3, 14,
+        14, 14, 14, 3, 3, 3, 14, 3,
+        3, 14, 14, 14, 3, 3, 3, 14,
+        14, 3, 122, 3, 19, 17, 17, 161,
+        3, 17, 3, 14, 19, 162, 163, 19,
+        164, 165, 19, 60, 166, 167, 168, 169,
+        170, 19, 171, 172, 173, 19, 174, 175,
+        176, 18, 177, 178, 179, 18, 180, 19,
+        17, 3, 3, 14, 14, 3, 3, 3,
+        14, 14, 14, 14, 3, 14, 14, 3,
+        3, 3, 3, 14, 14, 3, 3, 14,
+        14, 3, 3, 3, 3, 3, 3, 14,
+        14, 14, 3, 3, 3, 14, 3, 3,
+        3, 14, 14, 3, 14, 14, 14, 14,
+        3, 14, 14, 14, 14, 3, 14, 14,
+        14, 14, 14, 14, 3, 3, 3, 14,
+        14, 14, 14, 3, 181, 182, 3, 17,
+        3, 14, 3, 3, 14, 19, 183, 184,
+        185, 186, 60, 187, 188, 58, 189, 190,
+        191, 192, 193, 194, 195, 196, 197, 17,
+        3, 3, 14, 3, 14, 14, 14, 14,
+        14, 14, 14, 3, 14, 14, 14, 3,
+        14, 3, 3, 14, 3, 14, 3, 3,
+        14, 14, 14, 14, 3, 14, 14, 14,
+        3, 3, 14, 14, 14, 14, 3, 14,
+        14, 3, 3, 14, 14, 14, 14, 14,
+        3, 198, 199, 200, 201, 202, 203, 204,
+        205, 206, 207, 208, 204, 209, 210, 211,
+        212, 41, 3, 213, 214, 19, 215, 216,
+        217, 218, 219, 220, 221, 222, 223, 19,
+        17, 224, 225, 226, 227, 19, 228, 229,
+        230, 231, 232, 233, 234, 235, 236, 237,
+        238, 239, 240, 241, 242, 19, 147, 17,
+        243, 3, 14, 14, 14, 14, 14, 3,
+        3, 3, 14, 3, 14, 14, 3, 14,
+        3, 14, 14, 3, 3, 3, 14, 14,
+        14, 3, 3, 3, 14, 14, 14, 3,
+        3, 3, 3, 14, 3, 3, 14, 3,
+        3, 14, 14, 14, 3, 3, 14, 3,
+        14, 14, 14, 3, 14, 14, 14, 14,
+        14, 14, 3, 3, 3, 14, 14, 3,
+        14, 14, 3, 14, 14, 3, 14, 14,
+        3, 14, 14, 14, 14, 14, 14, 14,
+        3, 14, 3, 14, 3, 14, 14, 3,
+        14, 3, 14, 14, 3, 14, 3, 14,
+        3, 244, 215, 245, 246, 247, 248, 249,
+        250, 251, 252, 253, 101, 254, 19, 255,
+        256, 257, 19, 258, 132, 259, 260, 261,
+        262, 263, 264, 265, 266, 19, 3, 3,
+        3, 14, 14, 14, 3, 14, 14, 3,
+        14, 14, 3, 3, 3, 3, 3, 14,
+        14, 14, 14, 3, 14, 14, 14, 14,
+        14, 14, 3, 3, 3, 14, 14, 14,
+        14, 14, 14, 14, 14, 14, 3, 14,
+        14, 14, 14, 14, 14, 14, 14, 3,
+        14, 14, 3, 3, 3, 3, 14, 14,
+        14, 3, 3, 3, 14, 3, 3, 3,
+        14, 14, 3, 14, 14, 14, 3, 14,
+        3, 3, 3, 14, 14, 3, 14, 14,
+        14, 3, 14, 14, 14, 3, 3, 3,
+        3, 14, 19, 184, 267, 268, 17, 19,
+        17, 3, 3, 14, 3, 14, 19, 267,
+        17, 3, 19, 269, 17, 3, 3, 14,
+        19, 270, 271, 272, 175, 273, 274, 19,
+        275, 276, 277, 17, 3, 3, 14, 14,
+        14, 3, 14, 14, 3, 14, 14, 14,
+        14, 3, 3, 14, 3, 3, 14, 14,
+        3, 14, 3, 19, 17, 3, 278, 19,
+        279, 3, 17, 3, 14, 3, 14, 280,
+        19, 281, 282, 3, 14, 3, 3, 3,
+        14, 14, 14, 14, 3, 283, 284, 285,
+        19, 286, 287, 288, 289, 290, 291, 292,
+        293, 294, 295, 296, 297, 298, 299, 17,
+        3, 14, 14, 14, 3, 3, 3, 3,
+        14, 14, 3, 3, 14, 3, 3, 3,
+        3, 3, 3, 3, 14, 3, 14, 3,
+        3, 3, 3, 3, 3, 14, 14, 14,
+        14, 14, 3, 3, 14, 3, 3, 3,
+        14, 3, 3, 14, 3, 3, 14, 3,
+        3, 14, 3, 3, 3, 14, 14, 14,
+        3, 3, 3, 14, 14, 14, 14, 3,
+        300, 19, 301, 19, 302, 303, 304, 305,
+        17, 3, 14, 14, 14, 14, 14, 3,
+        3, 3, 14, 3, 3, 14, 14, 14,
+        14, 14, 14, 14, 14, 14, 14, 3,
+        14, 14, 14, 14, 14, 14, 14, 14,
+        14, 14, 14, 14, 14, 14, 14, 14,
+        14, 14, 14, 3, 14, 14, 14, 14,
+        14, 3, 306, 19, 17, 3, 14, 307,
+        19, 103, 17, 3, 14, 308, 3, 17,
+        3, 14, 19, 309, 17, 3, 3, 14,
+        310, 3, 19, 311, 17, 3, 3, 14,
+        14, 14, 14, 3, 14, 14, 14, 14,
+        3, 14, 14, 14, 14, 14, 3, 3,
+        14, 3, 14, 14, 14, 3, 14, 3,
+        14, 14, 14, 3, 3, 3, 3, 3,
+        3, 3, 14, 14, 14, 3, 14, 3,
+        3, 3, 14, 14, 14, 14, 3, 312,
+        313, 72, 314, 315, 316, 317, 318, 319,
+        320, 321, 322, 323, 324, 325, 326, 327,
+        328, 329, 330, 331, 332, 334, 335, 336,
+        337, 338, 339, 333, 3, 14, 14, 14,
+        14, 3, 14, 3, 14, 14, 3, 14,
+        14, 14, 3, 3, 3, 3, 3, 3,
+        3, 3, 3, 14, 14, 14, 14, 14,
+        3, 14, 14, 14, 14, 14, 14, 14,
+        3, 14, 14, 14, 3, 14, 14, 14,
+        14, 14, 14, 14, 3, 14, 14, 14,
+        3, 14, 14, 14, 14, 14, 14, 14,
+        3, 14, 14, 14, 3, 14, 14, 14,
+        14, 14, 14, 14, 14, 14, 14, 3,
+        14, 3, 14, 14, 14, 14, 14, 3,
+        14, 14, 3, 14, 14, 14, 14, 14,
+        14, 14, 3, 14, 14, 14, 3, 14,
+        14, 14, 14, 3, 14, 14, 14, 14,
+        3, 14, 14, 14, 14, 3, 14, 3,
+        14, 14, 3, 14, 14, 14, 14, 14,
+        14, 14, 14, 14, 14, 14, 14, 14,
+        14, 3, 14, 14, 14, 3, 14, 3,
+        14, 14, 3, 14, 3, 340, 341, 342,
+        104, 105, 106, 107, 108, 343, 110, 111,
+        112, 113, 114, 115, 344, 345, 170, 346,
+        261, 120, 347, 122, 232, 272, 125, 348,
+        349, 350, 351, 352, 353, 354, 355, 356,
+        357, 134, 358, 19, 17, 18, 19, 137,
+        138, 139, 140, 17, 17, 3, 14, 14,
+        3, 14, 14, 14, 14, 14, 14, 3,
+        3, 3, 14, 3, 14, 14, 14, 14,
+        3, 14, 14, 14, 3, 14, 14, 3,
+        14, 14, 14, 3, 3, 14, 14, 14,
+        3, 3, 14, 14, 3, 14, 3, 14,
+        3, 14, 14, 14, 3, 3, 14, 14,
+        3, 14, 14, 3, 14, 14, 14, 3,
+        359, 143, 145, 146, 147, 148, 149, 17,
+        360, 151, 361, 153, 362, 3, 14, 14,
+        3, 3, 3, 3, 14, 3, 3, 14,
+        14, 14, 14, 14, 3, 363, 112, 364,
+        157, 158, 17, 159, 160, 19, 17, 3,
+        14, 14, 14, 14, 3, 3, 3, 14,
+        19, 162, 163, 19, 365, 366, 222, 311,
+        166, 167, 168, 367, 170, 368, 369, 370,
+        371, 372, 373, 374, 375, 376, 377, 178,
+        179, 18, 378, 19, 17, 3, 3, 3,
+        3, 14, 14, 14, 3, 3, 3, 3,
+        3, 14, 14, 3, 14, 14, 14, 3,
+        14, 14, 3, 3, 3, 14, 14, 3,
+        14, 14, 14, 14, 3, 14, 3, 14,
+        14, 14, 14, 14, 3, 3, 3, 3,
+        3, 14, 14, 14, 14, 14, 14, 3,
+        14, 3, 19, 183, 184, 379, 186, 60,
+        187, 188, 58, 189, 190, 380, 17, 193,
+        381, 195, 196, 197, 17, 3, 14, 14,
+        14, 14, 14, 14, 14, 3, 14, 14,
+        3, 14, 3, 382, 383, 200, 201, 202,
+        384, 204, 205, 385, 386, 387, 204, 209,
+        210, 211, 212, 41, 3, 213, 214, 19,
+        215, 216, 218, 388, 220, 389, 222, 223,
+        19, 17, 390, 225, 226, 227, 19, 228,
+        229, 230, 231, 232, 233, 234, 235, 391,
+        237, 238, 392, 240, 241, 242, 19, 147,
+        17, 243, 3, 3, 14, 3, 3, 14,
+        3, 14, 14, 14, 14, 14, 3, 14,
+        14, 3, 393, 394, 395, 396, 397, 398,
+        399, 400, 250, 401, 322, 402, 216, 403,
+        404, 405, 406, 407, 404, 408, 409, 410,
+        261, 411, 263, 412, 413, 274, 3, 14,
+        3, 14, 3, 14, 3, 14, 3, 14,
+        14, 3, 14, 3, 14, 14, 14, 3,
+        14, 14, 3, 3, 14, 14, 14, 3,
+        14, 3, 14, 3, 14, 14, 3, 14,
+        3, 14, 3, 14, 3, 14, 3, 14,
+        3, 3, 3, 14, 14, 14, 3, 14,
+        14, 3, 19, 270, 232, 414, 404, 415,
+        274, 19, 416, 417, 277, 17, 3, 14,
+        3, 14, 14, 14, 3, 3, 3, 14,
+        14, 3, 280, 19, 281, 418, 3, 14,
+        14, 3, 19, 286, 287, 288, 289, 290,
+        291, 292, 293, 294, 295, 419, 17, 3,
+        3, 3, 14, 19, 420, 19, 268, 303,
+        304, 305, 17, 3, 3, 14, 422, 422,
+        422, 422, 421, 422, 422, 422, 421, 422,
+        421, 422, 422, 421, 421, 421, 421, 421,
+        421, 422, 421, 421, 421, 421, 422, 422,
+        422, 422, 422, 421, 421, 422, 421, 421,
+        422, 421, 422, 421, 421, 422, 421, 421,
+        421, 422, 422, 422, 422, 422, 422, 421,
+        422, 422, 421, 422, 422, 421, 421, 421,
+        421, 421, 421, 422, 422, 421, 421, 422,
+        421, 422, 422, 422, 421, 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, 453, 454, 421, 422, 421,
+        422, 421, 422, 422, 421, 422, 422, 421,
+        421, 421, 422, 421, 421, 421, 421, 421,
+        421, 421, 422, 421, 421, 421, 421, 421,
+        421, 421, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 421, 421, 421,
+        421, 421, 421, 421, 421, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 421, 421,
+        421, 421, 421, 421, 421, 421, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 421,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        421, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 421, 422, 422, 422,
+        422, 422, 422, 421, 422, 422, 422, 422,
+        422, 422, 421, 421, 421, 421, 421, 421,
+        421, 421, 422, 422, 422, 422, 422, 422,
+        422, 422, 421, 422, 422, 422, 422, 422,
+        422, 422, 422, 421, 422, 422, 422, 422,
+        422, 421, 421, 421, 421, 421, 421, 421,
+        421, 422, 422, 422, 422, 422, 422, 421,
+        422, 422, 422, 422, 422, 422, 422, 421,
+        422, 421, 422, 422, 421, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 421, 422, 422, 422, 422, 422,
+        421, 422, 422, 422, 422, 422, 422, 422,
+        421, 422, 422, 422, 421, 422, 422, 422,
+        421, 422, 421, 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, 489, 490, 427,
+        491, 492, 493, 494, 495, 496, 427, 472,
+        427, 421, 422, 421, 422, 422, 421, 421,
+        422, 421, 421, 421, 421, 422, 421, 421,
+        421, 421, 421, 422, 421, 421, 421, 421,
+        421, 422, 422, 422, 422, 422, 421, 421,
+        421, 422, 421, 421, 421, 422, 422, 422,
+        421, 421, 421, 422, 422, 421, 421, 421,
+        422, 422, 422, 421, 421, 421, 422, 422,
+        422, 422, 421, 422, 422, 422, 422, 421,
+        421, 421, 421, 421, 422, 422, 422, 422,
+        421, 421, 422, 422, 422, 421, 421, 422,
+        422, 422, 422, 421, 422, 422, 421, 422,
+        422, 421, 421, 421, 422, 422, 422, 421,
+        421, 421, 421, 422, 422, 422, 422, 422,
+        421, 421, 421, 421, 422, 421, 422, 422,
+        421, 422, 422, 421, 422, 421, 422, 422,
+        422, 421, 422, 422, 421, 421, 421, 422,
+        421, 421, 421, 421, 421, 421, 421, 422,
+        422, 422, 422, 421, 422, 422, 422, 422,
+        422, 422, 422, 421, 497, 498, 499, 500,
+        501, 502, 503, 504, 505, 427, 506, 507,
+        508, 509, 510, 421, 422, 421, 421, 421,
+        421, 421, 422, 422, 421, 422, 422, 422,
+        421, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 421, 422, 422, 422, 421,
+        421, 422, 422, 422, 421, 421, 422, 421,
+        421, 422, 422, 422, 422, 422, 421, 421,
+        421, 421, 422, 422, 422, 422, 422, 422,
+        421, 422, 422, 422, 422, 422, 421, 511,
+        466, 512, 513, 514, 427, 515, 516, 472,
+        427, 421, 422, 422, 422, 422, 421, 421,
+        421, 422, 421, 421, 422, 422, 422, 421,
+        421, 421, 422, 422, 421, 477, 421, 472,
+        427, 427, 517, 421, 427, 421, 422, 472,
+        518, 519, 472, 520, 521, 472, 522, 523,
+        524, 525, 526, 527, 472, 528, 529, 530,
+        472, 531, 532, 533, 491, 534, 535, 536,
+        491, 537, 472, 427, 421, 421, 422, 422,
+        421, 421, 421, 422, 422, 422, 422, 421,
+        422, 422, 421, 421, 421, 421, 422, 422,
+        421, 421, 422, 422, 421, 421, 421, 421,
+        421, 421, 422, 422, 422, 421, 421, 421,
+        422, 421, 421, 421, 422, 422, 421, 422,
+        422, 422, 422, 421, 422, 422, 422, 422,
+        421, 422, 422, 422, 422, 422, 422, 421,
+        421, 421, 422, 422, 422, 422, 421, 538,
+        539, 421, 427, 421, 422, 421, 421, 422,
+        472, 540, 541, 542, 543, 522, 544, 545,
+        546, 547, 548, 549, 550, 551, 552, 553,
+        554, 555, 427, 421, 421, 422, 421, 422,
+        422, 422, 422, 422, 422, 422, 421, 422,
+        422, 422, 421, 422, 421, 421, 422, 421,
+        422, 421, 421, 422, 422, 422, 422, 421,
+        422, 422, 422, 421, 421, 422, 422, 422,
+        422, 421, 422, 422, 421, 421, 422, 422,
+        422, 422, 422, 421, 556, 557, 558, 559,
+        560, 561, 562, 563, 564, 565, 566, 562,
+        568, 569, 570, 571, 567, 421, 572, 573,
+        472, 574, 575, 576, 577, 578, 579, 580,
+        581, 582, 472, 427, 583, 584, 585, 586,
+        472, 587, 588, 589, 590, 591, 592, 593,
+        594, 595, 596, 597, 598, 599, 600, 601,
+        472, 503, 427, 602, 421, 422, 422, 422,
+        422, 422, 421, 421, 421, 422, 421, 422,
+        422, 421, 422, 421, 422, 422, 421, 421,
+        421, 422, 422, 422, 421, 421, 421, 422,
+        422, 422, 421, 421, 421, 421, 422, 421,
+        421, 422, 421, 421, 422, 422, 422, 421,
+        421, 422, 421, 422, 422, 422, 421, 422,
+        422, 422, 422, 422, 422, 421, 421, 421,
+        422, 422, 421, 422, 422, 421, 422, 422,
+        421, 422, 422, 421, 422, 422, 422, 422,
+        422, 422, 422, 421, 422, 421, 422, 421,
+        422, 422, 421, 422, 421, 422, 422, 421,
+        422, 421, 422, 421, 603, 574, 604, 605,
+        606, 607, 608, 609, 610, 611, 612, 455,
+        613, 472, 614, 615, 616, 472, 617, 487,
+        618, 619, 620, 621, 622, 623, 624, 625,
+        472, 421, 421, 421, 422, 422, 422, 421,
+        422, 422, 421, 422, 422, 421, 421, 421,
+        421, 421, 422, 422, 422, 422, 421, 422,
+        422, 422, 422, 422, 422, 421, 421, 421,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 421, 422, 422, 422, 422, 422, 422,
+        422, 422, 421, 422, 422, 421, 421, 421,
+        421, 422, 422, 422, 421, 421, 421, 422,
+        421, 421, 421, 422, 422, 421, 422, 422,
+        422, 421, 422, 421, 421, 421, 422, 422,
+        421, 422, 422, 422, 421, 422, 422, 422,
+        421, 421, 421, 421, 422, 472, 541, 626,
+        627, 427, 472, 427, 421, 421, 422, 421,
+        422, 472, 626, 427, 421, 472, 628, 427,
+        421, 421, 422, 472, 629, 630, 631, 532,
+        632, 633, 472, 634, 635, 636, 427, 421,
+        421, 422, 422, 422, 421, 422, 422, 421,
+        422, 422, 422, 422, 421, 421, 422, 421,
+        421, 422, 422, 421, 422, 421, 472, 427,
+        421, 637, 472, 638, 421, 427, 421, 422,
+        421, 422, 639, 472, 640, 641, 421, 422,
+        421, 421, 421, 422, 422, 422, 422, 421,
+        642, 643, 644, 472, 645, 646, 647, 648,
+        649, 650, 651, 652, 653, 654, 655, 656,
+        657, 658, 427, 421, 422, 422, 422, 421,
+        421, 421, 421, 422, 422, 421, 421, 422,
+        421, 421, 421, 421, 421, 421, 421, 422,
+        421, 422, 421, 421, 421, 421, 421, 421,
+        422, 422, 422, 422, 422, 421, 421, 422,
+        421, 421, 421, 422, 421, 421, 422, 421,
+        421, 422, 421, 421, 422, 421, 421, 421,
+        422, 422, 422, 421, 421, 421, 422, 422,
+        422, 422, 421, 659, 472, 660, 472, 661,
+        662, 663, 664, 427, 421, 422, 422, 422,
+        422, 422, 421, 421, 421, 422, 421, 421,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 421, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 421, 422,
+        422, 422, 422, 422, 421, 665, 472, 427,
+        421, 422, 666, 472, 457, 427, 421, 422,
+        667, 421, 427, 421, 422, 472, 668, 427,
+        421, 421, 422, 669, 421, 472, 670, 427,
+        421, 421, 422, 672, 671, 422, 422, 422,
+        422, 672, 671, 422, 672, 671, 672, 672,
+        422, 672, 671, 422, 672, 422, 672, 671,
+        422, 672, 422, 672, 422, 671, 672, 672,
+        672, 672, 672, 672, 672, 672, 671, 422,
+        422, 672, 672, 422, 672, 422, 672, 671,
+        672, 672, 672, 672, 672, 422, 672, 422,
+        672, 422, 672, 671, 672, 672, 422, 672,
+        422, 672, 671, 672, 672, 672, 672, 672,
+        422, 672, 422, 672, 671, 422, 422, 672,
+        422, 672, 671, 672, 672, 672, 422, 672,
+        422, 672, 422, 672, 422, 672, 671, 672,
+        422, 672, 422, 672, 671, 422, 672, 672,
+        672, 672, 422, 672, 422, 672, 422, 672,
+        422, 672, 422, 672, 422, 672, 671, 422,
+        672, 671, 672, 672, 672, 422, 672, 422,
+        672, 671, 672, 422, 672, 422, 672, 671,
+        422, 672, 672, 672, 672, 422, 672, 422,
+        672, 671, 422, 672, 422, 672, 422, 672,
+        671, 672, 672, 422, 672, 422, 672, 671,
+        422, 672, 422, 672, 422, 672, 422, 671,
+        672, 672, 672, 422, 672, 422, 672, 671,
+        422, 672, 671, 672, 672, 422, 672, 671,
+        672, 672, 672, 422, 672, 672, 672, 672,
+        672, 672, 422, 422, 672, 422, 672, 422,
+        672, 422, 672, 671, 672, 422, 672, 422,
+        672, 671, 422, 672, 671, 672, 422, 672,
+        671, 672, 422, 672, 671, 422, 422, 672,
+        671, 422, 672, 422, 672, 422, 672, 422,
+        672, 422, 672, 422, 671, 672, 672, 422,
+        672, 672, 672, 672, 422, 422, 672, 672,
+        672, 672, 672, 422, 672, 672, 672, 672,
+        672, 671, 422, 672, 672, 422, 672, 422,
+        671, 672, 672, 422, 672, 671, 422, 422,
+        672, 422, 671, 672, 672, 671, 422, 672,
+        422, 671, 672, 671, 422, 672, 422, 672,
+        422, 671, 672, 672, 671, 422, 672, 422,
+        672, 422, 672, 671, 672, 422, 672, 422,
+        672, 671, 422, 672, 671, 422, 422, 672,
+        671, 672, 422, 671, 672, 671, 422, 672,
+        422, 672, 422, 671, 672, 671, 422, 422,
+        672, 671, 672, 422, 672, 422, 672, 671,
+        422, 672, 422, 671, 672, 671, 422, 422,
+        672, 422, 671, 672, 671, 422, 422, 672,
+        671, 672, 422, 672, 671, 672, 422, 672,
+        671, 672, 422, 672, 422, 672, 422, 671,
+        672, 671, 422, 422, 672, 671, 672, 422,
+        672, 422, 672, 671, 422, 672, 671, 672,
+        672, 422, 672, 422, 672, 671, 671, 422,
+        671, 422, 672, 672, 422, 672, 672, 672,
+        672, 672, 672, 672, 671, 422, 672, 672,
+        672, 422, 671, 672, 672, 672, 422, 672,
+        422, 672, 422, 672, 422, 672, 422, 672,
+        671, 422, 422, 672, 671, 672, 422, 672,
+        671, 422, 422, 672, 422, 422, 422, 672,
+        422, 672, 422, 672, 422, 672, 422, 671,
+        422, 672, 422, 672, 422, 671, 672, 671,
+        422, 672, 422, 671, 672, 422, 672, 672,
+        672, 671, 422, 672, 422, 422, 672, 422,
+        671, 672, 672, 671, 422, 672, 672, 672,
+        672, 422, 672, 422, 671, 672, 672, 672,
+        422, 672, 671, 672, 422, 672, 422, 672,
+        422, 672, 422, 672, 671, 672, 672, 422,
+        672, 671, 422, 672, 422, 672, 422, 671,
+        672, 672, 671, 422, 672, 422, 671, 672,
+        671, 422, 672, 671, 422, 672, 422, 672,
+        671, 672, 672, 672, 671, 422, 422, 422,
+        672, 671, 422, 672, 422, 671, 672, 671,
+        422, 672, 422, 672, 422, 671, 672, 672,
+        672, 671, 422, 672, 422, 671, 672, 672,
+        672, 672, 671, 422, 672, 422, 672, 671,
+        422, 422, 672, 422, 672, 671, 672, 422,
+        672, 422, 671, 672, 672, 671, 422, 672,
+        422, 672, 671, 422, 672, 672, 672, 422,
+        672, 422, 671, 422, 672, 671, 672, 422,
+        422, 672, 422, 672, 422, 671, 672, 672,
+        672, 672, 671, 422, 672, 422, 672, 422,
+        672, 422, 672, 422, 672, 671, 672, 672,
+        672, 422, 672, 422, 672, 422, 672, 422,
+        671, 672, 672, 422, 422, 672, 671, 672,
+        422, 672, 672, 671, 422, 672, 422, 672,
+        671, 422, 422, 672, 672, 672, 672, 422,
+        672, 422, 672, 422, 671, 672, 672, 422,
+        671, 672, 671, 422, 672, 422, 671, 672,
+        671, 422, 672, 422, 671, 672, 422, 672,
+        672, 671, 422, 672, 672, 422, 671, 672,
+        671, 422, 672, 422, 672, 671, 672, 422,
+        672, 422, 671, 672, 671, 422, 672, 422,
+        672, 422, 672, 422, 672, 422, 672, 671,
+        673, 671, 674, 675, 676, 677, 678, 679,
+        680, 681, 682, 683, 684, 676, 685, 686,
+        687, 688, 689, 676, 690, 691, 692, 693,
+        694, 695, 696, 697, 698, 699, 700, 701,
+        702, 703, 704, 676, 705, 673, 685, 673,
+        706, 673, 671, 672, 672, 672, 672, 422,
+        671, 672, 672, 671, 422, 672, 671, 422,
+        422, 672, 671, 422, 672, 422, 671, 672,
+        671, 422, 422, 672, 422, 671, 672, 672,
+        671, 422, 672, 672, 672, 671, 422, 672,
+        422, 672, 672, 671, 422, 422, 672, 422,
+        671, 672, 671, 422, 672, 671, 422, 422,
+        672, 422, 672, 671, 422, 672, 422, 422,
+        672, 422, 672, 422, 671, 672, 672, 671,
+        422, 672, 672, 422, 672, 671, 422, 672,
+        422, 672, 671, 422, 672, 422, 671, 422,
+        672, 672, 672, 422, 672, 671, 672, 422,
+        672, 671, 422, 672, 671, 672, 422, 672,
+        671, 422, 672, 671, 422, 672, 422, 672,
+        671, 422, 672, 671, 422, 672, 671, 707,
+        708, 709, 710, 711, 712, 713, 714, 715,
+        716, 717, 718, 678, 719, 720, 721, 722,
+        723, 720, 724, 725, 726, 727, 728, 729,
+        730, 731, 732, 673, 671, 672, 422, 672,
+        671, 672, 422, 672, 671, 672, 422, 672,
+        671, 672, 422, 672, 671, 422, 672, 422,
+        672, 671, 672, 422, 672, 671, 672, 422,
+        422, 422, 672, 671, 672, 422, 672, 671,
+        672, 672, 672, 672, 422, 672, 422, 671,
+        672, 671, 422, 422, 672, 422, 672, 671,
+        672, 422, 672, 671, 422, 672, 671, 672,
+        672, 422, 672, 671, 422, 672, 671, 672,
+        422, 672, 671, 422, 672, 671, 422, 672,
+        671, 422, 672, 671, 672, 671, 422, 422,
+        672, 671, 672, 422, 672, 671, 422, 672,
+        422, 671, 672, 671, 422, 676, 733, 673,
+        676, 734, 676, 735, 685, 673, 671, 672,
+        671, 422, 672, 671, 422, 676, 734, 685,
+        673, 671, 676, 736, 673, 685, 673, 671,
+        672, 671, 422, 676, 737, 694, 738, 720,
+        739, 732, 676, 740, 741, 742, 673, 685,
+        673, 671, 672, 671, 422, 672, 422, 672,
+        671, 422, 672, 422, 672, 422, 671, 672,
+        672, 671, 422, 672, 422, 672, 671, 422,
+        672, 671, 676, 685, 427, 671, 743, 676,
+        744, 685, 673, 671, 427, 672, 671, 422,
+        672, 671, 422, 745, 676, 746, 747, 673,
+        671, 422, 672, 671, 672, 672, 671, 422,
+        422, 672, 422, 672, 671, 676, 748, 749,
+        750, 751, 752, 753, 754, 755, 756, 757,
+        758, 673, 685, 673, 671, 672, 422, 672,
+        672, 672, 672, 672, 672, 672, 422, 672,
+        422, 672, 672, 672, 672, 672, 672, 671,
+        422, 672, 672, 422, 672, 422, 671, 672,
+        422, 672, 672, 672, 422, 672, 672, 422,
+        672, 672, 422, 672, 672, 422, 672, 672,
+        671, 422, 676, 759, 676, 735, 760, 761,
+        762, 673, 685, 673, 671, 672, 671, 422,
+        672, 672, 672, 422, 672, 672, 672, 422,
+        672, 422, 672, 671, 422, 422, 422, 422,
+        672, 672, 422, 422, 422, 422, 422, 672,
+        672, 672, 672, 672, 672, 672, 422, 672,
+        422, 672, 422, 671, 672, 672, 672, 422,
+        672, 422, 672, 671, 685, 427, 763, 676,
+        685, 427, 672, 671, 422, 764, 676, 765,
+        685, 427, 672, 671, 422, 672, 422, 766,
+        685, 673, 671, 427, 672, 671, 422, 676,
+        767, 673, 685, 673, 671, 672, 671, 422,
+        768, 769, 768, 770, 771, 768, 772, 768,
+        773, 768, 771, 774, 775, 774, 777, 776,
+        778, 779, 778, 780, 781, 776, 782, 776,
+        783, 778, 784, 779, 785, 780, 787, 786,
+        788, 789, 789, 786, 790, 786, 791, 788,
+        792, 789, 793, 789, 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, 1148, 1149, 1150,
+        1151, 1152, 1153, 1154, 672, 672, 422, 1155,
+        1156, 1157, 1158, 672, 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, 672, 1148, 10, 1148,
+        422, 1148, 422, 1160, 1163, 1187, 1194, 1159,
+        1142, 1142, 1195, 1143, 1196, 1198, 1197, 2,
+        1, 1199, 1197, 1200, 1197, 5, 1, 1197,
+        6, 5, 9, 11, 11, 10, 1202, 1203,
+        1204, 1197, 1205, 1206, 1197, 1207, 1197, 422,
+        422, 1209, 1210, 491, 472, 1211, 472, 1212,
+        1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220,
+        1221, 1222, 546, 1223, 522, 1224, 1225, 1226,
+        1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234,
+        1235, 422, 422, 422, 427, 567, 1208, 1236,
+        1197, 1237, 1197, 672, 1238, 422, 422, 422,
+        672, 1238, 672, 672, 422, 1238, 422, 1238,
+        422, 1238, 422, 672, 672, 672, 672, 672,
+        1238, 422, 672, 672, 672, 422, 672, 422,
+        1238, 422, 672, 672, 672, 672, 422, 1238,
+        672, 422, 672, 422, 672, 422, 672, 672,
+        422, 672, 1238, 422, 672, 422, 672, 422,
+        672, 1238, 672, 422, 1238, 672, 422, 672,
+        422, 1238, 672, 672, 672, 672, 672, 1238,
+        422, 422, 672, 422, 672, 1238, 672, 422,
+        1238, 672, 672, 1238, 422, 422, 672, 422,
+        672, 422, 672, 1238, 1239, 1240, 1241, 1242,
+        1243, 1244, 1245, 1246, 1247, 1248, 1249, 717,
+        1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257,
+        1258, 1259, 1260, 1261, 1260, 1262, 1263, 1264,
+        1265, 1266, 673, 1238, 1267, 1268, 1269, 1270,
+        1271, 1272, 1273, 1274, 1275, 1276, 1277, 1278,
+        1279, 1280, 1281, 1282, 1283, 1284, 1285, 727,
+        1286, 1287, 1288, 694, 1289, 1290, 1291, 1292,
+        1293, 1294, 673, 1295, 1296, 1297, 1298, 1299,
+        1300, 1301, 1302, 676, 1303, 673, 676, 1304,
+        1305, 1306, 1307, 685, 1238, 1308, 1309, 1310,
+        1311, 705, 1312, 1313, 685, 1314, 1315, 1316,
+        1317, 1318, 673, 1238, 1319, 1278, 1320, 1321,
+        1322, 685, 1323, 1324, 676, 673, 685, 427,
+        1238, 1288, 673, 676, 685, 427, 685, 427,
+        1325, 685, 1238, 427, 676, 1326, 1327, 676,
+        1328, 1329, 683, 1330, 1331, 1332, 1333, 1334,
+        1284, 1335, 1336, 1337, 1338, 1339, 1340, 1341,
+        1342, 1343, 1344, 1345, 1346, 1303, 1347, 676,
+        685, 427, 1238, 1348, 1349, 685, 673, 1238,
+        427, 673, 1238, 676, 1350, 733, 1351, 1352,
+        1353, 1354, 1355, 1356, 1357, 1358, 673, 1359,
+        1360, 1361, 1362, 1363, 1364, 673, 685, 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, 771, 1391, 1391, 1391, 1392, 1393, 1386,
+        1391, 772, 773, 1394, 1391, 771, 1395, 1395,
+        1395, 1397, 1398, 1399, 1395, 1400, 1401, 1402,
+        1395, 1396, 1403, 1403, 1403, 1405, 1406, 1407,
+        1403, 1408, 1409, 1410, 1403, 1404, 1391, 1391,
+        1411, 1412, 1386, 1391, 772, 773, 1394, 1391,
+        771, 1413, 1414, 1415, 771, 1416, 1417, 1418,
+        769, 769, 769, 769, 1420, 1421, 1422, 1396,
+        769, 1423, 1424, 1425, 769, 1419, 770, 770,
+        770, 1427, 1428, 1429, 1396, 770, 1430, 1431,
+        1432, 770, 1426, 769, 769, 769, 1434, 1435,
+        1436, 1404, 769, 1437, 1438, 1439, 769, 1433,
+        1395, 1395, 771, 1440, 1441, 1399, 1395, 1400,
+        1401, 1402, 1395, 1396, 1442, 1443, 1444, 771,
+        1445, 1446, 1447, 770, 770, 770, 770, 1449,
+        1450, 1451, 1404, 770, 1452, 1453, 1454, 770,
+        1448, 1403, 1403, 771, 1455, 1456, 1407, 1403,
+        1408, 1409, 1410, 1403, 1404, 1403, 1403, 1403,
+        1405, 1406, 1407, 771, 1408, 1409, 1410, 1403,
+        1404, 1403, 1403, 1403, 1405, 1406, 1407, 772,
+        1408, 1409, 1410, 1403, 1404, 1403, 1403, 1403,
+        1405, 1406, 1407, 773, 1408, 1409, 1410, 1403,
+        1404, 1395, 1395, 1395, 1397, 1398, 1399, 771,
+        1400, 1401, 1402, 1395, 1396, 1395, 1395, 1395,
+        1397, 1398, 1399, 772, 1400, 1401, 1402, 1395,
+        1396, 1395, 1395, 1395, 1397, 1398, 1399, 773,
+        1400, 1401, 1402, 1395, 1396, 1458, 769, 1460,
+        1459, 1461, 770, 1463, 1462, 771, 1464, 775,
+        1464, 1465, 1464, 777, 1466, 1467, 1468, 1469,
+        1470, 1471, 1472, 1469, 781, 777, 1466, 1474,
+        1475, 1473, 782, 783, 1476, 1473, 781, 1479,
+        1480, 1481, 1482, 1477, 1483, 1484, 1485, 1477,
+        1478, 1488, 1489, 1490, 1491, 1486, 1492, 1493,
+        1494, 1486, 1487, 1496, 1495, 1498, 1497, 781,
+        1499, 782, 1499, 783, 1499, 787, 1500, 1501,
+        1502, 1503, 1504, 1505, 1506, 1503, 789, 787,
+        1500, 1508, 1507, 790, 791, 1509, 1507, 789,
+        1511, 1510, 1513, 1512, 789, 1514, 790, 1514,
+        791, 1514, 795, 1517, 1518, 1520, 1521, 1522,
+        1516, 1523, 1524, 1525, 1526, 1527, 1528, 1529,
+        1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537,
+        1538, 1539, 1540, 1541, 1542, 1544, 1545, 1546,
+        1547, 1548, 1549, 795, 795, 1515, 1516, 1519,
+        1543, 1550, 1515, 1046, 795, 795, 1552, 1553,
+        865, 846, 1554, 846, 1555, 1556, 1557, 1558,
+        1559, 1560, 1561, 1562, 1563, 1564, 1565, 920,
+        1566, 896, 1567, 1568, 1569, 1570, 1571, 1572,
+        1573, 1574, 1575, 1576, 1577, 1578, 795, 795,
+        795, 801, 941, 1551, 1046, 1579, 795, 795,
+        795, 1046, 1579, 1046, 1046, 795, 1579, 795,
+        1579, 795, 1579, 795, 1046, 1046, 1046, 1046,
+        1046, 1579, 795, 1046, 1046, 1046, 795, 1046,
+        795, 1579, 795, 1046, 1046, 1046, 1046, 795,
+        1579, 1046, 795, 1046, 795, 1046, 795, 1046,
+        1046, 795, 1046, 1579, 795, 1046, 795, 1046,
+        795, 1046, 1579, 1046, 795, 1579, 1046, 795,
+        1046, 795, 1579, 1046, 1046, 1046, 1046, 1046,
+        1579, 795, 795, 1046, 795, 1046, 1579, 1046,
+        795, 1579, 1046, 1046, 1579, 795, 795, 1046,
+        795, 1046, 795, 1046, 1579, 1580, 1581, 1582,
+        1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590,
+        1091, 1591, 1592, 1593, 1594, 1595, 1596, 1597,
+        1598, 1599, 1600, 1601, 1602, 1601, 1603, 1604,
+        1605, 1606, 1607, 1047, 1579, 1608, 1609, 1610,
+        1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618,
+        1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626,
+        1101, 1627, 1628, 1629, 1068, 1630, 1631, 1632,
+        1633, 1634, 1635, 1047, 1636, 1637, 1638, 1639,
+        1640, 1641, 1642, 1643, 1050, 1644, 1047, 1050,
+        1645, 1646, 1647, 1648, 1059, 1579, 1649, 1650,
+        1651, 1652, 1079, 1653, 1654, 1059, 1655, 1656,
+        1657, 1658, 1659, 1047, 1579, 1660, 1619, 1661,
+        1662, 1663, 1059, 1664, 1665, 1050, 1047, 1059,
+        801, 1579, 1629, 1047, 1050, 1059, 801, 1059,
+        801, 1666, 1059, 1579, 801, 1050, 1667, 1668,
+        1050, 1669, 1670, 1057, 1671, 1672, 1673, 1674,
+        1675, 1625, 1676, 1677, 1678, 1679, 1680, 1681,
+        1682, 1683, 1684, 1685, 1686, 1687, 1644, 1688,
+        1050, 1059, 801, 1579, 1689, 1690, 1059, 1047,
+        1579, 801, 1047, 1579, 1050, 1691, 1107, 1692,
+        1693, 1694, 1695, 1696, 1697, 1698, 1699, 1047,
+        1700, 1701, 1702, 1703, 1704, 1705, 1047, 1059,
+        1579, 1707, 1708, 1709, 1710, 1711, 1712, 1713,
+        1714, 1715, 1716, 1717, 1713, 1719, 1720, 1721,
+        1722, 1706, 1718, 1706, 1579, 1706, 1579,
+}
+
+var _hcltok_trans_targs []int16 = []int16{
+        1464, 1, 1464, 1464, 1464, 3, 4, 1472,
+        1464, 5, 1473, 6, 7, 9, 10, 287,
+        13, 14, 15, 16, 17, 288, 289, 20,
+        290, 22, 23, 291, 292, 293, 294, 295,
+        296, 297, 298, 299, 300, 329, 349, 354,
+        128, 129, 130, 357, 152, 372, 376, 1464,
+        11, 12, 18, 19, 21, 24, 25, 26,
+        27, 28, 29, 30, 31, 32, 33, 65,
+        106, 121, 132, 155, 171, 284, 34, 35,
+        36, 37, 38, 39, 40, 41, 42, 43,
+        44, 45, 46, 47, 48, 49, 50, 51,
+        52, 53, 54, 55, 56, 57, 58, 59,
+        60, 61, 62, 63, 64, 66, 67, 68,
+        69, 70, 71, 72, 73, 74, 75, 76,
+        77, 78, 79, 80, 81, 82, 83, 84,
+        85, 86, 87, 88, 89, 90, 91, 92,
+        93, 94, 95, 96, 97, 98, 99, 100,
+        101, 102, 103, 104, 105, 107, 108, 109,
+        110, 111, 112, 113, 114, 115, 116, 117,
+        118, 119, 120, 122, 123, 124, 125, 126,
+        127, 131, 133, 134, 135, 136, 137, 138,
+        139, 140, 141, 142, 143, 144, 145, 146,
+        147, 148, 149, 150, 151, 153, 154, 156,
+        157, 158, 159, 160, 161, 162, 163, 164,
+        165, 166, 167, 168, 169, 170, 172, 204,
+        228, 231, 232, 234, 243, 244, 247, 251,
+        269, 276, 278, 280, 282, 173, 174, 175,
+        176, 177, 178, 179, 180, 181, 182, 183,
+        184, 185, 186, 187, 188, 189, 190, 191,
+        192, 193, 194, 195, 196, 197, 198, 199,
+        200, 201, 202, 203, 205, 206, 207, 208,
+        209, 210, 211, 212, 213, 214, 215, 216,
+        217, 218, 219, 220, 221, 222, 223, 224,
+        225, 226, 227, 229, 230, 233, 235, 236,
+        237, 238, 239, 240, 241, 242, 245, 246,
+        248, 249, 250, 252, 253, 254, 255, 256,
+        257, 258, 259, 260, 261, 262, 263, 264,
+        265, 266, 267, 268, 270, 271, 272, 273,
+        274, 275, 277, 279, 281, 283, 285, 286,
+        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, 328, 330, 331, 332, 333,
+        334, 335, 336, 337, 338, 339, 340, 341,
+        342, 343, 344, 345, 346, 347, 348, 350,
+        351, 352, 353, 355, 356, 358, 359, 360,
+        361, 362, 363, 364, 365, 366, 367, 368,
+        369, 370, 371, 373, 374, 375, 377, 383,
+        405, 410, 412, 414, 378, 379, 380, 381,
+        382, 384, 385, 386, 387, 388, 389, 390,
+        391, 392, 393, 394, 395, 396, 397, 398,
+        399, 400, 401, 402, 403, 404, 406, 407,
+        408, 409, 411, 413, 415, 1464, 1477, 438,
+        439, 440, 441, 418, 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, 468, 470,
+        471, 472, 473, 474, 475, 476, 477, 478,
+        479, 480, 481, 482, 483, 484, 485, 486,
+        420, 487, 488, 489, 490, 491, 492, 493,
+        494, 495, 496, 497, 498, 499, 500, 501,
+        502, 503, 504, 419, 505, 506, 507, 508,
+        509, 511, 512, 513, 514, 515, 516, 517,
+        518, 519, 520, 521, 522, 523, 524, 526,
+        527, 528, 529, 530, 531, 535, 537, 538,
+        539, 540, 435, 541, 542, 543, 544, 545,
+        546, 547, 548, 549, 550, 551, 552, 553,
+        554, 555, 557, 558, 560, 561, 562, 563,
+        564, 565, 433, 566, 567, 568, 569, 570,
+        571, 572, 573, 574, 576, 608, 632, 635,
+        636, 638, 647, 648, 651, 655, 673, 533,
+        680, 682, 684, 686, 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, 607, 609, 610, 611, 612, 613,
+        614, 615, 616, 617, 618, 619, 620, 621,
+        622, 623, 624, 625, 626, 627, 628, 629,
+        630, 631, 633, 634, 637, 639, 640, 641,
+        642, 643, 644, 645, 646, 649, 650, 652,
+        653, 654, 656, 657, 658, 659, 660, 661,
+        662, 663, 664, 665, 666, 667, 668, 669,
+        670, 671, 672, 674, 675, 676, 677, 678,
+        679, 681, 683, 685, 687, 689, 690, 1464,
+        1464, 691, 828, 829, 760, 830, 831, 832,
+        833, 834, 835, 789, 836, 725, 837, 838,
+        839, 840, 841, 842, 843, 844, 745, 845,
+        846, 847, 848, 849, 850, 851, 852, 853,
+        854, 770, 855, 857, 858, 859, 860, 861,
+        862, 863, 864, 865, 866, 703, 867, 868,
+        869, 870, 871, 872, 873, 874, 875, 741,
+        876, 877, 878, 879, 880, 811, 882, 883,
+        886, 888, 889, 890, 891, 892, 893, 896,
+        897, 899, 900, 901, 903, 904, 905, 906,
+        907, 908, 909, 910, 911, 912, 913, 915,
+        916, 917, 918, 921, 923, 924, 926, 928,
+        1515, 1517, 1518, 1516, 931, 932, 1515, 934,
+        1541, 1541, 1541, 1543, 1544, 1542, 939, 940,
+        1545, 1546, 1550, 1550, 1550, 1551, 946, 947,
+        1552, 1553, 1557, 1558, 1557, 973, 974, 975,
+        976, 953, 977, 978, 979, 980, 981, 982,
+        983, 984, 985, 986, 987, 988, 989, 990,
+        991, 992, 993, 994, 995, 996, 997, 998,
+        999, 1000, 1001, 1002, 1003, 1005, 1006, 1007,
+        1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015,
+        1016, 1017, 1018, 1019, 1020, 1021, 955, 1022,
+        1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030,
+        1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038,
+        1039, 954, 1040, 1041, 1042, 1043, 1044, 1046,
+        1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054,
+        1055, 1056, 1057, 1058, 1059, 1061, 1062, 1063,
+        1064, 1065, 1066, 1070, 1072, 1073, 1074, 1075,
+        970, 1076, 1077, 1078, 1079, 1080, 1081, 1082,
+        1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090,
+        1092, 1093, 1095, 1096, 1097, 1098, 1099, 1100,
+        968, 1101, 1102, 1103, 1104, 1105, 1106, 1107,
+        1108, 1109, 1111, 1143, 1167, 1170, 1171, 1173,
+        1182, 1183, 1186, 1190, 1208, 1068, 1215, 1217,
+        1219, 1221, 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, 1138, 1139, 1140, 1141,
+        1142, 1144, 1145, 1146, 1147, 1148, 1149, 1150,
+        1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158,
+        1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166,
+        1168, 1169, 1172, 1174, 1175, 1176, 1177, 1178,
+        1179, 1180, 1181, 1184, 1185, 1187, 1188, 1189,
+        1191, 1192, 1193, 1194, 1195, 1196, 1197, 1198,
+        1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206,
+        1207, 1209, 1210, 1211, 1212, 1213, 1214, 1216,
+        1218, 1220, 1222, 1224, 1225, 1557, 1557, 1226,
+        1363, 1364, 1295, 1365, 1366, 1367, 1368, 1369,
+        1370, 1324, 1371, 1260, 1372, 1373, 1374, 1375,
+        1376, 1377, 1378, 1379, 1280, 1380, 1381, 1382,
+        1383, 1384, 1385, 1386, 1387, 1388, 1389, 1305,
+        1390, 1392, 1393, 1394, 1395, 1396, 1397, 1398,
+        1399, 1400, 1401, 1238, 1402, 1403, 1404, 1405,
+        1406, 1407, 1408, 1409, 1410, 1276, 1411, 1412,
+        1413, 1414, 1415, 1346, 1417, 1418, 1421, 1423,
+        1424, 1425, 1426, 1427, 1428, 1431, 1432, 1434,
+        1435, 1436, 1438, 1439, 1440, 1441, 1442, 1443,
+        1444, 1445, 1446, 1447, 1448, 1450, 1451, 1452,
+        1453, 1456, 1458, 1459, 1461, 1463, 1465, 1464,
+        1466, 1467, 1464, 1468, 1464, 1469, 1470, 1471,
+        1474, 1475, 1476, 1464, 1478, 1464, 1479, 1464,
+        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, 1509, 1510, 1511,
+        1512, 1513, 1514, 1464, 1464, 1464, 1464, 1464,
+        2, 1464, 1464, 8, 1464, 1464, 1464, 1464,
+        1464, 416, 417, 421, 422, 423, 424, 425,
+        426, 427, 428, 429, 430, 431, 432, 434,
+        436, 437, 469, 510, 525, 532, 534, 536,
+        556, 559, 575, 688, 1464, 1464, 1464, 692,
+        693, 694, 695, 696, 697, 698, 699, 700,
+        701, 702, 704, 705, 706, 707, 708, 709,
+        710, 711, 712, 713, 714, 715, 716, 717,
+        718, 719, 720, 721, 722, 723, 724, 726,
+        727, 728, 729, 730, 731, 732, 733, 734,
+        735, 736, 737, 738, 739, 740, 742, 743,
+        744, 746, 747, 748, 749, 750, 751, 752,
+        753, 754, 755, 756, 757, 758, 759, 761,
+        762, 763, 764, 765, 766, 767, 768, 769,
+        771, 772, 773, 774, 775, 776, 777, 778,
+        779, 780, 781, 782, 783, 784, 785, 786,
+        787, 788, 790, 791, 792, 793, 794, 795,
+        796, 797, 798, 799, 800, 801, 802, 803,
+        804, 805, 806, 807, 808, 809, 810, 812,
+        813, 814, 815, 816, 817, 818, 819, 820,
+        821, 822, 823, 824, 825, 826, 827, 856,
+        881, 884, 885, 887, 894, 895, 898, 902,
+        914, 919, 920, 922, 925, 927, 1515, 1515,
+        1534, 1536, 1519, 1515, 1538, 1539, 1540, 1515,
+        929, 930, 933, 1515, 1516, 929, 930, 1519,
+        931, 932, 933, 1515, 1516, 929, 930, 1519,
+        931, 932, 933, 1520, 1525, 1521, 1522, 1524,
+        1531, 1532, 1533, 1517, 1521, 1522, 1524, 1531,
+        1532, 1533, 1518, 1523, 1526, 1527, 1528, 1529,
+        1530, 1517, 1521, 1522, 1524, 1531, 1532, 1533,
+        1520, 1525, 1523, 1526, 1527, 1528, 1529, 1530,
+        1518, 1523, 1526, 1527, 1528, 1529, 1530, 1520,
+        1525, 1515, 1535, 1515, 1515, 1537, 1515, 1515,
+        1515, 935, 936, 942, 943, 1541, 1547, 1548,
+        1549, 1541, 937, 938, 941, 1541, 1542, 1541,
+        936, 937, 938, 939, 940, 941, 1541, 1542,
+        1541, 936, 937, 938, 939, 940, 941, 1541,
+        1541, 1541, 1541, 1541, 944, 949, 950, 1550,
+        1554, 1555, 1556, 1550, 945, 948, 1550, 1550,
+        1550, 1550, 1550, 1557, 1559, 1560, 1561, 1562,
+        1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570,
+        1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578,
+        1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586,
+        1587, 1588, 1589, 1590, 1591, 1592, 1593, 1557,
+        951, 952, 956, 957, 958, 959, 960, 961,
+        962, 963, 964, 965, 966, 967, 969, 971,
+        972, 1004, 1045, 1060, 1067, 1069, 1071, 1091,
+        1094, 1110, 1223, 1557, 1227, 1228, 1229, 1230,
+        1231, 1232, 1233, 1234, 1235, 1236, 1237, 1239,
+        1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247,
+        1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255,
+        1256, 1257, 1258, 1259, 1261, 1262, 1263, 1264,
+        1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272,
+        1273, 1274, 1275, 1277, 1278, 1279, 1281, 1282,
+        1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290,
+        1291, 1292, 1293, 1294, 1296, 1297, 1298, 1299,
+        1300, 1301, 1302, 1303, 1304, 1306, 1307, 1308,
+        1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316,
+        1317, 1318, 1319, 1320, 1321, 1322, 1323, 1325,
+        1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333,
+        1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341,
+        1342, 1343, 1344, 1345, 1347, 1348, 1349, 1350,
+        1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358,
+        1359, 1360, 1361, 1362, 1391, 1416, 1419, 1420,
+        1422, 1429, 1430, 1433, 1437, 1449, 1454, 1455,
+        1457, 1460, 1462,
+}
+
+var _hcltok_trans_actions []byte = []byte{
+        151, 0, 93, 147, 109, 0, 0, 201,
+        143, 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, 123,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 145, 198, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 149,
+        127, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        35, 13, 13, 13, 0, 0, 37, 0,
+        57, 43, 55, 180, 180, 180, 0, 0,
+        0, 0, 77, 63, 75, 186, 0, 0,
+        0, 0, 87, 192, 91, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 89, 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, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 95,
+        0, 0, 121, 210, 113, 0, 13, 204,
+        13, 0, 0, 115, 0, 117, 0, 125,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 13, 13,
+        13, 207, 207, 207, 207, 207, 207, 13,
+        13, 207, 13, 129, 141, 137, 99, 105,
+        0, 135, 131, 0, 103, 97, 111, 101,
+        133, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 107, 119, 139, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 21, 19,
+        0, 0, 13, 23, 0, 13, 13, 29,
+        0, 0, 0, 153, 174, 1, 1, 174,
+        1, 1, 1, 156, 177, 3, 3, 177,
+        3, 3, 3, 0, 0, 0, 0, 13,
+        13, 13, 13, 174, 1, 1, 174, 174,
+        174, 174, 174, 1, 1, 174, 174, 174,
+        174, 177, 3, 3, 177, 177, 177, 177,
+        1, 1, 0, 0, 13, 13, 13, 13,
+        177, 3, 3, 177, 177, 177, 177, 3,
+        3, 31, 0, 25, 15, 0, 27, 17,
+        33, 0, 0, 0, 0, 45, 0, 183,
+        183, 51, 0, 0, 0, 162, 213, 159,
+        5, 5, 5, 5, 5, 5, 168, 217,
+        165, 7, 7, 7, 7, 7, 7, 47,
+        39, 49, 41, 53, 0, 0, 0, 65,
+        0, 189, 189, 71, 0, 0, 67, 59,
+        69, 61, 73, 79, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 13, 13, 13, 195, 195, 195,
+        195, 195, 195, 13, 13, 195, 13, 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, 85, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 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, 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, 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, 171, 0, 0,
+        0, 0, 0, 0, 0, 0, 171, 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,
+}
+
+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, 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,
+        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, 11, 0, 0,
+        0, 0, 0, 0, 0, 0, 11, 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,
+}
+
+var _hcltok_eof_trans []int16 = []int16{
+        0, 1, 4, 1, 1, 9, 9, 9,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        422, 422, 1, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 422, 422, 422, 422, 422,
+        422, 422, 422, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 672, 672, 672, 672, 672, 672, 672,
+        672, 769, 769, 769, 769, 769, 775, 775,
+        777, 779, 779, 777, 777, 779, 0, 0,
+        787, 789, 787, 787, 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, 1197, 1198, 1198, 1198,
+        1202, 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, 1396, 1404, 1392,
+        1392, 1396, 1396, 1404, 1396, 1392, 1404, 1404,
+        1404, 1404, 1404, 1396, 1396, 1396, 1458, 1460,
+        1458, 1463, 1465, 1465, 1465, 0, 1474, 1478,
+        1487, 1496, 1498, 1500, 1500, 1500, 0, 1508,
+        1511, 1513, 1515, 1515, 1515, 0, 1552, 1580,
+        1580, 1580, 1580, 1580, 1580, 1580, 1580, 1580,
+        1580, 1580, 1580, 1580, 1580, 1580, 1580, 1580,
+        1580, 1580, 1580, 1580, 1580, 1580, 1580, 1580,
+        1580, 1580, 1580, 1580, 1580, 1580, 1580, 1580,
+        1580, 1580,
+}
+
+const hcltok_start int = 1464
+const hcltok_first_final int = 1464
+const hcltok_error int = 0
+
+const hcltok_en_stringTemplate int = 1515
+const hcltok_en_heredocTemplate int = 1541
+const hcltok_en_bareTemplate int = 1550
+const hcltok_en_identOnly int = 1557
+const hcltok_en_main int = 1464
+
+// line 16 "scan_tokens.rl"
+
+func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []Token {
+        f := &tokenAccum{
+                Filename: filename,
+                Bytes:    data,
+                Pos:      start,
+        }
+
+        // line 294 "scan_tokens.rl"
+
+        // 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 329 "scan_tokens.rl"
+
+        // 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 4372 "scan_tokens.go"
+        {
+                top = 0
+                ts = 0
+                te = 0
+                act = 0
+        }
+
+        // line 4380 "scan_tokens.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(_hcltok_from_state_actions[cs])
+                _nacts = uint(_hcltok_actions[_acts])
+                _acts++
+                for ; _nacts > 0; _nacts-- {
+                        _acts++
+                        switch _hcltok_actions[_acts-1] {
+                        case 6:
+                                // line 1 "NONE"
+
+                                ts = p
+
+                                // line 4404 "scan_tokens.go"
+                        }
+                }
+
+                _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 218 "scan_tokens.rl"
+
+                                p--
+
+                        case 1:
+                                // line 219 "scan_tokens.rl"
+
+                                p--
+
+                        case 2:
+                                // line 224 "scan_tokens.rl"
+
+                                p--
+
+                        case 3:
+                                // line 225 "scan_tokens.rl"
+
+                                p--
+
+                        case 7:
+                                // line 1 "NONE"
+
+                                te = p + 1
+
+                        case 8:
+                                // line 155 "scan_tokens.rl"
+
+                                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 = 1464
+                                                goto _again
+                                        }
+                                }
+                        case 9:
+                                // line 165 "scan_tokens.rl"
+
+                                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 = 1464
+                                                goto _again
+                                        }
+                                }
+                        case 10:
+                                // line 79 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenCQuote)
+                                        top--
+                                        cs = stack[top]
+                                        {
+                                                stack = stack[:len(stack)-1]
+                                        }
+                                        goto _again
+
+                                }
+                        case 11:
+                                // line 239 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenInvalid)
+                                }
+                        case 12:
+                                // line 240 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenBadUTF8)
+                                }
+                        case 13:
+                                // line 155 "scan_tokens.rl"
+
+                                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 = 1464
+                                                goto _again
+                                        }
+                                }
+                        case 14:
+                                // line 165 "scan_tokens.rl"
+
+                                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 = 1464
+                                                goto _again
+                                        }
+                                }
+                        case 15:
+                                // line 238 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        token(TokenQuotedLit)
+                                }
+                        case 16:
+                                // line 239 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        token(TokenInvalid)
+                                }
+                        case 17:
+                                // line 240 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        token(TokenBadUTF8)
+                                }
+                        case 18:
+                                // line 238 "scan_tokens.rl"
+
+                                p = (te) - 1
+                                {
+                                        token(TokenQuotedLit)
+                                }
+                        case 19:
+                                // line 240 "scan_tokens.rl"
+
+                                p = (te) - 1
+                                {
+                                        token(TokenBadUTF8)
+                                }
+                        case 20:
+                                // line 143 "scan_tokens.rl"
+
+                                act = 10
+                        case 21:
+                                // line 248 "scan_tokens.rl"
+
+                                act = 11
+                        case 22:
+                                // line 155 "scan_tokens.rl"
+
+                                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 = 1464
+                                                goto _again
+                                        }
+                                }
+                        case 23:
+                                // line 165 "scan_tokens.rl"
+
+                                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 = 1464
+                                                goto _again
+                                        }
+                                }
+                        case 24:
+                                // line 106 "scan_tokens.rl"
+
+                                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 25:
+                                // line 248 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenBadUTF8)
+                                }
+                        case 26:
+                                // line 155 "scan_tokens.rl"
+
+                                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 = 1464
+                                                goto _again
+                                        }
+                                }
+                        case 27:
+                                // line 165 "scan_tokens.rl"
+
+                                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 = 1464
+                                                goto _again
+                                        }
+                                }
+                        case 28:
+                                // line 143 "scan_tokens.rl"
+
+                                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 29:
+                                // line 248 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        token(TokenBadUTF8)
+                                }
+                        case 30:
+                                // line 143 "scan_tokens.rl"
+
+                                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 31:
+                                // line 1 "NONE"
+
+                                switch act {
+                                case 0:
+                                        {
+                                                cs = 0
+                                                goto _again
+                                        }
+                                case 10:
+                                        {
+                                                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 11:
+                                        {
+                                                p = (te) - 1
+                                                token(TokenBadUTF8)
+                                        }
+                                }
+
+                        case 32:
+                                // line 151 "scan_tokens.rl"
+
+                                act = 14
+                        case 33:
+                                // line 255 "scan_tokens.rl"
+
+                                act = 15
+                        case 34:
+                                // line 155 "scan_tokens.rl"
+
+                                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 = 1464
+                                                goto _again
+                                        }
+                                }
+                        case 35:
+                                // line 165 "scan_tokens.rl"
+
+                                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 = 1464
+                                                goto _again
+                                        }
+                                }
+                        case 36:
+                                // line 151 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenStringLit)
+                                }
+                        case 37:
+                                // line 255 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenBadUTF8)
+                                }
+                        case 38:
+                                // line 155 "scan_tokens.rl"
+
+                                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 = 1464
+                                                goto _again
+                                        }
+                                }
+                        case 39:
+                                // line 165 "scan_tokens.rl"
+
+                                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 = 1464
+                                                goto _again
+                                        }
+                                }
+                        case 40:
+                                // line 151 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        token(TokenStringLit)
+                                }
+                        case 41:
+                                // line 255 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        token(TokenBadUTF8)
+                                }
+                        case 42:
+                                // line 151 "scan_tokens.rl"
+
+                                p = (te) - 1
+                                {
+                                        token(TokenStringLit)
+                                }
+                        case 43:
+                                // line 1 "NONE"
+
+                                switch act {
+                                case 0:
+                                        {
+                                                cs = 0
+                                                goto _again
+                                        }
+                                case 14:
+                                        {
+                                                p = (te) - 1
+
+                                                token(TokenStringLit)
+                                        }
+                                case 15:
+                                        {
+                                                p = (te) - 1
+                                                token(TokenBadUTF8)
+                                        }
+                                }
+
+                        case 44:
+                                // line 259 "scan_tokens.rl"
+
+                                act = 16
+                        case 45:
+                                // line 260 "scan_tokens.rl"
+
+                                act = 17
+                        case 46:
+                                // line 260 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenBadUTF8)
+                                }
+                        case 47:
+                                // line 261 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenInvalid)
+                                }
+                        case 48:
+                                // line 259 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        token(TokenIdent)
+                                }
+                        case 49:
+                                // line 260 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        token(TokenBadUTF8)
+                                }
+                        case 50:
+                                // line 259 "scan_tokens.rl"
+
+                                p = (te) - 1
+                                {
+                                        token(TokenIdent)
+                                }
+                        case 51:
+                                // line 260 "scan_tokens.rl"
+
+                                p = (te) - 1
+                                {
+                                        token(TokenBadUTF8)
+                                }
+                        case 52:
+                                // line 1 "NONE"
+
+                                switch act {
+                                case 16:
+                                        {
+                                                p = (te) - 1
+                                                token(TokenIdent)
+                                        }
+                                case 17:
+                                        {
+                                                p = (te) - 1
+                                                token(TokenBadUTF8)
+                                        }
+                                }
+
+                        case 53:
+                                // line 267 "scan_tokens.rl"
+
+                                act = 21
+                        case 54:
+                                // line 269 "scan_tokens.rl"
+
+                                act = 22
+                        case 55:
+                                // line 280 "scan_tokens.rl"
+
+                                act = 32
+                        case 56:
+                                // line 290 "scan_tokens.rl"
+
+                                act = 38
+                        case 57:
+                                // line 291 "scan_tokens.rl"
+
+                                act = 39
+                        case 58:
+                                // line 269 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenComment)
+                                }
+                        case 59:
+                                // line 270 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenNewline)
+                                }
+                        case 60:
+                                // line 272 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenEqualOp)
+                                }
+                        case 61:
+                                // line 273 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenNotEqual)
+                                }
+                        case 62:
+                                // line 274 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenGreaterThanEq)
+                                }
+                        case 63:
+                                // line 275 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenLessThanEq)
+                                }
+                        case 64:
+                                // line 276 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenAnd)
+                                }
+                        case 65:
+                                // line 277 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenOr)
+                                }
+                        case 66:
+                                // line 278 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenEllipsis)
+                                }
+                        case 67:
+                                // line 279 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenFatArrow)
+                                }
+                        case 68:
+                                // line 280 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        selfToken()
+                                }
+                        case 69:
+                                // line 175 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenOBrace)
+                                        braces++
+                                }
+                        case 70:
+                                // line 180 "scan_tokens.rl"
+
+                                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 71:
+                                // line 192 "scan_tokens.rl"
+
+                                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 72:
+                                // line 74 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenOQuote)
+                                        {
+                                                stack = append(stack, 0)
+                                                stack[top] = cs
+                                                top++
+                                                cs = 1515
+                                                goto _again
+                                        }
+                                }
+                        case 73:
+                                // line 84 "scan_tokens.rl"
+
+                                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 = 1541
+                                                goto _again
+                                        }
+                                }
+                        case 74:
+                                // line 290 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenBadUTF8)
+                                }
+                        case 75:
+                                // line 291 "scan_tokens.rl"
+
+                                te = p + 1
+                                {
+                                        token(TokenInvalid)
+                                }
+                        case 76:
+                                // line 265 "scan_tokens.rl"
+
+                                te = p
+                                p--
+
+                        case 77:
+                                // line 266 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        token(TokenNumberLit)
+                                }
+                        case 78:
+                                // line 267 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        token(TokenIdent)
+                                }
+                        case 79:
+                                // line 269 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        token(TokenComment)
+                                }
+                        case 80:
+                                // line 280 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        selfToken()
+                                }
+                        case 81:
+                                // line 290 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        token(TokenBadUTF8)
+                                }
+                        case 82:
+                                // line 291 "scan_tokens.rl"
+
+                                te = p
+                                p--
+                                {
+                                        token(TokenInvalid)
+                                }
+                        case 83:
+                                // line 266 "scan_tokens.rl"
+
+                                p = (te) - 1
+                                {
+                                        token(TokenNumberLit)
+                                }
+                        case 84:
+                                // line 267 "scan_tokens.rl"
+
+                                p = (te) - 1
+                                {
+                                        token(TokenIdent)
+                                }
+                        case 85:
+                                // line 280 "scan_tokens.rl"
+
+                                p = (te) - 1
+                                {
+                                        selfToken()
+                                }
+                        case 86:
+                                // line 290 "scan_tokens.rl"
+
+                                p = (te) - 1
+                                {
+                                        token(TokenBadUTF8)
+                                }
+                        case 87:
+                                // line 1 "NONE"
+
+                                switch act {
+                                case 21:
+                                        {
+                                                p = (te) - 1
+                                                token(TokenIdent)
+                                        }
+                                case 22:
+                                        {
+                                                p = (te) - 1
+                                                token(TokenComment)
+                                        }
+                                case 32:
+                                        {
+                                                p = (te) - 1
+                                                selfToken()
+                                        }
+                                case 38:
+                                        {
+                                                p = (te) - 1
+                                                token(TokenBadUTF8)
+                                        }
+                                case 39:
+                                        {
+                                                p = (te) - 1
+                                                token(TokenInvalid)
+                                        }
+                                }
+
+                                // line 5232 "scan_tokens.go"
+                        }
+                }
+
+        _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 4:
+                                // line 1 "NONE"
+
+                                ts = 0
+
+                        case 5:
+                                // line 1 "NONE"
+
+                                act = 0
+
+                                // line 5252 "scan_tokens.go"
+                        }
+                }
+
+                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 352 "scan_tokens.rl"
+
+        // 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/hcl2/hcl/hclsyntax/scan_tokens.rl b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.rl
new file mode 100644
index 0000000..83ef65b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.rl
@@ -0,0 +1,376 @@
+
+package hclsyntax
+
+import (
+    "bytes"
+
+    "github.com/hashicorp/hcl2/hcl"
+)
+
+// This file is generated from scan_tokens.rl. DO NOT EDIT.
+%%{
+  # (except 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 {
+    f := &tokenAccum{
+        Filename: filename,
+        Bytes:    data,
+        Pos:      start,
+    }
+
+    %%{
+        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 = (
+            ("#" (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 = '"';
+        StringLiteralChars = (AnyUTF8 - ("\r"|"\n"));
+        TemplateStringLiteral = (
+            ('$' ^'{' %{ fhold; }) |
+            ('%' ^'{' %{ fhold; }) |
+            ('\\' StringLiteralChars) |
+            (StringLiteralChars - ("$" | '%' | '"'))
+        )+;
+        HeredocStringLiteral = (
+            ('$' ^'{' %{ fhold; }) |
+            ('%' ^'{' %{ fhold; }) |
+            (StringLiteralChars - ("$" | '%'))
+        )*;
+        BareStringLiteral = (
+            ('$' ^'{') |
+            ('%' ^'{') |
+            (StringLiteralChars - ("$" | '%'))
+        )* Newline?;
+
+        stringTemplate := |*
+            TemplateInterp        => beginTemplateInterp;
+            TemplateControl       => beginTemplateControl;
+            EndStringTmpl         => endStringTemplate;
+            TemplateStringLiteral => { token(TokenQuotedLit); };
+            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/hcl2/hcl/hclsyntax/spec.md b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md
new file mode 100644
index 0000000..49b9a3e
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md
@@ -0,0 +1,923 @@
+# 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 maintenence, as opposed to machine
+generation of configuration.
+
+The language consists of three integrated sub-languages:
+
+* The _structural_ language defines the overall heirarchical 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 not considered to be whitespace and
+are not valid within HCL native syntax.
+
+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 comments 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)*;
+Attribute  = Identifier "=" Expression Newline;
+Block      = Identifier (StringLit|Identifier)* "{" Newline Body "}" 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 heirachy 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 paretheses 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 experssion, 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.
+
+### 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 the left operand of a splat operator is an unknown value of any type, the
+result is a value of the dynamic pseudo-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 literalsas 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 analyis, 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/hcl2/hcl/hclsyntax/structure.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/structure.go
new file mode 100644
index 0000000..d69f65b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/structure.go
@@ -0,0 +1,379 @@
+package hclsyntax
+
+import (
+        "fmt"
+        "strings"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// AsHCLBlock returns the block data expressed as a *hcl.Block.
+func (b *Block) AsHCLBlock() *hcl.Block {
+        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) {
+        b.Attributes = w(b.Attributes).(Attributes)
+        b.Blocks = w(b.Blocks).(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 attribute",
+                                Detail:   fmt.Sprintf("An attribute 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 attribute %q?", 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 attribute",
+                                        Detail:   fmt.Sprintf("The attribute %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 %s block", example.Type),
+                        Detail:   "Blocks are not allowed here.",
+                        Context:  &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 b.EndRange
+}
+
+// Attributes is the collection of attribute definitions within a body.
+type Attributes map[string]*Attribute
+
+func (a Attributes) walkChildNodes(w internalWalkFunc) {
+        for k, attr := range a {
+                a[k] = w(attr).(*Attribute)
+        }
+}
+
+// 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) {
+        a.Expr = w(a.Expr).(Expression)
+}
+
+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 {
+        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 i, block := range bs {
+                bs[i] = w(block).(*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) {
+        b.Body = w(b.Body).(*Body)
+}
+
+func (b *Block) Range() hcl.Range {
+        return hcl.RangeBetween(b.TypeRange, b.CloseBraceRange)
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token.go
new file mode 100644
index 0000000..bcaa15f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token.go
@@ -0,0 +1,272 @@
+package hclsyntax
+
+import (
+        "fmt"
+
+        "github.com/apparentlymart/go-textseg/textseg"
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// 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 = '➚'
+        TokenBacktick   TokenType = '`'
+        TokenSemicolon  TokenType = ';'
+        TokenTabs       TokenType = '␉'
+        TokenInvalid    TokenType = '�'
+        TokenBadUTF8    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
+}
+
+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.Pos.Byte // Safe because only ASCII spaces can be in the offset
+        start.Byte = startOfs
+
+        end := start
+        end.Byte = endOfs
+        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
+}
+
+// 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
+        toldSemicolon := 0
+        toldTabs := 0
+        toldBadUTF8 := 0
+
+        for _, tok := range tokens {
+                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 toldExponent < 4 && (toldExponent%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,
+                                })
+
+                                toldBacktick++
+                        }
+                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 attributes 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 TokenInvalid:
+                        diags = append(diags, &hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid character",
+                                Detail:   "This character is not used within the language.",
+                                Subject:  &tok.Range,
+                        })
+
+                        toldTabs++
+                }
+        }
+        return diags
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token_type_string.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token_type_string.go
new file mode 100644
index 0000000..93de7ee
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token_type_string.go
@@ -0,0 +1,69 @@
+// Code generated by "stringer -type TokenType -output token_type_string.go"; DO NOT EDIT.
+
+package hclsyntax
+
+import "strconv"
+
+const _TokenType_name = "TokenNilTokenNewlineTokenBangTokenPercentTokenBitwiseAndTokenOParenTokenCParenTokenStarTokenPlusTokenCommaTokenMinusTokenDotTokenSlashTokenColonTokenSemicolonTokenLessThanTokenEqualTokenGreaterThanTokenQuestionTokenCommentTokenOHeredocTokenIdentTokenNumberLitTokenQuotedLitTokenStringLitTokenOBrackTokenCBrackTokenBitwiseXorTokenBacktickTokenCHeredocTokenOBraceTokenBitwiseOrTokenCBraceTokenBitwiseNotTokenOQuoteTokenCQuoteTokenTemplateControlTokenEllipsisTokenFatArrowTokenTemplateSeqEndTokenAndTokenOrTokenTemplateInterpTokenEqualOpTokenNotEqualTokenLessThanEqTokenGreaterThanEqTokenEOFTokenTabsTokenStarStarTokenInvalidTokenBadUTF8"
+
+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],
+        40:     _TokenType_name[56:67],
+        41:     _TokenType_name[67:78],
+        42:     _TokenType_name[78:87],
+        43:     _TokenType_name[87:96],
+        44:     _TokenType_name[96:106],
+        45:     _TokenType_name[106:116],
+        46:     _TokenType_name[116:124],
+        47:     _TokenType_name[124:134],
+        58:     _TokenType_name[134:144],
+        59:     _TokenType_name[144:158],
+        60:     _TokenType_name[158:171],
+        61:     _TokenType_name[171:181],
+        62:     _TokenType_name[181:197],
+        63:     _TokenType_name[197:210],
+        67:     _TokenType_name[210:222],
+        72:     _TokenType_name[222:235],
+        73:     _TokenType_name[235:245],
+        78:     _TokenType_name[245:259],
+        81:     _TokenType_name[259:273],
+        83:     _TokenType_name[273:287],
+        91:     _TokenType_name[287:298],
+        93:     _TokenType_name[298:309],
+        94:     _TokenType_name[309:324],
+        96:     _TokenType_name[324:337],
+        104:    _TokenType_name[337:350],
+        123:    _TokenType_name[350:361],
+        124:    _TokenType_name[361:375],
+        125:    _TokenType_name[375:386],
+        126:    _TokenType_name[386:401],
+        171:    _TokenType_name[401:412],
+        187:    _TokenType_name[412:423],
+        955:    _TokenType_name[423:443],
+        8230:   _TokenType_name[443:456],
+        8658:   _TokenType_name[456:469],
+        8718:   _TokenType_name[469:488],
+        8743:   _TokenType_name[488:496],
+        8744:   _TokenType_name[496:503],
+        8747:   _TokenType_name[503:522],
+        8788:   _TokenType_name[522:534],
+        8800:   _TokenType_name[534:547],
+        8804:   _TokenType_name[547:562],
+        8805:   _TokenType_name[562:580],
+        9220:   _TokenType_name[580:588],
+        9225:   _TokenType_name[588:597],
+        10138:  _TokenType_name[597:610],
+        65533:  _TokenType_name[610:622],
+        128169: _TokenType_name[622:634],
+}
+
+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/hcl2/hcl/hclsyntax/unicode2ragel.rb b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/unicode2ragel.rb
new file mode 100644
index 0000000..422e4e5
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/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/hcl2/hcl/hclsyntax/unicode_derived.rl b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/unicode_derived.rl
new file mode 100644
index 0000000..612ad62
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/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/hcl2/hcl/hclsyntax/variables.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/variables.go
new file mode 100644
index 0000000..eeee1a5
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/variables.go
@@ -0,0 +1,86 @@
+package hclsyntax
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// 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 // pointer because it can be replaced on walk
+}
+
+func (e ChildScope) walkChildNodes(w internalWalkFunc) {
+        *(e.Expr) = w(*(e.Expr)).(Expression)
+}
+
+// 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/hcl2/hcl/hclsyntax/walk.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/walk.go
new file mode 100644
index 0000000..3405d26
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/walk.go
@@ -0,0 +1,77 @@
+package hclsyntax
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// 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) Node {
+                diags = append(diags, VisitAll(node, f)...)
+                return node
+        })
+        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) Node {
+                diags = append(diags, Walk(node, w)...)
+                return node
+        })
+        return diags
+}
+
+// Transformer is an interface used with Transform
+type Transformer interface {
+        // Transform accepts a node and returns a replacement node along with
+        // a flag for whether to also visit child nodes. If the flag is false,
+        // none of the child nodes will be visited and the TransformExit method
+        // will not be called for the node.
+        //
+        // It is acceptable and appropriate for Transform to return the same node
+        // it was given, for situations where no transform is needed.
+        Transform(node Node) (Node, bool, hcl.Diagnostics)
+
+        // TransformExit signals the end of transformations of child nodes of the
+        // given node. If Transform returned a new node, the given node is the
+        // node that was returned, rather than the node that was originally
+        // encountered.
+        TransformExit(node Node) hcl.Diagnostics
+}
+
+// Transform allows for in-place transformations of an AST starting with a
+// particular node. The provider Transformer implementation drives the
+// transformation process. The return value is the node that replaced the
+// given top-level node.
+func Transform(node Node, t Transformer) (Node, hcl.Diagnostics) {
+        newNode, descend, diags := t.Transform(node)
+        if !descend {
+                return newNode, diags
+        }
+        node.walkChildNodes(func(node Node) Node {
+                newNode, newDiags := Transform(node, t)
+                diags = append(diags, newDiags...)
+                return newNode
+        })
+        diags = append(diags, t.TransformExit(newNode)...)
+        return newNode, diags
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/ast.go b/vendor/github.com/hashicorp/hcl2/hcl/json/ast.go
new file mode 100644
index 0000000..753bfa0
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/ast.go
@@ -0,0 +1,121 @@
+package json
+
+import (
+        "math/big"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+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/hcl2/hcl/json/didyoumean.go b/vendor/github.com/hashicorp/hcl2/hcl/json/didyoumean.go
new file mode 100644
index 0000000..fbdd8bf
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/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/hcl2/hcl/json/doc.go b/vendor/github.com/hashicorp/hcl2/hcl/json/doc.go
new file mode 100644
index 0000000..4943f9b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/doc.go
@@ -0,0 +1,8 @@
+// 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.
+package json
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/navigation.go b/vendor/github.com/hashicorp/hcl2/hcl/json/navigation.go
new file mode 100644
index 0000000..bc8a97f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/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/hcl2/hcl/json/parser.go b/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go
new file mode 100644
index 0000000..246fd1c
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go
@@ -0,0 +1,491 @@
+package json
+
+import (
+        "encoding/json"
+        "fmt"
+        "math/big"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+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 attribute 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 attribute name",
+                                Detail:   "A JSON object attribute 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 attribute 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 attribute value colon",
+                                Detail:   "A colon must appear between an object attribute'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 attribute 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 attribute declaration 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 attribute 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,
+                        },
+                }
+        }
+
+        f, _, err := big.ParseFloat(string(num), 10, 512, big.ToNearestEven)
+        if err != nil {
+                // Should never happen if above passed, since JSON numbers are a subset
+                // of what big.Float 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:    f,
+                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/hcl2/hcl/json/peeker.go b/vendor/github.com/hashicorp/hcl2/hcl/json/peeker.go
new file mode 100644
index 0000000..fc7bbf5
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/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/hcl2/hcl/json/public.go b/vendor/github.com/hashicorp/hcl2/hcl/json/public.go
new file mode 100644
index 0000000..2728aa1
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/public.go
@@ -0,0 +1,94 @@
+package json
+
+import (
+        "fmt"
+        "io/ioutil"
+        "os"
+
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// 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/hcl2/hcl/json/scanner.go b/vendor/github.com/hashicorp/hcl2/hcl/json/scanner.go
new file mode 100644
index 0000000..0a8378b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/scanner.go
@@ -0,0 +1,293 @@
+package json
+
+import (
+        "fmt"
+
+        "github.com/apparentlymart/go-textseg/textseg"
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+//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.
+                        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 b >= 'a' || b <= 'z' || b >= 'A' || b <= 'Z':
+                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 (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || 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)
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md b/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md
new file mode 100644
index 0000000..9b33c7f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/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 maintenence.
+
+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 enumerationg the JSON array elements, creating
+for each an element whose type is the result of recursively applying the
+expression mapping rules. Correspondance 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 intepreted 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/hcl2/hcl/json/structure.go b/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
new file mode 100644
index 0000000..28dcf52
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
@@ -0,0 +1,616 @@
+package json
+
+import (
+        "fmt"
+
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/hcl2/hcl/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 attribute 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 attribute definition",
+                                        Detail:   fmt.Sprintf("The attribute %q was already defined 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 attribute",
+                                Detail:   fmt.Sprintf("The attribute %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, defining the attributes 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 attribute %q was already defined 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 *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 *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 attributes 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 attributes 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:
+                vals := []cty.Value{}
+                for _, jsonVal := range v.Values {
+                        val, _ := (&expression{src: jsonVal}).Value(ctx)
+                        vals = append(vals, val)
+                }
+                return cty.TupleVal(vals), nil
+        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
+                        // experessions 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)
+                        val, valDiags := (&expression{src: jsonAttr.Value}).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,
+                                })
+                                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,
+                                })
+                                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,
+                                })
+                                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
+        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 {
+                        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/hcl2/hcl/json/tokentype_string.go b/vendor/github.com/hashicorp/hcl2/hcl/json/tokentype_string.go
new file mode 100644
index 0000000..bbcce5b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/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/hashicorp/hcl2/hcl/merged.go b/vendor/github.com/hashicorp/hcl2/hcl/merged.go
new file mode 100644
index 0000000..ca2b728
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/merged.go
@@ -0,0 +1,226 @@
+package hcl
+
+import (
+        "fmt"
+)
+
+// MergeFiles combines the given files to produce a single body that contains
+// configuration from all of the given files.
+//
+// The ordering of the given files decides the order in which contained
+// elements will be returned. If any top-level attributes are defined with
+// the same name across multiple files, a diagnostic will be produced from
+// the Content and PartialContent methods describing this error in a
+// user-friendly way.
+func MergeFiles(files []*File) Body {
+        var bodies []Body
+        for _, file := range files {
+                bodies = append(bodies, file.Body)
+        }
+        return MergeBodies(bodies)
+}
+
+// MergeBodies is like MergeFiles except it deals directly with bodies, rather
+// than with entire files.
+func MergeBodies(bodies []Body) Body {
+        if len(bodies) == 0 {
+                // Swap out for our singleton empty body, to reduce the number of
+                // empty slices we have hanging around.
+                return emptyBody
+        }
+
+        // If any of the given bodies are already merged bodies, we'll unpack
+        // to flatten to a single mergedBodies, since that's conceptually simpler.
+        // This also, as a side-effect, eliminates any empty bodies, since
+        // empties are merged bodies with no inner bodies.
+        var newLen int
+        var flatten bool
+        for _, body := range bodies {
+                if children, merged := body.(mergedBodies); merged {
+                        newLen += len(children)
+                        flatten = true
+                } else {
+                        newLen++
+                }
+        }
+
+        if !flatten { // not just newLen == len, because we might have mergedBodies with single bodies inside
+                return mergedBodies(bodies)
+        }
+
+        if newLen == 0 {
+                // Don't allocate a new empty when we already have one
+                return emptyBody
+        }
+
+        new := make([]Body, 0, newLen)
+        for _, body := range bodies {
+                if children, merged := body.(mergedBodies); merged {
+                        new = append(new, children...)
+                } else {
+                        new = append(new, body)
+                }
+        }
+        return mergedBodies(new)
+}
+
+var emptyBody = mergedBodies([]Body{})
+
+// EmptyBody returns a body with no content. This body can be used as a
+// placeholder when a body is required but no body content is available.
+func EmptyBody() Body {
+        return emptyBody
+}
+
+type mergedBodies []Body
+
+// Content returns the content produced by applying the given schema to all
+// of the merged bodies and merging the result.
+//
+// Although required attributes _are_ supported, they should be used sparingly
+// with merged bodies since in this case there is no contextual information
+// with which to return good diagnostics. Applications working with merged
+// bodies may wish to mark all attributes as optional and then check for
+// required attributes afterwards, to produce better diagnostics.
+func (mb mergedBodies) Content(schema *BodySchema) (*BodyContent, Diagnostics) {
+        // the returned body will always be empty in this case, because mergedContent
+        // will only ever call Content on the child bodies.
+        content, _, diags := mb.mergedContent(schema, false)
+        return content, diags
+}
+
+func (mb mergedBodies) PartialContent(schema *BodySchema) (*BodyContent, Body, Diagnostics) {
+        return mb.mergedContent(schema, true)
+}
+
+func (mb mergedBodies) JustAttributes() (Attributes, Diagnostics) {
+        attrs := make(map[string]*Attribute)
+        var diags Diagnostics
+
+        for _, body := range mb {
+                thisAttrs, thisDiags := body.JustAttributes()
+
+                if len(thisDiags) != 0 {
+                        diags = append(diags, thisDiags...)
+                }
+
+                if thisAttrs != nil {
+                        for name, attr := range thisAttrs {
+                                if existing := attrs[name]; existing != nil {
+                                        diags = diags.Append(&Diagnostic{
+                                                Severity: DiagError,
+                                                Summary:  "Duplicate attribute",
+                                                Detail: fmt.Sprintf(
+                                                        "Attribute %q was already assigned at %s",
+                                                        name, existing.NameRange.String(),
+                                                ),
+                                                Subject: &attr.NameRange,
+                                        })
+                                        continue
+                                }
+
+                                attrs[name] = attr
+                        }
+                }
+        }
+
+        return attrs, diags
+}
+
+func (mb mergedBodies) MissingItemRange() Range {
+        if len(mb) == 0 {
+                // Nothing useful to return here, so we'll return some garbage.
+                return Range{
+                        Filename: "<empty>",
+                }
+        }
+
+        // arbitrarily use the first body's missing item range
+        return mb[0].MissingItemRange()
+}
+
+func (mb mergedBodies) mergedContent(schema *BodySchema, partial bool) (*BodyContent, Body, Diagnostics) {
+        // We need to produce a new schema with none of the attributes marked as
+        // required, since _any one_ of our bodies can contribute an attribute value.
+        // We'll separately check that all required attributes are present at
+        // the end.
+        mergedSchema := &BodySchema{
+                Blocks: schema.Blocks,
+        }
+        for _, attrS := range schema.Attributes {
+                mergedAttrS := attrS
+                mergedAttrS.Required = false
+                mergedSchema.Attributes = append(mergedSchema.Attributes, mergedAttrS)
+        }
+
+        var mergedLeftovers []Body
+        content := &BodyContent{
+                Attributes: map[string]*Attribute{},
+        }
+
+        var diags Diagnostics
+        for _, body := range mb {
+                var thisContent *BodyContent
+                var thisLeftovers Body
+                var thisDiags Diagnostics
+
+                if partial {
+                        thisContent, thisLeftovers, thisDiags = body.PartialContent(mergedSchema)
+                } else {
+                        thisContent, thisDiags = body.Content(mergedSchema)
+                }
+
+                if thisLeftovers != nil {
+                        mergedLeftovers = append(mergedLeftovers)
+                }
+                if len(thisDiags) != 0 {
+                        diags = append(diags, thisDiags...)
+                }
+
+                if thisContent.Attributes != nil {
+                        for name, attr := range thisContent.Attributes {
+                                if existing := content.Attributes[name]; existing != nil {
+                                        diags = diags.Append(&Diagnostic{
+                                                Severity: DiagError,
+                                                Summary:  "Duplicate attribute",
+                                                Detail: fmt.Sprintf(
+                                                        "Attribute %q was already assigned at %s",
+                                                        name, existing.NameRange.String(),
+                                                ),
+                                                Subject: &attr.NameRange,
+                                        })
+                                        continue
+                                }
+                                content.Attributes[name] = attr
+                        }
+                }
+
+                if len(thisContent.Blocks) != 0 {
+                        content.Blocks = append(content.Blocks, thisContent.Blocks...)
+                }
+        }
+
+        // Finally, we check for required attributes.
+        for _, attrS := range schema.Attributes {
+                if !attrS.Required {
+                        continue
+                }
+
+                if content.Attributes[attrS.Name] == nil {
+                        // We don't have any context here to produce a good diagnostic,
+                        // which is why we warn in the Content docstring to minimize the
+                        // use of required attributes on merged bodies.
+                        diags = diags.Append(&Diagnostic{
+                                Severity: DiagError,
+                                Summary:  "Missing required attribute",
+                                Detail: fmt.Sprintf(
+                                        "The attribute %q is required, but was not assigned.",
+                                        attrS.Name,
+                                ),
+                        })
+                }
+        }
+
+        leftoverBody := MergeBodies(mergedLeftovers)
+        return content, leftoverBody, diags
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/ops.go b/vendor/github.com/hashicorp/hcl2/hcl/ops.go
new file mode 100644
index 0000000..f4e30b0
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/ops.go
@@ -0,0 +1,147 @@
+package hcl
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+)
+
+// Index is a helper function that performs the same operation as the index
+// operator in the HCL expression language. That is, the result is the
+// same as it would be for collection[key] in a configuration expression.
+//
+// This is exported so that applications can perform indexing in a manner
+// consistent with how the language does it, including handling of null and
+// unknown values, etc.
+//
+// Diagnostics are produced if the given combination of values is not valid.
+// Therefore a pointer to a source range must be provided to use in diagnostics,
+// though nil can be provided if the calling application is going to
+// ignore the subject of the returned diagnostics anyway.
+func Index(collection, key cty.Value, srcRange *Range) (cty.Value, Diagnostics) {
+        if collection.IsNull() {
+                return cty.DynamicVal, Diagnostics{
+                        {
+                                Severity: DiagError,
+                                Summary:  "Attempt to index null value",
+                                Detail:   "This value is null, so it does not have any indices.",
+                                Subject:  srcRange,
+                        },
+                }
+        }
+        if key.IsNull() {
+                return cty.DynamicVal, Diagnostics{
+                        {
+                                Severity: DiagError,
+                                Summary:  "Invalid index",
+                                Detail:   "Can't use a null value as an indexing key.",
+                                Subject:  srcRange,
+                        },
+                }
+        }
+        ty := collection.Type()
+        kty := key.Type()
+        if kty == cty.DynamicPseudoType || ty == cty.DynamicPseudoType {
+                return cty.DynamicVal, nil
+        }
+
+        switch {
+
+        case ty.IsListType() || ty.IsTupleType() || ty.IsMapType():
+                var wantType cty.Type
+                switch {
+                case ty.IsListType() || ty.IsTupleType():
+                        wantType = cty.Number
+                case ty.IsMapType():
+                        wantType = cty.String
+                default:
+                        // should never happen
+                        panic("don't know what key type we want")
+                }
+
+                key, keyErr := convert.Convert(key, wantType)
+                if keyErr != nil {
+                        return cty.DynamicVal, Diagnostics{
+                                {
+                                        Severity: DiagError,
+                                        Summary:  "Invalid index",
+                                        Detail: fmt.Sprintf(
+                                                "The given key does not identify an element in this collection value: %s.",
+                                                keyErr.Error(),
+                                        ),
+                                        Subject: srcRange,
+                                },
+                        }
+                }
+
+                has := collection.HasIndex(key)
+                if !has.IsKnown() {
+                        if ty.IsTupleType() {
+                                return cty.DynamicVal, nil
+                        } else {
+                                return cty.UnknownVal(ty.ElementType()), nil
+                        }
+                }
+                if has.False() {
+                        return cty.DynamicVal, Diagnostics{
+                                {
+                                        Severity: DiagError,
+                                        Summary:  "Invalid index",
+                                        Detail:   "The given key does not identify an element in this collection value.",
+                                        Subject:  srcRange,
+                                },
+                        }
+                }
+
+                return collection.Index(key), nil
+
+        case ty.IsObjectType():
+                key, keyErr := convert.Convert(key, cty.String)
+                if keyErr != nil {
+                        return cty.DynamicVal, Diagnostics{
+                                {
+                                        Severity: DiagError,
+                                        Summary:  "Invalid index",
+                                        Detail: fmt.Sprintf(
+                                                "The given key does not identify an element in this collection value: %s.",
+                                                keyErr.Error(),
+                                        ),
+                                        Subject: srcRange,
+                                },
+                        }
+                }
+                if !collection.IsKnown() {
+                        return cty.DynamicVal, nil
+                }
+                if !key.IsKnown() {
+                        return cty.DynamicVal, nil
+                }
+
+                attrName := key.AsString()
+
+                if !ty.HasAttribute(attrName) {
+                        return cty.DynamicVal, Diagnostics{
+                                {
+                                        Severity: DiagError,
+                                        Summary:  "Invalid index",
+                                        Detail:   "The given key does not identify an element in this collection value.",
+                                        Subject:  srcRange,
+                                },
+                        }
+                }
+
+                return collection.GetAttr(attrName), nil
+
+        default:
+                return cty.DynamicVal, Diagnostics{
+                        {
+                                Severity: DiagError,
+                                Summary:  "Invalid index",
+                                Detail:   "This value does not have any indices.",
+                                Subject:  srcRange,
+                        },
+                }
+        }
+
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/pos.go b/vendor/github.com/hashicorp/hcl2/hcl/pos.go
new file mode 100644
index 0000000..1a4b329
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/pos.go
@@ -0,0 +1,262 @@
+package hcl
+
+import "fmt"
+
+// Pos represents a single position in a source file, by addressing the
+// start byte of a unicode character encoded in UTF-8.
+//
+// Pos is generally used only in the context of a Range, which then defines
+// which source file the position is within.
+type Pos struct {
+        // Line is the source code line where this position points. Lines are
+        // counted starting at 1 and incremented for each newline character
+        // encountered.
+        Line int
+
+        // Column is the source code column where this position points, in
+        // unicode characters, with counting starting at 1.
+        //
+        // Column counts characters as they appear visually, so for example a
+        // latin letter with a combining diacritic mark counts as one character.
+        // This is intended for rendering visual markers against source code in
+        // contexts where these diacritics would be rendered in a single character
+        // cell. Technically speaking, Column is counting grapheme clusters as
+        // used in unicode normalization.
+        Column int
+
+        // Byte is the byte offset into the file where the indicated character
+        // begins. This is a zero-based offset to the first byte of the first
+        // UTF-8 codepoint sequence in the character, and thus gives a position
+        // that can be resolved _without_ awareness of Unicode characters.
+        Byte int
+}
+
+// Range represents a span of characters between two positions in a source
+// file.
+//
+// This struct is usually used by value in types that represent AST nodes,
+// but by pointer in types that refer to the positions of other objects,
+// such as in diagnostics.
+type Range struct {
+        // Filename is the name of the file into which this range's positions
+        // point.
+        Filename string
+
+        // Start and End represent the bounds of this range. Start is inclusive
+        // and End is exclusive.
+        Start, End Pos
+}
+
+// RangeBetween returns a new range that spans from the beginning of the
+// start range to the end of the end range.
+//
+// The result is meaningless if the two ranges do not belong to the same
+// source file or if the end range appears before the start range.
+func RangeBetween(start, end Range) Range {
+        return Range{
+                Filename: start.Filename,
+                Start:    start.Start,
+                End:      end.End,
+        }
+}
+
+// RangeOver returns a new range that covers both of the given ranges and
+// possibly additional content between them if the two ranges do not overlap.
+//
+// If either range is empty then it is ignored. The result is empty if both
+// given ranges are empty.
+//
+// The result is meaningless if the two ranges to not belong to the same
+// source file.
+func RangeOver(a, b Range) Range {
+        if a.Empty() {
+                return b
+        }
+        if b.Empty() {
+                return a
+        }
+
+        var start, end Pos
+        if a.Start.Byte < b.Start.Byte {
+                start = a.Start
+        } else {
+                start = b.Start
+        }
+        if a.End.Byte > b.End.Byte {
+                end = a.End
+        } else {
+                end = b.End
+        }
+        return Range{
+                Filename: a.Filename,
+                Start:    start,
+                End:      end,
+        }
+}
+
+// ContainsOffset returns true if and only if the given byte offset is within
+// the receiving Range.
+func (r Range) ContainsOffset(offset int) bool {
+        return offset >= r.Start.Byte && offset < r.End.Byte
+}
+
+// Ptr returns a pointer to a copy of the receiver. This is a convenience when
+// ranges in places where pointers are required, such as in Diagnostic, but
+// the range in question is returned from a method. Go would otherwise not
+// allow one to take the address of a function call.
+func (r Range) Ptr() *Range {
+        return &r
+}
+
+// String returns a compact string representation of the receiver.
+// Callers should generally prefer to present a range more visually,
+// e.g. via markers directly on the relevant portion of source code.
+func (r Range) String() string {
+        if r.Start.Line == r.End.Line {
+                return fmt.Sprintf(
+                        "%s:%d,%d-%d",
+                        r.Filename,
+                        r.Start.Line, r.Start.Column,
+                        r.End.Column,
+                )
+        } else {
+                return fmt.Sprintf(
+                        "%s:%d,%d-%d,%d",
+                        r.Filename,
+                        r.Start.Line, r.Start.Column,
+                        r.End.Line, r.End.Column,
+                )
+        }
+}
+
+func (r Range) Empty() bool {
+        return r.Start.Byte == r.End.Byte
+}
+
+// CanSliceBytes returns true if SliceBytes could return an accurate
+// sub-slice of the given slice.
+//
+// This effectively tests whether the start and end offsets of the range
+// are within the bounds of the slice, and thus whether SliceBytes can be
+// trusted to produce an accurate start and end position within that slice.
+func (r Range) CanSliceBytes(b []byte) bool {
+        switch {
+        case r.Start.Byte < 0 || r.Start.Byte > len(b):
+                return false
+        case r.End.Byte < 0 || r.End.Byte > len(b):
+                return false
+        case r.End.Byte < r.Start.Byte:
+                return false
+        default:
+                return true
+        }
+}
+
+// SliceBytes returns a sub-slice of the given slice that is covered by the
+// receiving range, assuming that the given slice is the source code of the
+// file indicated by r.Filename.
+//
+// If the receiver refers to any byte offsets that are outside of the slice
+// then the result is constrained to the overlapping portion only, to avoid
+// a panic. Use CanSliceBytes to determine if the result is guaranteed to
+// be an accurate span of the requested range.
+func (r Range) SliceBytes(b []byte) []byte {
+        start := r.Start.Byte
+        end := r.End.Byte
+        if start < 0 {
+                start = 0
+        } else if start > len(b) {
+                start = len(b)
+        }
+        if end < 0 {
+                end = 0
+        } else if end > len(b) {
+                end = len(b)
+        }
+        if end < start {
+                end = start
+        }
+        return b[start:end]
+}
+
+// Overlaps returns true if the receiver and the other given range share any
+// characters in common.
+func (r Range) Overlaps(other Range) bool {
+        switch {
+        case r.Filename != other.Filename:
+                // If the ranges are in different files then they can't possibly overlap
+                return false
+        case r.Empty() || other.Empty():
+                // Empty ranges can never overlap
+                return false
+        case r.ContainsOffset(other.Start.Byte) || r.ContainsOffset(other.End.Byte):
+                return true
+        case other.ContainsOffset(r.Start.Byte) || other.ContainsOffset(r.End.Byte):
+                return true
+        default:
+                return false
+        }
+}
+
+// Overlap finds a range that is either identical to or a sub-range of both
+// the receiver and the other given range. It returns an empty range
+// within the receiver if there is no overlap between the two ranges.
+//
+// A non-empty result is either identical to or a subset of the receiver.
+func (r Range) Overlap(other Range) Range {
+        if !r.Overlaps(other) {
+                // Start == End indicates an empty range
+                return Range{
+                        Filename: r.Filename,
+                        Start:    r.Start,
+                        End:      r.Start,
+                }
+        }
+
+        var start, end Pos
+        if r.Start.Byte > other.Start.Byte {
+                start = r.Start
+        } else {
+                start = other.Start
+        }
+        if r.End.Byte < other.End.Byte {
+                end = r.End
+        } else {
+                end = other.End
+        }
+
+        return Range{
+                Filename: r.Filename,
+                Start:    start,
+                End:      end,
+        }
+}
+
+// PartitionAround finds the portion of the given range that overlaps with
+// the reciever and returns three ranges: the portion of the reciever that
+// precedes the overlap, the overlap itself, and then the portion of the
+// reciever that comes after the overlap.
+//
+// If the two ranges do not overlap then all three returned ranges are empty.
+//
+// If the given range aligns with or extends beyond either extent of the
+// reciever then the corresponding outer range will be empty.
+func (r Range) PartitionAround(other Range) (before, overlap, after Range) {
+        overlap = r.Overlap(other)
+        if overlap.Empty() {
+                return overlap, overlap, overlap
+        }
+
+        before = Range{
+                Filename: r.Filename,
+                Start:    r.Start,
+                End:      overlap.Start,
+        }
+        after = Range{
+                Filename: r.Filename,
+                Start:    overlap.End,
+                End:      r.End,
+        }
+
+        return before, overlap, after
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/pos_scanner.go b/vendor/github.com/hashicorp/hcl2/hcl/pos_scanner.go
new file mode 100644
index 0000000..7c8f2df
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/pos_scanner.go
@@ -0,0 +1,148 @@
+package hcl
+
+import (
+        "bufio"
+        "bytes"
+
+        "github.com/apparentlymart/go-textseg/textseg"
+)
+
+// RangeScanner is a helper that will scan over a buffer using a bufio.SplitFunc
+// and visit a source range for each token matched.
+//
+// For example, this can be used with bufio.ScanLines to find the source range
+// for each line in the file, skipping over the actual newline characters, which
+// may be useful when printing source code snippets as part of diagnostic
+// messages.
+//
+// The line and column information in the returned ranges is produced by
+// counting newline characters and grapheme clusters respectively, which
+// mimics the behavior we expect from a parser when producing ranges.
+type RangeScanner struct {
+        filename string
+        b        []byte
+        cb       bufio.SplitFunc
+
+        pos Pos    // position of next byte to process in b
+        cur Range  // latest range
+        tok []byte // slice of b that is covered by cur
+        err error  // error from last scan, if any
+}
+
+// Create a new RangeScanner for the given buffer, producing ranges for the
+// given filename.
+//
+// Since ranges have grapheme-cluster granularity rather than byte granularity,
+// the scanner will produce incorrect results if the given SplitFunc creates
+// tokens between grapheme cluster boundaries. In particular, it is incorrect
+// to use RangeScanner with bufio.ScanRunes because it will produce tokens
+// around individual UTF-8 sequences, which will split any multi-sequence
+// grapheme clusters.
+func NewRangeScanner(b []byte, filename string, cb bufio.SplitFunc) *RangeScanner {
+        return &RangeScanner{
+                filename: filename,
+                b:        b,
+                cb:       cb,
+                pos: Pos{
+                        Byte:   0,
+                        Line:   1,
+                        Column: 1,
+                },
+        }
+}
+
+func (sc *RangeScanner) Scan() bool {
+        if sc.pos.Byte >= len(sc.b) || sc.err != nil {
+                // All done
+                return false
+        }
+
+        // Since we're operating on an in-memory buffer, we always pass the whole
+        // remainder of the buffer to our SplitFunc and set isEOF to let it know
+        // that it has the whole thing.
+        advance, token, err := sc.cb(sc.b[sc.pos.Byte:], true)
+
+        // Since we are setting isEOF to true this should never happen, but
+        // if it does we will just abort and assume the SplitFunc is misbehaving.
+        if advance == 0 && token == nil && err == nil {
+                return false
+        }
+
+        if err != nil {
+                sc.err = err
+                sc.cur = Range{
+                        Filename: sc.filename,
+                        Start:    sc.pos,
+                        End:      sc.pos,
+                }
+                sc.tok = nil
+                return false
+        }
+
+        sc.tok = token
+        start := sc.pos
+        end := sc.pos
+        new := sc.pos
+
+        // adv is similar to token but it also includes any subsequent characters
+        // we're being asked to skip over by the SplitFunc.
+        // adv is a slice covering any additional bytes we are skipping over, based
+        // on what the SplitFunc told us to do with advance.
+        adv := sc.b[sc.pos.Byte : sc.pos.Byte+advance]
+
+        // We now need to scan over our token to count the grapheme clusters
+        // so we can correctly advance Column, and count the newlines so we
+        // can correctly advance Line.
+        advR := bytes.NewReader(adv)
+        gsc := bufio.NewScanner(advR)
+        advanced := 0
+        gsc.Split(textseg.ScanGraphemeClusters)
+        for gsc.Scan() {
+                gr := gsc.Bytes()
+                new.Byte += len(gr)
+                new.Column++
+
+                // We rely here on the fact that \r\n is considered a grapheme cluster
+                // and so we don't need to worry about miscounting additional lines
+                // on files with Windows-style line endings.
+                if len(gr) != 0 && (gr[0] == '\r' || gr[0] == '\n') {
+                        new.Column = 1
+                        new.Line++
+                }
+
+                if advanced < len(token) {
+                        // If we've not yet found the end of our token then we'll
+                        // also push our "end" marker along.
+                        // (if advance > len(token) then we'll stop moving "end" early
+                        // so that the caller only sees the range covered by token.)
+                        end = new
+                }
+                advanced += len(gr)
+        }
+
+        sc.cur = Range{
+                Filename: sc.filename,
+                Start:    start,
+                End:      end,
+        }
+        sc.pos = new
+        return true
+}
+
+// Range returns a range that covers the latest token obtained after a call
+// to Scan returns true.
+func (sc *RangeScanner) Range() Range {
+        return sc.cur
+}
+
+// Bytes returns the slice of the input buffer that is covered by the range
+// that would be returned by Range.
+func (sc *RangeScanner) Bytes() []byte {
+        return sc.tok
+}
+
+// Err can be called after Scan returns false to determine if the latest read
+// resulted in an error, and obtain that error if so.
+func (sc *RangeScanner) Err() error {
+        return sc.err
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/schema.go b/vendor/github.com/hashicorp/hcl2/hcl/schema.go
new file mode 100644
index 0000000..891257a
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/schema.go
@@ -0,0 +1,21 @@
+package hcl
+
+// BlockHeaderSchema represents the shape of a block header, and is
+// used for matching blocks within bodies.
+type BlockHeaderSchema struct {
+        Type       string
+        LabelNames []string
+}
+
+// AttributeSchema represents the requirements for an attribute, and is used
+// for matching attributes within bodies.
+type AttributeSchema struct {
+        Name     string
+        Required bool
+}
+
+// BodySchema represents the desired shallow structure of a body.
+type BodySchema struct {
+        Attributes []AttributeSchema
+        Blocks     []BlockHeaderSchema
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/spec.md b/vendor/github.com/hashicorp/hcl2/hcl/spec.md
new file mode 100644
index 0000000..58257bf
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/spec.md
@@ -0,0 +1,691 @@
+# HCL Syntax-Agnostic Information Model
+
+This is the specification for the general information model (abstract types and
+semantics) 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, each with a mapping to the model defined
+in this specification.
+
+The two primary syntaxes intended for use in conjunction with this model are
+[the HCL native syntax](./hclsyntax/spec.md) and [the JSON syntax](./json/spec.md).
+In principle other syntaxes are possible as long as either their language model
+is sufficiently rich to express the concepts described in this specification
+or the language targets a well-defined subset of the specification.
+
+## Structural Elements
+
+The primary structural element is the _body_, which is a container representing
+a set of zero or more _attributes_ and a set of zero or more _blocks_.
+
+A _configuration file_ is the top-level object, and will usually be produced
+by reading a file from disk and parsing it as a particular syntax. A
+configuration file has its own _body_, representing the top-level attributes
+and blocks.
+
+An _attribute_ is a name and value pair associated with a body. Attribute names
+are unique within a given body. Attribute values are provided as _expressions_,
+which are discussed in detail in a later section.
+
+A _block_ is a nested structure that has a _type name_, zero or more string
+_labels_ (e.g. identifiers), and a nested body.
+
+Together the structural elements create a heirarchical data structure, with
+attributes intended to represent the direct properties of a particular object
+in the calling application, and blocks intended to represent child objects
+of a particular object.
+
+## Body Content
+
+To support the expression of the HCL concepts in languages whose information
+model is a subset of HCL's, such as JSON, a _body_ is an opaque container
+whose content can only be accessed by providing information on the expected
+structure of the content.
+
+The specification for each syntax must describe how its physical constructs
+are mapped on to body content given a schema. For syntaxes that have
+first-class syntax distinguishing attributes and bodies this can be relatively
+straightforward, while more detailed mapping rules may be required in syntaxes
+where the representation of attributes vs. blocks is ambiguous.
+
+### Schema-driven Processing
+
+Schema-driven processing is the primary way to access body content.
+A _body schema_ is a description of what is expected within a particular body,
+which can then be used to extract the _body content_, which then provides
+access to the specific attributes and blocks requested.
+
+A _body schema_ consists of a list of _attribute schemata_ and
+_block header schemata_:
+
+* An _attribute schema_ provides the name of an attribute and whether its
+  presence is required.
+
+* A _block header schema_ provides a block type name and the semantic names
+  assigned to each of the labels of that block type, if any.
+
+Within a schema, it is an error to request the same attribute name twice or
+to request a block type whose name is also an attribute name. While this can
+in principle be supported in some syntaxes, in other syntaxes the attribute
+and block namespaces are combined and so an an attribute cannot coexist with
+a block whose type name is identical to the attribute name.
+
+The result of applying a body schema to a body is _body content_, which
+consists of an _attribute map_ and a _block sequence_:
+
+* The _attribute map_ is a map data structure whose keys are attribute names
+  and whose values are _expressions_ that represent the corresponding attribute
+  values.
+
+* The _block sequence_ is an ordered sequence of blocks, with each specifying
+  a block _type name_, the sequence of _labels_ specified for the block,
+  and the body object (not body _content_) representing the block's own body.
+
+After obtaining _body content_, the calling application may continue processing
+by evaluating attribute expressions and/or recursively applying further
+schema-driven processing to the child block bodies.
+
+**Note:** The _body schema_ is intentionally minimal, to reduce the set of
+mapping rules that must be defined for each syntax. Higher-level utility
+libraries may be provided to assist in the construction of a schema and
+perform additional processing, such as automatically evaluating attribute
+expressions and assigning their result values into a data structure, or
+recursively applying a schema to child blocks. Such utilities are not part of
+this core specification and will vary depending on the capabilities and idiom
+of the implementation language.
+
+### _Dynamic Attributes_ Processing
+
+The _schema-driven_ processing model is useful when the expected structure
+of a body is known a priori by the calling application. Some blocks are
+instead more free-form, such as a user-provided set of arbitrary key/value
+pairs.
+
+The alternative _dynamic attributes_ processing mode allows for this more
+ad-hoc approach. Processing in this mode behaves as if a schema had been
+constructed without any _block header schemata_ and with an attribute
+schema for each distinct key provided within the physical representation
+of the body.
+
+The means by which _distinct keys_ are identified is dependent on the
+physical syntax; this processing mode assumes that the syntax has a way
+to enumerate keys provided by the author and identify expressions that
+correspond with those keys, but does not define the means by which this is
+done.
+
+The result of _dynamic attributes_ processing is an _attribute map_ as
+defined in the previous section. No _block sequence_ is produced in this
+processing mode.
+
+### Partial Processing of Body Content
+
+Under _schema-driven processing_, by default the given schema is assumed
+to be exhaustive, such that any attribute or block not matched by schema
+elements is considered an error. This allows feedback about unsupported
+attributes and blocks (such as typos) to be provided.
+
+An alternative is _partial processing_, where any additional elements within
+the body are not considered an error.
+
+Under partial processing, the result is both body content as described
+above _and_ a new body that represents any body elements that remain after
+the schema has been processed.
+
+Specifically:
+
+* Any attribute whose name is specified in the schema is returned in body
+  content and elided from the new body.
+
+* Any block whose type is specified in the schema is returned in body content
+  and elided from the new body.
+
+* Any attribute or block _not_ meeting the above conditions is placed into
+  the new body, unmodified.
+
+The new body can then be recursively processed using any of the body
+processing models. This facility allows different subsets of body content
+to be processed by different parts of the calling application.
+
+Processing a body in two steps — first partial processing of a source body,
+then exhaustive processing of the returned body — is equivalent to single-step
+processing with a schema that is the union of the schemata used
+across the two steps.
+
+## Expressions
+
+Attribute values are represented by _expressions_. Depending on the concrete
+syntax in use, an expression may just be a literal value or it may describe
+a computation in terms of literal values, variables, and functions.
+
+Each syntax defines its own representation of expressions. For syntaxes based
+in languages that do not have any non-literal expression syntax, it is
+recommended to embed the template language from
+[the native syntax](./hclsyntax/spec.md) e.g. as a post-processing step on
+string literals.
+
+### Expression Evaluation
+
+In order to obtain a concrete value, each expression must be _evaluated_.
+Evaluation is performed in terms of an evaluation context, which
+consists of the following:
+
+* An _evaluation mode_, which is defined below.
+* A _variable scope_, which provides a set of named variables for use in
+  expressions.
+* A _function table_, which provides a set of named functions for use in
+  expressions.
+
+The _evaluation mode_ allows for two different interpretations of an
+expression:
+
+* In _literal-only mode_, variables and functions are not available and it
+  is assumed that the calling application's intent is to treat the attribute
+  value as a literal.
+
+* In _full expression mode_, variables and functions are defined and it is
+  assumed that the calling application wishes to provide a full expression
+  language for definition of the attribute value.
+
+The actual behavior of these two modes depends on the syntax in use. For
+languages with first-class expression syntax, these two modes may be considered
+equivalent, with _literal-only mode_ simply not defining any variables or
+functions. For languages that embed arbitrary expressions via string templates,
+_literal-only mode_ may disable such processing, allowing literal strings to
+pass through without interpretation as templates.
+
+Since literal-only mode does not support variables and functions, it is an
+error for the calling application to enable this mode and yet provide a
+variable scope and/or function table.
+
+## Values and Value Types
+
+The result of expression evaluation is a _value_. Each value has a _type_,
+which is dynamically determined during evaluation. The _variable scope_ in
+the evaluation context is a map from variable name to value, using the same
+definition of value.
+
+The type system for HCL values is intended to be of a level abstraction
+suitable for configuration of various applications. A well-defined,
+implementation-language-agnostic type system is defined to allow for
+consistent processing of configuration across many implementation languages.
+Concrete implementations may provide additional functionality to lower
+HCL values and types to corresponding native language types, which may then
+impose additional constraints on the values outside of the scope of this
+specification.
+
+Two values are _equal_ if and only if they have identical types and their
+values are equal according to the rules of their shared type.
+
+### Primitive Types
+
+The primitive types are _string_, _bool_, and _number_.
+
+A _string_ is a sequence of unicode characters. Two strings are equal if
+NFC normalization ([UAX#15](http://unicode.org/reports/tr15/)
+of each string produces two identical sequences of characters.
+NFC normalization ensures that, for example, a precomposed combination of a
+latin letter and a diacritic compares equal with the letter followed by
+a combining diacritic.
+
+The _bool_ type has only two non-null values: _true_ and _false_. Two bool
+values are equal if and only if they are either both true or both false.
+
+A _number_ is an arbitrary-precision floating point value. An implementation
+_must_ make the full-precision values available to the calling application
+for interpretation into any suitable number representation. An implementation
+may in practice implement numbers with limited precision so long as the
+following constraints are met:
+
+* Integers are represented with at least 256 bits.
+* Non-integer numbers are represented as floating point values with a
+  mantissa of at least 256 bits and a signed binary exponent of at least
+  16 bits.
+* An error is produced if an integer value given in source cannot be
+  represented precisely.
+* An error is produced if a non-integer value cannot be represented due to
+  overflow.
+* A non-integer number is rounded to the nearest possible value when a
+  value is of too high a precision to be represented.
+
+The _number_ type also requires representation of both positive and negative
+infinity. A "not a number" (NaN) value is _not_ provided nor used.
+
+Two number values are equal if they are numerically equal to the precision
+associated with the number. Positive infinity and negative infinity are
+equal to themselves but not to each other. Positive infinity is greater than
+any other number value, and negative infinity is less than any other number
+value.
+
+Some syntaxes may be unable to represent numeric literals of arbitrary
+precision. This must be defined in the syntax specification as part of its
+description of mapping numeric literals to HCL values.
+
+### Structural Types
+
+_Structural types_ are types that are constructed by combining other types.
+Each distinct combination of other types is itself a distinct type. There
+are two structural type _kinds_:
+
+* _Object types_ are constructed of a set of named attributes, each of which
+  has a type. Attribute names are always strings. (_Object_ attributes are a
+  distinct idea from _body_ attributes, though calling applications
+  may choose to blur the distinction by use of common naming schemes.)
+* _Tuple tupes_ are constructed of a sequence of elements, each of which
+  has a type.
+
+Values of structural types are compared for equality in terms of their
+attributes or elements. A structural type value is equal to another if and
+only if all of the corresponding attributes or elements are equal.
+
+Two structural types are identical if they are of the same kind and
+have attributes or elements with identical types.
+
+### Collection Types
+
+_Collection types_ are types that combine together an arbitrary number of
+values of some other single type. There are three collection type _kinds_:
+
+* _List types_ represent ordered sequences of values of their element type.
+* _Map types_ represent values of their element type accessed via string keys.
+* _Set types_ represent unordered sets of distinct values of their element type.
+
+For each of these kinds and each distinct element type there is a distinct
+collection type. For example, "list of string" is a distinct type from
+"set of string", and "list of number" is a distinct type from "list of string".
+
+Values of collection types are compared for equality in terms of their
+elements. A collection type value is equal to another if and only if both
+have the same number of elements and their corresponding elements are equal.
+
+Two collection types are identical if they are of the same kind and have
+the same element type.
+
+### Null values
+
+Each type has a null value. The null value of a type represents the absense
+of a value, but with type information retained to allow for type checking.
+
+Null values are used primarily to represent the conditional absense of a
+body attribute. In a syntax with a conditional operator, one of the result
+values of that conditional may be null to indicate that the attribute should be
+considered not present in that case.
+
+Calling applications _should_ consider an attribute with a null value as
+equivalent to the value not being present at all.
+
+A null value of a particular type is equal to itself.
+
+### Unknown Values and the Dynamic Pseudo-type
+
+An _unknown value_ is a placeholder for a value that is not yet known.
+Operations on unknown values themselves return unknown values that have a
+type appropriate to the operation. For example, adding together two unknown
+numbers yields an unknown number, while comparing two unknown values of any
+type for equality yields an unknown bool.
+
+Each type has a distinct unknown value. For example, an unknown _number_ is
+a distinct value from an unknown _string_.
+
+_The dynamic pseudo-type_ is a placeholder for a type that is not yet known.
+The only values of this type are its null value and its unknown value. It is
+referred to as a _pseudo-type_ because it should not be considered a type in
+its own right, but rather as a placeholder for a type yet to be established.
+The unknown value of the dynamic pseudo-type is referred to as _the dynamic
+value_.
+
+Operations on values of the dynamic pseudo-type behave as if it is a value
+of the expected type, optimistically assuming that once the value and type
+are known they will be valid for the operation. For example, adding together
+a number and the dynamic value produces an unknown number.
+
+Unknown values and the dynamic pseudo-type can be used as a mechanism for
+partial type checking and semantic checking: by evaluating an expression with
+all variables set to an unknown value, the expression can be evaluated to
+produce an unknown value of a given type, or produce an error if any operation
+is provably invalid with only type information.
+
+Unknown values and the dynamic pseudo-type must never be returned from
+operations unless at least one operand is unknown or dynamic. Calling
+applications are guaranteed that unless the global scope includes unknown
+values, or the function table includes functions that return unknown values,
+no expression will evaluate to an unknown value. The calling application is
+thus in total control over the use and meaning of unknown values.
+
+The dynamic pseudo-type is identical only to itself.
+
+### Capsule Types
+
+A _capsule type_ is a custom type defined by the calling application. A value
+of a capsule type is considered opaque to HCL, but may be accepted
+by functions provided by the calling application.
+
+A particular capsule type is identical only to itself. The equality of two
+values of the same capsule type is defined by the calling application. No
+other operations are supported for values of capsule types.
+
+Support for capsule types in a HCL implementation is optional. Capsule types
+are intended to allow calling applications to pass through values that are
+not part of the standard type system. For example, an application that
+deals with raw binary data may define a capsule type representing a byte
+array, and provide functions that produce or operate on byte arrays.
+
+### Type Specifications
+
+In certain situations it is necessary to define expectations about the expected
+type of a value. Whereas two _types_ have a commutative _identity_ relationship,
+a type has a non-commutative _matches_ relationship with a _type specification_.
+A type specification is, in practice, just a different interpretation of a
+type such that:
+
+* Any type _matches_ any type that it is identical to.
+
+* Any type _matches_ the dynamic pseudo-type.
+
+For example, given a type specification "list of dynamic pseudo-type", the
+concrete types "list of string" and "list of map" match, but the
+type "set of string" does not.
+
+## Functions and Function Calls
+
+The evaluation context used to evaluate an expression includes a function
+table, which represents an application-defined set of named functions
+available for use in expressions.
+
+Each syntax defines whether function calls are supported and how they are
+physically represented in source code, but the semantics of function calls are
+defined here to ensure consistent results across syntaxes and to allow
+applications to provide functions that are interoperable with all syntaxes.
+
+A _function_ is defined from the following elements:
+
+* Zero or more _positional parameters_, each with a name used for documentation,
+  a type specification for expected argument values, and a flag for whether
+  each of null values, unknown values, and values of the dynamic pseudo-type
+  are accepted.
+
+* Zero or one _variadic parameters_, with the same structure as the _positional_
+  parameters, which if present collects any additional arguments provided at
+  the function call site.
+
+* A _result type definition_, which specifies the value type returned for each
+  valid sequence of argument values.
+
+* A _result value definition_, which specifies the value returned for each
+  valid sequence of argument values.
+
+A _function call_, regardless of source syntax, consists of a sequence of
+argument values. The argument values are each mapped to a corresponding
+parameter as follows:
+
+* For each of the function's positional parameters in sequence, take the next
+  argument. If there are no more arguments, the call is erroneous.
+
+* If the function has a variadic parameter, take all remaining arguments that
+  where not yet assigned to a positional parameter and collect them into
+  a sequence of variadic arguments that each correspond to the variadic
+  parameter.
+
+* If the function has _no_ variadic parameter, it is an error if any arguments
+  remain after taking one argument for each positional parameter.
+
+After mapping each argument to a parameter, semantic checking proceeds
+for each argument:
+
+* If the argument value corresponding to a parameter does not match the
+  parameter's type specification, the call is erroneous.
+
+* If the argument value corresponding to a parameter is null and the parameter
+  is not specified as accepting nulls, the call is erroneous.
+
+* If the argument value corresponding to a parameter is the dynamic value
+  and the parameter is not specified as accepting values of the dynamic
+  pseudo-type, the call is valid but its _result type_ is forced to be the
+  dynamic pseudo type.
+
+* If neither of the above conditions holds for any argument, the call is
+  valid and the function's value type definition is used to determine the
+  call's _result type_. A function _may_ vary its result type depending on
+  the argument _values_ as well as the argument _types_; for example, a
+  function that decodes a JSON value will return a different result type
+  depending on the data structure described by the given JSON source code.
+
+If semantic checking succeeds without error, the call is _executed_:
+
+* For each argument, if its value is unknown and its corresponding parameter
+  is not specified as accepting unknowns, the _result value_ is forced to be an
+  unknown value of the result type.
+
+* If the previous condition does not apply, the function's result value
+  definition is used to determine the call's _result value_.
+
+The result of a function call expression is either an error, if one of the
+erroenous conditions above applies, or the _result value_.
+
+## Type Conversions and Unification
+
+Values given in configuration may not always match the expectations of the
+operations applied to them or to the calling application. In such situations,
+automatic type conversion is attempted as a convenience to the user.
+
+Along with conversions to a _specified_ type, it is sometimes necessary to
+ensure that a selection of values are all of the _same_ type, without any
+constraint on which type that is. This is the process of _type unification_,
+which attempts to find the most general type that all of the given types can
+be converted to.
+
+Both type conversions and unification are defined in the syntax-agnostic
+model to ensure consistency of behavior between syntaxes.
+
+Type conversions are broadly characterized into two categories: _safe_ and
+_unsafe_. A conversion is "safe" if any distinct value of the source type
+has a corresponding distinct value in the target type. A conversion is
+"unsafe" if either the target type values are _not_ distinct (information
+may be lost in conversion) or if some values of the source type do not have
+any corresponding value in the target type. An unsafe conversion may result
+in an error.
+
+A given type can always be converted to itself, which is a no-op.
+
+### Conversion of Null Values
+
+All null values are safely convertable to a null value of any other type,
+regardless of other type-specific rules specified in the sections below.
+
+### Conversion to and from the Dynamic Pseudo-type
+
+Conversion _from_ the dynamic pseudo-type _to_ any other type always succeeds,
+producing an unknown value of the target type.
+
+Conversion of any value _to_ the dynamic pseudo-type is a no-op. The result
+is the input value, verbatim. This is the only situation where the conversion
+result value is not of the the given target type.
+
+### Primitive Type Conversions
+
+Bidirectional conversions are available between the string and number types,
+and between the string and boolean types.
+
+The bool value true corresponds to the string containing the characters "true",
+while the bool value false corresponds to teh string containing the characters
+"false". Conversion from bool to string is safe, while the converse is
+unsafe. The strings "1" and "0" are alternative string representations
+of true and false respectively. It is an error to convert a string other than
+the four in this paragraph to type bool.
+
+A number value is converted to string by translating its integer portion
+into a sequence of decimal digits (`0` through `9`), and then if it has a
+non-zero fractional part, a period `.` followed by a sequence of decimal
+digits representing its fractional part. No exponent portion is included.
+The number is converted at its full precision. Conversion from number to
+string is safe.
+
+A string is converted to a number value by reversing the above mapping.
+No exponent portion is allowed. Conversion from string to number is unsafe.
+It is an error to convert a string that does not comply with the expected
+syntax to type number.
+
+No direct conversion is available between the bool and number types.
+
+### Collection and Structural Type Conversions
+
+Conversion from set types to list types is _safe_, as long as their
+element types are safely convertable. If the element types are _unsafely_
+convertable, then the collection conversion is also unsafe. Each set element
+becomes a corresponding list element, in an undefined order. Although no
+particular ordering is required, implementations _should_ produce list
+elements in a consistent order for a given input set, as a convenience
+to calling applications.
+
+Conversion from list types to set types is _unsafe_, as long as their element
+types are convertable. Each distinct list item becomes a distinct set item.
+If two list items are equal, one of the two is lost in the conversion.
+
+Conversion from tuple types to list types permitted if all of the
+tuple element types are convertable to the target list element type.
+The safety of the conversion depends on the safety of each of the element
+conversions. Each element in turn is converted to the list element type,
+producing a list of identical length.
+
+Conversion from tuple types to set types is permitted, behaving as if the
+tuple type was first converted to a list of the same element type and then
+that list converted to the target set type.
+
+Conversion from object types to map types is permitted if all of the object
+attribute types are convertable to the target map element type. The safety
+of the conversion depends on the safety of each of the attribute conversions.
+Each attribute in turn is converted to the map element type, and map element
+keys are set to the name of each corresponding object attribute.
+
+Conversion from list and set types to tuple types is permitted, following
+the opposite steps as the converse conversions. Such conversions are _unsafe_.
+It is an error to convert a list or set to a tuple type whose number of
+elements does not match the list or set length.
+
+Conversion from map types to object types is permitted if each map key
+corresponds to an attribute in the target object type. It is an error to
+convert from a map value whose set of keys does not exactly match the target
+type's attributes. The conversion takes the opposite steps of the converse
+conversion.
+
+Conversion from one object type to another is permitted as long as the
+common attribute names have convertable types. Any attribute present in the
+target type but not in the source type is populated with a null value of
+the appropriate type.
+
+Conversion from one tuple type to another is permitted as long as the
+tuples have the same length and the elements have convertable types.
+
+### Type Unification
+
+Type unification is an operation that takes a list of types and attempts
+to find a single type to which they can all be converted. Since some
+type pairs have bidirectional conversions, preference is given to _safe_
+conversions. In technical terms, all possible types are arranged into
+a lattice, from which a most general supertype is selected where possible.
+
+The type resulting from type unification may be one of the input types, or
+it may be an entirely new type produced by combination of two or more
+input types.
+
+The following rules do not guarantee a valid result. In addition to these
+rules, unification fails if any of the given types are not convertable
+(per the above rules) to the selected result type.
+
+The following unification rules apply transitively. That is, if a rule is
+defined from A to B, and one from B to C, then A can unify to C.
+
+Number and bool types both unify with string by preferring string.
+
+Two collection types of the same kind unify according to the unification
+of their element types.
+
+List and set types unify by preferring the list type.
+
+Map and object types unify by preferring the object type.
+
+List, set and tuple types unify by preferring the tuple type.
+
+The dynamic pseudo-type unifies with any other type by selecting that other
+type. The dynamic pseudo-type is the result type only if _all_ input types
+are the dynamic pseudo-type.
+
+Two object types unify by constructing a new type whose attributes are
+the union of those of the two input types. Any common attributes themselves
+have their types unified.
+
+Two tuple types of the same length unify constructing a new type of the
+same length whose elements are the unification of the corresponding elements
+in the two input types.
+
+## Static Analysis
+
+In most applications, full expression evaluation is sufficient for understanding
+the provided configuration. However, some specialized applications require more
+direct access to the physical structures in the expressions, which can for
+example allow the construction of new language constructs in terms of the
+existing syntax elements.
+
+Since static analysis analyses the physical structure of configuration, the
+details will vary depending on syntax. Each syntax must decide which of its
+physical structures corresponds to the following analyses, producing error
+diagnostics if they are applied to inappropriate expressions.
+
+The following are the required static analysis functions:
+
+* **Static List**: Require list/tuple construction syntax to be used and
+  return a list of expressions for each of the elements given.
+
+* **Static Map**: Require map/object construction syntax to be used and
+  return a list of key/value pairs -- both expressions -- for each of
+  the elements given. The usual constraint that a map key must be a string
+  must not apply to this analysis, thus allowing applications to interpret
+  arbitrary keys as they see fit.
+
+* **Static Call**: Require function call syntax to be used and return an
+  object describing the called function name and a list of expressions
+  representing each of the call arguments.
+
+* **Static Traversal**: Require a reference to a symbol in the variable
+  scope and return a description of the path from the root scope to the
+  accessed attribute or index.
+
+The intent of a calling application using these features is to require a more
+rigid interpretation of the configuration than in expression evaluation.
+Syntax implementations should make use of the extra contextual information
+provided in order to make an intuitive mapping onto the constructs of the
+underlying syntax, possibly interpreting the expression slightly differently
+than it would be interpreted in normal evaluation.
+
+Each syntax must define which of its expression elements each of the analyses
+above applies to, and how those analyses behave given those expression elements.
+
+## Implementation Considerations
+
+Implementations of this specification are free to adopt any strategy that
+produces behavior consistent with the specification. This non-normative
+section describes some possible implementation strategies that are consistent
+with the goals of this specification.
+
+### Language-agnosticism
+
+The language-agnosticism of this specification assumes that certain behaviors
+are implemented separately for each syntax:
+
+* Matching of a body schema with the physical elements of a body in the
+  source language, to determine correspondance between physical constructs
+  and schema elements.
+
+* Implementing the _dynamic attributes_ body processing mode by either
+  interpreting all physical constructs as attributes or producing an error
+  if non-attribute constructs are present.
+
+* Providing an evaluation function for all possible expressions that produces
+  a value given an evaluation context.
+
+* Providing the static analysis functionality described above in a manner that
+  makes sense within the convention of the syntax.
+
+The suggested implementation strategy is to use an implementation language's
+closest concept to an _abstract type_, _virtual type_ or _interface type_
+to represent both Body and Expression. Each language-specific implementation
+can then provide an implementation of each of these types wrapping AST nodes
+or other physical constructs from the language parser.
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/static_expr.go b/vendor/github.com/hashicorp/hcl2/hcl/static_expr.go
new file mode 100644
index 0000000..98ada87
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/static_expr.go
@@ -0,0 +1,40 @@
+package hcl
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+type staticExpr struct {
+        val cty.Value
+        rng Range
+}
+
+// StaticExpr returns an Expression that always evaluates to the given value.
+//
+// This is useful to substitute default values for expressions that are
+// not explicitly given in configuration and thus would otherwise have no
+// Expression to return.
+//
+// Since expressions are expected to have a source range, the caller must
+// provide one. Ideally this should be a real source range, but it can
+// be a synthetic one (with an empty-string filename) if no suitable range
+// is available.
+func StaticExpr(val cty.Value, rng Range) Expression {
+        return staticExpr{val, rng}
+}
+
+func (e staticExpr) Value(ctx *EvalContext) (cty.Value, Diagnostics) {
+        return e.val, nil
+}
+
+func (e staticExpr) Variables() []Traversal {
+        return nil
+}
+
+func (e staticExpr) Range() Range {
+        return e.rng
+}
+
+func (e staticExpr) StartRange() Range {
+        return e.rng
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/structure.go b/vendor/github.com/hashicorp/hcl2/hcl/structure.go
new file mode 100644
index 0000000..b336f30
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/structure.go
@@ -0,0 +1,151 @@
+package hcl
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// File is the top-level node that results from parsing a HCL file.
+type File struct {
+        Body  Body
+        Bytes []byte
+
+        // Nav is used to integrate with the "hcled" editor integration package,
+        // and with diagnostic information formatters. It is not for direct use
+        // by a calling application.
+        Nav interface{}
+}
+
+// Block represents a nested block within a Body.
+type Block struct {
+        Type   string
+        Labels []string
+        Body   Body
+
+        DefRange    Range   // Range that can be considered the "definition" for seeking in an editor
+        TypeRange   Range   // Range for the block type declaration specifically.
+        LabelRanges []Range // Ranges for the label values specifically.
+}
+
+// Blocks is a sequence of Block.
+type Blocks []*Block
+
+// Attributes is a set of attributes keyed by their names.
+type Attributes map[string]*Attribute
+
+// Body is a container for attributes and blocks. It serves as the primary
+// unit of heirarchical structure within configuration.
+//
+// The content of a body cannot be meaningfully intepreted without a schema,
+// so Body represents the raw body content and has methods that allow the
+// content to be extracted in terms of a given schema.
+type Body interface {
+        // Content verifies that the entire body content conforms to the given
+        // schema and then returns it, and/or returns diagnostics. The returned
+        // body content is valid if non-nil, regardless of whether Diagnostics
+        // are provided, but diagnostics should still be eventually shown to
+        // the user.
+        Content(schema *BodySchema) (*BodyContent, Diagnostics)
+
+        // PartialContent is like Content except that it permits the configuration
+        // to contain additional blocks or attributes not specified in the
+        // schema. If any are present, the returned Body is non-nil and contains
+        // the remaining items from the body that were not selected by the schema.
+        PartialContent(schema *BodySchema) (*BodyContent, Body, Diagnostics)
+
+        // JustAttributes attempts to interpret all of the contents of the body
+        // as attributes, allowing for the contents to be accessed without a priori
+        // knowledge of the structure.
+        //
+        // The behavior of this method depends on the body's source language.
+        // Some languages, like JSON, can't distinguish between attributes and
+        // blocks without schema hints, but for languages that _can_ error
+        // diagnostics will be generated if any blocks are present in the body.
+        //
+        // Diagnostics may be produced for other reasons too, such as duplicate
+        // declarations of the same attribute.
+        JustAttributes() (Attributes, Diagnostics)
+
+        // MissingItemRange returns a range that represents where a missing item
+        // might hypothetically be inserted. This is used when producing
+        // diagnostics about missing required attributes or blocks. Not all bodies
+        // will have an obvious single insertion point, so the result here may
+        // be rather arbitrary.
+        MissingItemRange() Range
+}
+
+// BodyContent is the result of applying a BodySchema to a Body.
+type BodyContent struct {
+        Attributes Attributes
+        Blocks     Blocks
+
+        MissingItemRange Range
+}
+
+// Attribute represents an attribute from within a body.
+type Attribute struct {
+        Name string
+        Expr Expression
+
+        Range     Range
+        NameRange Range
+}
+
+// Expression is a literal value or an expression provided in the
+// configuration, which can be evaluated within a scope to produce a value.
+type Expression interface {
+        // Value returns the value resulting from evaluating the expression
+        // in the given evaluation context.
+        //
+        // The context may be nil, in which case the expression may contain
+        // only constants and diagnostics will be produced for any non-constant
+        // sub-expressions. (The exact definition of this depends on the source
+        // language.)
+        //
+        // The context may instead be set but have either its Variables or
+        // Functions maps set to nil, in which case only use of these features
+        // will return diagnostics.
+        //
+        // Different diagnostics are provided depending on whether the given
+        // context maps are nil or empty. In the former case, the message
+        // tells the user that variables/functions are not permitted at all,
+        // while in the latter case usage will produce a "not found" error for
+        // the specific symbol in question.
+        Value(ctx *EvalContext) (cty.Value, Diagnostics)
+
+        // Variables returns a list of variables referenced in the receiving
+        // expression. These are expressed as absolute Traversals, so may include
+        // additional information about how the variable is used, such as
+        // attribute lookups, which the calling application can potentially use
+        // to only selectively populate the scope.
+        Variables() []Traversal
+
+        Range() Range
+        StartRange() Range
+}
+
+// OfType filters the receiving block sequence by block type name,
+// returning a new block sequence including only the blocks of the
+// requested type.
+func (els Blocks) OfType(typeName string) Blocks {
+        ret := make(Blocks, 0)
+        for _, el := range els {
+                if el.Type == typeName {
+                        ret = append(ret, el)
+                }
+        }
+        return ret
+}
+
+// ByType transforms the receiving block sequence into a map from type
+// name to block sequences of only that type.
+func (els Blocks) ByType() map[string]Blocks {
+        ret := make(map[string]Blocks)
+        for _, el := range els {
+                ty := el.Type
+                if ret[ty] == nil {
+                        ret[ty] = make(Blocks, 0, 1)
+                }
+                ret[ty] = append(ret[ty], el)
+        }
+        return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/traversal.go b/vendor/github.com/hashicorp/hcl2/hcl/traversal.go
new file mode 100644
index 0000000..24f4c91
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/traversal.go
@@ -0,0 +1,352 @@
+package hcl
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+// A Traversal is a description of traversing through a value through a
+// series of operations such as attribute lookup, index lookup, etc.
+//
+// It is used to look up values in scopes, for example.
+//
+// The traversal operations are implementations of interface Traverser.
+// This is a closed set of implementations, so the interface cannot be
+// implemented from outside this package.
+//
+// A traversal can be absolute (its first value is a symbol name) or relative
+// (starts from an existing value).
+type Traversal []Traverser
+
+// TraversalJoin appends a relative traversal to an absolute traversal to
+// produce a new absolute traversal.
+func TraversalJoin(abs Traversal, rel Traversal) Traversal {
+        if abs.IsRelative() {
+                panic("first argument to TraversalJoin must be absolute")
+        }
+        if !rel.IsRelative() {
+                panic("second argument to TraversalJoin must be relative")
+        }
+
+        ret := make(Traversal, len(abs)+len(rel))
+        copy(ret, abs)
+        copy(ret[len(abs):], rel)
+        return ret
+}
+
+// TraverseRel applies the receiving traversal to the given value, returning
+// the resulting value. This is supported only for relative traversals,
+// and will panic if applied to an absolute traversal.
+func (t Traversal) TraverseRel(val cty.Value) (cty.Value, Diagnostics) {
+        if !t.IsRelative() {
+                panic("can't use TraverseRel on an absolute traversal")
+        }
+
+        current := val
+        var diags Diagnostics
+        for _, tr := range t {
+                var newDiags Diagnostics
+                current, newDiags = tr.TraversalStep(current)
+                diags = append(diags, newDiags...)
+                if newDiags.HasErrors() {
+                        return cty.DynamicVal, diags
+                }
+        }
+        return current, diags
+}
+
+// TraverseAbs applies the receiving traversal to the given eval context,
+// returning the resulting value. This is supported only for absolute
+// traversals, and will panic if applied to a relative traversal.
+func (t Traversal) TraverseAbs(ctx *EvalContext) (cty.Value, Diagnostics) {
+        if t.IsRelative() {
+                panic("can't use TraverseAbs on a relative traversal")
+        }
+
+        split := t.SimpleSplit()
+        root := split.Abs[0].(TraverseRoot)
+        name := root.Name
+
+        thisCtx := ctx
+        hasNonNil := false
+        for thisCtx != nil {
+                if thisCtx.Variables == nil {
+                        thisCtx = thisCtx.parent
+                        continue
+                }
+                hasNonNil = true
+                val, exists := thisCtx.Variables[name]
+                if exists {
+                        return split.Rel.TraverseRel(val)
+                }
+                thisCtx = thisCtx.parent
+        }
+
+        if !hasNonNil {
+                return cty.DynamicVal, Diagnostics{
+                        {
+                                Severity: DiagError,
+                                Summary:  "Variables not allowed",
+                                Detail:   "Variables may not be used here.",
+                                Subject:  &root.SrcRange,
+                        },
+                }
+        }
+
+        suggestions := make([]string, 0, len(ctx.Variables))
+        thisCtx = ctx
+        for thisCtx != nil {
+                for k := range thisCtx.Variables {
+                        suggestions = append(suggestions, k)
+                }
+                thisCtx = thisCtx.parent
+        }
+        suggestion := nameSuggestion(name, suggestions)
+        if suggestion != "" {
+                suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+        }
+
+        return cty.DynamicVal, Diagnostics{
+                {
+                        Severity: DiagError,
+                        Summary:  "Unknown variable",
+                        Detail:   fmt.Sprintf("There is no variable named %q.%s", name, suggestion),
+                        Subject:  &root.SrcRange,
+                },
+        }
+}
+
+// IsRelative returns true if the receiver is a relative traversal, or false
+// otherwise.
+func (t Traversal) IsRelative() bool {
+        if len(t) == 0 {
+                return true
+        }
+        if _, firstIsRoot := t[0].(TraverseRoot); firstIsRoot {
+                return false
+        }
+        return true
+}
+
+// SimpleSplit returns a TraversalSplit where the name lookup is the absolute
+// part and the remainder is the relative part. Supported only for
+// absolute traversals, and will panic if applied to a relative traversal.
+//
+// This can be used by applications that have a relatively-simple variable
+// namespace where only the top-level is directly populated in the scope, with
+// everything else handled by relative lookups from those initial values.
+func (t Traversal) SimpleSplit() TraversalSplit {
+        if t.IsRelative() {
+                panic("can't use SimpleSplit on a relative traversal")
+        }
+        return TraversalSplit{
+                Abs: t[0:1],
+                Rel: t[1:],
+        }
+}
+
+// RootName returns the root name for a absolute traversal. Will panic if
+// called on a relative traversal.
+func (t Traversal) RootName() string {
+        if t.IsRelative() {
+                panic("can't use RootName on a relative traversal")
+
+        }
+        return t[0].(TraverseRoot).Name
+}
+
+// SourceRange returns the source range for the traversal.
+func (t Traversal) SourceRange() Range {
+        if len(t) == 0 {
+                // Nothing useful to return here, but we'll return something
+                // that's correctly-typed at least.
+                return Range{}
+        }
+
+        return RangeBetween(t[0].SourceRange(), t[len(t)-1].SourceRange())
+}
+
+// TraversalSplit represents a pair of traversals, the first of which is
+// an absolute traversal and the second of which is relative to the first.
+//
+// This is used by calling applications that only populate prefixes of the
+// traversals in the scope, with Abs representing the part coming from the
+// scope and Rel representing the remaining steps once that part is
+// retrieved.
+type TraversalSplit struct {
+        Abs Traversal
+        Rel Traversal
+}
+
+// TraverseAbs traverses from a scope to the value resulting from the
+// absolute traversal.
+func (t TraversalSplit) TraverseAbs(ctx *EvalContext) (cty.Value, Diagnostics) {
+        return t.Abs.TraverseAbs(ctx)
+}
+
+// TraverseRel traverses from a given value, assumed to be the result of
+// TraverseAbs on some scope, to a final result for the entire split traversal.
+func (t TraversalSplit) TraverseRel(val cty.Value) (cty.Value, Diagnostics) {
+        return t.Rel.TraverseRel(val)
+}
+
+// Traverse is a convenience function to apply TraverseAbs followed by
+// TraverseRel.
+func (t TraversalSplit) Traverse(ctx *EvalContext) (cty.Value, Diagnostics) {
+        v1, diags := t.TraverseAbs(ctx)
+        if diags.HasErrors() {
+                return cty.DynamicVal, diags
+        }
+        v2, newDiags := t.TraverseRel(v1)
+        diags = append(diags, newDiags...)
+        return v2, diags
+}
+
+// Join concatenates together the Abs and Rel parts to produce a single
+// absolute traversal.
+func (t TraversalSplit) Join() Traversal {
+        return TraversalJoin(t.Abs, t.Rel)
+}
+
+// RootName returns the root name for the absolute part of the split.
+func (t TraversalSplit) RootName() string {
+        return t.Abs.RootName()
+}
+
+// A Traverser is a step within a Traversal.
+type Traverser interface {
+        TraversalStep(cty.Value) (cty.Value, Diagnostics)
+        SourceRange() Range
+        isTraverserSigil() isTraverser
+}
+
+// Embed this in a struct to declare it as a Traverser
+type isTraverser struct {
+}
+
+func (tr isTraverser) isTraverserSigil() isTraverser {
+        return isTraverser{}
+}
+
+// TraverseRoot looks up a root name in a scope. It is used as the first step
+// of an absolute Traversal, and cannot itself be traversed directly.
+type TraverseRoot struct {
+        isTraverser
+        Name     string
+        SrcRange Range
+}
+
+// TraversalStep on a TraverseName immediately panics, because absolute
+// traversals cannot be directly traversed.
+func (tn TraverseRoot) TraversalStep(cty.Value) (cty.Value, Diagnostics) {
+        panic("Cannot traverse an absolute traversal")
+}
+
+func (tn TraverseRoot) SourceRange() Range {
+        return tn.SrcRange
+}
+
+// TraverseAttr looks up an attribute in its initial value.
+type TraverseAttr struct {
+        isTraverser
+        Name     string
+        SrcRange Range
+}
+
+func (tn TraverseAttr) TraversalStep(val cty.Value) (cty.Value, Diagnostics) {
+        if val.IsNull() {
+                return cty.DynamicVal, Diagnostics{
+                        {
+                                Severity: DiagError,
+                                Summary:  "Attempt to get attribute from null value",
+                                Detail:   "This value is null, so it does not have any attributes.",
+                                Subject:  &tn.SrcRange,
+                        },
+                }
+        }
+
+        ty := val.Type()
+        switch {
+        case ty.IsObjectType():
+                if !ty.HasAttribute(tn.Name) {
+                        return cty.DynamicVal, Diagnostics{
+                                {
+                                        Severity: DiagError,
+                                        Summary:  "Unsupported attribute",
+                                        Detail:   fmt.Sprintf("This object does not have an attribute named %q.", tn.Name),
+                                        Subject:  &tn.SrcRange,
+                                },
+                        }
+                }
+
+                if !val.IsKnown() {
+                        return cty.UnknownVal(ty.AttributeType(tn.Name)), nil
+                }
+
+                return val.GetAttr(tn.Name), nil
+        case ty.IsMapType():
+                if !val.IsKnown() {
+                        return cty.UnknownVal(ty.ElementType()), nil
+                }
+
+                idx := cty.StringVal(tn.Name)
+                if val.HasIndex(idx).False() {
+                        return cty.DynamicVal, Diagnostics{
+                                {
+                                        Severity: DiagError,
+                                        Summary:  "Missing map element",
+                                        Detail:   fmt.Sprintf("This map does not have an element with the key %q.", tn.Name),
+                                        Subject:  &tn.SrcRange,
+                                },
+                        }
+                }
+
+                return val.Index(idx), nil
+        case ty == cty.DynamicPseudoType:
+                return cty.DynamicVal, nil
+        default:
+                return cty.DynamicVal, Diagnostics{
+                        {
+                                Severity: DiagError,
+                                Summary:  "Unsupported attribute",
+                                Detail:   "This value does not have any attributes.",
+                                Subject:  &tn.SrcRange,
+                        },
+                }
+        }
+}
+
+func (tn TraverseAttr) SourceRange() Range {
+        return tn.SrcRange
+}
+
+// TraverseIndex applies the index operation to its initial value.
+type TraverseIndex struct {
+        isTraverser
+        Key      cty.Value
+        SrcRange Range
+}
+
+func (tn TraverseIndex) TraversalStep(val cty.Value) (cty.Value, Diagnostics) {
+        return Index(val, tn.Key, &tn.SrcRange)
+}
+
+func (tn TraverseIndex) SourceRange() Range {
+        return tn.SrcRange
+}
+
+// TraverseSplat applies the splat operation to its initial value.
+type TraverseSplat struct {
+        isTraverser
+        Each     Traversal
+        SrcRange Range
+}
+
+func (tn TraverseSplat) TraversalStep(val cty.Value) (cty.Value, Diagnostics) {
+        panic("TraverseSplat not yet implemented")
+}
+
+func (tn TraverseSplat) SourceRange() Range {
+        return tn.SrcRange
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go b/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go
new file mode 100644
index 0000000..5f52946
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go
@@ -0,0 +1,121 @@
+package hcl
+
+// AbsTraversalForExpr attempts to interpret the given expression as
+// an absolute traversal, or returns error diagnostic(s) if that is
+// not possible for the given expression.
+//
+// A particular Expression implementation can support this function by
+// offering a method called AsTraversal that takes no arguments and
+// returns either a valid absolute traversal or nil to indicate that
+// no traversal is possible. Alternatively, an implementation can support
+// UnwrapExpression to delegate handling of this function to a wrapped
+// Expression object.
+//
+// In most cases the calling application is interested in the value
+// that results from an expression, but in rarer cases the application
+// needs to see the the name of the variable and subsequent
+// attributes/indexes itself, for example to allow users to give references
+// to the variables themselves rather than to their values. An implementer
+// of this function should at least support attribute and index steps.
+func AbsTraversalForExpr(expr Expression) (Traversal, Diagnostics) {
+        type asTraversal interface {
+                AsTraversal() Traversal
+        }
+
+        physExpr := UnwrapExpressionUntil(expr, func(expr Expression) bool {
+                _, supported := expr.(asTraversal)
+                return supported
+        })
+
+        if asT, supported := physExpr.(asTraversal); supported {
+                if traversal := asT.AsTraversal(); traversal != nil {
+                        return traversal, nil
+                }
+        }
+        return nil, Diagnostics{
+                &Diagnostic{
+                        Severity: DiagError,
+                        Summary:  "Invalid expression",
+                        Detail:   "A static variable reference is required.",
+                        Subject:  expr.Range().Ptr(),
+                },
+        }
+}
+
+// RelTraversalForExpr is similar to AbsTraversalForExpr but it returns
+// a relative traversal instead. Due to the nature of HCL expressions, the
+// first element of the returned traversal is always a TraverseAttr, and
+// then it will be followed by zero or more other expressions.
+//
+// Any expression accepted by AbsTraversalForExpr is also accepted by
+// RelTraversalForExpr.
+func RelTraversalForExpr(expr Expression) (Traversal, Diagnostics) {
+        traversal, diags := AbsTraversalForExpr(expr)
+        if len(traversal) > 0 {
+                root := traversal[0].(TraverseRoot)
+                traversal[0] = TraverseAttr{
+                        Name:     root.Name,
+                        SrcRange: root.SrcRange,
+                }
+        }
+        return traversal, diags
+}
+
+// ExprAsKeyword attempts to interpret the given expression as a static keyword,
+// returning the keyword string if possible, and the empty string if not.
+//
+// A static keyword, for the sake of this function, is a single identifier.
+// For example, the following attribute has an expression that would produce
+// the keyword "foo":
+//
+//     example = foo
+//
+// This function is a variant of AbsTraversalForExpr, which uses the same
+// interface on the given expression. This helper constrains the result
+// further by requiring only a single root identifier.
+//
+// This function is intended to be used with the following idiom, to recognize
+// situations where one of a fixed set of keywords is required and arbitrary
+// expressions are not allowed:
+//
+//     switch hcl.ExprAsKeyword(expr) {
+//     case "allow":
+//         // (take suitable action for keyword "allow")
+//     case "deny":
+//         // (take suitable action for keyword "deny")
+//     default:
+//         diags = append(diags, &hcl.Diagnostic{
+//             // ... "invalid keyword" diagnostic message ...
+//         })
+//     }
+//
+// The above approach will generate the same message for both the use of an
+// unrecognized keyword and for not using a keyword at all, which is usually
+// reasonable if the message specifies that the given value must be a keyword
+// from that fixed list.
+//
+// Note that in the native syntax the keywords "true", "false", and "null" are
+// recognized as literal values during parsing and so these reserved words
+// cannot not be accepted as keywords by this function.
+//
+// Since interpreting an expression as a keyword bypasses usual expression
+// evaluation, it should be used sparingly for situations where e.g. one of
+// a fixed set of keywords is used in a structural way in a special attribute
+// to affect the further processing of a block.
+func ExprAsKeyword(expr Expression) string {
+        type asTraversal interface {
+                AsTraversal() Traversal
+        }
+
+        physExpr := UnwrapExpressionUntil(expr, func(expr Expression) bool {
+                _, supported := expr.(asTraversal)
+                return supported
+        })
+
+        if asT, supported := physExpr.(asTraversal); supported {
+                if traversal := asT.AsTraversal(); len(traversal) == 1 {
+                        return traversal.RootName()
+                }
+        }
+        return ""
+}